@ronkovic/aad 0.3.0

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

@@ -0,0 +1,127 @@
+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-3-5-20241022",
+    });
+
+    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);
+});

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

@@ -0,0 +1,347 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test";
+import { ClaudeSdkAdapter } from "../claude-sdk.adapter";
+import type { Config } from "../../../shared/config";
+import type { ClaudeRequest } from "../claude-provider.port";
+import pino from "pino";
+import { ClaudeProviderError } from "../../../shared/errors";
+
+// SDK型のモック
+type MockSDKMessage =
+  | {
+      type: "assistant";
+      message: {
+        model: string;
+        content: Array<{ type: string; text?: string }>;
+      };
+      error?: string;
+    }
+  | {
+      type: "result";
+      subtype: "success";
+      result: string;
+    }
+  | {
+      type: "result";
+      subtype: "error_during_execution";
+      errors: string[];
+    };
+
+// @anthropic-ai/claude-agent-sdk のモック
+const mockQuery = mock(
+  (_params: { prompt: string; options?: unknown }): AsyncGenerator<MockSDKMessage, void, unknown> => {
+    return (async function* () {
+      // デフォルトは成功レスポンス
+      yield {
+        type: "assistant",
+        message: {
+          model: "claude-sonnet-4-5-20250929",
+          content: [{ type: "text", text: "Test response" }],
+        },
+      } as MockSDKMessage;
+      yield {
+        type: "result",
+        subtype: "success",
+        result: "Test response",
+      } as MockSDKMessage;
+    })() as AsyncGenerator<MockSDKMessage, void, unknown>;
+  }
+);
+
+// SDKモジュール全体をモック
+mock.module("@anthropic-ai/claude-agent-sdk", () => ({
+  query: mockQuery,
+}));
+
+describe("ClaudeSdkAdapter", () => {
+  let adapter: ClaudeSdkAdapter;
+  let config: Config;
+  let logger: pino.Logger;
+
+  beforeEach(() => {
+    config = {
+      workers: { num: 2, max: 8 },
+      models: {
+        default: "claude-sonnet-4-5-20250929",
+      },
+      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" },
+    };
+
+    logger = pino({ level: "silent" });
+    adapter = new ClaudeSdkAdapter(config, logger);
+
+    // モックをリセット
+    mockQuery.mockClear();
+  });
+
+  test("call() - 成功レスポンス", async () => {
+    const request: ClaudeRequest = {
+      prompt: "Test prompt",
+    };
+
+    const response = await adapter.call(request);
+
+    expect(response.exitCode).toBe(0);
+    expect(response.result).toBe("Test response");
+    expect(response.model).toBe("claude-sonnet-4-5-20250929");
+    expect(response.effortLevel).toBe("medium");
+    expect(response.duration).toBeGreaterThanOrEqual(0);
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+  });
+
+  test("call() - カスタムオプション", async () => {
+    const request: ClaudeRequest = {
+      prompt: "Test prompt",
+      model: "claude-opus-4-20250514",
+      effortLevel: "high",
+      systemPrompt: "Custom system prompt",
+      allowedTools: ["Bash", "Read"],
+      cwd: "/custom/path",
+    };
+
+    await adapter.call(request);
+
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+    const callArgs = mockQuery.mock.calls[0] as unknown as [
+      { prompt: string; options: { model?: string; systemPrompt?: string; allowedTools?: string[]; cwd?: string; env?: Record<string, string> } }
+    ];
+    expect(callArgs[0]!.prompt).toBe("Test prompt");
+    expect(callArgs[0]!.options).toMatchObject({
+      model: "claude-opus-4-20250514",
+      systemPrompt: "Custom system prompt",
+      allowedTools: ["Bash", "Read"],
+      cwd: "/custom/path",
+    });
+    expect(callArgs[0]!.options.env?.CLAUDE_CODE_EFFORT_LEVEL).toBe("high");
+  });
+
+  test("call() - エラーレスポンス", async () => {
+    // SDKモジュールを一時的に上書き
+    mockQuery.mockImplementationOnce(
+      (_params: { prompt: string; options?: unknown }): AsyncGenerator<MockSDKMessage, void, unknown> => {
+        return (async function* () {
+          yield {
+            type: "result",
+            subtype: "error_during_execution",
+            errors: ["Test error"],
+          } as MockSDKMessage;
+        })() as AsyncGenerator<MockSDKMessage, void, unknown>;
+      }
+    );
+
+    const request: ClaudeRequest = {
+      prompt: "Test prompt",
+    };
+
+    await expect(adapter.call(request)).rejects.toThrow(ClaudeProviderError);
+  });
+
+  test("call() - アシスタントメッセージエラー", async () => {
+    mockQuery.mockReturnValueOnce(
+      (async function* () {
+        yield {
+          type: "assistant",
+          message: {
+            model: "claude-sonnet-4-5-20250929",
+            content: [{ type: "text", text: "Error response" }],
+          },
+          error: "rate_limit",
+        } as MockSDKMessage;
+        yield {
+          type: "result",
+          subtype: "error_during_execution",
+          errors: ["Rate limit exceeded"],
+        } as MockSDKMessage;
+      })() as AsyncGenerator<MockSDKMessage, void, unknown>
+    );
+
+    const request: ClaudeRequest = {
+      prompt: "Test prompt",
+    };
+
+    await expect(adapter.call(request)).rejects.toThrow(ClaudeProviderError);
+  });
+
+  test("call() - タイムアウト設定", async () => {
+    const request: ClaudeRequest = {
+      prompt: "Test prompt",
+      timeout: 5000,
+    };
+
+    await adapter.call(request);
+
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+    const callArgs = mockQuery.mock.calls[0] as unknown as [
+      { prompt: string; options: { abortController?: AbortController } }
+    ];
+    expect(callArgs[0]!.options.abortController).toBeDefined();
+  });
+
+  test("call() - JSON出力フォーマット", async () => {
+    const request: ClaudeRequest = {
+      prompt: "Test prompt",
+      outputFormat: "json",
+    };
+
+    await adapter.call(request);
+
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+    const callArgs = mockQuery.mock.calls[0] as unknown as [
+      { prompt: string; options: { outputFormat?: { type: string; schema: unknown } } }
+    ];
+    expect(callArgs[0]!.options.outputFormat).toMatchObject({
+      type: "json_schema",
+      schema: {
+        type: "object",
+        properties: {
+          result: { type: "string" },
+        },
+        required: ["result"],
+      },
+    });
+  });
+
+  test("call() - パーミッションモード設定", async () => {
+    const requestBypass: ClaudeRequest = {
+      prompt: "Test prompt",
+      permissionMode: "bypassPermissions",
+    };
+
+    await adapter.call(requestBypass);
+    let callArgs = mockQuery.mock.calls[0] as unknown as [
+      { prompt: string; options: { permissionMode?: string } }
+    ];
+    expect(callArgs[0]!.options.permissionMode).toBe("bypassPermissions");
+
+    mockQuery.mockClear();
+
+    const requestDefault: ClaudeRequest = {
+      prompt: "Test prompt",
+      permissionMode: "default",
+    };
+
+    await adapter.call(requestDefault);
+    callArgs = mockQuery.mock.calls[0] as unknown as [
+      { prompt: string; options: { permissionMode?: string } }
+    ];
+    expect(callArgs[0]!.options.permissionMode).toBe("default");
+
+    mockQuery.mockClear();
+
+    const requestNoMode: ClaudeRequest = {
+      prompt: "Test prompt",
+    };
+
+    await adapter.call(requestNoMode);
+    callArgs = mockQuery.mock.calls[0] as unknown as [
+      { prompt: string; options: { permissionMode?: string } }
+    ];
+    expect(callArgs[0]!.options.permissionMode).toBe("bypassPermissions");
+  });
+
+  test("call() - systemPrompt追記", async () => {
+    const request: ClaudeRequest = {
+      prompt: "Test prompt",
+      systemPrompt: "Base prompt",
+      appendSystemPrompt: "Additional instructions",
+    };
+
+    await adapter.call(request);
+
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+    const callArgs = mockQuery.mock.calls[0] as unknown as [
+      { prompt: string; options: { systemPrompt?: string } }
+    ];
+    expect(callArgs[0]!.options.systemPrompt).toBe("Base prompt\n\nAdditional instructions");
+  });
+
+  test("call() - resume指定", async () => {
+    const request: ClaudeRequest = {
+      prompt: "Test prompt",
+      resume: "session-id-123",
+    };
+
+    await adapter.call(request);
+
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+    const callArgs = mockQuery.mock.calls[0] as unknown as [
+      { prompt: string; options: { resume?: string } }
+    ];
+    expect(callArgs[0]!.options.resume).toBe("session-id-123");
+  });
+
+  test("call() - subagentsオプションが正しく渡される", async () => {
+    const request: ClaudeRequest = {
+      prompt: "Test prompt",
+      subagents: [
+        { name: "analyzer", prompt: "Analyze code" },
+        { name: "reviewer", prompt: "Review code", model: "claude-opus-4-20250514" },
+      ],
+    };
+
+    await adapter.call(request);
+
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+    const callArgs = mockQuery.mock.calls[0] as unknown as [
+      { prompt: string; options: { subagents?: Array<{ name: string; prompt: string; model?: string }> } }
+    ];
+    expect(callArgs[0]!.options.subagents).toEqual([
+      { name: "analyzer", prompt: "Analyze code" },
+      { name: "reviewer", prompt: "Review code", model: "claude-opus-4-20250514" },
+    ]);
+  });
+
+  test("call() - subagentsが空の場合はオプションに含まれない", async () => {
+    const request: ClaudeRequest = {
+      prompt: "Test prompt",
+      subagents: [],
+    };
+
+    await adapter.call(request);
+
+    const callArgs = mockQuery.mock.calls[0] as unknown as [
+      { prompt: string; options: { subagents?: unknown } }
+    ];
+    expect(callArgs[0]!.options.subagents).toBeUndefined();
+  });
+
+  test("call() - 複数のアシスタントメッセージ", async () => {
+    mockQuery.mockReturnValueOnce(
+      (async function* () {
+        yield {
+          type: "assistant",
+          message: {
+            model: "claude-sonnet-4-5-20250929",
+            content: [{ type: "text", text: "First response" }],
+          },
+        } as MockSDKMessage;
+        yield {
+          type: "assistant",
+          message: {
+            model: "claude-sonnet-4-5-20250929",
+            content: [{ type: "text", text: "Second response" }],
+          },
+        } as MockSDKMessage;
+        yield {
+          type: "result",
+          subtype: "success",
+          result: "Final result",
+        } as MockSDKMessage;
+      })() as AsyncGenerator<MockSDKMessage, void, unknown>
+    );
+
+    const request: ClaudeRequest = {
+      prompt: "Test prompt",
+    };
+
+    const response = await adapter.call(request);
+
+    expect(response.exitCode).toBe(0);
+    expect(response.result).toBe("Final result");
+  });
+});

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

@@ -0,0 +1,212 @@
+import { describe, test, expect } from "bun:test";
+import {
+  getEffortLevel,
+  getAdaptiveEffortLevel,
+  getPhaseModel,
+  estimateTaskComplexity,
+} from "../effort-strategy";
+import type { Config } from "../../../shared/config";
+import type { Task } from "../../../shared/types";
+
+function makeTask(overrides: Partial<Task> = {}): Task {
+  return {
+    taskId: "task-1" as any,
+    title: "Test task",
+    description: "Short desc",
+    filesToModify: [],
+    dependsOn: [],
+    priority: 1,
+    status: "pending" as any,
+    retryCount: 0,
+    ...overrides,
+  };
+}
+
+describe("getEffortLevel", () => {
+  test("splitter returns high", () => {
+    expect(getEffortLevel("splitter")).toBe("high");
+  });
+
+  test("tester returns medium", () => {
+    expect(getEffortLevel("tester")).toBe("medium");
+  });
+
+  test("implementer returns medium", () => {
+    expect(getEffortLevel("implementer")).toBe("medium");
+  });
+
+  test("reviewer returns high", () => {
+    expect(getEffortLevel("reviewer")).toBe("high");
+  });
+
+  test("merge-resolver returns low", () => {
+    expect(getEffortLevel("merge-resolver")).toBe("low");
+  });
+});
+
+describe("getAdaptiveEffortLevel", () => {
+  const disabledConfig: Config = {
+    adaptiveEffort: false,
+  } as Config;
+
+  const enabledConfig: Config = {
+    adaptiveEffort: true,
+  } as Config;
+
+  describe("when adaptiveEffort is disabled", () => {
+    test("returns base effort for splitter with high complexity", () => {
+      const result = getAdaptiveEffortLevel("splitter", "high", disabledConfig);
+      expect(result).toBe("high");
+    });
+
+    test("returns base effort for splitter with medium complexity", () => {
+      const result = getAdaptiveEffortLevel("splitter", "medium", disabledConfig);
+      expect(result).toBe("high");
+    });
+
+    test("returns base effort for implementer with low complexity", () => {
+      const result = getAdaptiveEffortLevel("implementer", "low", disabledConfig);
+      expect(result).toBe("medium");
+    });
+  });
+
+  describe("when adaptiveEffort is enabled with high complexity", () => {
+    test("promotes implementer medium to high", () => {
+      const result = getAdaptiveEffortLevel("implementer", "high", enabledConfig);
+      expect(result).toBe("high");
+    });
+
+    test("promotes tester medium to high", () => {
+      const result = getAdaptiveEffortLevel("tester", "high", enabledConfig);
+      expect(result).toBe("high");
+    });
+  });
+
+  describe("when adaptiveEffort is enabled with low complexity", () => {
+    test("demotes implementer medium to low", () => {
+      const result = getAdaptiveEffortLevel("implementer", "low", enabledConfig);
+      expect(result).toBe("low");
+    });
+
+    test("demotes tester medium to low", () => {
+      const result = getAdaptiveEffortLevel("tester", "low", enabledConfig);
+      expect(result).toBe("low");
+    });
+  });
+
+  describe("when adaptiveEffort is enabled with medium complexity", () => {
+    test("keeps implementer at medium", () => {
+      const result = getAdaptiveEffortLevel("implementer", "medium", enabledConfig);
+      expect(result).toBe("medium");
+    });
+  });
+
+  describe("high/low base effort levels should not change", () => {
+    test("splitter (base=high) with low complexity remains high", () => {
+      const result = getAdaptiveEffortLevel("splitter", "low", enabledConfig);
+      expect(result).toBe("high");
+    });
+
+    test("merge-resolver (base=low) with high complexity remains low", () => {
+      const result = getAdaptiveEffortLevel("merge-resolver", "high", enabledConfig);
+      expect(result).toBe("low");
+    });
+  });
+});
+
+describe("getPhaseModel", () => {
+  test("returns phase-specific model when configured", () => {
+    const config: Config = {
+      models: {
+        splitter: "opus",
+        tester: "sonnet",
+        implementer: "sonnet",
+        reviewer: "opus",
+        mergeResolver: "haiku",
+      },
+    } as Config;
+
+    expect(getPhaseModel("splitter", config)).toBe("opus");
+    expect(getPhaseModel("tester", config)).toBe("sonnet");
+    expect(getPhaseModel("implementer", config)).toBe("sonnet");
+    expect(getPhaseModel("reviewer", config)).toBe("opus");
+    expect(getPhaseModel("merge-resolver", config)).toBe("haiku");
+  });
+
+  test("falls back to default model when phase model not configured", () => {
+    const config: Config = {
+      models: {
+        default: "sonnet",
+      },
+    } as Config;
+
+    expect(getPhaseModel("splitter", config)).toBe("sonnet");
+    expect(getPhaseModel("tester", config)).toBe("sonnet");
+  });
+
+  test("returns undefined when no models configured", () => {
+    const config: Config = {
+      models: {},
+    } as Config;
+
+    expect(getPhaseModel("splitter", config)).toBeUndefined();
+  });
+
+  test("merge-resolver defaults to haiku when not configured", () => {
+    const config: Config = {
+      models: {},
+    } as Config;
+
+    expect(getPhaseModel("merge-resolver", config)).toBe("haiku");
+  });
+});
+
+describe("estimateTaskComplexity", () => {
+  test("returns low for minimal task", () => {
+    const task = makeTask();
+    expect(estimateTaskComplexity(task)).toBe("low");
+  });
+
+  test("returns low for single file, no deps, short description", () => {
+    const task = makeTask({ filesToModify: ["a.ts"], description: "fix bug" });
+    expect(estimateTaskComplexity(task)).toBe("low");
+  });
+
+  test("returns medium for 3 files, 1 dep, medium description", () => {
+    const task = makeTask({
+      filesToModify: ["a.ts", "b.ts", "c.ts"],
+      dependsOn: ["task-0" as any],
+      description: "a".repeat(200),
+    });
+    // score: 2 (files) + 1 (dep) + 1 (desc) = 4 → medium
+    expect(estimateTaskComplexity(task)).toBe("medium");
+  });
+
+  test("returns high for 5+ files, 3+ deps, long description", () => {
+    const task = makeTask({
+      filesToModify: ["a.ts", "b.ts", "c.ts", "d.ts", "e.ts"],
+      dependsOn: ["t1", "t2", "t3"] as any[],
+      description: "a".repeat(500),
+    });
+    // score: 3 (files) + 2 (deps) + 2 (desc) = 7 → high
+    expect(estimateTaskComplexity(task)).toBe("high");
+  });
+
+  test("high files alone can push to medium", () => {
+    const task = makeTask({
+      filesToModify: ["a.ts", "b.ts", "c.ts", "d.ts", "e.ts"],
+    });
+    // score: 3 → medium
+    expect(estimateTaskComplexity(task)).toBe("medium");
+  });
+
+  test("combination of medium factors reaches high", () => {
+    const task = makeTask({
+      filesToModify: ["a.ts", "b.ts", "c.ts"],
+      dependsOn: ["t1", "t2", "t3"] as any[],
+      description: "a".repeat(200),
+    });
+    // score: 2 + 2 + 1 = 5 → high
+    expect(estimateTaskComplexity(task)).toBe("high");
+  });
+});