chq 0.1.0

package/dist/index.js

@@ -0,0 +1,931 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/index.ts
+import { Command as Command13 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/project.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+
+// src/types.ts
+import { z } from "zod/v4";
+var TaskStatus = z.enum(["pending", "running", "done", "failed"]);
+var Task = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  repo: z.string(),
+  blockedBy: z.array(z.string()).default([]),
+  status: TaskStatus.default("pending")
+});
+var ChqConfig = z.object({
+  name: z.string(),
+  description: z.string().default(""),
+  createdAt: z.string(),
+  tasks: z.array(Task).default([])
+});
+var GlobalConfig = z.object({
+  chqHome: z.string().optional(),
+  pollInterval: z.number().optional()
+});
+
+// src/project.ts
+var GLOBAL_CONFIG_DIR = join(homedir(), ".config", "chq");
+var GLOBAL_CONFIG_PATH = join(GLOBAL_CONFIG_DIR, "config.json");
+var _globalConfig;
+function loadGlobalConfig() {
+  if (_globalConfig)
+    return _globalConfig;
+  if (!existsSync(GLOBAL_CONFIG_PATH)) {
+    _globalConfig = {};
+    return _globalConfig;
+  }
+  try {
+    const raw = readFileSync(GLOBAL_CONFIG_PATH, "utf-8");
+    _globalConfig = GlobalConfig.parse(JSON.parse(raw));
+    return _globalConfig;
+  } catch {
+    _globalConfig = {};
+    return _globalConfig;
+  }
+}
+function saveGlobalConfig(config) {
+  mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+  writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`);
+  _globalConfig = config;
+}
+function getChqHome() {
+  const config = loadGlobalConfig();
+  if (config.chqHome) {
+    return config.chqHome.replace(/^~/, homedir());
+  }
+  return join(homedir(), "chq");
+}
+function getPollInterval() {
+  const envVal = process.env["CHQ_POLL_INTERVAL"];
+  if (envVal)
+    return parseInt(envVal, 10);
+  const config = loadGlobalConfig();
+  return config.pollInterval ?? 30;
+}
+function resolveProject(cwd) {
+  const chqHome = getChqHome();
+  if (cwd.startsWith(chqHome)) {
+    const relative = cwd.slice(chqHome.length + 1);
+    const projectName = relative.split("/")[0];
+    if (projectName) {
+      return join(chqHome, projectName);
+    }
+  }
+  if (existsSync(join(cwd, "chq.json"))) {
+    return cwd;
+  }
+  throw new Error(`Not inside a chq project. Run "chq init <name>" first.`);
+}
+function loadConfig(projectDir) {
+  const configPath = join(projectDir, "chq.json");
+  if (!existsSync(configPath)) {
+    throw new Error(`chq.json not found in ${projectDir}`);
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  return ChqConfig.parse(JSON.parse(raw));
+}
+function saveConfig(projectDir, config) {
+  const configPath = join(projectDir, "chq.json");
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + `
+`);
+}
+function ensureProjectDir(projectDir) {
+  mkdirSync(projectDir, { recursive: true });
+}
+function resolveRepoPath(repo) {
+  try {
+    const result = execSync(`ghq list --full-path`, { encoding: "utf-8" });
+    const lines = result.trim().split(`
+`);
+    const match = lines.find((line) => line.endsWith(repo) || line.includes(`/${repo}`));
+    if (!match) {
+      throw new Error(`Repository ${repo} not found via ghq. Run: ghq get ${repo}`);
+    }
+    return match.trim();
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("not found via ghq")) {
+      throw e;
+    }
+    throw new Error(`Failed to resolve repo path for ${repo}. Is ghq installed?`);
+  }
+}
+
+// src/commands/init.ts
+function createInitCommand() {
+  return new Command("init").description("Initialize a new chq project").argument("<project-name>", "Name of the project").action((projectName) => {
+    const projectDir = join2(getChqHome(), projectName);
+    if (existsSync2(join2(projectDir, "chq.json"))) {
+      console.error(`Project "${projectName}" already exists at ${projectDir}`);
+      process.exit(1);
+    }
+    ensureProjectDir(projectDir);
+    const config = {
+      name: projectName,
+      description: "",
+      createdAt: new Date().toISOString(),
+      tasks: []
+    };
+    saveConfig(projectDir, config);
+    console.log(`Created project "${projectName}" at ${projectDir}`);
+    console.log(`Next: cd ${projectDir} && chq plan "<goal>"`);
+  });
+}
+
+// src/commands/setup.ts
+import { Command as Command2 } from "commander";
+import { existsSync as existsSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import { execSync as execSync2 } from "node:child_process";
+
+// src/topo-sort.ts
+function topoSort(tasks) {
+  const taskMap = new Map;
+  for (const task of tasks) {
+    taskMap.set(task.id, task);
+  }
+  const visited = new Set;
+  const inStack = new Set;
+  const result = [];
+  function visit(id, path) {
+    if (inStack.has(id)) {
+      const cycle = [...path.slice(path.indexOf(id)), id].join(" -> ");
+      throw new Error(`Circular dependency detected: ${cycle}`);
+    }
+    if (visited.has(id))
+      return;
+    inStack.add(id);
+    path.push(id);
+    const task = taskMap.get(id);
+    if (!task) {
+      throw new Error(`Unknown task ID referenced in blockedBy: ${id}`);
+    }
+    for (const dep of task.blockedBy) {
+      visit(dep, path);
+    }
+    inStack.delete(id);
+    path.pop();
+    visited.add(id);
+    result.push(task);
+  }
+  for (const task of tasks) {
+    visit(task.id, []);
+  }
+  return result;
+}
+
+// src/commands/setup.ts
+function createSetupCommand() {
+  return new Command2("setup").description("Create worktrees and generate CLAUDE.md").action(() => {
+    const projectDir = resolveProject(process.cwd());
+    const config = loadConfig(projectDir);
+    if (config.tasks.length === 0) {
+      console.error("Error: No tasks defined in chq.json. Run chq:plan first.");
+      process.exit(1);
+    }
+    const sorted = topoSort(config.tasks);
+    const taskMap = new Map(config.tasks.map((t) => [t.id, t]));
+    for (const task of sorted) {
+      const repoPath = resolveRepoPath(task.repo);
+      const branchName = `chq/${config.name}/${task.id}`;
+      const worktreePath = join3(projectDir, `sub-${task.id}`);
+      if (existsSync3(worktreePath)) {
+        console.log(`Skipping ${task.id}: worktree already exists`);
+        continue;
+      }
+      let baseBranch = "main";
+      const sameRepoDep = task.blockedBy.find((depId) => {
+        const dep = taskMap.get(depId);
+        return dep && dep.repo === task.repo;
+      });
+      if (sameRepoDep) {
+        baseBranch = `chq/${config.name}/${sameRepoDep}`;
+      }
+      try {
+        const cmd = `git -C ${repoPath} worktree add ${worktreePath} -b ${branchName} ${baseBranch}`;
+        execSync2(cmd, { stdio: "inherit" });
+        console.log(`Created worktree for ${task.id}: ${worktreePath}`);
+      } catch {
+        console.error(`Failed to create worktree for ${task.id}`);
+        process.exit(1);
+      }
+    }
+    const taskRows = config.tasks.map((t) => {
+      const deps = t.blockedBy.length > 0 ? t.blockedBy.join(",") : "-";
+      return `| ${t.id} | ${t.title} | ${t.repo} | ${deps} | ${t.status} |`;
+    });
+    const claudeMd = `# ${config.name}
+
+${config.description}
+
+## タスク一覧
+
+| ID | タイトル | リポジトリ | 依存 | ステータス |
+|----|---------|-----------|------|-----------|
+${taskRows.join(`
+`)}
+`;
+    writeFileSync2(join3(projectDir, "CLAUDE.md"), claudeMd);
+    console.log(`
+Generated CLAUDE.md`);
+    console.log("Setup complete. Run: chq dispatch");
+  });
+}
+
+// src/commands/status.ts
+import { Command as Command3 } from "commander";
+import { execSync as execSync3 } from "node:child_process";
+function getPrStatus(repo, branchName) {
+  try {
+    const result = execSync3(`gh pr list --head ${branchName} -R ${repo} --json state --jq '.[0].state'`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (result === "OPEN")
+      return "Open";
+    if (result === "MERGED")
+      return "Merged";
+    if (result === "CLOSED")
+      return "Closed";
+    return "-";
+  } catch {
+    return "-";
+  }
+}
+function getStatusIcon(task, allTasks) {
+  switch (task.status) {
+    case "done":
+      return "✅ done";
+    case "running":
+      return "\uD83D\uDD04 running";
+    case "failed":
+      return "❌ failed";
+    case "pending": {
+      const allDepsDone = task.blockedBy.every((depId) => {
+        const dep = allTasks.get(depId);
+        return dep?.status === "done";
+      });
+      return allDepsDone ? "⏳ ready" : "\uD83D\uDD12 pending";
+    }
+  }
+}
+function printStatus(projectDir) {
+  const config = loadConfig(projectDir);
+  const taskMap = new Map(config.tasks.map((t) => [t.id, t]));
+  console.log(`Project: ${config.name}`);
+  if (config.description) {
+    console.log(`Description: ${config.description}`);
+  }
+  console.log();
+  const headers = ["ID", "Title", "Repo", "Blocked By", "Status", "PR"];
+  const rows = config.tasks.map((task) => {
+    const branchName = `chq/${config.name}/${task.id}`;
+    const pr = task.status === "pending" ? "-" : getPrStatus(task.repo, branchName);
+    const deps = task.blockedBy.length > 0 ? task.blockedBy.join(",") : "-";
+    return [task.id, task.title, task.repo, deps, getStatusIcon(task, taskMap), pr];
+  });
+  const colWidths = headers.map((h, i) => {
+    const maxRow = Math.max(...rows.map((r) => (r[i] ?? "").length));
+    return Math.max(h.length, maxRow);
+  });
+  const formatRow = (cols) => " " + cols.map((c, i) => c.padEnd(colWidths[i])).join("  ");
+  console.log(formatRow(headers));
+  for (const row of rows) {
+    console.log(formatRow(row));
+  }
+}
+function createStatusCommand() {
+  return new Command3("status").description("Show project task status").action(() => {
+    const projectDir = resolveProject(process.cwd());
+    printStatus(projectDir);
+  });
+}
+
+// src/commands/dispatch.ts
+import { Command as Command4 } from "commander";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+import { execSync as execSync4 } from "node:child_process";
+
+// src/prompts.ts
+import { readFileSync as readFileSync2, existsSync as existsSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+var PROMPTS_DIR = join4(GLOBAL_CONFIG_DIR, "prompts");
+function loadCustomPrompt(name) {
+  const filePath = join4(PROMPTS_DIR, `${name}.md`);
+  if (!existsSync4(filePath))
+    return null;
+  return readFileSync2(filePath, "utf-8");
+}
+function renderTemplate(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+}
+function computeSolveVars(config, task) {
+  const taskMap = new Map(config.tasks.map((t) => [t.id, t]));
+  let baseBranch = "main";
+  const sameRepoDep = task.blockedBy.find((depId) => {
+    const dep = taskMap.get(depId);
+    return dep && dep.repo === task.repo;
+  });
+  if (sameRepoDep) {
+    baseBranch = `chq/${config.name}/${sameRepoDep}`;
+  }
+  const crossRepoDep = task.blockedBy.some((depId) => {
+    const dep = taskMap.get(depId);
+    return dep && dep.repo !== task.repo;
+  });
+  const draftFlag = crossRepoDep ? `
+  --draft \\` : "";
+  const branchName = `chq/${config.name}/${task.id}`;
+  return {
+    projectName: config.name,
+    projectDescription: config.description,
+    taskId: task.id,
+    taskTitle: task.title,
+    taskDescription: task.description,
+    taskRepo: task.repo,
+    blockedBy: task.blockedBy.length > 0 ? task.blockedBy.join(", ") : "なし",
+    baseBranch,
+    draftFlag,
+    branchName
+  };
+}
+var DEFAULT_SOLVE = `# chq:solve
+
+引数として与えられたタスクID「{{taskId}}」の内容を実装し、PRを作成してください。
+
+## タスク情報
+
+- **Project**: {{projectName}}
+- **Description**: {{projectDescription}}
+- **Task ID**: {{taskId}}
+- **Title**: {{taskTitle}}
+- **Repo**: {{taskRepo}}
+- **Blocked By**: {{blockedBy}}
+
+## タスク詳細
+
+{{taskDescription}}
+
+## 手順
+
+### 1. 実装
+
+- 上記タスク詳細に記載された内容をスコープとして実装する
+- このタスクのスコープ外の変更はしない
+- 同一プロジェクト内の他タスクの worktree（\`sub-*\` ディレクトリ）を参照して整合性を確認してもよい
+
+### 2. PR作成
+
+以下のコマンドでPRを作成する:
+
+\`\`\`
+gh pr create \\
+  --base {{baseBranch}} \\
+  --head {{branchName}} \\
+  --title "{{taskTitle}}" \\{{draftFlag}}
+  --body "## 概要
+{{taskDescription}}
+
+## chq
+- Project: {{projectName}}
+- Task: {{taskId}}
+" \\
+  -R {{taskRepo}}
+\`\`\`
+
+### 3. 完了通知
+
+PR作成後、親ディレクトリの \`chq.json\` の該当タスク（id: {{taskId}}）の \`status\` を \`"done"\` に更新する。
+`;
+var DEFAULT_PLAN = `# chq:plan
+
+プロジェクトの目的に基づいてタスクを分解し、chq.json に書き出してください。
+
+## 手順
+
+### 1. 現状把握
+
+- カレントディレクトリの \`chq.json\` を読み込み、プロジェクト名を確認する
+- プロジェクト名: {{projectName}}
+- 大目的: {{goal}}
+
+### 2. タスク分解
+
+以下の原則に従ってタスクを分解する:
+
+- 各タスクは **1つのPR** に対応する粒度にする
+- 各タスクは **1つのリポジトリ** に閉じる
+- タスク間の依存関係を明確にする
+- PRとして実装できない作業（手動設定、確認作業など）は含めない。ユーザーに別途伝えること
+
+### 3. ユーザーへの確認
+
+分解結果を以下の形式で表示し、ユーザーの確認を得る:
+
+\`\`\`
+タスク分解案:
+
+t1: <title> (<repo>)
+    <description>
+    依存: なし
+
+t2: <title> (<repo>)
+    <description>
+    依存: なし
+
+t3: <title> (<repo>)
+    <description>
+    依存: t1, t2
+
+依存グラフ:
+t1 ─┐
+    ├─→ t3
+t2 ─┘
+\`\`\`
+
+### 4. chq.json への書き出し
+
+ユーザーが承認したら、\`chq.json\` の \`tasks\` 配列にタスクを書き出す。
+\`description\` にはプロジェクト全体の目的も書き出す。
+
+各タスクのフィールド:
+- \`id\`: \`t1\`, \`t2\`, ... の連番
+- \`title\`: タスクのタイトル
+- \`description\`: 実装に必要な詳細説明。Claude Code がこれだけを読んで実装できる十分な情報を含めること
+- \`repo\`: \`owner/repo\` 形式
+- \`blockedBy\`: 依存タスクの id 配列
+- \`status\`: \`"pending"\`
+`;
+var DEFAULT_REVIEW = `# chq:review
+
+プロジェクト全体の整合性をレビューしてください。
+
+## 手順
+
+### 1. 全体把握
+
+- \`chq.json\` を読み込み、全タスクの状態を確認する
+- \`CLAUDE.md\` からプロジェクトの目的を把握する
+
+### 2. 各タスクの実装確認
+
+- 各 \`sub-*\` ディレクトリの変更内容を確認する
+- 以下の観点でレビューする:
+  - 各タスクがスコープ通りに実装されているか
+  - タスク間で矛盾する変更がないか
+  - リポジトリをまたいだ整合性が取れているか（API の互換性、設定値の一致など）
+  - 依存関係の順序でマージした場合に問題が起きないか
+
+### 3. レポート
+
+レビュー結果を報告する。問題がある場合は具体的な修正提案を含める。
+`;
+function generateSolvePrompt(config, task) {
+  const vars = computeSolveVars(config, task);
+  const template = loadCustomPrompt("solve") ?? DEFAULT_SOLVE;
+  return renderTemplate(template, vars);
+}
+function generatePlanPrompt(projectName, goal) {
+  const vars = { projectName, goal };
+  const template = loadCustomPrompt("plan") ?? DEFAULT_PLAN;
+  return renderTemplate(template, vars);
+}
+function generateReviewPrompt() {
+  const template = loadCustomPrompt("review") ?? DEFAULT_REVIEW;
+  return renderTemplate(template, {});
+}
+
+// src/commands/dispatch.ts
+function shellEscape(s) {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+function dispatchTasks(projectDir) {
+  const config = loadConfig(projectDir);
+  const taskMap = new Map(config.tasks.map((t) => [t.id, t]));
+  let dispatched = false;
+  const promptsDir = join5(projectDir, ".prompts");
+  mkdirSync2(promptsDir, { recursive: true });
+  for (const task of config.tasks) {
+    if (task.status !== "pending")
+      continue;
+    const allDepsDone = task.blockedBy.every((depId) => {
+      const dep = taskMap.get(depId);
+      return dep?.status === "done";
+    });
+    if (!allDepsDone) {
+      const blockingIds = task.blockedBy.filter((depId) => {
+        const dep = taskMap.get(depId);
+        return dep?.status !== "done";
+      });
+      console.log(`Skipping ${task.id}: blocked by ${blockingIds.join(", ")}`);
+      continue;
+    }
+    task.status = "running";
+    dispatched = true;
+    const worktreePath = join5(projectDir, `sub-${task.id}`);
+    const prompt = generateSolvePrompt(config, task);
+    const promptPath = join5(promptsDir, `${task.id}.md`);
+    writeFileSync3(promptPath, prompt);
+    const launcherPath = join5(promptsDir, `${task.id}.sh`);
+    writeFileSync3(launcherPath, `#!/bin/sh
+exec claude ${shellEscape(prompt)}
+`, { mode: 493 });
+    console.log(`Dispatching ${task.id}: ${task.title} (${task.repo})`);
+    try {
+      execSync4(`wezterm cli split-pane --cwd "${worktreePath}" -- "${launcherPath}"`, { stdio: "inherit" });
+      execSync4(`wezterm cli set-tab-title "${task.id}: ${task.title}"`, {
+        stdio: "inherit"
+      });
+    } catch {
+      console.error(`Failed to dispatch ${task.id}. Is wezterm running?`);
+      task.status = "failed";
+    }
+  }
+  saveConfig(projectDir, config);
+  if (!dispatched) {
+    console.log("No tasks to dispatch.");
+  }
+}
+function createDispatchCommand() {
+  return new Command4("dispatch").description("Dispatch ready tasks to Claude Code").action(() => {
+    const projectDir = resolveProject(process.cwd());
+    dispatchTasks(projectDir);
+  });
+}
+
+// src/commands/watch.ts
+import { Command as Command7 } from "commander";
+import { execSync as execSync7 } from "node:child_process";
+
+// src/commands/dispatch.ts
+import { Command as Command5 } from "commander";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join6 } from "node:path";
+import { execSync as execSync5 } from "node:child_process";
+function shellEscape2(s) {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+function dispatchTasks2(projectDir) {
+  const config = loadConfig(projectDir);
+  const taskMap = new Map(config.tasks.map((t) => [t.id, t]));
+  let dispatched = false;
+  const promptsDir = join6(projectDir, ".prompts");
+  mkdirSync3(promptsDir, { recursive: true });
+  for (const task of config.tasks) {
+    if (task.status !== "pending")
+      continue;
+    const allDepsDone = task.blockedBy.every((depId) => {
+      const dep = taskMap.get(depId);
+      return dep?.status === "done";
+    });
+    if (!allDepsDone) {
+      const blockingIds = task.blockedBy.filter((depId) => {
+        const dep = taskMap.get(depId);
+        return dep?.status !== "done";
+      });
+      console.log(`Skipping ${task.id}: blocked by ${blockingIds.join(", ")}`);
+      continue;
+    }
+    task.status = "running";
+    dispatched = true;
+    const worktreePath = join6(projectDir, `sub-${task.id}`);
+    const prompt = generateSolvePrompt(config, task);
+    const promptPath = join6(promptsDir, `${task.id}.md`);
+    writeFileSync4(promptPath, prompt);
+    const launcherPath = join6(promptsDir, `${task.id}.sh`);
+    writeFileSync4(launcherPath, `#!/bin/sh
+exec claude ${shellEscape2(prompt)}
+`, { mode: 493 });
+    console.log(`Dispatching ${task.id}: ${task.title} (${task.repo})`);
+    try {
+      execSync5(`wezterm cli split-pane --cwd "${worktreePath}" -- "${launcherPath}"`, { stdio: "inherit" });
+      execSync5(`wezterm cli set-tab-title "${task.id}: ${task.title}"`, {
+        stdio: "inherit"
+      });
+    } catch {
+      console.error(`Failed to dispatch ${task.id}. Is wezterm running?`);
+      task.status = "failed";
+    }
+  }
+  saveConfig(projectDir, config);
+  if (!dispatched) {
+    console.log("No tasks to dispatch.");
+  }
+}
+
+// src/commands/status.ts
+import { Command as Command6 } from "commander";
+import { execSync as execSync6 } from "node:child_process";
+function getPrStatus2(repo, branchName) {
+  try {
+    const result = execSync6(`gh pr list --head ${branchName} -R ${repo} --json state --jq '.[0].state'`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (result === "OPEN")
+      return "Open";
+    if (result === "MERGED")
+      return "Merged";
+    if (result === "CLOSED")
+      return "Closed";
+    return "-";
+  } catch {
+    return "-";
+  }
+}
+function getStatusIcon2(task, allTasks) {
+  switch (task.status) {
+    case "done":
+      return "✅ done";
+    case "running":
+      return "\uD83D\uDD04 running";
+    case "failed":
+      return "❌ failed";
+    case "pending": {
+      const allDepsDone = task.blockedBy.every((depId) => {
+        const dep = allTasks.get(depId);
+        return dep?.status === "done";
+      });
+      return allDepsDone ? "⏳ ready" : "\uD83D\uDD12 pending";
+    }
+  }
+}
+function printStatus2(projectDir) {
+  const config = loadConfig(projectDir);
+  const taskMap = new Map(config.tasks.map((t) => [t.id, t]));
+  console.log(`Project: ${config.name}`);
+  if (config.description) {
+    console.log(`Description: ${config.description}`);
+  }
+  console.log();
+  const headers = ["ID", "Title", "Repo", "Blocked By", "Status", "PR"];
+  const rows = config.tasks.map((task) => {
+    const branchName = `chq/${config.name}/${task.id}`;
+    const pr = task.status === "pending" ? "-" : getPrStatus2(task.repo, branchName);
+    const deps = task.blockedBy.length > 0 ? task.blockedBy.join(",") : "-";
+    return [task.id, task.title, task.repo, deps, getStatusIcon2(task, taskMap), pr];
+  });
+  const colWidths = headers.map((h, i) => {
+    const maxRow = Math.max(...rows.map((r) => (r[i] ?? "").length));
+    return Math.max(h.length, maxRow);
+  });
+  const formatRow = (cols) => " " + cols.map((c, i) => c.padEnd(colWidths[i])).join("  ");
+  console.log(formatRow(headers));
+  for (const row of rows) {
+    console.log(formatRow(row));
+  }
+}
+
+// src/commands/watch.ts
+function checkRunningTasks(projectDir) {
+  const config = loadConfig(projectDir);
+  let updated = false;
+  for (const task of config.tasks) {
+    if (task.status !== "running")
+      continue;
+    const branchName = `chq/${config.name}/${task.id}`;
+    try {
+      const result = execSync7(`gh pr list --head ${branchName} -R ${task.repo} --json state --jq '.[0].state'`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      if (result === "OPEN" || result === "MERGED") {
+        task.status = "done";
+        updated = true;
+        console.log(`Task ${task.id} completed (PR: ${result})`);
+      }
+    } catch {}
+  }
+  if (updated) {
+    saveConfig(projectDir, config);
+  }
+}
+function allDone(projectDir) {
+  const config = loadConfig(projectDir);
+  return config.tasks.every((t) => t.status === "done");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createWatchCommand() {
+  return new Command7("watch").description("Watch and auto-dispatch tasks as dependencies complete").action(async () => {
+    const projectDir = resolveProject(process.cwd());
+    const pollInterval = getPollInterval() * 1000;
+    console.log(`Watching project... (poll interval: ${pollInterval / 1000}s)
+`);
+    while (true) {
+      checkRunningTasks(projectDir);
+      if (allDone(projectDir)) {
+        console.log(`
+All tasks completed!`);
+        break;
+      }
+      dispatchTasks2(projectDir);
+      console.log();
+      printStatus2(projectDir);
+      await sleep(pollInterval);
+    }
+  });
+}
+
+// src/commands/clean.ts
+import { Command as Command8 } from "commander";
+import { existsSync as existsSync5, rmSync } from "node:fs";
+import { join as join7 } from "node:path";
+import { execSync as execSync8 } from "node:child_process";
+import { createInterface } from "node:readline";
+function confirm(message) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+function createCleanCommand() {
+  return new Command8("clean").description("Remove worktrees for the current project").option("--force", "Skip confirmation prompt").option("--all", "Delete the entire project directory").action(async (opts) => {
+    const projectDir = resolveProject(process.cwd());
+    const config = loadConfig(projectDir);
+    if (!opts.force) {
+      const confirmed = await confirm(`Clean project "${config.name}"? This will remove all worktrees. (y/N) `);
+      if (!confirmed) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    for (const task of config.tasks) {
+      const worktreePath = join7(projectDir, `sub-${task.id}`);
+      if (!existsSync5(worktreePath))
+        continue;
+      try {
+        const repoPath = resolveRepoPath(task.repo);
+        execSync8(`git -C ${repoPath} worktree remove ${worktreePath}`, {
+          stdio: "inherit"
+        });
+        console.log(`Removed worktree: sub-${task.id}`);
+      } catch {
+        console.error(`Failed to remove worktree: sub-${task.id}`);
+      }
+    }
+    if (opts.all) {
+      rmSync(projectDir, { recursive: true, force: true });
+      console.log(`Deleted project directory: ${projectDir}`);
+    } else {
+      console.log("Worktrees removed. Project directory and chq.json preserved.");
+    }
+  });
+}
+
+// src/commands/list.ts
+import { Command as Command9 } from "commander";
+import { existsSync as existsSync6, readdirSync, statSync } from "node:fs";
+import { join as join8 } from "node:path";
+function createListCommand() {
+  return new Command9("list").description("List all chq projects").action(() => {
+    const chqHome = getChqHome();
+    if (!existsSync6(chqHome)) {
+      console.log("No projects found. Run: chq init <project-name>");
+      return;
+    }
+    const entries = readdirSync(chqHome).filter((entry) => {
+      const entryPath = join8(chqHome, entry);
+      return statSync(entryPath).isDirectory() && existsSync6(join8(entryPath, "chq.json"));
+    });
+    if (entries.length === 0) {
+      console.log("No projects found. Run: chq init <project-name>");
+      return;
+    }
+    console.log(`Projects:
+`);
+    for (const entry of entries) {
+      const projectDir = join8(chqHome, entry);
+      try {
+        const config = loadConfig(projectDir);
+        const total = config.tasks.length;
+        const done = config.tasks.filter((t) => t.status === "done").length;
+        const date = config.createdAt.split("T")[0];
+        console.log(`  ${config.name}  ${done}/${total} done  (${date})`);
+      } catch {
+        console.log(`  ${entry}  (invalid chq.json)`);
+      }
+    }
+  });
+}
+
+// src/commands/plan.ts
+import { Command as Command10 } from "commander";
+import { spawnSync } from "node:child_process";
+function createPlanCommand() {
+  return new Command10("plan").description("Launch Claude Code to plan tasks for the project").argument("<goal>", "Project goal in natural language").action((goal) => {
+    const projectDir = resolveProject(process.cwd());
+    const config = loadConfig(projectDir);
+    const prompt = generatePlanPrompt(config.name, goal);
+    console.log(`Launching Claude Code for planning "${config.name}"...
+`);
+    const result = spawnSync("claude", [prompt], {
+      stdio: "inherit",
+      cwd: projectDir
+    });
+    process.exit(result.status ?? 0);
+  });
+}
+
+// src/commands/review.ts
+import { Command as Command11 } from "commander";
+import { spawnSync as spawnSync2 } from "node:child_process";
+function createReviewCommand() {
+  return new Command11("review").description("Launch Claude Code to review project consistency").action(() => {
+    const projectDir = resolveProject(process.cwd());
+    const prompt = generateReviewPrompt();
+    console.log(`Launching Claude Code for review...
+`);
+    const result = spawnSync2("claude", [prompt], {
+      stdio: "inherit",
+      cwd: projectDir
+    });
+    process.exit(result.status ?? 0);
+  });
+}
+
+// src/commands/config.ts
+import { Command as Command12 } from "commander";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join9 } from "node:path";
+var PROMPTS_DIR2 = join9(GLOBAL_CONFIG_DIR, "prompts");
+function createConfigInit() {
+  return new Command12("init").description("Initialize global config directory with defaults").option("--force", "Overwrite existing files").action((opts) => {
+    mkdirSync4(PROMPTS_DIR2, { recursive: true });
+    const configPath = join9(GLOBAL_CONFIG_DIR, "config.json");
+    if (!existsSync7(configPath) || opts.force) {
+      saveGlobalConfig({ chqHome: "~/chq", pollInterval: 30 });
+      console.log(`Created ${configPath}`);
+    } else {
+      console.log(`Exists  ${configPath} (use --force to overwrite)`);
+    }
+    const prompts = [
+      ["solve.md", DEFAULT_SOLVE],
+      ["plan.md", DEFAULT_PLAN],
+      ["review.md", DEFAULT_REVIEW]
+    ];
+    for (const [name, content] of prompts) {
+      const filePath = join9(PROMPTS_DIR2, name);
+      if (!existsSync7(filePath) || opts.force) {
+        writeFileSync5(filePath, content);
+        console.log(`Created ${filePath}`);
+      } else {
+        console.log(`Exists  ${filePath} (use --force to overwrite)`);
+      }
+    }
+    console.log(`
+Done. Edit files in ~/.config/chq/ to customize.`);
+  });
+}
+function createConfigPath() {
+  return new Command12("path").description("Show config directory path").action(() => {
+    console.log(GLOBAL_CONFIG_DIR);
+  });
+}
+function createConfigShow() {
+  return new Command12("show").description("Show current configuration").action(() => {
+    const config = loadGlobalConfig();
+    console.log(`Config dir:    ${GLOBAL_CONFIG_DIR}`);
+    console.log(`chqHome:       ${getChqHome()}`);
+    console.log(`pollInterval:  ${getPollInterval()}s`);
+    console.log();
+    console.log("Prompts:");
+    for (const name of ["solve.md", "plan.md", "review.md"]) {
+      const filePath = join9(PROMPTS_DIR2, name);
+      const status = existsSync7(filePath) ? "custom" : "default";
+      console.log(`  ${name}  (${status})`);
+    }
+  });
+}
+function createConfigCommand() {
+  const cmd = new Command12("config").description("Manage global configuration");
+  cmd.addCommand(createConfigInit());
+  cmd.addCommand(createConfigPath());
+  cmd.addCommand(createConfigShow());
+  return cmd;
+}
+
+// src/index.ts
+var program = new Command13;
+program.name("chq").description("Orchestrate multi-repo tasks with Claude Code in parallel").version("0.1.0");
+program.addCommand(createInitCommand());
+program.addCommand(createSetupCommand());
+program.addCommand(createStatusCommand());
+program.addCommand(createDispatchCommand());
+program.addCommand(createWatchCommand());
+program.addCommand(createCleanCommand());
+program.addCommand(createListCommand());
+program.addCommand(createPlanCommand());
+program.addCommand(createReviewCommand());
+program.addCommand(createConfigCommand());
+program.parse();