@ronkovic/aad 0.3.0

package/src/modules/claude-provider/__tests__/provider-registry.test.ts

@@ -0,0 +1,251 @@
+import { test, expect, describe, beforeEach } from "bun:test";
+import type pino from "pino";
+import type { ClaudeProvider } from "../claude-provider.port";
+import type { PhaseName } from "../../../shared/types";
+import type { ProviderType } from "../index";
+import { ProviderRegistry, createProviderRegistry, type ProviderConfig } from "../provider-registry";
+import type { Config } from "../../../shared/config";
+
+// Mock provider implementation
+class MockClaudeProvider implements ClaudeProvider {
+  constructor(public readonly name: string) {}
+
+  async call() {
+    return {
+      result: `Mock response from ${this.name}`,
+      exitCode: 0,
+      model: "mock-model",
+      effortLevel: "medium" as const,
+      duration: 100,
+    };
+  }
+}
+
+// Mock logger
+const mockLogger: pino.Logger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+} as unknown as pino.Logger;
+
+// Mock app config
+const mockAppConfig: Config = {
+  workers: {
+    num: 1,
+    max: 4,
+  },
+  models: {
+    default: "claude-sonnet-4",
+  },
+  timeouts: {
+    claude: 1200,
+    test: 600,
+    staleTask: 5400,
+  },
+  retry: {
+    maxRetries: 2,
+  },
+  debug: false,
+  adaptiveEffort: false,
+  teams: {
+    splitter: false,
+    reviewer: false,
+  },
+  memorySync: false,
+  dashboard: {
+    enabled: false,
+    port: 7333,
+    host: "localhost",
+  },
+};
+
+describe("ProviderRegistry", () => {
+  let cliProvider: ClaudeProvider;
+  let sdkProvider: ClaudeProvider;
+  let providersMap: Map<ProviderType, ClaudeProvider>;
+
+  beforeEach(() => {
+    cliProvider = new MockClaudeProvider("CLI");
+    sdkProvider = new MockClaudeProvider("SDK");
+    providersMap = new Map([
+      ["cli", cliProvider],
+      ["sdk", sdkProvider],
+    ]);
+  });
+
+  describe("constructor", () => {
+    test("should accept valid config with default provider", () => {
+      const config: ProviderConfig = { default: "cli" };
+      const registry = new ProviderRegistry(providersMap, config, mockLogger);
+      expect(registry).toBeDefined();
+    });
+
+    test("should throw error if default provider not in map", () => {
+      const config: ProviderConfig = { default: "invalid" as ProviderType };
+      expect(() => {
+        new ProviderRegistry(providersMap, config, mockLogger);
+      }).toThrow("Default provider 'invalid' not found in providers map");
+    });
+
+    test("should throw error if override provider not in map", () => {
+      const config: ProviderConfig = {
+        default: "cli",
+        overrides: {
+          tester: "invalid" as ProviderType,
+        },
+      };
+      expect(() => {
+        new ProviderRegistry(providersMap, config, mockLogger);
+      }).toThrow("Override provider 'invalid' for phase 'tester' not found in providers map");
+    });
+
+    test("should accept valid config with overrides", () => {
+      const config: ProviderConfig = {
+        default: "cli",
+        overrides: {
+          reviewer: "sdk",
+          splitter: "sdk",
+        },
+      };
+      const registry = new ProviderRegistry(providersMap, config, mockLogger);
+      expect(registry).toBeDefined();
+    });
+  });
+
+  describe("getProviderType", () => {
+    test("should return default provider type when phase is not specified", () => {
+      const config: ProviderConfig = { default: "cli" };
+      const registry = new ProviderRegistry(providersMap, config, mockLogger);
+
+      expect(registry.getProviderType()).toBe("cli");
+    });
+
+    test("should return default provider type for phase without override", () => {
+      const config: ProviderConfig = {
+        default: "cli",
+        overrides: { reviewer: "sdk" },
+      };
+      const registry = new ProviderRegistry(providersMap, config, mockLogger);
+
+      expect(registry.getProviderType("tester")).toBe("cli");
+    });
+
+    test("should return override provider type for configured phase", () => {
+      const config: ProviderConfig = {
+        default: "cli",
+        overrides: {
+          reviewer: "sdk",
+          splitter: "sdk",
+        },
+      };
+      const registry = new ProviderRegistry(providersMap, config, mockLogger);
+
+      expect(registry.getProviderType("reviewer")).toBe("sdk");
+      expect(registry.getProviderType("splitter")).toBe("sdk");
+    });
+
+    test("should handle all phase names correctly", () => {
+      const config: ProviderConfig = {
+        default: "cli",
+        overrides: {
+          splitter: "sdk",
+          tester: "cli",
+          implementer: "cli",
+          reviewer: "sdk",
+          "merge-resolver": "cli",
+        },
+      };
+      const registry = new ProviderRegistry(providersMap, config, mockLogger);
+
+      const phases: PhaseName[] = ["splitter", "tester", "implementer", "reviewer", "merge-resolver"];
+
+      for (const phase of phases) {
+        const expected = config.overrides![phase]!;
+        expect(registry.getProviderType(phase)).toBe(expected);
+      }
+    });
+  });
+
+  describe("getProvider", () => {
+    test("should return default provider when phase is not specified", () => {
+      const config: ProviderConfig = { default: "cli" };
+      const registry = new ProviderRegistry(providersMap, config, mockLogger);
+
+      expect(registry.getProvider()).toBe(cliProvider);
+    });
+
+    test("should return default provider for phase without override", () => {
+      const config: ProviderConfig = {
+        default: "cli",
+        overrides: { reviewer: "sdk" },
+      };
+      const registry = new ProviderRegistry(providersMap, config, mockLogger);
+
+      expect(registry.getProvider("tester")).toBe(cliProvider);
+    });
+
+    test("should return override provider for configured phase", () => {
+      const config: ProviderConfig = {
+        default: "cli",
+        overrides: {
+          reviewer: "sdk",
+          splitter: "sdk",
+        },
+      };
+      const registry = new ProviderRegistry(providersMap, config, mockLogger);
+
+      expect(registry.getProvider("reviewer")).toBe(sdkProvider);
+      expect(registry.getProvider("splitter")).toBe(sdkProvider);
+    });
+
+    test("should fallback to default for unspecified phases", () => {
+      const config: ProviderConfig = {
+        default: "sdk",
+        overrides: {
+          tester: "cli",
+        },
+      };
+      const registry = new ProviderRegistry(providersMap, config, mockLogger);
+
+      expect(registry.getProvider("reviewer")).toBe(sdkProvider);
+      expect(registry.getProvider("tester")).toBe(cliProvider);
+      expect(registry.getProvider("implementer")).toBe(sdkProvider);
+    });
+  });
+
+  describe("createProviderRegistry", () => {
+    test("should create registry with default provider only", () => {
+      const config: ProviderConfig = { default: "cli" };
+      const registry = createProviderRegistry(config, mockAppConfig, mockLogger);
+
+      expect(registry).toBeInstanceOf(ProviderRegistry);
+      expect(registry.getProviderType()).toBe("cli");
+    });
+
+    test("should create registry with default and override providers", () => {
+      const config: ProviderConfig = {
+        default: "cli",
+        overrides: {
+          reviewer: "sdk",
+          splitter: "sdk",
+        },
+      };
+      const registry = createProviderRegistry(config, mockAppConfig, mockLogger);
+
+      expect(registry).toBeInstanceOf(ProviderRegistry);
+      expect(registry.getProviderType()).toBe("cli");
+      expect(registry.getProviderType("reviewer")).toBe("sdk");
+      expect(registry.getProviderType("splitter")).toBe("sdk");
+    });
+
+    test("should create minimal set of providers based on config", () => {
+      const config: ProviderConfig = { default: "cli" };
+      const registry = createProviderRegistry(config, mockAppConfig, mockLogger);
+
+      // Should only have CLI provider
+      expect(registry.getProvider()).toBeDefined();
+      expect(registry.getProviderType()).toBe("cli");
+    });
+  });
+});

package/src/modules/claude-provider/__tests__/retry.test.ts

@@ -0,0 +1,201 @@
+import { describe, test, expect } from "bun:test";
+import { withRetry } from "../retry";
+import type { EffortLevel } from "../../../shared/types";
+import { ClaudeProviderError, TimeoutError } from "../../../shared/errors";
+
+describe("withRetry", () => {
+  test("returns success on first attempt", async () => {
+    const fn = async () => ({ success: true, data: "result" });
+
+    const result = await withRetry(fn, {
+      maxRetries: 2,
+      initialEffort: "medium",
+      backoffMs: 10,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.attempts).toBe(1);
+    expect(result.finalEffort).toBe("medium");
+    if (result.success) {
+      expect(result.data.data).toBe("result");
+    }
+  });
+
+  test("retries on failure and succeeds", async () => {
+    let attemptCount = 0;
+
+    const fn = async () => {
+      attemptCount++;
+      if (attemptCount < 2) {
+        throw new ClaudeProviderError("Temporary failure");
+      }
+      return { success: true, data: "result" };
+    };
+
+    const result = await withRetry(fn, {
+      maxRetries: 2,
+      initialEffort: "medium",
+      backoffMs: 10,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.attempts).toBe(2);
+    expect(attemptCount).toBe(2);
+  });
+
+  test("escalates effort level on first failure (low -> medium)", async () => {
+    let attemptCount = 0;
+    let lastEffort: EffortLevel = "low";
+
+    const fn = async (effort: EffortLevel) => {
+      attemptCount++;
+      lastEffort = effort;
+      if (attemptCount < 2) {
+        throw new ClaudeProviderError("Temporary failure");
+      }
+      return { success: true, data: "result" };
+    };
+
+    const result = await withRetry(fn, {
+      maxRetries: 2,
+      initialEffort: "low",
+      backoffMs: 10,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.attempts).toBe(2);
+    expect(result.finalEffort).toBe("medium");
+    expect(lastEffort as string).toBe("medium");
+  });
+
+  test("escalates effort level on second failure (medium -> high)", async () => {
+    let attemptCount = 0;
+    let lastEffort: EffortLevel = "medium";
+
+    const fn = async (effort: EffortLevel) => {
+      attemptCount++;
+      lastEffort = effort;
+      if (attemptCount < 3) {
+        throw new ClaudeProviderError("Temporary failure");
+      }
+      return { success: true, data: "result" };
+    };
+
+    const result = await withRetry(fn, {
+      maxRetries: 3,
+      initialEffort: "medium",
+      backoffMs: 10,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.attempts).toBe(3);
+    expect(result.finalEffort).toBe("high");
+    expect(lastEffort as string).toBe("high");
+  });
+
+  test("does not escalate beyond high", async () => {
+    let attemptCount = 0;
+    let lastEffort: EffortLevel = "high";
+
+    const fn = async (effort: EffortLevel) => {
+      attemptCount++;
+      lastEffort = effort;
+      if (attemptCount < 3) {
+        throw new ClaudeProviderError("Temporary failure");
+      }
+      return { success: true, data: "result" };
+    };
+
+    const result = await withRetry(fn, {
+      maxRetries: 3,
+      initialEffort: "high",
+      backoffMs: 10,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.finalEffort).toBe("high");
+    expect(lastEffort).toBe("high");
+  });
+
+  test("returns failure after exhausting retries", async () => {
+    const fn = async () => {
+      throw new ClaudeProviderError("Persistent failure");
+    };
+
+    const result = await withRetry(fn, {
+      maxRetries: 2,
+      initialEffort: "medium",
+      backoffMs: 10,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.attempts).toBe(3); // initial + 2 retries
+    if (!result.success) {
+      expect(result.error).toBeInstanceOf(ClaudeProviderError);
+      expect(result.error.message).toContain("Persistent failure");
+    }
+  });
+
+  test("applies exponential backoff between retries", async () => {
+    const timestamps: number[] = [];
+
+    const fn = async () => {
+      timestamps.push(Date.now());
+      throw new ClaudeProviderError("Failure");
+    };
+
+    await withRetry(fn, {
+      maxRetries: 2,
+      initialEffort: "medium",
+      backoffMs: 100, // 100ms base for testing
+    });
+
+    expect(timestamps).toHaveLength(3);
+
+    // 1回目と2回目の間隔 (attempt 1 * 100ms)
+    const delay1 = timestamps[1]! - timestamps[0]!;
+    expect(delay1).toBeGreaterThanOrEqual(90); // 多少の誤差を許容
+
+    // 2回目と3回目の間隔 (attempt 2 * 100ms)
+    const delay2 = timestamps[2]! - timestamps[1]!;
+    expect(delay2).toBeGreaterThanOrEqual(180); // 多少の誤差を許容
+  });
+
+  test("handles TimeoutError specifically", async () => {
+    const fn = async () => {
+      throw new TimeoutError("Operation timed out", { timeout: 30000 });
+    };
+
+    const result = await withRetry(fn, {
+      maxRetries: 1,
+      initialEffort: "medium",
+      backoffMs: 10,
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toBeInstanceOf(TimeoutError);
+    }
+  });
+
+  test("preserves error context through retries", async () => {
+    const fn = async () => {
+      throw new ClaudeProviderError("Error with context", {
+        phase: "tester",
+        taskId: "t1",
+      });
+    };
+
+    const result = await withRetry(fn, {
+      maxRetries: 1,
+      initialEffort: "medium",
+      backoffMs: 10,
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.context.phase).toBe("tester");
+      expect(result.error.context.taskId).toBe("t1");
+    }
+  });
+});

package/src/modules/claude-provider/claude-cli.adapter.ts

@@ -0,0 +1,156 @@
+import type { ClaudeProvider, ClaudeRequest, ClaudeResponse } from "./claude-provider.port";
+import type { Config } from "../../shared/config";
+import type pino from "pino";
+import { ClaudeProviderError, TimeoutError } from "../../shared/errors";
+import { withRetry } from "./retry";
+import type { EffortLevel } from "../../shared/types";
+
+export class ClaudeCliAdapter implements ClaudeProvider {
+  constructor(
+    private config: Config,
+    private logger: pino.Logger,
+    private backoffMs: number = 5000
+  ) {}
+
+  async call(request: ClaudeRequest): Promise<ClaudeResponse> {
+    const startTime = Date.now();
+
+    // Effort level決定
+    const initialEffort = request.effortLevel ?? "medium";
+
+    // Retry logic適用
+    const result = await withRetry(
+      async (effort: EffortLevel) => this.executeCli(request, effort),
+      {
+        maxRetries: request.maxRetries ?? this.config.retry.maxRetries,
+        initialEffort,
+        backoffMs: this.backoffMs,
+      }
+    );
+
+    if (!result.success) {
+      throw result.error;
+    }
+
+    const duration = Date.now() - startTime;
+
+    return {
+      result: result.data.stdout,
+      exitCode: result.data.exitCode,
+      model: request.model ?? this.config.models.default ?? "sonnet",
+      effortLevel: result.finalEffort,
+      duration,
+    };
+  }
+
+  private async executeCli(
+    request: ClaudeRequest,
+    effort: EffortLevel
+  ): Promise<{ stdout: string; exitCode: number }> {
+    const args = this.buildCliArgs(request, effort);
+
+    this.logger.debug({ args }, "Executing Claude CLI");
+
+    const timeout = request.timeout ?? this.config.timeouts.claude;
+
+    try {
+      const proc = Bun.spawn(args, {
+        cwd: request.cwd,
+        env: {
+          ...process.env,
+          CLAUDE_CODE_EFFORT_LEVEL: effort,
+        },
+      });
+
+      // タイムアウト処理
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => {
+          proc.kill();
+          reject(
+            new TimeoutError(`Claude CLI timed out after ${timeout}s`, {
+              timeout,
+            })
+          );
+        }, timeout * 1000);
+      });
+
+      const exitedPromise = proc.exited;
+
+      await Promise.race([exitedPromise, timeoutPromise]);
+
+      const stdout = await (proc.stdout as { text: () => Promise<string> }).text();
+      const stderr = proc.stderr ? await (proc.stderr as { text: () => Promise<string> }).text() : "";
+      const exited = await proc.exited;
+      const exitCode = typeof exited === "number" ? exited : (exited as { exitCode: number }).exitCode;
+
+      if (exitCode !== 0) {
+        throw new ClaudeProviderError(
+          `Claude CLI failed with exit code ${exitCode}`,
+          {
+            exitCode,
+            stdout,
+            stderr,
+            effort,
+          }
+        );
+      }
+
+      return { stdout, exitCode };
+    } catch (error) {
+      if (error instanceof TimeoutError || error instanceof ClaudeProviderError) {
+        throw error;
+      }
+
+      throw new ClaudeProviderError(
+        `Failed to execute Claude CLI: ${error instanceof Error ? error.message : String(error)}`,
+        { originalError: error }
+      );
+    }
+  }
+
+  private buildCliArgs(request: ClaudeRequest, _effort: EffortLevel): string[] {
+    const args: string[] = ["claude", "-p"]; // print mode (非対話)
+
+    // System prompt
+    if (request.systemPrompt || request.appendSystemPrompt) {
+      args.push("--append-system-prompt", request.systemPrompt ?? request.appendSystemPrompt!);
+    }
+
+    // Allowed tools
+    if (request.allowedTools && request.allowedTools.length > 0) {
+      args.push("--allowed-tools", request.allowedTools.join(","));
+    }
+
+    // Output format
+    if (request.outputFormat) {
+      args.push("--output-format", request.outputFormat);
+    }
+
+    // Permission mode
+    if (request.permissionMode) {
+      args.push("--permission-mode", request.permissionMode);
+    }
+
+    // Model
+    if (request.model) {
+      args.push("--model", request.model);
+    }
+
+    // Resume
+    if (request.resume) {
+      args.push("--resume");
+    }
+
+    // Prompt（subagentsがある場合はプロンプトに注入）
+    let prompt = request.prompt;
+    if (request.subagents && request.subagents.length > 0) {
+      const subagentDescriptions = request.subagents
+        .map(sa => `- ${sa.name}: ${sa.prompt}`)
+        .join("\n");
+      prompt = `${prompt}\n\n## Available Subagents (simulate as internal analysis threads)\n${subagentDescriptions}\n\nPlease coordinate with these roles internally and integrate their perspectives into your response.`;
+    }
+    args.push(prompt);
+
+    return args;
+  }
+}

package/src/modules/claude-provider/claude-provider.port.ts

@@ -0,0 +1,35 @@
+import type { EffortLevel } from "../../shared/types";
+
+export interface SubagentConfig {
+  name: string;
+  prompt: string;
+  model?: string;
+}
+
+export interface ClaudeRequest {
+  prompt: string;
+  systemPrompt?: string;
+  model?: string;
+  effortLevel?: EffortLevel;
+  timeout?: number;
+  maxRetries?: number;
+  allowedTools?: string[];
+  outputFormat?: "text" | "json";
+  permissionMode?: "acceptEdits" | "bypassPermissions" | "default" | "delegate" | "dontAsk" | "plan";
+  cwd?: string;
+  appendSystemPrompt?: string;
+  resume?: string;
+  subagents?: SubagentConfig[];
+}
+
+export interface ClaudeResponse {
+  result: string;
+  exitCode: number;
+  model: string;
+  effortLevel: EffortLevel;
+  duration: number;
+}
+
+export interface ClaudeProvider {
+  call(request: ClaudeRequest): Promise<ClaudeResponse>;
+}