@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.1

package/src/git.js

@@ -0,0 +1,626 @@
+import { spawn } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync, realpathSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { appendFile, copyFile, lstat, mkdir, readdir, readFile, realpath, rm } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { envNumber, timerMs, WORKTREE_DIR } from "./config.js";
+import { childEnv } from "./env.js";
+import { logWarn } from "./log.js";
+const GIT_TIMEOUT_MS = timerMs(envNumber("CODEFLOW_GIT_TIMEOUT_SEC", 300, { min: 1 }) * 1e3);
+const GIT_MAX_OUTPUT = 64 * 1024 * 1024;
+function gitEnv(extra) {
+  return childEnv({ GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never", GIT_OPTIONAL_LOCKS: "0", LANGUAGE: "C", LC_MESSAGES: "C", ...extra });
+}
+const folderOf = (cwd) => typeof cwd === "string" ? cwd : cwd.path;
+function gitCommand(args, cwd, opts = {}) {
+  const own = ["-c", "core.fsmonitor=false", ...opts.hooks ? [] : ["-c", "core.hooksPath=/dev/null"]];
+  const ceiling = opts.discover ? {} : { GIT_CEILING_DIRECTORIES: dirname(realPathSync(folderOf(cwd))) };
+  const pinned = typeof cwd === "string" ? {} : { GIT_DIR: cwd.gitDir, GIT_WORK_TREE: cwd.path };
+  return { args: [...own, ...args], env: gitEnv({ ...ceiling, ...pinned, ...opts.env }) };
+}
+function realPathSync(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+const realPath = (path) => realpath(path).catch(() => resolve(path));
+function git(args, cwd, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? GIT_TIMEOUT_MS;
+  return new Promise((resolve2) => {
+    const command = gitCommand(args, cwd, opts);
+    const child = spawn("git", command.args, { cwd: folderOf(cwd), env: command.env, detached: true, stdio: ["pipe", "pipe", "pipe"] });
+    const out = [];
+    const err = [];
+    let outBytes = 0;
+    let errBytes = 0;
+    let overflow = false;
+    let timedOut = false;
+    let aborted = false;
+    let settled = false;
+    const kill = () => {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+        child.kill("SIGKILL");
+      }
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill();
+    }, timeoutMs);
+    timer.unref();
+    const onAbort = () => {
+      aborted = true;
+      kill();
+    };
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    if (opts.signal?.aborted) onAbort();
+    child.stdout.on("data", (chunk) => {
+      if (overflow) return;
+      outBytes += chunk.length;
+      if (outBytes > GIT_MAX_OUTPUT) {
+        overflow = true;
+        kill();
+      } else out.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      if (errBytes > 1024 * 1024) return;
+      errBytes += chunk.length;
+      err.push(chunk);
+    });
+    const finish = (exitCode) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
+      const stdout = Buffer.concat(out).toString();
+      const stderr = Buffer.concat(err).toString();
+      if (overflow) resolve2({ code: 1, stdout: "", stderr: `git ${args[0]} printed more than ${GIT_MAX_OUTPUT / 1024 / 1024} MB` });
+      else if (aborted) resolve2({ code: 1, stdout: "", stderr: `git ${args[0]} was cancelled`, aborted: true });
+      else if (timedOut) resolve2({ code: 1, stdout, stderr: `git ${args[0]} timed out after ${Math.round(timeoutMs / 1e3)}s
+${stderr}`.trim(), timedOut: true });
+      else resolve2({ code: exitCode ?? 1, stdout, stderr });
+    };
+    child.on("error", (e) => {
+      err.push(Buffer.from(e.message));
+      finish(1);
+    });
+    child.on("close", (code) => finish(code));
+    child.on("exit", (code) => {
+      setTimeout(() => {
+        child.stdout.destroy();
+        child.stderr.destroy();
+        finish(code);
+      }, 2e3).unref();
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(opts.input);
+  });
+}
+function gitError(args, res) {
+  const text = (res.stderr.trim() || res.stdout.trim()).slice(0, 2e3);
+  return `git ${args.join(" ").slice(0, 200)} failed: ${text}`;
+}
+async function gitOk(args, cwd, opts) {
+  const res = await git(args, cwd, opts);
+  if (res.code !== 0) throw new Error(gitError(args, res));
+  return res.stdout.trim();
+}
+function classifyGitFailure(res) {
+  if (res.timedOut) return "timeout";
+  const text = `${res.stderr}
+${res.stdout}`;
+  if (/index\.lock|Unable to create '.*\.lock'|another git process seems to be running/i.test(text)) return "locked";
+  if (/untracked working tree files would be (?:overwritten|removed)/i.test(text)) return "untracked";
+  if (/local changes to the following files would be overwritten|Please commit your changes or stash them/i.test(text)) return "dirty";
+  if (/^CONFLICT|Automatic merge failed|fix conflicts and then commit/im.test(text)) return "conflict";
+  if (/Please tell me who you are|unable to auto-detect email address|empty ident name/i.test(text)) return "identity";
+  if (/Authentication failed|could not read (?:Username|Password)|terminal prompts disabled|Permission denied \(publickey|returned error: 403|Repository not found/i.test(text)) return "auth";
+  if (/hook\b.*(?:failed|declined|exit)|(?:pre|post)-\w+ hook/i.test(text)) return "hook";
+  return "other";
+}
+function describeGitFailure(kind) {
+  switch (kind) {
+    case "locked":
+      return "another git process is using this repository (an index.lock exists); try again when it finishes";
+    case "untracked":
+      return "untracked files in your checkout would be overwritten";
+    case "dirty":
+      return "your checkout has uncommitted changes that would be overwritten";
+    case "conflict":
+      return "the branches conflict";
+    case "hook":
+      return "a git hook failed";
+    case "identity":
+      return "git doesn't know your name and email (set user.name and user.email)";
+    case "auth":
+      return "git couldn't sign in to the remote (check your credentials)";
+    case "timeout":
+      return "git took too long";
+    default:
+      return "git failed";
+  }
+}
+let versionPromise;
+function gitVersion() {
+  const pending = versionPromise ??= git(["--version"], process.cwd(), { timeoutMs: 1e4 }).then((res) => {
+    const m = /(\d+)\.(\d+)(?:\.(\d+))?/.exec(res.stdout);
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3] ?? 0)] : void 0;
+  });
+  void pending.then((v) => {
+    if (!v && versionPromise === pending) versionPromise = void 0;
+  });
+  return pending;
+}
+async function gitAtLeast(major, minor) {
+  const v = await gitVersion();
+  return !!v && (v[0] > major || v[0] === major && v[1] >= minor);
+}
+function serialize(locks, key, fn) {
+  const prev = locks.get(key) ?? Promise.resolve();
+  const next = prev.catch(() => void 0).then(fn);
+  const tail = next.catch(() => void 0);
+  locks.set(key, tail);
+  void tail.then(() => {
+    if (locks.get(key) === tail) locks.delete(key);
+  });
+  return next;
+}
+const repoLocks = /* @__PURE__ */ new Map();
+function withRepoLock(repo, fn) {
+  return serialize(repoLocks, resolve(repo), fn);
+}
+const worktreeLocks = /* @__PURE__ */ new Map();
+function withWorktreeLock(cwd, fn) {
+  return serialize(worktreeLocks, resolve(cwd), fn);
+}
+async function repoRoot(path) {
+  return gitOk(["rev-parse", "--show-toplevel"], path, { discover: true });
+}
+async function resolveCommit(repo, ref = "HEAD") {
+  return gitOk(["rev-parse", "--verify", `${ref}^{commit}`], repo);
+}
+class WorktreeMismatchError extends Error {
+}
+async function worktreeGit(repo, path) {
+  const found = await findGitDir(repo, path);
+  if (!found.gitDir) {
+    throw new WorktreeMismatchError(`${path} isn't a checkout of ${repo} (no git folder of ${repo}'s names it), so code-flow didn't run git there.`);
+  }
+  return { path: found.path, gitDir: found.gitDir };
+}
+async function commonDir(repo) {
+  return realPath(resolve(repo, await gitOk(["rev-parse", "--git-common-dir"], repo)));
+}
+const realPathOfEntry = async (path) => join(await realPath(dirname(path)), basename(path));
+async function namedGitDir(dotGit) {
+  const info = await lstat(dotGit).catch(() => void 0);
+  if (!info?.isFile() || info.size > 4096) return void 0;
+  const named = /^gitdir: *(.+?)\s*$/m.exec(await readFile(dotGit, "utf8").catch(() => ""))?.[1];
+  return named ? realPath(resolve(dirname(dotGit), named)) : void 0;
+}
+async function namesCheckout(gitDir, dotGit) {
+  const back = (await readFile(join(gitDir, "gitdir"), "utf8").catch(() => "")).trim();
+  return !!back && await realPathOfEntry(resolve(gitDir, back)) === dotGit;
+}
+async function findGitDir(repo, path) {
+  const common = await commonDir(repo);
+  const real = await realPath(path);
+  const dotGit = join(real, ".git");
+  const worktrees = join(common, "worktrees");
+  const hint = await namedGitDir(dotGit);
+  if (hint && dirname(hint) === worktrees && await namesCheckout(hint, dotGit)) return { path: real, common, gitDir: hint };
+  for (const entry of await readdir(worktrees).catch(() => [])) {
+    if (await namesCheckout(join(worktrees, entry), dotGit)) return { path: real, common, gitDir: join(worktrees, entry) };
+  }
+  const main = await mainWorktree(repo);
+  return { path: real, common, gitDir: main && await realPath(main) === real ? common : void 0 };
+}
+async function assertWorktree(repo, wt) {
+  const found = await findGitDir(repo, wt.path);
+  const problem = await dotGitProblem(repo, found);
+  const checkout = found.gitDir && !problem ? { path: found.path, gitDir: found.gitDir } : void 0;
+  const branchProblem = checkout && wt.branch ? await headProblem(checkout, wt.branch) : void 0;
+  if (!checkout || branchProblem) {
+    throw new WorktreeMismatchError(
+      `${wt.path} isn't the checkout code-flow expects (${problem ?? branchProblem ?? `no git folder of ${repo}'s names it`}), so code-flow didn't run git there: it could have changed another checkout or branch, such as yours. Nothing was changed.`
+    );
+  }
+  return checkout;
+}
+async function dotGitProblem(repo, found) {
+  const dotGit = join(found.path, ".git");
+  const info = await lstat(dotGit).catch(() => void 0);
+  if (!info) return "its .git is missing";
+  let named;
+  if (info.isDirectory()) named = await realPath(dotGit);
+  else if (info.isFile()) {
+    const gitDir = await namedGitDir(dotGit);
+    if (!gitDir) return "its .git doesn't name a git folder";
+    named = gitDir;
+  } else return `its .git is a ${info.isSymbolicLink() ? "symbolic link" : "special file"}`;
+  if (named === found.gitDir) return void 0;
+  if (named === found.common) return `its .git points to the git folder of ${await mainWorktree(repo) ?? repo} itself`;
+  if (dirname(named) === join(found.common, "worktrees")) {
+    return existsSync(join(named, "gitdir")) ? `its .git points to the git folder of another worktree (${named})` : `its .git points to ${named}, which isn't there any more`;
+  }
+  return `its .git points to ${named}, which isn't one of ${repo}'s worktrees`;
+}
+async function headProblem(checkout, branch) {
+  const head = (await git(["symbolic-ref", "-q", "HEAD"], checkout)).stdout.trim();
+  if (head === `refs/heads/${branch}`) return void 0;
+  return head ? `it's on ${head.replace(/^refs\/heads\//, "")}, not ${branch}` : `its HEAD is detached, not on ${branch}`;
+}
+async function mainWorktree(repo) {
+  const lines = (await gitOk(["worktree", "list", "--porcelain"], repo)).split("\n");
+  const end = lines.indexOf("");
+  const first = lines.slice(0, end === -1 ? void 0 : end);
+  return first.includes("bare") ? void 0 : first.find((l) => l.startsWith("worktree "))?.slice("worktree ".length);
+}
+const IDENTITY = ["-c", "user.name=code-flow", "-c", "user.email=code-flow@localhost"];
+const RAW_DIFF = ["--no-ext-diff", "--no-textconv"];
+function worktreeRoot(repo) {
+  return resolve(repo, WORKTREE_DIR);
+}
+const CONTEXT_DIR = ".codeflow-context";
+async function ensureCodeflowExcludes(repo) {
+  const patterns = [`/${CONTEXT_DIR}/`];
+  const rel = relative(repo, worktreeRoot(repo));
+  if (rel && !rel.startsWith("..") && !isAbsolute(rel)) patterns.unshift(`/${rel.split(sep).join("/")}/`);
+  const excludeFile = resolve(repo, await gitOk(["rev-parse", "--git-path", "info/exclude"], repo));
+  const current = await readFile(excludeFile, "utf8").catch(() => "");
+  const existing = new Set(current.split("\n").map((line) => line.trim()));
+  const missing = patterns.filter((p) => !existing.has(p));
+  if (!missing.length) return;
+  await mkdir(dirname(excludeFile), { recursive: true });
+  const newline = current && !current.endsWith("\n") ? "\n" : "";
+  await appendFile(excludeFile, `${newline}# code-flow
+${missing.join("\n")}
+`);
+}
+function gitWithInput(args, cwd, input) {
+  return git(args, cwd, { input });
+}
+async function objectTypeAt(repo, ref, path) {
+  const res = await git(["cat-file", "-t", `${ref}:${path}`], repo);
+  const type = res.stdout.trim();
+  return res.code === 0 && (type === "blob" || type === "tree") ? type : null;
+}
+async function workingCopyDiffers(repo, ref, path) {
+  return (await git(["diff", "--quiet", ...RAW_DIFF, ref, "--", path], repo)).code !== 0;
+}
+const SUBMODULE_TIMEOUT_MS = 10 * 6e4;
+async function registerSubmodules(path) {
+  if (!existsSync(join(path, ".gitmodules"))) return void 0;
+  const args = ["submodule", "init"];
+  const res = await git(args, path);
+  return res.code === 0 ? void 0 : submoduleWarning(path, args, res);
+}
+async function updateSubmodules(path, signal) {
+  if (!existsSync(join(path, ".gitmodules"))) return void 0;
+  const args = ["submodule", "update", "--init", "--recursive"];
+  const res = await git(args, path, { timeoutMs: SUBMODULE_TIMEOUT_MS, signal });
+  return res.code === 0 ? void 0 : submoduleWarning(path, args, res);
+}
+const submoduleWarning = (path, args, res) => `Submodules weren't checked out in ${path}, so setup and checks that need them may fail. ${gitError(args, res)}`;
+async function openWorktree(repo, name, path, branch, fromRef, opts = {}) {
+  const base = await resolveCommit(repo, fromRef);
+  const wt = { name, path, branch, base };
+  if (existsSync(join(path, ".git"))) return { wt, created: false };
+  const opened = await withRepoLock(repo, async () => {
+    await mkdir(dirname(path), { recursive: true });
+    let created = false;
+    if ((await git(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], repo)).code === 0) {
+      await git(["worktree", "prune"], repo);
+      await gitOk(["worktree", "add", path, branch], repo);
+    } else {
+      await gitOk(["worktree", "add", "-b", branch, path, fromRef], repo);
+      created = true;
+    }
+    return { created, warning: await registerSubmodules(path) };
+  });
+  const warning = opened.warning ?? await updateSubmodules(path, opts.signal);
+  return warning ? { wt, created: opened.created, warning } : { wt, created: opened.created };
+}
+async function openDetachedWorktree(repo, path, ref, opts = {}) {
+  await removeDetachedWorktree(repo, path);
+  const registered = await withRepoLock(repo, async () => {
+    await mkdir(dirname(path), { recursive: true });
+    await gitOk(["worktree", "add", "--detach", path, ref], repo);
+    return registerSubmodules(path);
+  });
+  const warning = registered ?? await updateSubmodules(path, opts.signal);
+  return warning ? { warning } : {};
+}
+async function removeDetachedWorktree(repo, path) {
+  await withRepoLock(repo, async () => {
+    if (existsSync(path)) await git(["worktree", "remove", "--force", path], repo);
+    await rm(path, { recursive: true, force: true });
+    await git(["worktree", "prune"], repo);
+  });
+}
+async function listBranches(repo) {
+  const out = await gitOk(
+    [
+      "for-each-ref",
+      "--sort=-committerdate",
+      "--format=%(refname)%09%(refname:short)%09%(committerdate:relative)",
+      "refs/heads",
+      "refs/remotes"
+    ],
+    repo
+  );
+  const branches = [];
+  for (const line of out.split("\n").filter(Boolean)) {
+    const [ref = "", name = "", updated = ""] = line.split("	");
+    if (ref.startsWith("refs/remotes/") && ref.endsWith("/HEAD")) continue;
+    const kind = ref.startsWith("refs/remotes/") ? "remote" : ref.startsWith("refs/heads/codeflow/") ? "run" : "local";
+    branches.push({ name, kind, updated });
+  }
+  const head = await git(["symbolic-ref", "--short", "-q", "HEAD"], repo);
+  return { current: head.code === 0 ? head.stdout.trim() : null, branches };
+}
+async function validateBranchPrefix(repo, prefix) {
+  if ((await git(["check-ref-format", "--branch", `${prefix}/x`], repo)).code !== 0) {
+    throw new Error(`"${prefix}" is not a valid branch name prefix`);
+  }
+  if ((await git(["show-ref", "--verify", "--quiet", `refs/heads/${prefix}`], repo)).code === 0) {
+    throw new Error(`A branch named "${prefix}" already exists, so "${prefix}/\u2026" branches can't be created`);
+  }
+  if (await gitOk(["for-each-ref", "--count=1", "--format=%(refname:short)", `refs/heads/${prefix}/`], repo)) {
+    throw new Error(`Branches under "${prefix}/" already exist; pick another prefix`);
+  }
+}
+async function commitAll(repo, wt, message, onWarning) {
+  const at = await assertWorktree(repo, wt);
+  await gitOk(["add", "-A"], at);
+  await unstageSecrets(at, onWarning);
+  const staged = await git(["diff", "--cached", "--quiet", ...RAW_DIFF], at);
+  if (staged.code === 0 && !await isMerging(at)) return null;
+  await gitOk([...IDENTITY, "commit", "--no-verify", "-m", message], at);
+  return resolveCommit(at);
+}
+const COPIED_FILES = "codeflow-copied";
+const SECRET_NAME = /^(?:\.env(?:\..+)?|.+\.pem|id_rsa.*|id_ed25519.*)$/;
+const SECRET_TEMPLATE = /^\.env\.(?:example|sample|template)$/;
+async function unstageSecrets(at, onWarning) {
+  const staged = await git(["diff", "--cached", "--name-status", "--no-renames", "-z", ...RAW_DIFF], at);
+  if (staged.code !== 0 || !staged.stdout) return;
+  const record = (await git(["rev-parse", "--git-path", COPIED_FILES], at)).stdout.trim();
+  const copied = new Set(record ? (await readFile(resolve(folderOf(at), record), "utf8").catch(() => "")).split("\0").filter(Boolean) : []);
+  const tokens = staged.stdout.split("\0");
+  const drop = [];
+  for (let i = 0; i + 1 < tokens.length; i += 2) {
+    const [status, path] = [tokens[i], tokens[i + 1]];
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    const secret = status === "A" && SECRET_NAME.test(name) && !SECRET_TEMPLATE.test(name);
+    if (copied.has(path) && status !== "D" || secret) drop.push(path);
+  }
+  if (!drop.length) return;
+  await gitOk(["reset", "-q", "--", ...drop], at, { env: { GIT_LITERAL_PATHSPECS: "1" } });
+  const text = `Left ${drop.join(", ")} out of the commit: ${drop.length === 1 ? "it was" : "they were"} copied in from your checkout or ${drop.length === 1 ? "is" : "are"} named like a secret. Commit it yourself if it belongs in the repository.`;
+  logWarn(text, { worktree: folderOf(at) });
+  onWarning?.(text);
+}
+async function diffSince(at, base) {
+  return gitOk(["diff", "--no-color", ...RAW_DIFF, `${base}..HEAD`], at);
+}
+async function diffStat(at, base) {
+  return gitOk(["diff", "--stat", "--no-color", ...RAW_DIFF, `${base}..HEAD`], at);
+}
+async function changedFiles(cwd, from, to = "HEAD") {
+  const out = await gitOk(["diff", "--name-only", ...RAW_DIFF, `${from}..${to}`], cwd);
+  return out ? out.split("\n") : [];
+}
+async function mergeBranch(repo, wt, branch) {
+  const at = await assertWorktree(repo, wt);
+  const res = await git([...IDENTITY, "merge", "--no-ff", "--no-edit", branch], at);
+  if (res.code === 0) return { ok: true, conflicts: [], output: res.stdout };
+  const conflicts = await git(["diff", "--name-only", "--diff-filter=U", ...RAW_DIFF], at);
+  return {
+    ok: false,
+    conflicts: conflicts.stdout.trim().split("\n").filter(Boolean),
+    output: `${res.stdout}
+${res.stderr}`.trim()
+  };
+}
+async function isClean(cwd) {
+  return await gitOk(["status", "--porcelain"], cwd) === "";
+}
+async function uncommittedCount(cwd) {
+  const out = await gitOk(["status", "--porcelain"], cwd);
+  return out ? out.split("\n").length : 0;
+}
+async function discardChanges(repo, wt, to = "HEAD") {
+  const at = await assertWorktree(repo, wt);
+  await gitOk(["reset", "--hard", "-q", to], at);
+  await gitOk(["clean", "-fdq"], at);
+}
+const SNAPSHOT_FILE_LIMIT = { bytes: 8 * 1024 * 1024, files: 2e3 };
+const HASH_AS_IS = ["hash-object", "--no-filters", "--stdin-paths"];
+async function saveUntracked(at, paths) {
+  const files = [];
+  for (const path of paths) {
+    if (files.length >= SNAPSHOT_FILE_LIMIT.files) break;
+    if (path.includes("\n")) continue;
+    const info = await lstat(join(at.path, path)).catch(() => void 0);
+    if (info?.isFile() && info.size <= SNAPSHOT_FILE_LIMIT.bytes) files.push(path);
+  }
+  if (!files.length) return {};
+  const ids = (await gitOk([...HASH_AS_IS, "-w"], at, { input: `${files.join("\n")}
+` })).split("\n");
+  return Object.fromEntries(files.map((f, i) => [f, ids[i]]).filter(([, id]) => /^[0-9a-f]{40,64}$/.test(id)));
+}
+function writeBlob(at, id, path) {
+  return new Promise((resolve2, reject) => {
+    const target = join(at.path, path);
+    mkdirSync(dirname(target), { recursive: true });
+    const fd = openSync(target, "w");
+    const command = gitCommand(["cat-file", "blob", id], at);
+    const child = spawn("git", command.args, { cwd: at.path, env: command.env, stdio: ["ignore", fd, "pipe"] });
+    let stderr = "";
+    child.stderr?.on("data", (c) => stderr += c.toString());
+    child.on("error", (err) => {
+      closeSync(fd);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      closeSync(fd);
+      if (code === 0) resolve2();
+      else reject(new Error(`git cat-file blob ${id} failed: ${stderr.trim()}`));
+    });
+  });
+}
+async function stashCreate(at) {
+  const index = resolve(at.path, await gitOk(["rev-parse", "--git-path", "index"], at));
+  const copy = `${index}.codeflow-${process.pid}-${randomBytes(4).toString("hex")}`;
+  const copied = await copyFile(index, copy).then(() => true, () => false);
+  const env = copied ? { env: { GIT_INDEX_FILE: copy } } : void 0;
+  try {
+    if (copied) await git(["update-index", "-q", "--refresh"], at, env);
+    return (await gitOk(["stash", "create"], at, env)).trim();
+  } finally {
+    if (copied) await Promise.all([rm(copy, { force: true }), rm(`${copy}.lock`, { force: true })]);
+  }
+}
+async function gitOkWhenFree(args, at) {
+  for (let attempt = 0; ; attempt++) {
+    const res = await git(args, at);
+    if (res.code === 0) return res.stdout.trim();
+    if (attempt >= 5 || classifyGitFailure(res) !== "locked") throw new Error(gitError(args, res));
+    await new Promise((r) => setTimeout(r, 100 * 2 ** attempt));
+  }
+}
+async function uncommittedTree(at) {
+  const sha = await stashCreate(at);
+  return sha ? (await gitOk(["rev-parse", `${sha}^{tree}`], at)).trim() : "";
+}
+const untrackedFiles = async (at) => (await gitOk(["ls-files", "--others", "--exclude-standard", "-z"], at)).split("\0").filter(Boolean);
+async function snapshot(repo, cwd) {
+  return withWorktreeLock(cwd, async () => {
+    const at = await assertWorktree(repo, { path: cwd });
+    const untracked = await untrackedFiles(at);
+    return {
+      head: await resolveCommit(at),
+      changes: await stashCreate(at),
+      untracked,
+      untrackedBlobs: await saveUntracked(at, untracked)
+    };
+  });
+}
+async function restoreSnapshot(repo, wt, snap) {
+  return compareSnapshot(repo, wt, snap, true);
+}
+async function changedSince(repo, wt, snap) {
+  return compareSnapshot(repo, wt, snap, false);
+}
+function compareSnapshot(repo, wt, snap, undo) {
+  const cwd = wt.path;
+  return withWorktreeLock(cwd, async () => {
+    const at = await assertWorktree(repo, undo ? wt : { path: cwd });
+    const found = [];
+    const head = await resolveCommit(at);
+    const changesNow = await uncommittedTree(at);
+    const changesBefore = snap.changes ? (await gitOk(["rev-parse", `${snap.changes}^{tree}`], at)).trim() : "";
+    if (head !== snap.head) found.push("commits");
+    if (head !== snap.head || changesNow !== changesBefore) {
+      if (head === snap.head) found.push("edits");
+      if (undo) {
+        await gitOkWhenFree(["reset", "--hard", "-q", snap.head], at);
+        if (snap.changes) await gitOkWhenFree(["stash", "apply", "-q", snap.changes], at);
+      }
+    }
+    const before = new Set(snap.untracked);
+    const added = (await untrackedFiles(at)).filter((f) => !before.has(f));
+    if (added.length) {
+      found.push(`${added.length} new file${added.length === 1 ? "" : "s"}`);
+      if (undo) for (let i = 0; i < added.length; i += 100) await gitOkWhenFree(["clean", "-fq", "--", ...added.slice(i, i + 100)], at);
+    }
+    const saved = Object.entries(snap.untrackedBlobs ?? {});
+    if (saved.length) {
+      const present = (await Promise.all(saved.map(async ([path]) => (await lstat(join(at.path, path)).catch(() => void 0))?.isFile() ? path : void 0))).filter(
+        (p) => !!p
+      );
+      const now = present.length ? (await gitOk(HASH_AS_IS, at, { input: `${present.join("\n")}
+` })).split("\n") : [];
+      const current = new Map(present.map((p, i) => [p, now[i]]));
+      const changed = saved.filter(([path, id]) => current.get(path) !== id);
+      for (const [path, id] of undo ? changed : []) {
+        await rm(join(at.path, path), { recursive: true, force: true });
+        await writeBlob(at, id, path);
+      }
+      if (changed.length) found.push(`${changed.length} untracked file${changed.length === 1 ? "" : "s"} ${undo ? "put back" : "changed"}`);
+    }
+    return found;
+  });
+}
+async function isMerging(cwd) {
+  return (await git(["rev-parse", "-q", "--verify", "MERGE_HEAD"], cwd)).code === 0;
+}
+async function branchExists(repo, branch) {
+  return (await git(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], repo)).code === 0;
+}
+async function isAncestor(cwd, a, b = "HEAD") {
+  return (await git(["merge-base", "--is-ancestor", a, b], cwd)).code === 0;
+}
+async function restorePaths(repo, wt, ref, paths) {
+  if (!paths.length) return;
+  const at = await assertWorktree(repo, wt);
+  for (const path of paths) {
+    if (await objectTypeAt(at, ref, path)) await gitOk(["checkout", ref, "--", path], at);
+    else await git(["rm", "-q", "-f", "--ignore-unmatch", "--", path], at);
+  }
+}
+async function validRef(repo, ref) {
+  return !!ref && !ref.startsWith("-") && (await git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], repo)).code === 0;
+}
+async function hasConflictMarkers(at) {
+  const res = await git(["diff", "--check", ...RAW_DIFF], at);
+  return /conflict marker/i.test(res.stdout + res.stderr);
+}
+export {
+  CONTEXT_DIR,
+  COPIED_FILES,
+  WorktreeMismatchError,
+  assertWorktree,
+  branchExists,
+  changedFiles,
+  changedSince,
+  classifyGitFailure,
+  commitAll,
+  describeGitFailure,
+  diffSince,
+  diffStat,
+  discardChanges,
+  ensureCodeflowExcludes,
+  git,
+  gitAtLeast,
+  gitError,
+  gitVersion,
+  gitWithInput,
+  hasConflictMarkers,
+  isAncestor,
+  isClean,
+  isMerging,
+  listBranches,
+  mergeBranch,
+  objectTypeAt,
+  openDetachedWorktree,
+  openWorktree,
+  removeDetachedWorktree,
+  repoRoot,
+  resolveCommit,
+  restorePaths,
+  restoreSnapshot,
+  snapshot,
+  uncommittedCount,
+  validRef,
+  validateBranchPrefix,
+  withRepoLock,
+  workingCopyDiffers,
+  worktreeGit,
+  worktreeRoot
+};