Port: --worktree flag for isolated write-capable rescue tasks #43

import {
  createWorktree,
  removeWorktree,
  deleteWorktreeBranch,
  getWorktreeDiff,
  applyWorktreePatch,
} from "./git.mjs";
import { getGitRoot } from "./git.mjs";

export async function createWorktreeSession(cwd) {
  const repoRoot = await getGitRoot(cwd);
  if (!repoRoot) throw new Error("Not a git repository — --worktree requires one.");
  return createWorktree(repoRoot);
}

export function diffWorktreeSession(session) {
  return getWorktreeDiff(session.worktreePath, session.baseCommit);
}

export function cleanupWorktreeSession(session, { keep = false } = {}) {
  if (keep) {
    const result = applyWorktreePatch(session.repoRoot, session.worktreePath, session.baseCommit);
    if (!result.applied && result.detail !== "No changes to apply.") {
      return result;
    }
    removeWorktree(session.repoRoot, session.worktreePath);
    deleteWorktreeBranch(session.repoRoot, session.branch);
    return result;
  }
  removeWorktree(session.repoRoot, session.worktreePath);
  deleteWorktreeBranch(session.repoRoot, session.branch);
  return { applied: false, detail: "Worktree discarded." };
}

import fs from "node:fs";
import path from "node:path";

export async function createWorktree(repoRoot) {
  const ts = Date.now();
  const worktreesDir = path.join(repoRoot, ".worktrees");
  fs.mkdirSync(worktreesDir, { recursive: true });

  // Add .worktrees/ to git/info/exclude if not already present, so the
  // worktree dir never shows up in the main repo's status.
  const rawGitDir = (await runCommand("git", ["rev-parse", "--git-dir"], { cwd: repoRoot })).stdout.trim();
  const gitDir = path.resolve(repoRoot, rawGitDir);
  const excludePath = path.join(gitDir, "info", "exclude");
  const excludeContent = fs.existsSync(excludePath) ? fs.readFileSync(excludePath, "utf8") : "";
  if (!excludeContent.includes(".worktrees")) {
    fs.mkdirSync(path.dirname(excludePath), { recursive: true });
    fs.appendFileSync(
      excludePath,
      `${excludeContent.endsWith("\n") || !excludeContent ? "" : "\n"}.worktrees/\n`
    );
  }

  const worktreePath = path.join(worktreesDir, `opencode-${ts}`);
  const branch = `opencode/${ts}`;
  const baseCommit = (await runCommand("git", ["rev-parse", "HEAD"], { cwd: repoRoot })).stdout.trim();
  await runCommand("git", ["worktree", "add", worktreePath, "-b", branch], { cwd: repoRoot });
  return { worktreePath, branch, repoRoot, baseCommit, timestamp: ts };
}

export async function removeWorktree(repoRoot, worktreePath) {
  await runCommand("git", ["worktree", "remove", "--force", worktreePath], { cwd: repoRoot });
}

export async function deleteWorktreeBranch(repoRoot, branch) {
  await runCommand("git", ["branch", "-D", branch], { cwd: repoRoot });
}

export async function getWorktreeDiff(worktreePath, baseCommit) {
  await runCommand("git", ["add", "-A"], { cwd: worktreePath });
  const statR = await runCommand("git", ["diff", "--cached", baseCommit, "--stat"], { cwd: worktreePath });
  if (statR.exitCode !== 0 || !statR.stdout.trim()) return { stat: "", patch: "" };
  const patchR = await runCommand("git", ["diff", "--cached", baseCommit], { cwd: worktreePath });
  return { stat: statR.stdout.trim(), patch: patchR.stdout };
}

export async function applyWorktreePatch(repoRoot, worktreePath, baseCommit) {
  await runCommand("git", ["add", "-A"], { cwd: worktreePath });
  const patchR = await runCommand("git", ["diff", "--cached", baseCommit], { cwd: worktreePath });
  if (patchR.exitCode !== 0 || !patchR.stdout.trim()) {
    return { applied: false, detail: "No changes to apply." };
  }
  const patchPath = path.join(
    repoRoot,
    `.opencode-worktree-${Date.now()}-${Math.random().toString(16).slice(2)}.patch`
  );
  try {
    fs.writeFileSync(patchPath, patchR.stdout, "utf8");
    const applyR = await runCommand("git", ["apply", "--index", patchPath], { cwd: repoRoot });
    if (applyR.exitCode !== 0) {
      return { applied: false, detail: applyR.stderr.trim() || "Patch apply failed (conflicts?)." };
    }
    return { applied: true, detail: "Changes applied and staged." };
  } finally {
    fs.rmSync(patchPath, { force: true });
  }
}