@ronkovic/aad 0.3.0

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

@@ -0,0 +1,144 @@
+/**
+ * Status Command Tests
+ */
+
+import { describe, test, expect, beforeEach, mock } from "bun:test";
+import type { App } from "../app";
+import { displayStatus } from "../commands/status";
+import { createRunId, createTaskId, type Task, type RunState } from "../../../shared/types";
+
+describe("displayStatus", () => {
+  let mockApp: App;
+
+  beforeEach(() => {
+    const mockRunState: RunState = {
+      runId: createRunId("test-run"),
+      parentBranch: "main",
+      totalTasks: 3,
+      pending: 1,
+      running: 1,
+      completed: 1,
+      failed: 0,
+      startTime: "2024-01-01T00:00:00Z",
+    };
+
+    const mockTasks: Task[] = [
+      {
+        taskId: createTaskId("task-1"),
+        title: "Task 1",
+        description: "First task",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 1,
+        status: "completed",
+        retryCount: 0,
+      },
+      {
+        taskId: createTaskId("task-2"),
+        title: "Task 2",
+        description: "Second task",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 2,
+        status: "running",
+        retryCount: 0,
+      },
+      {
+        taskId: createTaskId("task-3"),
+        title: "Task 3",
+        description: "Third task",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 3,
+        status: "pending",
+        retryCount: 0,
+      },
+    ];
+
+    mockApp = {
+      config: {} as any,
+      eventBus: {} as any,
+      logger: {
+        info: mock(() => {}),
+        error: mock(() => {}),
+      } as any,
+      stores: {
+        runStore: {
+          get: mock(async () => mockRunState),
+          getLatest: mock(async () => null),
+        } as any,
+        taskStore: {
+          getAll: mock(async () => mockTasks),
+        } as any,
+        workerStore: {} as any,
+      },
+      dispatcher: {} as any,
+      processManager: {} as any,
+      planningService: {} as any,
+      providerRegistry: {} as any,
+      worktreeManager: {} as any,
+      branchManager: {} as any,
+      mergeService: {} as any,
+      pluginManager: { runHook: mock(async (_p: string, d: unknown) => d), deactivateAll: mock(async () => {}), register: mock(async () => {}), loadFromConfig: mock(async () => {}), addHook: mock(() => {}), list: mock(() => []) } as any,
+      shutdown: mock(async () => {}),
+    };
+  });
+
+  test("displays status for valid run", async () => {
+    await displayStatus(mockApp, "test-run");
+
+    expect(mockApp.stores.runStore.get).toHaveBeenCalledWith(createRunId("test-run"));
+    expect(mockApp.stores.taskStore.getAll).toHaveBeenCalled();
+  });
+
+  test("throws error for non-existent run", async () => {
+    mockApp.stores.runStore.get = mock(async () => null);
+
+    await expect(displayStatus(mockApp, "non-existent")).rejects.toThrow(
+      "Run not found: non-existent"
+    );
+  });
+
+  test("throws error when no run ID provided and no runs exist", async () => {
+    await expect(displayStatus(mockApp)).rejects.toThrow(
+      "No runs found. Please provide a run ID or create a new run with 'aad run'."
+    );
+  });
+
+  test("handles empty task list", async () => {
+    mockApp.stores.taskStore.getAll = mock(async () => []);
+
+    await displayStatus(mockApp, "test-run");
+    // Should complete without throwing
+    expect(true).toBe(true);
+  });
+
+  test("auto-detects latest run when no runId provided", async () => {
+    const latestRunState: RunState = {
+      runId: createRunId("latest-run"),
+      parentBranch: "main",
+      totalTasks: 2,
+      pending: 0,
+      running: 0,
+      completed: 2,
+      failed: 0,
+      startTime: "2024-01-02T00:00:00Z",
+    };
+
+    mockApp.stores.runStore.getLatest = mock(async () => latestRunState);
+    mockApp.stores.runStore.get = mock(async () => latestRunState);
+
+    await displayStatus(mockApp);
+
+    expect(mockApp.stores.runStore.getLatest).toHaveBeenCalled();
+    expect(mockApp.stores.runStore.get).toHaveBeenCalledWith(createRunId("latest-run"));
+  });
+
+  test("throws error when no runs exist and no runId provided", async () => {
+    mockApp.stores.runStore.getLatest = mock(async () => null);
+
+    await expect(displayStatus(mockApp)).rejects.toThrow(
+      "No runs found. Please provide a run ID or create a new run with 'aad run'."
+    );
+  });
+});

package/src/modules/cli/app.ts

@@ -0,0 +1,241 @@
+/**
+ * CLI App - Composition Root
+ * DI配線とライフサイクル管理
+ */
+
+import type { Logger } from "pino";
+import type { Config } from "../../shared/config";
+import type { EventBus } from "../../shared/events";
+import type { Stores } from "../persistence";
+import type { Dispatcher } from "../task-queue";
+import type { ProcessManager } from "../process-manager";
+import type { PlanningService } from "../planning";
+import type { ProviderRegistry } from "../claude-provider";
+import type { WorktreeManager, BranchManager, MergeService } from "../git-workspace";
+import type { DashboardServer } from "../dashboard";
+import type { PluginManager } from "../plugin";
+
+import { loadConfig } from "../../shared/config";
+import { EventBus as EventBusImpl } from "../../shared/events";
+import { createLogger, LogStore, createSSETransport } from "../logging";
+import { createProviderRegistry, type ProviderType } from "../claude-provider";
+import { createStores } from "../persistence";
+import { Dispatcher as DispatcherImpl } from "../task-queue";
+import { ProcessManager as ProcessManagerImpl } from "../process-manager";
+import { PlanningService as PlanningServiceImpl } from "../planning";
+import { WorktreeManager as WorktreeManagerImpl, BranchManager as BranchManagerImpl, MergeService as MergeServiceImpl } from "../git-workspace";
+import { DashboardServer as DashboardServerImpl } from "../dashboard";
+import { PluginManager as PluginManagerImpl } from "../plugin";
+
+export interface AppOptions {
+  workers?: number;
+  persist?: "memory" | "fs";
+  debug?: boolean;
+  dashboard?: boolean;
+  providerDefault?: ProviderType;
+  providerOverrides?: Partial<Record<string, ProviderType>>;
+}
+
+export interface App {
+  config: Config;
+  eventBus: EventBus;
+  logger: Logger;
+  stores: Stores;
+  dispatcher: Dispatcher;
+  processManager: ProcessManager;
+  planningService: PlanningService;
+  providerRegistry: ProviderRegistry;
+  worktreeManager: WorktreeManager;
+  branchManager: BranchManager;
+  mergeService: MergeService;
+  dashboardServer?: DashboardServer;
+  pluginManager: PluginManager;
+  shutdown(): Promise<void>;
+}
+
+/**
+ * アプリケーションのComposition Root
+ * 全モジュールのDI配線とライフサイクル管理
+ */
+export function createApp(options: AppOptions = {}): App {
+  // 1. 設定読み込み (CLI optionsでenv overrides)
+  const envOverrides: Record<string, string> = {};
+  if (options.workers !== undefined) {
+    envOverrides.AAD_NUM_WORKERS = String(options.workers);
+    // Also override max workers to avoid validation error
+    envOverrides.AAD_MAX_WORKERS = String(Math.max(options.workers, 8));
+  }
+  if (options.debug !== undefined) {
+    envOverrides.DEBUG = options.debug ? "1" : "0";
+  }
+  if (options.dashboard !== undefined) {
+    envOverrides.AAD_DASHBOARD_ENABLED = options.dashboard ? "1" : "0";
+  }
+
+  const config = loadConfig({ ...process.env, ...envOverrides });
+
+  // 2. EventBus初期化
+  const eventBus = new EventBusImpl();
+
+  // 3. Logger初期化
+  const logger = createLogger({
+    service: "aad-cli",
+    debug: config.debug,
+  });
+  logger.debug({ config, options }, "AAD CLI starting");
+
+  // 4. LogStore + SSE Transport初期化
+  const logStore = new LogStore();
+  const sseTransport = createSSETransport({ logStore, eventBus });
+  void sseTransport;
+
+  // 5. ProviderRegistry初期化
+  const providerRegistry = createProviderRegistry(
+    {
+      default: options.providerDefault ?? "cli",
+      overrides: options.providerOverrides,
+    },
+    config,
+    logger.child({ service: "claude-provider" })
+  );
+  logger.debug({ default: options.providerDefault ?? "cli" }, "ProviderRegistry initialized");
+
+  // 6. Persistence stores初期化
+  const persistMode = options.persist ?? "memory";
+  const stores = createStores(persistMode, {
+    basePath: persistMode === "fs" ? `${process.cwd()}/.aad/data` : undefined,
+    logger: logger.child({ service: "persistence" }),
+  });
+  logger.debug({ mode: persistMode }, "Persistence stores initialized");
+
+  // 7. ProcessManager初期化
+  const processManager = new ProcessManagerImpl({
+    eventBus,
+    config,
+    logger: logger.child({ service: "process-manager" }),
+  });
+  logger.debug("ProcessManager initialized");
+
+  // 8. Dispatcher初期化
+  const dispatcher = new DispatcherImpl({
+    taskStore: stores.taskStore,
+    workerStore: stores.workerStore,
+    runStore: stores.runStore,
+    eventBus,
+    config: {
+      maxRetries: config.retry.maxRetries,
+      staleTaskCheckInterval: 60000,
+      staleTaskThreshold: config.timeouts.staleTask * 1000, // Convert seconds to milliseconds
+    },
+    logger: logger.child({ service: "task-queue" }),
+  });
+  logger.debug("Dispatcher initialized");
+
+  // 9. PlanningService初期化
+  const planningService = new PlanningServiceImpl(
+    providerRegistry.getProvider("splitter"),
+    eventBus,
+    config,
+    logger.child({ service: "planning" })
+  );
+  logger.debug("PlanningService initialized");
+
+  // 10. Git Workspace Services初期化
+  const repoRoot = process.cwd();
+  const worktreeBase = `${repoRoot}/.aad/worktrees`;
+
+  const worktreeManager = new WorktreeManagerImpl({
+    repoRoot,
+    worktreeBase,
+    logger: logger.child({ service: "git-workspace" }),
+  });
+  const branchManager = new BranchManagerImpl({
+    repoRoot,
+    logger: logger.child({ service: "git-workspace" }),
+  });
+  const mergeService = new MergeServiceImpl({
+    repoRoot,
+    logger: logger.child({ service: "git-workspace" }),
+  });
+  logger.debug({ repoRoot, worktreeBase }, "Git Workspace services initialized");
+
+  // 11. Dashboard Server初期化 (optional)
+  let dashboardServer: DashboardServer | undefined;
+  if (config.dashboard.enabled) {
+    // Dashboard uses TaskStore and ProcessManager directly
+    dashboardServer = new DashboardServerImpl({
+      eventBus,
+      logStore,
+      taskStore: stores.taskStore,
+      processManager: processManager,
+      port: config.dashboard.port,
+      host: config.dashboard.host,
+      logger,
+    });
+
+    dashboardServer.start();
+    logger.info(
+      { port: config.dashboard.port, host: config.dashboard.host },
+      "Dashboard server started"
+    );
+  }
+
+  // 12. PluginManager初期化
+  const pluginManager = new PluginManagerImpl({
+    config,
+    eventBus,
+    logger: logger.child({ service: "plugin" }),
+  });
+
+  // Load plugins from config if present
+  if (config.plugins && config.plugins.length > 0) {
+    void pluginManager.loadFromConfig(config.plugins);
+  }
+
+  // 13. Shutdown handler
+  const shutdown = async (): Promise<void> => {
+    logger.debug("Shutting down AAD...");
+
+    try {
+      // Plugin deactivation
+      await pluginManager.deactivateAll();
+      logger.debug("Plugins deactivated");
+
+      // Dashboard停止
+      if (dashboardServer) {
+        dashboardServer.stop();
+        logger.debug("Dashboard server stopped");
+      }
+
+      // ProcessManager停止
+      await processManager.stopAll();
+      logger.debug("ProcessManager stopped");
+
+      // Dispatcher停止
+      dispatcher.stop();
+      logger.debug("Dispatcher stopped");
+
+      logger.debug("AAD shutdown complete");
+    } catch (error) {
+      logger.error({ error }, "Error during shutdown");
+      throw error;
+    }
+  };
+
+  return {
+    config,
+    eventBus,
+    logger,
+    stores,
+    dispatcher,
+    processManager,
+    planningService,
+    providerRegistry,
+    worktreeManager,
+    branchManager,
+    mergeService,
+    dashboardServer,
+    pluginManager,
+    shutdown,
+  };
+}

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

@@ -0,0 +1,120 @@
+/**
+ * Cleanup Command
+ * Remove worktrees and orphaned branches
+ */
+
+import { Command } from "commander";
+import type { App } from "../app";
+import { createRunId } from "../../../shared/types";
+
+export interface CleanupCommandOptions {
+  force?: boolean;
+}
+
+/**
+ * Create cleanup command
+ */
+export function createCleanupCommand(getApp: () => App): Command {
+  const command = new Command("cleanup");
+
+  command
+    .description("Remove worktrees and orphaned branches")
+    .argument("[run-id]", "Run ID to cleanup (defaults to all AAD worktrees)")
+    .option("-f, --force", "Force remove worktrees and branches", false)
+    .action(async (runIdArg?: string, options?: CleanupCommandOptions) => {
+      let app: App | null = null;
+
+      try {
+        app = getApp();
+        await cleanupWorktrees(app, runIdArg, options?.force ?? false);
+        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;
+}
+
+/**
+ * Cleanup worktrees and branches
+ */
+export async function cleanupWorktrees(
+  app: App,
+  runIdArg?: string,
+  force = false
+): Promise<void> {
+  const { worktreeManager, branchManager, logger } = app;
+
+  const runId = runIdArg ? createRunId(runIdArg) : undefined;
+
+  logger.info({ runId, force }, "Starting cleanup");
+
+  // 1. List all worktrees
+  const worktrees = await worktreeManager.listWorktrees();
+  logger.debug({ count: worktrees.length }, "Found worktrees");
+
+  const worktreeBase = `${process.cwd()}/.aad/worktrees`;
+  const aadWorktrees = worktrees.filter((wt) => wt.path.startsWith(worktreeBase));
+
+  if (aadWorktrees.length === 0) {
+    console.log("No AAD worktrees found.");
+  } else {
+    console.log(`\nFound ${aadWorktrees.length} AAD worktree(s):`);
+
+    // 2. Remove each worktree
+    let removed = 0;
+    for (const worktree of aadWorktrees) {
+      try {
+        // Filter by runId if specified
+        if (runId && !worktree.path.includes(runId)) {
+          continue;
+        }
+
+        console.log(`  Removing: ${worktree.path}`);
+        await worktreeManager.removeWorktree(worktree.path, force);
+        removed++;
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(`  Failed to remove ${worktree.path}: ${errorMsg}`);
+      }
+    }
+
+    console.log(`\nRemoved ${removed} worktree(s).`);
+  }
+
+  // 3. Prune orphaned worktrees
+  await worktreeManager.pruneWorktrees();
+  logger.info("Pruned orphaned worktrees");
+
+  // 4. Cleanup orphaned branches
+  const deletedBranches = runId
+    ? await branchManager.cleanupOrphanBranches(runId)
+    : await branchManager.cleanupOrphanBranches();
+
+  if (deletedBranches.length > 0) {
+    console.log(`\nDeleted ${deletedBranches.length} orphan branch(es):`);
+    for (const branch of deletedBranches) {
+      console.log(`  - ${branch}`);
+    }
+  } else {
+    console.log("\nNo orphan branches found.");
+  }
+
+  console.log("\nCleanup complete.");
+}

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

@@ -0,0 +1,156 @@
+/**
+ * Resume Command
+ * 中断されたrunを再開
+ */
+
+import { Command } from "commander";
+import type { App } from "../app";
+import { createRunId } from "../../../shared/types";
+
+export function createResumeCommand(getApp: () => App): Command {
+  const command = new Command("resume")
+    .description("Resume interrupted run")
+    .argument("<runId>", "Run ID to resume")
+    .action(async (runIdStr: string) => {
+      try {
+        const app = getApp();
+        await resumeRun(app, runIdStr);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error("Resume failed:", message);
+        process.exit(1);
+      }
+    });
+
+  return command;
+}
+
+/**
+ * Run再開
+ */
+export async function resumeRun(app: App, runIdStr: string): Promise<void> {
+  const { logger, stores, dispatcher, processManager } = app;
+  const runId = createRunId(runIdStr);
+
+  logger.info({ runId }, "Resuming run");
+  console.log(`\n🔄 Resuming Run: ${runId}\n`);
+
+  // 1. RunStateを読み込み
+  const runState = await stores.runStore.get(runId);
+  if (!runState) {
+    throw new Error(`Run not found: ${runId}`);
+  }
+
+  logger.info({ runState }, "Run state loaded");
+
+  // 2. タスク一覧を読み込み
+  const allTasks = await stores.taskStore.getAll();
+  const runTasks = allTasks.filter((task) => {
+    return task.taskId.includes(runIdStr);
+  });
+
+  logger.info({ taskCount: runTasks.length }, "Tasks loaded");
+
+  // 2.5. 早期リターン: タスクが0件の場合
+  if (runTasks.length === 0) {
+    logger.info({ runId }, "No tasks found for run");
+    console.log("⚠️ No tasks found for this run\n");
+    await app.shutdown();
+    return;
+  }
+
+  // 2.6. 早期リターン: 全タスク完了済みまたは全タスク失敗済み
+  const pendingOrRunning = runTasks.filter(
+    (t) => t.status === "pending" || t.status === "running"
+  );
+  if (pendingOrRunning.length === 0) {
+    const failedCount = runTasks.filter((t) => t.status === "failed").length;
+    const completedCount = runTasks.filter((t) => t.status === "completed").length;
+    if (failedCount > 0 && completedCount === 0) {
+      logger.info({ runId, failedCount }, "All tasks already failed");
+      console.log(`⚠️ All ${failedCount} tasks already failed\n`);
+    } else {
+      logger.info({ runId, completedCount, failedCount }, "All tasks already finished");
+      console.log(`✅ All tasks already finished (${completedCount} completed, ${failedCount} failed)\n`);
+    }
+    await app.shutdown();
+    return;
+  }
+
+  // 3. running → pending にリセット
+  let resetCount = 0;
+  for (const task of runTasks) {
+    if (task.status === "running") {
+      await stores.taskStore.save({
+        ...task,
+        status: "pending",
+        workerId: undefined,
+      });
+      resetCount++;
+    }
+  }
+
+  logger.info({ resetCount }, "Reset running tasks to pending");
+  console.log(`✅ Reset ${resetCount} running tasks to pending\n`);
+
+  // 4. TaskPlanを再構築
+  const taskPlan = {
+    runId,
+    parentBranch: runState.parentBranch,
+    tasks: runTasks,
+  };
+
+  // 5. Dispatcher再初期化
+  await dispatcher.initialize(taskPlan);
+  await processManager.initializePool(app.config.workers.num);
+
+  logger.info("Dispatcher and ProcessManager re-initialized");
+  console.log("✅ Dispatcher and ProcessManager re-initialized\n");
+
+  // 6. Dispatcher.start()
+  dispatcher.start();
+  logger.info({ runId }, "Run resumed");
+  console.log("✅ Run resumed. Waiting for completion...\n");
+
+  // 7. Wait for run completion with timeout and error handling
+  const timeoutMs = (app.config.timeouts.staleTask || 5400) * 1000;
+
+  await new Promise<void>((resolve, reject) => {
+    let settled = false;
+    const settle = (fn: () => void) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      fn();
+    };
+
+    const onCompleted = (event: { type: string; runId?: string }) => {
+      if (event.type === "run:completed" && event.runId === runId) {
+        settle(resolve);
+      }
+    };
+
+    const onFailed = (event: { type: string; runId?: string; error?: string }) => {
+      if (event.type === "run:failed" && event.runId === runId) {
+        settle(() => reject(new Error(`Run failed: ${event.error ?? "unknown error"}`)));
+      }
+    };
+
+    const timer = setTimeout(() => {
+      settle(() => reject(new Error(`Resume timed out after ${timeoutMs}ms`)));
+    }, timeoutMs);
+
+    const cleanup = () => {
+      clearTimeout(timer);
+      app.eventBus.off("run:completed", onCompleted);
+      app.eventBus.off("run:failed", onFailed);
+    };
+
+    app.eventBus.on("run:completed", onCompleted);
+    app.eventBus.on("run:failed", onFailed);
+  });
+
+  // 8. Shutdown gracefully
+  await app.shutdown();
+  console.log("\n✅ Run completed successfully\n");
+}