@ronkovic/aad 0.3.0

package/src/modules/cli/commands/run.ts

@@ -0,0 +1,322 @@
+/**
+ * Run Command
+ * メインパイプライン: plan → dispatch → execute
+ */
+
+import { Command } from "commander";
+import { randomUUID } from "node:crypto";
+import type { App } from "../app";
+import { formatProgress, formatTaskTable, createSpinner } from "../output";
+import { createRunId, createWorkerId } from "../../../shared/types";
+import type { WorkspaceInfo } from "../../../shared/types";
+import { getCurrentBranch } from "../../git-workspace";
+import { executeTddPipeline } from "../../task-execution";
+import {
+  detectProjectType,
+  detectPackageManager,
+  detectTestFramework,
+  detectFramework,
+  detectOrm,
+  detectArchitecturePattern,
+  createBunFileChecker,
+} from "../../planning";
+
+export function createRunCommand(getApp: () => App): Command {
+  const command = new Command("run")
+    .description("Run AAD pipeline with requirements file")
+    .argument("<requirements>", "Path to requirements.md file")
+    .option("-w, --workers <number>", "Number of workers", parseInt)
+    .option("--persist <mode>", "Persistence mode: memory or fs", "memory")
+    .option("--debug", "Enable debug logging")
+    .option("--no-dashboard", "Disable dashboard server")
+    .option("--provider <type>", "Default provider: cli or sdk", "cli")
+    .option("--repos <paths>", "Comma-separated repository paths for multi-repo mode")
+    .option("--strategy <type>", "Multi-repo strategy: independent or coordinated", "independent")
+    .option("--plugins <paths>", "Comma-separated plugin paths to load")
+    .action(async (requirementsPath: string) => {
+      try {
+        const app = getApp();
+        await runPipeline(app, requirementsPath);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error("Run pipeline failed:", message);
+        process.exit(1);
+      }
+    });
+
+  return command;
+}
+
+/**
+ * メインパイプライン実行
+ */
+export async function runPipeline(app: App, requirementsPath: string): Promise<void> {
+  const { config, logger, eventBus, planningService, dispatcher, processManager, worktreeManager, providerRegistry, stores } = app;
+
+  // Validate requirements file exists
+  const reqFile = Bun.file(requirementsPath);
+  if (!(await reqFile.exists())) {
+    throw new Error(`Requirements file not found: ${requirementsPath}`);
+  }
+
+  logger.info({ requirementsPath }, "Starting AAD pipeline");
+
+  // 1. RunId生成 + 現在ブランチ取得
+  const runId = createRunId(randomUUID());
+  const parentBranch = await getCurrentBranch(process.cwd());
+
+  logger.info({ runId, parentBranch }, "Initialized run");
+  console.log(`\n🚀 AAD Run: ${runId}`);
+  console.log(`📍 Parent Branch: ${parentBranch}\n`);
+
+  // 2. PlanningService.planTasks() → TaskPlan
+  const planSpinner = createSpinner("Planning tasks...");
+  planSpinner.start();
+
+  // Run before:planning hook
+  await app.pluginManager.runHook("before:planning", {
+    runId,
+    parentBranch,
+    requirementsPath,
+  });
+
+  const targetDocsDir = `${process.cwd()}/.aad/docs/${runId}`;
+  const taskPlan = await planningService.planTasks({
+    runId,
+    parentBranch,
+    requirementsPath,
+    targetDocsDir,
+    projectRoot: process.cwd(),
+  });
+
+  planSpinner.stop();
+
+  // Run after:planning hook
+  await app.pluginManager.runHook("after:planning", { runId, taskPlan });
+
+  logger.info({ runId, taskCount: taskPlan.tasks.length }, "Task plan generated");
+  console.log(`✅ Task plan generated: ${taskPlan.tasks.length} tasks\n`);
+
+  if (taskPlan.tasks.length === 0) {
+    console.log("No tasks to execute.");
+    return;
+  }
+
+  // タスク一覧表示
+  console.log(formatTaskTable(taskPlan.tasks));
+  console.log();
+
+  // 3. Dispatcher.initialize(taskPlan) + ProcessManager.initializePool()
+  await dispatcher.initialize(taskPlan);
+  await processManager.initializePool(config.workers.num);
+
+  logger.info({ runId, workerCount: app.config.workers.num }, "Dispatcher and ProcessManager initialized");
+
+  // 4. WorkerStore + RunStoreにworker/run state保存
+  await stores.runStore.save({
+    runId,
+    parentBranch,
+    totalTasks: taskPlan.tasks.length,
+    pending: taskPlan.tasks.length,
+    running: 0,
+    completed: 0,
+    failed: 0,
+    startTime: new Date().toISOString(),
+  });
+
+  // Worker state初期化
+  for (let i = 0; i < app.config.workers.num; i++) {
+    const workerId = createWorkerId(`worker-${i}`);
+    await stores.workerStore.save({
+      workerId,
+      status: "idle",
+      currentTask: null,
+    });
+  }
+
+  // 5. EventBus: task:dispatched → TDDパイプライン起動
+  eventBus.on<Extract<import("../../../shared/events").AADEvent, { type: "task:dispatched" }>>(
+    "task:dispatched",
+    (event) => {
+      const taskId = event.taskId;
+      const workerId = event.workerId;
+      logger.info({ taskId, workerId }, "Task dispatched, starting TDD pipeline");
+
+      void (async () => {
+        try {
+          const task = await stores.taskStore.get(taskId);
+          if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+          }
+
+          // Worktree作成
+          const branchName = `aad/${runId}/${taskId}`;
+          const worktreePath = await worktreeManager.createTaskWorktree(taskId, branchName);
+          logger.info({ taskId, worktreePath, branchName }, "Worktree created");
+
+          // Workspace情報 (project detectionから自動検出)
+          const workspace = await detectWorkspace(worktreePath, logger);
+
+          // Run before:execution hook
+          await app.pluginManager.runHook("before:execution", { taskId, task, worktreePath });
+
+          // TDDパイプライン実行
+          const provider = providerRegistry.getProvider("implementer");
+          const result = await executeTddPipeline(
+            task,
+            workspace,
+            branchName,
+            parentBranch,
+            process.cwd(),
+            runId,
+            app.config,
+            provider,
+            app.mergeService,
+            eventBus,
+            undefined // testSpawner: use default
+          );
+
+          // Run after:execution hook
+          await app.pluginManager.runHook("after:execution", { taskId, result });
+
+          // 結果をEventBusに通知
+          eventBus.emit({ type: "task:completed", taskId, result });
+        } catch (error) {
+          logger.error({ taskId, workerId, error }, "TDD pipeline failed");
+          eventBus.emit({ type: "task:failed", taskId, error: String(error) });
+        }
+      })();
+    }
+  );
+
+  // 6. 進捗表示
+  const progressSpinner = createSpinner("Executing tasks...");
+  progressSpinner.start();
+
+  let lastProgress = { total: 0, pending: 0, running: 0, completed: 0, failed: 0 };
+
+  eventBus.on<Extract<import("../../../shared/events").AADEvent, { type: "progress:updated" }>>(
+    "progress:updated",
+    (event) => {
+      lastProgress = event.state;
+      // Note: Spinner doesn't have update() method - just log progress
+      console.log(formatProgress(event.state));
+    }
+  );
+
+  // 7. Dispatcher.start() (イベントドリブン)
+  void dispatcher.start();
+
+  // 8. run:completed待機 → 結果表示
+  await new Promise<void>((resolve) => {
+    const handler: import("../../../shared/events").EventListener<
+      Extract<import("../../../shared/events").AADEvent, { type: "run:completed" }>
+    > = () => {
+      // runIdの一致をチェック (テスト時はany runIdでも許可)
+      progressSpinner.stop();
+      eventBus.off("run:completed", handler);
+      resolve();
+    };
+    eventBus.on("run:completed", handler);
+  });
+
+  // 最終結果表示
+  console.log("\n" + "=".repeat(60));
+  console.log(formatProgress(lastProgress));
+  console.log("=".repeat(60) + "\n");
+
+  if (lastProgress.failed > 0) {
+    logger.error({ runId, failedCount: lastProgress.failed }, "Pipeline completed with failures");
+    console.error(`❌ Pipeline completed with ${lastProgress.failed} failed tasks`);
+    process.exitCode = 1;
+  } else {
+    logger.info({ runId }, "Pipeline completed successfully");
+    console.log("✅ Pipeline completed successfully!");
+  }
+}
+
+/**
+ * Detect workspace information from worktree path
+ */
+async function detectWorkspace(
+  worktreePath: string,
+  logger: import("pino").Logger
+): Promise<WorkspaceInfo> {
+  try {
+    const fileChecker = createBunFileChecker();
+    const projectType = await detectProjectType(worktreePath, fileChecker);
+    const packageManager = await detectPackageManager(worktreePath, fileChecker);
+    const testFramework = await detectTestFramework(worktreePath, projectType, fileChecker);
+    const framework = await detectFramework(worktreePath, projectType, fileChecker);
+    const orm = await detectOrm(worktreePath, projectType, fileChecker);
+    const architecture = await detectArchitecturePattern(worktreePath, fileChecker);
+
+    // Map planning module types → shared types
+    const workspace: WorkspaceInfo = {
+      path: worktreePath,
+      language: mapProjectTypeToLanguage(projectType),
+      packageManager,
+      framework: framework !== "unknown" ? framework : "none",
+      testFramework: mapTestFramework(testFramework),
+      orm: orm !== "unknown" ? orm : undefined,
+      architecturePattern: architecture !== "custom" && architecture !== "unknown" ? architecture : undefined,
+    };
+
+    logger.debug({ workspace }, "Workspace detected");
+    return workspace;
+  } catch (error) {
+    // Fallback to defaults on detection failure
+    logger.warn({ error, worktreePath }, "Project detection failed, using fallback");
+    return {
+      path: worktreePath,
+      language: "typescript",
+      packageManager: "bun",
+      framework: "none",
+      testFramework: "bun-test",
+    };
+  }
+}
+
+/**
+ * Map ProjectType → language string
+ */
+function mapProjectTypeToLanguage(projectType: import("../../planning").ProjectType): string {
+  const mapping: Record<import("../../planning").ProjectType, string> = {
+    go: "go",
+    "go-workspace": "go",
+    rust: "rust",
+    python: "python",
+    nodejs: "typescript",
+    nextjs: "typescript",
+    express: "typescript",
+    react: "typescript",
+    terraform: "hcl",
+    unknown: "typescript",
+  };
+  return mapping[projectType];
+}
+
+/**
+ * Map planning TestFramework → shared TestFramework
+ */
+function mapTestFramework(tf: import("../../planning").TestFramework): import("../../../shared/types").TestFramework {
+  // "bun:test" → "bun-test"
+  if (tf === "bun:test") return "bun-test";
+  // "unittest" は shared types にないので "pytest" にフォールバック
+  if (tf === "unittest") return "pytest";
+  // "terraform-validate" は shared types にないので "unknown" にフォールバック
+  if (tf === "terraform-validate") return "unknown";
+
+  // その他は1:1マッピング ("pytest", "vitest", "jest", "mocha", "go-test", "cargo-test", "unknown")
+  const mapping: Partial<Record<import("../../planning").TestFramework, import("../../../shared/types").TestFramework>> = {
+    pytest: "pytest",
+    vitest: "vitest",
+    jest: "jest",
+    mocha: "mocha",
+    "go-test": "go-test",
+    "cargo-test": "cargo",
+    unknown: "unknown",
+  };
+
+  return mapping[tf] ?? "unknown";
+}

package/src/modules/cli/commands/status.ts

@@ -0,0 +1,101 @@
+/**
+ * Status Command
+ * Display current run status and task progress
+ */
+
+import { Command } from "commander";
+import type { App } from "../app";
+import type { RunId } from "../../../shared/types";
+import { createRunId } from "../../../shared/types";
+import { formatRunStatus, formatTaskTable } from "../output";
+
+export interface StatusCommandOptions {
+  runId?: string;
+}
+
+/**
+ * Create status command
+ */
+export function createStatusCommand(getApp: () => App): Command {
+  const command = new Command("status");
+
+  command
+    .description("Display run status and task progress")
+    .argument("[run-id]", "Run ID to check status (defaults to latest run)")
+    .action(async (runIdArg?: string) => {
+      let app: App | null = null;
+
+      try {
+        app = getApp();
+        await displayStatus(app, runIdArg);
+        await app.shutdown();
+        process.exit(0);
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(`Error: ${error.message}`);
+        } else {
+          console.error("Unknown error:", error);
+        }
+
+        if (app) {
+          try {
+            await app.shutdown();
+          } catch {
+            // Ignore shutdown errors
+          }
+        }
+
+        process.exit(1);
+      }
+    });
+
+  return command;
+}
+
+/**
+ * Display status for a run
+ */
+export async function displayStatus(app: App, runIdArg?: string): Promise<void> {
+  const { stores, logger } = app;
+
+  let runId: RunId;
+
+  if (runIdArg) {
+    runId = createRunId(runIdArg);
+  } else {
+    // Auto-detect latest run
+    const latestRun = await stores.runStore.getLatest();
+    if (!latestRun) {
+      throw new Error(
+        "No runs found. Please provide a run ID or create a new run with 'aad run'."
+      );
+    }
+    runId = latestRun.runId;
+    logger.info({ runId }, "Auto-detected latest run");
+  }
+
+  logger.info({ runId }, "Fetching run status");
+
+  // 1. Fetch run state
+  const runState = await stores.runStore.get(runId);
+  if (!runState) {
+    throw new Error(`Run not found: ${runId}`);
+  }
+
+  // 2. Fetch all tasks
+  const tasks = await stores.taskStore.getAll();
+
+  // 3. Display run status
+  console.log("\n" + "=".repeat(60));
+  console.log(formatRunStatus(runState));
+  console.log("=".repeat(60));
+
+  // 4. Display task table
+  if (tasks.length > 0) {
+    console.log("\n" + formatTaskTable(tasks));
+  } else {
+    console.log("\nNo tasks found.");
+  }
+
+  console.log();
+}

package/src/modules/cli/index.ts

@@ -0,0 +1,29 @@
+/**
+ * CLI Module
+ *
+ * Command-line interface for AAD.
+ * Provides progress display, table formatting, and error output helpers.
+ */
+
+export {
+  formatProgress,
+  formatTaskTable,
+  formatRunStatus,
+  formatError,
+  formatDuration,
+  createSpinner,
+  type Spinner,
+} from "./output";
+
+export { createApp, type App, type AppOptions } from "./app";
+
+export { createRunCommand, runPipeline } from "./commands/run";
+export { createResumeCommand, resumeRun } from "./commands/resume";
+export { createStatusCommand, displayStatus } from "./commands/status";
+export { createCleanupCommand, cleanupWorktrees } from "./commands/cleanup";
+
+export {
+  createShutdownManager,
+  type ShutdownManager,
+  type ShutdownHandler,
+} from "./shutdown";

package/src/modules/cli/output.ts

@@ -0,0 +1,256 @@
+import type { ProgressState, Task, RunState } from "@aad/shared/types";
+
+// ANSI Color Codes
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const BLUE = "\x1b[34m";
+const CYAN = "\x1b[36m";
+const GRAY = "\x1b[90m";
+
+// Spinner Implementation
+export interface Spinner {
+  start(): void;
+  stop(): void;
+  succeed(message?: string): void;
+  fail(message?: string): void;
+}
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export function createSpinner(message: string): Spinner {
+  let frameIndex = 0;
+  let intervalId: Timer | null = null;
+
+  return {
+    start() {
+      process.stdout.write(`${SPINNER_FRAMES[0]} ${message}`);
+      intervalId = setInterval(() => {
+        frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+        process.stdout.write(`\r${SPINNER_FRAMES[frameIndex]} ${message}`);
+      }, 80);
+    },
+
+    stop() {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+        process.stdout.write("\r\x1b[K"); // Clear line
+      }
+    },
+
+    succeed(msg?: string) {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      const finalMsg = msg ?? message;
+      process.stdout.write(`\r${GREEN}✓${RESET} ${finalMsg}\n`);
+    },
+
+    fail(msg?: string) {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      const finalMsg = msg ?? message;
+      process.stdout.write(`\r${RED}✗${RESET} ${finalMsg}\n`);
+    },
+  };
+}
+
+/**
+ * Format progress state as colored summary
+ */
+export function formatProgress(state: ProgressState): string {
+  const { total, pending, running, completed, failed } = state;
+  const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
+
+  const parts = [
+    `${BOLD}Progress:${RESET} ${percentage}%`,
+    `${BLUE}${pending} pending${RESET}`,
+    `${CYAN}${running} running${RESET}`,
+    `${GREEN}${completed} completed${RESET}`,
+  ];
+
+  if (failed > 0) {
+    parts.push(`${RED}${failed} failed${RESET}`);
+  }
+
+  return parts.join(" | ");
+}
+
+/**
+ * Format task list as ASCII table
+ */
+export function formatTaskTable(tasks: Task[]): string {
+  if (tasks.length === 0) {
+    return `${GRAY}No tasks found.${RESET}`;
+  }
+
+  const rows: string[][] = [
+    ["ID", "Title", "Status", "Worker", "Duration"],
+  ];
+
+  for (const task of tasks) {
+    const id = task.taskId.substring(0, 8);
+    const title =
+      task.title.length > 40 ? task.title.substring(0, 37) + "..." : task.title;
+    const status = colorizeStatus(task.status);
+    const worker = task.workerId
+      ? task.workerId.substring(0, 8)
+      : GRAY + "-" + RESET;
+    const duration = task.startTime
+      ? formatDuration(
+          task.endTime
+            ? new Date(task.endTime).getTime() -
+                new Date(task.startTime).getTime()
+            : Date.now() - new Date(task.startTime).getTime()
+        )
+      : GRAY + "-" + RESET;
+
+    rows.push([id, title, status, worker, duration]);
+  }
+
+  return formatTable(rows);
+}
+
+/**
+ * Format run state as summary box
+ */
+export function formatRunStatus(state: RunState): string {
+  const lines: string[] = [];
+  const duration = state.endTime
+    ? formatDuration(
+        new Date(state.endTime).getTime() - new Date(state.startTime).getTime()
+      )
+    : formatDuration(Date.now() - new Date(state.startTime).getTime());
+
+  lines.push(`${BOLD}Run ID:${RESET} ${state.runId}`);
+  lines.push(`${BOLD}Branch:${RESET} ${state.parentBranch}`);
+  lines.push(`${BOLD}Duration:${RESET} ${duration}`);
+  lines.push("");
+  lines.push(
+    formatProgress({
+      total: state.totalTasks,
+      pending: state.pending,
+      running: state.running,
+      completed: state.completed,
+      failed: state.failed,
+    })
+  );
+
+  return lines.join("\n");
+}
+
+/**
+ * Format error with stack trace
+ */
+export function formatError(error: Error): string {
+  const lines: string[] = [];
+  lines.push(`${RED}${BOLD}Error:${RESET} ${error.message}`);
+
+  if (error.stack) {
+    const stackLines = error.stack.split("\n").slice(1, 4); // First 3 stack frames
+    for (const line of stackLines) {
+      lines.push(`${GRAY}  ${line.trim()}${RESET}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Format duration in human-readable format
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 0) return "0s";
+
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  } else if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  } else {
+    return `${seconds}s`;
+  }
+}
+
+// Helper Functions
+
+function colorizeStatus(status: string): string {
+  switch (status) {
+    case "pending":
+      return `${BLUE}${status}${RESET}`;
+    case "running":
+      return `${CYAN}${status}${RESET}`;
+    case "completed":
+      return `${GREEN}${status}${RESET}`;
+    case "failed":
+      return `${RED}${status}${RESET}`;
+    default:
+      return `${GRAY}${status}${RESET}`;
+  }
+}
+
+function formatTable(rows: string[][]): string {
+  if (rows.length === 0) return "";
+
+  const headerRow = rows[0];
+  if (!headerRow) return "";
+
+  // Calculate column widths (without ANSI codes)
+  const colWidths = headerRow.map((_, colIndex) => {
+    return Math.max(
+      ...rows.map((row) => stripAnsi(row[colIndex] ?? "").length)
+    );
+  });
+
+  const lines: string[] = [];
+
+  // Header
+  const header = headerRow
+    .map((cell, i) => {
+      const width = colWidths[i];
+      return width !== undefined
+        ? cell.padEnd(width + getAnsiLength(cell))
+        : cell;
+    })
+    .join(" | ");
+  lines.push(BOLD + header + RESET);
+
+  // Separator
+  const separator = colWidths.map((w) => "-".repeat(w)).join("-+-");
+  lines.push(separator);
+
+  // Rows
+  for (let i = 1; i < rows.length; i++) {
+    const currentRow = rows[i];
+    if (!currentRow) continue;
+
+    const row = currentRow
+      .map((cell, j) => {
+        const width = colWidths[j];
+        return width !== undefined
+          ? cell.padEnd(width + getAnsiLength(cell || ""))
+          : cell;
+      })
+      .join(" | ");
+    lines.push(row);
+  }
+
+  return lines.join("\n");
+}
+
+function stripAnsi(str: string): string {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+function getAnsiLength(str: string): number {
+  return str.length - stripAnsi(str).length;
+}