@monotykamary/localterm-server 2.0.5 → 2.1.1

package/dist/git-diff.js

@@ -2,10 +2,9 @@ import fs from "node:fs";
 import fsPromises from "node:fs/promises";
 import path from "node:path";
 import { Octokit } from "@octokit/rest";
-import { openRepository } from "es-git";
-import { memoBy } from "./utils/memo-by.js";
-import { computePatchFromContents } from "./utils/compute-patch.js";
+import { runGit } from "./utils/run-git.js";
 import { resolveGithubToken } from "./utils/resolve-github-token.js";
+import { memoBy } from "./utils/memo-by.js";
 import { GIT_BINARY_SNIFF_BYTES, GIT_CACHE_TTL_MS, GIT_EMPTY_TREE_HASH, GIT_MAX_BRANCHES, GIT_MAX_PATCH_BYTES_PER_FILE, GIT_MAX_TOTAL_PATCH_BYTES, GIT_MAX_UNTRACKED_FILE_BYTES, GIT_MAX_UNTRACKED_FILES, } from "./constants.js";
 const WORKING_OPTIONS = { mode: "working" };
 const EMPTY_SUMMARY = {
@@ -16,7 +15,6 @@ const EMPTY_SUMMARY = {
     binaries: 0,
     branch: null,
 };
-const ZERO_OID = "0000000000000000000000000000000000000000";
 // Nested so a cwd can hold more than one comparison (the working-tree summary
 // is pushed on git-dirty while the viewer may be open in branch mode).
 const diffCacheByCwd = new Map();
@@ -47,128 +45,73 @@ const writeDiffCache = (cwd, mode, base, cache) => {
 export const invalidateGitDiffCache = (cwd) => {
     diffCacheByCwd.delete(cwd);
 };
-const collectIterator = (iterable) => {
-    const result = [];
-    for (const item of iterable)
-        result.push(item);
-    return result;
-};
-const deltaTypeToStatus = (delta) => {
-    switch (delta) {
-        case "Added":
-            return "added";
-        case "Deleted":
-            return "deleted";
-        case "Renamed":
-            return "renamed";
-        case "Copied":
-            return "added";
-        case "Untracked":
-            return "untracked";
-        case "Modified":
-        case "Typechange":
-        default:
-            return "modified";
-    }
+const runGitText = async (cwd, args) => {
+    const result = await runGit(cwd, args);
+    return result.stdout.toString("utf8");
 };
-const openRepo = async (cwd) => {
-    try {
-        const repo = await openRepository(cwd);
-        return { cwd, repo };
-    }
-    catch {
-        return null;
-    }
+// `git diff` flags shared by every diff invocation so numstat, name-status and
+// patch all walk the same diff queue (same rename detection, same file order).
+const DIFF_RENAME_FLAG = "--find-renames";
+const isGitRepo = async (cwd) => {
+    const result = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+    return result.exitCode === 0;
 };
-const getCurrentBranch = (r) => {
-    try {
-        const head = r.repo.head();
-        const shorthand = head.shorthand();
-        return shorthand && shorthand !== "HEAD" ? shorthand : null;
-    }
-    catch {
+const getCurrentBranch = async (cwd) => {
+    const result = await runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (result.exitCode !== 0)
         return null;
-    }
-};
-const resolveDiffBaseRef = (r) => {
-    try {
-        r.repo.head();
-        return "HEAD";
-    }
-    catch {
-        return GIT_EMPTY_TREE_HASH;
-    }
-};
-const resolveDefaultBase = (r) => {
-    const currentBranch = getCurrentBranch(r);
-    try {
-        const remoteHead = r.repo.getReference("refs/remotes/origin/HEAD");
-        const symTarget = remoteHead.symbolicTarget();
-        if (symTarget) {
-            const shortName = symTarget.replace("refs/remotes/", "");
-            if (shortName !== currentBranch) {
-                try {
-                    r.repo.revparseSingle(shortName);
-                    return { ref: shortName, source: "remoteHead" };
-                }
-                catch {
-                    // stale origin/HEAD
-                }
+    const name = result.stdout.toString("utf8").trim();
+    return name === "HEAD" ? null : name;
+};
+// working mode compares against HEAD (or the empty tree when the branch is
+// unborn). branch mode compares against the merge-base of HEAD and the base
+// ref, so only changes since the branches diverged are shown.
+const resolveDiffBaseRef = async (cwd) => {
+    const result = await runGit(cwd, ["rev-parse", "--verify", "-q", "HEAD"]);
+    return result.exitCode === 0 ? "HEAD" : GIT_EMPTY_TREE_HASH;
+};
+const verifyRef = async (cwd, ref) => {
+    const result = await runGit(cwd, ["rev-parse", "--verify", "-q", ref]);
+    return result.exitCode === 0;
+};
+const resolveDefaultBase = async (cwd) => {
+    const currentBranch = await getCurrentBranch(cwd);
+    const symbolic = await runGit(cwd, ["symbolic-ref", "-q", "refs/remotes/origin/HEAD"]);
+    if (symbolic.exitCode === 0) {
+        const target = symbolic.stdout.toString("utf8").trim();
+        if (target.startsWith("refs/remotes/")) {
+            const shortName = target.slice("refs/remotes/".length);
+            if (shortName !== currentBranch && (await verifyRef(cwd, shortName))) {
+                return { ref: shortName, source: "remoteHead" };
             }
         }
     }
-    catch {
-        // No origin/HEAD configured
-    }
     for (const name of ["main", "master", "develop"]) {
         if (name === currentBranch)
             continue;
         for (const candidate of [`origin/${name}`, name]) {
-            try {
-                r.repo.revparseSingle(candidate);
+            if (await verifyRef(cwd, candidate))
                 return { ref: candidate, source: "fallback" };
-            }
-            catch {
-                continue;
-            }
         }
     }
     return null;
 };
-const resolveEffectiveBaseRef = (r, options) => {
+const resolveEffectiveBaseRef = async (cwd, options) => {
     if (options.mode !== "branch")
-        return resolveDiffBaseRef(r);
+        return resolveDiffBaseRef(cwd);
     let baseRef = options.base?.trim() || null;
-    if (baseRef) {
-        try {
-            r.repo.revparseSingle(baseRef);
-        }
-        catch {
-            baseRef = null;
-        }
-    }
-    if (!baseRef) {
-        const resolved = resolveDefaultBase(r);
-        baseRef = resolved?.ref ?? null;
-    }
+    if (baseRef && !(await verifyRef(cwd, baseRef)))
+        baseRef = null;
+    if (!baseRef)
+        baseRef = (await resolveDefaultBase(cwd))?.ref ?? null;
     if (!baseRef)
         return null;
-    try {
-        const baseOid = r.repo.revparseSingle(baseRef);
-        const headOid = r.repo.revparseSingle("HEAD");
-        const mergeBase = r.repo.getMergeBase(baseOid, headOid);
-        if (mergeBase)
-            return mergeBase;
-    }
-    catch {
-        // Unrelated histories
-    }
-    try {
-        return r.repo.revparseSingle(baseRef);
-    }
-    catch {
+    const mergeBase = await runGit(cwd, ["merge-base", baseRef, "HEAD"]);
+    if (mergeBase.exitCode === 0)
+        return mergeBase.stdout.toString("utf8").trim();
+    if (!(await verifyRef(cwd, baseRef)))
         return null;
-    }
+    return runGitText(cwd, ["rev-parse", "--verify", baseRef]);
 };
 const countLines = (text) => {
     if (text.length === 0)
@@ -182,42 +125,45 @@ const countLines = (text) => {
         count += 1;
     return count;
 };
-const collectUntrackedFiles = async (r) => {
-    const files = [];
-    const statuses = r.repo.statuses();
-    const entries = collectIterator(statuses.iter());
-    for (const entry of entries) {
-        const s = entry.status();
-        if (!s.wtNew || s.ignored)
-            continue;
-        if (files.length >= GIT_MAX_UNTRACKED_FILES)
-            break;
-        const filePath = entry.path();
-        const absolutePath = path.join(r.cwd, filePath);
+const readUntrackedFile = async (cwd, filePath) => {
+    const absolutePath = path.join(cwd, filePath);
+    try {
+        const stat = await fsPromises.stat(absolutePath);
+        if (!stat.isFile())
+            return null;
+        const bytesToRead = Math.min(stat.size, GIT_MAX_UNTRACKED_FILE_BYTES);
+        const buffer = Buffer.alloc(bytesToRead);
+        const handle = await fsPromises.open(absolutePath, "r");
         try {
-            const stat = await fsPromises.stat(absolutePath);
-            if (!stat.isFile())
-                continue;
-            const bytesToRead = Math.min(stat.size, GIT_MAX_UNTRACKED_FILE_BYTES);
-            const buffer = Buffer.alloc(bytesToRead);
-            const handle = await fsPromises.open(absolutePath, "r");
-            try {
-                const { buffer: readBuffer } = await handle.read(buffer, 0, bytesToRead, 0);
-                const sniffEnd = Math.min(readBuffer.length, GIT_BINARY_SNIFF_BYTES);
-                const binary = readBuffer.subarray(0, sniffEnd).includes(0);
-                const truncated = stat.size > GIT_MAX_UNTRACKED_FILE_BYTES;
-                const content = binary ? null : truncated ? null : readBuffer.toString("utf8");
-                const lines = binary ? 0 : content ? countLines(content) : 0;
-                files.push({ path: filePath, binary, lines, content, truncated });
-            }
-            finally {
-                await handle.close();
-            }
+            const { buffer: readBuffer } = await handle.read(buffer, 0, bytesToRead, 0);
+            const sniffEnd = Math.min(readBuffer.length, GIT_BINARY_SNIFF_BYTES);
+            const binary = readBuffer.subarray(0, sniffEnd).includes(0);
+            const truncated = stat.size > GIT_MAX_UNTRACKED_FILE_BYTES;
+            const content = binary ? null : truncated ? null : readBuffer.toString("utf8");
+            const lines = binary ? 0 : content ? countLines(content) : 0;
+            return { path: filePath, binary, lines, content, truncated };
         }
-        catch {
-            continue;
+        finally {
+            await handle.close();
         }
     }
+    catch {
+        return null;
+    }
+};
+const collectUntrackedFiles = async (cwd) => {
+    const result = await runGit(cwd, ["ls-files", "--others", "--exclude-standard", "-z"]);
+    if (result.exitCode !== 0)
+        return [];
+    const paths = result.stdout.toString("utf8").split("\0").filter(Boolean);
+    const files = [];
+    for (const filePath of paths) {
+        if (files.length >= GIT_MAX_UNTRACKED_FILES)
+            break;
+        const file = await readUntrackedFile(cwd, filePath);
+        if (file)
+            files.push(file);
+    }
     return files;
 };
 export const buildUntrackedPatch = (content) => {
@@ -231,138 +177,216 @@ export const buildUntrackedPatch = (content) => {
     const noNewlineMarker = hasTrailingNewline ? "" : "\n\";
     return `@@ -0,0 +1,${lines.length} @@\n${body}${noNewlineMarker}\n`;
 };
-const readBlobContent = (r, oid) => {
-    if (oid === ZERO_OID)
-        return null;
-    try {
-        const obj = r.repo.findObject(oid);
-        if (!obj)
-            return null;
-        const blob = obj.peelToBlob();
-        return Buffer.from(blob.content()).toString("utf8");
-    }
-    catch {
-        return null;
-    }
-};
-const readWorkingTreeFile = (r, filePath, maxBytes = GIT_MAX_UNTRACKED_FILE_BYTES) => {
-    const absolutePath = path.join(r.cwd, filePath);
-    try {
-        const stat = fs.statSync(absolutePath);
-        if (!stat.isFile())
-            return null;
-        const bytesToRead = Math.min(stat.size, maxBytes);
-        const buffer = Buffer.alloc(bytesToRead);
-        const handle = fs.openSync(absolutePath, "r");
-        fs.readSync(handle, buffer, 0, bytesToRead, 0);
-        fs.closeSync(handle);
-        const sniffEnd = Math.min(buffer.length, GIT_BINARY_SNIFF_BYTES);
-        if (buffer.subarray(0, sniffEnd).includes(0))
-            return null;
-        if (stat.size > maxBytes)
-            return null;
-        return buffer.toString("utf8");
-    }
-    catch {
-        return null;
-    }
-};
-const collectDeltaInfos = (diff) => {
-    const deltas = collectIterator(diff.deltas());
-    const result = [];
-    for (const delta of deltas) {
-        const status = deltaTypeToStatus(delta.status());
-        if (status === "untracked")
+export const splitPatchByFile = (raw) => raw.split(/^(?=diff --git )/m).filter((chunk) => chunk.startsWith("diff --git "));
+export const parseNumstatZ = (raw) => {
+    const tokens = raw.split("\0");
+    const entries = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (!token)
             continue;
-        const newFile = delta.newFile();
-        const oldFile = delta.oldFile();
-        result.push({
-            path: newFile.path(),
-            oldPath: status === "renamed" ? oldFile.path() : null,
-            status,
-            binary: newFile.isBinary(),
-            oldId: oldFile.id(),
-            newId: newFile.id(),
-        });
+        const match = /^(\d+|-)\t(\d+|-)\t(.*)$/s.exec(token);
+        if (!match)
+            continue;
+        const binary = match[1] === "-" || match[2] === "-";
+        const additions = binary ? 0 : Number.parseInt(match[1], 10);
+        const deletions = binary ? 0 : Number.parseInt(match[2], 10);
+        if (match[3]) {
+            entries.push({ path: match[3], oldPath: null, additions, deletions, binary });
+            continue;
+        }
+        const oldPath = tokens[index + 1];
+        const newPath = tokens[index + 2];
+        index += 2;
+        if (!oldPath || !newPath)
+            continue;
+        entries.push({ path: newPath, oldPath, additions, deletions, binary });
     }
-    return result;
+    return entries;
 };
-const buildDeltaPatch = (r, delta) => {
-    if (delta.binary)
-        return { patchText: null, additions: 0, deletions: 0 };
-    // All diff passes use diffTreeToWorkdirWithIndex, so the new side is the
-    // working tree — read it straight from disk rather than the delta's blob id
-    // (which points at the index/HEAD blob for unstaged edits and would read as
-    // unchanged vs the old side → zero counts). The old side is the base tree's
-    // blob.
-    const oldContent = delta.status === "added" ? null : readBlobContent(r, delta.oldId);
-    const newContent = delta.status === "deleted"
-        ? null
-        : readWorkingTreeFile(r, delta.path, GIT_MAX_TOTAL_PATCH_BYTES);
-    const aPath = delta.oldPath ?? delta.path;
-    try {
-        const patchResult = computePatchFromContents(oldContent, newContent, aPath, delta.path, null, null, delta.oldId === ZERO_OID ? null : delta.oldId, delta.newId === ZERO_OID ? null : delta.newId, delta.status === "renamed");
-        return {
-            patchText: patchResult.patchText || null,
-            additions: patchResult.additions,
-            deletions: patchResult.deletions,
-        };
-    }
-    catch {
-        return { patchText: null, additions: 0, deletions: 0 };
+export const parseNameStatusZ = (raw) => {
+    const tokens = raw.split("\0");
+    const statuses = new Map();
+    for (let index = 0; index < tokens.length; index += 1) {
+        const statusToken = tokens[index];
+        if (!statusToken)
+            continue;
+        const letter = statusToken[0];
+        if (letter === "R" || letter === "C") {
+            const newPath = tokens[index + 2];
+            index += 2;
+            if (!newPath)
+                continue;
+            statuses.set(newPath, letter === "R" ? "renamed" : "added");
+            continue;
+        }
+        const filePath = tokens[index + 1];
+        index += 1;
+        if (!filePath)
+            continue;
+        if (letter === "A")
+            statuses.set(filePath, "added");
+        else if (letter === "D")
+            statuses.set(filePath, "deleted");
+        else
+            statuses.set(filePath, "modified");
     }
+    return statuses;
 };
-const buildBaseTree = (r, baseRef) => {
-    try {
-        return r.repo.getTree(baseRef);
-    }
-    catch {
-        try {
-            const baseOid = r.repo.revparseSingle(baseRef);
-            const obj = r.repo.findObject(baseOid);
-            if (!obj)
-                return null;
-            if (obj.type() === "Tree") {
-                return obj;
+// Undo git's C-style path quoting (paths with spaces/special chars get wrapped
+// in "..." with \-escapes; core.quotepath=false leaves only those, not non-ASCII).
+const unquoteGitPath = (raw) => {
+    if (raw.length < 2 || raw[0] !== '"' || raw[raw.length - 1] !== '"')
+        return raw;
+    let out = "";
+    let index = 1;
+    const end = raw.length - 1;
+    while (index < end) {
+        const char = raw[index];
+        if (char === "\\" && index + 1 < end) {
+            const next = raw[index + 1];
+            if (next === "n") {
+                out += "\n";
+                index += 2;
+            }
+            else if (next === "t") {
+                out += "\t";
+                index += 2;
+            }
+            else if (next === '"') {
+                out += '"';
+                index += 2;
+            }
+            else if (next === "\\") {
+                out += "\\";
+                index += 2;
+            }
+            else if (next >= "0" && next <= "7" && index + 3 < end) {
+                out += String.fromCharCode(Number.parseInt(raw.slice(index + 1, index + 4), 8));
+                index += 4;
+            }
+            else {
+                out += char;
+                index += 1;
             }
-            const commit = r.repo.getCommit(baseOid);
-            return commit.tree();
         }
-        catch {
-            return null;
+        else {
+            out += char;
+            index += 1;
         }
     }
+    return out;
 };
-// One full diff pass for `(cwd)` against `baseRef`: walks the tree diff, runs
-// rename detection, then builds per-file metadata + patch text in a single
-// loop (one jsdiff per file, used for both counts and patch — the old code
-// ran jsdiff twice per file). Untracked files are folded in from the working
-// tree with synthesized patches. Yields to the event loop between batches so a
-// large branch diff never blocks the WS terminal during this one pass.
-const buildDiffCache = async (r, baseRef) => {
-    const baseTree = buildBaseTree(r, baseRef);
-    if (!baseTree)
+// Strip the `+++ ` / `--- ` prefix and the `b/` / `a/` namespace, unquoting if
+// git wrapped the path. `/dev/null` (a deletion's +++ side) yields null so the
+// caller can fall back to the --- side.
+const pathFromLine = (line, prefix) => {
+    if (!line.startsWith(prefix))
         return null;
-    let diff;
-    try {
-        diff = r.repo.diffTreeToWorkdirWithIndex(baseTree);
-    }
-    catch {
+    let rest = line.slice(prefix.length);
+    if (rest === "/dev/null")
         return null;
+    rest = unquoteGitPath(rest);
+    // git appends a literal tab after an unquoted path in ---/+++ lines when the
+    // path contains a space, to keep it from running into hunk content; the
+    // closing quote already disambiguates quoted paths, so this only affects
+    // the unquoted branch. Numstat/name-status never carry that tab, so strip it
+    // or the path keys won't line up.
+    if (rest.endsWith("\t"))
+        rest = rest.slice(0, -1);
+    if (rest.startsWith("b/"))
+        return rest.slice(2);
+    if (rest.startsWith("a/"))
+        return rest.slice(2);
+    return rest;
+};
+// Pull the new-side path out of one `diff --git` chunk: prefer `+++ b/<path>`
+// (added/modified/rename target), fall back to `--- a/<path>` for deletions
+// (whose +++ is /dev/null), then to `rename to <path>` for a pure rename with
+// no content change (which has no ---/+++ lines at all).
+const extractPatchPath = (chunk) => {
+    const lines = chunk.split("\n");
+    for (const line of lines) {
+        if (line.startsWith("+++ ")) {
+            const fromNew = pathFromLine(line, "+++ ");
+            if (fromNew !== null)
+                return fromNew;
+            for (const fallback of lines) {
+                if (fallback.startsWith("--- ")) {
+                    const fromOld = pathFromLine(fallback, "--- ");
+                    if (fromOld !== null)
+                        return fromOld;
+                }
+            }
+            return null;
+        }
     }
-    try {
-        diff.findSimilar({ renames: true });
+    for (const line of lines) {
+        if (line.startsWith("rename to "))
+            return unquoteGitPath(line.slice("rename to ".length));
     }
-    catch {
-        // Rename detection failed
+    return null;
+};
+// Index `git diff --patch` output by path. A single path can map to several
+// `diff --git` blocks (a symlink re-added as a regular file emits a deletion +
+// an addition for one path), so those are concatenated back into one patch.
+const indexPatchesByPath = (raw) => {
+    const chunksByPath = new Map();
+    for (const chunk of splitPatchByFile(raw)) {
+        const patchPath = extractPatchPath(chunk);
+        if (patchPath === null)
+            continue;
+        let chunks = chunksByPath.get(patchPath);
+        if (!chunks) {
+            chunks = [];
+            chunksByPath.set(patchPath, chunks);
+        }
+        chunks.push(chunk);
+    }
+    const result = new Map();
+    for (const [patchPath, chunks] of chunksByPath) {
+        result.set(patchPath, chunks.join(""));
     }
-    // Prime libgit2's lazy per-delta binary flag: DiffFile.isBinary() returns
-    // false until the diff's stats have been materialized, which loads content
-    // and sniffs for NUL bytes. Without this, binary files read as text and get
-    // a junk patch synthesized from utf8-decoded blob bytes.
-    void diff.stats();
-    const deltaInfos = collectDeltaInfos(diff);
-    const untracked = await collectUntrackedFiles(r);
+    return result;
+};
+// One full diff pass for `(cwd)` against `baseRef`. Three parallel `git diff`
+// invocations (numstat for counts+binary, name-status for the status letter +
+// rename old path, patch for the body) walk the same diff queue. numstat and
+// name-status are NUL-delimited and unambiguous; they're the source of truth
+// for the file list. The patch output is keyed by path rather than paired
+// positionally, because a single numstat entry can span several `diff --git`
+// blocks (a symlink is deleted as mode 120000 and re-added as a regular file:
+// git emits that as a deletion + an addition sharing one path, so there's no
+// 1:1 with numstat entries). Untracked files are folded in from `ls-files`
+// with synthesized patches (git's own diff never lists untracked files).
+const buildDiffCache = async (cwd, baseRef) => {
+    const [numstatRes, nameStatusRes, patchRes] = await Promise.all([
+        runGit(cwd, [
+            "-c",
+            "core.quotepath=false",
+            "diff",
+            DIFF_RENAME_FLAG,
+            "--numstat",
+            "-z",
+            baseRef,
+        ]),
+        runGit(cwd, [
+            "-c",
+            "core.quotepath=false",
+            "diff",
+            DIFF_RENAME_FLAG,
+            "--name-status",
+            "-z",
+            baseRef,
+        ]),
+        runGit(cwd, ["-c", "core.quotepath=false", "diff", DIFF_RENAME_FLAG, "--patch", baseRef]),
+    ]);
+    if (numstatRes.exitCode !== 0 || patchRes.exitCode !== 0)
+        return null;
+    const numstat = parseNumstatZ(numstatRes.stdout.toString("utf8"));
+    const statuses = parseNameStatusZ(nameStatusRes.stdout.toString("utf8"));
+    const patchesByPath = indexPatchesByPath(patchRes.stdout.toString("utf8"));
+    const untracked = await collectUntrackedFiles(cwd);
     const fileMeta = [];
     const filePatchByPath = new Map();
     const fileBinaryByPath = new Map();
@@ -371,52 +395,40 @@ const buildDiffCache = async (r, baseRef) => {
     let additions = 0;
     let deletions = 0;
     let binaries = 0;
-    const YIELD_EVERY = 200;
-    for (let index = 0; index < deltaInfos.length; index += 1) {
-        if (index > 0 && index % YIELD_EVERY === 0)
-            await yieldToEventLoop();
-        const delta = deltaInfos[index];
+    for (let index = 0; index < numstat.length; index += 1) {
+        const entry = numstat[index];
+        const status = statuses.get(entry.path) ?? "modified";
+        const oldPath = status === "renamed" ? entry.oldPath : null;
         let patchText = null;
         let patchOmitted = false;
-        let fileAdditions;
-        let fileDeletions;
-        if (delta.binary) {
-            fileAdditions = 0;
-            fileDeletions = 0;
+        if (entry.binary) {
             binaries += 1;
         }
         else {
-            const patchResult = buildDeltaPatch(r, delta);
-            fileAdditions = patchResult.additions;
-            fileDeletions = patchResult.deletions;
-            patchText = patchResult.patchText;
-            if (patchText !== null) {
-                if (patchText.length > GIT_MAX_PATCH_BYTES_PER_FILE ||
-                    totalPatchBytes + patchText.length > GIT_MAX_TOTAL_PATCH_BYTES) {
-                    patchText = null;
-                    patchOmitted = true;
-                }
-                else {
-                    totalPatchBytes += patchText.length;
-                }
+            const rawPatch = patchesByPath.get(entry.path) ?? null;
+            if (rawPatch === null ||
+                rawPatch.length > GIT_MAX_PATCH_BYTES_PER_FILE ||
+                totalPatchBytes + rawPatch.length > GIT_MAX_TOTAL_PATCH_BYTES) {
+                patchOmitted = true;
             }
             else {
-                patchOmitted = true;
+                patchText = rawPatch;
+                totalPatchBytes += rawPatch.length;
             }
+            additions += entry.additions;
+            deletions += entry.deletions;
         }
-        additions += fileAdditions;
-        deletions += fileDeletions;
         fileMeta.push({
-            path: delta.path,
-            oldPath: delta.oldPath,
-            status: delta.status,
-            additions: fileAdditions,
-            deletions: fileDeletions,
-            binary: delta.binary,
+            path: entry.path,
+            oldPath,
+            status,
+            additions: entry.additions,
+            deletions: entry.deletions,
+            binary: entry.binary,
         });
-        filePatchByPath.set(delta.path, patchText);
-        fileBinaryByPath.set(delta.path, delta.binary);
-        filePatchOmittedByPath.set(delta.path, patchOmitted);
+        filePatchByPath.set(entry.path, patchText);
+        fileBinaryByPath.set(entry.path, entry.binary);
+        filePatchOmittedByPath.set(entry.path, patchOmitted);
     }
     for (const file of untracked) {
         const patch = file.binary
@@ -456,7 +468,7 @@ const buildDiffCache = async (r, baseRef) => {
         additions,
         deletions,
         binaries,
-        branch: getCurrentBranch(r),
+        branch: await getCurrentBranch(cwd),
     };
     return {
         summary,
@@ -467,129 +479,64 @@ const buildDiffCache = async (r, baseRef) => {
         builtAt: Date.now(),
     };
 };
-const yieldToEventLoop = () => new Promise((resolve) => {
-    setImmediate(resolve);
-});
-const ensureDiffCache = async (r, options) => {
-    // Read the cache before resolving the base ref — that resolution does
-    // libgit2 work (revparseSingle + getMergeBase) on every call, so for the
-    // per-file patch endpoint (where the cache is warm on nearly every
-    // request) checking first keeps it a pure map lookup.
-    const cached = readDiffCache(r.cwd, options.mode, options.base ?? null);
+const ensureDiffCache = async (cwd, options) => {
+    // Read the cache before resolving the base ref — that resolution does git work
+    // (rev-parse + merge-base) on every call, so for the per-file patch endpoint
+    // (where the cache is warm on nearly every request) checking first keeps it a
+    // pure map lookup with no subprocess.
+    const cached = readDiffCache(cwd, options.mode, options.base ?? null);
     if (cached)
         return cached;
-    const baseRef = resolveEffectiveBaseRef(r, options);
+    const baseRef = await resolveEffectiveBaseRef(cwd, options);
     if (baseRef === null)
         return null;
-    const cache = await buildDiffCache(r, baseRef);
+    const cache = await buildDiffCache(cwd, baseRef);
     if (cache)
-        writeDiffCache(r.cwd, options.mode, options.base ?? null, cache);
+        writeDiffCache(cwd, options.mode, options.base ?? null, cache);
     return cache;
 };
-export const splitPatchByFile = (raw) => raw.split(/^(?=diff --git )/m).filter((chunk) => chunk.startsWith("diff --git "));
-export const parseNumstatZ = (raw) => {
-    const tokens = raw.split("\0");
-    const entries = [];
-    for (let index = 0; index < tokens.length; index += 1) {
-        const token = tokens[index];
-        if (!token)
-            continue;
-        const match = /^(\d+|-)\t(\d+|-)\t(.*)$/s.exec(token);
-        if (!match)
-            continue;
-        const binary = match[1] === "-" || match[2] === "-";
-        const additions = binary ? 0 : Number.parseInt(match[1], 10);
-        const deletions = binary ? 0 : Number.parseInt(match[2], 10);
-        if (match[3]) {
-            entries.push({ path: match[3], oldPath: null, additions, deletions, binary });
-            continue;
-        }
-        const oldPath = tokens[index + 1];
-        const newPath = tokens[index + 2];
-        index += 2;
-        if (!oldPath || !newPath)
-            continue;
-        entries.push({ path: newPath, oldPath, additions, deletions, binary });
-    }
-    return entries;
-};
-export const parseNameStatusZ = (raw) => {
-    const tokens = raw.split("\0");
-    const statuses = new Map();
-    for (let index = 0; index < tokens.length; index += 1) {
-        const statusToken = tokens[index];
-        if (!statusToken)
-            continue;
-        const letter = statusToken[0];
-        if (letter === "R" || letter === "C") {
-            const newPath = tokens[index + 2];
-            index += 2;
-            if (!newPath)
-                continue;
-            statuses.set(newPath, letter === "R" ? "renamed" : "added");
-            continue;
-        }
-        const filePath = tokens[index + 1];
-        index += 1;
-        if (!filePath)
-            continue;
-        if (letter === "A")
-            statuses.set(filePath, "added");
-        else if (letter === "D")
-            statuses.set(filePath, "deleted");
-        else
-            statuses.set(filePath, "modified");
-    }
-    return statuses;
-};
 export const getGitDiffSummary = async (cwd, options = WORKING_OPTIONS) => {
-    const r = await openRepo(cwd);
-    if (!r)
-        return EMPTY_SUMMARY;
-    // Summary is pushed on every git-dirty signal (per-keystroke during edits),
-    // so it must stay cheap even when the full diff cache is cold. Read only the
-    // aggregate stats from the tree diff — no per-file jsdiff — unless a cache
-    // is already warm, in which case reuse its per-file summary.
-    const cached = readDiffCache(r.cwd, options.mode, options.base ?? null);
+    const cached = readDiffCache(cwd, options.mode, options.base ?? null);
     if (cached)
         return cached.summary;
+    if (!(await isGitRepo(cwd)))
+        return EMPTY_SUMMARY;
     try {
-        const baseRef = resolveEffectiveBaseRef(r, options);
+        const baseRef = await resolveEffectiveBaseRef(cwd, options);
         if (baseRef === null)
             return { ...EMPTY_SUMMARY, isRepo: true };
-        const branch = getCurrentBranch(r);
-        const baseTree = buildBaseTree(r, baseRef);
-        if (!baseTree)
+        const branch = await getCurrentBranch(cwd);
+        // Summary is pushed on every git-dirty signal, so it stays on the cheap
+        // numstat-only path (no patch) unless a cache is already warm.
+        const numstatRes = await runGit(cwd, [
+            "-c",
+            "core.quotepath=false",
+            "diff",
+            DIFF_RENAME_FLAG,
+            "--numstat",
+            "-z",
+            baseRef,
+        ]);
+        if (numstatRes.exitCode !== 0)
             return { ...EMPTY_SUMMARY, isRepo: true };
-        let diff;
-        try {
-            diff = r.repo.diffTreeToWorkdirWithIndex(baseTree);
-        }
-        catch {
-            return { ...EMPTY_SUMMARY, isRepo: true };
-        }
-        try {
-            diff.findSimilar({ renames: true });
-        }
-        catch {
-            // Rename detection failed
-        }
-        const stats = diff.stats();
-        let additions = Number(stats.insertions);
-        let deletions = Number(stats.deletions);
+        let additions = 0;
+        let deletions = 0;
         let binaries = 0;
-        let fileCount = Number(stats.filesChanged);
-        const diffDeltas = collectIterator(diff.deltas());
-        for (const delta of diffDeltas) {
-            if (deltaTypeToStatus(delta.status()) !== "untracked" && delta.newFile().isBinary()) {
-                binaries++;
+        let fileCount = 0;
+        for (const entry of parseNumstatZ(numstatRes.stdout.toString("utf8"))) {
+            fileCount += 1;
+            if (entry.binary) {
+                binaries += 1;
+                continue;
             }
+            additions += entry.additions;
+            deletions += entry.deletions;
         }
-        const untracked = await collectUntrackedFiles(r);
+        const untracked = await collectUntrackedFiles(cwd);
         for (const file of untracked) {
-            fileCount++;
+            fileCount += 1;
             if (file.binary) {
-                binaries++;
+                binaries += 1;
             }
             else {
                 additions += file.lines;
@@ -602,39 +549,41 @@ export const getGitDiffSummary = async (cwd, options = WORKING_OPTIONS) => {
     }
 };
 export const getGitDiff = async (cwd, options = WORKING_OPTIONS) => {
-    const r = await openRepo(cwd);
-    if (!r)
+    const cached = readDiffCache(cwd, options.mode, options.base ?? null);
+    if (cached) {
+        return { isRepo: true, files: mapCacheFiles(cached) };
+    }
+    if (!(await isGitRepo(cwd)))
         return { isRepo: false, files: [] };
-    const cache = await ensureDiffCache(r, options);
+    const cache = await ensureDiffCache(cwd, options);
     if (!cache)
         return { isRepo: true, files: [] };
-    const files = cache.fileMeta.map((meta) => ({
-        path: meta.path,
-        oldPath: meta.oldPath,
-        status: meta.status,
-        additions: meta.additions,
-        deletions: meta.deletions,
-        binary: meta.binary,
-        patch: cache.filePatchByPath.get(meta.path) ?? null,
-        patchOmitted: cache.filePatchOmittedByPath.get(meta.path) ?? false,
-    }));
-    return { isRepo: true, files };
-};
+    return { isRepo: true, files: mapCacheFiles(cache) };
+};
+const mapCacheFiles = (cache) => cache.fileMeta.map((meta) => ({
+    path: meta.path,
+    oldPath: meta.oldPath,
+    status: meta.status,
+    additions: meta.additions,
+    deletions: meta.deletions,
+    binary: meta.binary,
+    patch: cache.filePatchByPath.get(meta.path) ?? null,
+    patchOmitted: cache.filePatchOmittedByPath.get(meta.path) ?? false,
+}));
 export const getGitDiffFiles = async (cwd, options = WORKING_OPTIONS) => {
-    const r = await openRepo(cwd);
-    if (!r)
+    const cached = readDiffCache(cwd, options.mode, options.base ?? null);
+    if (cached)
+        return { isRepo: true, files: cached.fileMeta };
+    if (!(await isGitRepo(cwd)))
         return { isRepo: false, files: [] };
-    const cache = await ensureDiffCache(r, options);
+    const cache = await ensureDiffCache(cwd, options);
     if (!cache)
         return { isRepo: true, files: [] };
     return { isRepo: true, files: cache.fileMeta };
 };
 export const getGitDiffFilePatch = async (cwd, requestedPath, options = WORKING_OPTIONS) => {
     const empty = { patch: null, patchOmitted: false, binary: false };
-    const r = await openRepo(cwd);
-    if (!r)
-        return empty;
-    const cache = await ensureDiffCache(r, options);
+    const cache = await ensureDiffCache(cwd, options);
     if (!cache)
         return empty;
     // O(1) lookup: the full diff pass that the per-file patch needs was already
@@ -650,11 +599,11 @@ export const getGitDiffFilePatch = async (cwd, requestedPath, options = WORKING_
     }
     // An untracked path the cache didn't cover (created between the cache build
     // and this request) falls back to synthesizing from the working tree.
-    return getGitDiffFilePatchFromWorkingTree(r, requestedPath);
+    return getGitDiffFilePatchFromWorkingTree(cwd, requestedPath);
 };
-const getGitDiffFilePatchFromWorkingTree = async (r, requestedPath) => {
+const getGitDiffFilePatchFromWorkingTree = async (cwd, requestedPath) => {
     const empty = { patch: null, patchOmitted: false, binary: false };
-    const absolutePath = path.join(r.cwd, requestedPath);
+    const absolutePath = path.join(cwd, requestedPath);
     try {
         const stat = fs.statSync(absolutePath);
         if (!stat.isFile())
@@ -720,34 +669,33 @@ let activePrFetcher = defaultPrFetcher;
 export const setPrFetcher = (fetcher) => {
     activePrFetcher = fetcher;
 };
-const parseGithubRemotes = (r) => {
+const parseGithubRemotes = async (cwd) => {
+    const result = await runGit(cwd, ["remote", "-v"]);
+    if (result.exitCode !== 0)
+        return [];
     const raw = [];
-    try {
-        for (const remoteName of r.repo.remoteNames()) {
-            try {
-                const remote = r.repo.getRemote(remoteName);
-                const url = remote.url();
-                const match = /github\.com[/:]([^\s/]+)\/([^\s]+?)(?:\.git)?$/i.exec(url);
-                if (!match)
-                    continue;
-                const [, owner, repoName] = match;
-                raw.push({ name: remoteName, slug: `${owner}/${repoName}`, owner });
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    catch {
-        // No remotes
+    const seen = new Set();
+    for (const line of result.stdout.toString("utf8").split("\n")) {
+        const match = /^(\S+)\t(.+?)\s+\(fetch\)$/.exec(line);
+        if (!match)
+            continue;
+        const [, name, url] = match;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        const urlMatch = /github\.com[/:]([^\s/]+)\/([^\s]+?)(?:\.git)?$/i.exec(url);
+        if (!urlMatch)
+            continue;
+        const [, owner, repoName] = urlMatch;
+        raw.push({ name, slug: `${owner}/${repoName}`, owner });
     }
     return memoBy(raw, (remote) => `${remote.name} ${remote.slug}`);
 };
-const detectPr = async (r) => {
-    const currentBranch = getCurrentBranch(r);
+const detectPr = async (cwd) => {
+    const currentBranch = await getCurrentBranch(cwd);
     if (!currentBranch)
         return null;
-    const remotes = parseGithubRemotes(r);
+    const remotes = await parseGithubRemotes(cwd);
     if (remotes.length === 0)
         return null;
     const ownRemote = remotes.find((remote) => remote.name === "origin") ?? remotes[0];
@@ -776,16 +724,32 @@ const detectPr = async (r) => {
         }
         : null;
 };
-export const listGithubRemoteSlugs = async (cwd) => {
-    const r = await openRepo(cwd);
-    if (!r)
+const listBranchesByRecency = async (cwd) => {
+    const result = await runGit(cwd, [
+        "for-each-ref",
+        "--format=%(refname:short)",
+        "--sort=-committerdate",
+        "refs/heads",
+        "refs/remotes",
+    ]);
+    if (result.exitCode !== 0)
         return [];
-    const remotes = parseGithubRemotes(r);
+    const names = [];
+    for (const name of result.stdout.toString("utf8").split("\n")) {
+        if (!name || name.endsWith("/HEAD"))
+            continue;
+        names.push(name);
+        if (names.length >= GIT_MAX_BRANCHES)
+            break;
+    }
+    return names;
+};
+export const listGithubRemoteSlugs = async (cwd) => {
+    const remotes = await parseGithubRemotes(cwd);
     return memoBy(remotes, (remote) => remote.slug).map((remote) => remote.slug);
 };
 export const getGitBranchInfo = async (cwd) => {
-    const r = await openRepo(cwd);
-    if (!r) {
+    if (!(await isGitRepo(cwd))) {
         return {
             isRepo: false,
             currentBranch: null,
@@ -795,42 +759,23 @@ export const getGitBranchInfo = async (cwd) => {
             pr: null,
         };
     }
-    const currentBranch = getCurrentBranch(r);
-    const defaultBase = resolveDefaultBase(r);
-    const branchEntries = collectIterator(r.repo.branches());
-    const branchData = [];
-    for (const b of branchEntries) {
-        if (b.name.endsWith("/HEAD"))
-            continue;
-        try {
-            const refName = b.type === "Remote" ? `refs/remotes/${b.name}` : `refs/heads/${b.name}`;
-            const ref = r.repo.getReference(refName);
-            const target = ref.target();
-            if (!target)
-                continue;
-            const commit = r.repo.getCommit(target);
-            branchData.push({ name: b.name, time: commit.time().getTime() });
-        }
-        catch {
-            branchData.push({ name: b.name, time: 0 });
-        }
-        if (branchData.length >= GIT_MAX_BRANCHES)
-            break;
-    }
-    branchData.sort((a, b) => b.time - a.time);
+    const [currentBranch, defaultBase, branches] = await Promise.all([
+        getCurrentBranch(cwd),
+        resolveDefaultBase(cwd),
+        listBranchesByRecency(cwd),
+    ]);
     return {
         isRepo: true,
         currentBranch,
         defaultBase: defaultBase?.ref ?? null,
         defaultBaseSource: defaultBase?.source ?? null,
-        branches: branchData.map((b) => b.name),
+        branches,
         pr: null,
     };
 };
 export const getGitBranchPr = async (cwd) => {
-    const r = await openRepo(cwd);
-    if (!r)
+    if (!(await isGitRepo(cwd)))
         return null;
-    return detectPr(r);
+    return detectPr(cwd);
 };
 //# sourceMappingURL=git-diff.js.map