@ronkovic/aad 0.3.0

package/src/modules/git-workspace/worktree-manager.ts

@@ -0,0 +1,199 @@
+import { join } from "node:path";
+import { mkdir, rm } from "node:fs/promises";
+import type { Logger } from "pino";
+import type { TaskId, RunId } from "@aad/shared/types";
+import { GitWorkspaceError } from "@aad/shared/errors";
+import { defaultGitOps, type GitOps } from "./git-exec";
+
+export interface WorktreeManagerFsOps {
+  mkdir: typeof mkdir;
+  rm: typeof rm;
+}
+
+const defaultFsOps: WorktreeManagerFsOps = { mkdir, rm };
+
+export interface WorktreeManagerOptions {
+  repoRoot: string;
+  worktreeBase: string;
+  logger?: Logger;
+  gitOps?: GitOps;
+  fsOps?: WorktreeManagerFsOps;
+}
+
+/**
+ * Manage git worktrees for parallel task execution
+ */
+export class WorktreeManager {
+  private repoRoot: string;
+  private worktreeBase: string;
+  private logger?: Logger;
+  private gitOps: GitOps;
+  private fsOps: WorktreeManagerFsOps;
+
+  constructor(options: WorktreeManagerOptions) {
+    this.repoRoot = options.repoRoot;
+    this.worktreeBase = options.worktreeBase;
+    this.logger = options.logger;
+    this.gitOps = options.gitOps ?? defaultGitOps;
+    this.fsOps = options.fsOps ?? defaultFsOps;
+  }
+
+  /**
+   * Create worktree for a task
+   */
+  async createTaskWorktree(taskId: TaskId, branch: string): Promise<string> {
+    const worktreePath = join(this.worktreeBase, taskId as string);
+
+    this.logger?.info({ taskId, branch, worktreePath }, "Creating task worktree");
+
+    try {
+      // Ensure worktree base directory exists
+      await this.fsOps.mkdir(this.worktreeBase, { recursive: true });
+
+      // Create worktree with new branch
+      await this.gitOps.gitExec(
+        ["worktree", "add", "-b", branch, worktreePath, "HEAD"],
+        { cwd: this.repoRoot, logger: this.logger }
+      );
+
+      return worktreePath;
+    } catch (error) {
+      throw new GitWorkspaceError("Failed to create task worktree", {
+        taskId: taskId as string,
+        branch,
+        worktreePath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  /**
+   * Create worktree for parent branch (used for merging)
+   */
+  async createParentWorktree(runId: RunId, parentBranch: string): Promise<string> {
+    const worktreePath = join(this.worktreeBase, `parent-${runId as string}`);
+
+    this.logger?.info({ runId, parentBranch, worktreePath }, "Creating parent worktree");
+
+    try {
+      await this.fsOps.mkdir(this.worktreeBase, { recursive: true });
+
+      // Create worktree on existing branch (no -b flag)
+      await this.gitOps.gitExec(
+        ["worktree", "add", worktreePath, parentBranch],
+        { cwd: this.repoRoot, logger: this.logger }
+      );
+
+      return worktreePath;
+    } catch (error) {
+      throw new GitWorkspaceError("Failed to create parent worktree", {
+        runId: runId as string,
+        parentBranch,
+        worktreePath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  /**
+   * Remove worktree
+   */
+  async removeWorktree(worktreePath: string, force = false): Promise<void> {
+    this.logger?.info({ worktreePath, force }, "Removing worktree");
+
+    try {
+      const args = ["worktree", "remove", worktreePath];
+      if (force) {
+        args.push("--force");
+      }
+
+      await this.gitOps.gitExec(args, { cwd: this.repoRoot, logger: this.logger });
+    } catch (error) {
+      // If worktree already removed, ignore error
+      if (error instanceof GitWorkspaceError) {
+        const stderr = error.context.stderr;
+        if (typeof stderr === "string" && stderr.includes("not a working tree")) {
+          this.logger?.debug({ worktreePath }, "Worktree already removed");
+          return;
+        }
+      }
+
+      // Try to force remove directory as fallback
+      try {
+        await this.fsOps.rm(worktreePath, { recursive: true, force: true });
+        await this.gitOps.gitExec(["worktree", "prune"], { cwd: this.repoRoot, logger: this.logger });
+      } catch (cleanupError) {
+        this.logger?.debug({ cleanupError, worktreePath }, "Worktree cleanup fallback failed (ignored)");
+      }
+
+      throw new GitWorkspaceError("Failed to remove worktree", {
+        worktreePath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  /**
+   * List all worktrees
+   */
+  async listWorktrees(): Promise<Array<{ path: string; branch: string; head: string }>> {
+    const result = await this.gitOps.gitExec(
+      ["worktree", "list", "--porcelain"],
+      { cwd: this.repoRoot, logger: this.logger }
+    );
+
+    const worktrees: Array<{ path: string; branch: string; head: string }> = [];
+    const lines = result.stdout.split("\n");
+
+    let current: Partial<{ path: string; branch: string; head: string }> = {};
+
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        current.path = line.substring("worktree ".length);
+      } else if (line.startsWith("branch ")) {
+        current.branch = line.substring("branch ".length);
+      } else if (line.startsWith("HEAD ")) {
+        current.head = line.substring("HEAD ".length);
+      } else if (line === "") {
+        if (current.path && current.head) {
+          worktrees.push({
+            path: current.path,
+            branch: current.branch ?? "(detached)",
+            head: current.head,
+          });
+        }
+        current = {};
+      }
+    }
+
+    return worktrees;
+  }
+
+  /**
+   * Verify worktree exists and is valid
+   */
+  async verifyWorktree(worktreePath: string): Promise<boolean> {
+    try {
+      await this.gitOps.gitExec(
+        ["rev-parse", "--git-dir"],
+        { cwd: worktreePath, logger: this.logger }
+      );
+      return true;
+    } catch (error) {
+      this.logger?.debug({ error, worktreePath }, "Worktree verification failed");
+      return false;
+    }
+  }
+
+  /**
+   * Cleanup orphaned worktrees
+   */
+  async pruneWorktrees(): Promise<void> {
+    this.logger?.info("Pruning orphaned worktrees");
+
+    await this.gitOps.gitExec(
+      ["worktree", "prune"],
+      { cwd: this.repoRoot, logger: this.logger }
+    );
+  }
+}

package/src/modules/logging/__tests__/log-store.test.ts

@@ -0,0 +1,242 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { LogStore, type LogEntry, type LogFilter } from "../log-store";
+
+describe("LogStore", () => {
+  let store: LogStore;
+
+  beforeEach(() => {
+    store = new LogStore();
+  });
+
+  test("adds log entry", () => {
+    const entry: LogEntry = {
+      level: "info",
+      service: "test-service",
+      message: "test message",
+      timestamp: Date.now(),
+    };
+
+    store.add(entry);
+
+    const all = store.getAll();
+    expect(all).toHaveLength(1);
+    expect(all[0]).toBeDefined();
+    expect(all[0]).toEqual(entry);
+  });
+
+  test("adds multiple log entries", () => {
+    store.add({
+      level: "info",
+      service: "test",
+      message: "msg1",
+      timestamp: Date.now(),
+    });
+
+    store.add({
+      level: "error",
+      service: "test",
+      message: "msg2",
+      timestamp: Date.now(),
+    });
+
+    expect(store.getAll()).toHaveLength(2);
+  });
+
+  test("respects capacity limit", () => {
+    const smallStore = new LogStore(3);
+
+    smallStore.add({
+      level: "info",
+      service: "test",
+      message: "msg1",
+      timestamp: Date.now(),
+    });
+    smallStore.add({
+      level: "info",
+      service: "test",
+      message: "msg2",
+      timestamp: Date.now(),
+    });
+    smallStore.add({
+      level: "info",
+      service: "test",
+      message: "msg3",
+      timestamp: Date.now(),
+    });
+    smallStore.add({
+      level: "info",
+      service: "test",
+      message: "msg4",
+      timestamp: Date.now(),
+    });
+
+    const all = smallStore.getAll();
+    expect(all).toHaveLength(3);
+    expect(all[0]?.message).toBe("msg2");
+    expect(all[2]?.message).toBe("msg4");
+  });
+
+  test("clears all entries", () => {
+    store.add({
+      level: "info",
+      service: "test",
+      message: "msg1",
+      timestamp: Date.now(),
+    });
+
+    expect(store.getAll()).toHaveLength(1);
+
+    store.clear();
+
+    expect(store.getAll()).toHaveLength(0);
+  });
+
+  test("queries by level", () => {
+    const now = Date.now();
+
+    store.add({ level: "info", service: "test", message: "info msg", timestamp: now });
+    store.add({ level: "error", service: "test", message: "error msg", timestamp: now });
+    store.add({ level: "warn", service: "test", message: "warn msg", timestamp: now });
+
+    const filter: LogFilter = { level: "error" };
+    const results = store.query(filter);
+
+    expect(results).toHaveLength(1);
+    expect(results[0]?.level).toBe("error");
+  });
+
+  test("queries by service", () => {
+    const now = Date.now();
+
+    store.add({ level: "info", service: "service-a", message: "msg1", timestamp: now });
+    store.add({ level: "info", service: "service-b", message: "msg2", timestamp: now });
+    store.add({ level: "info", service: "service-a", message: "msg3", timestamp: now });
+
+    const filter: LogFilter = { service: "service-a" };
+    const results = store.query(filter);
+
+    expect(results).toHaveLength(2);
+    results.forEach((entry) => {
+      expect(entry.service).toBe("service-a");
+    });
+  });
+
+  test("queries by taskId", () => {
+    const now = Date.now();
+
+    store.add({
+      level: "info",
+      service: "test",
+      message: "msg1",
+      timestamp: now,
+      taskId: "t1",
+    });
+    store.add({
+      level: "info",
+      service: "test",
+      message: "msg2",
+      timestamp: now,
+      taskId: "t2",
+    });
+
+    const filter: LogFilter = { taskId: "t1" };
+    const results = store.query(filter);
+
+    expect(results).toHaveLength(1);
+    expect(results[0]?.taskId).toBe("t1");
+  });
+
+  test("queries by workerId", () => {
+    const now = Date.now();
+
+    store.add({
+      level: "info",
+      service: "test",
+      message: "msg1",
+      timestamp: now,
+      workerId: "w1",
+    });
+    store.add({
+      level: "info",
+      service: "test",
+      message: "msg2",
+      timestamp: now,
+      workerId: "w2",
+    });
+
+    const filter: LogFilter = { workerId: "w1" };
+    const results = store.query(filter);
+
+    expect(results).toHaveLength(1);
+    expect(results[0]?.workerId).toBe("w1");
+  });
+
+  test("queries by since timestamp", () => {
+    const now = Date.now();
+
+    store.add({ level: "info", service: "test", message: "msg1", timestamp: now - 1000 });
+    store.add({ level: "info", service: "test", message: "msg2", timestamp: now });
+    store.add({ level: "info", service: "test", message: "msg3", timestamp: now + 1000 });
+
+    const filter: LogFilter = { since: now };
+    const results = store.query(filter);
+
+    expect(results).toHaveLength(2);
+  });
+
+  test("queries with limit", () => {
+    const now = Date.now();
+
+    store.add({ level: "info", service: "test", message: "msg1", timestamp: now });
+    store.add({ level: "info", service: "test", message: "msg2", timestamp: now });
+    store.add({ level: "info", service: "test", message: "msg3", timestamp: now });
+
+    const filter: LogFilter = { limit: 2 };
+    const results = store.query(filter);
+
+    expect(results).toHaveLength(2);
+  });
+
+  test("queries with multiple filters", () => {
+    const now = Date.now();
+
+    store.add({
+      level: "error",
+      service: "service-a",
+      message: "msg1",
+      timestamp: now,
+      taskId: "t1",
+    });
+    store.add({
+      level: "error",
+      service: "service-b",
+      message: "msg2",
+      timestamp: now,
+      taskId: "t1",
+    });
+    store.add({
+      level: "info",
+      service: "service-a",
+      message: "msg3",
+      timestamp: now,
+      taskId: "t1",
+    });
+
+    const filter: LogFilter = {
+      level: "error",
+      service: "service-a",
+      taskId: "t1",
+    };
+    const results = store.query(filter);
+
+    expect(results).toHaveLength(1);
+    expect(results[0]?.message).toBe("msg1");
+  });
+
+  test("query returns empty array when no matches", () => {
+    const filter: LogFilter = { level: "error" };
+    const results = store.query(filter);
+
+    expect(results).toHaveLength(0);
+  });
+});

package/src/modules/logging/__tests__/logger.test.ts

@@ -0,0 +1,81 @@
+import { describe, test, expect, afterEach } from "bun:test";
+import { createLogger } from "../logger";
+import { unlinkSync, existsSync } from "node:fs";
+
+describe("createLogger", () => {
+  const testLogFile = "/tmp/aad-test-logger.log";
+
+  afterEach(() => {
+    if (existsSync(testLogFile)) {
+      unlinkSync(testLogFile);
+    }
+  });
+
+  test("creates logger with service field", () => {
+    const logger = createLogger({ service: "test-service" });
+
+    expect(logger).toBeDefined();
+    expect(typeof logger.info).toBe("function");
+    expect(typeof logger.error).toBe("function");
+    expect(typeof logger.warn).toBe("function");
+    expect(typeof logger.debug).toBe("function");
+  });
+
+  test("child logger includes service in log context", () => {
+    const logger = createLogger({ service: "test-service" });
+
+    // pino loggerは内部で bindings() を使って context を確認できる
+    const bindings = (logger as any).bindings();
+    expect(bindings.service).toBe("test-service");
+  });
+
+  test("creates logger without log file in debug mode", () => {
+    const logger = createLogger({
+      service: "test-service",
+      debug: true,
+    });
+
+    expect(logger).toBeDefined();
+  });
+
+  test("creates logger with log file path", async () => {
+    const logger = createLogger({
+      service: "test-service",
+      logFilePath: testLogFile,
+    });
+
+    logger.info("test message");
+
+    // pino transport (worker thread) の非同期書き込みをポーリングで待機
+    const maxWait = 2000;
+    const interval = 50;
+    let elapsed = 0;
+    while (!existsSync(testLogFile) && elapsed < maxWait) {
+      await new Promise((resolve) => setTimeout(resolve, interval));
+      elapsed += interval;
+    }
+
+    // ファイルが作成されることを確認
+    expect(existsSync(testLogFile)).toBe(true);
+  });
+
+  test("logger can log at different levels", () => {
+    const logger = createLogger({ service: "test-service" });
+
+    // ログ出力がエラーを投げないことを確認
+    expect(() => {
+      logger.info("info message");
+      logger.error("error message");
+      logger.warn("warn message");
+      logger.debug("debug message");
+    }).not.toThrow();
+  });
+
+  test("logger supports structured logging", () => {
+    const logger = createLogger({ service: "test-service" });
+
+    expect(() => {
+      logger.info({ taskId: "t1", workerId: "w1" }, "task dispatched");
+    }).not.toThrow();
+  });
+});

package/src/modules/logging/__tests__/sse-transport.test.ts

@@ -0,0 +1,93 @@
+import { describe, test, expect, mock } from "bun:test";
+import { createSSETransport } from "../transports/sse-transport";
+import { LogStore, type LogEntry } from "../log-store";
+import { EventBus } from "../../../shared/events";
+
+describe("createSSETransport", () => {
+  test("returns object with write method", () => {
+    const logStore = new LogStore();
+    const eventBus = new EventBus();
+
+    const transport = createSSETransport({ logStore, eventBus });
+
+    expect(transport).toBeDefined();
+    expect(typeof transport.write).toBe("function");
+  });
+
+  test("write calls logStore.add with entry", () => {
+    const logStore = new LogStore();
+    const eventBus = new EventBus();
+    const addSpy = mock(() => {});
+    logStore.add = addSpy;
+
+    const transport = createSSETransport({ logStore, eventBus });
+
+    const entry: LogEntry = {
+      level: "info",
+      service: "test-service",
+      message: "Test message",
+      timestamp: Date.now(),
+    };
+
+    transport.write(entry);
+
+    expect(addSpy).toHaveBeenCalledTimes(1);
+    expect(addSpy).toHaveBeenCalledWith(entry);
+  });
+
+  test("write emits log:entry event via EventBus", () => {
+    const logStore = new LogStore();
+    const eventBus = new EventBus();
+    const emitSpy = mock(() => {});
+    eventBus.emit = emitSpy;
+
+    const transport = createSSETransport({ logStore, eventBus });
+
+    const entry: LogEntry = {
+      level: "error",
+      service: "task-execution",
+      message: "Execution failed",
+      timestamp: Date.now(),
+      taskId: "task-1",
+    };
+
+    transport.write(entry);
+
+    expect(emitSpy).toHaveBeenCalledTimes(1);
+    expect(emitSpy).toHaveBeenCalledWith({
+      type: "log:entry",
+      entry,
+    });
+  });
+
+  test("write handles multiple calls correctly", () => {
+    const logStore = new LogStore();
+    const eventBus = new EventBus();
+    const addSpy = mock(() => {});
+    const emitSpy = mock(() => {});
+    logStore.add = addSpy;
+    eventBus.emit = emitSpy;
+
+    const transport = createSSETransport({ logStore, eventBus });
+
+    const entry1: LogEntry = {
+      level: "info",
+      service: "planning",
+      message: "Planning started",
+      timestamp: Date.now(),
+    };
+
+    const entry2: LogEntry = {
+      level: "warn",
+      service: "task-queue",
+      message: "Task stale",
+      timestamp: Date.now(),
+    };
+
+    transport.write(entry1);
+    transport.write(entry2);
+
+    expect(addSpy).toHaveBeenCalledTimes(2);
+    expect(emitSpy).toHaveBeenCalledTimes(2);
+  });
+});

package/src/modules/logging/index.ts

@@ -0,0 +1,7 @@
+export { createLogger, type LoggerOptions } from "./logger";
+export { LogStore, type LogEntry, type LogFilter } from "./log-store";
+export {
+  createSSETransport,
+  type SSETransport,
+  type SSETransportOptions,
+} from "./transports/sse-transport";

package/src/modules/logging/log-store.ts

@@ -0,0 +1,80 @@
+export interface LogEntry {
+  level: string;
+  service: string;
+  message: string;
+  timestamp: number;
+  taskId?: string;
+  workerId?: string;
+  [key: string]: unknown;
+}
+
+export interface LogFilter {
+  level?: string;
+  service?: string;
+  taskId?: string;
+  workerId?: string;
+  since?: number;
+  limit?: number;
+}
+
+export class LogStore {
+  private entries: LogEntry[] = [];
+  private capacity: number;
+
+  constructor(capacity: number = 10000) {
+    this.capacity = capacity;
+  }
+
+  add(entry: LogEntry): void {
+    this.entries.push(entry);
+
+    // リングバッファ: capacityを超えたら古いものを削除
+    if (this.entries.length > this.capacity) {
+      this.entries.shift();
+    }
+  }
+
+  query(filter: LogFilter): LogEntry[] {
+    let results = this.entries;
+
+    // level filter
+    if (filter.level !== undefined) {
+      results = results.filter((entry) => entry.level === filter.level);
+    }
+
+    // service filter
+    if (filter.service !== undefined) {
+      results = results.filter((entry) => entry.service === filter.service);
+    }
+
+    // taskId filter
+    if (filter.taskId !== undefined) {
+      results = results.filter((entry) => entry.taskId === filter.taskId);
+    }
+
+    // workerId filter
+    if (filter.workerId !== undefined) {
+      results = results.filter((entry) => entry.workerId === filter.workerId);
+    }
+
+    // since filter
+    if (filter.since !== undefined) {
+      results = results.filter((entry) => entry.timestamp >= filter.since!);
+    }
+
+    // limit filter
+    if (filter.limit !== undefined && filter.limit > 0) {
+      results = results.slice(0, filter.limit);
+    }
+
+    return results;
+  }
+
+  clear(): void {
+    this.entries = [];
+  }
+
+  getAll(): LogEntry[] {
+    return [...this.entries];
+  }
+}