@ronkovic/aad 0.3.0

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

@@ -0,0 +1,217 @@
+import type { ClaudeProvider, ClaudeRequest, ClaudeResponse } from "./claude-provider.port";
+import type { Config } from "../../shared/config";
+import type pino from "pino";
+import { ClaudeProviderError } from "../../shared/errors";
+import {
+  query,
+  type Options,
+  type SDKMessage,
+  type SDKAssistantMessage,
+  type SDKResultMessage,
+  type SDKResultSuccess,
+  type SDKResultError,
+} from "@anthropic-ai/claude-agent-sdk";
+
+/**
+ * Claude SDK Adapter
+ * @anthropic-ai/claude-agent-sdkを使用したClaudeプロバイダーの実装
+ */
+export class ClaudeSdkAdapter implements ClaudeProvider {
+  constructor(
+    private config: Config,
+    private logger: pino.Logger
+  ) {}
+
+  async call(request: ClaudeRequest): Promise<ClaudeResponse> {
+    const startTime = Date.now();
+    const childLogger = this.logger.child({ adapter: "sdk", prompt: request.prompt.slice(0, 50) });
+
+    try {
+      childLogger.info("Starting SDK query");
+
+      const options = this.buildOptions(request);
+      const q = query({ prompt: request.prompt, options });
+
+      // AsyncGeneratorを消費してClaudeResponseにマッピング
+      let lastAssistantMessage = "";
+      let exitCode = 0;
+      let actualModel = request.model ?? this.config.models.default ?? "claude-sonnet-4-5-20250929";
+      let error: string | undefined;
+      let resultMessage: SDKResultMessage | null = null;
+
+      for await (const message of q) {
+        this.logMessage(childLogger, message);
+
+        if (message.type === "assistant") {
+          const assistantMsg = message as SDKAssistantMessage;
+          // アシスタントメッセージから結果テキストを抽出
+          const textBlocks = assistantMsg.message.content.filter(
+            (block: { type: string }) => block.type === "text"
+          );
+          if (textBlocks.length > 0) {
+            lastAssistantMessage = textBlocks
+              .map((block: { text?: string }) => block.text ?? "")
+              .join("\n");
+          }
+          actualModel = assistantMsg.message.model ?? actualModel;
+
+          // エラーチェック
+          if (assistantMsg.error) {
+            error = this.mapSdkError(assistantMsg.error);
+            exitCode = 1;
+          }
+        } else if (message.type === "result") {
+          resultMessage = message as SDKResultMessage;
+          if (resultMessage.subtype === "success") {
+            const successMsg = resultMessage as SDKResultSuccess;
+            lastAssistantMessage = successMsg.result;
+            exitCode = 0;
+          } else {
+            const errorMsg = resultMessage as SDKResultError;
+            error = errorMsg.errors.join("; ");
+            exitCode = 1;
+          }
+        }
+      }
+
+      const duration = Date.now() - startTime;
+
+      if (exitCode !== 0) {
+        childLogger.error({ exitCode, error, duration }, "SDK query failed");
+        throw new ClaudeProviderError(
+          `SDK query failed with exit code ${exitCode}: ${error ?? "unknown error"}`
+        );
+      }
+
+      childLogger.info({ duration, model: actualModel }, "SDK query completed");
+
+      return {
+        result: lastAssistantMessage,
+        exitCode,
+        model: actualModel,
+        effortLevel: request.effortLevel ?? "medium",
+        duration,
+      };
+    } catch (err) {
+      const duration = Date.now() - startTime;
+      childLogger.error({ err, duration }, "SDK query error");
+
+      if (err instanceof ClaudeProviderError) {
+        throw err;
+      }
+
+      throw new ClaudeProviderError(
+        `SDK adapter error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+
+  private buildOptions(request: ClaudeRequest): Options {
+    const options: Options = {
+      cwd: request.cwd ?? process.cwd(),
+      model: request.model ?? this.config.models.default,
+      systemPrompt: request.systemPrompt,
+      allowedTools: request.allowedTools,
+      permissionMode: request.permissionMode ?? "bypassPermissions",
+    };
+
+    // env: 認証情報（ANTHROPIC_API_KEY / CLAUDE_CODE_OAUTH_TOKEN）+ effort level
+    options.env = this.buildEnv(request);
+
+    // Output Format
+    if (request.outputFormat === "json") {
+      // JSON出力を要求する場合、schema指定が必要
+      // ここでは汎用的なschemaを使用
+      options.outputFormat = {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: {
+            result: { type: "string" },
+          },
+          required: ["result"],
+        },
+      };
+    }
+
+    // タイムアウト
+    if (request.timeout) {
+      const abortController = new AbortController();
+      setTimeout(() => abortController.abort(), request.timeout);
+      options.abortController = abortController;
+    }
+
+    // Resume
+    if (request.resume) {
+      options.resume = request.resume;
+    }
+
+    // System Prompt追記
+    if (request.appendSystemPrompt) {
+      if (typeof options.systemPrompt === "string") {
+        options.systemPrompt = `${options.systemPrompt}\n\n${request.appendSystemPrompt}`;
+      } else {
+        options.systemPrompt = {
+          type: "preset",
+          preset: "claude_code",
+          append: request.appendSystemPrompt,
+        };
+      }
+    }
+
+    // Subagents
+    if (request.subagents && request.subagents.length > 0) {
+      (options as Options & { subagents?: Array<{ name: string; prompt: string; model?: string }> }).subagents = request.subagents.map(sa => ({
+        name: sa.name,
+        prompt: sa.prompt,
+        ...(sa.model ? { model: sa.model } : {}),
+      }));
+    }
+
+    return options;
+  }
+
+
+  private buildEnv(request: ClaudeRequest): Record<string, string | undefined> {
+    const env: Record<string, string | undefined> = { ...process.env };
+    if (request.effortLevel) {
+      env.CLAUDE_CODE_EFFORT_LEVEL = request.effortLevel;
+    }
+    return env;
+  }
+
+  private mapSdkError(error: string): string {
+    const errorMap: Record<string, string> = {
+      authentication_failed: "Authentication failed",
+      billing_error: "Billing error",
+      rate_limit: "Rate limit exceeded",
+      invalid_request: "Invalid request",
+      server_error: "Server error",
+      unknown: "Unknown error",
+    };
+    return errorMap[error] ?? error;
+  }
+
+
+  private logMessage(logger: pino.Logger, message: SDKMessage): void {
+    switch (message.type) {
+      case "assistant":
+        {
+          const assistantMsg = message as SDKAssistantMessage;
+          logger.debug({ model: assistantMsg.message.model }, "Assistant message");
+        }
+        break;
+      case "user":
+        logger.debug("User message");
+        break;
+      case "result":
+        {
+          const resultMsg = message as SDKResultMessage;
+          logger.debug({ subtype: resultMsg.subtype }, "Result message");
+        }
+        break;
+      default:
+        logger.trace({ type: message.type }, "SDK message");
+    }
+  }
+}

package/src/modules/claude-provider/effort-strategy.ts

@@ -0,0 +1,94 @@
+import type { EffortLevel, PhaseName, Task } from "../../shared/types";
+import type { Config } from "../../shared/config";
+
+export type TaskComplexity = "low" | "medium" | "high";
+
+export function estimateTaskComplexity(task: Task): TaskComplexity {
+  let score = 0;
+
+  // ファイル数
+  const fileCount = task.filesToModify.length;
+  if (fileCount >= 5) score += 3;
+  else if (fileCount >= 3) score += 2;
+  else if (fileCount >= 1) score += 1;
+
+  // 依存タスク数
+  const depCount = task.dependsOn.length;
+  if (depCount >= 3) score += 2;
+  else if (depCount >= 1) score += 1;
+
+  // 説明の長さ（複雑な要件 = 長い説明）
+  const descLen = task.description.length;
+  if (descLen >= 500) score += 2;
+  else if (descLen >= 200) score += 1;
+
+  // スコアから複雑度を判定
+  if (score >= 5) return "high";
+  if (score >= 3) return "medium";
+  return "low";
+}
+
+export function getEffortLevel(phase: PhaseName): EffortLevel {
+  switch (phase) {
+    case "splitter":
+      return "high";
+    case "tester":
+      return "medium";
+    case "implementer":
+      return "medium";
+    case "reviewer":
+      return "high";
+    case "merge-resolver":
+      return "low";
+    default:
+      return "medium";
+  }
+}
+
+export function getAdaptiveEffortLevel(
+  phase: PhaseName,
+  complexity: TaskComplexity,
+  config: Config
+): EffortLevel {
+  const baseEffort = getEffortLevel(phase);
+
+  // Adaptive effort無効の場合はベースをそのまま返す
+  if (!config.adaptiveEffort) {
+    return baseEffort;
+  }
+
+  // 複雑度に応じてeffort levelを調整
+  if (complexity === "high" && baseEffort === "medium") {
+    return "high";
+  }
+
+  if (complexity === "low" && baseEffort === "medium") {
+    return "low";
+  }
+
+  return baseEffort;
+}
+
+export function getPhaseModel(
+  phase: PhaseName,
+  config: Config
+): string | undefined {
+  // フェーズ別モデル設定を確認
+  const phaseModelMap: Record<PhaseName, string | undefined> = {
+    splitter: config.models.splitter,
+    tester: config.models.tester,
+    implementer: config.models.implementer,
+    reviewer: config.models.reviewer,
+    "merge-resolver": config.models.mergeResolver,
+  };
+
+  const phaseModel = phaseModelMap[phase];
+
+  // merge-resolverは未設定時にhaikuデフォルト
+  if (phase === "merge-resolver" && !phaseModel) {
+    return "haiku";
+  }
+
+  // フェーズ別モデルがあればそれを使用、なければデフォルトモデルにフォールバック
+  return phaseModel ?? config.models.default;
+}

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

@@ -0,0 +1,32 @@
+import type { ClaudeProvider } from "./claude-provider.port";
+import type { Config } from "../../shared/config";
+import type pino from "pino";
+import { ClaudeCliAdapter } from "./claude-cli.adapter";
+import { ClaudeSdkAdapter } from "./claude-sdk.adapter";
+
+export type { ClaudeProvider, ClaudeRequest, ClaudeResponse, SubagentConfig } from "./claude-provider.port";
+export { getEffortLevel, getAdaptiveEffortLevel, getPhaseModel, estimateTaskComplexity } from "./effort-strategy";
+export type { TaskComplexity } from "./effort-strategy";
+export { withRetry, type RetryResult, type RetryOptions } from "./retry";
+export {
+  ProviderRegistry,
+  createProviderRegistry,
+  type ProviderConfig,
+} from "./provider-registry";
+
+export type ProviderType = "cli" | "sdk";
+
+export function createClaudeProvider(
+  type: ProviderType,
+  config: Config,
+  logger: pino.Logger
+): ClaudeProvider {
+  switch (type) {
+    case "cli":
+      return new ClaudeCliAdapter(config, logger);
+    case "sdk":
+      return new ClaudeSdkAdapter(config, logger);
+    default:
+      throw new Error(`Unknown provider type: ${type}`);
+  }
+}

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

@@ -0,0 +1,92 @@
+import type pino from "pino";
+import type { ClaudeProvider } from "./claude-provider.port";
+import type { PhaseName } from "../../shared/types";
+import type { Config } from "../../shared/config";
+import type { ProviderType } from "./index";
+import { createClaudeProvider } from "./index";
+
+export interface ProviderConfig {
+  default: ProviderType;
+  overrides?: Partial<Record<PhaseName, ProviderType>>;
+}
+
+export class ProviderRegistry {
+  private readonly providers: Map<ProviderType, ClaudeProvider>;
+  private readonly config: ProviderConfig;
+  private readonly logger: pino.Logger;
+
+  constructor(
+    providers: Map<ProviderType, ClaudeProvider>,
+    config: ProviderConfig,
+    logger: pino.Logger
+  ) {
+    this.providers = providers;
+    this.config = config;
+    this.logger = logger;
+
+    // Validate default provider exists
+    if (!this.providers.has(config.default)) {
+      throw new Error(`Default provider '${config.default}' not found in providers map`);
+    }
+
+    // Validate all override providers exist
+    if (config.overrides) {
+      for (const [phase, providerType] of Object.entries(config.overrides)) {
+        if (providerType && !this.providers.has(providerType)) {
+          throw new Error(
+            `Override provider '${providerType}' for phase '${phase}' not found in providers map`
+          );
+        }
+      }
+    }
+  }
+
+  getProvider(phase?: PhaseName): ClaudeProvider {
+    const providerType = this.getProviderType(phase);
+    const provider = this.providers.get(providerType);
+
+    if (!provider) {
+      throw new Error(`Provider '${providerType}' not found`);
+    }
+
+    this.logger.debug(
+      { phase, providerType },
+      `Selected provider for phase`
+    );
+
+    return provider;
+  }
+
+  getProviderType(phase?: PhaseName): ProviderType {
+    if (phase && this.config.overrides?.[phase]) {
+      return this.config.overrides[phase]!;
+    }
+    return this.config.default;
+  }
+}
+
+export function createProviderRegistry(
+  config: ProviderConfig,
+  appConfig: Config,
+  logger: pino.Logger
+): ProviderRegistry {
+  const providers = new Map<ProviderType, ClaudeProvider>();
+
+  // Determine which providers need to be instantiated
+  const requiredTypes = new Set<ProviderType>([config.default]);
+
+  if (config.overrides) {
+    for (const providerType of Object.values(config.overrides)) {
+      if (providerType) {
+        requiredTypes.add(providerType);
+      }
+    }
+  }
+
+  // Create only the required providers
+  for (const type of requiredTypes) {
+    providers.set(type, createClaudeProvider(type, appConfig, logger));
+  }
+
+  return new ProviderRegistry(providers, config, logger);
+}

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

@@ -0,0 +1,81 @@
+import type { EffortLevel } from "../../shared/types";
+import { AadError } from "../../shared/errors";
+
+export interface RetryOptions {
+  maxRetries: number;
+  initialEffort: EffortLevel;
+  backoffMs?: number;
+}
+
+export type RetryResult<T> =
+  | {
+      success: true;
+      data: T;
+      attempts: number;
+      finalEffort: EffortLevel;
+    }
+  | {
+      success: false;
+      error: AadError;
+      attempts: number;
+      finalEffort: EffortLevel;
+    };
+
+function escalateEffort(currentEffort: EffortLevel): EffortLevel {
+  if (currentEffort === "low") return "medium";
+  if (currentEffort === "medium") return "high";
+  return "high"; // already at max
+}
+
+async function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function withRetry<T>(
+  fn: (effort: EffortLevel) => Promise<T>,
+  options: RetryOptions
+): Promise<RetryResult<T>> {
+  const { maxRetries, initialEffort, backoffMs = 5000 } = options;
+
+  let currentEffort = initialEffort;
+  let lastError: AadError | null = null;
+
+  for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
+    try {
+      const result = await fn(currentEffort);
+      return {
+        success: true,
+        data: result,
+        attempts: attempt,
+        finalEffort: currentEffort,
+      };
+    } catch (error) {
+      // AadError以外の例外はラップする
+      if (!(error instanceof AadError)) {
+        lastError = new AadError(
+          "UNKNOWN_ERROR",
+          error instanceof Error ? error.message : String(error)
+        );
+      } else {
+        lastError = error;
+      }
+
+      // 最後の試行でない場合
+      if (attempt <= maxRetries) {
+        // Effort levelをエスカレート
+        currentEffort = escalateEffort(currentEffort);
+
+        // Exponential backoff: attempt * backoffMs
+        const delayMs = attempt * backoffMs;
+        await sleep(delayMs);
+      }
+    }
+  }
+
+  return {
+    success: false,
+    error: lastError!,
+    attempts: maxRetries + 1,
+    finalEffort: currentEffort,
+  };
+}

package/src/modules/cli/__tests__/app.test.ts

@@ -0,0 +1,160 @@
+/**
+ * CLI App - Composition Root Tests
+ */
+
+import { describe, test, expect, afterEach } from "bun:test";
+import { createApp, type App } from "../app";
+
+describe("createApp", () => {
+  let app: App | undefined;
+
+  afterEach(async () => {
+    if (app) {
+      await app.shutdown();
+      app = undefined;
+    }
+  });
+
+  test("creates app with default options", async () => {
+    app = await createApp({ dashboard: false }); // デフォルトでdashboardを無効化
+
+    expect(app).toBeDefined();
+    expect(app.config).toBeDefined();
+    expect(app.eventBus).toBeDefined();
+    expect(app.logger).toBeDefined();
+    expect(app.stores).toBeDefined();
+    expect(app.dispatcher).toBeDefined();
+    expect(app.processManager).toBeDefined();
+    expect(app.planningService).toBeDefined();
+    expect(app.providerRegistry).toBeDefined();
+    expect(app.worktreeManager).toBeDefined();
+    expect(app.branchManager).toBeDefined();
+    expect(app.mergeService).toBeDefined();
+    expect(typeof app.shutdown).toBe("function");
+  });
+
+  test("creates app with custom workers", async () => {
+    app = await createApp({ workers: 4, dashboard: false });
+
+    expect(app.config.workers.num).toBe(4);
+  });
+
+  test("creates app with debug enabled", async () => {
+    app = await createApp({ debug: true, dashboard: false });
+
+    expect(app.config.debug).toBe(true);
+  });
+
+  test("creates app with debug disabled", async () => {
+    app = await createApp({ debug: false, dashboard: false });
+
+    expect(app.config.debug).toBe(false);
+  });
+
+  test("creates app with memory persistence", async () => {
+    app = await createApp({ persist: "memory", dashboard: false });
+
+    expect(app.stores).toBeDefined();
+    expect(app.stores.taskStore).toBeDefined();
+    expect(app.stores.workerStore).toBeDefined();
+    expect(app.stores.runStore).toBeDefined();
+  });
+
+  test("creates app with memory persistence (default)", async () => {
+    app = await createApp({ dashboard: false });
+
+    expect(app.stores).toBeDefined();
+    expect(app.stores.taskStore).toBeDefined();
+    expect(app.stores.workerStore).toBeDefined();
+    expect(app.stores.runStore).toBeDefined();
+  });
+
+  test("creates app with dashboard enabled on custom port", async () => {
+    // ランダムポートでテスト
+    const randomPort = 10000 + Math.floor(Math.random() * 10000);
+    process.env.AAD_DASHBOARD_PORT = String(randomPort);
+
+    app = await createApp({ dashboard: true });
+
+    expect(app.config.dashboard.enabled).toBe(true);
+    expect(app.dashboardServer).toBeDefined();
+    expect(app.config.dashboard.port).toBe(randomPort);
+
+    // 環境変数リセット
+    delete process.env.AAD_DASHBOARD_PORT;
+  });
+
+  test("creates app with dashboard disabled", async () => {
+    app = await createApp({ dashboard: false });
+
+    expect(app.config.dashboard.enabled).toBe(false);
+    expect(app.dashboardServer).toBeUndefined();
+  });
+
+  test("creates app with CLI provider default", async () => {
+    app = await createApp({ providerDefault: "cli", dashboard: false });
+
+    expect(app.providerRegistry).toBeDefined();
+    expect(app.providerRegistry.getProviderType()).toBe("cli");
+  });
+
+  test("creates app with SDK provider default", async () => {
+    app = await createApp({ providerDefault: "sdk", dashboard: false });
+
+    expect(app.providerRegistry).toBeDefined();
+    expect(app.providerRegistry.getProviderType()).toBe("sdk");
+  });
+
+  test("creates app with provider overrides", async () => {
+    app = await createApp({
+      providerDefault: "cli",
+      providerOverrides: {
+        reviewer: "sdk",
+      },
+      dashboard: false,
+    });
+
+    expect(app.providerRegistry.getProviderType()).toBe("cli");
+    expect(app.providerRegistry.getProviderType("reviewer")).toBe("sdk");
+  });
+
+  test("shutdown stops all services", async () => {
+    app = await createApp({ dashboard: false });
+
+    // shutdown should not throw
+    await expect(app.shutdown()).resolves.toBeUndefined();
+  });
+
+  test("shutdown stops dashboard if enabled", async () => {
+    // ランダムポートでテスト
+    const randomPort = 10000 + Math.floor(Math.random() * 10000);
+    process.env.AAD_DASHBOARD_PORT = String(randomPort);
+
+    app = await createApp({ dashboard: true });
+
+    expect(app.dashboardServer).toBeDefined();
+
+    await app.shutdown();
+
+    // Dashboard should be stopped (no error thrown)
+
+    // 環境変数リセット
+    delete process.env.AAD_DASHBOARD_PORT;
+  });
+
+  test("multiple options combined", async () => {
+    app = await createApp({
+      workers: 3,
+      debug: true,
+      persist: "memory",
+      dashboard: false,
+      providerDefault: "sdk",
+    });
+
+    expect(app.config.workers.num).toBe(3);
+    expect(app.config.debug).toBe(true);
+    expect(app.config.dashboard.enabled).toBe(false);
+    expect(app.dashboardServer).toBeUndefined();
+    expect(app.providerRegistry.getProviderType()).toBe("sdk");
+  });
+});