Teams 多代理协作

// TeamCreateTool: 创建并行工作团队
const TeamCreateTool = {
  name: 'TeamCreate',
  description: '创建一个并行工作团队来执行多个子任务',
  inputSchema: {
    type: 'object',
    properties: {
      workers: {
        type: 'array',
        items: {
          type: 'object',
          properties: {
            name: { type: 'string' },
            task: { type: 'string' },
            tools: {
              type: 'array',
              items: { type: 'string' }
            }
          }
        }
      },
      backend: {
        type: 'string',
        enum: ['iterm', 'tmux', 'in-process']
      }
    }
  },
  execute: async (input: TeamCreateInput) => {
    const backend = selectBackend(input.backend);
    const workers = await Promise.all(
      input.workers.map(w =>
        backend.spawnWorker({
          name: w.name,
          task: w.task,
          tools: w.tools
        })
      )
    );
    return { teamId: generateId(), workers };
  }
};

// coordinatorMode.ts: 协调者编排模式
async function coordinatorMode(
  task: string,
  context: CoordinatorContext
): Promise<CoordinatorResult> {
  // 1. 分析任务，拆解为子任务
  const subtasks = await analyzeAndDecompose(task);

  // 2. 创建工作者团队
  const team = await TeamCreateTool.execute({
    workers: subtasks.map(st => ({
      name: st.name,
      task: st.description,
      tools: st.requiredTools
    })),
    backend: context.preferredBackend || 'in-process'
  });

  // 3. 监控进度
  const results = await monitorTeam(team.teamId);

  // 4. 汇总结果
  return {
    summary: aggregateResults(results),
    teamId: team.teamId
  };
}

// 三种执行后端接口
interface SwarmBackend {
  spawnWorker(config: WorkerConfig): Promise<Worker>;
  killWorker(workerId: string): Promise<void>;
  getWorkerStatus(workerId: string): WorkerStatus;
}

// InProcessBackend: 进程内后端
class InProcessBackend implements SwarmBackend {
  private workers = new Map<string, InProcessWorker>();

  async spawnWorker(
    config: WorkerConfig
  ): Promise<Worker> {
    const worker = new InProcessWorker(config);
    this.workers.set(worker.id, worker);

    // 初始化队友
    await teammateInit(worker, {
      tools: config.tools,
      model: teammateModel.select(config.task),
      prompt: config.task
        + '\n'
        + teammatePromptAddendum.get()
    });

    // 异步启动执行
    worker.run().catch(err => {
      worker.status = 'failed';
      worker.error = err;
    });

    return worker;
  }

  async killWorker(workerId: string): Promise<void> {
    const worker = this.workers.get(workerId);
    if (worker) {
      await worker.abort();
      this.workers.delete(workerId);
    }
  }

  getWorkerStatus(workerId: string): WorkerStatus {
    const worker = this.workers.get(workerId);
    return worker?.status || 'unknown';
  }
}

// TmuxBackend: Tmux 会话后端
class TmuxBackend implements SwarmBackend {
  async spawnWorker(
    config: WorkerConfig
  ): Promise<Worker> {
    // 创建 Tmux 窗格
    const paneId = await execCommand(
      'tmux split-window -h -P -F "#{pane_id}"'
    );
    // 在窗格中启动 Claude Code 子进程
    await execCommand(
      'tmux send-keys -t ' + paneId
      + ' "claude --agent-mode --task '
      + escapeShell(config.task) + '" Enter'
    );
    return { id: paneId, status: 'running' };
  }

  async killWorker(workerId: string): Promise<void> {
    await execCommand('tmux kill-pane -t ' + workerId);
  }

  getWorkerStatus(workerId: string): WorkerStatus {
    // 检查 Tmux 窗格是否存在
    return 'running';
  }
}

// permissionSync.ts: 工作者间权限同步
class PermissionSync {
  private sharedPermissions = new Map<string, boolean>();
  private listeners: PermissionListener[] = [];

  // 当一个工作者获得权限时，广播给所有工作者
  grantPermission(
    workerId: string,
    permission: string
  ): void {
    this.sharedPermissions.set(permission, true);
    // 通知所有其他工作者
    for (const listener of this.listeners) {
      listener.onPermissionGranted(permission);
    }
  }

  // 检查权限是否已被任一工作者获得
  hasPermission(permission: string): boolean {
    return this.sharedPermissions.get(permission) || false;
  }

  subscribe(listener: PermissionListener): void {
    this.listeners.push(listener);
  }
}

// teamMemorySync: 团队内存同步服务
class TeamMemorySync {
  private sharedMemory: SharedMemoryEntry[] = [];

  // 工作者共享发现
  shareDiscovery(
    workerId: string,
    discovery: string
  ): void {
    // 秘密扫描：检查是否包含敏感信息
    if (containsSecrets(discovery)) {
      console.warn(
        'Secret detected in worker ' + workerId
        + ' output, redacting...'
      );
      discovery = redactSecrets(discovery);
    }

    this.sharedMemory.push({
      workerId,
      content: discovery,
      timestamp: Date.now()
    });
  }

  // 获取所有共享内存
  getSharedMemories(): SharedMemoryEntry[] {
    return [...this.sharedMemory];
  }

  // 检查是否有工作者已经处理过某个文件
  isFileBeingProcessed(filePath: string): boolean {
    return this.sharedMemory.some(
      m => m.content.includes(filePath)
        && m.content.includes('processing')
    );
  }
}

// teammatePromptAddendum.ts: 队友附加指令
const teammatePromptAddendum = {
  get(): string {
    return [
      '你是团队中的一个工作者。',
      '与其他工作者协作完成任务。',
      '通过共享内存报告重要发现。',
      '避免修改其他工作者正在处理的文件。',
      '完成任务后生成简洁的结果摘要。'
    ].join('\n');
  }
};