@ronkovic/aad 0.3.9 → 0.5.0

package/src/modules/task-execution/executor.ts

@@ -3,6 +3,7 @@ import type {
   WorkspaceInfo,
   RunId,
   TaskExecutionResult,
+  PreviousFailure,
 } from "@aad/shared/types";
 import type { Config } from "@aad/shared/config";
 import type { ClaudeProvider } from "@aad/claude-provider";
@@ -19,9 +20,30 @@ import { runReviewer } from "./phases/reviewer";
 import { runMergePhase } from "./phases/merge";
 import { PhaseError } from "@aad/shared/errors";
 
+/**
+ * Retry context for TDD pipeline execution
+ */
+export interface RetryContext {
+  retryCount: number;
+  previousFailure?: PreviousFailure;
+}
+
+/**
+ * Run pre-check to see if tests already pass
+ */
+async function runPreCheck(
+  workspace: WorkspaceInfo,
+  testSpawner: ProcessSpawner | undefined,
+  timeout: number
+): Promise<boolean> {
+  const result = await runTests(workspace, testSpawner, timeout);
+  return result.success;
+}
+
 /**
  * Execute full TDD pipeline for a task
  * Phases: Red → Green → Verify → Review → Merge
+ * Optionally skips pipeline if tests already pass (pre-check)
  */
 export async function executeTddPipeline(
   task: Task,
@@ -34,11 +56,74 @@ export async function executeTddPipeline(
   provider: ClaudeProvider,
   mergeService: MergeService,
   eventBus: EventBus,
-  testSpawner?: ProcessSpawner
+  testSpawner?: ProcessSpawner,
+  retryContext?: RetryContext
 ): Promise<TaskExecutionResult> {
   const startTime = Date.now();
 
   try {
+    // ===== Pre-check: Skip if tests already pass (unless strictTdd) =====
+    if (config.skipCompleted && !config.strictTdd) {
+      eventBus.emit({
+        type: "log:entry",
+        entry: {
+          level: "info",
+          service: "task-execution",
+          message: "Running pre-check to see if tests already pass",
+          timestamp: Date.now(),
+          taskId: task.taskId as string,
+        },
+      });
+
+      const testsAlreadyPass = await runPreCheck(
+        workspace,
+        testSpawner,
+        config.timeouts.test * 1000
+      );
+
+      if (testsAlreadyPass) {
+        const duration = Date.now() - startTime;
+
+        eventBus.emit({
+          type: "execution:skipped",
+          taskId: task.taskId,
+          reason: "Tests already pass",
+        });
+
+        eventBus.emit({
+          type: "log:entry",
+          entry: {
+            level: "info",
+            service: "task-execution",
+            message: "Tests already pass, skipping TDD pipeline",
+            timestamp: Date.now(),
+            taskId: task.taskId as string,
+            duration,
+          },
+        });
+
+        return {
+          taskId: task.taskId,
+          status: "completed",
+          duration,
+          output: "Skipped: tests already pass",
+          skipped: true,
+          phasesExecuted: ["pre-check"],
+        };
+      }
+
+      eventBus.emit({
+        type: "log:entry",
+        entry: {
+          level: "info",
+          service: "task-execution",
+          message: "Pre-check failed, running full TDD pipeline",
+          timestamp: Date.now(),
+          taskId: task.taskId as string,
+        },
+      });
+    }
+
     // Estimate task complexity for adaptive effort
     const complexity = estimateTaskComplexity(task);
     const testerEffort = getAdaptiveEffortLevel("tester", complexity, config);
@@ -74,7 +159,7 @@ export async function executeTddPipeline(
       effortLevel: testerEffort,
       model: config.models.tester,
       timeout: config.timeouts.claude * 1000,
-    });
+    }, retryContext);
 
     if (!redResult.success) {
       eventBus.emit({
@@ -98,6 +183,33 @@ export async function executeTddPipeline(
       duration: Date.now() - redStart,
     });
 
+    // ===== Commit failing tests =====
+    try {
+      await gitExec(["add", "-A"], { cwd: workspace.path });
+      try {
+        await gitExec(["reset", "HEAD", "--", ".claude/"], { cwd: workspace.path });
+      } catch {
+        // .claude/ がない場合は無視
+      }
+      await gitExec(
+        ["commit", "--no-gpg-sign", "-m", `test: Add failing tests for ${task.title}`],
+        { cwd: workspace.path }
+      );
+    } catch (commitError) {
+      // If commit fails (e.g., no changes), log but don't fail the pipeline
+      eventBus.emit({
+        type: "log:entry",
+        entry: {
+          level: "warn",
+          service: "task-execution",
+          message: "Commit after Red phase failed (no changes?)",
+          timestamp: Date.now(),
+          taskId: task.taskId as string,
+          error: String(commitError),
+        },
+      });
+    }
+
     // ===== Phase 2: Green - Implement minimal code =====
     eventBus.emit({
       type: "execution:phase:started",
@@ -110,7 +222,7 @@ export async function executeTddPipeline(
       effortLevel: implementerEffort,
       model: config.models.implementer,
       timeout: config.timeouts.claude * 1000,
-    });
+    }, retryContext);
 
     if (!greenResult.success) {
       eventBus.emit({
@@ -138,13 +250,29 @@ export async function executeTddPipeline(
     // Commit changes after Green phase so they can be merged later
     try {
       await gitExec(["add", "-A"], { cwd: workspace.path });
+      try {
+        await gitExec(["reset", "HEAD", "--", ".claude/"], { cwd: workspace.path });
+      } catch {
+        // .claude/ がない場合は無視
+      }
       await gitExec(
         ["commit", "--no-gpg-sign", "-m", `feat: Implement ${task.title}`],
         { cwd: workspace.path }
       );
-    } catch (_error) {
+    } catch (commitError) {
       // If commit fails (e.g., no changes), log but don't fail the pipeline
       // This can happen if Claude didn't generate any new files
+      eventBus.emit({
+        type: "log:entry",
+        entry: {
+          level: "warn",
+          service: "task-execution",
+          message: "Commit after Green phase failed (no changes?)",
+          timestamp: Date.now(),
+          taskId: task.taskId as string,
+          error: String(commitError),
+        },
+      });
     }
 
     // ===== Phase 3: Verify - Run tests =====
@@ -221,6 +349,36 @@ export async function executeTddPipeline(
       });
     }
 
+    // ===== Commit review changes (if any) =====
+    try {
+      const statusResult = await gitExec(["status", "--porcelain"], { cwd: workspace.path });
+      if (statusResult.stdout.trim() !== "") {
+        await gitExec(["add", "-A"], { cwd: workspace.path });
+        try {
+          await gitExec(["reset", "HEAD", "--", ".claude/"], { cwd: workspace.path });
+        } catch {
+          // .claude/ がない場合は無視
+        }
+        await gitExec(
+          ["commit", "--no-gpg-sign", "-m", `refactor: Apply review feedback for ${task.title}`],
+          { cwd: workspace.path }
+        );
+      }
+    } catch (commitError) {
+      // If commit fails, log but don't fail the pipeline
+      eventBus.emit({
+        type: "log:entry",
+        entry: {
+          level: "warn",
+          service: "task-execution",
+          message: "Commit after Review phase failed",
+          timestamp: Date.now(),
+          taskId: task.taskId as string,
+          error: String(commitError),
+        },
+      });
+    }
+
     // ===== Phase 5: Merge - Merge to parent branch =====
     eventBus.emit({
       type: "execution:phase:started",
@@ -282,6 +440,7 @@ export async function executeTddPipeline(
       status: "completed",
       duration,
       output: "TDD pipeline completed successfully",
+      phasesExecuted: ["red", "green", "verify", "review", "merge"],
     };
   } catch (error) {
     const duration = Date.now() - startTime;

package/src/modules/task-execution/phases/implementer-green.ts

@@ -1,5 +1,6 @@
 import type { Task, WorkspaceInfo, EffortLevel, PhaseResult } from "@aad/shared/types";
 import type { ClaudeProvider } from "@aad/claude-provider";
+import type { RetryContext } from "../executor";
 
 export interface ImplementerGreenOptions {
   effortLevel?: EffortLevel;
@@ -10,10 +11,10 @@ export interface ImplementerGreenOptions {
 /**
  * Build TDD Green phase prompt for implementer agent
  */
-export function buildGreenPhasePrompt(task: Task, workspace: WorkspaceInfo): string {
+export function buildGreenPhasePrompt(task: Task, workspace: WorkspaceInfo, retryContext?: RetryContext): string {
   const codingConventions = getCodingConventions(workspace.language);
 
-  return `implementerエージェントとして、TDD Green フェーズを実行してください。
+  let prompt = `implementerエージェントとして、TDD Green フェーズを実行してください。
 
 Task ID: ${task.taskId as string}
 Task Title: ${task.title}
@@ -28,10 +29,25 @@ Task Description: ${task.description}
 
 実行内容:
 1. 作成されたテストを確認する
-2. テストをパスするための最小限の実装を書く（${codingConventions}）
+2. テストをパスするための最小限の実装を書く(${codingConventions})
 3. テストを実行してパスすることを確認する
 
 注意: 過度な最適化やリファクタリングは行わず、テストをパスするための最小限のコードを書いてください。`;
+
+  if (retryContext?.previousFailure) {
+    prompt += `\n\n⚠️ リトライ情報 (${retryContext.retryCount}回目):
+前回のフェーズ「${retryContext.previousFailure.phase}」で失敗しました。
+エラー: ${retryContext.previousFailure.error}`;
+
+    if (retryContext.previousFailure.testOutput) {
+      prompt += `\n\n前回のテスト出力:
+${retryContext.previousFailure.testOutput}`;
+    }
+
+    prompt += `\n\n前回の失敗パターンを特に注意して実装してください。`;
+  }
+
+  return prompt;
 }
 
 /**
@@ -72,9 +88,10 @@ export async function runImplementerGreen(
   task: Task,
   workspace: WorkspaceInfo,
   provider: ClaudeProvider,
-  options: ImplementerGreenOptions = {}
+  options: ImplementerGreenOptions = {},
+  retryContext?: RetryContext
 ): Promise<PhaseResult> {
-  const prompt = buildGreenPhasePrompt(task, workspace);
+  const prompt = buildGreenPhasePrompt(task, workspace, retryContext);
 
   const response = await provider.call({
     prompt,

package/src/modules/task-execution/phases/merge.ts

@@ -78,7 +78,7 @@ export async function runMergePhase(
   }
 
   // Merge failed with conflicts
-  const conflicts = mergeResult.conflicts ?? [];
+  let conflicts = mergeResult.conflicts ?? [];
 
   if (conflicts.length === 0) {
     // Merge failed but no conflicts detected (unexpected error)
@@ -90,7 +90,49 @@ export async function runMergePhase(
     };
   }
 
-  // Resolve conflicts with Claude
+  // Auto-resolve generated files (lockfiles, snapshots)
+  const AUTO_RESOLVE_PATTERNS = [
+    "package-lock.json",
+    "yarn.lock",
+    "bun.lockb",
+    "pnpm-lock.yaml",
+    "go.sum",
+    "Cargo.lock",
+    ".snap",
+  ];
+
+  const autoResolved: string[] = [];
+  for (const conflict of conflicts) {
+    if (AUTO_RESOLVE_PATTERNS.some((pattern) => conflict.includes(pattern))) {
+      try {
+        await gitExec(["checkout", "--theirs", conflict], { cwd: parentWorktree });
+        await gitExec(["add", conflict], { cwd: parentWorktree });
+        autoResolved.push(conflict);
+      } catch (_resolveError) {
+        // If auto-resolve fails, leave it for Claude
+      }
+    }
+  }
+
+  // Remove auto-resolved conflicts from list
+  conflicts = conflicts.filter((c) => !autoResolved.includes(c));
+
+  // If all conflicts are auto-resolved, complete merge
+  if (conflicts.length === 0) {
+    try {
+      await gitExec(["commit", "--no-gpg-sign", "--no-edit"], { cwd: parentWorktree });
+      return {
+        success: true,
+        output: `Auto-resolved conflicts: ${autoResolved.join(", ")}`,
+        hadConflict: true,
+        duration: Date.now() - startTime,
+      };
+    } catch (_commitError) {
+      // Commit failed, fall through to Claude resolution
+    }
+  }
+
+  // Resolve remaining conflicts with Claude
   const prompt = buildConflictResolutionPrompt(task, conflicts);
 
   const response = await provider.call({

package/src/modules/task-execution/phases/tester-red.ts

@@ -1,5 +1,6 @@
 import type { Task, WorkspaceInfo, EffortLevel, PhaseResult } from "@aad/shared/types";
 import type { ClaudeProvider } from "@aad/claude-provider";
+import type { RetryContext } from "../executor";
 
 export interface TesterRedOptions {
   effortLevel?: EffortLevel;
@@ -10,10 +11,10 @@ export interface TesterRedOptions {
 /**
  * Build TDD Red phase prompt for tester agent
  */
-export function buildRedPhasePrompt(task: Task, workspace: WorkspaceInfo): string {
+export function buildRedPhasePrompt(task: Task, workspace: WorkspaceInfo, retryContext?: RetryContext): string {
   const languagePatterns = getLanguageTestPatterns(workspace.language);
 
-  return `testerエージェントとして、TDD Red フェーズを実行してください。
+  let prompt = `testerエージェントとして、TDD Red フェーズを実行してください。
 
 Task ID: ${task.taskId as string}
 Task Title: ${task.title}
@@ -28,11 +29,26 @@ Task Description: ${task.description}
 
 実行内容:
 1. タスクの要件を理解する
-2. 失敗するテストを作成する（言語に応じた適切なパターンを使用）
+2. 失敗するテストを作成する(言語に応じた適切なパターンを使用)
    ${languagePatterns}
 3. テストを実行して失敗することを確認する
 
 注意: このフェーズでは実装コードは書かないでください。テストのみ作成してください。`;
+
+  if (retryContext?.previousFailure) {
+    prompt += `\n\n⚠️ リトライ情報 (${retryContext.retryCount}回目):
+前回のフェーズ「${retryContext.previousFailure.phase}」で失敗しました。
+エラー: ${retryContext.previousFailure.error}`;
+
+    if (retryContext.previousFailure.testOutput) {
+      prompt += `\n\n前回のテスト出力:
+${retryContext.previousFailure.testOutput}`;
+    }
+
+    prompt += `\n\n前回の失敗を踏まえて、より堅牢なテストを作成してください。`;
+  }
+
+  return prompt;
 }
 
 /**
@@ -72,9 +88,10 @@ export async function runTesterRed(
   task: Task,
   workspace: WorkspaceInfo,
   provider: ClaudeProvider,
-  options: TesterRedOptions = {}
+  options: TesterRedOptions = {},
+  retryContext?: RetryContext
 ): Promise<PhaseResult> {
-  const prompt = buildRedPhasePrompt(task, workspace);
+  const prompt = buildRedPhasePrompt(task, workspace, retryContext);
 
   const response = await provider.call({
     prompt,

package/src/modules/task-execution/phases/tester-verify.ts

@@ -48,8 +48,12 @@ export function buildTestCommand(workspace: WorkspaceInfo): string[] {
       if (packageManager === "yarn") return ["yarn", "test"];
       return ["npx", "mocha"];
 
-    case "pytest":
+    case "pytest": {
+      const { packageManager } = workspace;
+      if (packageManager === "uv") return ["uv", "run", "pytest", "-v"];
+      if (packageManager === "poetry") return ["poetry", "run", "pytest", "-v"];
       return ["pytest", "-v"];
+    }
 
     case "go-test":
       return ["go", "test", "./..."];
@@ -63,11 +67,23 @@ export function buildTestCommand(workspace: WorkspaceInfo): string[] {
     case "gradle":
       return ["./gradlew", "test"];
 
-    case "unknown":
-      throw new TestRunnerError(
-        "Unsupported test framework: unknown",
-        { testFramework }
-      );
+    case "playwright":
+      return ["npx", "playwright", "test"];
+
+    case "terraform":
+      return ["terraform", "validate"];
+
+    case "unknown": {
+      // Fallback: use package manager-based test command
+      const { packageManager } = workspace;
+      if (packageManager === "bun") return ["bun", "test"];
+      if (packageManager === "npm") return ["npm", "test"];
+      if (packageManager === "yarn") return ["yarn", "test"];
+      if (packageManager === "pnpm") return ["pnpm", "test"];
+      if (packageManager === "uv") return ["uv", "run", "pytest", "-v"];
+      if (packageManager === "poetry") return ["poetry", "run", "pytest", "-v"];
+      return ["npm", "test"];
+    }
 
     default: {
       const exhaustive: never = testFramework;

package/src/modules/task-queue/dispatcher.ts

@@ -53,6 +53,7 @@ export class Dispatcher {
   private taskMap: Map<string, Task> = new Map();
   private initialized = false;
   private runId?: import("@aad/shared/types").RunId;
+  private skippedCount = 0;
 
   constructor(deps: DispatcherDeps) {
     this.deps = deps;
@@ -112,6 +113,10 @@ export class Dispatcher {
     // Listen to task:completed events
     this.deps.eventBus.on("task:completed", (event) => {
       if (event.type === "task:completed") {
+        // Track skipped tasks
+        if (event.result.skipped) {
+          this.skippedCount++;
+        }
         void this.handleTaskCompleted(event.taskId);
       }
     });
@@ -248,6 +253,13 @@ export class Dispatcher {
       task.retryCount += 1;
       task.workerId = undefined;
       task.failureReason = error;
+      // Store structured failure context for retry
+      task.previousFailure = {
+        phase: this.extractPhaseFromError(error),
+        error: error,
+        testOutput: this.extractTestOutput(error),
+        retryCount: task.retryCount,
+      };
       await this.deps.taskStore.save(task);
       this.taskMap.set(taskId as string, task);
 
@@ -330,14 +342,23 @@ export class Dispatcher {
     // Emit run:completed if all tasks are done (FIX #1)
     if (progress.pending === 0 && progress.running === 0) {
       if (this.runId) {
+        const metrics = this.getRunMetrics();
+
         this.deps.eventBus.emit({
           type: "run:completed",
           runId: this.runId,
         });
 
         this.deps.logger.info(
-          { runId: this.runId, completed: progress.completed, failed: progress.failed },
-          "Run completed"
+          {
+            runId: this.runId,
+            completed: progress.completed,
+            failed: progress.failed,
+            skipped: metrics.skippedTasks,
+            totalDuration: metrics.totalDuration,
+            averageTaskDuration: Math.round(metrics.averageTaskDuration),
+          },
+          "Run completed with metrics"
         );
       }
     }
@@ -369,10 +390,82 @@ export class Dispatcher {
 
           this.deps.logger.warn(
             { taskId: task.taskId, elapsed },
-            "Stale task detected"
+            "Stale task detected, triggering retry"
+          );
+
+          // Trigger retry flow via handleTaskFailed
+          void this.handleTaskFailed(
+            task.taskId,
+            `Task stale (elapsed: ${elapsed}ms)`
           );
         }
       }
     }
   }
+
+  /**
+   * Extract phase name from error message
+   */
+  private extractPhaseFromError(error: string): string {
+    const lowerError = error.toLowerCase();
+    if (lowerError.includes("red phase")) return "red";
+    if (lowerError.includes("green phase")) return "green";
+    if (lowerError.includes("verify phase")) return "verify";
+    if (lowerError.includes("review phase")) return "review";
+    if (lowerError.includes("merge phase")) return "merge";
+    return "unknown";
+  }
+
+  /**
+   * Extract test output from error context (truncated to 2000 chars)
+   */
+  private extractTestOutput(error: string): string | undefined {
+    try {
+      // Try to parse JSON context from PhaseError
+      const jsonMatch = error.match(/\{.*\}/s);
+      if (!jsonMatch) return undefined;
+
+      const context = JSON.parse(jsonMatch[0]);
+      const output = context.output ?? context.error;
+      if (!output) return undefined;
+
+      // Truncate to 2000 chars
+      return output.length > 2000
+        ? output.substring(0, 2000) + "\n... (truncated)"
+        : output;
+    } catch {
+      // If parsing fails, return undefined
+      return undefined;
+    }
+  }
+
+  /**
+   * Calculate run metrics including skipped tasks
+   */
+  getRunMetrics(): import("@aad/shared/types").RunMetrics {
+    const tasks = Array.from(this.taskMap.values());
+    const completedTasks = tasks.filter((t) => t.status === "completed");
+    const failedTasks = tasks.filter((t) => t.status === "failed");
+
+    const totalDuration = completedTasks.reduce((sum, task) => {
+      if (task.startTime && task.endTime) {
+        const start = new Date(task.startTime).getTime();
+        const end = new Date(task.endTime).getTime();
+        return sum + (end - start);
+      }
+      return sum;
+    }, 0);
+
+    const averageTaskDuration =
+      completedTasks.length > 0 ? totalDuration / completedTasks.length : 0;
+
+    return {
+      totalTasks: tasks.length,
+      completedTasks: completedTasks.length,
+      failedTasks: failedTasks.length,
+      skippedTasks: this.skippedCount,
+      totalDuration,
+      averageTaskDuration,
+    };
+  }
 }

package/src/shared/__tests__/config.test.ts

@@ -201,4 +201,34 @@ describe("loadConfig", () => {
     const config = loadConfig({});
     expect(config.plugins).toBeUndefined();
   });
+
+  test("loads skipCompleted from env (default true)", () => {
+    const config = loadConfig({});
+    expect(config.skipCompleted).toBe(true);
+  });
+
+  test("loads skipCompleted from env (explicit false)", () => {
+    const config = loadConfig({ AAD_SKIP_COMPLETED: "0" });
+    expect(config.skipCompleted).toBe(false);
+  });
+
+  test("loads skipCompleted from env (explicit true)", () => {
+    const config = loadConfig({ AAD_SKIP_COMPLETED: "1" });
+    expect(config.skipCompleted).toBe(true);
+  });
+
+  test("loads strictTdd from env (default false)", () => {
+    const config = loadConfig({});
+    expect(config.strictTdd).toBe(false);
+  });
+
+  test("loads strictTdd from env (explicit true)", () => {
+    const config = loadConfig({ AAD_STRICT_TDD: "1" });
+    expect(config.strictTdd).toBe(true);
+  });
+
+  test("loads strictTdd from env (explicit false)", () => {
+    const config = loadConfig({ AAD_STRICT_TDD: "0" });
+    expect(config.strictTdd).toBe(false);
+  });
 });