@monotykamary/localterm-server 2.0.3 → 2.0.5

package/dist/git-diff.js

@@ -3,10 +3,10 @@ import fsPromises from "node:fs/promises";
 import path from "node:path";
 import { Octokit } from "@octokit/rest";
 import { openRepository } from "es-git";
-import { computePatchFromContents } from "./utils/compute-patch.js";
 import { memoBy } from "./utils/memo-by.js";
+import { computePatchFromContents } from "./utils/compute-patch.js";
 import { resolveGithubToken } from "./utils/resolve-github-token.js";
-import { GIT_BINARY_SNIFF_BYTES, GIT_BRANCH_INFO_PR_TIMEOUT_MS, 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";
+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 = {
     isRepo: false,
@@ -16,8 +16,37 @@ const EMPTY_SUMMARY = {
     binaries: 0,
     branch: null,
 };
-const GIT_EMPTY_TREE_HASH = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 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();
+const comparisonKey = (mode, base) => `${mode}:${base ?? ""}`;
+const readDiffCache = (cwd, mode, base) => {
+    const byComparison = diffCacheByCwd.get(cwd);
+    if (!byComparison)
+        return null;
+    const entry = byComparison.get(comparisonKey(mode, base));
+    if (!entry)
+        return null;
+    if (Date.now() - entry.builtAt > GIT_CACHE_TTL_MS) {
+        byComparison.delete(comparisonKey(mode, base));
+        if (byComparison.size === 0)
+            diffCacheByCwd.delete(cwd);
+        return null;
+    }
+    return entry;
+};
+const writeDiffCache = (cwd, mode, base, cache) => {
+    let byComparison = diffCacheByCwd.get(cwd);
+    if (!byComparison) {
+        byComparison = new Map();
+        diffCacheByCwd.set(cwd, byComparison);
+    }
+    byComparison.set(comparisonKey(mode, base), cache);
+};
+export const invalidateGitDiffCache = (cwd) => {
+    diffCacheByCwd.delete(cwd);
+};
 const collectIterator = (iterable) => {
     const result = [];
     for (const item of iterable)
@@ -238,10 +267,7 @@ const readWorkingTreeFile = (r, filePath, maxBytes = GIT_MAX_UNTRACKED_FILE_BYTE
         return null;
     }
 };
-const collectDeltaMeta = (r, diff, isWorkingTree) => {
-    const stats = diff.stats();
-    const totalInsertions = Number(stats.insertions);
-    const totalDeletions = Number(stats.deletions);
+const collectDeltaInfos = (diff) => {
     const deltas = collectIterator(diff.deltas());
     const result = [];
     for (const delta of deltas) {
@@ -250,97 +276,41 @@ const collectDeltaMeta = (r, diff, isWorkingTree) => {
             continue;
         const newFile = delta.newFile();
         const oldFile = delta.oldFile();
-        const isBinary = newFile.isBinary();
         result.push({
             path: newFile.path(),
             oldPath: status === "renamed" ? oldFile.path() : null,
             status,
-            additions: 0,
-            deletions: 0,
-            binary: isBinary,
+            binary: newFile.isBinary(),
             oldId: oldFile.id(),
             newId: newFile.id(),
-            isWorkingTree,
         });
     }
-    // Compute per-file additions/deletions from patch text.
-    // es-git's DiffStats only gives aggregate totals; we generate
-    // patches per-delta and count +/- lines from the structured diff.
-    const nonBinary = result.filter((d) => !d.binary);
-    if (nonBinary.length === 0)
-        return result;
-    if (nonBinary.length === 1) {
-        nonBinary[0].additions = totalInsertions;
-        nonBinary[0].deletions = totalDeletions;
-        return result;
-    }
-    // Compute per-file stats from patch text. Each delta gets its own
-    // patch generated from old vs new content, giving exact counts.
-    for (const d of result) {
-        if (d.binary)
-            continue;
-        try {
-            const oldContent = d.oldId === ZERO_OID || d.oldId === ""
-                ? d.status === "added"
-                    ? null
-                    : readBlobContent(r, d.oldId)
-                : readBlobContent(r, d.oldId);
-            const newContent = d.isWorkingTree
-                ? readWorkingTreeFile(r, d.path, GIT_MAX_TOTAL_PATCH_BYTES)
-                : d.newId === ZERO_OID || d.newId === ""
-                    ? d.status === "deleted"
-                        ? null
-                        : readBlobContent(r, d.newId)
-                    : readBlobContent(r, d.newId);
-            const aPath = d.oldPath ?? d.path;
-            const patchResult = computePatchFromContents(oldContent, newContent, aPath, d.path, null, null, d.oldId === ZERO_OID ? null : d.oldId, d.newId === ZERO_OID ? null : d.newId, d.status === "renamed");
-            d.additions = patchResult.additions;
-            d.deletions = patchResult.deletions;
-        }
-        catch {
-            // Fallback: proportional split of aggregate totals
-            const perFileAdd = Math.floor(totalInsertions / nonBinary.length);
-            d.additions = perFileAdd;
-            d.deletions = Math.floor(totalDeletions / nonBinary.length);
-        }
-    }
-    // Verify totals match and redistribute remainder if needed
-    let computedAdds = 0;
-    let computedDels = 0;
-    for (const d of result) {
-        if (!d.binary) {
-            computedAdds += d.additions;
-            computedDels += d.deletions;
-        }
+    return result;
+};
+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,
+        };
     }
-    const addDelta = totalInsertions - computedAdds;
-    const delDelta = totalDeletions - computedDels;
-    if (addDelta !== 0 || delDelta !== 0) {
-        const sorted = result.filter((d) => !d.binary);
-        let remainingAdd = addDelta;
-        let remainingDel = delDelta;
-        for (const d of sorted) {
-            if (remainingAdd > 0) {
-                d.additions += 1;
-                remainingAdd -= 1;
-            }
-            else if (remainingAdd < 0) {
-                d.additions -= 1;
-                remainingAdd += 1;
-            }
-            if (remainingDel > 0) {
-                d.deletions += 1;
-                remainingDel -= 1;
-            }
-            else if (remainingDel < 0) {
-                d.deletions -= 1;
-                remainingDel += 1;
-            }
-            if (remainingAdd === 0 && remainingDel === 0)
-                break;
-        }
+    catch {
+        return { patchText: null, additions: 0, deletions: 0 };
     }
-    return result;
 };
 const buildBaseTree = (r, baseRef) => {
     try {
@@ -363,17 +333,22 @@ const buildBaseTree = (r, baseRef) => {
         }
     }
 };
-export const splitPatchByFile = (raw) => raw.split(/^(?=diff --git )/m).filter((chunk) => chunk.startsWith("diff --git "));
-const computeTrackedDeltas = async (r, baseRef) => {
+// 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)
-        return [];
+        return null;
     let diff;
     try {
         diff = r.repo.diffTreeToWorkdirWithIndex(baseTree);
     }
     catch {
-        return [];
+        return null;
     }
     try {
         diff.findSimilar({ renames: true });
@@ -381,16 +356,137 @@ const computeTrackedDeltas = async (r, baseRef) => {
     catch {
         // Rename detection failed
     }
-    const deltaMeta = collectDeltaMeta(r, diff, true);
-    return deltaMeta.map((d) => ({
-        path: d.path,
-        oldPath: d.oldPath,
-        status: d.status,
-        additions: d.additions,
-        deletions: d.deletions,
-        binary: d.binary,
-    }));
+    // 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);
+    const fileMeta = [];
+    const filePatchByPath = new Map();
+    const fileBinaryByPath = new Map();
+    const filePatchOmittedByPath = new Map();
+    let totalPatchBytes = 0;
+    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];
+        let patchText = null;
+        let patchOmitted = false;
+        let fileAdditions;
+        let fileDeletions;
+        if (delta.binary) {
+            fileAdditions = 0;
+            fileDeletions = 0;
+            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;
+                }
+            }
+            else {
+                patchOmitted = true;
+            }
+        }
+        additions += fileAdditions;
+        deletions += fileDeletions;
+        fileMeta.push({
+            path: delta.path,
+            oldPath: delta.oldPath,
+            status: delta.status,
+            additions: fileAdditions,
+            deletions: fileDeletions,
+            binary: delta.binary,
+        });
+        filePatchByPath.set(delta.path, patchText);
+        fileBinaryByPath.set(delta.path, delta.binary);
+        filePatchOmittedByPath.set(delta.path, patchOmitted);
+    }
+    for (const file of untracked) {
+        const patch = file.binary
+            ? null
+            : file.truncated || file.content === null
+                ? null
+                : buildUntrackedPatch(file.content);
+        let patchOmitted = file.truncated;
+        if (patch !== null) {
+            if (patch.length > GIT_MAX_PATCH_BYTES_PER_FILE ||
+                totalPatchBytes + patch.length > GIT_MAX_TOTAL_PATCH_BYTES) {
+                patchOmitted = true;
+            }
+            else {
+                totalPatchBytes += patch.length;
+            }
+        }
+        const fileAdditions = file.binary ? 0 : file.lines;
+        if (file.binary)
+            binaries += 1;
+        additions += fileAdditions;
+        fileMeta.push({
+            path: file.path,
+            oldPath: null,
+            status: "untracked",
+            additions: fileAdditions,
+            deletions: 0,
+            binary: file.binary,
+        });
+        filePatchByPath.set(file.path, patchOmitted ? null : patch);
+        fileBinaryByPath.set(file.path, file.binary);
+        filePatchOmittedByPath.set(file.path, patchOmitted);
+    }
+    const summary = {
+        isRepo: true,
+        files: fileMeta.length,
+        additions,
+        deletions,
+        binaries,
+        branch: getCurrentBranch(r),
+    };
+    return {
+        summary,
+        fileMeta,
+        filePatchByPath,
+        fileBinaryByPath,
+        filePatchOmittedByPath,
+        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);
+    if (cached)
+        return cached;
+    const baseRef = resolveEffectiveBaseRef(r, options);
+    if (baseRef === null)
+        return null;
+    const cache = await buildDiffCache(r, baseRef);
+    if (cache)
+        writeDiffCache(r.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 = [];
@@ -450,6 +546,13 @@ 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);
+    if (cached)
+        return cached.summary;
     try {
         const baseRef = resolveEffectiveBaseRef(r, options);
         if (baseRef === null)
@@ -498,191 +601,60 @@ export const getGitDiffSummary = async (cwd, options = WORKING_OPTIONS) => {
         return { ...EMPTY_SUMMARY, isRepo: true };
     }
 };
-const buildFilePatch = (r, delta) => {
-    if (delta.binary)
-        return null;
-    const oldContent = delta.status === "added"
-        ? null
-        : delta.isWorkingTree
-            ? readBlobContent(r, delta.oldId)
-            : readBlobContent(r, delta.oldId);
-    const newContent = delta.status === "deleted"
-        ? null
-        : delta.isWorkingTree
-            ? readWorkingTreeFile(r, delta.path, GIT_MAX_TOTAL_PATCH_BYTES)
-            : delta.newId === ZERO_OID
-                ? readWorkingTreeFile(r, delta.path, GIT_MAX_TOTAL_PATCH_BYTES)
-                : readBlobContent(r, delta.newId);
-    const aPath = delta.oldPath ?? delta.path;
-    const result = 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 result.patchText || null;
-};
 export const getGitDiff = async (cwd, options = WORKING_OPTIONS) => {
     const r = await openRepo(cwd);
     if (!r)
         return { isRepo: false, files: [] };
-    const baseRef = resolveEffectiveBaseRef(r, options);
-    if (baseRef === null)
-        return { isRepo: true, files: [] };
-    const baseTree = buildBaseTree(r, baseRef);
-    if (!baseTree)
-        return { isRepo: true, files: [] };
-    let diff;
-    try {
-        diff = r.repo.diffTreeToWorkdirWithIndex(baseTree);
-    }
-    catch {
+    const cache = await ensureDiffCache(r, options);
+    if (!cache)
         return { isRepo: true, files: [] };
-    }
-    try {
-        diff.findSimilar({ renames: true });
-    }
-    catch {
-        // Rename detection failed
-    }
-    const deltaMeta = collectDeltaMeta(r, diff, true);
-    let totalPatchBytes = 0;
-    const files = deltaMeta.map((entry) => {
-        let patch = null;
-        let patchOmitted = false;
-        if (entry.binary) {
-            patch = null;
-        }
-        else {
-            try {
-                patch = buildFilePatch(r, entry);
-            }
-            catch {
-                patchOmitted = true;
-            }
-            if (patch !== null) {
-                if (patch.length > GIT_MAX_PATCH_BYTES_PER_FILE ||
-                    totalPatchBytes + patch.length > GIT_MAX_TOTAL_PATCH_BYTES) {
-                    patch = null;
-                    patchOmitted = true;
-                }
-                else {
-                    totalPatchBytes += patch.length;
-                }
-            }
-            else if (!patchOmitted) {
-                patchOmitted = true;
-            }
-        }
-        return {
-            path: entry.path,
-            oldPath: entry.oldPath,
-            status: entry.status,
-            additions: entry.additions,
-            deletions: entry.deletions,
-            binary: entry.binary,
-            patch,
-            patchOmitted,
-        };
-    });
-    const untracked = await collectUntrackedFiles(r);
-    for (const file of untracked) {
-        const patch = file.binary
-            ? null
-            : file.truncated || file.content === null
-                ? null
-                : buildUntrackedPatch(file.content);
-        const entry = {
-            path: file.path,
-            oldPath: null,
-            status: "untracked",
-            additions: file.binary ? 0 : file.lines,
-            deletions: 0,
-            binary: file.binary,
-            patch,
-            patchOmitted: file.truncated,
-        };
-        if (entry.patch !== null) {
-            if (entry.patch.length > GIT_MAX_PATCH_BYTES_PER_FILE ||
-                totalPatchBytes + entry.patch.length > GIT_MAX_TOTAL_PATCH_BYTES) {
-                entry.patch = null;
-                entry.patchOmitted = true;
-            }
-            else {
-                totalPatchBytes += entry.patch.length;
-            }
-        }
-        files.push(entry);
-    }
+    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 };
 };
 export const getGitDiffFiles = async (cwd, options = WORKING_OPTIONS) => {
     const r = await openRepo(cwd);
     if (!r)
         return { isRepo: false, files: [] };
-    const baseRef = resolveEffectiveBaseRef(r, options);
-    if (baseRef === null)
+    const cache = await ensureDiffCache(r, options);
+    if (!cache)
         return { isRepo: true, files: [] };
-    const trackedDeltas = await computeTrackedDeltas(r, baseRef);
-    const files = trackedDeltas.map((entry) => ({
-        path: entry.path,
-        oldPath: entry.oldPath,
-        status: entry.status,
-        additions: entry.additions,
-        deletions: entry.deletions,
-        binary: entry.binary,
-    }));
-    const untracked = await collectUntrackedFiles(r);
-    for (const file of untracked) {
-        files.push({
-            path: file.path,
-            oldPath: null,
-            status: "untracked",
-            additions: file.binary ? 0 : file.lines,
-            deletions: 0,
-            binary: file.binary,
-        });
-    }
-    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 baseRef = resolveEffectiveBaseRef(r, options);
-    if (baseRef === null)
-        return empty;
-    const baseTree = buildBaseTree(r, baseRef);
-    if (!baseTree)
-        return empty;
-    let diff;
-    try {
-        diff = r.repo.diffTreeToWorkdirWithIndex(baseTree);
-    }
-    catch {
+    const cache = await ensureDiffCache(r, options);
+    if (!cache)
         return empty;
+    // O(1) lookup: the full diff pass that the per-file patch needs was already
+    // computed once for this (cwd, mode, base) and cached. This was the O(N²)
+    // regression — each per-file request re-ran the whole-tree diff + a jsdiff
+    // for every file. Now it's a map lookup.
+    if (cache.filePatchByPath.has(requestedPath)) {
+        return {
+            patch: cache.filePatchByPath.get(requestedPath) ?? null,
+            patchOmitted: cache.filePatchOmittedByPath.get(requestedPath) ?? false,
+            binary: cache.fileBinaryByPath.get(requestedPath) ?? false,
+        };
     }
-    try {
-        diff.findSimilar({ renames: true });
-    }
-    catch {
-        // Rename detection failed
-    }
-    const deltaMeta = collectDeltaMeta(r, diff, true);
-    const entry = deltaMeta.find((d) => d.path === requestedPath);
-    if (entry) {
-        if (entry.binary)
-            return { patch: null, patchOmitted: false, binary: true };
-        try {
-            const patch = buildFilePatch(r, entry);
-            if (patch === null)
-                return empty;
-            if (patch.length > GIT_MAX_PATCH_BYTES_PER_FILE) {
-                return { patch: null, patchOmitted: true, binary: false };
-            }
-            return { patch, patchOmitted: false, binary: false };
-        }
-        catch {
-            return { patch: null, patchOmitted: true, binary: false };
-        }
-    }
-    const absolutePath = path.join(cwd, requestedPath);
+    // 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);
+};
+const getGitDiffFilePatchFromWorkingTree = async (r, requestedPath) => {
+    const empty = { patch: null, patchOmitted: false, binary: false };
+    const absolutePath = path.join(r.cwd, requestedPath);
     try {
         const stat = fs.statSync(absolutePath);
         if (!stat.isFile())
@@ -824,10 +796,6 @@ export const getGitBranchInfo = async (cwd) => {
         };
     }
     const currentBranch = getCurrentBranch(r);
-    const pr = await Promise.race([
-        detectPr(r),
-        new Promise((resolve) => setTimeout(() => resolve(null), GIT_BRANCH_INFO_PR_TIMEOUT_MS)),
-    ]);
     const defaultBase = resolveDefaultBase(r);
     const branchEntries = collectIterator(r.repo.branches());
     const branchData = [];
@@ -856,7 +824,13 @@ export const getGitBranchInfo = async (cwd) => {
         defaultBase: defaultBase?.ref ?? null,
         defaultBaseSource: defaultBase?.source ?? null,
         branches: branchData.map((b) => b.name),
-        pr,
+        pr: null,
     };
 };
+export const getGitBranchPr = async (cwd) => {
+    const r = await openRepo(cwd);
+    if (!r)
+        return null;
+    return detectPr(r);
+};
 //# sourceMappingURL=git-diff.js.map