@ronkovic/aad 0.3.5 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronkovic/aad",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Autonomous Agent Development Orchestrator - Multi-agent TDD pipeline powered by Claude",
   "module": "src/main.ts",
   "type": "module",
@@ -38,11 +38,12 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.34",
+    "@inquirer/prompts": "^8.2.0",
+    "chokidar": "^4.0",
+    "commander": "^13.0",
     "hono": "^4.6",
     "pino": "^9.6",
     "pino-pretty": "^13.0",
-    "chokidar": "^4.0",
-    "commander": "^13.0",
     "zod": "^3.24"
   },
   "devDependencies": {

package/src/__tests__/e2e/pipeline-e2e.test.ts

@@ -270,6 +270,12 @@ describe("E2E Pipeline", () => {
       result: { taskId: createTaskId("task-1"), status: "completed", duration: 50 },
     });
 
+    // Emit worker:idle to trigger dispatch (mirrors real task-dispatch-handler behavior)
+    eventBus.emit({
+      type: "worker:idle",
+      workerId: createWorkerId("w-1"),
+    });
+
     await waitFor(() => dispatchedTasks.length >= 2, 3000);
 
     expect(dispatchedTasks[1]).toBe(createTaskId("task-2"));

package/src/main.ts

@@ -11,9 +11,11 @@ import {
   createResumeCommand,
   createStatusCommand,
   createCleanupCommand,
+  createUpdateCommand,
   type App,
   type AppOptions,
 } from "./modules/cli";
+import { registerInteractiveCommand } from "./modules/cli/commands/interactive.js";
 import packageJson from "../package.json" with { type: "json" };
 
 const program = new Command()
@@ -47,6 +49,12 @@ program.addCommand(createRunCommand(getApp));
 program.addCommand(createResumeCommand(getApp));
 program.addCommand(createStatusCommand(getApp));
 program.addCommand(createCleanupCommand(getApp));
+program.addCommand(createUpdateCommand());
+registerInteractiveCommand(program);
 
-// Parse CLI args
-program.parse();
+// Default to interactive mode when no command is given
+if (process.argv.length <= 2) {
+  program.parse(["node", "aad", "interactive"]);
+} else {
+  program.parse();
+}

package/src/modules/cli/__tests__/interactive/auth-step.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { runAuthStep } from "../../commands/interactive/auth-step";
+
+// Mock @inquirer/prompts by testing the env detection logic directly
+describe("Auth Step", () => {
+  let origApiKey: string | undefined;
+  let origOauth: string | undefined;
+
+  beforeEach(() => {
+    origApiKey = process.env.ANTHROPIC_API_KEY;
+    origOauth = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+  });
+
+  afterEach(() => {
+    if (origApiKey !== undefined) process.env.ANTHROPIC_API_KEY = origApiKey;
+    else delete process.env.ANTHROPIC_API_KEY;
+    if (origOauth !== undefined) process.env.CLAUDE_CODE_OAUTH_TOKEN = origOauth;
+    else delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
+  });
+
+  it("module exports runAuthStep function", () => {
+    expect(typeof runAuthStep).toBe("function");
+  });
+});

package/src/modules/cli/__tests__/interactive/interactive.test.ts

@@ -0,0 +1,14 @@
+import { describe, it, expect } from "bun:test";
+import { registerInteractiveCommand } from "../../commands/interactive";
+import { Command } from "commander";
+
+describe("Interactive Command Registration", () => {
+  it("registers interactive command on program", () => {
+    const program = new Command();
+    registerInteractiveCommand(program);
+
+    const cmd = program.commands.find((c) => c.name() === "interactive");
+    expect(cmd).toBeDefined();
+    expect(cmd?.description()).toContain("Interactive");
+  });
+});

package/src/modules/cli/__tests__/interactive/process-supervisor.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from "bun:test";
+import { spawnProject, killAll } from "../../commands/interactive/process-supervisor";
+import type { ProjectConfig } from "../../commands/interactive/project-step";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+
+describe("Process Supervisor", () => {
+  it("exports spawnProject and killAll functions", () => {
+    expect(typeof spawnProject).toBe("function");
+    expect(typeof killAll).toBe("function");
+  });
+
+  it("spawns a simple process and returns ManagedProcess", async () => {
+    const tmpDir = mkdtempSync(resolve(tmpdir(), "aad-test-"));
+    const project: ProjectConfig = {
+      directory: tmpDir,
+      branch: "main",
+      requirementsPath: "/dev/null",
+      workers: 1,
+    };
+
+    const mp = spawnProject(project, 0);
+    expect(mp.dashboardPort).toBe(7333);
+    expect(mp.project).toBe(project);
+    expect(mp.proc).toBeDefined();
+
+    // Kill immediately
+    await killAll([mp]);
+  });
+
+  it("increments dashboard port by index", async () => {
+    const tmpDir = mkdtempSync(resolve(tmpdir(), "aad-test-"));
+    const project: ProjectConfig = {
+      directory: tmpDir,
+      branch: "main",
+      requirementsPath: "/dev/null",
+      workers: 1,
+    };
+
+    const mp = spawnProject(project, 3);
+    expect(mp.dashboardPort).toBe(7336);
+    await killAll([mp]);
+  });
+});

package/src/modules/cli/__tests__/interactive/prompts.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from "bun:test";
+import { printBox, success, warn, error } from "../../commands/interactive/prompts";
+
+describe("Interactive Prompts Utilities", () => {
+  describe("printBox", () => {
+    it("prints a box with lines", () => {
+      const logs: string[] = [];
+      const origLog = console.log;
+      console.log = (...args: unknown[]) => logs.push(args.join(" "));
+      try {
+        printBox(["line 1", "line 2"]);
+        expect(logs.length).toBe(4); // top + 2 lines + bottom
+        expect(logs[0]).toContain("┌");
+        expect(logs[3]).toContain("└");
+      } finally {
+        console.log = origLog;
+      }
+    });
+
+    it("prints a box with title", () => {
+      const logs: string[] = [];
+      const origLog = console.log;
+      console.log = (...args: unknown[]) => logs.push(args.join(" "));
+      try {
+        printBox(["content"], "Title");
+        expect(logs.length).toBe(5); // top + title + separator + content + bottom
+        expect(logs[1]).toContain("Title");
+        expect(logs[2]).toContain("├");
+      } finally {
+        console.log = origLog;
+      }
+    });
+  });
+
+  describe("status helpers", () => {
+    it("success prints green check", () => {
+      const logs: string[] = [];
+      const origLog = console.log;
+      console.log = (...args: unknown[]) => logs.push(args.join(" "));
+      try {
+        success("done");
+        expect(logs[0]).toContain("✓");
+        expect(logs[0]).toContain("done");
+      } finally {
+        console.log = origLog;
+      }
+    });
+
+    it("warn prints yellow warning", () => {
+      const logs: string[] = [];
+      const origLog = console.log;
+      console.log = (...args: unknown[]) => logs.push(args.join(" "));
+      try {
+        warn("caution");
+        expect(logs[0]).toContain("⚠");
+        expect(logs[0]).toContain("caution");
+      } finally {
+        console.log = origLog;
+      }
+    });
+
+    it("error prints red cross", () => {
+      const logs: string[] = [];
+      const origLog = console.log;
+      console.log = (...args: unknown[]) => logs.push(args.join(" "));
+      try {
+        error("fail");
+        expect(logs[0]).toContain("✗");
+        expect(logs[0]).toContain("fail");
+      } finally {
+        console.log = origLog;
+      }
+    });
+  });
+});

package/src/modules/cli/__tests__/update.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from "bun:test";
+import { createUpdateCommand } from "../commands/update";
+
+describe("Update Command", () => {
+  it("creates a command named 'update'", () => {
+    const cmd = createUpdateCommand();
+    expect(cmd.name()).toBe("update");
+  });
+
+  it("has --check option", () => {
+    const cmd = createUpdateCommand();
+    const checkOpt = cmd.options.find((o) => o.long === "--check");
+    expect(checkOpt).toBeDefined();
+  });
+
+  it("has description", () => {
+    const cmd = createUpdateCommand();
+    expect(cmd.description()).toContain("Update");
+  });
+});

package/src/modules/cli/commands/interactive/auth-step.ts

@@ -0,0 +1,61 @@
+/**
+ * Auth check / input step for interactive mode
+ */
+import { askConfirm, askSelect, askPassword, success, warn } from "./prompts.js";
+
+export interface AuthResult {
+  method: "api-key" | "oauth";
+  token: string;
+}
+
+function maskToken(token: string): string {
+  if (token.length <= 8) return "••••••••";
+  return `${token.slice(0, 6)}...${token.slice(-4)}`;
+}
+
+export async function runAuthStep(): Promise<AuthResult> {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  const oauthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+
+  // Existing API key detected
+  if (apiKey) {
+    console.log(`\n  API Key検出: ${maskToken(apiKey)}`);
+    const useExisting = await askConfirm("この設定を使用しますか？", true);
+    if (useExisting) {
+      success("API Key認証を使用");
+      return { method: "api-key", token: apiKey };
+    }
+  }
+
+  // Existing OAuth token detected
+  if (oauthToken) {
+    console.log(`\n  OAuth Token検出: ${maskToken(oauthToken)}`);
+    const useExisting = await askConfirm("この設定を使用しますか？", true);
+    if (useExisting) {
+      success("OAuth認証を使用");
+      return { method: "oauth", token: oauthToken };
+    }
+  }
+
+  // Manual input
+  if (!apiKey && !oauthToken) {
+    warn("認証トークンが未設定です");
+  }
+
+  const method = await askSelect<"api-key" | "oauth">("認証方式を選択:", [
+    { name: "API Key (ANTHROPIC_API_KEY)", value: "api-key" },
+    { name: "OAuth Token (CLAUDE_CODE_OAUTH_TOKEN)", value: "oauth" },
+  ]);
+
+  const token = await askPassword("トークンを入力:");
+
+  // Set in process env for this session
+  if (method === "api-key") {
+    process.env.ANTHROPIC_API_KEY = token;
+  } else {
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = token;
+  }
+
+  success(`${method === "api-key" ? "API Key" : "OAuth"}認証を設定（セッション限定）`);
+  return { method, token };
+}

package/src/modules/cli/commands/interactive/launch-step.ts

@@ -0,0 +1,76 @@
+/**
+ * Launch confirmation + execution step
+ */
+import { basename } from "node:path";
+import { getMemoryStatus } from "@aad/shared/memory-check";
+import type { ProjectConfig } from "./project-step.js";
+import {
+  type ManagedProcess,
+  spawnAll,
+  setupSignalHandler,
+} from "./process-supervisor.js";
+import { askConfirm, printBox, success } from "./prompts.js";
+
+function formatPlanLines(projects: ProjectConfig[]): string[] {
+  const lines: string[] = [];
+  for (let i = 0; i < projects.length; i++) {
+    const p = projects[i]!;
+    lines.push(`#${i + 1} ${p.directory}`);
+    lines.push(`   ブランチ: ${p.branch}`);
+    lines.push(`   要件: ${p.requirementsPath}`);
+    lines.push(`   ワーカー: ${p.workers}`);
+    if (i < projects.length - 1) lines.push("");
+  }
+  return lines;
+}
+
+export async function runLaunchStep(
+  projects: ProjectConfig[],
+): Promise<ManagedProcess[] | null> {
+  const memStatus = await getMemoryStatus();
+  const availableGB = memStatus.freeGB;
+  const totalWorkers = projects.reduce((sum, p) => sum + p.workers, 0);
+
+  const planLines = formatPlanLines(projects);
+  planLines.push("");
+  planLines.push(
+    `合計ワーカー: ${totalWorkers}  メモリ: ${availableGB.toFixed(1)}GB free`,
+  );
+
+  printBox(planLines, "実行プラン");
+  console.log();
+
+  const confirmed = await askConfirm("実行しますか？", true);
+  if (!confirmed) {
+    console.log("\n  実行をキャンセルしました\n");
+    return null;
+  }
+
+  console.log();
+  const managed = spawnAll(projects);
+
+  for (const mp of managed) {
+    const name = basename(mp.project.directory);
+    success(`${name} 起動 — Dashboard: http://localhost:${mp.dashboardPort}`);
+  }
+
+  setupSignalHandler(managed);
+
+  console.log("\n  全プロジェクト起動完了。ダッシュボードで進捗を確認できます。");
+  console.log("  終了: Ctrl+C (全プロジェクト停止)\n");
+
+  // Wait for all processes to complete
+  const exitCodes = await Promise.all(managed.map((mp) => mp.proc.exited));
+  for (let i = 0; i < exitCodes.length; i++) {
+    const mp = managed[i]!;
+    const code = exitCodes[i]!;
+    const name = basename(mp.project.directory);
+    if (code === 0) {
+      success(`${name} 完了 (exit: 0)`);
+    } else {
+      console.log(`  \x1b[31m✗\x1b[0m ${name} 終了 (exit: ${code})`);
+    }
+  }
+
+  return managed;
+}

package/src/modules/cli/commands/interactive/process-supervisor.ts

@@ -0,0 +1,105 @@
+/**
+ * Child process management — spawn, monitor, and terminate AAD runs
+ */
+import { resolve } from "node:path";
+import { mkdirSync, existsSync, openSync } from "node:fs";
+import type { ProjectConfig } from "./project-step.js";
+
+const BASE_DASHBOARD_PORT = 7333;
+
+export interface ManagedProcess {
+  project: ProjectConfig;
+  proc: ReturnType<typeof Bun.spawn>;
+  dashboardPort: number;
+  logDir: string;
+}
+
+function ensureLogDir(directory: string, runId: string): string {
+  const logDir = resolve(directory, ".aad", "logs", runId);
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+  return logDir;
+}
+
+function generateRunId(): string {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+}
+
+export function spawnProject(
+  project: ProjectConfig,
+  index: number,
+): ManagedProcess {
+  const runId = generateRunId();
+  const logDir = ensureLogDir(project.directory, runId);
+  const dashboardPort = BASE_DASHBOARD_PORT + index;
+
+  const stdoutFd = openSync(resolve(logDir, "stdout.log"), "w");
+  const stderrFd = openSync(resolve(logDir, "stderr.log"), "w");
+
+  const proc = Bun.spawn(
+    [
+      "bun",
+      "run",
+      resolve(import.meta.dir, "../../../../main.ts"),
+      "run",
+      project.requirementsPath,
+      "--branch",
+      project.branch,
+      "--workers",
+      String(project.workers),
+    ],
+    {
+      cwd: project.directory,
+      stdout: stdoutFd,
+      stderr: stderrFd,
+      env: {
+        ...process.env,
+        AAD_DASHBOARD_PORT: String(dashboardPort),
+      },
+    },
+  );
+
+  return { project, proc, dashboardPort, logDir };
+}
+
+export function spawnAll(projects: ProjectConfig[]): ManagedProcess[] {
+  return projects.map((project, i) => spawnProject(project, i));
+}
+
+export async function killAll(processes: ManagedProcess[]): Promise<void> {
+  for (const mp of processes) {
+    try {
+      mp.proc.kill("SIGTERM");
+    } catch {
+      // Process may have already exited
+    }
+  }
+
+  // Wait for all to exit (with timeout)
+  const timeout = setTimeout(() => {
+    for (const mp of processes) {
+      try {
+        mp.proc.kill("SIGKILL");
+      } catch {
+        // ignore
+      }
+    }
+  }, 5000);
+
+  await Promise.allSettled(processes.map((mp) => mp.proc.exited));
+  clearTimeout(timeout);
+}
+
+export function setupSignalHandler(processes: ManagedProcess[]): void {
+  const handler = (): void => {
+    console.log("\n\n  全プロセスを停止中...");
+    void killAll(processes).then(() => {
+      console.log("  停止完了\n");
+      process.exit(0);
+    });
+  };
+
+  process.on("SIGINT", handler);
+  process.on("SIGTERM", handler);
+}

package/src/modules/cli/commands/interactive/project-step.ts

@@ -0,0 +1,157 @@
+/**
+ * Project configuration step — repeatable loop
+ */
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { gitExec } from "@aad/git-workspace/git-exec";
+import { getMemoryStatus } from "@aad/shared/memory-check";
+import {
+  askConfirm,
+  askInput,
+  askSelect,
+  success,
+  warn,
+  error,
+} from "./prompts.js";
+
+export interface ProjectConfig {
+  directory: string;
+  branch: string;
+  requirementsPath: string;
+  workers: number;
+}
+
+async function isGitRepo(dir: string): Promise<boolean> {
+  try {
+    await gitExec(["rev-parse", "--is-inside-work-tree"], { cwd: dir });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function listBranches(dir: string): Promise<string[]> {
+  const result = await gitExec(["branch", "--format=%(refname:short)"], {
+    cwd: dir,
+  });
+  return result.stdout
+    .split("\n")
+    .map((b: string) => b.trim())
+    .filter(Boolean);
+}
+
+async function getCurrentBranch(dir: string): Promise<string> {
+  const result = await gitExec(["branch", "--show-current"], { cwd: dir });
+  return result.stdout.trim();
+}
+
+async function pullBranch(dir: string, branch: string): Promise<boolean> {
+  try {
+    await gitExec(["checkout", branch], { cwd: dir });
+    await gitExec(["pull", "--ff-only"], { cwd: dir });
+    success(`${branch} を最新に更新`);
+    return true;
+  } catch (e) {
+    warn(`git pull失敗: ${e instanceof Error ? e.message : String(e)}`);
+    return false;
+  }
+}
+
+function suggestWorkers(availableGB: number): number {
+  if (availableGB >= 12) return 3;
+  if (availableGB >= 8) return 2;
+  return 1;
+}
+
+async function configureProject(index: number): Promise<ProjectConfig> {
+  console.log(`\n── プロジェクト #${index + 1} ──\n`);
+
+  // Directory
+  const directory = await askInput("プロジェクトディレクトリパス:", {
+    validate: (v) => {
+      const resolved = resolve(v);
+      if (!existsSync(resolved)) return "ディレクトリが存在しません";
+      if (!statSync(resolved).isDirectory()) return "ディレクトリではありません";
+      return true;
+    },
+  });
+
+  const resolvedDir = resolve(directory);
+
+  if (!(await isGitRepo(resolvedDir))) {
+    error("gitリポジトリが検出されませんでした");
+    throw new Error(`Not a git repository: ${resolvedDir}`);
+  }
+  success("gitリポジトリ検出");
+
+  // Branch selection
+  const branches = await listBranches(resolvedDir);
+  const currentBranch = await getCurrentBranch(resolvedDir);
+  const branchChoices = branches.map((b) => ({
+    name: b === currentBranch ? `${b} (現在)` : b,
+    value: b,
+  }));
+
+  const branch = await askSelect("worktree元ブランチ:", branchChoices);
+
+  // Pull
+  const doPull = await askConfirm("ブランチを最新にしますか？ (git pull)", true);
+  if (doPull) {
+    await pullBranch(resolvedDir, branch);
+  }
+
+  // Requirements file
+  const requirementsPath = await askInput("要件定義ドキュメントパス:", {
+    validate: (v) => {
+      const absPath = resolve(resolvedDir, v);
+      if (!existsSync(absPath)) return `ファイルが存在しません: ${absPath}`;
+      return true;
+    },
+  });
+  success("ファイル存在確認");
+
+  // Workers
+  const memStatus = await getMemoryStatus();
+  const availableGB = memStatus.freeGB;
+  const suggested = suggestWorkers(availableGB);
+
+  const workersStr = await askInput(
+    `並行ワーカー数 (推奨: ${suggested}, 空きメモリ: ${availableGB.toFixed(1)}GB):`,
+    {
+      default: String(suggested),
+      validate: (v) => {
+        const n = parseInt(v, 10);
+        if (isNaN(n) || n < 1) return "1以上の整数を入力してください";
+        if (n > 8) return "最大8ワーカーまでです";
+        return true;
+      },
+    },
+  );
+
+  const workers = parseInt(workersStr, 10);
+
+  console.log(`\n────────────────────────────`);
+  console.log(`  プロジェクト #${index + 1} 設定完了`);
+  console.log(`────────────────────────────`);
+
+  return {
+    directory: resolvedDir,
+    branch,
+    requirementsPath: resolve(resolvedDir, requirementsPath),
+    workers,
+  };
+}
+
+export async function runProjectStep(): Promise<ProjectConfig[]> {
+  const projects: ProjectConfig[] = [];
+
+  // At least one project
+  projects.push(await configureProject(0));
+
+  // Additional projects
+  while (await askConfirm("別のプロジェクトを追加しますか？", false)) {
+    projects.push(await configureProject(projects.length));
+  }
+
+  return projects;
+}