@ronkovic/aad 0.3.8 → 0.4.0

package/src/modules/git-workspace/__tests__/template-copy.test.ts

@@ -0,0 +1,189 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { copyTemplatesToWorktree, resolveTemplateDir } from "../template-copy";
+import { createLogger } from "../../logging";
+
+const testDir = join(import.meta.dir, ".tmp-template-copy-test");
+const projectRoot = join(testDir, "project");
+const templateDir = join(projectRoot, ".aad", "templates");
+const targetDir = join(testDir, "target");
+
+const logger = createLogger({ service: "test", debug: false });
+
+beforeEach(async () => {
+  // Clean up test directory
+  await rm(testDir, { recursive: true, force: true });
+  await mkdir(testDir, { recursive: true });
+  await mkdir(projectRoot, { recursive: true });
+  await mkdir(templateDir, { recursive: true });
+  await mkdir(targetDir, { recursive: true });
+});
+
+describe("copyTemplatesToWorktree", () => {
+  test("copies CLAUDE.md with project append", async () => {
+    // Setup template and project CLAUDE.md
+    await writeFile(join(templateDir, "CLAUDE.md"), "# Template Context\n\nTemplate content.");
+    await writeFile(join(projectRoot, "CLAUDE.md"), "# Project Context\n\nProject content.");
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    const targetCLAUDE = await Bun.file(join(targetDir, "CLAUDE.md")).text();
+    expect(targetCLAUDE).toContain("Template content");
+    expect(targetCLAUDE).toContain("# プロジェクト固有コンテキスト");
+    expect(targetCLAUDE).toContain("Project content");
+  });
+
+  test("handles missing template CLAUDE.md", async () => {
+    // Only project CLAUDE.md
+    await writeFile(join(projectRoot, "CLAUDE.md"), "Project only.");
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    const targetCLAUDE = await Bun.file(join(targetDir, "CLAUDE.md")).text();
+    expect(targetCLAUDE).toContain("# プロジェクト固有コンテキスト");
+    expect(targetCLAUDE).toContain("Project only");
+  });
+
+  test("copies .claude/ with overlay merge", async () => {
+    // Setup project .claude/rules
+    await mkdir(join(projectRoot, ".claude", "rules"), { recursive: true });
+    await writeFile(join(projectRoot, ".claude", "rules", "project.md"), "Project rule");
+
+    // Setup template .claude/rules (should overlay)
+    await mkdir(join(templateDir, ".claude", "rules"), { recursive: true });
+    await writeFile(join(templateDir, ".claude", "rules", "template.md"), "Template rule");
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    // Both should exist
+    const projectRule = await Bun.file(join(targetDir, ".claude", "rules", "project.md")).text();
+    const templateRule = await Bun.file(join(targetDir, ".claude", "rules", "template.md")).text();
+
+    expect(projectRule).toBe("Project rule");
+    expect(templateRule).toBe("Template rule");
+  });
+
+  test("merges settings.json", async () => {
+    // Setup project settings
+    await mkdir(join(projectRoot, ".claude"), { recursive: true });
+    await writeFile(
+      join(projectRoot, ".claude", "settings.json"),
+      JSON.stringify({ permissions: { allow: ["read"] } })
+    );
+
+    // Setup template settings (now at root level, not in .claude/)
+    await writeFile(
+      join(templateDir, "settings.json"),
+      JSON.stringify({ permissions: { deny: ["write"] } })
+    );
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    const targetSettings = JSON.parse(
+      await Bun.file(join(targetDir, ".claude", "settings.json")).text()
+    );
+
+    expect(targetSettings.permissions).toBeDefined();
+    expect(targetSettings.permissions.allow).toEqual(["read"]);
+    expect(targetSettings.permissions.deny).toEqual(["write"]);
+  });
+
+  test("copies .gitignore from template", async () => {
+    await writeFile(join(templateDir, ".gitignore"), "node_modules/\n*.log");
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    const gitignore = await Bun.file(join(targetDir, ".gitignore")).text();
+    expect(gitignore).toContain("node_modules/");
+    expect(gitignore).toContain("*.log");
+  });
+
+  test("handles missing template directory gracefully", async () => {
+    const nonExistentTemplate = join(testDir, "nonexistent");
+
+    // Should not throw
+    await expect(
+      copyTemplatesToWorktree({
+        targetDir,
+        projectRoot,
+        templateDir: nonExistentTemplate,
+        logger,
+      })
+    ).resolves.toBeUndefined();
+
+    // Target directory should be created even if templates don't exist
+    const { stat } = await import("node:fs/promises");
+    const stats = await stat(targetDir);
+    expect(stats.isDirectory()).toBe(true);
+  });
+
+  test("preserves existing agent-memory", async () => {
+    // Setup project agent-memory
+    await mkdir(join(projectRoot, ".claude", "agent-memory", "explorer"), { recursive: true });
+    await writeFile(
+      join(projectRoot, ".claude", "agent-memory", "explorer", "MEMORY.md"),
+      "Existing memory"
+    );
+
+    // Setup template agent-memory (should NOT overwrite)
+    await mkdir(join(templateDir, ".claude", "agent-memory", "explorer"), { recursive: true });
+    await writeFile(
+      join(templateDir, ".claude", "agent-memory", "explorer", "MEMORY.md"),
+      "Template memory"
+    );
+
+    await copyTemplatesToWorktree({
+      targetDir,
+      projectRoot,
+      templateDir,
+      logger,
+    });
+
+    const memory = await Bun.file(
+      join(targetDir, ".claude", "agent-memory", "explorer", "MEMORY.md")
+    ).text();
+    expect(memory).toBe("Existing memory");
+  });
+});
+
+describe("resolveTemplateDir", () => {
+  test("returns local template dir when it exists", () => {
+    // This test assumes the actual project has templates/
+    const result = resolveTemplateDir(process.cwd());
+    expect(result).toBeDefined();
+    expect(result).toContain("templates");
+  });
+
+  test("falls back to package templates when local not found", () => {
+    const result = resolveTemplateDir("/nonexistent");
+    // Should resolve to {packageRoot}/templates, not one level above
+    expect(result).toContain("templates");
+    expect(result).not.toContain("sandbox/templates");
+  });
+});

package/src/modules/git-workspace/__tests__/worktree-cleanup.test.ts

@@ -100,8 +100,35 @@ describe("cleanupOrphanedFromPreviousRuns", () => {
 
     const result = await cleanupOrphanedFromPreviousRuns(worktreeManager, logger);
 
-    // First worktree fails, second succeeds
-    expect(result.removedWorktrees).toBe(1);
+    // First worktree fails git remove but succeeds via fallback (force=true)
+    // Second worktree succeeds normally
+    expect(result.removedWorktrees).toBe(2);
     expect(result.deletedBranches).toBe(2);
   });
+
+  test("preserves parent worktrees (path matches /parent-xxx)", async () => {
+    mockGitOps.gitExec = mock(async (args: string[]) => {
+      if (args[0] === "worktree" && args[1] === "list") {
+        return {
+          stdout: [
+            "worktree /repo", "HEAD abc", "branch refs/heads/main", "",
+            "worktree /repo/.aad/worktrees/task-001", "HEAD def", "branch refs/heads/aad/r/task-001", "",
+            "worktree /repo/.aad/worktrees/parent-run-001", "HEAD ghi", "branch refs/heads/feat/run-001/parent", "",
+          ].join("\n"),
+          stderr: "", exitCode: 0,
+        };
+      }
+      if (args[0] === "branch" && args[1] === "--list") {
+        if (args[2] === "aad/*") return { stdout: "  aad/r/task-001\n", stderr: "", exitCode: 0 };
+        if (args[2] === "feat/*") return { stdout: "  feat/run-001/parent\n", stderr: "", exitCode: 0 };
+        return { stdout: "", stderr: "", exitCode: 0 };
+      }
+      return { stdout: "", stderr: "", exitCode: 0 };
+    });
+
+    const result = await cleanupOrphanedFromPreviousRuns(worktreeManager, logger);
+
+    expect(result.removedWorktrees).toBe(1); // task-001 のみ
+    expect(result.preservedBranches).toBe(1); // feat/run-001/parent
+  });
 });

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

@@ -145,9 +145,24 @@ describe("WorktreeManager", () => {
       await expect(worktreeManager.removeWorktree(worktreePath)).resolves.toBeUndefined();
     });
 
-    test("attempts fallback cleanup on failure", async () => {
+    test("does not attempt fallback cleanup on failure without force", async () => {
       const worktreePath = "/test/worktrees/task-004";
 
+      mockGitOps.gitExec = mock(async () => {
+        throw new Error("git worktree remove failed");
+      });
+
+      await expect(worktreeManager.removeWorktree(worktreePath, false)).rejects.toThrow(
+        GitWorkspaceError
+      );
+
+      // Should NOT call fallback rm when force=false
+      expect(mockFsOps.rm).not.toHaveBeenCalled();
+    });
+
+    test("attempts fallback cleanup on failure with force", async () => {
+      const worktreePath = "/test/worktrees/task-005";
+
       let callCount = 0;
       mockGitOps.gitExec = mock(async () => {
         callCount++;
@@ -157,9 +172,8 @@ describe("WorktreeManager", () => {
         return { stdout: "", stderr: "", exitCode: 0 };
       });
 
-      await expect(worktreeManager.removeWorktree(worktreePath)).rejects.toThrow(
-        GitWorkspaceError
-      );
+      // Should succeed via fallback
+      await expect(worktreeManager.removeWorktree(worktreePath, true)).resolves.toBeUndefined();
 
       expect(mockFsOps.rm).toHaveBeenCalledWith(worktreePath, { recursive: true, force: true });
       expect(mockGitOps.gitExec).toHaveBeenCalledWith(
@@ -167,6 +181,22 @@ describe("WorktreeManager", () => {
         expect.objectContaining({ cwd: repoRoot })
       );
     });
+
+    test("throws if fallback also fails with force", async () => {
+      const worktreePath = "/test/worktrees/task-006";
+
+      mockGitOps.gitExec = mock(async () => {
+        throw new Error("git worktree remove failed");
+      });
+
+      mockFsOps.rm = mock(async () => {
+        throw new Error("rm failed");
+      });
+
+      await expect(worktreeManager.removeWorktree(worktreePath, true)).rejects.toThrow(
+        GitWorkspaceError
+      );
+    });
   });
 
   describe("listWorktrees", () => {
@@ -217,6 +247,36 @@ HEAD 789ghi
 
       expect(worktrees).toEqual([]);
     });
+
+    test("parses worktree list without trailing newline", async () => {
+      const porcelainOutput = `worktree /test/repo
+HEAD abc123
+branch refs/heads/main
+
+worktree /test/worktrees/task-001
+HEAD def456
+branch refs/heads/task/001-feature`;
+
+      mockGitOps.gitExec = mock(async () => ({
+        stdout: porcelainOutput,
+        stderr: "",
+        exitCode: 0
+      }));
+
+      const worktrees = await worktreeManager.listWorktrees();
+
+      expect(worktrees).toHaveLength(2);
+      expect(worktrees[0]).toEqual({
+        path: "/test/repo",
+        branch: "refs/heads/main",
+        head: "abc123",
+      });
+      expect(worktrees[1]).toEqual({
+        path: "/test/worktrees/task-001",
+        branch: "refs/heads/task/001-feature",
+        head: "def456",
+      });
+    });
   });
 
   describe("verifyWorktree", () => {

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

@@ -9,6 +9,11 @@ export interface BranchManagerOptions {
   gitOps?: GitOps;
 }
 
+export interface CleanupBranchOptions {
+  force?: boolean;
+  excludePatterns?: RegExp[];
+}
+
 /**
  * Manage git branches for parallel task execution
  */
@@ -136,7 +141,15 @@ export class BranchManager {
   /**
    * Cleanup orphaned AAD branches (branches without worktrees)
    */
-  async cleanupOrphanBranches(runId?: RunId, force = false): Promise<string[]> {
+  async cleanupOrphanBranches(
+    runId?: RunId,
+    forceOrOptions?: boolean | CleanupBranchOptions,
+  ): Promise<string[]> {
+    // Support both legacy boolean signature and new options object
+    const options: CleanupBranchOptions = typeof forceOrOptions === "boolean"
+      ? { force: forceOrOptions, excludePatterns: [/\/parent$/] }
+      : { force: forceOrOptions?.force ?? false, excludePatterns: forceOrOptions?.excludePatterns ?? [/\/parent$/] };
+
     // Support aad/*, conventional commit prefixes (feat/*, fix/*, etc.), and legacy aad-* patterns
     const conventionalPrefixes = ["aad", "feat", "fix", "docs", "style", "refactor", "perf", "test", "chore"];
     const patterns = runId
@@ -149,7 +162,7 @@ export class BranchManager {
           "aad-*",
         ];
 
-    this.logger?.info({ patterns, force }, "Cleaning up orphan branches");
+    this.logger?.info({ patterns, force: options.force, excludePatterns: options.excludePatterns }, "Cleaning up orphan branches");
 
     const deleted: string[] = [];
 
@@ -157,9 +170,17 @@ export class BranchManager {
       const branches = await this.listBranches(pattern);
 
       for (const branch of branches) {
+        // Check if branch matches any exclude pattern
+        const excludePatterns = options.excludePatterns ?? [/\/parent$/];
+        const isExcluded = excludePatterns.some((pattern) => pattern.test(branch));
+        if (isExcluded) {
+          this.logger?.info({ branch }, "Preserving parent branch (contains commit history)");
+          continue;
+        }
+
         try {
           // Delete branch (force if requested)
-          await this.deleteBranch(branch, force);
+          await this.deleteBranch(branch, options.force);
           deleted.push(branch);
           this.logger?.info({ branch }, "Deleted orphan branch");
         } catch (error) {

package/src/modules/git-workspace/dependency-installer.ts

@@ -0,0 +1,113 @@
+/**
+ * Dependency Installer
+ * Installs package dependencies in task worktrees after creation.
+ */
+
+import type { WorkspaceInfo } from "../../shared/types";
+import type { Logger } from "pino";
+
+export interface InstallResult {
+  success: boolean;
+  output: string;
+  duration: number;
+  skipped: boolean; // Go/Rust等で明示的にスキップした場合
+}
+
+/**
+ * パッケージマネージャからインストールコマンドを導出
+ * Returns null if no install command is available (unknown or no-op).
+ */
+export function buildInstallCommand(workspace: WorkspaceInfo): string[] | null {
+  switch (workspace.packageManager) {
+    // Node.js 系
+    case "bun":
+      return ["bun", "install", "--frozen-lockfile"];
+    case "npm":
+      return ["npm", "ci"];
+    case "yarn":
+      return ["yarn", "install", "--frozen-lockfile"];
+    case "pnpm":
+      return ["pnpm", "install", "--frozen-lockfile"];
+
+    // Python 系
+    case "uv":
+      return ["uv", "sync"];
+    case "poetry":
+      return ["poetry", "install", "--no-interaction"];
+    case "pipenv":
+      return ["pipenv", "install"];
+    case "pip":
+      return ["pip", "install", "-r", "requirements.txt"];
+
+    // Go / Rust (テスト実行時に自動ダウンロードするが、先にfetchしておく)
+    case "go":
+      return ["go", "mod", "download"];
+    case "cargo":
+      return ["cargo", "fetch"];
+
+    case "unknown":
+    default:
+      return null; // インストール不要またはスキップ
+  }
+}
+
+/**
+ * worktreeの依存パッケージをインストール
+ * Non-fatal: 失敗してもエラーをthrowせず、InstallResultで報告。
+ * Claude CLIエージェントは自分でinstallコマンドを実行できるため、ここでの失敗は致命的ではない。
+ */
+export async function installDependencies(
+  workspace: WorkspaceInfo,
+  logger: Logger,
+  timeout?: number
+): Promise<InstallResult> {
+  const startTime = Date.now();
+  const command = buildInstallCommand(workspace);
+
+  if (!command) {
+    logger.debug(
+      { packageManager: workspace.packageManager },
+      "No install command for package manager, skipping"
+    );
+    return { success: true, output: "", duration: 0, skipped: true };
+  }
+
+  const [cmd, ...args] = command;
+  logger.info({ cmd, args, cwd: workspace.path }, "Installing dependencies");
+
+  // Bun.spawn で実行（default-spawner.ts と同パターン）
+  const proc = Bun.spawn([cmd!, ...args], {
+    cwd: workspace.path,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const installTimeout = timeout ?? 180000; // デフォルト3分
+  const timer = setTimeout(() => proc.kill(), installTimeout);
+
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    clearTimeout(timer);
+    const duration = Date.now() - startTime;
+
+    if (exitCode !== 0) {
+      logger.warn(
+        { exitCode, stderr: stderr.slice(0, 500) },
+        "Dependency install failed"
+      );
+      return { success: false, output: stderr || stdout, duration, skipped: false };
+    }
+
+    logger.info({ duration }, "Dependencies installed successfully");
+    return { success: true, output: stdout, duration, skipped: false };
+  } catch (error) {
+    clearTimeout(timer);
+    const duration = Date.now() - startTime;
+    logger.warn({ error }, "Dependency install error");
+    return { success: false, output: String(error), duration, skipped: false };
+  }
+}

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

@@ -5,6 +5,7 @@ export interface GitExecOptions {
   cwd?: string;
   timeout?: number;
   logger?: Logger;
+  allowNonZeroExit?: boolean;
 }
 
 export interface GitExecResult {
@@ -21,7 +22,7 @@ export async function gitExec(
   args: string[],
   options: GitExecOptions = {}
 ): Promise<GitExecResult> {
-  const { cwd = process.cwd(), timeout = 30000, logger } = options;
+  const { cwd = process.cwd(), timeout = 30000, logger, allowNonZeroExit = false } = options;
 
   logger?.debug({ args, cwd }, "Executing git command");
 
@@ -45,7 +46,7 @@ export async function gitExec(
 
     clearTimeout(timeoutId);
 
-    if (exitCode !== 0) {
+    if (exitCode !== 0 && !allowNonZeroExit) {
       logger?.error({ args, exitCode, stderr }, "Git command failed");
       throw new GitWorkspaceError("Git command failed", {
         args,

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

@@ -5,7 +5,7 @@ export { WorktreeManager, cleanupOrphanedFromPreviousRuns } from "./worktree-man
 export type { WorktreeManagerOptions, WorktreeManagerFsOps } from "./worktree-manager";
 
 export { BranchManager } from "./branch-manager";
-export type { BranchManagerOptions } from "./branch-manager";
+export type { BranchManagerOptions, CleanupBranchOptions } from "./branch-manager";
 
 export { MergeService } from "./merge-service";
 export type { MergeServiceOptions, MergeResult } from "./merge-service";
@@ -15,3 +15,12 @@ export type { ClaudeSettings } from "./settings-merge";
 
 export { harvestMemory } from "./memory-sync";
 export type { MemorySyncOptions, MemorySyncFsOps } from "./memory-sync";
+
+export { copyTemplatesToWorktree, resolveTemplateDir } from "./template-copy";
+export type { CopyTemplatesOptions } from "./template-copy";
+
+export { PrManager } from "./pr-manager";
+export type { PrManagerOptions } from "./pr-manager";
+
+export { installDependencies, buildInstallCommand } from "./dependency-installer";
+export type { InstallResult } from "./dependency-installer";

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

@@ -14,6 +14,7 @@ export interface MergeResult {
   success: boolean;
   conflicts?: string[];
   message?: string;
+  alreadyUpToDate?: boolean;
 }
 
 /**
@@ -68,25 +69,54 @@ export class MergeService {
     try {
       await lock.acquire();
 
-      this.logger?.info({ taskId, taskBranch, parentBranch }, "Merging task to parent");
+      // Check for stale MERGE_HEAD (interrupted previous merge) and abort
+      const mergeHeadPath = join(gitDir, "MERGE_HEAD");
+      try {
+        const mergeHeadExists = await Bun.file(mergeHeadPath).exists();
+        if (mergeHeadExists) {
+          this.logger?.warn({ taskId, parentWorktree }, "Stale MERGE_HEAD detected, aborting previous merge");
+          await gitExec(["merge", "--abort"], { cwd: parentWorktree, logger: this.logger });
+        }
+      } catch (_cleanupError) {
+        // Ignore cleanup errors
+      }
 
-      // Fetch latest from task branch
-      await gitExec(
-        ["fetch", this.repoRoot, taskBranch],
-        { cwd: parentWorktree, logger: this.logger }
-      );
+      this.logger?.info({ taskId, taskBranch, parentBranch, parentWorktree }, "Merging task to parent");
+
+      // Before merge: commit any untracked files in parent worktree
+      // (shell parity: worker-executor.sh L388-393)
+      const status = await gitExec(["status", "--porcelain"], {
+        cwd: parentWorktree,
+        logger: this.logger,
+      });
+      if (status.stdout.trim() !== "") {
+        this.logger?.info({ parentWorktree }, "Committing untracked files before merge");
+        await gitExec(["add", "-A"], { cwd: parentWorktree, logger: this.logger });
+        await gitExec(
+          ["commit", "--no-gpg-sign", "-m", "chore: add template files before merge"],
+          { cwd: parentWorktree, logger: this.logger }
+        );
+      }
 
-      // Try merge
+      // Worktrees share the same git object store, so we can merge the task
+      // branch directly without fetching. This is more reliable than
+      // `git fetch <repoRoot> <branch>` + `git merge FETCH_HEAD`.
       try {
-        await gitExec(
-          ["merge", "--no-ff", "-m", `Merge task ${taskId as string}: ${taskBranch}`, "FETCH_HEAD"],
+        const mergeOutput = await gitExec(
+          ["merge", "--no-ff", "-m", `Merge task ${taskId as string}: ${taskBranch}`, taskBranch],
           { cwd: parentWorktree, logger: this.logger }
         );
 
-        this.logger?.info({ taskId, taskBranch }, "Merge succeeded");
+        const alreadyUpToDate = mergeOutput.stdout.includes("Already up to date");
+        if (alreadyUpToDate) {
+          this.logger?.warn({ taskId, taskBranch }, "No new commits on task branch");
+        } else {
+          this.logger?.info({ taskId, taskBranch }, "Merge succeeded");
+        }
 
         return {
           success: true,
+          alreadyUpToDate,
           message: `Successfully merged ${taskBranch} into ${parentBranch}`,
         };
       } catch (error) {