@ronkovic/aad 0.3.0

package/src/modules/persistence/stores.port.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import type { Task, TaskId, TaskStatus, Worker, WorkerId, RunState, RunId } from "@aad/shared/types";
+
+// Zod Schemas for validation (string-based, not branded)
+export const TaskSchema = z.object({
+  taskId: z.string(),
+  title: z.string(),
+  description: z.string(),
+  filesToModify: z.array(z.string()),
+  dependsOn: z.array(z.string()),
+  priority: z.number(),
+  status: z.enum(["pending", "running", "completed", "failed"]),
+  workerId: z.string().optional(),
+  startTime: z.string().optional(),
+  endTime: z.string().optional(),
+  retryCount: z.number(),
+  failureReason: z.string().optional(),
+});
+
+export const WorkerSchema = z.object({
+  workerId: z.string(),
+  status: z.enum(["idle", "busy", "stopped"]),
+  currentTask: z.string().nullable(),
+  pid: z.number().optional(),
+});
+
+export const RunStateSchema = z.object({
+  runId: z.string(),
+  parentBranch: z.string(),
+  totalTasks: z.number(),
+  pending: z.number(),
+  running: z.number(),
+  completed: z.number(),
+  failed: z.number(),
+  startTime: z.string(),
+  endTime: z.string().optional(),
+});
+
+// Port Interfaces
+export interface TaskStore {
+  get(taskId: TaskId): Promise<Task | null>;
+  getAll(): Promise<Task[]>;
+  getByStatus(status: TaskStatus): Promise<Task[]>;
+  save(task: Task): Promise<void>;
+  delete(taskId: TaskId): Promise<void>;
+}
+
+export interface WorkerStore {
+  get(workerId: WorkerId): Promise<Worker | null>;
+  getAll(): Promise<Worker[]>;
+  getIdle(): Promise<Worker[]>;
+  save(worker: Worker): Promise<void>;
+  delete(workerId: WorkerId): Promise<void>;
+}
+
+export interface RunStore {
+  get(runId: RunId): Promise<RunState | null>;
+  getLatest(): Promise<RunState | null>;
+  save(state: RunState): Promise<void>;
+}

package/src/modules/planning/__tests__/file-conflict-validator.test.ts

@@ -0,0 +1,256 @@
+import { describe, test, expect } from "bun:test";
+import type { Task } from "../../../shared/types";
+import { createTaskId } from "../../../shared/types";
+import {
+  validateFileConflicts,
+  formatConflictErrors,
+} from "../file-conflict-validator";
+
+function createTestTask(
+  taskId: string,
+  filesToModify: string[],
+  dependsOn: string[] = [],
+  priority: number = 1
+): Task {
+  return {
+    taskId: createTaskId(taskId),
+    title: `Task ${taskId}`,
+    description: `Test task ${taskId}`,
+    filesToModify,
+    dependsOn: dependsOn.map(createTaskId),
+    priority,
+    status: "pending",
+    retryCount: 0,
+  };
+}
+
+describe("validateFileConflicts", () => {
+  test("passes when no file conflicts exist", () => {
+    const tasks = [
+      createTestTask("task-1", ["file1.ts"], [], 1),
+      createTestTask("task-2", ["file2.ts"], [], 2),
+      createTestTask("task-3", ["file3.ts"], [], 3),
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    expect(result.valid).toBe(true);
+    expect(result.conflicts).toHaveLength(0);
+  });
+
+  test("passes when file conflict has direct dependency", () => {
+    const tasks = [
+      createTestTask("task-1", ["shared.ts"], [], 1),
+      createTestTask("task-2", ["shared.ts"], ["task-1"], 2),
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    expect(result.valid).toBe(true);
+    expect(result.conflicts).toHaveLength(0);
+  });
+
+  test("passes when file conflict has transitive dependency", () => {
+    const tasks = [
+      createTestTask("task-1", ["shared.ts"], [], 1),
+      createTestTask("task-2", ["other.ts"], ["task-1"], 2),
+      createTestTask("task-3", ["shared.ts"], ["task-2"], 3),
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    expect(result.valid).toBe(true);
+    expect(result.conflicts).toHaveLength(0);
+  });
+
+  test("fails when file conflict has no dependency", () => {
+    const tasks = [
+      createTestTask("task-1", ["shared.ts"], [], 1),
+      createTestTask("task-2", ["shared.ts"], [], 2),
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    expect(result.valid).toBe(false);
+    expect(result.conflicts).toHaveLength(1);
+    expect(result.conflicts[0]).toMatchObject({
+      filePath: "shared.ts",
+      ownerTask: createTaskId("task-1"),
+      conflictingTask: createTaskId("task-2"),
+      hasDependency: false,
+    });
+  });
+
+  test("detects multiple file conflicts", () => {
+    const tasks = [
+      createTestTask("task-1", ["file1.ts", "file2.ts"], [], 1),
+      createTestTask("task-2", ["file1.ts", "file3.ts"], [], 2),
+      createTestTask("task-3", ["file2.ts", "file4.ts"], [], 3),
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    expect(result.valid).toBe(false);
+    expect(result.conflicts).toHaveLength(2);
+
+    const filePathsInConflicts = result.conflicts.map((c) => c.filePath);
+    expect(filePathsInConflicts).toContain("file1.ts");
+    expect(filePathsInConflicts).toContain("file2.ts");
+  });
+
+  test("ignores empty filesToModify arrays", () => {
+    const tasks = [
+      createTestTask("task-1", [], [], 1),
+      createTestTask("task-2", ["file1.ts"], [], 2),
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    expect(result.valid).toBe(true);
+    expect(result.conflicts).toHaveLength(0);
+  });
+
+  test("handles circular dependency detection", () => {
+    const tasks = [
+      createTestTask("task-1", ["shared.ts"], ["task-2"], 1),
+      createTestTask("task-2", ["shared.ts"], ["task-1"], 2),
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    // Circular dependency: both tasks think they depend on each other
+    // Our visited set prevents infinite loop, so this passes validation
+    // (The circular dependency itself is a separate validation concern)
+    expect(result.valid).toBe(true);
+  });
+
+  test("processes tasks in priority order", () => {
+    const tasks = [
+      createTestTask("task-high", ["shared.ts"], [], 1), // Highest priority
+      createTestTask("task-low", ["shared.ts"], [], 10), // Lower priority
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    expect(result.valid).toBe(false);
+    expect(result.conflicts[0]?.ownerTask).toBe(createTaskId("task-high"));
+    expect(result.conflicts[0]?.conflictingTask).toBe(createTaskId("task-low"));
+  });
+
+  test("validates complex dependency chain", () => {
+    const tasks = [
+      createTestTask("task-1", ["base.ts"], [], 1),
+      createTestTask("task-2", ["utils.ts"], ["task-1"], 2),
+      createTestTask("task-3", ["service.ts"], ["task-2"], 3),
+      createTestTask("task-4", ["base.ts"], ["task-3"], 4), // Depends on task-3, which transitively depends on task-1
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    expect(result.valid).toBe(true);
+    expect(result.conflicts).toHaveLength(0);
+  });
+
+  test("detects missing dependency in complex scenario", () => {
+    const tasks = [
+      createTestTask("task-1", ["shared.ts"], [], 1),
+      createTestTask("task-2", ["other.ts"], ["task-1"], 2),
+      createTestTask("task-3", ["shared.ts"], [], 3), // Missing dependency on task-1
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    expect(result.valid).toBe(false);
+    expect(result.conflicts).toHaveLength(1);
+    expect(result.conflicts[0]).toMatchObject({
+      filePath: "shared.ts",
+      ownerTask: createTaskId("task-1"),
+      conflictingTask: createTaskId("task-3"),
+      hasDependency: false,
+    });
+  });
+
+  test("handles same file modified by multiple tasks with proper dependencies", () => {
+    const tasks = [
+      createTestTask("task-1", ["config.ts"], [], 1),
+      createTestTask("task-2", ["config.ts"], ["task-1"], 2),
+      createTestTask("task-3", ["config.ts"], ["task-2"], 3),
+      createTestTask("task-4", ["config.ts"], ["task-3"], 4),
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    expect(result.valid).toBe(true);
+    expect(result.conflicts).toHaveLength(0);
+  });
+
+  test("skips empty file paths", () => {
+    const tasks = [
+      createTestTask("task-1", ["valid.ts", "", "  "], [], 1),
+      createTestTask("task-2", ["valid.ts"], [], 2),
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    // Only valid.ts should cause a conflict, not the empty strings
+    expect(result.valid).toBe(false);
+    expect(result.conflicts).toHaveLength(1);
+    expect(result.conflicts[0]?.filePath).toBe("valid.ts");
+  });
+
+  test("handles task not found in dependency lookup", () => {
+    // task-2 depends on "task-nonexistent" which isn't in the tasks list
+    const tasks = [
+      createTestTask("task-1", ["shared.ts"], [], 1),
+      createTestTask("task-2", ["shared.ts"], ["task-nonexistent"], 2),
+    ];
+
+    const result = validateFileConflicts(tasks);
+
+    // task-2 can't prove dependency on task-1 via task-nonexistent, so conflict
+    expect(result.valid).toBe(false);
+    expect(result.conflicts).toHaveLength(1);
+  });
+});
+
+describe("formatConflictErrors", () => {
+  test("returns empty array for valid result", () => {
+    const tasks = [
+      createTestTask("task-1", ["file1.ts"], [], 1),
+      createTestTask("task-2", ["file2.ts"], [], 2),
+    ];
+    const result = validateFileConflicts(tasks);
+    const errors = formatConflictErrors(result);
+    expect(errors).toHaveLength(0);
+  });
+
+  test("formats conflict errors as human-readable messages", () => {
+    const tasks = [
+      createTestTask("task-1", ["shared.ts"], [], 1),
+      createTestTask("task-2", ["shared.ts"], [], 2),
+    ];
+
+    const result = validateFileConflicts(tasks);
+    const errors = formatConflictErrors(result);
+
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toContain("File conflict detected");
+    expect(errors[0]).toContain("shared.ts");
+    expect(errors[0]).toContain("task-1");
+    expect(errors[0]).toContain("task-2");
+    expect(errors[0]).toContain("ERROR");
+  });
+
+  test("formats multiple conflicts", () => {
+    const tasks = [
+      createTestTask("task-1", ["file1.ts", "file2.ts"], [], 1),
+      createTestTask("task-2", ["file1.ts"], [], 2),
+      createTestTask("task-3", ["file2.ts"], [], 3),
+    ];
+
+    const result = validateFileConflicts(tasks);
+    const errors = formatConflictErrors(result);
+
+    expect(errors).toHaveLength(2);
+  });
+});

package/src/modules/planning/__tests__/planning-service.test.ts

@@ -0,0 +1,366 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import type { Config } from "../../../shared/config";
+import type { ClaudeProvider, ClaudeRequest, ClaudeResponse } from "../../claude-provider";
+import type pino from "pino";
+import { EventBus, type AADEvent } from "../../../shared/events";
+import { PlanningService } from "../planning.service";
+import { createRunId } from "../../../shared/types";
+import type { FileChecker } from "../project-detection";
+
+// Mock ClaudeProvider
+class MockClaudeProvider implements ClaudeProvider {
+  public lastRequest: ClaudeRequest | null = null;
+  public mockResponse: ClaudeResponse = {
+    result: "Mock response",
+    exitCode: 0,
+    model: "claude-sonnet-4-5",
+    effortLevel: "medium",
+    duration: 1000,
+  };
+
+  async call(request: ClaudeRequest): Promise<ClaudeResponse> {
+    this.lastRequest = request;
+    return this.mockResponse;
+  }
+}
+
+// Mock Logger
+function createMockLogger(): pino.Logger {
+  return {
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+    child: () => createMockLogger(),
+  } as unknown as pino.Logger;
+}
+
+// Mock Config
+function createMockConfig(teamsEnabled: boolean = false): Config {
+  return {
+    workers: { num: 2, max: 8 },
+    models: {},
+    timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+    retry: { maxRetries: 2 },
+    debug: false,
+    adaptiveEffort: false,
+    teams: {
+      splitter: teamsEnabled,
+      reviewer: false,
+    },
+    memorySync: true,
+    dashboard: {
+      enabled: true,
+      port: 7333,
+      host: "localhost",
+    },
+  };
+}
+
+// Mock FileChecker to avoid real filesystem I/O in tests
+const mockFileChecker: FileChecker = {
+  exists: async () => false,
+  readText: async () => "",
+  glob: async () => [],
+};
+
+describe("PlanningService", () => {
+  let eventBus: EventBus;
+  let mockProvider: MockClaudeProvider;
+  let mockLogger: pino.Logger;
+
+  beforeEach(() => {
+    eventBus = new EventBus();
+    mockProvider = new MockClaudeProvider();
+    mockLogger = createMockLogger();
+  });
+
+  test("creates planning service instance", () => {
+    const config = createMockConfig();
+    const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+    expect(service).toBeDefined();
+  });
+
+  test("planTasks emits planning:started event", async () => {
+    const config = createMockConfig();
+    const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+
+    let eventEmitted = false;
+    type PlanningStartedEvent = Extract<AADEvent, { type: "planning:started" }>;
+    eventBus.on<PlanningStartedEvent>("planning:started", (event) => {
+      eventEmitted = true;
+      expect(event.requirementsPath).toBe("/test/requirements.md");
+    });
+
+    // Mock successful task plan generation
+    mockProvider.mockResponse = {
+      result: JSON.stringify({
+        run_id: "test-run",
+        parent_branch: "feature/test-run",
+        tasks: [
+          {
+            task_id: "task-1",
+            title: "Test task",
+            description: "Test description",
+            files_to_modify: ["file1.ts"],
+            depends_on: [],
+            priority: 1,
+          },
+        ],
+      }),
+      exitCode: 0,
+      model: "claude-sonnet-4-5",
+      effortLevel: "medium" as const,
+      duration: 1000,
+    };
+
+    try {
+      await service.planTasks({
+        runId: createRunId("test-run"),
+        parentBranch: "feature/test-run",
+        requirementsPath: "/test/requirements.md",
+        targetDocsDir: "/test/docs",
+      });
+    } catch {
+      // Ignore errors for this test
+    }
+
+    expect(eventEmitted).toBe(true);
+  });
+
+  test("planTasks calls ClaudeProvider with solo mode prompt", async () => {
+    const config = createMockConfig(false); // teams disabled
+    const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+
+    mockProvider.mockResponse = {
+      result: JSON.stringify({
+        run_id: "test-run",
+        parent_branch: "feature/test-run",
+        tasks: [
+          {
+            task_id: "task-1",
+            title: "Test task",
+            description: "Test",
+            files_to_modify: ["file1.ts"],
+            depends_on: [],
+            priority: 1,
+          },
+        ],
+      }),
+      exitCode: 0,
+      model: "claude-sonnet-4-5",
+      effortLevel: "medium" as const,
+      duration: 1000,
+    };
+
+    try {
+      await service.planTasks({
+        runId: createRunId("test-run"),
+        parentBranch: "feature/test-run",
+        requirementsPath: "/test/requirements.md",
+        targetDocsDir: "/test/docs",
+      });
+    } catch {
+      // Ignore errors
+    }
+
+    expect(mockProvider.lastRequest).toBeDefined();
+    expect(mockProvider.lastRequest?.prompt).toContain("splitterエージェントとして");
+    expect(mockProvider.lastRequest?.prompt).not.toContain("サブエージェント");
+  }, 15_000);
+
+  test("planTasks calls ClaudeProvider with teams mode prompt", async () => {
+    const config = createMockConfig(true); // teams enabled
+    const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+
+    mockProvider.mockResponse = {
+      result: JSON.stringify({
+        run_id: "test-run",
+        parent_branch: "feature/test-run",
+        tasks: [],
+      }),
+      exitCode: 0,
+      model: "claude-sonnet-4-5",
+      effortLevel: "medium" as const,
+      duration: 1000,
+    };
+
+    try {
+      await service.planTasks({
+        runId: createRunId("test-run"),
+        parentBranch: "feature/test-run",
+        requirementsPath: "/test/requirements.md",
+        targetDocsDir: "/test/docs",
+      });
+    } catch {
+      // Ignore errors
+    }
+
+    expect(mockProvider.lastRequest).toBeDefined();
+    expect(mockProvider.lastRequest?.prompt).toContain("サブエージェント");
+    // Teams mode now uses subagents instead of prompt-only instructions
+    expect(mockProvider.lastRequest?.subagents).toBeDefined();
+    expect(mockProvider.lastRequest?.subagents).toHaveLength(3);
+    expect(mockProvider.lastRequest?.subagents?.map(s => s.name)).toEqual([
+      "codebase-analyzer",
+      "requirement-analyzer",
+      "dependency-mapper",
+    ]);
+    // Each subagent should have a non-empty prompt
+    for (const sa of mockProvider.lastRequest?.subagents ?? []) {
+      expect(sa.prompt.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("planTasks does not include subagents in solo mode", async () => {
+    const config = createMockConfig(false);
+    const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+
+    mockProvider.mockResponse = {
+      result: JSON.stringify({
+        run_id: "test-run",
+        parent_branch: "feature/test-run",
+        tasks: [
+          {
+            task_id: "task-1",
+            title: "Test task",
+            description: "Test",
+            files_to_modify: ["file1.ts"],
+            depends_on: [],
+            priority: 1,
+          },
+        ],
+      }),
+      exitCode: 0,
+      model: "claude-sonnet-4-5",
+      effortLevel: "medium" as const,
+      duration: 1000,
+    };
+
+    await service.planTasks({
+      runId: createRunId("test-run"),
+      parentBranch: "feature/test-run",
+      requirementsPath: "/test/requirements.md",
+      targetDocsDir: "/test/docs",
+    });
+
+    expect(mockProvider.lastRequest?.subagents).toBeUndefined();
+  });
+
+  test("planTasks emits planning:completed on success", async () => {
+    const config = createMockConfig();
+    const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+
+    let completedEvent: Extract<AADEvent, { type: "planning:completed" }> | null = null;
+    type PlanningCompletedEvent = Extract<AADEvent, { type: "planning:completed" }>;
+    eventBus.on<PlanningCompletedEvent>("planning:completed", (event) => {
+      completedEvent = event;
+    });
+
+    mockProvider.mockResponse = {
+      result: JSON.stringify({
+        run_id: "test-run",
+        parent_branch: "feature/test-run",
+        tasks: [
+          {
+            task_id: "task-1",
+            title: "Test",
+            description: "Test",
+            files_to_modify: ["file1.ts"],
+            depends_on: [],
+            priority: 1,
+          },
+          {
+            task_id: "task-2",
+            title: "Test 2",
+            description: "Test 2",
+            files_to_modify: ["file2.ts"],
+            depends_on: [],
+            priority: 2,
+          },
+        ],
+      }),
+      exitCode: 0,
+      model: "claude-sonnet-4-5",
+      effortLevel: "medium" as const,
+      duration: 1000,
+    };
+
+    const result = await service.planTasks({
+      runId: createRunId("test-run"),
+      parentBranch: "feature/test-run",
+      requirementsPath: "/test/requirements.md",
+      targetDocsDir: "/test/docs",
+    });
+
+    expect(result).toBeDefined();
+    expect(result.tasks).toHaveLength(2);
+    expect(completedEvent).toBeDefined();
+    expect(completedEvent!.taskCount).toBe(2);
+  });
+
+  test("planTasks emits planning:failed on Claude error", async () => {
+    const config = createMockConfig();
+    const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+
+    let failedEvent: Extract<AADEvent, { type: "planning:failed" }> | null = null;
+    type PlanningFailedEvent = Extract<AADEvent, { type: "planning:failed" }>;
+    eventBus.on<PlanningFailedEvent>("planning:failed", (event) => {
+      failedEvent = event;
+    });
+
+    mockProvider.mockResponse = {
+      result: "Claude API error",
+      exitCode: 1,
+      model: "claude-sonnet-4-5",
+      effortLevel: "medium" as const,
+      duration: 1000,
+    };
+
+    await expect(
+      service.planTasks({
+        runId: createRunId("test-run"),
+        parentBranch: "feature/test-run",
+        requirementsPath: "/test/requirements.md",
+        targetDocsDir: "/test/docs",
+      })
+    ).rejects.toThrow();
+
+    expect(failedEvent).toBeDefined();
+    expect(failedEvent!.error).toContain("exit code 1");
+  });
+
+  test("planTasks emits planning:failed on invalid task plan", async () => {
+    const config = createMockConfig();
+    const service = new PlanningService(mockProvider, eventBus, config, mockLogger, { fileChecker: mockFileChecker });
+
+    let failedEvent: Extract<AADEvent, { type: "planning:failed" }> | null = null;
+    type PlanningFailedEvent = Extract<AADEvent, { type: "planning:failed" }>;
+    eventBus.on<PlanningFailedEvent>("planning:failed", (event) => {
+      failedEvent = event;
+    });
+
+    mockProvider.mockResponse = {
+      result: JSON.stringify({
+        run_id: "test-run",
+        parent_branch: "feature/test-run",
+        tasks: "invalid", // Should be array
+      }),
+      exitCode: 0,
+      model: "claude-sonnet-4-5",
+      effortLevel: "medium" as const,
+      duration: 1000,
+    };
+
+    await expect(
+      service.planTasks({
+        runId: createRunId("test-run"),
+        parentBranch: "feature/test-run",
+        requirementsPath: "/test/requirements.md",
+        targetDocsDir: "/test/docs",
+      })
+    ).rejects.toThrow();
+
+    expect(failedEvent).toBeDefined();
+  });
+});