@ronkovic/aad 0.4.0 → 0.5.1

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);
       }
     });
@@ -337,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"
         );
       }
     }
@@ -424,4 +438,34 @@ export class Dispatcher {
       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);
+  });
 });

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__/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(),
@@ -101,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),

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/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
@@ -110,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;

package/src/modules/claude-provider/__tests__/claude-sdk-real-env.test.ts

@@ -1,127 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { ClaudeSdkAdapter } from "../claude-sdk.adapter";
-import { loadConfig } from "../../../shared/config";
-import pino from "pino";
-import { ClaudeProviderError } from "../../../shared/errors";
-
-/**
- * 実環境バリデーションテスト
- * ANTHROPIC_API_KEY または CLAUDE_CODE_OAUTH_TOKEN が設定されている場合のみ実行
- */
-
-const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
-const hasOAuth = !!process.env.CLAUDE_CODE_OAUTH_TOKEN;
-const hasAuth = hasApiKey || hasOAuth;
-
-const logger = pino({ level: "silent" });
-
-function createAdapter() {
-  const config = loadConfig();
-  return new ClaudeSdkAdapter(config, logger);
-}
-
-describe.skipIf(!hasAuth)("ClaudeSdkAdapter - Real Environment", () => {
-  test("simple query returns valid response", async () => {
-    const adapter = createAdapter();
-    const response = await adapter.call({
-      prompt: "Reply with exactly: PING",
-    });
-
-    expect(response.result).toBeDefined();
-    expect(response.result.length).toBeGreaterThan(0);
-    expect(response.exitCode).toBe(0);
-    expect(response.model).toBeDefined();
-    expect(response.duration).toBeGreaterThan(0);
-  }, 30_000);
-
-  test("detects authentication method", () => {
-    if (hasApiKey) {
-      expect(process.env.ANTHROPIC_API_KEY).toBeDefined();
-      console.log("Auth: ANTHROPIC_API_KEY");
-    }
-    if (hasOAuth) {
-      expect(process.env.CLAUDE_CODE_OAUTH_TOKEN).toBeDefined();
-      console.log("Auth: CLAUDE_CODE_OAUTH_TOKEN");
-    }
-  });
-
-  test("throws ClaudeProviderError on invalid auth", async () => {
-    const originalKey = process.env.ANTHROPIC_API_KEY;
-    const originalOAuth = process.env.CLAUDE_CODE_OAUTH_TOKEN;
-
-    try {
-      // 無効な認証情報に差し替え
-      process.env.ANTHROPIC_API_KEY = "sk-ant-invalid-key-for-testing";
-      delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
-
-      const adapter = createAdapter();
-      await expect(
-        adapter.call({ prompt: "test" })
-      ).rejects.toThrow(ClaudeProviderError);
-    } 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;
-    }
-  }, 15_000);
-
-  test("respects timeout/abort", async () => {
-    const adapter = createAdapter();
-
-    await expect(
-      adapter.call({
-        prompt: "Write a very long essay about the history of computing.",
-        timeout: 100, // 100ms — 即タイムアウト
-      })
-    ).rejects.toThrow();
-  }, 10_000);
-
-  test("passes effort level correctly", async () => {
-    const adapter = createAdapter();
-    const response = await adapter.call({
-      prompt: "Reply with exactly: OK",
-      effortLevel: "low",
-    });
-
-    expect(response.result).toBeDefined();
-    expect(response.exitCode).toBe(0);
-    expect(response.effortLevel).toBe("low");
-  }, 30_000);
-
-  test("respects model override", async () => {
-    const adapter = createAdapter();
-    const response = await adapter.call({
-      prompt: "Reply with exactly: HI",
-      model: "claude-haiku-4-5-20251001",
-    });
-
-    expect(response.result).toBeDefined();
-    expect(response.exitCode).toBe(0);
-    // model名はSDKが返す値に依存するが、haiku系であることを確認
-    expect(response.model).toContain("haiku");
-  }, 30_000);
-});
-
-describe.skipIf(!hasOAuth)("ClaudeSdkAdapter - OAuth Authentication", () => {
-  test("authenticates with CLAUDE_CODE_OAUTH_TOKEN", async () => {
-    const originalKey = process.env.ANTHROPIC_API_KEY;
-
-    try {
-      // API Keyを一時的に除外してOAuthのみで認証
-      delete process.env.ANTHROPIC_API_KEY;
-
-      const adapter = createAdapter();
-      const response = await adapter.call({
-        prompt: "Reply with exactly: OAUTH_OK",
-      });
-
-      expect(response.result).toBeDefined();
-      expect(response.exitCode).toBe(0);
-    } finally {
-      if (originalKey) process.env.ANTHROPIC_API_KEY = originalKey;
-      else delete process.env.ANTHROPIC_API_KEY;
-    }
-  }, 30_000);
-});