@ronkovic/aad 0.3.9 → 0.4.0

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

@@ -0,0 +1,278 @@
+import type { Logger } from "pino";
+import { GitWorkspaceError } from "@aad/shared/errors";
+
+export interface PrManagerOptions {
+  repoRoot: string;
+  logger?: Logger;
+}
+
+export interface DraftPrOptions {
+  title: string;
+  body: string;
+  baseBranch: string;
+  headBranch: string;
+}
+
+export interface PrInfo {
+  number: number;
+  url: string;
+  state: "draft" | "open" | "closed";
+}
+
+/**
+ * Manage Pull Request lifecycle via GitHub CLI (gh)
+ */
+export class PrManager {
+  private repoRoot: string;
+  private logger?: Logger;
+
+  constructor(options: PrManagerOptions) {
+    this.repoRoot = options.repoRoot;
+    this.logger = options.logger;
+  }
+
+  /**
+   * Check if gh CLI is installed
+   */
+  async checkGhInstalled(): Promise<boolean> {
+    try {
+      const proc = Bun.spawn(["gh", "--version"], {
+        cwd: this.repoRoot,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const exitCode = await proc.exited;
+      return exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Create a draft PR
+   */
+  async createDraftPr(options: DraftPrOptions): Promise<PrInfo> {
+    this.logger?.info({ headBranch: options.headBranch, baseBranch: options.baseBranch }, "Creating draft PR");
+
+    if (!(await this.checkGhInstalled())) {
+      throw new GitWorkspaceError("GitHub CLI (gh) is not installed or not in PATH", {
+        suggestion: "Install gh from https://cli.github.com/",
+      });
+    }
+
+    try {
+      // Create draft PR using gh CLI
+      const proc = Bun.spawn(
+        [
+          "gh",
+          "pr",
+          "create",
+          "--draft",
+          "--title",
+          options.title,
+          "--body",
+          options.body,
+          "--base",
+          options.baseBranch,
+          "--head",
+          options.headBranch,
+        ],
+        {
+          cwd: this.repoRoot,
+          stdout: "pipe",
+          stderr: "pipe",
+        }
+      );
+
+      const exitCode = await proc.exited;
+      const stdout = proc.stdout ? await new Response(proc.stdout).text() : "";
+      const stderr = proc.stderr ? await new Response(proc.stderr).text() : "";
+
+      if (exitCode !== 0) {
+        throw new Error(`gh pr create failed: ${stderr}`);
+      }
+
+      // Parse PR URL from stdout (gh prints the PR URL)
+      const url = stdout.trim();
+      const match = url.match(/\/pull\/(\d+)$/);
+      const number = match?.[1] ? parseInt(match[1], 10) : 0;
+
+      this.logger?.info({ prNumber: number, url }, "Draft PR created");
+
+      return {
+        number,
+        url,
+        state: "draft",
+      };
+    } catch (error) {
+      throw new GitWorkspaceError("Failed to create draft PR", {
+        headBranch: options.headBranch,
+        baseBranch: options.baseBranch,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  /**
+   * Mark draft PR as ready for review
+   */
+  async markPrReady(prNumber: number): Promise<void> {
+    this.logger?.info({ prNumber }, "Marking PR as ready for review");
+
+    if (!(await this.checkGhInstalled())) {
+      throw new GitWorkspaceError("GitHub CLI (gh) is not installed or not in PATH", {
+        suggestion: "Install gh from https://cli.github.com/",
+      });
+    }
+
+    try {
+      const proc = Bun.spawn(["gh", "pr", "ready", String(prNumber)], {
+        cwd: this.repoRoot,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      const exitCode = await proc.exited;
+      const stderr = proc.stderr ? await new Response(proc.stderr).text() : "";
+
+      if (exitCode !== 0) {
+        throw new Error(`gh pr ready failed: ${stderr}`);
+      }
+
+      this.logger?.info({ prNumber }, "PR marked as ready");
+    } catch (error) {
+      throw new GitWorkspaceError("Failed to mark PR as ready", {
+        prNumber,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  /**
+   * Get PR info
+   */
+  async getPrInfo(prNumber: number): Promise<PrInfo | null> {
+    if (!(await this.checkGhInstalled())) {
+      return null;
+    }
+
+    try {
+      const proc = Bun.spawn(
+        ["gh", "pr", "view", String(prNumber), "--json", "number,url,isDraft,state"],
+        {
+          cwd: this.repoRoot,
+          stdout: "pipe",
+          stderr: "pipe",
+        }
+      );
+
+      const exitCode = await proc.exited;
+      const stdout = proc.stdout ? await new Response(proc.stdout).text() : "";
+
+      if (exitCode !== 0) {
+        return null;
+      }
+
+      const data = JSON.parse(stdout) as {
+        number: number;
+        url: string;
+        isDraft: boolean;
+        state: string;
+      };
+
+      return {
+        number: data.number,
+        url: data.url,
+        state: data.isDraft ? "draft" : data.state === "OPEN" ? "open" : "closed",
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Close PR
+   */
+  async closePr(prNumber: number): Promise<void> {
+    this.logger?.info({ prNumber }, "Closing PR");
+
+    if (!(await this.checkGhInstalled())) {
+      throw new GitWorkspaceError("GitHub CLI (gh) is not installed or not in PATH", {
+        suggestion: "Install gh from https://cli.github.com/",
+      });
+    }
+
+    try {
+      const proc = Bun.spawn(["gh", "pr", "close", String(prNumber)], {
+        cwd: this.repoRoot,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      const exitCode = await proc.exited;
+      const stderr = proc.stderr ? await new Response(proc.stderr).text() : "";
+
+      if (exitCode !== 0) {
+        throw new Error(`gh pr close failed: ${stderr}`);
+      }
+
+      this.logger?.info({ prNumber }, "PR closed");
+    } catch (error) {
+      throw new GitWorkspaceError("Failed to close PR", {
+        prNumber,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  /**
+   * Find PR by head branch
+   */
+  async findPrByBranch(headBranch: string): Promise<PrInfo | null> {
+    if (!(await this.checkGhInstalled())) {
+      return null;
+    }
+
+    try {
+      const proc = Bun.spawn(
+        ["gh", "pr", "list", "--head", headBranch, "--json", "number,url,isDraft,state", "--limit", "1"],
+        {
+          cwd: this.repoRoot,
+          stdout: "pipe",
+          stderr: "pipe",
+        }
+      );
+
+      const exitCode = await proc.exited;
+      const stdout = proc.stdout ? await new Response(proc.stdout).text() : "";
+
+      if (exitCode !== 0) {
+        return null;
+      }
+
+      const data = JSON.parse(stdout) as Array<{
+        number: number;
+        url: string;
+        isDraft: boolean;
+        state: string;
+      }>;
+
+      if (data.length === 0) {
+        return null;
+      }
+
+      const pr = data[0];
+      if (!pr) {
+        return null;
+      }
+
+      return {
+        number: pr.number,
+        url: pr.url,
+        state: pr.isDraft ? "draft" : pr.state === "OPEN" ? "open" : "closed",
+      };
+    } catch {
+      return null;
+    }
+  }
+}

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

@@ -0,0 +1,302 @@
+import { mkdir, readdir, cp, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { Logger } from "pino";
+import { loadAndMergeSettings, saveSettings } from "./settings-merge";
+
+export interface CopyTemplatesOptions {
+  targetDir: string; // worktreeパス
+  projectRoot: string;
+  templateDir?: string; // default: resolveTemplateDir(projectRoot)
+  logger?: Logger;
+}
+
+const PROJECT_CONTEXT_HEADER = "# プロジェクト固有コンテキスト\n\n";
+
+/**
+ * Resolve template directory path:
+ * 1. Project local override: {projectRoot}/.aad/templates/ (if exists)
+ * 2. Package bundled: {packageRoot}/templates/
+ */
+export function resolveTemplateDir(projectRoot: string): string {
+  const localTemplateDir = join(projectRoot, ".aad", "templates");
+
+  // Check if local override exists
+  if (existsSync(localTemplateDir)) {
+    return localTemplateDir;
+  }
+
+  // Fallback to package bundled templates
+  // src/modules/git-workspace/ -> ../../../.aad/templates
+  const packageRoot = join(import.meta.dir, "..", "..", "..");
+  return join(packageRoot, ".aad", "templates");
+}
+
+/**
+ * Copy templates from .aad/templates/ to target worktree
+ * Implements overlay merge strategy:
+ * - CLAUDE.md: template base + project-specific append
+ * - .claude/: project base + template overlay (agents, hooks, rules, skills)
+ * - settings.json: deep merge
+ * - .gitignore: copy from template
+ */
+export async function copyTemplatesToWorktree(
+  options: CopyTemplatesOptions
+): Promise<void> {
+  const {
+    targetDir,
+    projectRoot,
+    templateDir = resolveTemplateDir(projectRoot),
+    logger,
+  } = options;
+
+  logger?.info({ targetDir, templateDir }, "Copying templates to worktree");
+
+  // Ensure target directory exists
+  await mkdir(targetDir, { recursive: true });
+
+  // Each step is non-critical, continue on errors
+  try {
+    // (a) CLAUDE.md: template base + project CLAUDE.md appended
+    await copyCLAUDEmd({
+      templateDir,
+      projectRoot,
+      targetDir,
+      logger,
+    });
+  } catch (error) {
+    logger?.debug({ error }, "CLAUDE.md copy failed (non-critical)");
+  }
+
+  try {
+    // (b) .claude/: overlay merge (agents, hooks, rules, skills)
+    await copyClaudeDir({
+      templateDir,
+      projectRoot,
+      targetDir,
+      logger,
+    });
+  } catch (error) {
+    logger?.debug({ error }, ".claude/ copy failed (non-critical)");
+  }
+
+  try {
+    // (c) settings.json: deep merge
+    await mergeSettingsJson({
+      templateDir,
+      projectRoot,
+      targetDir,
+      logger,
+    });
+  } catch (error) {
+    logger?.debug({ error }, "settings.json merge failed (non-critical)");
+  }
+
+  try {
+    // (d) .gitignore: copy from template
+    await copyGitignore({
+      templateDir,
+      targetDir,
+      logger,
+    });
+  } catch (error) {
+    logger?.debug({ error }, ".gitignore copy failed (non-critical)");
+  }
+
+  logger?.info({ targetDir }, "Template copy completed");
+}
+
+/**
+ * Copy CLAUDE.md: template base + project content appended
+ */
+async function copyCLAUDEmd(opts: {
+  templateDir: string;
+  projectRoot: string;
+  targetDir: string;
+  logger?: Logger;
+}): Promise<void> {
+  const { templateDir, projectRoot, targetDir, logger } = opts;
+
+  const templateCLAUDE = join(templateDir, "CLAUDE.md");
+  const projectCLAUDE = join(projectRoot, "CLAUDE.md");
+  const targetCLAUDE = join(targetDir, "CLAUDE.md");
+
+  let content = "";
+
+  // Start with template CLAUDE.md if exists
+  try {
+    content = await Bun.file(templateCLAUDE).text();
+    logger?.debug({ templateCLAUDE }, "Loaded template CLAUDE.md");
+  } catch {
+    logger?.debug({ templateCLAUDE }, "No template CLAUDE.md found (skipping)");
+  }
+
+  // Append project CLAUDE.md if exists
+  try {
+    const projectContent = await Bun.file(projectCLAUDE).text();
+    if (projectContent.trim()) {
+      content += "\n\n" + PROJECT_CONTEXT_HEADER + projectContent;
+      logger?.debug({ projectCLAUDE }, "Appended project CLAUDE.md");
+    }
+  } catch {
+    logger?.debug({ projectCLAUDE }, "No project CLAUDE.md found (skipping)");
+  }
+
+  // Write to target
+  if (content.trim()) {
+    await Bun.write(targetCLAUDE, content);
+    logger?.debug({ targetCLAUDE }, "Written CLAUDE.md");
+  }
+}
+
+/**
+ * Copy .claude/ directory: project base + template overlay
+ * Overlay: agents, hooks, rules, skills from template
+ * Preserve: agent-memory from project (existing wins)
+ */
+async function copyClaudeDir(opts: {
+  templateDir: string;
+  projectRoot: string;
+  targetDir: string;
+  logger?: Logger;
+}): Promise<void> {
+  const { templateDir, projectRoot, targetDir, logger } = opts;
+
+  const projectClaudeDir = join(projectRoot, ".claude");
+  const templateClaudeDir = join(templateDir, ".claude");
+  const targetClaudeDir = join(targetDir, ".claude");
+
+  // Ensure target .claude/ exists
+  await mkdir(targetClaudeDir, { recursive: true });
+
+  // Copy project .claude/ subdirectories as base layer (if exists), excluding agent-memory
+  // We manually copy subdirectories to exclude agent-memory
+  try {
+    let projectClaudeExists = false;
+    try {
+      const stats = await stat(projectClaudeDir);
+      projectClaudeExists = stats.isDirectory();
+    } catch {
+      projectClaudeExists = false;
+    }
+
+    if (projectClaudeExists) {
+      const entries = await readdir(projectClaudeDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name === "agent-memory") {
+          continue; // Skip agent-memory, will handle separately
+        }
+        const src = join(projectClaudeDir, entry.name);
+        const dest = join(targetClaudeDir, entry.name);
+        if (entry.isDirectory()) {
+          await cp(src, dest, { recursive: true });
+        } else {
+          await cp(src, dest);
+        }
+      }
+      logger?.debug({ projectClaudeDir }, "Copied project .claude/ as base (excluding agent-memory)");
+    }
+  } catch (error) {
+    logger?.debug({ projectClaudeDir, error }, "No project .claude/ found or copy failed");
+  }
+
+  // Overlay template subdirectories (agents, hooks, rules, skills)
+  const overlayDirs = ["agents", "hooks", "rules", "skills"];
+
+  for (const subdir of overlayDirs) {
+    const templateSubdir = join(templateClaudeDir, subdir);
+    const targetSubdir = join(targetClaudeDir, subdir);
+
+    try {
+      // Ensure target subdir exists
+      await mkdir(targetSubdir, { recursive: true });
+
+      // Copy template files (overwrite)
+      await cp(templateSubdir, targetSubdir, { recursive: true });
+      logger?.debug({ templateSubdir, targetSubdir }, `Overlayed ${subdir}/`);
+    } catch {
+      logger?.debug({ templateSubdir }, `No template ${subdir}/ found (skipping)`);
+    }
+  }
+
+  // Handle agent-memory: existing (project) wins, don't overwrite
+  const projectMemoryDir = join(projectClaudeDir, "agent-memory");
+  const templateMemoryDir = join(templateClaudeDir, "agent-memory");
+  const targetMemoryDir = join(targetClaudeDir, "agent-memory");
+
+  try {
+    // Check if project has agent-memory directory
+    let projectMemoryExists = false;
+    try {
+      const stats = await stat(projectMemoryDir);
+      projectMemoryExists = stats.isDirectory();
+    } catch {
+      projectMemoryExists = false;
+    }
+
+    if (projectMemoryExists) {
+      // Copy project agent-memory
+      await cp(projectMemoryDir, targetMemoryDir, { recursive: true });
+      logger?.debug({ projectMemoryDir }, "Preserved project agent-memory/");
+    } else {
+      // No project memory, copy template if exists
+      try {
+        await cp(templateMemoryDir, targetMemoryDir, { recursive: true });
+        logger?.debug({ templateMemoryDir }, "Copied template agent-memory/");
+      } catch {
+        logger?.debug("No template agent-memory found");
+      }
+    }
+  } catch (error) {
+    logger?.debug({ error }, "No agent-memory to handle");
+  }
+}
+
+/**
+ * Merge settings.json: project + template deep merge
+ */
+async function mergeSettingsJson(opts: {
+  templateDir: string;
+  projectRoot: string;
+  targetDir: string;
+  logger?: Logger;
+}): Promise<void> {
+  const { templateDir, projectRoot, targetDir, logger } = opts;
+
+  const projectSettings = join(projectRoot, ".claude", "settings.json");
+  const templateSettings = join(templateDir, "settings.json");
+  const targetSettings = join(targetDir, ".claude", "settings.json");
+
+  // Load and merge settings
+  const merged = await loadAndMergeSettings(
+    [projectSettings, templateSettings],
+    logger
+  );
+
+  // Save to target
+  await mkdir(join(targetDir, ".claude"), { recursive: true });
+  await saveSettings(targetSettings, merged, logger);
+
+  logger?.debug({ targetSettings }, "Merged and saved settings.json");
+}
+
+/**
+ * Copy .gitignore from template
+ */
+async function copyGitignore(opts: {
+  templateDir: string;
+  targetDir: string;
+  logger?: Logger;
+}): Promise<void> {
+  const { templateDir, targetDir, logger } = opts;
+
+  const templateGitignore = join(templateDir, ".gitignore");
+  const targetGitignore = join(targetDir, ".gitignore");
+
+  try {
+    await cp(templateGitignore, targetGitignore, { force: true });
+    logger?.debug({ templateGitignore, targetGitignore }, "Copied .gitignore");
+  } catch {
+    logger?.debug({ templateGitignore }, "No template .gitignore found (skipping)");
+  }
+}

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

@@ -169,16 +169,20 @@ export class WorktreeManager {
         }
       }
 
-      // 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)");
+      // Try to force remove directory as fallback (only if force=true)
+      if (force) {
+        try {
+          await this.fsOps.rm(worktreePath, { recursive: true, force: true });
+          await this.gitOps.gitExec(["worktree", "prune"], { cwd: this.repoRoot, logger: this.logger });
+          return;
+        } catch (cleanupError) {
+          this.logger?.debug({ cleanupError, worktreePath }, "Worktree cleanup fallback failed");
+        }
       }
 
       throw new GitWorkspaceError("Failed to remove worktree", {
         worktreePath,
+        force,
         error: error instanceof Error ? error.message : String(error),
       });
     }
@@ -217,6 +221,15 @@ export class WorktreeManager {
       }
     }
 
+    // Push the last worktree if it hasn't been pushed yet
+    if (current.path && current.head) {
+      worktrees.push({
+        path: current.path,
+        branch: current.branch ?? "(detached)",
+        head: current.head,
+      });
+    }
+
     return worktrees;
   }
 
@@ -256,16 +269,24 @@ export class WorktreeManager {
 export async function cleanupOrphanedFromPreviousRuns(
   worktreeManager: WorktreeManager,
   logger: Logger,
-): Promise<{ removedWorktrees: number; deletedBranches: number }> {
+): Promise<{ removedWorktrees: number; deletedBranches: number; preservedBranches: number }> {
   logger.info("Cleaning up orphaned worktrees/branches from previous runs");
 
   let removedWorktrees = 0;
   let deletedBranches = 0;
+  let preservedBranches = 0;
 
-  // 1. Remove all worktrees under .aad/worktrees/
+  // 1. Remove all worktrees under .aad/worktrees/ (except parent worktrees)
   try {
     const worktrees = await worktreeManager.listWorktrees();
-    const aadWorktrees = worktrees.filter((wt) => wt.path.includes("/.aad/worktrees/"));
+    const aadWorktrees = worktrees.filter((wt) => {
+      if (!wt.path.includes("/.aad/worktrees/")) return false;
+      if (/\/parent-[^/]+$/.test(wt.path)) {
+        logger.info({ path: wt.path }, "Preserving parent worktree (contains commit history)");
+        return false;
+      }
+      return true;
+    });
 
     for (const wt of aadWorktrees) {
       try {
@@ -307,6 +328,11 @@ export async function cleanupOrphanedFromPreviousRuns(
           .filter((b: string) => b.length > 0);
 
         for (const branch of branches) {
+          if (branch.endsWith("/parent")) {
+            logger.info({ branch }, "Preserving parent branch (contains commit history)");
+            preservedBranches++;
+            continue;
+          }
           try {
             await gitOps.gitExec(["branch", "-D", branch], { cwd: repoRoot });
             deletedBranches++;
@@ -323,6 +349,6 @@ export async function cleanupOrphanedFromPreviousRuns(
     logger.debug({ error }, "Failed to list branches during cleanup");
   }
 
-  logger.info({ removedWorktrees, deletedBranches }, "Orphaned cleanup completed");
-  return { removedWorktrees, deletedBranches };
+  logger.info({ removedWorktrees, deletedBranches, preservedBranches }, "Orphaned cleanup completed");
+  return { removedWorktrees, deletedBranches, preservedBranches };
 }

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

@@ -54,6 +54,7 @@ function createMockConfig(teamsEnabled: boolean = false): Config {
       port: 7333,
       host: "localhost",
     },
+    git: { autoPush: false },
   };
 }