@ronkovic/aad 0.3.0

package/src/modules/task-execution/__tests__/implementer-green.test.ts

@@ -0,0 +1,286 @@
+import { describe, test, expect } from "bun:test";
+import {
+  runImplementerGreen,
+  buildGreenPhasePrompt,
+} from "../phases/implementer-green";
+import type { Task, WorkspaceInfo } from "@aad/shared/types";
+import type { ClaudeProvider, ClaudeRequest, ClaudeResponse } from "@aad/claude-provider";
+import { createTaskId } from "@aad/shared/types";
+
+describe("buildGreenPhasePrompt", () => {
+  test("builds Green phase prompt with task context", () => {
+    const task: Task = {
+      taskId: createTaskId("task-001"),
+      title: "Implement login endpoint",
+      description: "Create POST /login with JWT response",
+      filesToModify: ["src/routes/auth.ts", "src/services/auth.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const prompt = buildGreenPhasePrompt(task, workspace);
+
+    expect(prompt).toContain("TDD Green フェーズ");
+    expect(prompt).toContain("task-001");
+    expect(prompt).toContain("Implement login endpoint");
+    expect(prompt).toContain("POST /login");
+    expect(prompt).toContain("最小限の実装");
+    expect(prompt).toContain("テストをパスする");
+  });
+
+  test("includes language-specific coding conventions", () => {
+    const task: Task = {
+      taskId: createTaskId("task-002"),
+      title: "Test",
+      description: "Test",
+      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 = buildGreenPhasePrompt(task, workspaceGo);
+    expect(promptGo).toContain("effective Go");
+
+    const workspacePython: WorkspaceInfo = {
+      path: "/py-project",
+      language: "python",
+      packageManager: "pip",
+      framework: "flask",
+      testFramework: "pytest",
+    };
+
+    const promptPython = buildGreenPhasePrompt(task, workspacePython);
+    expect(promptPython).toContain("PEP 8");
+
+    const workspaceRust: WorkspaceInfo = {
+      path: "/rust-project",
+      language: "rust",
+      packageManager: "cargo",
+      framework: "axum",
+      testFramework: "cargo",
+    };
+
+    const promptRust = buildGreenPhasePrompt(task, workspaceRust);
+    expect(promptRust).toContain("Rust API guidelines");
+
+    const workspaceJava: WorkspaceInfo = {
+      path: "/java-project",
+      language: "java",
+      packageManager: "maven",
+      framework: "spring",
+      testFramework: "maven",
+    };
+    const promptJava = buildGreenPhasePrompt(task, workspaceJava);
+    expect(promptJava).toContain("Google Java Style Guide");
+
+    const workspaceCSharp: WorkspaceInfo = {
+      path: "/csharp-project",
+      language: "c#",
+      packageManager: "dotnet",
+      framework: "aspnet",
+      testFramework: "jest",
+    };
+    const promptCSharp = buildGreenPhasePrompt(task, workspaceCSharp);
+    expect(promptCSharp).toContain("C# Coding Conventions");
+
+    const workspaceUnknown: WorkspaceInfo = {
+      path: "/unknown-project",
+      language: "elixir",
+      packageManager: "mix",
+      framework: "phoenix",
+      testFramework: "unknown",
+    };
+    const promptUnknown = buildGreenPhasePrompt(task, workspaceUnknown);
+    expect(promptUnknown).toContain("コーディング規約");
+  });
+});
+
+describe("runImplementerGreen", () => {
+  test("calls Claude provider with Green phase prompt", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-003"),
+      title: "Add user model",
+      description: "Create User struct with validation",
+      filesToModify: ["src/models/user.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 Green");
+        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: 1500,
+        };
+      },
+    };
+
+    const result = await runImplementerGreen(task, workspace, mockProvider);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("実装を完了しました");
+  });
+
+  test("handles implementation 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: 800,
+        };
+      },
+    };
+
+    const result = await runImplementerGreen(task, workspace, mockProvider);
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("実装に失敗しました");
+  });
+
+  test("passes custom effort level and model", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-005"),
+      title: "Complex implementation",
+      description: "Complex task",
+      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: 2500,
+        };
+      },
+    };
+
+    await runImplementerGreen(task, workspace, mockProvider, {
+      effortLevel: "high",
+      model: "claude-opus-4-6",
+    });
+  });
+
+  test("respects timeout configuration", 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(90000);
+
+        return {
+          result: "OK",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 1000,
+        };
+      },
+    };
+
+    await runImplementerGreen(task, workspace, mockProvider, {
+      timeout: 90000,
+    });
+  });
+});

package/src/modules/task-execution/__tests__/merge-phase.test.ts

@@ -0,0 +1,368 @@
+import { describe, test, expect } from "bun:test";
+import {
+  runMergePhase,
+  buildConflictResolutionPrompt,
+} from "../phases/merge";
+import type { Task, WorkspaceInfo } from "@aad/shared/types";
+import type { ClaudeProvider, ClaudeRequest, ClaudeResponse } from "@aad/claude-provider";
+import type { MergeService, MergeResult } from "@aad/git-workspace";
+import { createTaskId } from "@aad/shared/types";
+
+describe("buildConflictResolutionPrompt", () => {
+  test("builds conflict resolution prompt with file list", () => {
+    const task: Task = {
+      taskId: createTaskId("task-001"),
+      title: "Add auth",
+      description: "JWT auth",
+      filesToModify: ["src/auth.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const conflicts = ["src/auth.ts", "src/middleware.ts"];
+
+    const prompt = buildConflictResolutionPrompt(task, conflicts);
+
+    expect(prompt).toContain("merge-resolverエージェント");
+    expect(prompt).toContain("マージ競合を解決");
+    expect(prompt).toContain("task-001");
+    expect(prompt).toContain("src/auth.ts");
+    expect(prompt).toContain("src/middleware.ts");
+    expect(prompt).toContain("git add");
+  });
+});
+
+describe("runMergePhase", () => {
+  test("merges successfully without conflicts", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-002"),
+      title: "Add feature",
+      description: "New feature",
+      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 taskBranch = "task/002-add-feature";
+    const parentBranch = "main";
+    const parentWorktree = "/parent/worktree";
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return {
+          success: true,
+          message: "Successfully merged",
+        };
+      },
+    } as unknown as MergeService;
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        throw new Error("Should not be called when merge succeeds");
+      },
+    };
+
+    const result = await runMergePhase(
+      task,
+      workspace,
+      taskBranch,
+      parentBranch,
+      parentWorktree,
+      mockMergeService,
+      mockProvider
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("Successfully merged");
+    expect(result.hadConflict).toBe(false);
+  });
+
+  test("handles merge conflict and resolves with Claude", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-003"),
+      title: "Conflicting change",
+      description: "Will conflict",
+      filesToModify: ["src/conflict.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const taskBranch = "task/003-conflicting-change";
+    const parentBranch = "main";
+    const parentWorktree = "/parent/worktree";
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return {
+          success: false,
+          conflicts: ["src/conflict.ts", "src/utils.ts"],
+          message: "Merge conflict detected",
+        };
+      },
+    } as unknown as MergeService;
+
+    const mockProvider: ClaudeProvider = {
+      async call(request: ClaudeRequest): Promise<ClaudeResponse> {
+        expect(request.prompt).toContain("merge-resolver");
+        expect(request.prompt).toContain("src/conflict.ts");
+        expect(request.prompt).toContain("src/utils.ts");
+        expect(request.cwd).toBe("/parent/worktree");
+        expect(request.effortLevel).toBe("low");
+        expect(request.model).toContain("haiku");
+
+        return {
+          result: "競合を解決しました",
+          exitCode: 0,
+          model: "claude-haiku-4-5",
+          effortLevel: "low",
+          duration: 500,
+        };
+      },
+    };
+
+    const result = await runMergePhase(
+      task,
+      workspace,
+      taskBranch,
+      parentBranch,
+      parentWorktree,
+      mockMergeService,
+      mockProvider
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.hadConflict).toBe(true);
+    expect(result.output).toContain("競合を解決しました");
+  });
+
+  test("fails when conflict resolution fails", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-004"),
+      title: "Failed resolution",
+      description: "Will fail to resolve",
+      filesToModify: ["src/bad.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const taskBranch = "task/004-failed-resolution";
+    const parentBranch = "main";
+    const parentWorktree = "/parent/worktree";
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return {
+          success: false,
+          conflicts: ["src/bad.ts"],
+          message: "Conflict",
+        };
+      },
+    } as unknown as MergeService;
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        return {
+          result: "解決失敗",
+          exitCode: 1,
+          model: "claude-haiku-4-5",
+          effortLevel: "low",
+          duration: 300,
+        };
+      },
+    };
+
+    const result = await runMergePhase(
+      task,
+      workspace,
+      taskBranch,
+      parentBranch,
+      parentWorktree,
+      mockMergeService,
+      mockProvider
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.hadConflict).toBe(true);
+    expect(result.output).toContain("解決失敗");
+  });
+
+  test("uses custom model for conflict resolution", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-005"),
+      title: "Custom model",
+      description: "Test",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const taskBranch = "task/005-custom-model";
+    const parentBranch = "main";
+    const parentWorktree = "/parent/worktree";
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return {
+          success: false,
+          conflicts: ["src/file.ts"],
+        };
+      },
+    } as unknown as MergeService;
+
+    const mockProvider: ClaudeProvider = {
+      async call(request: ClaudeRequest): Promise<ClaudeResponse> {
+        expect(request.model).toBe("claude-sonnet-4-5");
+
+        return {
+          result: "OK",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "low",
+          duration: 500,
+        };
+      },
+    };
+
+    await runMergePhase(
+      task,
+      workspace,
+      taskBranch,
+      parentBranch,
+      parentWorktree,
+      mockMergeService,
+      mockProvider,
+      {
+        mergeResolverModel: "claude-sonnet-4-5",
+      }
+    );
+  });
+
+  test("fails with no conflicts (unexpected merge error)", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-006"),
+      title: "No conflict failure",
+      description: "Merge fails without conflicts",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return {
+          success: false,
+          conflicts: [],
+          message: "Unknown merge error",
+        };
+      },
+    } as unknown as MergeService;
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        throw new Error("Should not be called");
+      },
+    };
+
+    const result = await runMergePhase(
+      task, workspace, "branch", "main", "/parent",
+      mockMergeService, mockProvider
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.hadConflict).toBe(false);
+    expect(result.output).toContain("Unknown merge error");
+  });
+
+  test("fails with no conflicts and no message", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-007"),
+      title: "No message failure",
+      description: "Merge fails without message",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return { success: false };
+      },
+    } as unknown as MergeService;
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        throw new Error("Should not be called");
+      },
+    };
+
+    const result = await runMergePhase(
+      task, workspace, "branch", "main", "/parent",
+      mockMergeService, mockProvider
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.hadConflict).toBe(false);
+  });
+});