@ronkovic/aad 0.3.9 → 0.4.0

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

@@ -248,6 +248,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);
 
@@ -369,10 +376,52 @@ 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;
+    }
+  }
 }

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

@@ -0,0 +1,176 @@
+/**
+ * Prerequisites Tests
+ * Verifies prerequisite checks for AAD pipeline
+ */
+
+import { describe, test, expect, beforeEach } from "bun:test";
+import { checkPrerequisites } from "../prerequisites";
+import { pino } from "pino";
+
+describe("checkPrerequisites", () => {
+  let logger: import("pino").Logger;
+
+  beforeEach(() => {
+    logger = pino({ level: "silent" });
+  });
+
+  test("runs all prerequisite checks", async () => {
+    const result = await checkPrerequisites(logger);
+
+    expect(result).toBeDefined();
+    expect(result.passed).toBeDefined();
+    expect(Array.isArray(result.failures)).toBe(true);
+    expect(Array.isArray(result.warnings)).toBe(true);
+  });
+
+  test("passes if all required checks pass with ANTHROPIC_API_KEY", async () => {
+    // In a git repo with ANTHROPIC_API_KEY set, all required checks should pass
+    // This test assumes we're running in a valid git repo
+    const originalKey = process.env.ANTHROPIC_API_KEY;
+    const originalOAuth = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    process.env.ANTHROPIC_API_KEY = "test-key";
+    delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
+
+    try {
+      const result = await checkPrerequisites(logger);
+
+      // Git, git-version, git-repo, and claude-auth should all pass
+      // If we're in a git repo, failures should be 0
+      // If not (e.g., running in a worktree without git), we skip this assertion
+      if (result.passed) {
+        expect(result.failures.length).toBe(0);
+        expect(result.passed).toBe(true);
+      } else {
+        // We're likely in a non-git environment or worktree - just verify structure
+        expect(result.failures).toBeDefined();
+        expect(result.warnings).toBeDefined();
+      }
+    } finally {
+      if (originalKey) {
+        process.env.ANTHROPIC_API_KEY = originalKey;
+      } else {
+        delete process.env.ANTHROPIC_API_KEY;
+      }
+      if (originalOAuth) {
+        process.env.CLAUDE_CODE_OAUTH_TOKEN = originalOAuth;
+      } else {
+        delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
+      }
+    }
+  });
+
+  test("passes if CLAUDE_CODE_OAUTH_TOKEN is set", async () => {
+    const originalKey = process.env.ANTHROPIC_API_KEY;
+    const originalOAuth = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    delete process.env.ANTHROPIC_API_KEY;
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = "test-oauth-token";
+
+    try {
+      const result = await checkPrerequisites(logger);
+
+      // Should pass auth check with OAuth token
+      const authFailure = result.failures.find((f) => f.name === "claude-auth");
+      expect(authFailure).toBeUndefined();
+    } finally {
+      if (originalKey) {
+        process.env.ANTHROPIC_API_KEY = originalKey;
+      } else {
+        delete process.env.ANTHROPIC_API_KEY;
+      }
+      if (originalOAuth) {
+        process.env.CLAUDE_CODE_OAUTH_TOKEN = originalOAuth;
+      } else {
+        delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
+      }
+    }
+  });
+
+  test("passes if both ANTHROPIC_API_KEY and CLAUDE_CODE_OAUTH_TOKEN are set", async () => {
+    const originalKey = process.env.ANTHROPIC_API_KEY;
+    const originalOAuth = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    process.env.ANTHROPIC_API_KEY = "test-key";
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = "test-oauth-token";
+
+    try {
+      const result = await checkPrerequisites(logger);
+
+      // Should pass auth check with both set
+      const authFailure = result.failures.find((f) => f.name === "claude-auth");
+      expect(authFailure).toBeUndefined();
+    } finally {
+      if (originalKey) {
+        process.env.ANTHROPIC_API_KEY = originalKey;
+      } else {
+        delete process.env.ANTHROPIC_API_KEY;
+      }
+      if (originalOAuth) {
+        process.env.CLAUDE_CODE_OAUTH_TOKEN = originalOAuth;
+      } else {
+        delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
+      }
+    }
+  });
+
+  test("fails if neither ANTHROPIC_API_KEY nor CLAUDE_CODE_OAUTH_TOKEN is set", async () => {
+    const originalKey = process.env.ANTHROPIC_API_KEY;
+    const originalOAuth = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
+
+    try {
+      const result = await checkPrerequisites(logger);
+
+      expect(result.passed).toBe(false);
+      expect(result.failures.some((f) => f.name === "claude-auth")).toBe(true);
+    } finally {
+      if (originalKey) {
+        process.env.ANTHROPIC_API_KEY = originalKey;
+      }
+      if (originalOAuth) {
+        process.env.CLAUDE_CODE_OAUTH_TOKEN = originalOAuth;
+      }
+    }
+  });
+
+  test("includes warnings for non-required checks", async () => {
+    const originalKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = "test-key";
+
+    try {
+      const result = await checkPrerequisites(logger);
+
+      // Clean working directory is optional, may appear in warnings
+      // (depends on current git state)
+      expect(result.warnings).toBeDefined();
+    } finally {
+      if (originalKey) {
+        process.env.ANTHROPIC_API_KEY = originalKey;
+      } else {
+        delete process.env.ANTHROPIC_API_KEY;
+      }
+    }
+  });
+
+  test("formats error messages properly", async () => {
+    const originalKey = process.env.ANTHROPIC_API_KEY;
+    const originalOAuth = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
+
+    try {
+      const result = await checkPrerequisites(logger);
+
+      const authFailure = result.failures.find((f) => f.name === "claude-auth");
+      expect(authFailure).toBeDefined();
+      expect(authFailure?.message).toContain("ANTHROPIC_API_KEY");
+      expect(authFailure?.message).toContain("CLAUDE_CODE_OAUTH_TOKEN");
+    } finally {
+      if (originalKey) {
+        process.env.ANTHROPIC_API_KEY = originalKey;
+      }
+      if (originalOAuth) {
+        process.env.CLAUDE_CODE_OAUTH_TOKEN = originalOAuth;
+      }
+    }
+  });
+});

package/src/shared/config.ts

@@ -38,6 +38,9 @@ const configSchema = z.object({
     port: z.number().int().min(1).max(65535),
     host: z.string(),
   }),
+  git: z.object({
+    autoPush: z.boolean(),
+  }),
   repos: z.array(z.object({
     name: z.string().optional(),
     path: z.string(),
@@ -111,6 +114,9 @@ export function loadConfig(env: Record<string, string | undefined> = process.env
       port: parseIntOrDefault(env.AAD_DASHBOARD_PORT, 7333),
       host: env.AAD_DASHBOARD_HOST ?? "localhost",
     },
+    git: {
+      autoPush: parseBoolOrDefault(env.AAD_GIT_AUTO_PUSH, true),
+    },
     repos: env.AAD_REPOS
       ? env.AAD_REPOS.split(",").map((p) => ({ path: p.trim() }))
       : undefined,

package/src/shared/prerequisites.ts

@@ -0,0 +1,190 @@
+/**
+ * Prerequisites Checker
+ * Verifies required tools and environment before running AAD pipeline
+ */
+
+import type { Logger } from "pino";
+
+export interface PrerequisiteCheck {
+  name: string;
+  required: boolean;
+  check: () => Promise<boolean>;
+  errorMessage: string;
+}
+
+export interface PrerequisiteResult {
+  passed: boolean;
+  failures: Array<{ name: string; message: string }>;
+  warnings: Array<{ name: string; message: string }>;
+}
+
+/**
+ * Check if a command exists in PATH
+ */
+async function commandExists(command: string): Promise<boolean> {
+  try {
+    const proc = Bun.spawn(["which", command], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await proc.exited;
+    return proc.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check git version (requires >= 2.25 for worktree improvements)
+ */
+async function checkGitVersion(): Promise<boolean> {
+  try {
+    const proc = Bun.spawn(["git", "--version"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const output = await new Response(proc.stdout).text();
+    await proc.exited;
+
+    if (proc.exitCode !== 0) return false;
+
+    // Parse version from "git version 2.39.1"
+    const match = output.match(/git version (\d+)\.(\d+)/);
+    if (!match?.[1] || !match[2]) return false;
+
+    const major = parseInt(match[1], 10);
+    const minor = parseInt(match[2], 10);
+
+    return major > 2 || (major === 2 && minor >= 25);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if git repository is initialized
+ */
+async function checkGitRepo(): Promise<boolean> {
+  try {
+    const proc = Bun.spawn(["git", "rev-parse", "--is-inside-work-tree"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await proc.exited;
+    return proc.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if Claude authentication is configured
+ * Accepts either ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN
+ */
+function checkClaudeAuth(): Promise<boolean> {
+  return Promise.resolve(
+    !!process.env.ANTHROPIC_API_KEY || !!process.env.CLAUDE_CODE_OAUTH_TOKEN
+  );
+}
+
+/**
+ * Check if working directory is clean (no uncommitted changes)
+ */
+async function checkCleanWorkingDirectory(): Promise<boolean> {
+  try {
+    const proc = Bun.spawn(["git", "status", "--porcelain"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const output = await new Response(proc.stdout).text();
+    await proc.exited;
+
+    if (proc.exitCode !== 0) return false;
+
+    // Empty output means clean working directory
+    return output.trim().length === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Define all prerequisite checks
+ */
+function defineChecks(): PrerequisiteCheck[] {
+  return [
+    {
+      name: "git",
+      required: true,
+      check: () => commandExists("git"),
+      errorMessage: "git is not installed. Please install git to use AAD.",
+    },
+    {
+      name: "git-version",
+      required: true,
+      check: checkGitVersion,
+      errorMessage: "git version must be >= 2.25 for worktree support.",
+    },
+    {
+      name: "git-repo",
+      required: true,
+      check: checkGitRepo,
+      errorMessage: "Current directory is not a git repository. Run 'git init' first.",
+    },
+    {
+      name: "claude-auth",
+      required: true,
+      check: checkClaudeAuth,
+      errorMessage: "No authentication configured. Set ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN.",
+    },
+    {
+      name: "clean-working-directory",
+      required: false,
+      check: checkCleanWorkingDirectory,
+      errorMessage: "Working directory has uncommitted changes. Commit or stash them before running AAD.",
+    },
+  ];
+}
+
+/**
+ * Run all prerequisite checks
+ */
+export async function checkPrerequisites(logger?: Logger): Promise<PrerequisiteResult> {
+  logger?.debug("Running prerequisite checks");
+
+  const checks = defineChecks();
+  const failures: Array<{ name: string; message: string }> = [];
+  const warnings: Array<{ name: string; message: string }> = [];
+
+  for (const check of checks) {
+    try {
+      const passed = await check.check();
+
+      if (!passed) {
+        if (check.required) {
+          failures.push({ name: check.name, message: check.errorMessage });
+          logger?.error({ check: check.name }, check.errorMessage);
+        } else {
+          warnings.push({ name: check.name, message: check.errorMessage });
+          logger?.warn({ check: check.name }, check.errorMessage);
+        }
+      } else {
+        logger?.debug({ check: check.name }, "Prerequisite check passed");
+      }
+    } catch (error) {
+      const errorMessage = `Failed to check ${check.name}: ${error}`;
+      if (check.required) {
+        failures.push({ name: check.name, message: errorMessage });
+        logger?.error({ check: check.name, error }, errorMessage);
+      } else {
+        warnings.push({ name: check.name, message: errorMessage });
+        logger?.warn({ check: check.name, error }, errorMessage);
+      }
+    }
+  }
+
+  const passed = failures.length === 0;
+  logger?.info({ passed, failures: failures.length, warnings: warnings.length }, "Prerequisites check completed");
+
+  return { passed, failures, warnings };
+}

package/src/shared/types.ts

@@ -83,6 +83,7 @@ export interface Task {
   endTime?: string;
   retryCount: number;
   failureReason?: string;
+  previousFailure?: PreviousFailure;
   repoName?: RepoName;
 }
 
@@ -129,6 +130,8 @@ export type TestFramework =
   | "cargo"
   | "maven"
   | "gradle"
+  | "playwright"
+  | "terraform"
   | "unknown";
 
 // Workspace Info (from project detection)
@@ -150,3 +153,13 @@ export interface PhaseResult {
   output: string;
   duration?: number;
 }
+
+/**
+ * Previous failure information for retry context
+ */
+export interface PreviousFailure {
+  phase: string;
+  error: string;
+  testOutput?: string;
+  retryCount: number;
+}