@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/runs/shared/worktree.ts

@@ -1,507 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { errorMessage as getErrorMessage, hasErrorCode } from "../../shared/unknown.ts";
-import { markWorktreesForPreservation } from "./worktree-preservation.ts";
-import { buildWorktreeBranch, buildWorktreePath } from "./worktree-location.ts";
-export {
-  findWorktreeTaskCwdConflict,
-  formatWorktreeTaskCwdConflict,
-  resolveExpectedWorktreeAgentCwd,
-} from "./worktree-location.ts";
-import { ensureTempRoot } from "../../shared/temp-root.ts";
-import { runGitChecked, runSetupCommand, runSetupGit } from "./worktree-process.ts";
-import {
-  DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS,
-  resolveWorktreeSetupHook,
-  runWorktreeSetupHook,
-  type WorktreeSetupHookConfig,
-  type ResolvedWorktreeSetupHook,
-} from "./worktree-hook.ts";
-
-export class WorktreeCleanupError extends Error {}
-
-export type { WorktreeSetup } from "./worktree-contract.ts";
-import type { WorktreeSetup, WorktreeInfo, WorktreeDiff } from "./worktree-contract.ts";
-
-interface CreateWorktreesOptions {
-  readonly agents?: readonly string[];
-  readonly setupHook?: WorktreeSetupHookConfig;
-  readonly signal?: AbortSignal;
-}
-
-interface RepoState {
-  readonly toplevel: string;
-  readonly cwdRelative: string;
-  readonly baseCommit: string;
-}
-
-async function resolveRepoState(cwd: string, signal?: AbortSignal): Promise<RepoState> {
-  const repoCheck = await runSetupCommand({
-    command: "git",
-    args: ["-C", cwd, "rev-parse", "--is-inside-work-tree"],
-    cwd,
-    signal,
-  });
-  if (repoCheck.status !== 0 || repoCheck.stdout.trim() !== "true") {
-    throw new Error("worktree isolation requires a git repository");
-  }
-  const cwdRelative = (await runSetupGit(cwd, ["rev-parse", "--show-prefix"], signal))
-    .trim()
-    .replace(/[\\/]+$/, "");
-  const toplevel = (await runSetupGit(cwd, ["rev-parse", "--show-toplevel"], signal)).trim();
-
-  const status = await runSetupGit(toplevel, ["status", "--porcelain"], signal);
-  if (status.trim().length > 0) {
-    throw new Error(
-      "worktree isolation requires a clean git working tree. Commit or stash changes first, or rerun without worktree isolation if shared-checkout edits are intentional.",
-    );
-  }
-
-  const baseCommit = (await runSetupGit(toplevel, ["rev-parse", "HEAD"], signal)).trim();
-  return { toplevel, cwdRelative, baseCommit };
-}
-
-function safePatchAgentName(agent: string): string {
-  return agent.replace(/[^\w.-]/g, "_");
-}
-
-function escapesRoot(relative: string): boolean {
-  return relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative);
-}
-
-function readSyntheticStat(resolved: string): fs.Stats | undefined {
-  try {
-    return fs.lstatSync(resolved);
-  } catch (error) {
-    if (hasErrorCode(error, "ENOENT")) {
-      return undefined;
-    }
-    throw error;
-  }
-}
-
-function removeSyntheticPath(worktree: WorktreeInfo, syntheticPath: string): void {
-  const resolved = path.resolve(worktree.path, syntheticPath);
-  const relative = path.relative(worktree.path, resolved);
-  if (relative.length === 0 || relative === "." || escapesRoot(relative)) {
-    return;
-  }
-  const stat = readSyntheticStat(resolved);
-  if (!stat) {
-    return;
-  }
-  const realRoot = fs.realpathSync(worktree.path);
-  const realParent = fs.realpathSync(path.dirname(resolved));
-  const parentRelative = path.relative(realRoot, realParent);
-  if (escapesRoot(parentRelative)) {
-    throw new Error(`synthetic path resolves outside the worktree: ${syntheticPath}`);
-  }
-
-  if (stat.isSymbolicLink()) {
-    fs.unlinkSync(resolved);
-    return;
-  }
-  if (stat.isDirectory()) {
-    fs.rmSync(resolved, { recursive: true, force: true });
-    return;
-  }
-  fs.rmSync(resolved, { force: true });
-}
-
-function removeSyntheticPathsBeforeDiff(worktree: WorktreeInfo): void {
-  if (worktree.syntheticPaths.length === 0) {
-    return;
-  }
-  const seen = new Set<string>();
-  for (const syntheticPath of worktree.syntheticPaths) {
-    if (seen.has(syntheticPath)) {
-      continue;
-    }
-    seen.add(syntheticPath);
-    removeSyntheticPath(worktree, syntheticPath);
-  }
-}
-
-function emptyDiff(
-  input: Pick<
-    WorktreeDiff,
-    "index" | "agent" | "branch" | "patchPath" | "worktreePath" | "captureError"
-  >,
-): WorktreeDiff {
-  return {
-    ...input,
-    diffStat: "",
-    filesChanged: 0,
-    insertions: 0,
-    deletions: 0,
-  };
-}
-
-function parseNumstat(numstat: string): {
-  filesChanged: number;
-  insertions: number;
-  deletions: number;
-} {
-  const lines = numstat
-    .split("\n")
-    .map((line) => line.trim())
-    .filter(Boolean);
-  let filesChanged = 0;
-  let insertions = 0;
-  let deletions = 0;
-
-  for (const line of lines) {
-    const columns = line.split("\t");
-    if (columns.length < 2) {
-      continue;
-    }
-    const [rawInsertions, rawDeletions] = columns;
-    filesChanged++;
-    if (/^\d+$/.test(rawInsertions)) {
-      insertions += parseInt(rawInsertions, 10);
-    }
-    if (/^\d+$/.test(rawDeletions)) {
-      deletions += parseInt(rawDeletions, 10);
-    }
-  }
-
-  return { filesChanged, insertions, deletions };
-}
-
-function captureWorktreeDiff(
-  setup: Readonly<WorktreeSetup>,
-  worktree: WorktreeInfo,
-  agent: string,
-  patchPath: string,
-): WorktreeDiff {
-  removeSyntheticPathsBeforeDiff(worktree);
-  runGitChecked(worktree.path, ["add", "-A"]);
-  const diffStat = runGitChecked(worktree.path, [
-    "diff",
-    "--cached",
-    "--stat",
-    setup.baseCommit,
-  ]).trim();
-  const patch = runGitChecked(worktree.path, [
-    "diff",
-    "--cached",
-    "--binary",
-    "--no-textconv",
-    "--no-ext-diff",
-    setup.baseCommit,
-  ]);
-  const numstat = runGitChecked(worktree.path, ["diff", "--cached", "--numstat", setup.baseCommit]);
-  fs.writeFileSync(patchPath, patch, "utf-8");
-
-  if (patch.trim().length === 0) {
-    return emptyDiff({
-      index: worktree.index,
-      agent,
-      branch: worktree.branch,
-      patchPath,
-      worktreePath: worktree.path,
-    });
-  }
-
-  const parsed = parseNumstat(numstat);
-  return {
-    index: worktree.index,
-    agent,
-    branch: worktree.branch,
-    diffStat,
-    filesChanged: parsed.filesChanged,
-    insertions: parsed.insertions,
-    deletions: parsed.deletions,
-    patchPath,
-    worktreePath: worktree.path,
-  };
-}
-
-function writeEmptyPatch(patchPath: string): void {
-  try {
-    fs.writeFileSync(patchPath, "", "utf-8");
-  } catch {
-    // Diff artifact writing is best-effort in error paths.
-  }
-}
-
-function cleanupSingleWorktree(repoCwd: string, worktree: WorktreeInfo): void {
-  try {
-    runGitChecked(repoCwd, ["worktree", "remove", "--force", worktree.path]);
-  } catch (error) {
-    console.error(`Failed to remove worktree '${worktree.path}': ${getErrorMessage(error)}`);
-  }
-  try {
-    runGitChecked(repoCwd, ["branch", "-D", worktree.branch]);
-  } catch (error) {
-    console.error(
-      `Failed to delete worktree branch '${worktree.branch}': ${getErrorMessage(error)}`,
-    );
-  }
-}
-
-function hasWorktreeChanges(diff: WorktreeDiff): boolean {
-  return (
-    Boolean(diff.captureError) ||
-    diff.filesChanged > 0 ||
-    diff.insertions > 0 ||
-    diff.deletions > 0 ||
-    diff.diffStat.trim().length > 0
-  );
-}
-
-interface WorktreeReservation {
-  readonly path?: string;
-  readonly branch?: string;
-}
-interface WorktreePlan {
-  readonly repo: Readonly<RepoState>;
-  readonly runId: string;
-  readonly hook?: ResolvedWorktreeSetupHook;
-  readonly signal?: AbortSignal;
-  readonly agents?: readonly string[];
-}
-
-async function reserveWorktree(
-  plan: WorktreePlan,
-  index: number,
-): Promise<{ worktree: WorktreeInfo; reservation: WorktreeReservation }> {
-  const { repo, signal } = plan;
-  const branch = buildWorktreeBranch(plan.runId, index);
-  const worktreePath = buildWorktreePath(plan.runId, index);
-  ensureTempRoot();
-  const pathExisted = fs.existsSync(worktreePath);
-  const branchExisted =
-    (await runSetupGit(repo.toplevel, ["branch", "--list", branch], signal)).trim().length > 0;
-  // Reserve only resources this attempt can create, before Git can partially initialize them.
-  const agentCwd =
-    repo.cwdRelative.length > 0 ? path.join(worktreePath, repo.cwdRelative) : worktreePath;
-  return {
-    worktree: { path: worktreePath, agentCwd, branch, index, syntheticPaths: [] },
-    reservation: {
-      path: pathExisted ? undefined : worktreePath,
-      branch: branchExisted ? undefined : branch,
-    },
-  };
-}
-
-async function initializeWorktree(
-  plan: WorktreePlan,
-  worktree: WorktreeInfo,
-): Promise<WorktreeInfo> {
-  const { repo, signal } = plan;
-  const { path: worktreePath, agentCwd, branch, index } = worktree;
-  await runSetupGit(repo.toplevel, ["worktree", "add", worktreePath, "-b", branch, "HEAD"], signal);
-  const syntheticPaths = plan.hook
-    ? await runWorktreeSetupHook(
-        plan.hook,
-        {
-          version: 1,
-          repoRoot: repo.toplevel,
-          worktreePath,
-          agentCwd,
-          branch,
-          index,
-          runId: plan.runId,
-          baseCommit: repo.baseCommit,
-          agent: plan.agents?.[index],
-        },
-        signal,
-      )
-    : [];
-  return { path: worktreePath, agentCwd, branch, index, syntheticPaths };
-}
-
-async function rollbackWorktree(
-  repoCwd: string,
-  entry: WorktreeReservation,
-  signal: AbortSignal,
-): Promise<string[]> {
-  const failures: string[] = [];
-  if (entry.path !== undefined && fs.existsSync(entry.path)) {
-    try {
-      // An interrupted checkout can leave Git's initializing lock on this newly owned path.
-      await runSetupGit(repoCwd, ["worktree", "remove", "--force", "--force", entry.path], signal);
-    } catch (error) {
-      failures.push(`Could not remove worktree '${entry.path}': ${getErrorMessage(error)}`);
-    }
-  }
-  if (entry.branch !== undefined) {
-    try {
-      const exists = (
-        await runSetupGit(repoCwd, ["branch", "--list", entry.branch], signal)
-      ).trim();
-      if (exists.length > 0) {
-        await runSetupGit(repoCwd, ["branch", "-D", entry.branch], signal);
-      }
-    } catch (error) {
-      failures.push(
-        `Could not delete worktree branch '${entry.branch}': ${getErrorMessage(error)}`,
-      );
-    }
-  }
-  return failures;
-}
-
-export async function createWorktrees(
-  cwd: string,
-  runId: string,
-  count: number,
-  options?: CreateWorktreesOptions,
-): Promise<WorktreeSetup> {
-  const signal = options?.signal;
-  const repo = await resolveRepoState(cwd, signal);
-  const hook = resolveWorktreeSetupHook(repo.toplevel, options?.setupHook);
-  const plan: WorktreePlan = { repo, runId, hook, signal, agents: options?.agents };
-  const worktrees: WorktreeInfo[] = [];
-  const reservations: WorktreeReservation[] = [];
-  try {
-    for (let index = 0; index < count; index++) {
-      // Git modifies a shared repository; finish setup before reserving the next worktree.
-      // oxlint-disable-next-line no-await-in-loop
-      const { worktree, reservation } = await reserveWorktree(plan, index);
-      reservations.push(reservation);
-      // Register rollback authority before Git can partially initialize this worktree.
-      // oxlint-disable-next-line no-await-in-loop
-      worktrees.push(await initializeWorktree(plan, worktree));
-    }
-  } catch (error) {
-    // Rollback remains owned after cancellation and has its own bounded lifetime.
-    const cleanupSignal = AbortSignal.timeout(
-      hook?.timeoutMs ?? DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS,
-    );
-    const failures: string[] = [];
-    for (const entry of reservations.reverse()) {
-      // Reverse-order resource release must finish before removing the preceding reservation.
-      // oxlint-disable-next-line no-await-in-loop
-      failures.push(...(await rollbackWorktree(repo.toplevel, entry, cleanupSignal)));
-    }
-    if (failures.length > 0) {
-      throw new WorktreeCleanupError(
-        `${getErrorMessage(error)}\n\nWorktree rollback incomplete:\n${failures.join("\n")}`,
-        { cause: error },
-      );
-    }
-    throw error;
-  }
-  return { cwd: repo.toplevel, worktrees, baseCommit: repo.baseCommit };
-}
-
-export function diffWorktrees(
-  setup: Readonly<WorktreeSetup>,
-  agents: readonly string[],
-  diffsDir: string,
-): WorktreeDiff[] {
-  try {
-    fs.mkdirSync(diffsDir, { recursive: true });
-  } catch (error) {
-    const message = `failed to create worktree diff artifact directory '${diffsDir}': ${getErrorMessage(error)}`;
-    markWorktreesForPreservation(setup, message);
-    return setup.worktrees.map((worktree, index) => {
-      const agent = agents[index] ?? `task-${index + 1}`;
-      const patchPath = path.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
-      return emptyDiff({
-        index,
-        agent,
-        branch: worktree.branch,
-        patchPath,
-        worktreePath: worktree.path,
-        captureError: message,
-      });
-    });
-  }
-
-  const diffs: WorktreeDiff[] = [];
-  for (let index = 0; index < setup.worktrees.length; index++) {
-    const worktree = setup.worktrees[index];
-    const agent = agents[index] ?? `task-${index + 1}`;
-    const patchPath = path.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
-    try {
-      diffs.push(captureWorktreeDiff(setup, worktree, agent, patchPath));
-    } catch (error) {
-      const message = `failed to capture worktree diff for task ${index + 1} (${agent}) at '${worktree.path}': ${getErrorMessage(error)}`;
-      markWorktreesForPreservation(setup, message);
-      writeEmptyPatch(patchPath);
-      diffs.push(
-        emptyDiff({
-          index,
-          agent,
-          branch: worktree.branch,
-          patchPath,
-          worktreePath: worktree.path,
-          captureError: message,
-        }),
-      );
-    }
-  }
-
-  return diffs;
-}
-
-export function cleanupWorktrees(setup: Readonly<WorktreeSetup>): void {
-  if (setup.preserveOnCleanup === true) {
-    return;
-  }
-  for (let index = setup.worktrees.length - 1; index >= 0; index--) {
-    cleanupSingleWorktree(setup.cwd, setup.worktrees[index]);
-  }
-  try {
-    runGitChecked(setup.cwd, ["worktree", "prune"]);
-  } catch (error) {
-    console.error(`Failed to prune worktrees in '${setup.cwd}': ${getErrorMessage(error)}`);
-  }
-}
-
-function worktreeRecoveryLines(diff: WorktreeDiff): string[] {
-  if (diff.captureError === undefined || diff.captureError.length === 0) {
-    return [];
-  }
-  const lines = [`Diff capture failed: ${diff.captureError}`];
-  if (diff.worktreePath !== undefined && diff.worktreePath.length > 0) {
-    lines.push(`Preserved worktree: ${diff.worktreePath}`);
-  }
-  lines.push(`Preserved branch: ${diff.branch}`);
-  return lines;
-}
-
-export function formatWorktreeDiffSummary(diffs: readonly WorktreeDiff[]): string {
-  const changed = diffs.filter(hasWorktreeChanges);
-  if (changed.length === 0) {
-    return "";
-  }
-
-  const lines: string[] = ["=== Worktree Changes ===", ""];
-  for (const diff of changed) {
-    lines.push(
-      `--- Task ${diff.index + 1} (${diff.agent}): ${diff.filesChanged} files changed, +${diff.insertions} -${diff.deletions} ---`,
-    );
-    lines.push(...worktreeRecoveryLines(diff));
-    if (diff.diffStat.trim().length > 0) {
-      lines.push(diff.diffStat);
-    }
-    lines.push("");
-  }
-
-  const patchesDir = path.dirname(changed[0]?.patchPath ?? "");
-  if (changed.some((diff) => (diff.captureError ?? "").length === 0)) {
-    lines.push(`Full patches: ${patchesDir}`);
-  } else {
-    lines.push("Patch artifacts unavailable; preserved worktrees contain the recoverable changes.");
-  }
-  return lines.join("\n").trimEnd();
-}
-
-export function formatParallelWorktreeSummary(
-  worktreeSetup: Readonly<WorktreeSetup> | undefined,
-  diffsDir: string,
-  agents: readonly string[],
-): string {
-  if (!worktreeSetup) {
-    return "";
-  }
-  return formatWorktreeDiffSummary(diffWorktrees(worktreeSetup, agents, diffsDir));
-}
-
-export function appendWorktreeSummary(output: string, worktreeSummary: string): string {
-  return worktreeSummary.length > 0 ? `${output}\n\n${worktreeSummary}` : output;
-}