@hummer98/cmux-team 3.0.0

package/skills/cmux-team/manager/master.ts

@@ -0,0 +1,51 @@
+/**
+ * Master surface の作成・管理
+ */
+import * as cmux from "./cmux";
+import { generateMasterPrompt } from "./template";
+import { log } from "./logger";
+
+export interface MasterState {
+  surface: string;
+}
+
+export async function spawnMaster(
+  projectRoot: string,
+  daemonSurface?: string
+): Promise<MasterState | null> {
+  try {
+    // プロンプト生成
+    await generateMasterPrompt(projectRoot);
+
+    // ペイン作成（daemon surface を右に split）
+    const surface = await cmux.newSplit("right", daemonSurface ? { surface: daemonSurface } : undefined);
+
+    if (!(await cmux.validateSurface(surface))) {
+      await log("error", `Master surface ${surface} validation failed`);
+      return null;
+    }
+
+    // Claude Code 起動
+    await cmux.send(
+      surface,
+      "claude --dangerously-skip-permissions --append-system-prompt-file .team/prompts/master.md 'ユーザーからのタスクを待ってください。'\n"
+    );
+
+    // Trust 承認
+    await cmux.waitForTrust(surface);
+
+    // タブ名設定
+    const num = surface.replace("surface:", "");
+    await cmux.renameTab(surface, `[${num}] Master`);
+
+    await log("master_spawned", `surface=${surface}`);
+    return { surface };
+  } catch (e: any) {
+    await log("error", `Master spawn failed: ${e.message}`);
+    return null;
+  }
+}
+
+export async function isMasterAlive(surface: string): Promise<boolean> {
+  return cmux.validateSurface(surface);
+}

package/skills/cmux-team/manager/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "manager",
+  "module": "index.ts",
+  "type": "module",
+  "private": true,
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^19.2.14"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "ink": "^6.8.0",
+    "react": "^19.2.4",
+    "zod": "^4.3.6"
+  }
+}

package/skills/cmux-team/manager/proxy.ts

@@ -0,0 +1,219 @@
+/**
+ * ロギングプロキシ — Anthropic API への透過プロキシ + JSONL トレース
+ *
+ * Agent の ANTHROPIC_BASE_URL をこのプロキシに向けることで、
+ * リクエスト/レスポンスを .team/logs/traces/ に記録する。
+ * レスポンスは streaming のまま返し、ログは非同期で書き込む。
+ */
+import { mkdir, appendFile, readFile } from "fs/promises";
+import { join } from "path";
+
+const DEFAULT_UPSTREAM = "https://api.anthropic.com";
+
+interface ProxyHandle {
+  port: number;
+  stop: () => void;
+}
+
+interface TraceEntry {
+  timestamp: string;
+  conductor_id?: string;
+  task_id?: string;
+  role?: string;
+  method: string;
+  path: string;
+  status?: number;
+  request_bytes: number;
+  response_bytes: number;
+  duration_ms: number;
+}
+
+export async function start(
+  projectRoot: string,
+  opts?: { conductorId?: string; taskId?: string; role?: string; getState?: () => any }
+): Promise<ProxyHandle> {
+  const upstream = process.env.ANTHROPIC_API_URL || DEFAULT_UPSTREAM;
+  const tracesDir = join(projectRoot, ".team/logs/traces");
+  await mkdir(tracesDir, { recursive: true });
+
+  const traceFile = join(tracesDir, "api-trace.jsonl");
+
+  // 前回ポートの読み取り（daemon リロード時に同じポートを再利用）
+  let preferredPort = 0;
+  try {
+    const saved = await readFile(join(projectRoot, ".team/proxy-port"), "utf-8");
+    const parsed = parseInt(saved.trim(), 10);
+    if (parsed > 0) preferredPort = parsed;
+  } catch {
+    // ファイルなし（初回起動）→ ランダムポート
+  }
+
+  const fetchHandler = async (req: Request) => {
+      const url = new URL(req.url);
+
+      // デバッグエンドポイント
+      if (req.method === "GET") {
+        const jsonHeaders = { "Content-Type": "application/json" };
+
+        if (url.pathname === "/state") {
+          if (!opts?.getState) return new Response("Not Found", { status: 404 });
+          const state = opts.getState();
+          const serialized = {
+            ...state,
+            conductors: Object.fromEntries(state.conductors),
+            lastUpdate: state.lastUpdate instanceof Date ? state.lastUpdate.toISOString() : state.lastUpdate,
+          };
+          return new Response(JSON.stringify(serialized), { headers: jsonHeaders });
+        }
+
+        if (url.pathname === "/tasks") {
+          if (!opts?.getState) return new Response("Not Found", { status: 404 });
+          const state = opts.getState();
+          return new Response(JSON.stringify(state.taskList), { headers: jsonHeaders });
+        }
+
+        if (url.pathname === "/conductors") {
+          if (!opts?.getState) return new Response("Not Found", { status: 404 });
+          const state = opts.getState();
+          return new Response(JSON.stringify(Object.fromEntries(state.conductors)), { headers: jsonHeaders });
+        }
+      }
+      const targetUrl = `${upstream}${url.pathname}${url.search}`;
+      const startTime = Date.now();
+
+      // リクエストボディを読み取り（転送用 + サイズ計測用）
+      const reqBody = req.body ? await req.arrayBuffer() : null;
+      const requestBytes = reqBody?.byteLength ?? 0;
+
+      // Host ヘッダーを除外して転送（そのまま渡すと Bun が
+      // Host の値を接続先に使い、プロキシ自身に接続してしまう）
+      const fwdHeaders = new Headers(req.headers);
+      fwdHeaders.delete("host");
+      fwdHeaders.delete("accept-encoding");
+
+      const upstreamRes = await fetch(targetUrl, {
+        method: req.method,
+        headers: fwdHeaders,
+        body: reqBody,
+      });
+
+      // Bun の fetch は自動解凍するので Content-Encoding / Content-Length を除去
+      const resHeaders = new Headers(upstreamRes.headers);
+      resHeaders.delete("content-encoding");
+      resHeaders.delete("content-length");
+
+      // レスポンスが streaming かどうかを判定
+      const contentType = upstreamRes.headers.get("content-type") || "";
+      const isStreaming = contentType.includes("text/event-stream");
+
+      if (isStreaming && upstreamRes.body) {
+        // streaming: tee して片方をログに使う
+        const [clientStream, logStream] = upstreamRes.body.tee();
+
+        // 非同期でログ書き込み（レスポンスはブロックしない）
+        drainAndLog(logStream, {
+          tracesDir: traceFile,
+          method: req.method,
+          path: url.pathname,
+          status: upstreamRes.status,
+          requestBytes,
+          startTime,
+          conductorId: opts?.conductorId,
+          taskId: opts?.taskId,
+          role: opts?.role,
+        });
+
+        return new Response(clientStream, {
+          status: upstreamRes.status,
+          statusText: upstreamRes.statusText,
+          headers: resHeaders,
+        });
+      }
+
+      // 非 streaming: ボディ全体を取得してログ
+      const resBody = await upstreamRes.arrayBuffer();
+      const duration = Date.now() - startTime;
+
+      const entry: TraceEntry = {
+        timestamp: new Date().toISOString(),
+        conductor_id: opts?.conductorId,
+        task_id: opts?.taskId,
+        role: opts?.role,
+        method: req.method,
+        path: url.pathname,
+        status: upstreamRes.status,
+        request_bytes: requestBytes,
+        response_bytes: resBody.byteLength,
+        duration_ms: duration,
+      };
+
+      // 非同期でログ書き込み
+      appendFile(traceFile, JSON.stringify(entry) + "\n").catch(() => {});
+
+      return new Response(resBody, {
+        status: upstreamRes.status,
+        statusText: upstreamRes.statusText,
+        headers: resHeaders,
+      });
+  };
+
+  // 前回ポートで起動を試み、失敗時はランダムポートにフォールバック
+  let server: ReturnType<typeof Bun.serve>;
+  try {
+    server = Bun.serve({ port: preferredPort, fetch: fetchHandler });
+  } catch {
+    if (preferredPort !== 0) {
+      server = Bun.serve({ port: 0, fetch: fetchHandler });
+    } else {
+      throw new Error("Failed to start proxy");
+    }
+  }
+
+  return {
+    port: server.port!,
+    stop: () => server.stop(),
+  };
+}
+
+/** streaming レスポンスを drain してバイト数をログに記録 */
+async function drainAndLog(
+  stream: ReadableStream<Uint8Array>,
+  ctx: {
+    tracesDir: string;
+    method: string;
+    path: string;
+    status: number;
+    requestBytes: number;
+    startTime: number;
+    conductorId?: string;
+    taskId?: string;
+    role?: string;
+  }
+): Promise<void> {
+  let responseBytes = 0;
+  try {
+    const reader = stream.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      responseBytes += value.byteLength;
+    }
+  } catch {
+    // stream エラーは無視（クライアント切断等）
+  }
+
+  const entry: TraceEntry = {
+    timestamp: new Date().toISOString(),
+    conductor_id: ctx.conductorId,
+    task_id: ctx.taskId,
+    role: ctx.role,
+    method: ctx.method,
+    path: ctx.path,
+    status: ctx.status,
+    request_bytes: ctx.requestBytes,
+    response_bytes: responseBytes,
+    duration_ms: Date.now() - ctx.startTime,
+  };
+
+  appendFile(ctx.tracesDir, JSON.stringify(entry) + "\n").catch(() => {});
+}

package/skills/cmux-team/manager/queue.ts

@@ -0,0 +1,73 @@
+import { readdir, readFile, mkdir, rename, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join, basename } from "path";
+import { QueueMessage } from "./schema";
+
+function getQueueDir(): string {
+  const root = process.env.PROJECT_ROOT || process.cwd();
+  return join(root, ".team/queue");
+}
+
+function getProcessedDir(): string {
+  return join(getQueueDir(), "processed");
+}
+
+export async function ensureQueueDirs(): Promise<void> {
+  await mkdir(getQueueDir(), { recursive: true });
+  await mkdir(getProcessedDir(), { recursive: true });
+}
+
+export async function readQueue(): Promise<
+  Array<{ path: string; message: QueueMessage }>
+> {
+  const queueDir = getQueueDir();
+  if (!existsSync(queueDir)) return [];
+
+  const files = await readdir(queueDir);
+  const jsonFiles = files
+    .filter((f) => f.endsWith(".json"))
+    .sort();
+
+  const messages: Array<{ path: string; message: QueueMessage }> = [];
+
+  for (const file of jsonFiles) {
+    const filePath = join(queueDir, file);
+    try {
+      const raw = JSON.parse(await readFile(filePath, "utf-8"));
+      const message = QueueMessage.parse(raw);
+      messages.push({ path: filePath, message });
+    } catch (e) {
+      console.error(`[queue] invalid message: ${file}`, e);
+      await rename(filePath, join(getProcessedDir(), file)).catch(() => {});
+    }
+  }
+
+  return messages;
+}
+
+export async function markProcessed(filePath: string): Promise<void> {
+  const file = basename(filePath);
+  await rename(filePath, join(getProcessedDir(), file));
+}
+
+let sequence = 0;
+
+export async function sendMessage(
+  message: QueueMessage
+): Promise<string> {
+  await ensureQueueDirs();
+
+  QueueMessage.parse(message);
+
+  sequence++;
+  const seq = String(sequence).padStart(3, "0");
+  const ts = Math.floor(Date.now() / 1000);
+  const fileName = `${seq}-${ts}-${message.type.toLowerCase()}.json`;
+  const filePath = join(getQueueDir(), fileName);
+  const tmpPath = `${filePath}.tmp`;
+
+  await writeFile(tmpPath, JSON.stringify(message, null, 2) + "\n");
+  await rename(tmpPath, filePath);
+
+  return filePath;
+}

package/skills/cmux-team/manager/schema.ts

@@ -0,0 +1,84 @@
+import { z } from "zod";
+
+// --- キューメッセージ ---
+
+export const TaskCreatedMessage = z.object({
+  type: z.literal("TASK_CREATED"),
+  taskId: z.string(),
+  taskFile: z.string(),
+  timestamp: z.string().datetime(),
+});
+
+export const ConductorDoneMessage = z.object({
+  type: z.literal("CONDUCTOR_DONE"),
+  conductorId: z.string(),
+  sessionId: z.string().optional(),
+  transcriptPath: z.string().optional(),
+  surface: z.string(),
+  success: z.boolean(),
+  reason: z.string().optional(),
+  exitCode: z.number().optional(),
+  timestamp: z.string().datetime(),
+});
+
+export const AgentSpawnedMessage = z.object({
+  type: z.literal("AGENT_SPAWNED"),
+  conductorId: z.string(),
+  surface: z.string(),
+  role: z.string().optional(),
+  taskTitle: z.string().optional(),
+  timestamp: z.string().datetime(),
+});
+
+export const AgentDoneMessage = z.object({
+  type: z.literal("AGENT_DONE"),
+  conductorId: z.string(),
+  surface: z.string(),
+  timestamp: z.string().datetime(),
+});
+
+export const ShutdownMessage = z.object({
+  type: z.literal("SHUTDOWN"),
+  timestamp: z.string().datetime(),
+});
+
+export const QueueMessage = z.discriminatedUnion("type", [
+  TaskCreatedMessage,
+  ConductorDoneMessage,
+  AgentSpawnedMessage,
+  AgentDoneMessage,
+  ShutdownMessage,
+]);
+
+export type QueueMessage = z.infer<typeof QueueMessage>;
+export type TaskCreatedMessage = z.infer<typeof TaskCreatedMessage>;
+export type ConductorDoneMessage = z.infer<typeof ConductorDoneMessage>;
+
+// --- Agent 状態 ---
+
+export interface AgentState {
+  surface: string;
+  role?: string;
+  taskTitle?: string;
+  spawnedAt: string;
+}
+
+// --- Conductor 状態 ---
+
+export const ConductorState = z.object({
+  conductorId: z.string(),
+  taskRunId: z.string().optional(),
+  taskId: z.string().optional(),
+  taskTitle: z.string().optional(),
+  surface: z.string(),
+  worktreePath: z.string().optional(),
+  outputDir: z.string().optional(),
+  startedAt: z.string().datetime(),
+});
+
+export type ConductorState = z.infer<typeof ConductorState> & {
+  agents: AgentState[];
+  doneCandidate: boolean;
+  status: "idle" | "running" | "done";
+  paneId?: string;
+};

package/skills/cmux-team/manager/task.ts

@@ -0,0 +1,160 @@
+/**
+ * タスクファイルのパース・依存解決
+ */
+import { readdir, readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+
+export interface TaskMeta {
+  id: string;
+  title: string;
+  status: string;
+  priority: string;
+  dependsOn: string[];
+  filePath: string;
+  fileName: string;
+  createdAt: string;  // ISO 8601 datetime
+}
+
+export interface TaskState {
+  status: string;     // "draft" | "ready" | "in_progress" | "closed"
+  closedAt?: string;  // ISO 8601
+  journal?: string;   // 完了時のサマリー
+}
+
+export type TaskStateMap = Record<string, TaskState>;
+
+/**
+ * YAML frontmatter からメタデータを抽出
+ */
+export function parseTaskMeta(content: string, fileName: string, filePath: string): TaskMeta | null {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch?.[1]) return null;
+
+  const fm = fmMatch[1];
+
+  const unquote = (s: string) => s.replace(/^["']|["']$/g, "");
+  const id = unquote(fm.match(/^id:\s*(.+)$/m)?.[1]?.trim() ?? "");
+  const title = unquote(fm.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? "");
+  const status = unquote(fm.match(/^status:\s*(.+)$/m)?.[1]?.trim() ?? "ready");
+  const priority = unquote(fm.match(/^priority:\s*(.+)$/m)?.[1]?.trim() ?? "medium");
+  const createdAt = unquote(fm.match(/^created_at:\s*(.+)$/m)?.[1]?.trim() ?? "");
+
+  // depends_on: [033, 034] or depends_on: 033
+  let dependsOn: string[] = [];
+  const depsMatch = fm.match(/^depends_on:\s*(.+)$/m);
+  if (depsMatch?.[1]) {
+    const raw = depsMatch[1].trim();
+    if (raw.startsWith("[")) {
+      // YAML array: [033, 034]
+      dependsOn = raw
+        .replace(/[\[\]]/g, "")
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    } else {
+      // single value: 033
+      dependsOn = [raw.trim()];
+    }
+  }
+
+  return {
+    id: id || fileName.match(/^(\d+)/)?.[1] || "",
+    title,
+    status,
+    priority,
+    dependsOn,
+    filePath,
+    fileName,
+    createdAt,
+  };
+}
+
+/**
+ * task-state.json の読み込み
+ */
+export async function loadTaskState(projectRoot: string): Promise<TaskStateMap> {
+  const filePath = join(projectRoot, ".team/task-state.json");
+  if (!existsSync(filePath)) return {};
+  try {
+    return JSON.parse(await readFile(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * task-state.json の書き込み
+ */
+export async function saveTaskState(projectRoot: string, state: TaskStateMap): Promise<void> {
+  const filePath = join(projectRoot, ".team/task-state.json");
+  await writeFile(filePath, JSON.stringify(state, null, 2) + "\n");
+}
+
+/**
+ * フラットな tasks/ からタスクを読み込み、task-state.json で状態を上書き
+ */
+export async function loadTasks(projectRoot: string): Promise<{
+  tasks: TaskMeta[];
+  taskState: TaskStateMap;
+}> {
+  const tasksDir = join(projectRoot, ".team/tasks");
+  const taskState = await loadTaskState(projectRoot);
+  const tasks: TaskMeta[] = [];
+
+  if (existsSync(tasksDir)) {
+    const files = await readdir(tasksDir);
+    for (const f of files) {
+      if (!f.endsWith(".md")) continue;
+      const filePath = join(tasksDir, f);
+      const content = await readFile(filePath, "utf-8");
+      const meta = parseTaskMeta(content, f, filePath);
+      if (meta) {
+        // task-state.json の状態で上書き（後方互換: なければファイルの frontmatter 値を使用）
+        if (taskState[meta.id]) {
+          meta.status = taskState[meta.id]!.status;
+        }
+        tasks.push(meta);
+      }
+    }
+  }
+
+  return { tasks, taskState };
+}
+
+/**
+ * 実行可能なタスクをフィルタリング
+ * - status: ready であること
+ * - depends_on の全タスクが closed に存在すること
+ */
+export function filterExecutableTasks(
+  tasks: TaskMeta[],
+  closedIds: Set<string>,
+  assignedIds: Set<string>
+): TaskMeta[] {
+  return tasks.filter((task) => {
+    // status チェック
+    if (task.status !== "ready") return false;
+
+    // 既にアサイン済み
+    if (assignedIds.has(task.id)) return false;
+
+    // 依存チェック
+    if (task.dependsOn.length > 0) {
+      const allDepsResolved = task.dependsOn.every((dep) => closedIds.has(dep));
+      if (!allDepsResolved) return false;
+    }
+
+    return true;
+  });
+}
+
+/**
+ * 優先度ソート（high > medium > low）
+ */
+export function sortByPriority(tasks: TaskMeta[]): TaskMeta[] {
+  const order: Record<string, number> = { high: 0, medium: 1, low: 2 };
+  return [...tasks].sort(
+    (a, b) => (order[a.priority] ?? 1) - (order[b.priority] ?? 1)
+  );
+}

package/skills/cmux-team/manager/template.ts

@@ -0,0 +1,92 @@
+/**
+ * テンプレート検索・変数展開
+ */
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir, cp } from "fs/promises";
+import { join, dirname } from "path";
+
+export function findTemplateDir(): string | null {
+  // 1. daemon 自身からの相対パス（manager/ の兄弟 templates/）
+  //    manager/template.ts → ../templates/
+  const fromSelf = join(dirname(import.meta.path), "../templates");
+  if (existsSync(join(fromSelf, "master.md"))) return fromSelf;
+
+  // 2. プロジェクトローカル
+  const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+  const local = join(projectRoot, "skills/cmux-team/templates");
+  if (existsSync(join(local, "master.md"))) return local;
+
+  return null;
+}
+
+export async function generateMasterPrompt(
+  projectRoot: string
+): Promise<void> {
+  const promptsDir = join(projectRoot, ".team/prompts");
+  await mkdir(promptsDir, { recursive: true });
+  const dst = join(promptsDir, "master.md");
+
+  const templateDir = findTemplateDir();
+  if (!templateDir) {
+    throw new Error(
+      "Template directory not found. npm install -g cmux-team を実行してください"
+    );
+  }
+
+  await cp(join(templateDir, "master.md"), dst);
+}
+
+export async function generateConductorRolePrompt(
+  projectRoot: string
+): Promise<string> {
+  const templateDir = findTemplateDir();
+  if (!templateDir || !existsSync(join(templateDir, "conductor-role.md"))) {
+    throw new Error(
+      "Conductor role template not found. npm install -g cmux-team を実行してください"
+    );
+  }
+
+  const promptsDir = join(projectRoot, ".team/prompts");
+  await mkdir(promptsDir, { recursive: true });
+
+  const promptFile = join(promptsDir, "conductor-role.md");
+
+  let content = await readFile(join(templateDir, "conductor-role.md"), "utf-8");
+  content = content.replace(/\{\{PROJECT_ROOT\}\}/g, projectRoot);
+
+  await writeFile(promptFile, content);
+  return promptFile;
+}
+
+export async function generateConductorTaskPrompt(
+  projectRoot: string,
+  conductorId: string,
+  taskId: string,
+  taskContent: string,
+  worktreePath: string,
+  outputDir: string
+): Promise<string> {
+  const templateDir = findTemplateDir();
+  if (!templateDir || !existsSync(join(templateDir, "conductor-task.md"))) {
+    throw new Error(
+      "Conductor task template not found. npm install -g cmux-team を実行してください"
+    );
+  }
+
+  const promptsDir = join(projectRoot, ".team/prompts");
+  await mkdir(promptsDir, { recursive: true });
+
+  const promptFile = join(promptsDir, `${conductorId}.md`);
+
+  let content = await readFile(join(templateDir, "conductor-task.md"), "utf-8");
+
+  content = content
+    .replace(/\{\{TASK_CONTENT\}\}/g, taskContent)
+    .replace(/\{\{WORKTREE_PATH\}\}/g, worktreePath)
+    .replace(/\{\{OUTPUT_DIR\}\}/g, join(projectRoot, outputDir))
+    .replace(/\{\{PROJECT_ROOT\}\}/g, projectRoot)
+    .replace(/\{\{CONDUCTOR_ID\}\}/g, conductorId);
+
+  await writeFile(promptFile, content);
+  return promptFile;
+}