@ronkovic/aad 0.3.9 → 0.5.0

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

@@ -8,11 +8,12 @@ import { randomUUID } from "node:crypto";
 import type { App } from "../app";
 import { formatProgress, formatTaskTable, createSpinner } from "../output";
 import { createRunId, createWorkerId } from "../../../shared/types";
-import { getCurrentBranch, cleanupOrphanedFromPreviousRuns } from "../../git-workspace";
+import { getCurrentBranch, cleanupOrphanedFromPreviousRuns, copyTemplatesToWorktree, installDependencies } from "../../git-workspace";
 import { checkMemoryAndWarn } from "../../../shared/memory-check";
 import { installShutdownHandler } from "../../../shared/shutdown-handler";
-import { registerTaskDispatchHandler } from "./task-dispatch-handler";
+import { registerTaskDispatchHandler, detectWorkspace } from "./task-dispatch-handler";
 import { generateFeatureName } from "../../planning/feature-name-generator";
+import { checkPrerequisites } from "../../../shared/prerequisites";
 
 export function createRunCommand(getApp: () => App): Command {
   const command = new Command("run")
@@ -27,13 +28,31 @@ export function createRunCommand(getApp: () => App): Command {
     .option("--strategy <type>", "Multi-repo strategy: independent or coordinated", "independent")
     .option("--plugins <paths>", "Comma-separated plugin paths to load")
     .option("--keep-worktrees", "Keep worktrees and branches after completion (default: auto-cleanup)", false)
-    .action(async (requirementsPath: string, cmdOptions: { keepWorktrees?: boolean }) => {
+    .option("--dry-run", "Display task plan without executing", false)
+    .option("--strict-tdd", "Always run full TDD pipeline (disable pre-check optimization)", false)
+    .action(async (requirementsPath: string, cmdOptions: { keepWorktrees?: boolean; dryRun?: boolean; strictTdd?: boolean }) => {
+      let app: App | null = null;
       try {
-        const app = getApp();
-        await runPipeline(app, requirementsPath, cmdOptions.keepWorktrees ?? false);
+        app = getApp();
+
+        // Override config with CLI options
+        if (cmdOptions.strictTdd !== undefined) {
+          app.config.strictTdd = cmdOptions.strictTdd;
+        }
+
+        await runPipeline(app, requirementsPath, cmdOptions.keepWorktrees ?? false, cmdOptions.dryRun ?? false);
+        await app.shutdown();
+        process.exit(process.exitCode ?? 0);
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         console.error("Run pipeline failed:", message);
+        if (app) {
+          try {
+            await app.shutdown();
+          } catch {
+            // Ignore shutdown errors
+          }
+        }
         process.exit(1);
       }
     });
@@ -44,7 +63,7 @@ export function createRunCommand(getApp: () => App): Command {
 /**
  * メインパイプライン実行
  */
-export async function runPipeline(app: App, requirementsPath: string, keepWorktrees = false): Promise<void> {
+export async function runPipeline(app: App, requirementsPath: string, keepWorktrees = false, dryRun = false): Promise<void> {
   const { config, logger, eventBus, planningService, dispatcher, processManager, worktreeManager, stores, branchManager, providerRegistry } = app;
 
   // Validate requirements file exists
@@ -55,7 +74,10 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
 
   logger.info({ requirementsPath }, "Starting AAD pipeline");
 
-  // 0. Memory check
+  // 0. Prerequisites check
+  await checkPrerequisites(logger);
+
+  // 0.1. Memory check
   await checkMemoryAndWarn(logger);
 
   // 0.5. Cleanup orphaned worktrees/branches from previous runs
@@ -71,7 +93,11 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
 
   logger.info({ runId, parentBranch }, "Initialized run");
   console.log(`\n🚀 AAD Run: ${runId}`);
-  console.log(`📍 Parent Branch: ${parentBranch}\n`);
+  console.log(`📍 Parent Branch: ${parentBranch}`);
+  if (app.dashboardServer) {
+    console.log(`📊 Dashboard: http://${config.dashboard.host}:${config.dashboard.port}`);
+  }
+  console.log();
 
   // 2. PlanningService.planTasks() → TaskPlan
   const planSpinner = createSpinner("Planning tasks...");
@@ -110,6 +136,12 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
   console.log(formatTaskTable(taskPlan.tasks));
   console.log();
 
+  // Dry-run: タスク一覧表示後に終了
+  if (dryRun) {
+    console.log("🔍 Dry-run mode: Exiting without execution\n");
+    return;
+  }
+
   // 3. Dispatcher.initialize(taskPlan) + ProcessManager.initializePool()
   await dispatcher.initialize(taskPlan);
   await processManager.initializePool(config.workers.num);
@@ -143,6 +175,7 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
     runId,
     stores: { runStore: stores.runStore, taskStore: stores.taskStore },
     logger,
+    persistMode: app.persistMode,
   });
 
   // 5. Generate feature name and create parent worktree with real branch
@@ -160,6 +193,32 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
     featureBranchName = result.branch;
     logger.info({ parentWorktreePath, featureBranchName }, "Parent worktree created for merging");
     console.log(`🌿 Feature Branch: ${featureBranchName}`);
+
+    // Copy templates to parent worktree
+    try {
+      await copyTemplatesToWorktree({
+        targetDir: parentWorktreePath,
+        projectRoot: process.cwd(),
+        logger,
+      });
+      logger.info({ parentWorktreePath }, "Templates copied to parent worktree");
+    } catch (templateError) {
+      logger.warn({ templateError }, "Template copy failed (non-critical)");
+    }
+
+    // Install dependencies in parent worktree (non-critical)
+    try {
+      const workspace = await detectWorkspace(parentWorktreePath, logger);
+      const installResult = await installDependencies(workspace, logger);
+      if (!installResult.skipped && !installResult.success) {
+        logger.warn(
+          { parentWorktreePath, output: installResult.output.slice(0, 500) },
+          "Parent worktree dependency install failed (non-fatal)"
+        );
+      }
+    } catch (installError) {
+      logger.warn({ installError }, "Parent worktree install error (non-fatal)");
+    }
   } catch (error) {
     logger.warn({ error }, "Failed to create parent worktree, using repo root as fallback");
   }
@@ -272,6 +331,9 @@ export async function runPipeline(app: App, requirementsPath: string, keepWorktr
 
       console.log(`  Removed ${removed} worktree(s)`);
       console.log(`  Deleted ${deletedBranches.length} branch(es)`);
+      if (featureBranchName) {
+        console.log(`  🌿 Parent branch preserved: ${featureBranchName}`);
+      }
       logger.info({ runId, removedWorktrees: removed, deletedBranches: deletedBranches.length }, "Auto-cleanup completed");
     } catch (error) {
       logger.error({ runId, error }, "Auto-cleanup failed");

package/src/modules/cli/commands/task-dispatch-handler.ts

@@ -20,6 +20,7 @@ import {
   detectArchitecturePattern,
   createBunFileChecker,
 } from "../../planning";
+import { copyTemplatesToWorktree, harvestMemory, installDependencies } from "../../git-workspace";
 
 export interface TaskDispatchContext {
   app: App;
@@ -69,18 +70,86 @@ export function registerTaskDispatchHandler(ctx: TaskDispatchContext): void {
       const worktreePath = await worktreeManager.createTaskWorktree(taskId, branchName, featureBranchName);
       logger.info({ taskId, worktreePath, branchName }, "Worktree created");
 
+      // Copy templates to task worktree
+      try {
+        await copyTemplatesToWorktree({
+          targetDir: worktreePath,
+          projectRoot: process.cwd(),
+          logger,
+        });
+      } catch (templateError) {
+        logger.warn({ templateError }, "Template copy failed (non-critical)");
+      }
+
       const workspace = await detectWorkspace(worktreePath, logger);
 
+      // Install dependencies in task worktree
+      try {
+        const installResult = await installDependencies(workspace, logger);
+        if (!installResult.skipped && !installResult.success) {
+          logger.warn(
+            {
+              taskId,
+              packageManager: workspace.packageManager,
+              output: installResult.output.slice(0, 500),
+            },
+            "Dependency install failed (non-fatal, Claude agent may handle)"
+          );
+        }
+      } catch (installError) {
+        logger.warn({ taskId, error: installError }, "Dependency install error (non-fatal)");
+      }
+
+      // Fetch dependency changes if task has dependencies
+      if (task.dependsOn.length > 0) {
+        try {
+          for (const depTaskId of task.dependsOn) {
+            const depTask = await stores.taskStore.get(depTaskId);
+            if (depTask?.status === "completed") {
+              const depBranchName = `${branchPrefix}/${depTaskId}`;
+              await app.mergeService.fetchDependencyChanges(depBranchName, worktreePath);
+              logger.info({ taskId, depTaskId }, "Fetched dependency changes");
+            }
+          }
+        } catch (depError) {
+          logger.warn({ taskId, error: depError }, "Dependency fetch failed (non-critical)");
+        }
+      }
+
       await app.pluginManager.runHook("before:execution", { taskId, task, worktreePath });
 
       const provider = providerRegistry.getProvider("implementer");
+      const retryContext = task.retryCount > 0 ? {
+        retryCount: task.retryCount,
+        previousFailure: task.previousFailure,
+      } : undefined;
+
       const result = await executeTddPipeline(
         task, workspace, branchName, parentBranch, mergeTarget,
         runId, app.config, provider, app.mergeService, eventBus,
+        undefined, // testSpawner
+        retryContext,
       );
 
       await app.pluginManager.runHook("after:execution", { taskId, result });
-      eventBus.emit({ type: "task:completed", taskId, result });
+
+      if (result.status === "failed") {
+        logger.warn({ taskId, error: result.error, output: result.output }, "TDD pipeline returned failure");
+        eventBus.emit({ type: "task:failed", taskId, error: result.error ?? "Pipeline failed" });
+      } else {
+        eventBus.emit({ type: "task:completed", taskId, result });
+
+        // Harvest agent memory (non-critical)
+        try {
+          await harvestMemory({
+            sourceDir: `${worktreePath}/.claude/agent-memory`,
+            targetDir: `${process.cwd()}/.claude/agent-memory`,
+            logger,
+          });
+        } catch (memoryError) {
+          logger.warn({ taskId, error: memoryError }, "Memory harvest failed (non-critical)");
+        }
+      }
     } catch (error) {
       logger.error({ taskId, workerId, error }, "TDD pipeline failed");
       eventBus.emit({ type: "task:failed", taskId, error: String(error) });
@@ -135,7 +204,7 @@ export function registerTaskDispatchHandler(ctx: TaskDispatchContext): void {
 /**
  * Detect workspace information from worktree path
  */
-async function detectWorkspace(
+export async function detectWorkspace(
   worktreePath: string,
   logger: import("pino").Logger
 ): Promise<WorkspaceInfo> {
@@ -202,13 +271,14 @@ function mapProjectTypeToLanguage(projectType: import("../../planning").ProjectT
 function mapTestFramework(tf: import("../../planning").TestFramework): import("../../../shared/types").TestFramework {
   if (tf === "bun:test") return "bun-test";
   if (tf === "unittest") return "pytest";
-  if (tf === "terraform-validate") return "unknown";
+  if (tf === "terraform-validate") return "terraform";
 
   const mapping: Partial<Record<import("../../planning").TestFramework, import("../../../shared/types").TestFramework>> = {
     pytest: "pytest",
     vitest: "vitest",
     jest: "jest",
     mocha: "mocha",
+    playwright: "playwright",
     "go-test": "go-test",
     "cargo-test": "cargo",
     unknown: "unknown",

package/src/modules/dashboard/__tests__/api-graph.test.ts

@@ -0,0 +1,332 @@
+import { describe, test, expect } from "bun:test";
+import type { StateAggregator } from "../services/state-aggregator";
+
+/**
+ * テストケース: /api/graph エンドポイント
+ *
+ * DAG (Directed Acyclic Graph) 可視化用のタスク依存関係グラフを返す
+ * - nodes: タスクのリスト (id, status)
+ * - edges: 依存関係のリスト (from → to)
+ */
+describe("GET /api/graph - Task Dependency Graph", () => {
+  /**
+   * テストケース 1: 空のグラフ (タスクなし)
+   *
+   * 期待値:
+   * - nodes: 空配列
+   * - edges: 空配列
+   */
+  test("returns empty graph when no tasks exist", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [],
+        edges: [],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toEqual([]);
+    expect(result.edges).toEqual([]);
+  });
+
+  /**
+   * テストケース 2: 単一タスク (依存関係なし)
+   *
+   * グラフ構造:
+   *
+   *   [task-1]
+   *
+   * 期待値:
+   * - nodes: 1つのノード
+   * - edges: 空配列
+   */
+  test("returns single node with no edges for independent task", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "pending" },
+        ],
+        edges: [],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(1);
+    expect(result.nodes[0]).toEqual({ id: "task-1", status: "pending" });
+    expect(result.edges).toEqual([]);
+  });
+
+  /**
+   * テストケース 3: 線形依存 (task-1 → task-2 → task-3)
+   *
+   * グラフ構造:
+   *
+   *   [task-1] → [task-2] → [task-3]
+   *
+   * 依存関係:
+   * - task-2 depends_on task-1
+   * - task-3 depends_on task-2
+   */
+  test("returns linear dependency chain", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "running" },
+          { id: "task-3", status: "pending" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-2" },
+          { from: "task-2", to: "task-3" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(3);
+    expect(result.edges).toHaveLength(2);
+
+    // エッジの正確性を検証
+    expect(result.edges).toContainEqual({ from: "task-1", to: "task-2" });
+    expect(result.edges).toContainEqual({ from: "task-2", to: "task-3" });
+
+    // ステータスの検証
+    const task1 = result.nodes.find((n) => n.id === "task-1");
+    const task2 = result.nodes.find((n) => n.id === "task-2");
+    const task3 = result.nodes.find((n) => n.id === "task-3");
+
+    expect(task1?.status).toBe("completed");
+    expect(task2?.status).toBe("running");
+    expect(task3?.status).toBe("pending");
+  });
+
+  /**
+   * テストケース 4: 並列タスク (task-1, task-2 独立、両方が task-3 に依存される)
+   *
+   * グラフ構造:
+   *
+   *   [task-1] ─┐
+   *              ├→ [task-3]
+   *   [task-2] ─┘
+   *
+   * 依存関係:
+   * - task-3 depends_on [task-1, task-2]
+   */
+  test("returns parallel tasks converging into single task", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "completed" },
+          { id: "task-3", status: "running" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-3" },
+          { from: "task-2", to: "task-3" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(3);
+    expect(result.edges).toHaveLength(2);
+
+    // task-3 は task-1 と task-2 両方に依存
+    const edgesToTask3 = result.edges.filter((e) => e.to === "task-3");
+    expect(edgesToTask3).toHaveLength(2);
+
+    expect(edgesToTask3).toContainEqual({ from: "task-1", to: "task-3" });
+    expect(edgesToTask3).toContainEqual({ from: "task-2", to: "task-3" });
+
+    // task-1, task-2 は並列実行可能 (互いに依存しない)
+    const edgesBetween1And2 = result.edges.filter(
+      (e) =>
+        (e.from === "task-1" && e.to === "task-2") ||
+        (e.from === "task-2" && e.to === "task-1")
+    );
+    expect(edgesBetween1And2).toHaveLength(0);
+  });
+
+  /**
+   * テストケース 5: ダイヤモンド依存 (task-1 → task-2,3 → task-4)
+   *
+   * グラフ構造:
+   *
+   *          [task-1]
+   *           ↙   ↘
+   *    [task-2]   [task-3]
+   *           ↘   ↙
+   *          [task-4]
+   *
+   * 依存関係:
+   * - task-2 depends_on task-1
+   * - task-3 depends_on task-1
+   * - task-4 depends_on [task-2, task-3]
+   */
+  test("returns diamond dependency graph", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "running" },
+          { id: "task-3", status: "running" },
+          { id: "task-4", status: "pending" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-2" },
+          { from: "task-1", to: "task-3" },
+          { from: "task-2", to: "task-4" },
+          { from: "task-3", to: "task-4" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(4);
+    expect(result.edges).toHaveLength(4);
+
+    // task-1 は task-2, task-3 に分岐
+    const edgesFromTask1 = result.edges.filter((e) => e.from === "task-1");
+    expect(edgesFromTask1).toHaveLength(2);
+    expect(edgesFromTask1).toContainEqual({ from: "task-1", to: "task-2" });
+    expect(edgesFromTask1).toContainEqual({ from: "task-1", to: "task-3" });
+
+    // task-4 は task-2, task-3 からマージ
+    const edgesToTask4 = result.edges.filter((e) => e.to === "task-4");
+    expect(edgesToTask4).toHaveLength(2);
+    expect(edgesToTask4).toContainEqual({ from: "task-2", to: "task-4" });
+    expect(edgesToTask4).toContainEqual({ from: "task-3", to: "task-4" });
+
+    // ステータス検証: task-1完了、task-2/3実行中、task-4保留
+    expect(result.nodes.find((n) => n.id === "task-1")?.status).toBe("completed");
+    expect(result.nodes.find((n) => n.id === "task-2")?.status).toBe("running");
+    expect(result.nodes.find((n) => n.id === "task-3")?.status).toBe("running");
+    expect(result.nodes.find((n) => n.id === "task-4")?.status).toBe("pending");
+  });
+
+  /**
+   * テストケース 6: 複雑なグラフ (多段階並列依存)
+   *
+   * グラフ構造:
+   *
+   *   [task-1] → [task-2] ─┐
+   *                         ├→ [task-5]
+   *   [task-3] → [task-4] ─┘
+   *
+   * 依存関係:
+   * - task-2 depends_on task-1
+   * - task-4 depends_on task-3
+   * - task-5 depends_on [task-2, task-4]
+   */
+  test("returns complex multi-level parallel graph", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "completed" },
+          { id: "task-3", status: "completed" },
+          { id: "task-4", status: "running" },
+          { id: "task-5", status: "pending" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-2" },
+          { from: "task-3", to: "task-4" },
+          { from: "task-2", to: "task-5" },
+          { from: "task-4", to: "task-5" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(5);
+    expect(result.edges).toHaveLength(4);
+
+    // task-1, task-3 は並列実行可能な起点
+    const rootTasks = result.nodes.filter(
+      (node) => !result.edges.some((edge) => edge.to === node.id)
+    );
+    expect(rootTasks).toHaveLength(2);
+    expect(rootTasks.map((t) => t.id).sort()).toEqual(["task-1", "task-3"]);
+
+    // task-5 は最終的な合流点
+    const edgesToTask5 = result.edges.filter((e) => e.to === "task-5");
+    expect(edgesToTask5).toHaveLength(2);
+  });
+
+  /**
+   * テストケース 7: タスクステータスのバリエーション検証
+   *
+   * 全ステータス (pending, running, completed, failed) を含むグラフ
+   */
+  test("returns graph with all task status types", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "running" },
+          { id: "task-3", status: "pending" },
+          { id: "task-4", status: "failed" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-2" },
+          { from: "task-1", to: "task-4" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(4);
+
+    const statuses = result.nodes.map((n) => n.status).sort();
+    expect(statuses).toEqual(["completed", "failed", "pending", "running"]);
+
+    // 各ステータスのノードが存在することを確認
+    expect(result.nodes.some((n) => n.status === "completed")).toBe(true);
+    expect(result.nodes.some((n) => n.status === "running")).toBe(true);
+    expect(result.nodes.some((n) => n.status === "pending")).toBe(true);
+    expect(result.nodes.some((n) => n.status === "failed")).toBe(true);
+  });
+
+  /**
+   * テストケース 8: グラフ構造の整合性検証
+   *
+   * - 全エッジの from/to が nodes に存在することを確認
+   * - 自己参照エッジがないことを確認
+   */
+  test("validates graph structure integrity", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "running" },
+          { id: "task-3", status: "pending" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-2" },
+          { from: "task-2", to: "task-3" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    const nodeIds = new Set(result.nodes.map((n) => n.id));
+
+    // 全エッジの from/to が nodes に存在
+    for (const edge of result.edges) {
+      expect(nodeIds.has(edge.from)).toBe(true);
+      expect(nodeIds.has(edge.to)).toBe(true);
+    }
+
+    // 自己参照エッジがない
+    const selfReferentialEdges = result.edges.filter((e) => e.from === e.to);
+    expect(selfReferentialEdges).toHaveLength(0);
+  });
+});