@ronkovic/aad 0.3.9 → 0.5.0

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,21 +69,54 @@ export class MergeService {
     try {
       await lock.acquire();
 
+      // 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
+      }
+
       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 }
+        );
+      }
+
       // 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(
+        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) {

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;
+    }
+  }
+}