@ronkovic/aad 0.3.9 → 0.5.0

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

@@ -186,22 +186,31 @@ describe("EventBus", () => {
   test("listener exception does not affect other listeners", () => {
     let received: AADEvent | undefined;
 
-    eventBus.on("worker:idle", () => {
-      throw new Error("Listener error");
-    });
-
-    eventBus.on("worker:idle", (event) => {
-      received = event;
-    });
-
-    const event: AADEvent = {
-      type: "worker:idle",
-      workerId: createWorkerId("w1"),
-    };
-
-    eventBus.emit(event);
-
-    expect(received).toEqual(event);
+    // Mock console.error to suppress error output
+    const originalConsoleError = console.error;
+    console.error = () => {};
+
+    try {
+      eventBus.on("worker:idle", () => {
+        throw new Error("Listener error");
+      });
+
+      eventBus.on("worker:idle", (event) => {
+        received = event;
+      });
+
+      const event: AADEvent = {
+        type: "worker:idle",
+        workerId: createWorkerId("w1"),
+      };
+
+      eventBus.emit(event);
+
+      expect(received).toEqual(event);
+    } finally {
+      // Restore console.error
+      console.error = originalConsoleError;
+    }
   });
 
   test("emits wildcard * for all events", () => {
@@ -493,4 +502,21 @@ describe("EventBus", () => {
 
     expect(received).toEqual(event);
   });
+
+  test("emits and receives execution:skipped event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("execution:skipped", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "execution:skipped",
+      taskId: createTaskId("t1"),
+      reason: "Tests already pass",
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
 });

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/__tests__/shutdown-handler.test.ts

@@ -135,4 +135,100 @@ describe("shutdown-handler", () => {
     // exitFn called only once due to debounce
     expect(exitFn).toHaveBeenCalledTimes(1);
   });
+
+  test("displays resume command example when using fs persistence", async () => {
+    const tasks = [makeTask("t1", "running")];
+    const runState: RunState = {
+      runId,
+      parentBranch: "main",
+      totalTasks: 1,
+      pending: 0,
+      running: 1,
+      completed: 0,
+      failed: 0,
+      startTime: new Date().toISOString(),
+    };
+
+    const exitFn = mock(() => {});
+    const stores = createMockStores(tasks, runState);
+    const logger = createMockLogger();
+
+    // Capture console output
+    const consoleLogSpy = mock(() => {});
+    const originalLog = console.log;
+    console.log = consoleLogSpy;
+
+    try {
+      installShutdownHandler({
+        runId,
+        stores: { runStore: stores.runStore, taskStore: stores.taskStore },
+        logger,
+        exitFn,
+        persistMode: "fs",
+      });
+
+      // Simulate SIGINT
+      process.emit("SIGINT");
+
+      // Wait for async handler
+      await new Promise((r) => setTimeout(r, 50));
+
+      // Verify resume command was logged
+      const calls = (consoleLogSpy as any).mock.calls as string[][];
+      const resumeLog = calls.find((args) =>
+        args.some((arg) => typeof arg === "string" && arg.includes("aad resume"))
+      );
+      expect(resumeLog).toBeDefined();
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test("does not display resume command when using memory persistence", async () => {
+    const tasks = [makeTask("t1", "running")];
+    const runState: RunState = {
+      runId,
+      parentBranch: "main",
+      totalTasks: 1,
+      pending: 0,
+      running: 1,
+      completed: 0,
+      failed: 0,
+      startTime: new Date().toISOString(),
+    };
+
+    const exitFn = mock(() => {});
+    const stores = createMockStores(tasks, runState);
+    const logger = createMockLogger();
+
+    // Capture console output
+    const consoleLogSpy = mock(() => {});
+    const originalLog = console.log;
+    console.log = consoleLogSpy;
+
+    try {
+      installShutdownHandler({
+        runId,
+        stores: { runStore: stores.runStore, taskStore: stores.taskStore },
+        logger,
+        exitFn,
+        persistMode: "memory",
+      });
+
+      // Simulate SIGINT
+      process.emit("SIGINT");
+
+      // Wait for async handler
+      await new Promise((r) => setTimeout(r, 50));
+
+      // Verify resume command was NOT logged
+      const calls = (consoleLogSpy as any).mock.calls as string[][];
+      const resumeLog = calls.find((args) =>
+        args.some((arg) => typeof arg === "string" && arg.includes("aad resume"))
+      );
+      expect(resumeLog).toBeUndefined();
+    } finally {
+      console.log = originalLog;
+    }
+  });
 });

package/src/shared/config.ts

@@ -25,6 +25,8 @@ const configSchema = z.object({
   }),
   debug: z.boolean(),
   adaptiveEffort: z.boolean(),
+  skipCompleted: z.boolean(),
+  strictTdd: z.boolean(),
   teams: z.object({
     splitter: z.boolean(),
     reviewer: z.boolean(),
@@ -38,6 +40,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(),
@@ -98,6 +103,8 @@ export function loadConfig(env: Record<string, string | undefined> = process.env
     },
     debug: parseBoolOrDefault(env.DEBUG, false),
     adaptiveEffort: parseBoolOrDefault(env.AAD_ADAPTIVE_EFFORT, false),
+    skipCompleted: parseBoolOrDefault(env.AAD_SKIP_COMPLETED, true),
+    strictTdd: parseBoolOrDefault(env.AAD_STRICT_TDD, false),
     teams: {
       splitter: parseBoolOrDefault(env.AAD_USE_TEAMS_FOR_SPLITTER, false),
       reviewer: parseBoolOrDefault(env.AAD_USE_TEAMS_FOR_REVIEW, false),
@@ -111,6 +118,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/events.ts

@@ -122,6 +122,11 @@ export type AADEvent =
       type: "execution:merge:conflict";
       taskId: TaskId;
       conflictedFiles: string[];
+    }
+  | {
+      type: "execution:skipped";
+      taskId: TaskId;
+      reason: string;
     };
 
 export type EventType = AADEvent["type"] | "*";

package/src/shared/memory-check.ts

@@ -64,8 +64,8 @@ export async function getMemoryStatus(): Promise<MemoryStatus> {
   const purgablePages = parseInt(purgableMatch?.[1] ?? "0", 10);
 
   // Calculate memory in GB
-  const bytesToGB = (bytes: number) => bytes / (1024 * 1024 * 1024);
-  const pagesToGB = (pages: number) => bytesToGB(pages * pageSize);
+  const bytesToGB = (bytes: number): number => bytes / (1024 * 1024 * 1024);
+  const pagesToGB = (pages: number): number => bytesToGB(pages * pageSize);
 
   // Available = free + inactive + speculative + purgeable
   // macOS reclaims inactive/purgeable pages on demand — they are effectively free

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/shutdown-handler.ts

@@ -15,6 +15,7 @@ export interface ShutdownHandlerOptions {
   };
   logger: pino.Logger;
   exitFn?: (code: number) => void;
+  persistMode?: "memory" | "fs";
 }
 
 let _shuttingDown = false;
@@ -56,7 +57,7 @@ export function installShutdownHandler(options: ShutdownHandlerOptions): void {
   const { runId, stores, logger, exitFn = (code: number) => process.exit(code) } = options;
   let saving = false;
 
-  const handleShutdown = async (reason: string) => {
+  const handleShutdown = async (reason: string): Promise<void> => {
     const now = Date.now();
     // Debounce: ignore signals within 1s
     if (now - _lastSignalTime < 1000) return;
@@ -95,7 +96,13 @@ export function installShutdownHandler(options: ShutdownHandlerOptions): void {
         });
       }
 
-      logger.info({ runId, pending, completed, failed }, "State saved. Use --resume to continue.");
+      logger.info({ runId, pending, completed, failed }, "State saved.");
+
+      // Display resume command example when using fs persistence
+      if (options.persistMode === "fs") {
+        console.log(`\n⚠️  Run interrupted. To resume:\n`);
+        console.log(`  aad resume ${runId}\n`);
+      }
     } catch (err) {
       logger.error({ err }, "Failed to save state during shutdown");
     }
@@ -103,9 +110,9 @@ export function installShutdownHandler(options: ShutdownHandlerOptions): void {
     exitFn(1);
   };
 
-  const onSigterm = () => { void handleShutdown("SIGTERM"); };
-  const onSigint = () => { void handleShutdown("SIGINT"); };
-  const onUncaught = (err: Error) => { void handleShutdown(`uncaughtException: ${err.message}`); };
+  const onSigterm = (): void => { void handleShutdown("SIGTERM"); };
+  const onSigint = (): void => { void handleShutdown("SIGINT"); };
+  const onUncaught = (err: Error): void => { void handleShutdown(`uncaughtException: ${err.message}`); };
 
   process.on("SIGTERM", onSigterm);
   process.on("SIGINT", onSigint);

package/src/shared/types.ts

@@ -54,6 +54,8 @@ export interface TaskExecutionResult {
   duration: number;
   output?: string;
   error?: string;
+  skipped?: boolean;
+  phasesExecuted?: string[];
 }
 
 // RepoName branded type
@@ -83,6 +85,7 @@ export interface Task {
   endTime?: string;
   retryCount: number;
   failureReason?: string;
+  previousFailure?: PreviousFailure;
   repoName?: RepoName;
 }
 
@@ -109,6 +112,16 @@ export interface RunState {
   endTime?: string;
 }
 
+// Run Metrics
+export interface RunMetrics {
+  totalTasks: number;
+  completedTasks: number;
+  failedTasks: number;
+  skippedTasks: number;
+  totalDuration: number;
+  averageTaskDuration: number;
+}
+
 // Task Plan
 export interface TaskPlan {
   runId: RunId;
@@ -129,6 +142,8 @@ export type TestFramework =
   | "cargo"
   | "maven"
   | "gradle"
+  | "playwright"
+  | "terraform"
   | "unknown";
 
 // Workspace Info (from project detection)
@@ -150,3 +165,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;
+}