@reviewflow/sdk 6.24.0 → 6.27.0

package/build/git-node.mjs

@@ -1,14 +1,14 @@
 import { execFile, spawn } from 'node:child_process';
-import { env } from 'node:process';
+import { env, pid } from 'node:process';
 import { promisify } from 'node:util';
-import { lstat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { existsSync } from 'node:fs';
+import { lstat, readdir } from 'node:fs/promises';
+import { join, dirname, relative, isAbsolute } from 'node:path';
+import { existsSync, realpathSync } from 'node:fs';
 import { parseSync } from 'oxc-parser';
 import { builtinModules } from 'node:module';
 import { setImmediate } from 'node:timers/promises';
 
-const execFileAsync = promisify(execFile);
+const execFileAsync$1 = promisify(execFile);
 const timeoutMs = 1e4;
 const networkTimeoutMs = 6e4;
 const defaultMaxBuffer = 4 * 1024 * 1024;
@@ -31,10 +31,39 @@ const failureReason = (error, timeout) => {
   return "stderr" in error ? reasonLine(String(error.stderr)) : "";
 };
 const isExitOneAnswer = (error) => typeof error === "object" && error !== null && "code" in error && error.code === 1 && "stdout" in error && typeof error.stdout === "string" && error.stdout !== "";
+const runUninterruptible = async (cwd, args) => new Promise((resolve, reject) => {
+  const child = spawn("git", args, {
+    cwd,
+    env,
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.setEncoding("utf8").on("data", (chunk) => {
+    stdout += chunk;
+  });
+  child.stderr.setEncoding("utf8").on("data", (chunk) => {
+    stderr += chunk;
+  });
+  child.on("error", reject);
+  child.on("close", (code) => {
+    if (code === 0) {
+      resolve(stdout);
+      return;
+    }
+    reject(
+      Object.assign(new Error(`git exited with ${String(code)}`), {
+        stderr
+      })
+    );
+  });
+});
 const git = async (cwd, args, options = {}) => {
   const timeout = options.network ? networkTimeoutMs : timeoutMs;
   try {
-    const { stdout } = await execFileAsync("git", args, {
+    if (options.uninterruptible) return await runUninterruptible(cwd, args);
+    const { stdout } = await execFileAsync$1("git", args, {
       cwd,
       timeout,
       maxBuffer: options.maxBuffer ?? defaultMaxBuffer,
@@ -403,7 +432,693 @@ const groupDiffPaths = (isPackage, paths) => {
     if (group === void 0) groups.set(name, [path]);
     else group.push(path);
   }
-  return [...groups].toSorted(([left], [right]) => Number(left !== "") - Number(right !== "")).map(([name, groupPaths]) => ({ name, paths: groupPaths }));
+  return [...groups].toSorted(([left], [right]) => Number(left === "") - Number(right === "")).map(([name, groupPaths]) => ({ name, paths: groupPaths }));
+};
+
+const readHeadBranch = async (cwd) => {
+  const branch = await gitOrNull(cwd, [
+    "symbolic-ref",
+    "--quiet",
+    "--short",
+    "HEAD"
+  ]);
+  return branch === null || branch.trim() === "" ? null : branch.trim();
+};
+const readHeadSha = async (cwd, ref = "HEAD") => {
+  const sha = await git(cwd, ["rev-parse", ref]);
+  return sha.trim();
+};
+const readDefaultBranch = async (cwd) => {
+  const ref = await gitOrNull(cwd, [
+    "symbolic-ref",
+    "--quiet",
+    "--short",
+    "refs/remotes/origin/HEAD"
+  ]);
+  const name = ref?.trim().replace(/^origin\//, "") ?? "";
+  return name === "" ? null : name;
+};
+const readCommit = async (cwd, ref) => {
+  const sha = await gitOrNull(cwd, [
+    "rev-parse",
+    "--verify",
+    "--quiet",
+    `${ref}^{commit}`
+  ]);
+  return sha === null ? null : sha.trim();
+};
+const resolveReadHead = async (cwd, branch) => {
+  if (branch === void 0) {
+    return { ref: "HEAD", branch: await readHeadBranch(cwd) };
+  }
+  const ref = `refs/heads/${branch}`;
+  if (await readCommit(cwd, ref) === null) {
+    throw new Error(`no local branch ${branch} in ${cwd}`);
+  }
+  return { ref, branch };
+};
+const resolveDiffBase = async (cwd, name, head = "HEAD") => {
+  const candidates = [
+    { ref: `origin/${name}`, fullRef: `refs/remotes/origin/${name}` },
+    { ref: name, fullRef: `refs/heads/${name}` }
+  ];
+  for (const { ref, fullRef } of candidates) {
+    const sha = await readCommit(cwd, fullRef);
+    if (sha === null) continue;
+    const mergeBase = await gitOrNull(cwd, ["merge-base", sha, head]);
+    if (mergeBase === null) {
+      throw new Error(`${head} shares no history with ${ref}`);
+    }
+    return { base: { name, ref, sha }, mergeBase: mergeBase.trim() };
+  }
+  throw new Error(
+    `neither origin/${name} nor ${name} exists in ${cwd}: fetch the repository, or check its default branch`
+  );
+};
+const readScopeStart = async ({
+  cwd,
+  scope,
+  baseName,
+  head
+}) => {
+  if (scope === "uncommitted") return null;
+  const name = baseName ?? await readDefaultBranch(cwd) ?? "main";
+  return resolveDiffBase(cwd, name, head);
+};
+const readCheckoutBranchDiff = async ({
+  cwd,
+  baseName,
+  scope,
+  branch: branchName,
+  whitespace = "show",
+  limits
+}) => {
+  if (branchName !== void 0 && scope === "uncommitted") {
+    throw new Error(
+      `${branchName} is not checked out here: it has nothing uncommitted`
+    );
+  }
+  const head = await resolveReadHead(cwd, branchName);
+  const [start, headSha] = await Promise.all([
+    readScopeStart({ cwd, scope, baseName, head: head.ref }),
+    readHeadSha(cwd, head.ref)
+  ]);
+  const { paths, ...diff } = await readBranchDiff({
+    cwd,
+    mergeBase: start?.mergeBase ?? headSha,
+    head: head.ref,
+    scope: scope === "uncommitted" ? "workingTree" : "committed",
+    whitespace,
+    limits
+  });
+  return {
+    scope,
+    whitespace,
+    branch: head.branch,
+    headSha,
+    base: start?.base ?? null,
+    mergeBase: start?.mergeBase ?? null,
+    ...diff,
+    groups: groupDiffPaths(packagesOnDisk(cwd), paths)
+  };
+};
+
+const defaultRecentCommits = 30;
+const fieldSeparator$1 = "";
+const recordSeparator = "";
+const logFormat = ["%H", "%P", "%an", "%cI", "%s", "%b"].join("%x1f");
+const parseLog = (output) => output.split(recordSeparator).map((record) => record.replace(/^\n/, "")).filter((record) => record !== "").map((record) => {
+  const [
+    sha = "",
+    parents = "",
+    author = "",
+    committedAt = "",
+    headline = "",
+    body = ""
+  ] = record.split(fieldSeparator$1);
+  return {
+    sha,
+    parents: parents === "" ? [] : parents.split(" "),
+    author,
+    committedAt,
+    headline,
+    body: body.trim()
+  };
+});
+const readBranchStart = async ({
+  cwd,
+  baseName,
+  limit,
+  head
+}) => {
+  const name = baseName ?? await readDefaultBranch(cwd) ?? "main";
+  try {
+    const { base, mergeBase } = await resolveDiffBase(cwd, name, head);
+    const range = `${mergeBase}..${head}`;
+    const [listed, count] = await Promise.all([
+      git(cwd, ["rev-list", `--max-count=${String(limit)}`, range]),
+      git(cwd, ["rev-list", "--count", range])
+    ]);
+    return {
+      base,
+      onBranch: new Set(listed.split("\n").filter((sha) => sha !== "")),
+      count: Number(count.trim())
+    };
+  } catch {
+    return null;
+  }
+};
+const readUnpushed = async (cwd, limit, head) => {
+  const remotes = await git(cwd, ["remote"]);
+  if (remotes.trim() === "") return null;
+  const listed = await gitOrNull(cwd, [
+    "rev-list",
+    `--max-count=${String(limit)}`,
+    head,
+    "--not",
+    "--remotes"
+  ]);
+  return new Set((listed ?? "").split("\n").filter((sha) => sha !== ""));
+};
+const readRecentCommits = async ({
+  cwd,
+  limit = defaultRecentCommits,
+  baseName,
+  branch: branchName
+}) => {
+  const head = await resolveReadHead(cwd, branchName);
+  const [start, unpushed, log] = await Promise.all([
+    readBranchStart({ cwd, baseName, limit, head: head.ref }),
+    readUnpushed(cwd, limit, head.ref),
+    gitOrNull(cwd, [
+      "log",
+      "--no-color",
+      `--max-count=${String(limit)}`,
+      `--format=${logFormat}%x1e`,
+      head.ref
+    ])
+  ]);
+  const { branch } = head;
+  const commits = parseLog(log ?? "").map((commit) => ({
+    oid: commit.sha,
+    parentOid: commit.parents[0] ?? null,
+    merge: commit.parents.length > 1,
+    headline: commit.headline,
+    body: commit.body,
+    author: { login: commit.author, avatarUrl: null },
+    committedAt: commit.committedAt,
+    onBranch: start?.onBranch.has(commit.sha) ?? false,
+    pushed: unpushed === null ? null : !unpushed.has(commit.sha)
+  }));
+  return {
+    branch,
+    base: start?.base ?? null,
+    onBranchCount: start?.count ?? null,
+    commits
+  };
+};
+const emptyTree = async (cwd) => {
+  const tree = await git(cwd, ["hash-object", "-t", "tree", "/dev/null"]);
+  return tree.trim();
+};
+const readCommitDiff = async ({
+  cwd,
+  sha,
+  whitespace = "show",
+  limits
+}) => {
+  const listed = await git(cwd, [
+    "rev-list",
+    "--parents",
+    "--max-count=1",
+    `${sha}^{commit}`
+  ]);
+  const [commit = sha, parentSha = null] = listed.trim().split(" ");
+  const { paths, patch, omitted } = await readBranchDiff({
+    cwd,
+    mergeBase: parentSha ?? await emptyTree(cwd),
+    head: commit,
+    scope: "committed",
+    whitespace,
+    limits
+  });
+  return {
+    sha: commit,
+    parentSha,
+    whitespace,
+    patch,
+    omitted,
+    groups: groupDiffPaths(packagesOnDisk(cwd), paths)
+  };
+};
+
+const upstreamGone = (upstream) => `${upstream} no longer exists on the remote`;
+const pullRefusal = (status) => {
+  if (status.branch === null) return "a detached HEAD has nothing to pull into";
+  if (status.upstream === null) {
+    return `${status.branch} tracks no remote branch`;
+  }
+  if (status.behind === null) return upstreamGone(status.upstream);
+  if (status.behind === 0) {
+    return `${status.branch} is not behind ${status.upstream}`;
+  }
+  return null;
+};
+const pushRefusal = (status, hasOrigin) => {
+  if (status.branch === null) return "a detached HEAD has no branch to push";
+  if (status.upstream === null) {
+    return hasOrigin ? null : "this repository has no origin remote";
+  }
+  if (status.ahead === null) return upstreamGone(status.upstream);
+  if (status.ahead === 0) {
+    return `${status.branch} has nothing to push to ${status.upstream}`;
+  }
+  return null;
+};
+
+const headerValue = (line, key) => line.startsWith(`# ${key} `) ? line.slice(`# ${key} `.length) : null;
+const parseStatusV2 = (stdout) => {
+  const status = {
+    branch: null,
+    hasCommit: true,
+    upstream: null,
+    ahead: null,
+    behind: null,
+    modified: 0,
+    untracked: 0
+  };
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("# ")) {
+      const oid = headerValue(line, "branch.oid");
+      if (oid !== null) status.hasCommit = oid !== "(initial)";
+      const head = headerValue(line, "branch.head");
+      if (head !== null) status.branch = head === "(detached)" ? null : head;
+      const upstream = headerValue(line, "branch.upstream");
+      if (upstream !== null) status.upstream = upstream;
+      const ab = headerValue(line, "branch.ab");
+      const counts = ab === null ? null : /^\+(\d+) -(\d+)$/.exec(ab);
+      if (counts) {
+        status.ahead = Number(counts[1]);
+        status.behind = Number(counts[2]);
+      }
+    } else if (line.startsWith("? ")) {
+      status.untracked += 1;
+    } else if (/^[12u] /.test(line)) {
+      status.modified += 1;
+    }
+  }
+  return status;
+};
+const readHeadCommit = async (cwd) => {
+  const stdout = await gitOrNull(cwd, [
+    "log",
+    "-1",
+    "--format=%h%x00%s%x00%cI",
+    "--no-patch"
+  ]);
+  const [shortSha, subject, committedAt] = (stdout?.trim() ?? "").split("\0");
+  if (!shortSha || subject === void 0 || !committedAt) return null;
+  return {
+    shortSha,
+    subject,
+    committedAt: new Date(committedAt).toISOString()
+  };
+};
+const readCheckoutStatus = async (cwd) => {
+  const { hasCommit, ...status } = parseStatusV2(
+    await git(cwd, ["status", "--porcelain=v2", "--branch"])
+  );
+  return {
+    path: cwd,
+    ...status,
+    commit: hasCommit ? await readHeadCommit(cwd) : null
+  };
+};
+const messageOf$1 = (error) => error instanceof Error ? error.message : String(error);
+const hasOriginRemote = async (cwd) => await gitOrNull(cwd, ["remote", "get-url", "origin"]) !== null;
+const fetchFirst = async (cwd, fetch) => {
+  if (fetch === "never") return null;
+  const upstreamSha = await gitOrNull(cwd, [
+    "rev-parse",
+    "--verify",
+    "--quiet",
+    "@{upstream}"
+  ]);
+  if (upstreamSha === null) return null;
+  if (fetch !== "always" && upstreamSha.trim() === fetch.unlessUpstreamAt) {
+    return null;
+  }
+  try {
+    await git(cwd, ["fetch", "--quiet"], { network: true });
+    return null;
+  } catch (error) {
+    return messageOf$1(error);
+  }
+};
+const readCheckoutSync = async ({
+  cwd,
+  fetch = "never"
+}) => {
+  const fetchError = await fetchFirst(cwd, fetch);
+  const [status, hasOrigin] = await Promise.all([
+    readCheckoutStatus(cwd),
+    hasOriginRemote(cwd)
+  ]);
+  return { status, hasOrigin, fetchError };
+};
+const pullCheckout = async (cwd) => {
+  const refusal = pullRefusal(await readCheckoutStatus(cwd));
+  if (refusal !== null) throw new Error(refusal);
+  await git(cwd, ["pull", "--quiet", "--ff-only"], { network: true });
+};
+const pushCheckout = async (cwd) => {
+  const [status, hasOrigin] = await Promise.all([
+    readCheckoutStatus(cwd),
+    hasOriginRemote(cwd)
+  ]);
+  const refusal = pushRefusal(status, hasOrigin);
+  if (refusal !== null) throw new Error(refusal);
+  await git(
+    cwd,
+    status.upstream === null && status.branch !== null ? ["push", "--quiet", "--set-upstream", "origin", status.branch] : ["push", "--quiet"],
+    { network: true }
+  );
+};
+
+const zeroSha = /^0+$/;
+const parseWorktreeList = (output) => output.split(/\n{2,}/).map((block) => block.split("\n").filter((line) => line !== "")).filter((lines) => lines[0]?.startsWith("worktree ") === true).map((lines) => {
+  const value = (key) => {
+    const line = lines.find(
+      (candidate) => candidate === key || candidate.startsWith(`${key} `)
+    );
+    return line === void 0 ? null : line.slice(key.length + 1);
+  };
+  const head = value("HEAD");
+  const branch = value("branch");
+  return {
+    path: value("worktree") ?? "",
+    branch: branch === null ? null : branch.replace(/^refs\/heads\//, ""),
+    headSha: head === null || zeroSha.test(head) ? null : head,
+    bare: value("bare") !== null,
+    lock: value("locked"),
+    prunable: value("prunable") !== null
+  };
+});
+const readWorktrees = async (cwd) => {
+  const listed = parseWorktreeList(
+    await git(cwd, ["worktree", "list", "--porcelain"])
+  );
+  return Promise.all(
+    listed.map((worktree, index) => ({ ...worktree, main: index === 0 })).filter(({ bare }) => !bare).map(async ({ bare: _bare, ...worktree }) => ({
+      ...worktree,
+      status: worktree.prunable ? null : await readCheckoutStatus(worktree.path).catch(() => null)
+    }))
+  );
+};
+const fieldSeparator = "\0";
+const branchFormat = [
+  "%(refname:lstrip=2)",
+  "%(objectname)",
+  "%(upstream:short)",
+  "%(upstream:track)",
+  "%(committerdate:iso-strict)",
+  "%(worktreepath)",
+  "%(subject)"
+].join("%00");
+const parseTrack = (track, hasUpstream) => {
+  if (!hasUpstream) return { ahead: null, behind: null, gone: false };
+  if (track === "[gone]") return { ahead: null, behind: null, gone: true };
+  const count = (word) => Number(new RegExp(`${word} (\\d+)`).exec(track)?.[1] ?? 0);
+  return { ahead: count("ahead"), behind: count("behind"), gone: false };
+};
+const readMergedBranches = async (cwd, start) => {
+  if (start === null) return /* @__PURE__ */ new Set();
+  const listed = await git(cwd, [
+    "for-each-ref",
+    `--merged=${start.base.sha}`,
+    "--format=%(refname:lstrip=2)",
+    "refs/heads"
+  ]);
+  return new Set(
+    listed.split("\n").filter((name) => name !== "" && name !== start.base.name)
+  );
+};
+const readBase = async (cwd, baseName) => {
+  const name = baseName ?? await readDefaultBranch(cwd) ?? "main";
+  return resolveDiffBase(cwd, name).catch(() => null);
+};
+const readBranches = async ({
+  cwd,
+  baseName
+}) => {
+  const start = await readBase(cwd, baseName);
+  const [listing, merged, worktrees] = await Promise.all([
+    gitOrNull(cwd, [
+      "for-each-ref",
+      "--sort=-committerdate",
+      `--format=${branchFormat}`,
+      "refs/heads"
+    ]),
+    readMergedBranches(cwd, start),
+    readWorktrees(cwd)
+  ]);
+  const branches = (listing ?? "").split("\n").filter((line) => line !== "").map((line) => {
+    const [
+      name = "",
+      sha = "",
+      upstream = "",
+      track = "",
+      committedAt = "",
+      worktreePath = "",
+      subject = ""
+    ] = line.split(fieldSeparator);
+    const { ahead, behind, gone } = parseTrack(track, upstream !== "");
+    return {
+      name,
+      sha,
+      upstream: upstream === "" ? null : upstream,
+      ahead,
+      behind,
+      upstreamGone: gone,
+      merged: merged.has(name),
+      worktreePath: worktreePath === "" ? null : worktreePath,
+      lastCommit: {
+        subject,
+        committedAt: new Date(committedAt).toISOString()
+      }
+    };
+  });
+  return { base: start?.base ?? null, worktrees, branches };
+};
+
+const fileCount = (count, kind) => count === 0 ? null : `${String(count)} ${kind} file${count === 1 ? "" : "s"}`;
+const mainWorktreeRefusal = "This is the main checkout, which holds the repository: it is never removed.";
+const dirtyRefusal = ({
+  modified,
+  untracked
+}) => {
+  const parts = [
+    fileCount(modified, "modified"),
+    fileCount(untracked, "untracked")
+  ].filter((part) => part !== null);
+  if (parts.length === 0) return null;
+  return `${parts.join(" and ")}: git would refuse to remove this worktree. Commit or discard them first.`;
+};
+const unpushedRefusal = (count) => {
+  if (count === 0) return null;
+  const subject = count === 1 ? "1 commit exists" : `${String(count)} commits exist`;
+  return `${subject} only in this clone, on no remote branch and in no pull request. Push them first.`;
+};
+const lockRefusal = (lock) => {
+  if (lock === null) return null;
+  const reason = lock === "" ? "" : ` (${lock})`;
+  return `git holds this worktree locked${reason}, usually by a Claude Code process still running in it. Exit it first.`;
+};
+const processesRefusal = (count) => {
+  if (count === null || count === 0) return null;
+  const subject = count === 1 ? "1 process runs" : `${String(count)} processes run`;
+  return `${subject} inside this worktree (a shell, an editor or an agent): removing it would pull the directory out from under them. Exit them first.`;
+};
+const worktreeRemovalRefusals = (status) => {
+  if (status.main) return [mainWorktreeRefusal];
+  return [
+    dirtyRefusal(status),
+    unpushedRefusal(status.unpushedCommits),
+    lockRefusal(status.lock),
+    processesRefusal(status.processesInside)
+  ].filter((refusal) => refusal !== null);
+};
+const worktreeRemovalRefusal = (status) => worktreeRemovalRefusals(status)[0] ?? null;
+
+const execFileAsync = promisify(execFile);
+const realpathOrSelf = (path) => {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+};
+const isInsideDirectory = (directory, path) => {
+  const relativePath = relative(directory, path);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+};
+const readGitDirectory = async (worktree, flag) => {
+  const directory = await git(worktree, [
+    "rev-parse",
+    "--path-format=absolute",
+    flag
+  ]);
+  return realpathOrSelf(directory.trim());
+};
+const readBranch = async (worktree) => {
+  const branch = await gitOrNull(worktree, [
+    "rev-parse",
+    "--abbrev-ref",
+    "HEAD"
+  ]);
+  const name = branch?.trim() ?? "";
+  return name === "" || name === "HEAD" ? null : name;
+};
+const countChanges = async (worktree) => {
+  const porcelain = await git(worktree, ["status", "--porcelain"]);
+  const lines = porcelain.split("\n").filter((line) => line.trim() !== "");
+  const untracked = lines.filter((line) => line.startsWith("??")).length;
+  return { modified: lines.length - untracked, untracked };
+};
+const hasCommit$1 = async (worktree, sha) => await gitOrNull(worktree, ["cat-file", "-e", `${sha}^{commit}`]) !== null;
+const countUnpushedCommits = async (worktree, keptShas) => {
+  const present = await Promise.all(
+    keptShas.filter((sha) => /^[\da-f]{7,64}$/i.test(sha)).map(async (sha) => await hasCommit$1(worktree, sha) ? sha : null)
+  );
+  const count = await gitOrNull(worktree, [
+    "rev-list",
+    "--count",
+    "HEAD",
+    "--not",
+    "--remotes",
+    ...present.filter((sha) => sha !== null)
+  ]);
+  return count === null ? 0 : Number(count.trim());
+};
+const readLock = async (worktree) => {
+  const listed = parseWorktreeList(
+    await git(worktree, ["worktree", "list", "--porcelain"])
+  );
+  const own = listed.find(
+    ({ path }) => realpathOrSelf(path) === realpathOrSelf(worktree)
+  );
+  return own?.lock ?? null;
+};
+const countProcessesInside = async (directory) => {
+  const stdout = await execFileAsync("lsof", ["-n", "-d", "cwd", "-F", "pn"], {
+    timeout: 1e4,
+    maxBuffer: 16 * 1024 * 1024
+  }).then(
+    ({ stdout: answer }) => answer,
+    (error) => {
+      if (typeof error === "object" && error !== null && "stdout" in error && typeof error.stdout === "string" && error.stdout !== "") {
+        return error.stdout;
+      }
+      return null;
+    }
+  );
+  if (stdout === null) return null;
+  const root = realpathOrSelf(directory);
+  const inside = /* @__PURE__ */ new Set();
+  let processId = "";
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("p")) processId = line.slice(1);
+    else if (line.startsWith("n") && processId !== String(pid) && isInsideDirectory(root, line.slice(1))) {
+      inside.add(processId);
+    }
+  }
+  return inside.size;
+};
+const ignoredPrefix = "!! ";
+const listFiles = async (worktree, relativeDirectory) => {
+  const entries = await readdir(join(worktree, relativeDirectory), {
+    recursive: true,
+    withFileTypes: true
+  }).catch(() => []);
+  return entries.filter((entry) => entry.isFile()).map((entry) => relative(worktree, join(entry.parentPath, entry.name))).toSorted();
+};
+const listLocalOnlyIgnored = async (worktree, mainCheckout) => {
+  const porcelain = await git(worktree, [
+    "status",
+    "--porcelain",
+    "--ignored",
+    "-z"
+  ]);
+  const ignored = porcelain.split("\0").filter((entry) => entry.startsWith(ignoredPrefix)).map((entry) => entry.slice(ignoredPrefix.length));
+  const localOnly = await Promise.all(
+    ignored.map(async (relativePath) => {
+      const entry = await lstat(join(worktree, relativePath)).catch(() => null);
+      if (entry === null || entry.isSymbolicLink()) return [];
+      if (existsSync(join(mainCheckout, relativePath))) return [];
+      return entry.isDirectory() ? listFiles(worktree, relativePath) : [relativePath];
+    })
+  );
+  return localOnly.flat();
+};
+const readWorktreeRemovalStatus = async ({
+  worktree,
+  keptShas = []
+}) => {
+  const [gitDirectory, commonDirectory] = await Promise.all([
+    readGitDirectory(worktree, "--git-dir"),
+    readGitDirectory(worktree, "--git-common-dir")
+  ]);
+  const [branch, changes, unpushedCommits, lock, ignored] = await Promise.all([
+    readBranch(worktree),
+    countChanges(worktree),
+    countUnpushedCommits(worktree, keptShas),
+    readLock(worktree),
+    listLocalOnlyIgnored(worktree, dirname(commonDirectory))
+  ]);
+  const processesInside = await countProcessesInside(worktree);
+  return {
+    path: worktree,
+    main: gitDirectory === commonDirectory,
+    branch,
+    ...changes,
+    unpushedCommits,
+    lock,
+    processesInside,
+    localOnlyIgnored: ignored
+  };
+};
+const prepareWorktreeRemoval = async ({
+  deleteBranch,
+  ...params
+}) => {
+  const status = await readWorktreeRemovalStatus(params);
+  const refusal = worktreeRemovalRefusal(status);
+  if (refusal !== null) throw new Error(refusal);
+  return {
+    path: status.path,
+    commonDirectory: await readGitDirectory(
+      params.worktree,
+      "--git-common-dir"
+    ),
+    branch: deleteBranch ? status.branch : null
+  };
+};
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+const completeWorktreeRemoval = async ({
+  path,
+  commonDirectory,
+  branch
+}) => {
+  await git(commonDirectory, ["worktree", "remove", path], {
+    uninterruptible: true
+  });
+  if (branch === null) return { path, branch, branchError: null };
+  try {
+    await git(commonDirectory, ["branch", "-d", branch]);
+    return { path, branch, branchError: null };
+  } catch (error) {
+    return { path, branch, branchError: messageOf(error) };
+  }
 };
 
 const cEscapes = {
@@ -782,7 +1497,7 @@ const orderPackages = (names, dependsOn) => {
   const isDependedOnByRemaining = (name) => [...remaining].some(
     (other) => other !== name && dependencies.get(other).has(name)
   );
-  const ordered = names.includes("") ? [""] : [];
+  const ordered = [];
   while (remaining.size > 0) {
     const sorted = [...remaining].toSorted(
       (left, right) => left.localeCompare(right)
@@ -791,6 +1506,7 @@ const orderPackages = (names, dependsOn) => {
     ordered.push(next);
     remaining.delete(next);
   }
+  if (names.includes("")) ordered.push("");
   return ordered;
 };
 const orderForReading = ({
@@ -1788,5 +2504,5 @@ const readImpacts = async ({
   };
 };
 
-export { createBindingsCache, defaultDiffLimits, git, gitFailedCode, gitOrNull, groupDiffPaths, maxTypescriptFiles, noPackages, packagesAtTree, packagesOnDisk, parseNumstat, readBranchDiff, readFileAtSha, readImpacts, readPullRequestDiff, readReadingOrder, reasonLine };
+export { completeWorktreeRemoval, countProcessesInside, createBindingsCache, defaultDiffLimits, defaultRecentCommits, git, gitFailedCode, gitOrNull, groupDiffPaths, maxTypescriptFiles, noPackages, packagesAtTree, packagesOnDisk, parseNumstat, parseStatusV2, parseTrack, parseWorktreeList, prepareWorktreeRemoval, pullCheckout, pushCheckout, readBranchDiff, readBranches, readCheckoutBranchDiff, readCheckoutStatus, readCheckoutSync, readCommitDiff, readDefaultBranch, readFileAtSha, readHeadBranch, readHeadSha, readImpacts, readPullRequestDiff, readReadingOrder, readRecentCommits, readWorktreeRemovalStatus, readWorktrees, reasonLine, resolveDiffBase };
 //# sourceMappingURL=git-node.mjs.map