@ronkovic/aad 0.3.0

package/src/modules/task-execution/__tests__/reviewer.test.ts

@@ -0,0 +1,302 @@
+import { describe, test, expect } from "bun:test";
+import {
+  runReviewer,
+  buildReviewPrompt,
+  buildTeamsReviewPrompt,
+  buildReviewerSubagents,
+} from "../phases/reviewer";
+import type { Task, WorkspaceInfo } from "@aad/shared/types";
+import type { ClaudeProvider, ClaudeRequest, ClaudeResponse } from "@aad/claude-provider";
+import { createTaskId, createRunId } from "@aad/shared/types";
+
+describe("buildReviewPrompt (solo mode)", () => {
+  test("builds solo review prompt", () => {
+    const task: Task = {
+      taskId: createTaskId("task-001"),
+      title: "Add login endpoint",
+      description: "JWT-based auth",
+      filesToModify: ["src/auth.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const prompt = buildReviewPrompt(task);
+
+    expect(prompt).toContain("reviewerエージェント");
+    expect(prompt).toContain("コードレビュー");
+    expect(prompt).toContain("task-001");
+    expect(prompt).toContain("Add login endpoint");
+    expect(prompt).toContain("品質・セキュリティ・パフォーマンス");
+  });
+});
+
+describe("buildTeamsReviewPrompt (teams mode)", () => {
+  test("builds teams review prompt with parallel reviewers", () => {
+    const task: Task = {
+      taskId: createTaskId("task-002"),
+      title: "API implementation",
+      description: "RESTful API",
+      filesToModify: ["src/api.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const runId = createRunId("run-123");
+
+    const prompt = buildTeamsReviewPrompt(task, runId);
+
+    expect(prompt).toContain("reviewerチームリーダー");
+    expect(prompt).toContain("Agent Teamsを使った並列コードレビュー");
+    expect(prompt).toContain("quality-reviewer");
+    expect(prompt).toContain("security-reviewer");
+    expect(prompt).toContain("performance-reviewer");
+    expect(prompt).toContain("code_review.md");
+    expect(prompt).toContain("run-123");
+  });
+
+  test("includes review aspects for each role", () => {
+    const task: Task = {
+      taskId: createTaskId("task-003"),
+      title: "Test",
+      description: "Test",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const runId = createRunId("run-456");
+    const prompt = buildTeamsReviewPrompt(task, runId);
+
+    // Quality reviewer
+    expect(prompt).toContain("可読性");
+    expect(prompt).toContain("DRY原則");
+
+    // Security reviewer
+    expect(prompt).toContain("SQLインジェクション");
+    expect(prompt).toContain("認証・認可");
+
+    // Performance reviewer
+    expect(prompt).toContain("N+1クエリ");
+    expect(prompt).toContain("アルゴリズム");
+  });
+});
+
+describe("buildReviewerSubagents", () => {
+  test("returns 3 reviewer subagents", () => {
+    const subagents = buildReviewerSubagents();
+    expect(subagents).toHaveLength(3);
+    expect(subagents.map(s => s.name)).toEqual([
+      "quality-reviewer",
+      "security-reviewer",
+      "performance-reviewer",
+    ]);
+  });
+
+  test("each subagent has a non-empty prompt", () => {
+    const subagents = buildReviewerSubagents();
+    for (const sa of subagents) {
+      expect(sa.prompt.length).toBeGreaterThan(0);
+    }
+  });
+});
+
+describe("runReviewer", () => {
+  test("runs solo review by default", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-004"),
+      title: "Add validation",
+      description: "Input validation",
+      filesToModify: ["src/validator.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config = {
+      teams: { reviewer: false },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(request: ClaudeRequest): Promise<ClaudeResponse> {
+        expect(request.prompt).toContain("reviewerエージェント");
+        expect(request.prompt).not.toContain("チームリーダー");
+        expect(request.cwd).toBe("/workspace");
+        expect(request.effortLevel).toBe("medium");
+
+        return {
+          result: "レビュー完了",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 1000,
+        };
+      },
+    };
+
+    const runId = createRunId("run-001");
+    const result = await runReviewer(task, workspace, runId, config, mockProvider);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("レビュー完了");
+  });
+
+  test("runs teams review when config.teams.reviewer is true", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-005"),
+      title: "Complex feature",
+      description: "Complex implementation",
+      filesToModify: ["src/feature.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config = {
+      teams: { reviewer: true },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(request: ClaudeRequest): Promise<ClaudeResponse> {
+        expect(request.prompt).toContain("reviewerチームリーダー");
+        expect(request.prompt).toContain("Agent Teams");
+        expect(request.effortLevel).toBe("high");
+        // Verify subagents are passed
+        expect(request.subagents).toBeDefined();
+        expect(request.subagents).toHaveLength(3);
+        expect(request.subagents?.map(s => s.name)).toEqual([
+          "quality-reviewer",
+          "security-reviewer",
+          "performance-reviewer",
+        ]);
+
+        return {
+          result: "並列レビュー完了",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "high",
+          duration: 2500,
+        };
+      },
+    };
+
+    const runId = createRunId("run-002");
+    const result = await runReviewer(task, workspace, runId, config, mockProvider);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("並列レビュー完了");
+  });
+
+  test("handles review failure gracefully (non-fatal)", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-006"),
+      title: "Test task",
+      description: "Test description",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config = {
+      teams: { reviewer: false },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        return {
+          result: "レビューエラー",
+          exitCode: 1,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 500,
+        };
+      },
+    };
+
+    const runId = createRunId("run-003");
+    const result = await runReviewer(task, workspace, runId, config, mockProvider);
+
+    // Review failure is non-fatal; returns success but logs warning
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("レビューエラー");
+  });
+
+  test("passes custom model and timeout", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-007"),
+      title: "Test task",
+      description: "Test description",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config = {
+      teams: { reviewer: false },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(request: ClaudeRequest): Promise<ClaudeResponse> {
+        expect(request.model).toBe("claude-opus-4-6");
+        expect(request.timeout).toBe(120000);
+
+        return {
+          result: "OK",
+          exitCode: 0,
+          model: "claude-opus-4-6",
+          effortLevel: "medium",
+          duration: 1000,
+        };
+      },
+    };
+
+    const runId = createRunId("run-004");
+    await runReviewer(task, workspace, runId, config, mockProvider, {
+      model: "claude-opus-4-6",
+      timeout: 120000,
+    });
+  });
+});

package/src/modules/task-execution/__tests__/tester-red.test.ts

@@ -0,0 +1,281 @@
+import { describe, test, expect } from "bun:test";
+import { runTesterRed, buildRedPhasePrompt } from "../phases/tester-red";
+import type { Task, WorkspaceInfo } from "@aad/shared/types";
+import type { ClaudeProvider, ClaudeRequest, ClaudeResponse } from "@aad/claude-provider";
+import { createTaskId } from "@aad/shared/types";
+
+describe("buildRedPhasePrompt", () => {
+  test("builds prompt with task info and workspace context", () => {
+    const task: Task = {
+      taskId: createTaskId("task-001"),
+      title: "Add user authentication",
+      description: "Implement JWT-based auth with refresh tokens",
+      filesToModify: ["src/auth.ts", "src/middleware.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const prompt = buildRedPhasePrompt(task, workspace);
+
+    expect(prompt).toContain("TDD Red フェーズ");
+    expect(prompt).toContain("task-001");
+    expect(prompt).toContain("Add user authentication");
+    expect(prompt).toContain("JWT-based auth");
+    expect(prompt).toContain("typescript");
+    expect(prompt).toContain("bun-test");
+    expect(prompt).toContain("失敗するテストを作成");
+  });
+
+  test("includes language-specific test patterns", () => {
+    const task: Task = {
+      taskId: createTaskId("task-002"),
+      title: "Test task",
+      description: "Test description",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspaceGo: WorkspaceInfo = {
+      path: "/go-project",
+      language: "go",
+      packageManager: "go-modules",
+      framework: "gin",
+      testFramework: "go-test",
+    };
+
+    const promptGo = buildRedPhasePrompt(task, workspaceGo);
+    expect(promptGo).toContain("テーブル駆動テスト");
+
+    const workspacePython: WorkspaceInfo = {
+      path: "/py-project",
+      language: "python",
+      packageManager: "pip",
+      framework: "flask",
+      testFramework: "pytest",
+    };
+
+    const promptPython = buildRedPhasePrompt(task, workspacePython);
+    expect(promptPython).toContain("pytest parametrize");
+
+    const workspaceRust: WorkspaceInfo = {
+      path: "/rust-project",
+      language: "rust",
+      packageManager: "cargo",
+      framework: "axum",
+      testFramework: "cargo",
+    };
+    const promptRust = buildRedPhasePrompt(task, workspaceRust);
+    expect(promptRust).toContain("テストケースベクター");
+
+    const workspaceTerraform: WorkspaceInfo = {
+      path: "/tf-project",
+      language: "terraform",
+      packageManager: "unknown",
+      framework: "unknown",
+      testFramework: "pytest",
+    };
+    const promptTf = buildRedPhasePrompt(task, workspaceTerraform);
+    expect(promptTf).toContain("terraform validate");
+
+    const workspaceJava: WorkspaceInfo = {
+      path: "/java-project",
+      language: "java",
+      packageManager: "maven",
+      framework: "spring",
+      testFramework: "maven",
+    };
+    const promptJava = buildRedPhasePrompt(task, workspaceJava);
+    expect(promptJava).toContain("JUnit");
+
+    const workspaceUnknown: WorkspaceInfo = {
+      path: "/unknown-project",
+      language: "elixir",
+      packageManager: "mix",
+      framework: "phoenix",
+      testFramework: "unknown",
+    };
+    const promptUnknown = buildRedPhasePrompt(task, workspaceUnknown);
+    expect(promptUnknown).toContain("適切なテストパターン");
+  });
+});
+
+describe("runTesterRed", () => {
+  test("calls Claude provider with correct request", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-003"),
+      title: "Add validation",
+      description: "Add input validation for user form",
+      filesToModify: ["src/validator.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(request: ClaudeRequest): Promise<ClaudeResponse> {
+        expect(request.prompt).toContain("TDD Red");
+        expect(request.allowedTools).toEqual([
+          "Read",
+          "Write",
+          "Edit",
+          "Glob",
+          "Grep",
+          "Bash",
+        ]);
+        expect(request.permissionMode).toBe("bypassPermissions");
+        expect(request.cwd).toBe("/workspace");
+
+        return {
+          result: "テストを作成しました",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 1200,
+        };
+      },
+    };
+
+    const result = await runTesterRed(task, workspace, mockProvider);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("テストを作成しました");
+  });
+
+  test("handles Claude provider failure", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-004"),
+      title: "Test task",
+      description: "Test description",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        return {
+          result: "エラーが発生しました",
+          exitCode: 1,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 500,
+        };
+      },
+    };
+
+    const result = await runTesterRed(task, workspace, mockProvider);
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("エラーが発生しました");
+  });
+
+  test("passes correct effort level and model", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-005"),
+      title: "Complex task",
+      description: "Complex description",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(request: ClaudeRequest): Promise<ClaudeResponse> {
+        expect(request.effortLevel).toBe("high");
+        expect(request.model).toBe("claude-opus-4-6");
+
+        return {
+          result: "OK",
+          exitCode: 0,
+          model: "claude-opus-4-6",
+          effortLevel: "high",
+          duration: 2000,
+        };
+      },
+    };
+
+    await runTesterRed(task, workspace, mockProvider, {
+      effortLevel: "high",
+      model: "claude-opus-4-6",
+    });
+  });
+
+  test("respects timeout option", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-006"),
+      title: "Test task",
+      description: "Test description",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(request: ClaudeRequest): Promise<ClaudeResponse> {
+        expect(request.timeout).toBe(60000);
+
+        return {
+          result: "OK",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 1000,
+        };
+      },
+    };
+
+    await runTesterRed(task, workspace, mockProvider, { timeout: 60000 });
+  });
+});