@ronkovic/aad 0.3.0

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

@@ -0,0 +1,191 @@
+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 BranchManagerOptions {
+  repoRoot: string;
+  logger?: Logger;
+  gitOps?: GitOps;
+}
+
+/**
+ * Manage git branches for parallel task execution
+ */
+export class BranchManager {
+  private repoRoot: string;
+  private logger?: Logger;
+  private gitOps: GitOps;
+
+  constructor(options: BranchManagerOptions) {
+    this.repoRoot = options.repoRoot;
+    this.logger = options.logger;
+    this.gitOps = options.gitOps ?? defaultGitOps;
+  }
+
+  /**
+   * Create parent branch for a run
+   */
+  async createParentBranch(runId: RunId, baseBranch: string): Promise<string> {
+    const branchName = `aad-run-${runId as string}`;
+
+    this.logger?.info({ runId, baseBranch, branchName }, "Creating parent branch");
+
+    try {
+      // Check if branch already exists
+      if (await this.gitOps.branchExists(branchName, this.repoRoot, this.logger)) {
+        throw new GitWorkspaceError("Parent branch already exists", {
+          branchName,
+          runId: runId as string,
+        });
+      }
+
+      // Create branch from base
+      await this.gitOps.gitExec(
+        ["checkout", "-b", branchName, baseBranch],
+        { cwd: this.repoRoot, logger: this.logger }
+      );
+
+      return branchName;
+    } catch (error) {
+      if (error instanceof GitWorkspaceError) {
+        throw error;
+      }
+
+      throw new GitWorkspaceError("Failed to create parent branch", {
+        runId: runId as string,
+        baseBranch,
+        branchName,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  /**
+   * Create task branch
+   */
+  async createTaskBranch(taskId: TaskId, parentBranch: string): Promise<string> {
+    const branchName = `aad-task-${taskId as string}`;
+
+    this.logger?.info({ taskId, parentBranch, branchName }, "Creating task branch");
+
+    try {
+      // Check if branch already exists
+      if (await this.gitOps.branchExists(branchName, this.repoRoot, this.logger)) {
+        this.logger?.warn({ branchName }, "Task branch already exists, using existing");
+        return branchName;
+      }
+
+      // Create branch from parent (without checking out)
+      await this.gitOps.gitExec(
+        ["branch", branchName, parentBranch],
+        { cwd: this.repoRoot, logger: this.logger }
+      );
+
+      return branchName;
+    } catch (error) {
+      throw new GitWorkspaceError("Failed to create task branch", {
+        taskId: taskId as string,
+        parentBranch,
+        branchName,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  /**
+   * Delete branch (local)
+   */
+  async deleteBranch(branchName: string, force = false): Promise<void> {
+    this.logger?.info({ branchName, force }, "Deleting branch");
+
+    try {
+      const args = ["branch", force ? "-D" : "-d", branchName];
+      await this.gitOps.gitExec(args, { cwd: this.repoRoot, logger: this.logger });
+    } catch (error) {
+      throw new GitWorkspaceError("Failed to delete branch", {
+        branchName,
+        force,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  /**
+   * List branches matching pattern
+   */
+  async listBranches(pattern: string): Promise<string[]> {
+    try {
+      const result = await this.gitOps.gitExec(
+        ["branch", "--list", pattern],
+        { cwd: this.repoRoot, logger: this.logger }
+      );
+
+      return result.stdout
+        .split("\n")
+        .map((line) => line.trim().replace(/^\* /, ""))
+        .filter((line) => line.length > 0);
+    } catch (error) {
+      throw new GitWorkspaceError("Failed to list branches", {
+        pattern,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  /**
+   * Cleanup orphaned AAD branches (branches without worktrees)
+   */
+  async cleanupOrphanBranches(runId?: RunId): Promise<string[]> {
+    // Support both aad/* (slash) and aad-* (hyphen) patterns for backward compatibility
+    const patterns = runId
+      ? [`aad/${runId as string}/*`, `aad-*-${runId as string}*`]
+      : ["aad/*", "aad-*"];
+
+    this.logger?.info({ patterns }, "Cleaning up orphan branches");
+
+    const deleted: string[] = [];
+
+    for (const pattern of patterns) {
+      const branches = await this.listBranches(pattern);
+
+      for (const branch of branches) {
+        try {
+          // Try to delete branch (non-force)
+          await this.deleteBranch(branch, false);
+          deleted.push(branch);
+          this.logger?.info({ branch }, "Deleted orphan branch");
+        } catch (_error) {
+          // Branch still has commits or is checked out, skip
+          this.logger?.debug({ branch }, "Skipping branch (in use or has commits)");
+        }
+      }
+    }
+
+    return deleted;
+  }
+
+  /**
+   * Force cleanup all AAD branches for a run
+   */
+  async forceCleanupRun(runId: RunId): Promise<string[]> {
+    // Support both aad/* (slash) and aad-* (hyphen) patterns
+    const patterns = [`aad/${runId as string}/*`, `aad-*-${runId as string}*`];
+    const deleted: string[] = [];
+
+    for (const pattern of patterns) {
+      const branches = await this.listBranches(pattern);
+
+      for (const branch of branches) {
+        try {
+          await this.deleteBranch(branch, true);
+          deleted.push(branch);
+        } catch (error) {
+          this.logger?.warn({ branch, error }, "Failed to force delete branch");
+        }
+      }
+    }
+
+    return deleted;
+  }
+}

package/src/modules/git-workspace/git-exec.ts

@@ -0,0 +1,124 @@
+import type { Logger } from "pino";
+import { GitWorkspaceError } from "@aad/shared/errors";
+
+export interface GitExecOptions {
+  cwd?: string;
+  timeout?: number;
+  logger?: Logger;
+}
+
+export interface GitExecResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+/**
+ * Execute git command using Bun.spawn
+ * Throws GitWorkspaceError on non-zero exit code
+ */
+export async function gitExec(
+  args: string[],
+  options: GitExecOptions = {}
+): Promise<GitExecResult> {
+  const { cwd = process.cwd(), timeout = 30000, logger } = options;
+
+  logger?.debug({ args, cwd }, "Executing git command");
+
+  try {
+    const proc = Bun.spawn(["git", ...args], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Set timeout
+    const timeoutId = setTimeout(() => {
+      proc.kill();
+    }, timeout);
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+
+    clearTimeout(timeoutId);
+
+    if (exitCode !== 0) {
+      logger?.error({ args, exitCode, stderr }, "Git command failed");
+      throw new GitWorkspaceError("Git command failed", {
+        args,
+        exitCode,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        cwd,
+      });
+    }
+
+    logger?.debug({ args, exitCode }, "Git command succeeded");
+
+    return {
+      stdout: stdout.trim(),
+      stderr: stderr.trim(),
+      exitCode,
+    };
+  } catch (error) {
+    if (error instanceof GitWorkspaceError) {
+      throw error;
+    }
+
+    const err = error as Error;
+    throw new GitWorkspaceError("Failed to execute git command", {
+      args,
+      error: err.message,
+      cwd,
+    });
+  }
+}
+
+/**
+ * Check if a directory is a git repository
+ */
+export async function isGitRepo(dir: string, logger?: Logger): Promise<boolean> {
+  try {
+    await gitExec(["rev-parse", "--git-dir"], { cwd: dir, logger });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get current branch name
+ */
+export async function getCurrentBranch(cwd: string, logger?: Logger): Promise<string> {
+  const result = await gitExec(["rev-parse", "--abbrev-ref", "HEAD"], { cwd, logger });
+  return result.stdout;
+}
+
+/**
+ * Check if branch exists (local or remote)
+ */
+export async function branchExists(
+  branch: string,
+  cwd: string,
+  logger?: Logger
+): Promise<boolean> {
+  try {
+    await gitExec(["rev-parse", "--verify", branch], { cwd, logger });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * GitOps interface for dependency injection in tests
+ */
+export interface GitOps {
+  gitExec: typeof gitExec;
+  branchExists: typeof branchExists;
+}
+
+export const defaultGitOps: GitOps = { gitExec, branchExists };

package/src/modules/git-workspace/index.ts

@@ -0,0 +1,17 @@
+export { gitExec, isGitRepo, getCurrentBranch, branchExists, defaultGitOps } from "./git-exec";
+export type { GitExecOptions, GitExecResult, GitOps } from "./git-exec";
+
+export { WorktreeManager } from "./worktree-manager";
+export type { WorktreeManagerOptions, WorktreeManagerFsOps } from "./worktree-manager";
+
+export { BranchManager } from "./branch-manager";
+export type { BranchManagerOptions } from "./branch-manager";
+
+export { MergeService } from "./merge-service";
+export type { MergeServiceOptions, MergeResult } from "./merge-service";
+
+export { mergeSettings, loadAndMergeSettings, saveSettings } from "./settings-merge";
+export type { ClaudeSettings } from "./settings-merge";
+
+export { harvestMemory } from "./memory-sync";
+export type { MemorySyncOptions, MemorySyncFsOps } from "./memory-sync";

package/src/modules/git-workspace/memory-sync.ts

@@ -0,0 +1,89 @@
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { Logger } from "pino";
+
+export interface MemorySyncFsOps {
+  readdir: typeof readdir;
+  readFile: typeof readFile;
+  writeFile: typeof writeFile;
+}
+
+const defaultFsOps: MemorySyncFsOps = { readdir, readFile, writeFile };
+
+export interface MemorySyncOptions {
+  sourceDir: string;
+  targetDir: string;
+  maxLines?: number;
+  logger?: Logger;
+  fsOps?: MemorySyncFsOps;
+}
+
+/**
+ * Harvest Agent Memory with line-based deduplication
+ */
+export async function harvestMemory(options: MemorySyncOptions): Promise<void> {
+  const { sourceDir, targetDir, maxLines = 200, logger, fsOps = defaultFsOps } = options;
+
+  logger?.info({ sourceDir, targetDir }, "Harvesting agent memory");
+
+  try {
+    const agentDirs = await fsOps.readdir(sourceDir, { withFileTypes: true });
+
+    for (const dirent of agentDirs) {
+      if (!dirent.isDirectory()) {
+        continue;
+      }
+
+      const agentName = dirent.name;
+      const sourceMemoryFile = join(sourceDir, agentName, "MEMORY.md");
+      const targetMemoryFile = join(targetDir, agentName, "MEMORY.md");
+
+      try {
+        // Read source memory
+        const sourceContent = await fsOps.readFile(sourceMemoryFile, "utf-8");
+        const sourceLines = sourceContent.split("\n").filter((line) => line.trim().length > 0);
+
+        // Read target memory (if exists)
+        let targetLines: string[] = [];
+        try {
+          const targetContent = await fsOps.readFile(targetMemoryFile, "utf-8");
+          targetLines = targetContent.split("\n").filter((line) => line.trim().length > 0);
+        } catch {
+          // Target doesn't exist, that's fine
+        }
+
+        // Deduplicate lines (preserve order, keep newest)
+        const seenLines = new Set<string>();
+        const mergedLines: string[] = [];
+
+        // Add target lines first (older)
+        for (const line of targetLines) {
+          if (!seenLines.has(line)) {
+            seenLines.add(line);
+            mergedLines.push(line);
+          }
+        }
+
+        // Add source lines (newer, may override)
+        for (const line of sourceLines) {
+          if (!seenLines.has(line)) {
+            seenLines.add(line);
+            mergedLines.push(line);
+          }
+        }
+
+        // Limit to maxLines (keep most recent)
+        const limitedLines = mergedLines.slice(-maxLines);
+
+        // Write back to target
+        await fsOps.writeFile(targetMemoryFile, limitedLines.join("\n") + "\n");
+
+        logger?.debug({ agentName, lines: limitedLines.length }, "Harvested agent memory");
+      } catch (error) {
+        logger?.debug({ agentName, error }, "Failed to harvest agent memory (skipping)");
+      }
+    }
+  } catch (error) {
+    logger?.warn({ sourceDir, error }, "Failed to harvest memories");
+  }
+}

package/src/modules/git-workspace/merge-service.ts

@@ -0,0 +1,156 @@
+import type { Logger } from "pino";
+import type { TaskId } from "@aad/shared/types";
+import { gitExec } from "./git-exec";
+import { FileLock } from "../persistence";
+
+export interface MergeServiceOptions {
+  repoRoot: string;
+  logger?: Logger;
+}
+
+export interface MergeResult {
+  success: boolean;
+  conflicts?: string[];
+  message?: string;
+}
+
+/**
+ * Merge task branches into parent branch with conflict detection
+ */
+export class MergeService {
+  private repoRoot: string;
+  private logger?: Logger;
+
+  constructor(options: MergeServiceOptions) {
+    this.repoRoot = options.repoRoot;
+    this.logger = options.logger;
+  }
+
+  /**
+   * Merge task branch into parent branch (with file lock)
+   */
+  async mergeToParent(
+    taskId: TaskId,
+    taskBranch: string,
+    parentBranch: string,
+    parentWorktree: string
+  ): Promise<MergeResult> {
+    const lockDir = `${parentWorktree}/.git/aad-merge.lock`;
+    const lock = new FileLock({ lockDir, timeout: 60000, logger: this.logger });
+
+    try {
+      await lock.acquire();
+
+      this.logger?.info({ taskId, taskBranch, parentBranch }, "Merging task to parent");
+
+      // Fetch latest from task branch
+      await gitExec(
+        ["fetch", this.repoRoot, taskBranch],
+        { cwd: parentWorktree, logger: this.logger }
+      );
+
+      // Try merge
+      try {
+        await gitExec(
+          ["merge", "--no-ff", "-m", `Merge task ${taskId as string}: ${taskBranch}`, "FETCH_HEAD"],
+          { cwd: parentWorktree, logger: this.logger }
+        );
+
+        this.logger?.info({ taskId, taskBranch }, "Merge succeeded");
+
+        return {
+          success: true,
+          message: `Successfully merged ${taskBranch} into ${parentBranch}`,
+        };
+      } catch (error) {
+        // Check if merge conflict
+        const conflicts = await this.detectConflicts(parentWorktree);
+
+        if (conflicts.length > 0) {
+          // Abort merge
+          await gitExec(
+            ["merge", "--abort"],
+            { cwd: parentWorktree, logger: this.logger }
+          );
+
+          this.logger?.warn({ taskId, conflicts }, "Merge conflict detected");
+
+          return {
+            success: false,
+            conflicts,
+            message: `Merge conflict: ${conflicts.join(", ")}`,
+          };
+        }
+
+        throw error;
+      }
+    } finally {
+      await lock.release();
+    }
+  }
+
+  /**
+   * Detect merge conflicts
+   */
+  async detectConflicts(worktreePath: string): Promise<string[]> {
+    try {
+      const result = await gitExec(
+        ["diff", "--name-only", "--diff-filter=U"],
+        { cwd: worktreePath, logger: this.logger }
+      );
+
+      return result.stdout.split("\n").filter((line) => line.length > 0);
+    } catch (error) {
+      this.logger?.warn({ error, worktreePath }, "Failed to detect merge conflicts");
+      return [];
+    }
+  }
+
+  /**
+   * Fetch dependency changes from another task branch
+   */
+  async fetchDependencyChanges(
+    depTaskBranch: string,
+    targetWorktree: string
+  ): Promise<void> {
+    this.logger?.info({ depTaskBranch, targetWorktree }, "Fetching dependency changes");
+
+    await gitExec(
+      ["fetch", this.repoRoot, depTaskBranch],
+      { cwd: targetWorktree, logger: this.logger }
+    );
+
+    await gitExec(
+      ["merge", "--no-ff", "-m", `Merge dependency: ${depTaskBranch}`, "FETCH_HEAD"],
+      { cwd: targetWorktree, logger: this.logger }
+    );
+  }
+
+  /**
+   * Get list of changed files in a branch compared to base
+   */
+  async getChangedFiles(branch: string, baseBranch: string): Promise<string[]> {
+    const result = await gitExec(
+      ["diff", "--name-only", `${baseBranch}...${branch}`],
+      { cwd: this.repoRoot, logger: this.logger }
+    );
+
+    return result.stdout.split("\n").filter((line) => line.length > 0);
+  }
+
+  /**
+   * Check if branches have conflicting changes
+   */
+  async hasConflictingChanges(
+    branch1: string,
+    branch2: string,
+    baseBranch: string
+  ): Promise<boolean> {
+    const files1 = await this.getChangedFiles(branch1, baseBranch);
+    const files2 = await this.getChangedFiles(branch2, baseBranch);
+
+    // Simple check: do they modify the same files?
+    const files1Set = new Set(files1);
+    return files2.some((file) => files1Set.has(file));
+  }
+}

package/src/modules/git-workspace/settings-merge.ts

@@ -0,0 +1,95 @@
+import type { Logger } from "pino";
+
+export interface ClaudeSettings {
+  permissions?: Record<string, unknown>;
+  hooks?: Record<string, unknown>;
+  env?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+/**
+ * Deep merge Claude settings with union semantics for arrays
+ */
+export function mergeSettings(
+  base: ClaudeSettings,
+  override: ClaudeSettings,
+  logger?: Logger
+): ClaudeSettings {
+  const merged: ClaudeSettings = { ...base };
+
+  for (const [key, value] of Object.entries(override)) {
+    if (value === undefined || value === null) {
+      continue;
+    }
+
+    if (!merged[key]) {
+      merged[key] = value;
+      continue;
+    }
+
+    // Array union (for permissions, hooks)
+    if (Array.isArray(merged[key]) && Array.isArray(value)) {
+      const baseArray = merged[key] as unknown[];
+      const overrideArray = value as unknown[];
+      merged[key] = [...new Set([...baseArray, ...overrideArray])];
+      continue;
+    }
+
+    // Object deep merge
+    if (
+      typeof merged[key] === "object" &&
+      !Array.isArray(merged[key]) &&
+      typeof value === "object" &&
+      !Array.isArray(value)
+    ) {
+      merged[key] = mergeSettings(
+        merged[key] as ClaudeSettings,
+        value as ClaudeSettings,
+        logger
+      );
+      continue;
+    }
+
+    // Primitive override
+    merged[key] = value;
+  }
+
+  logger?.debug({ merged }, "Settings merged");
+
+  return merged;
+}
+
+/**
+ * Load and merge settings from multiple sources
+ */
+export async function loadAndMergeSettings(
+  paths: string[],
+  logger?: Logger
+): Promise<ClaudeSettings> {
+  let merged: ClaudeSettings = {};
+
+  for (const path of paths) {
+    try {
+      const content = await Bun.file(path).text();
+      const settings = JSON.parse(content) as ClaudeSettings;
+      merged = mergeSettings(merged, settings, logger);
+      logger?.debug({ path }, "Loaded settings");
+    } catch (error) {
+      logger?.debug({ path, error }, "Failed to load settings (skipping)");
+    }
+  }
+
+  return merged;
+}
+
+/**
+ * Save merged settings
+ */
+export async function saveSettings(
+  path: string,
+  settings: ClaudeSettings,
+  logger?: Logger
+): Promise<void> {
+  await Bun.write(path, JSON.stringify(settings, null, 2));
+  logger?.debug({ path }, "Saved settings");
+}