@ronkovic/aad 0.3.0

package/src/__tests__/integration/pipeline.test.ts

@@ -0,0 +1,346 @@
+/**
+ * Integration Test: Cross-Module Pipeline
+ * Tests the integration between planning, task-queue, task-execution, and git-workspace modules
+ */
+
+import { describe, test, expect, beforeEach } from "bun:test";
+import { PlanningService } from "@aad/planning";
+import { Dispatcher, getReadyTasks, validateTaskPlan } from "@aad/task-queue";
+import { BranchManager, WorktreeManager, MergeService } from "@aad/git-workspace";
+import { EventBus } from "../../shared/events";
+import { createRunId, createTaskId, createWorkerId, type Task } from "../../shared/types";
+import { CircularDependencyError } from "../../shared/errors";
+import { createStores, type Stores } from "@aad/persistence";
+import type { Config } from "../../shared/config";
+import { pino } from "pino";
+
+describe("Cross-Module Integration: Pipeline", () => {
+  let eventBus: EventBus;
+  let config: Config;
+  let stores: Stores;
+
+  beforeEach(() => {
+    eventBus = new EventBus();
+    config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      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" },
+    };
+    stores = createStores("memory");
+  });
+
+  describe("Module Interface Compatibility", () => {
+    test("planning produces task plan compatible with task-queue", async () => {
+      const logger = pino({ level: "silent" });
+      const mockClaudeProvider = {
+        async call() {
+          return {
+            result: JSON.stringify({
+              run_id: "run-001",
+              parent_branch: "main",
+              tasks: [
+                {
+                  task_id: "task-1",
+                  title: "Test task",
+                  description: "Test description",
+                  files_to_modify: ["test.ts"],
+                  depends_on: [],
+                  priority: 1,
+                },
+              ],
+            }),
+            exitCode: 0,
+            model: "claude-sonnet-4-5",
+            effortLevel: "medium",
+            duration: 1000,
+          };
+        },
+      } as any;
+
+      // Mock FileChecker for project detection
+      const mockFileChecker = {
+        async exists() { return false; },
+        async readText() { return ""; },
+        async glob() { return []; },
+      };
+
+      const planningService = new PlanningService(
+        mockClaudeProvider,
+        eventBus,
+        config,
+        logger,
+        { fileChecker: mockFileChecker }
+      );
+
+      const taskPlan = await planningService.planTasks({
+        runId: createRunId("run-001"),
+        requirementsPath: "/tmp/requirements.md",
+        parentBranch: "main",
+        projectRoot: "/test/repo",
+        targetDocsDir: "/test/repo/.aad/docs/run-001",
+      });
+
+      // Validate task plan structure is compatible with task-queue
+      expect(taskPlan.runId).toBeDefined();
+      expect(taskPlan.parentBranch).toBe("main");
+      expect(taskPlan.tasks).toBeInstanceOf(Array);
+      expect(taskPlan.tasks.length).toBeGreaterThan(0);
+
+      // Verify task-queue can validate the plan (throws on error)
+      expect(() => validateTaskPlan(taskPlan.tasks)).not.toThrow();
+    });
+
+    test("task-queue dispatcher works with EventBus", async () => {
+      const task: Task = {
+        taskId: createTaskId("task-001"),
+        title: "Test task",
+        description: "Test",
+        filesToModify: ["test.ts"],
+        dependsOn: [],
+        priority: 1,
+        status: "pending",
+        retryCount: 0,
+      };
+
+      await stores.taskStore.save(task);
+
+      const dispatcher = new Dispatcher({
+        eventBus,
+        taskStore: stores.taskStore,
+        workerStore: stores.workerStore,
+        runStore: stores.runStore,
+        config: {
+          maxRetries: config.retry.maxRetries,
+          staleTaskThreshold: config.timeouts.staleTask,
+        },
+        logger: pino({ level: "silent" }),
+      });
+
+      const events: string[] = [];
+      eventBus.on("queue:initialized", (event) => {
+        if (event.type === "queue:initialized") {
+          events.push(event.type);
+        }
+      });
+
+      await dispatcher.initialize({
+        runId: createRunId("run-001"),
+        parentBranch: "main",
+        tasks: [task],
+      });
+
+      // Verify dispatcher emits queue:initialized event
+      expect(events).toContain("queue:initialized");
+    });
+
+    test("git-workspace modules integrate correctly", async () => {
+      const repoRoot = "/test/repo";
+      const worktreeBase = "/test/worktrees";
+
+      const branchManager = new BranchManager({
+        repoRoot,
+        logger: pino({ level: "silent" }),
+      });
+
+      const worktreeManager = new WorktreeManager({
+        repoRoot,
+        worktreeBase,
+        logger: pino({ level: "silent" }),
+      });
+
+      const mergeService = new MergeService({
+        repoRoot,
+        logger: pino({ level: "silent" }),
+      });
+
+      // Verify all git-workspace modules share compatible interfaces
+      expect(branchManager).toHaveProperty("createTaskBranch");
+      expect(worktreeManager).toHaveProperty("createTaskWorktree");
+      expect(mergeService).toHaveProperty("mergeToParent");
+    });
+  });
+
+  describe("Data Flow Between Modules", () => {
+    test("task flows from planning to task-queue to task-execution", async () => {
+      // Step 1: Planning produces tasks
+      const tasks: Task[] = [
+        {
+          taskId: createTaskId("task-001"),
+          title: "Add feature",
+          description: "New feature",
+          filesToModify: ["src/feature.ts"],
+          dependsOn: [],
+          priority: 1,
+          status: "pending",
+          retryCount: 0,
+        },
+      ];
+
+      // Step 2: Task-queue validates and manages tasks
+      expect(() => validateTaskPlan(tasks)).not.toThrow();
+
+      const taskMap = new Map(tasks.map((t) => [t.taskId, t]));
+      const readyTasks = getReadyTasks(taskMap);
+      expect(readyTasks.length).toBeGreaterThan(0);
+      expect(readyTasks[0]!.taskId).toBe(tasks[0]!.taskId);
+
+      // Step 3: Task-execution can process the task structure
+      // (We don't actually execute, just verify the interface compatibility)
+      const task = tasks[0]!;
+      expect(task.taskId).toBeDefined();
+      expect(task.filesToModify).toBeInstanceOf(Array);
+      expect(task.dependsOn).toBeInstanceOf(Array);
+    });
+
+    test("EventBus enables cross-module communication", async () => {
+      const events: Array<{ type: string; source: string }> = [];
+
+      // Simulate planning emitting event
+      eventBus.on("planning:completed", (event) => {
+        if (event.type === "planning:completed") {
+          events.push({ type: event.type, source: "planning" });
+        }
+      });
+
+      // Simulate task-queue emitting event
+      eventBus.on("task:dispatched", (event) => {
+        if (event.type === "task:dispatched") {
+          events.push({ type: event.type, source: "task-queue" });
+        }
+      });
+
+      // Emit events
+      eventBus.emit({
+        type: "planning:completed",
+        taskCount: 5,
+      });
+
+      eventBus.emit({
+        type: "task:dispatched",
+        taskId: createTaskId("task-001"),
+        workerId: createWorkerId("worker-1"),
+      });
+
+      expect(events).toHaveLength(2);
+      expect(events[0]?.type).toBe("planning:completed");
+      expect(events[1]?.type).toBe("task:dispatched");
+    });
+  });
+
+  describe("Type Compatibility", () => {
+    test("shared types are compatible across modules", () => {
+      const testRunId = createRunId("run-001");
+      const testTaskId = createTaskId("task-001");
+
+      // Verify branded types work across modules
+      const testTask: Task = {
+        taskId: testTaskId,
+        title: "Test",
+        description: "Test",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 1,
+        status: "pending",
+        retryCount: 0,
+      };
+
+      expect(testRunId).toBeDefined();
+      expect(testTask.taskId).toBe(testTaskId);
+
+      // Verify Config type is consistent
+      expect(config.workers.num).toBeGreaterThan(0);
+      expect(config.timeouts.claude).toBeGreaterThan(0);
+      expect(config.dashboard.port).toBeGreaterThan(0);
+    });
+
+    test("stores interface is compatible with dispatcher", async () => {
+      const task: Task = {
+        taskId: createTaskId("task-001"),
+        title: "Test",
+        description: "Test",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 1,
+        status: "pending",
+        retryCount: 0,
+      };
+
+      // Verify stores implement the expected interface
+      await stores.taskStore.save(task);
+      const retrieved = await stores.taskStore.get(task.taskId);
+      expect(retrieved?.taskId).toBe(task.taskId);
+
+      // Verify Dispatcher can use these stores
+      const dispatcher = new Dispatcher({
+        eventBus,
+        taskStore: stores.taskStore,
+        workerStore: stores.workerStore,
+        runStore: stores.runStore,
+        config: {
+          maxRetries: config.retry.maxRetries,
+          staleTaskThreshold: config.timeouts.staleTask,
+        },
+        logger: pino({ level: "silent" }),
+      });
+
+      expect(dispatcher).toBeDefined();
+    });
+  });
+
+  describe("Error Propagation", () => {
+    test("errors from planning propagate correctly", async () => {
+      const logger = pino({ level: "silent" });
+      const mockClaudeProvider = {
+        async call() {
+          return {
+            result: "Invalid JSON",
+            exitCode: 1,
+            model: "claude-sonnet-4-5",
+            effortLevel: "medium",
+            duration: 1000,
+          };
+        },
+      } as any;
+
+      const planningService = new PlanningService(
+        mockClaudeProvider,
+        eventBus,
+        config,
+        logger
+      );
+
+      await expect(
+        planningService.planTasks({
+          runId: createRunId("run-001"),
+          requirementsPath: "/tmp/requirements.md",
+          parentBranch: "main",
+          projectRoot: "/test/repo",
+          targetDocsDir: "/test/repo/.aad/docs/run-001",
+        })
+      ).rejects.toThrow();
+    });
+
+    test("task validation errors are caught by task-queue", () => {
+      const invalidTasks: Task[] = [
+        {
+          taskId: createTaskId("task-001"),
+          title: "Task 1",
+          description: "Depends on itself",
+          filesToModify: [],
+          dependsOn: [createTaskId("task-001")], // Circular dependency
+          priority: 1,
+          status: "pending",
+          retryCount: 0,
+        },
+      ];
+
+      expect(() => validateTaskPlan(invalidTasks)).toThrow(CircularDependencyError);
+    });
+  });
+});

package/src/bun-imports.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Bun-specific import attributes type declarations
+ */
+
+declare module "*.html" {
+  const content: string;
+  export default content;
+}
+
+declare module "*.json" {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const value: any;
+  export default value;
+}

package/src/main.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env bun
+/**
+ * AAD - Autonomous Agent Development Orchestrator
+ * CLI Entry Point
+ */
+
+import { Command } from "commander";
+import {
+  createApp,
+  createRunCommand,
+  createResumeCommand,
+  createStatusCommand,
+  createCleanupCommand,
+  type App,
+  type AppOptions,
+} from "./modules/cli";
+import packageJson from "../package.json" with { type: "json" };
+
+const program = new Command()
+  .name("aad")
+  .description("Autonomous Agent Development Orchestrator - Multi-agent TDD pipeline")
+  .version(packageJson.version);
+
+// Global options
+program
+  .option("-w, --workers <number>", "Number of workers", parseInt)
+  .option("--persist <mode>", "Persistence mode: memory or fs", "memory")
+  .option("--debug", "Enable debug logging", false)
+  .option("--no-dashboard", "Disable dashboard server")
+  .option("--provider <type>", "Default provider: cli or sdk", "cli");
+
+// App factory with global options
+const getApp = (): App => {
+  const opts = program.opts();
+  const appOptions: AppOptions = {
+    workers: opts.workers,
+    persist: opts.persist,
+    debug: opts.debug,
+    dashboard: opts.dashboard,
+    providerDefault: opts.provider,
+  };
+  return createApp(appOptions);
+};
+
+// Commands
+program.addCommand(createRunCommand(getApp));
+program.addCommand(createResumeCommand(getApp));
+program.addCommand(createStatusCommand(getApp));
+program.addCommand(createCleanupCommand(getApp));
+
+// Parse CLI args
+program.parse();

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

@@ -0,0 +1,277 @@
+import { describe, test, expect, mock } from "bun:test";
+import { ClaudeCliAdapter } from "../claude-cli.adapter";
+import type { Config } from "../../../shared/config";
+import type pino from "pino";
+
+describe("ClaudeCliAdapter", () => {
+  const mockConfig: Config = {
+    timeouts: {
+      claude: 1200,
+      test: 600,
+      staleTask: 5400,
+    },
+    retry: {
+      maxRetries: 2,
+    },
+    models: {
+      default: "sonnet",
+    },
+  } as Config;
+
+  const mockLogger = {
+    info: mock(() => {}),
+    error: mock(() => {}),
+    warn: mock(() => {}),
+    debug: mock(() => {}),
+  } as unknown as pino.Logger;
+
+  test("constructs CLI arguments correctly", async () => {
+    const adapter = new ClaudeCliAdapter(mockConfig, mockLogger);
+
+    // Bun.spawnをモック
+    const originalSpawn = Bun.spawn;
+    let capturedArgs: string[] = [];
+
+    (Bun as any).spawn = (args: string[]) => {
+      capturedArgs = args;
+      return {
+        exited: Promise.resolve({ exitCode: 0 }),
+        stdout: {
+          text: async () => "test output",
+        },
+        stderr: {
+          text: async () => "",
+        },
+      };
+    };
+
+    try {
+      await adapter.call({
+        prompt: "test prompt",
+        model: "opus",
+        effortLevel: "high",
+        timeout: 30,
+      });
+
+      expect(capturedArgs).toContain("claude");
+      expect(capturedArgs).toContain("-p");
+      expect(capturedArgs).toContain("--model");
+      expect(capturedArgs).toContain("opus");
+      expect(capturedArgs).toContain("test prompt");
+    } finally {
+      (Bun as any).spawn = originalSpawn;
+    }
+  });
+
+  test("includes system prompt when provided", async () => {
+    const adapter = new ClaudeCliAdapter(mockConfig, mockLogger);
+
+    const originalSpawn = Bun.spawn;
+    let capturedArgs: string[] = [];
+
+    (Bun as any).spawn = (args: string[]) => {
+      capturedArgs = args;
+      return {
+        exited: Promise.resolve({ exitCode: 0 }),
+        stdout: {
+          text: async () => "test output",
+        },
+        stderr: {
+          text: async () => "",
+        },
+      };
+    };
+
+    try {
+      await adapter.call({
+        prompt: "test prompt",
+        systemPrompt: "You are a test assistant",
+      });
+
+      expect(capturedArgs).toContain("--append-system-prompt");
+      expect(capturedArgs).toContain("You are a test assistant");
+    } finally {
+      (Bun as any).spawn = originalSpawn;
+    }
+  });
+
+  test("includes allowed tools when provided", async () => {
+    const adapter = new ClaudeCliAdapter(mockConfig, mockLogger);
+
+    const originalSpawn = Bun.spawn;
+    let capturedArgs: string[] = [];
+
+    (Bun as any).spawn = (args: string[]) => {
+      capturedArgs = args;
+      return {
+        exited: Promise.resolve({ exitCode: 0 }),
+        stdout: {
+          text: async () => "test output",
+        },
+        stderr: {
+          text: async () => "",
+        },
+      };
+    };
+
+    try {
+      await adapter.call({
+        prompt: "test prompt",
+        allowedTools: ["read", "write"],
+      });
+
+      expect(capturedArgs).toContain("--allowed-tools");
+      expect(capturedArgs).toContain("read,write");
+    } finally {
+      (Bun as any).spawn = originalSpawn;
+    }
+  });
+
+  test("injects subagents into prompt as fallback", async () => {
+    const adapter = new ClaudeCliAdapter(mockConfig, mockLogger);
+
+    const originalSpawn = Bun.spawn;
+    let capturedArgs: string[] = [];
+
+    (Bun as any).spawn = (args: string[]) => {
+      capturedArgs = args;
+      return {
+        exited: Promise.resolve({ exitCode: 0 }),
+        stdout: {
+          text: async () => "test output",
+        },
+        stderr: {
+          text: async () => "",
+        },
+      };
+    };
+
+    try {
+      await adapter.call({
+        prompt: "test prompt",
+        subagents: [
+          { name: "analyzer", prompt: "Analyze the code" },
+          { name: "reviewer", prompt: "Review the code" },
+        ],
+      });
+
+      const promptArg = capturedArgs[capturedArgs.length - 1];
+      expect(promptArg).toContain("test prompt");
+      expect(promptArg).toContain("Available Subagents");
+      expect(promptArg).toContain("analyzer: Analyze the code");
+      expect(promptArg).toContain("reviewer: Review the code");
+    } finally {
+      (Bun as any).spawn = originalSpawn;
+    }
+  });
+
+  test("does not inject subagents when empty", async () => {
+    const adapter = new ClaudeCliAdapter(mockConfig, mockLogger);
+
+    const originalSpawn = Bun.spawn;
+    let capturedArgs: string[] = [];
+
+    (Bun as any).spawn = (args: string[]) => {
+      capturedArgs = args;
+      return {
+        exited: Promise.resolve({ exitCode: 0 }),
+        stdout: {
+          text: async () => "test output",
+        },
+        stderr: {
+          text: async () => "",
+        },
+      };
+    };
+
+    try {
+      await adapter.call({
+        prompt: "test prompt",
+        subagents: [],
+      });
+
+      const promptArg = capturedArgs[capturedArgs.length - 1];
+      expect(promptArg).toBe("test prompt");
+      expect(promptArg).not.toContain("Available Subagents");
+    } finally {
+      (Bun as any).spawn = originalSpawn;
+    }
+  });
+
+  test("throws ClaudeProviderError on non-zero exit code", async () => {
+    const adapter = new ClaudeCliAdapter(mockConfig, mockLogger);
+
+    const originalSpawn = Bun.spawn;
+
+    (Bun as any).spawn = () => {
+      return {
+        exited: Promise.resolve({ exitCode: 1 }),
+        stdout: {
+          text: async () => "",
+        },
+        stderr: {
+          text: async () => "Claude error",
+        },
+      };
+    };
+
+    try {
+      await expect(
+        adapter.call({
+          prompt: "test prompt",
+          maxRetries: 0, // リトライなし
+        })
+      ).rejects.toThrow("Claude CLI failed");
+    } finally {
+      (Bun as any).spawn = originalSpawn;
+    }
+  });
+
+  test("applies retry logic with effort escalation", async () => {
+    const adapter = new ClaudeCliAdapter(mockConfig, mockLogger, 10); // 10ms backoff for testing
+
+    const originalSpawn = Bun.spawn;
+    let attemptCount = 0;
+
+    (Bun as any).spawn = (_args: string[]) => {
+      attemptCount++;
+
+      // 2回目の試行で成功
+      if (attemptCount >= 2) {
+        return {
+          exited: Promise.resolve({ exitCode: 0 }),
+          stdout: {
+            text: async () => "success",
+          },
+          stderr: {
+            text: async () => "",
+          },
+        };
+      }
+
+      // 1回目は失敗
+      return {
+        exited: Promise.resolve({ exitCode: 1 }),
+        stdout: {
+          text: async () => "",
+        },
+        stderr: {
+          text: async () => "temporary error",
+        },
+      };
+    };
+
+    try {
+      const response = await adapter.call({
+        prompt: "test prompt",
+        effortLevel: "low",
+        maxRetries: 2,
+      });
+
+      expect(attemptCount).toBe(2);
+      expect(response.effortLevel).toBe("medium"); // escalated from low
+    } finally {
+      (Bun as any).spawn = originalSpawn;
+    }
+  });
+});