@ronkovic/aad 0.3.0

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

@@ -0,0 +1,313 @@
+import { describe, test, expect } from "bun:test";
+import {
+  buildTestCommand,
+  runTests,
+  type ProcessSpawner,
+} from "../phases/tester-verify";
+import type { WorkspaceInfo } from "@aad/shared/types";
+
+describe("buildTestCommand", () => {
+  test("builds bun test command", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path/to/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    expect(buildTestCommand(workspace)).toEqual(["bun", "test"]);
+  });
+
+  test("builds vitest command", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path/to/workspace",
+      language: "typescript",
+      packageManager: "npm",
+      framework: "vite",
+      testFramework: "vitest",
+    };
+
+    expect(buildTestCommand(workspace)).toEqual(["npm", "run", "test"]);
+  });
+
+  test("builds jest command", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path/to/workspace",
+      language: "javascript",
+      packageManager: "yarn",
+      framework: "react",
+      testFramework: "jest",
+    };
+
+    expect(buildTestCommand(workspace)).toEqual(["yarn", "test"]);
+  });
+
+  test("builds pytest command", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path/to/workspace",
+      language: "python",
+      packageManager: "pip",
+      framework: "flask",
+      testFramework: "pytest",
+    };
+
+    expect(buildTestCommand(workspace)).toEqual(["pytest", "-v"]);
+  });
+
+  test("builds go test command", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path/to/workspace",
+      language: "go",
+      packageManager: "go-modules",
+      framework: "gin",
+      testFramework: "go-test",
+    };
+
+    expect(buildTestCommand(workspace)).toEqual(["go", "test", "./..."]);
+  });
+
+  test("builds cargo test command", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path/to/workspace",
+      language: "rust",
+      packageManager: "cargo",
+      framework: "axum",
+      testFramework: "cargo",
+    };
+
+    expect(buildTestCommand(workspace)).toEqual(["cargo", "test"]);
+  });
+
+  test("builds vitest command with yarn", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "typescript",
+      packageManager: "yarn",
+      framework: "vite",
+      testFramework: "vitest",
+    };
+    expect(buildTestCommand(workspace)).toEqual(["yarn", "test"]);
+  });
+
+  test("builds vitest command with pnpm", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "typescript",
+      packageManager: "pnpm",
+      framework: "vite",
+      testFramework: "vitest",
+    };
+    expect(buildTestCommand(workspace)).toEqual(["pnpm", "test"]);
+  });
+
+  test("builds vitest command with default (npx)", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "vite",
+      testFramework: "vitest",
+    };
+    expect(buildTestCommand(workspace)).toEqual(["npx", "vitest", "run"]);
+  });
+
+  test("builds jest command with npm", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "javascript",
+      packageManager: "npm",
+      framework: "react",
+      testFramework: "jest",
+    };
+    expect(buildTestCommand(workspace)).toEqual(["npm", "test"]);
+  });
+
+  test("builds jest command with pnpm", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "javascript",
+      packageManager: "pnpm",
+      framework: "react",
+      testFramework: "jest",
+    };
+    expect(buildTestCommand(workspace)).toEqual(["pnpm", "test"]);
+  });
+
+  test("builds jest command with default (npx)", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "javascript",
+      packageManager: "bun",
+      framework: "react",
+      testFramework: "jest",
+    };
+    expect(buildTestCommand(workspace)).toEqual(["npx", "jest"]);
+  });
+
+  test("builds mocha command with npm", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "javascript",
+      packageManager: "npm",
+      framework: "express",
+      testFramework: "mocha",
+    };
+    expect(buildTestCommand(workspace)).toEqual(["npm", "test"]);
+  });
+
+  test("builds mocha command with yarn", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "javascript",
+      packageManager: "yarn",
+      framework: "express",
+      testFramework: "mocha",
+    };
+    expect(buildTestCommand(workspace)).toEqual(["yarn", "test"]);
+  });
+
+  test("builds mocha command with default (npx)", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "javascript",
+      packageManager: "pnpm",
+      framework: "express",
+      testFramework: "mocha",
+    };
+    expect(buildTestCommand(workspace)).toEqual(["npx", "mocha"]);
+  });
+
+  test("builds maven test command", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "java",
+      packageManager: "maven",
+      framework: "spring",
+      testFramework: "maven",
+    };
+    expect(buildTestCommand(workspace)).toEqual(["mvn", "test"]);
+  });
+
+  test("builds gradle test command", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path",
+      language: "java",
+      packageManager: "gradle",
+      framework: "spring",
+      testFramework: "gradle",
+    };
+    expect(buildTestCommand(workspace)).toEqual(["./gradlew", "test"]);
+  });
+
+  test("throws error for unknown test framework", () => {
+    const workspace: WorkspaceInfo = {
+      path: "/path/to/workspace",
+      language: "unknown",
+      packageManager: "unknown",
+      framework: "unknown",
+      testFramework: "unknown",
+    };
+
+    expect(() => buildTestCommand(workspace)).toThrow("Unsupported test framework");
+  });
+});
+
+describe("runTests", () => {
+  test("runs tests successfully with exit code 0", async () => {
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const mockSpawner: ProcessSpawner = {
+      async spawn(cmd, args, opts) {
+        expect(cmd).toBe("bun");
+        expect(args).toEqual(["test"]);
+        expect(opts.cwd).toBe("/workspace");
+        return {
+          exitCode: 0,
+          stdout: "All tests passed",
+          stderr: "",
+        };
+      },
+    };
+
+    const result = await runTests(workspace, mockSpawner);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("All tests passed");
+  });
+
+  test("runs tests with failure (exit code 1)", async () => {
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "python",
+      packageManager: "pip",
+      framework: "flask",
+      testFramework: "pytest",
+    };
+
+    const mockSpawner: ProcessSpawner = {
+      async spawn(cmd, args, _opts) {
+        expect(cmd).toBe("pytest");
+        expect(args).toEqual(["-v"]);
+        return {
+          exitCode: 1,
+          stdout: "FAILED test_foo.py::test_bar",
+          stderr: "AssertionError",
+        };
+      },
+    };
+
+    const result = await runTests(workspace, mockSpawner);
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain("FAILED");
+    expect(result.error).toContain("AssertionError");
+  });
+
+  test("respects timeout configuration", async () => {
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const mockSpawner: ProcessSpawner = {
+      async spawn(_cmd, _args, opts) {
+        expect(opts.timeout).toBe(60000);
+        return {
+          exitCode: 0,
+          stdout: "OK",
+          stderr: "",
+        };
+      },
+    };
+
+    await runTests(workspace, mockSpawner, 60000);
+  });
+
+  test("handles process spawn errors", async () => {
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "go",
+      packageManager: "go-modules",
+      framework: "gin",
+      testFramework: "go-test",
+    };
+
+    const mockSpawner: ProcessSpawner = {
+      async spawn() {
+        throw new Error("Command not found: go");
+      },
+    };
+
+    await expect(runTests(workspace, mockSpawner)).rejects.toThrow("Command not found: go");
+  });
+});

package/src/modules/task-execution/executor.ts

@@ -0,0 +1,303 @@
+import type {
+  Task,
+  WorkspaceInfo,
+  RunId,
+  TaskExecutionResult,
+} from "@aad/shared/types";
+import type { Config } from "@aad/shared/config";
+import type { ClaudeProvider } from "@aad/claude-provider";
+import type { MergeService } from "@aad/git-workspace";
+import type { EventBus } from "@aad/shared/events";
+import type { ProcessSpawner } from "./phases/tester-verify";
+
+import { estimateTaskComplexity, getAdaptiveEffortLevel } from "@aad/claude-provider";
+import { runTesterRed } from "./phases/tester-red";
+import { runImplementerGreen } from "./phases/implementer-green";
+import { runTests } from "./phases/tester-verify";
+import { runReviewer } from "./phases/reviewer";
+import { runMergePhase } from "./phases/merge";
+import { PhaseError } from "@aad/shared/errors";
+
+/**
+ * Execute full TDD pipeline for a task
+ * Phases: Red → Green → Verify → Review → Merge
+ */
+export async function executeTddPipeline(
+  task: Task,
+  workspace: WorkspaceInfo,
+  taskBranch: string,
+  parentBranch: string,
+  parentWorktree: string,
+  runId: RunId,
+  config: Config,
+  provider: ClaudeProvider,
+  mergeService: MergeService,
+  eventBus: EventBus,
+  testSpawner?: ProcessSpawner
+): Promise<TaskExecutionResult> {
+  const startTime = Date.now();
+
+  try {
+    // Estimate task complexity for adaptive effort
+    const complexity = estimateTaskComplexity(task);
+    const testerEffort = getAdaptiveEffortLevel("tester", complexity, config);
+    const implementerEffort = getAdaptiveEffortLevel("implementer", complexity, config);
+    const reviewerEffort = getAdaptiveEffortLevel("reviewer", complexity, config);
+
+    eventBus.emit({
+      type: "log:entry",
+      entry: {
+        level: "info",
+        service: "task-execution",
+        message: `Task complexity estimated`,
+        timestamp: Date.now(),
+        taskId: task.taskId as string,
+        complexity,
+        adaptiveEffort: config.adaptiveEffort,
+        fileCount: task.filesToModify.length,
+        dependencyCount: task.dependsOn.length,
+        descriptionLength: task.description.length,
+        effortLevels: { tester: testerEffort, implementer: implementerEffort, reviewer: reviewerEffort },
+      },
+    });
+
+    // ===== Phase 1: Red - Create failing tests =====
+    eventBus.emit({
+      type: "execution:phase:started",
+      taskId: task.taskId,
+      phase: "red",
+    });
+
+    const redStart = Date.now();
+    const redResult = await runTesterRed(task, workspace, provider, {
+      effortLevel: testerEffort,
+      model: config.models.tester,
+      timeout: config.timeouts.claude * 1000,
+    });
+
+    if (!redResult.success) {
+      eventBus.emit({
+        type: "execution:phase:failed",
+        taskId: task.taskId,
+        phase: "red",
+        error: redResult.output,
+      });
+
+      throw new PhaseError("Red phase failed: failed to create tests", {
+        taskId: task.taskId,
+        phase: "red",
+        output: redResult.output,
+      });
+    }
+
+    eventBus.emit({
+      type: "execution:phase:completed",
+      taskId: task.taskId,
+      phase: "red",
+      duration: Date.now() - redStart,
+    });
+
+    // ===== Phase 2: Green - Implement minimal code =====
+    eventBus.emit({
+      type: "execution:phase:started",
+      taskId: task.taskId,
+      phase: "green",
+    });
+
+    const greenStart = Date.now();
+    const greenResult = await runImplementerGreen(task, workspace, provider, {
+      effortLevel: implementerEffort,
+      model: config.models.implementer,
+      timeout: config.timeouts.claude * 1000,
+    });
+
+    if (!greenResult.success) {
+      eventBus.emit({
+        type: "execution:phase:failed",
+        taskId: task.taskId,
+        phase: "green",
+        error: greenResult.output,
+      });
+
+      throw new PhaseError("Green phase failed: implementation error", {
+        taskId: task.taskId,
+        phase: "green",
+        output: greenResult.output,
+      });
+    }
+
+    eventBus.emit({
+      type: "execution:phase:completed",
+      taskId: task.taskId,
+      phase: "green",
+      duration: Date.now() - greenStart,
+    });
+
+    // ===== Commit generated code =====
+    // Commit changes after Green phase so they can be merged later
+    try {
+      await Bun.$`git -C ${workspace.path} add -A`.quiet();
+      await Bun.$`git -C ${workspace.path} commit -m ${"feat: Implement " + task.title}`.quiet();
+    } catch (_error) {
+      // If commit fails (e.g., no changes), log but don't fail the pipeline
+      // This can happen if Claude didn't generate any new files
+    }
+
+    // ===== Phase 3: Verify - Run tests =====
+    eventBus.emit({
+      type: "execution:phase:started",
+      taskId: task.taskId,
+      phase: "verify",
+    });
+
+    const verifyStart = Date.now();
+    const verifyResult = await runTests(
+      workspace,
+      testSpawner,
+      config.timeouts.test * 1000
+    );
+
+    if (!verifyResult.success) {
+      eventBus.emit({
+        type: "execution:phase:failed",
+        taskId: task.taskId,
+        phase: "verify",
+        error: verifyResult.error ?? "Tests failed",
+      });
+
+      throw new PhaseError("Verify phase failed: tests did not pass", {
+        taskId: task.taskId,
+        phase: "verify",
+        output: verifyResult.output,
+        error: verifyResult.error,
+      });
+    }
+
+    eventBus.emit({
+      type: "execution:phase:completed",
+      taskId: task.taskId,
+      phase: "verify",
+      duration: Date.now() - verifyStart,
+    });
+
+    // ===== Phase 4: Review - Code review (non-fatal) =====
+    eventBus.emit({
+      type: "execution:phase:started",
+      taskId: task.taskId,
+      phase: "review",
+    });
+
+    const reviewStart = Date.now();
+    const reviewResult = await runReviewer(
+      task,
+      workspace,
+      runId,
+      config,
+      provider,
+      {
+        model: config.models.reviewer,
+        timeout: config.timeouts.claude * 1000,
+      }
+    );
+
+    if (!reviewResult.success) {
+      // Review failure is non-fatal; log and continue
+      eventBus.emit({
+        type: "execution:phase:failed",
+        taskId: task.taskId,
+        phase: "review",
+        error: reviewResult.output,
+      });
+    } else {
+      eventBus.emit({
+        type: "execution:phase:completed",
+        taskId: task.taskId,
+        phase: "review",
+        duration: Date.now() - reviewStart,
+      });
+    }
+
+    // ===== Phase 5: Merge - Merge to parent branch =====
+    eventBus.emit({
+      type: "execution:phase:started",
+      taskId: task.taskId,
+      phase: "merge",
+    });
+
+    const mergeStart = Date.now();
+    const mergeResult = await runMergePhase(
+      task,
+      workspace,
+      taskBranch,
+      parentBranch,
+      parentWorktree,
+      mergeService,
+      provider,
+      {
+        mergeResolverModel: config.models.mergeResolver,
+        timeout: config.timeouts.claude * 1000,
+      }
+    );
+
+    if (!mergeResult.success) {
+      eventBus.emit({
+        type: "execution:phase:failed",
+        taskId: task.taskId,
+        phase: "merge",
+        error: mergeResult.output,
+      });
+
+      throw new PhaseError("Merge phase failed", {
+        taskId: task.taskId,
+        phase: "merge",
+        output: mergeResult.output,
+        hadConflict: mergeResult.hadConflict,
+      });
+    }
+
+    if (mergeResult.hadConflict) {
+      // Emit conflict event for monitoring
+      eventBus.emit({
+        type: "execution:merge:conflict",
+        taskId: task.taskId,
+        conflictedFiles: [], // MergeService would provide this
+      });
+    }
+
+    eventBus.emit({
+      type: "execution:phase:completed",
+      taskId: task.taskId,
+      phase: "merge",
+      duration: Date.now() - mergeStart,
+    });
+
+    // ===== Pipeline completed successfully =====
+    const duration = Date.now() - startTime;
+
+    return {
+      taskId: task.taskId,
+      status: "completed",
+      duration,
+      output: "TDD pipeline completed successfully",
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+
+    if (error instanceof PhaseError) {
+      return {
+        taskId: task.taskId,
+        status: "failed",
+        duration,
+        error: error.message,
+        output: JSON.stringify(error.context),
+      };
+    }
+
+    return {
+      taskId: task.taskId,
+      status: "failed",
+      duration,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}

package/src/modules/task-execution/index.ts

@@ -0,0 +1,45 @@
+// Main executor
+export { executeTddPipeline } from "./executor";
+
+// Phase functions
+export { runTesterRed, buildRedPhasePrompt } from "./phases/tester-red";
+export type { PhaseResult as TesterRedResult, TesterRedOptions } from "./phases/tester-red";
+
+export {
+  runImplementerGreen,
+  buildGreenPhasePrompt,
+} from "./phases/implementer-green";
+export type {
+  PhaseResult as ImplementerGreenResult,
+  ImplementerGreenOptions,
+} from "./phases/implementer-green";
+
+export { runTests, buildTestCommand } from "./phases/tester-verify";
+export type {
+  TestResult,
+  ProcessSpawner,
+  ProcessResult,
+} from "./phases/tester-verify";
+
+export {
+  runReviewer,
+  buildReviewPrompt,
+  buildTeamsReviewPrompt,
+} from "./phases/reviewer";
+export type {
+  PhaseResult as ReviewerResult,
+  ReviewerOptions,
+  ReviewConfig,
+} from "./phases/reviewer";
+
+export {
+  runMergePhase,
+  buildConflictResolutionPrompt,
+} from "./phases/merge";
+export type {
+  MergePhaseResult,
+  MergePhaseOptions,
+} from "./phases/merge";
+
+// Default spawner
+export { createDefaultSpawner } from "./phases/default-spawner";

package/src/modules/task-execution/phases/default-spawner.ts

@@ -0,0 +1,49 @@
+import type { ProcessSpawner, ProcessResult } from "./tester-verify";
+import { TimeoutError } from "@aad/shared/errors";
+
+/**
+ * Create default ProcessSpawner using Bun.spawn
+ */
+export function createDefaultSpawner(): ProcessSpawner {
+  return {
+    async spawn(cmd, args, opts): Promise<ProcessResult> {
+      const proc = Bun.spawn([cmd, ...args], {
+        cwd: opts.cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      const timeout = opts.timeout ?? 300000;
+      const timer = setTimeout(() => {
+        proc.kill();
+      }, timeout);
+
+      try {
+        const [stdout, stderr, exitCode] = await Promise.all([
+          new Response(proc.stdout).text(),
+          new Response(proc.stderr).text(),
+          proc.exited,
+        ]);
+
+        clearTimeout(timer);
+
+        return {
+          exitCode,
+          stdout,
+          stderr,
+        };
+      } catch (error) {
+        clearTimeout(timer);
+
+        if (error instanceof Error && error.message.includes("killed")) {
+          throw new TimeoutError(
+            `Process timed out after ${timeout}ms`,
+            { cmd, args, timeout }
+          );
+        }
+
+        throw error;
+      }
+    },
+  };
+}