@ronkovic/aad 0.3.0

package/src/modules/logging/logger.ts

@@ -0,0 +1,55 @@
+import pino from "pino";
+
+export interface LoggerOptions {
+  service: string;
+  debug?: boolean;
+  logFilePath?: string;
+}
+
+export function createLogger(options: LoggerOptions): pino.Logger {
+  const { service, debug = false, logFilePath } = options;
+
+  const targets: pino.TransportTargetOptions[] = [];
+
+  // Debug mode: pino-pretty for console
+  if (debug) {
+    targets.push({
+      target: "pino-pretty",
+      level: "debug",
+      options: {
+        colorize: true,
+        translateTime: "HH:MM:ss",
+        ignore: "pid,hostname",
+      },
+    });
+  }
+
+  // Log file: JSON Lines format
+  if (logFilePath) {
+    targets.push({
+      target: "pino/file",
+      level: "info",
+      options: {
+        destination: logFilePath,
+      },
+    });
+  }
+
+  // If no targets, use default console (warn level, stderr)
+  if (targets.length === 0) {
+    targets.push({
+      target: "pino/file",
+      level: "warn",
+      options: {
+        destination: 2, // stderr
+      },
+    });
+  }
+
+  const logger = pino({
+    level: debug ? "debug" : "warn",
+    transport: targets.length === 1 ? targets[0] : { targets },
+  });
+
+  return logger.child({ service });
+}

package/src/modules/logging/transports/sse-transport.ts

@@ -0,0 +1,28 @@
+import type { LogStore, LogEntry } from "../log-store";
+import type { EventBus } from "../../../shared/events";
+
+export interface SSETransportOptions {
+  logStore: LogStore;
+  eventBus: EventBus;
+}
+
+export interface SSETransport {
+  write(entry: LogEntry): void;
+}
+
+export function createSSETransport(options: SSETransportOptions): SSETransport {
+  const { logStore, eventBus } = options;
+
+  return {
+    write(entry: LogEntry): void {
+      // LogStoreに追加（リングバッファ永続化）
+      logStore.add(entry);
+
+      // EventBus経由でSSE配信用にブロードキャスト
+      eventBus.emit({
+        type: "log:entry",
+        entry,
+      });
+    },
+  };
+}

package/src/modules/multi-repo/__tests__/multi-repo-planner.test.ts

@@ -0,0 +1,93 @@
+import { describe, test, expect } from "bun:test";
+import { MultiRepoPlanner } from "../multi-repo-planner";
+import type { RepoContext } from "../repo-context";
+import { createRunId, createTaskId, createRepoName, type TaskPlan } from "../../../shared/types";
+import type pino from "pino";
+
+function createMockLogger(): pino.Logger {
+  return { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} } as unknown as pino.Logger;
+}
+
+function createMockPlanningService(plan: TaskPlan) {
+  return {
+    planTasks: async () => plan,
+  } as any;
+}
+
+const mockRunId = createRunId("test-run-001");
+
+function makePlan(tasks: { id: string; deps?: string[] }[]): TaskPlan {
+  return {
+    runId: mockRunId,
+    parentBranch: "main",
+    tasks: tasks.map((t) => ({
+      taskId: createTaskId(t.id),
+      title: `Task ${t.id}`,
+      description: "",
+      filesToModify: [],
+      dependsOn: (t.deps ?? []).map(createTaskId),
+      priority: 1,
+      status: "pending" as const,
+      retryCount: 0,
+    })),
+  };
+}
+
+function makeRepo(name: string): RepoContext {
+  return {
+    name: createRepoName(name),
+    path: `/tmp/${name}`,
+  };
+}
+
+describe("MultiRepoPlanner", () => {
+  test("independent strategy prefixes task IDs with repo name", async () => {
+    const plan = makePlan([{ id: "task-1" }, { id: "task-2", deps: ["task-1"] }]);
+    const planner = new MultiRepoPlanner({
+      planningService: createMockPlanningService(plan),
+      logger: createMockLogger(),
+    });
+
+    const result = await planner.plan({
+      repos: [makeRepo("frontend"), makeRepo("backend")],
+      runId: mockRunId,
+      parentBranch: "main",
+      requirementsPath: "req.md",
+      targetDocsDir: "/tmp/docs",
+      strategy: "independent",
+    });
+
+    expect(result.strategy).toBe("independent");
+    expect(result.plans.size).toBe(2);
+
+    const frontendPlan = result.plans.get(createRepoName("frontend"))!;
+    expect(frontendPlan.tasks[0]!.taskId as string).toBe("frontend/task-1");
+    expect(frontendPlan.tasks[1]!.dependsOn[0] as string).toBe("frontend/task-1");
+    expect(frontendPlan.tasks[0]!.repoName as string).toBe("frontend");
+
+    const backendPlan = result.plans.get(createRepoName("backend"))!;
+    expect(backendPlan.tasks[0]!.taskId as string).toBe("backend/task-1");
+  });
+
+  test("coordinated strategy produces single plan under primary repo", async () => {
+    const plan = makePlan([{ id: "task-1" }]);
+    const planner = new MultiRepoPlanner({
+      planningService: createMockPlanningService(plan),
+      logger: createMockLogger(),
+    });
+
+    const result = await planner.plan({
+      repos: [makeRepo("primary"), makeRepo("secondary")],
+      runId: mockRunId,
+      parentBranch: "main",
+      requirementsPath: "req.md",
+      targetDocsDir: "/tmp/docs",
+      strategy: "coordinated",
+    });
+
+    expect(result.strategy).toBe("coordinated");
+    expect(result.plans.size).toBe(1);
+    expect(result.plans.has(createRepoName("primary"))).toBe(true);
+    expect(result.plans.get(createRepoName("primary"))!.tasks[0]!.repoName as string).toBe("primary");
+  });
+});

package/src/modules/multi-repo/__tests__/repo-context.test.ts

@@ -0,0 +1,79 @@
+import { describe, test, expect } from "bun:test";
+import { createRepoContext, createRepoContexts } from "../repo-context";
+import type { FileChecker } from "../../planning/project-detection";
+
+function createMockFileChecker(existingPaths: Set<string>): FileChecker {
+  return {
+    async exists(path: string) {
+      return existingPaths.has(path);
+    },
+    async readText(_path: string) {
+      return "";
+    },
+    async glob(_pattern: string, _cwd: string) {
+      return [];
+    },
+  };
+}
+
+describe("createRepoContext", () => {
+  test("creates context for valid git repo", async () => {
+    const checker = createMockFileChecker(new Set(["/tmp/my-repo", "/tmp/my-repo/.git"]));
+    const ctx = await createRepoContext({ path: "/tmp/my-repo" }, checker);
+
+    expect(ctx.name as string).toBe("my-repo");
+    expect(ctx.path).toBe("/tmp/my-repo");
+    expect(ctx.ref).toBeUndefined();
+  });
+
+  test("uses provided name over directory name", async () => {
+    const checker = createMockFileChecker(new Set(["/tmp/my-repo", "/tmp/my-repo/.git"]));
+    const ctx = await createRepoContext({ path: "/tmp/my-repo", name: "custom-name" }, checker);
+
+    expect(ctx.name as string).toBe("custom-name");
+  });
+
+  test("includes ref when provided", async () => {
+    const checker = createMockFileChecker(new Set(["/tmp/my-repo", "/tmp/my-repo/.git"]));
+    const ctx = await createRepoContext({ path: "/tmp/my-repo", ref: "main" }, checker);
+
+    expect(ctx.ref).toBe("main");
+  });
+
+  test("throws when path does not exist", async () => {
+    const checker = createMockFileChecker(new Set());
+    await expect(createRepoContext({ path: "/nonexistent" }, checker)).rejects.toThrow(
+      "does not exist",
+    );
+  });
+
+  test("throws when path is not a git repo", async () => {
+    const checker = createMockFileChecker(new Set(["/tmp/not-git"]));
+    await expect(createRepoContext({ path: "/tmp/not-git" }, checker)).rejects.toThrow(
+      "not a git repository",
+    );
+  });
+});
+
+describe("createRepoContexts", () => {
+  test("creates multiple contexts in parallel", async () => {
+    const checker = createMockFileChecker(
+      new Set(["/tmp/repo-a", "/tmp/repo-a/.git", "/tmp/repo-b", "/tmp/repo-b/.git"]),
+    );
+    const contexts = await createRepoContexts(
+      [{ path: "/tmp/repo-a" }, { path: "/tmp/repo-b" }],
+      checker,
+    );
+
+    expect(contexts).toHaveLength(2);
+    expect(contexts[0]!.name as string).toBe("repo-a");
+    expect(contexts[1]!.name as string).toBe("repo-b");
+  });
+
+  test("rejects if any repo is invalid", async () => {
+    const checker = createMockFileChecker(new Set(["/tmp/repo-a", "/tmp/repo-a/.git"]));
+    await expect(
+      createRepoContexts([{ path: "/tmp/repo-a" }, { path: "/tmp/bad" }], checker),
+    ).rejects.toThrow("does not exist");
+  });
+});

package/src/modules/multi-repo/index.ts

@@ -0,0 +1,12 @@
+// Multi-Repo Module - Barrel Export
+
+export { createRepoContext, createRepoContexts } from "./repo-context";
+export type { RepoContext, RepoContextInput } from "./repo-context";
+
+export { MultiRepoPlanner } from "./multi-repo-planner";
+export type {
+  MultiRepoStrategy,
+  MultiRepoPlan,
+  MultiRepoPlannerDeps,
+  MultiRepoPlanParams,
+} from "./multi-repo-planner";

package/src/modules/multi-repo/multi-repo-planner.ts

@@ -0,0 +1,112 @@
+// MultiRepoPlanner - orchestrates planning across multiple repositories
+
+import type { RepoContext } from "./repo-context";
+import type { PlanningService } from "../planning/planning.service";
+import type { TaskPlan, RunId, RepoName } from "../../shared/types";
+import { createTaskId } from "../../shared/types";
+import type pino from "pino";
+
+export type MultiRepoStrategy = "independent" | "coordinated";
+
+export interface MultiRepoPlan {
+  strategy: MultiRepoStrategy;
+  plans: Map<RepoName, TaskPlan>;
+}
+
+export interface MultiRepoPlannerDeps {
+  planningService: PlanningService;
+  logger: pino.Logger;
+}
+
+export interface MultiRepoPlanParams {
+  repos: RepoContext[];
+  runId: RunId;
+  parentBranch: string;
+  requirementsPath: string;
+  targetDocsDir: string;
+  strategy: MultiRepoStrategy;
+}
+
+export class MultiRepoPlanner {
+  constructor(private deps: MultiRepoPlannerDeps) {}
+
+  async plan(params: MultiRepoPlanParams): Promise<MultiRepoPlan> {
+    const { strategy } = params;
+
+    this.deps.logger.info(
+      { strategy, repoCount: params.repos.length },
+      "Starting multi-repo planning",
+    );
+
+    if (strategy === "independent") {
+      return this.planIndependent(params);
+    }
+    return this.planCoordinated(params);
+  }
+
+  /**
+   * Independent strategy: plan each repo separately, prefix task IDs with repo name.
+   */
+  private async planIndependent(params: MultiRepoPlanParams): Promise<MultiRepoPlan> {
+    const plans = new Map<RepoName, TaskPlan>();
+
+    const results = await Promise.all(
+      params.repos.map(async (repo) => {
+        const taskPlan = await this.deps.planningService.planTasks({
+          runId: params.runId,
+          parentBranch: params.parentBranch,
+          requirementsPath: params.requirementsPath,
+          targetDocsDir: params.targetDocsDir,
+          projectRoot: repo.path,
+        });
+
+        // Prefix task IDs with repo name
+        const prefixedTasks = taskPlan.tasks.map((task) => ({
+          ...task,
+          taskId: createTaskId(`${repo.name}/${task.taskId}`),
+          repoName: repo.name,
+          dependsOn: task.dependsOn.map((dep) => createTaskId(`${repo.name}/${dep}`)),
+        }));
+
+        return {
+          repoName: repo.name,
+          plan: { ...taskPlan, tasks: prefixedTasks },
+        };
+      }),
+    );
+
+    for (const { repoName, plan } of results) {
+      plans.set(repoName, plan);
+    }
+
+    return { strategy: "independent", plans };
+  }
+
+  /**
+   * Coordinated strategy: build a combined context and make a single planning call.
+   * Uses the first repo as the primary project root.
+   */
+  private async planCoordinated(params: MultiRepoPlanParams): Promise<MultiRepoPlan> {
+    const plans = new Map<RepoName, TaskPlan>();
+
+    // Use first repo as primary project root for coordinated planning
+    const primaryRepo = params.repos[0]!;
+    const taskPlan = await this.deps.planningService.planTasks({
+      runId: params.runId,
+      parentBranch: params.parentBranch,
+      requirementsPath: params.requirementsPath,
+      targetDocsDir: params.targetDocsDir,
+      projectRoot: primaryRepo.path,
+    });
+
+    // Assign tasks to primary repo (coordinated produces a single unified plan)
+    const tasksWithRepo = taskPlan.tasks.map((task) => ({
+      ...task,
+      repoName: primaryRepo.name,
+    }));
+
+    plans.set(primaryRepo.name, { ...taskPlan, tasks: tasksWithRepo });
+
+    return { strategy: "coordinated", plans };
+  }
+}

package/src/modules/multi-repo/repo-context.ts

@@ -0,0 +1,71 @@
+// RepoContext - validates and enriches repository context for multi-repo planning
+
+import path from "node:path";
+import type { ProjectAnalysis, FileChecker } from "../planning/project-detection";
+import { analyzeProject } from "../planning/project-detection";
+import { createRepoName, type RepoName } from "../../shared/types";
+
+export interface RepoContext {
+  name: RepoName;
+  path: string;
+  ref?: string;
+  workspace?: ProjectAnalysis;
+}
+
+export interface RepoContextInput {
+  name?: string;
+  path: string;
+  ref?: string;
+}
+
+/**
+ * Create a validated RepoContext from input.
+ * Validates path exists and is a git repo, then detects workspace info.
+ */
+export async function createRepoContext(
+  input: RepoContextInput,
+  fileChecker: FileChecker,
+): Promise<RepoContext> {
+  const resolvedPath = path.resolve(input.path);
+
+  // Validate path exists
+  const exists = await fileChecker.exists(resolvedPath);
+  if (!exists) {
+    throw new Error(`Repository path does not exist: ${resolvedPath}`);
+  }
+
+  // Validate is a git repo
+  const gitDir = path.join(resolvedPath, ".git");
+  const isGitRepo = await fileChecker.exists(gitDir);
+  if (!isGitRepo) {
+    throw new Error(`Path is not a git repository: ${resolvedPath}`);
+  }
+
+  // Derive name from directory if not provided
+  const name = createRepoName(input.name ?? path.basename(resolvedPath));
+
+  // Detect workspace info
+  let workspace: ProjectAnalysis | undefined;
+  try {
+    workspace = await analyzeProject(resolvedPath, fileChecker);
+  } catch {
+    // Non-fatal: workspace detection is best-effort
+  }
+
+  return {
+    name,
+    path: resolvedPath,
+    ref: input.ref,
+    workspace,
+  };
+}
+
+/**
+ * Create multiple RepoContexts in parallel.
+ */
+export async function createRepoContexts(
+  inputs: RepoContextInput[],
+  fileChecker: FileChecker,
+): Promise<RepoContext[]> {
+  return Promise.all(inputs.map((input) => createRepoContext(input, fileChecker)));
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-81991/progress.json

@@ -0,0 +1,10 @@
+{
+  "runId": "run-latest",
+  "parentBranch": "main",
+  "totalTasks": 8,
+  "pending": 0,
+  "running": 0,
+  "completed": 8,
+  "failed": 0,
+  "startTime": "2024-01-03T10:00:00Z"
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-81991/queue/completed/task-getall-2.json

@@ -0,0 +1,10 @@
+{
+  "taskId": "task-getall-2",
+  "title": "Task 2",
+  "description": "Task 2",
+  "filesToModify": [],
+  "dependsOn": [],
+  "priority": 2,
+  "status": "completed",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-81991/queue/pending/task-1.json

@@ -0,0 +1,13 @@
+{
+  "taskId": "task-1",
+  "title": "FS Test Task",
+  "description": "A filesystem test task",
+  "filesToModify": [
+    "file1.ts",
+    "file2.ts"
+  ],
+  "dependsOn": [],
+  "priority": 1,
+  "status": "pending",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-81991/queue/pending/task-getall-1.json

@@ -0,0 +1,10 @@
+{
+  "taskId": "task-getall-1",
+  "title": "Task 1",
+  "description": "Task 1",
+  "filesToModify": [],
+  "dependsOn": [],
+  "priority": 1,
+  "status": "pending",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-81991/queue/pending/task-status-change.json

@@ -0,0 +1,10 @@
+{
+  "taskId": "task-status-change",
+  "title": "Task",
+  "description": "Task",
+  "filesToModify": [],
+  "dependsOn": [],
+  "priority": 1,
+  "status": "pending",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-81991/workers/worker-1.json

@@ -0,0 +1,5 @@
+{
+  "workerId": "worker-1",
+  "status": "idle",
+  "currentTask": null
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-81991/workers/worker-2.json

@@ -0,0 +1,5 @@
+{
+  "workerId": "worker-2",
+  "status": "busy",
+  "currentTask": "task-1"
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-82469/progress.json

@@ -0,0 +1,10 @@
+{
+  "runId": "run-latest",
+  "parentBranch": "main",
+  "totalTasks": 8,
+  "pending": 0,
+  "running": 0,
+  "completed": 8,
+  "failed": 0,
+  "startTime": "2024-01-03T10:00:00Z"
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-82469/queue/completed/task-getall-2.json

@@ -0,0 +1,10 @@
+{
+  "taskId": "task-getall-2",
+  "title": "Task 2",
+  "description": "Task 2",
+  "filesToModify": [],
+  "dependsOn": [],
+  "priority": 2,
+  "status": "completed",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-82469/queue/pending/task-1.json

@@ -0,0 +1,13 @@
+{
+  "taskId": "task-1",
+  "title": "FS Test Task",
+  "description": "A filesystem test task",
+  "filesToModify": [
+    "file1.ts",
+    "file2.ts"
+  ],
+  "dependsOn": [],
+  "priority": 1,
+  "status": "pending",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-82469/queue/pending/task-getall-1.json

@@ -0,0 +1,10 @@
+{
+  "taskId": "task-getall-1",
+  "title": "Task 1",
+  "description": "Task 1",
+  "filesToModify": [],
+  "dependsOn": [],
+  "priority": 1,
+  "status": "pending",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-82469/queue/pending/task-status-change.json

@@ -0,0 +1,10 @@
+{
+  "taskId": "task-status-change",
+  "title": "Task",
+  "description": "Task",
+  "filesToModify": [],
+  "dependsOn": [],
+  "priority": 1,
+  "status": "pending",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-82469/workers/worker-1.json

@@ -0,0 +1,5 @@
+{
+  "workerId": "worker-1",
+  "status": "idle",
+  "currentTask": null
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-82469/workers/worker-2.json

@@ -0,0 +1,5 @@
+{
+  "workerId": "worker-2",
+  "status": "busy",
+  "currentTask": "task-1"
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-85301/progress.json

@@ -0,0 +1,10 @@
+{
+  "runId": "run-latest",
+  "parentBranch": "main",
+  "totalTasks": 8,
+  "pending": 0,
+  "running": 0,
+  "completed": 8,
+  "failed": 0,
+  "startTime": "2024-01-03T10:00:00Z"
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-85301/queue/completed/task-getall-2.json

@@ -0,0 +1,10 @@
+{
+  "taskId": "task-getall-2",
+  "title": "Task 2",
+  "description": "Task 2",
+  "filesToModify": [],
+  "dependsOn": [],
+  "priority": 2,
+  "status": "completed",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-85301/queue/pending/task-1.json

@@ -0,0 +1,13 @@
+{
+  "taskId": "task-1",
+  "title": "FS Test Task",
+  "description": "A filesystem test task",
+  "filesToModify": [
+    "file1.ts",
+    "file2.ts"
+  ],
+  "dependsOn": [],
+  "priority": 1,
+  "status": "pending",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-85301/queue/pending/task-getall-1.json

@@ -0,0 +1,10 @@
+{
+  "taskId": "task-getall-1",
+  "title": "Task 1",
+  "description": "Task 1",
+  "filesToModify": [],
+  "dependsOn": [],
+  "priority": 1,
+  "status": "pending",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-85301/queue/pending/task-status-change.json

@@ -0,0 +1,10 @@
+{
+  "taskId": "task-status-change",
+  "title": "Task",
+  "description": "Task",
+  "filesToModify": [],
+  "dependsOn": [],
+  "priority": 1,
+  "status": "pending",
+  "retryCount": 0
+}

package/src/modules/persistence/__tests__/.tmp-stores-test-85301/workers/worker-1.json

@@ -0,0 +1,5 @@
+{
+  "workerId": "worker-1",
+  "status": "idle",
+  "currentTask": null
+}