@tequila99/githuman 0.2.0 → 0.2.1

package/dist/server/services/diff.service.js

@@ -1,5 +1,5 @@
 import { diffLines } from 'diff';
-import { assertSafeRef, getFileAtRef, listChangedPaths, listUntrackedPaths } from "./git.service.js";
+import { assertSafeRef, getFileAtRef, getFilesAtRefBatch, listChangedPaths, listUntrackedPaths } from "./git.service.js";
 function splitLines(text) {
     if (text === '')
         return [];
@@ -99,19 +99,37 @@ export function computeFileDiff(oldContent, newContent, meta) {
     const hunks = windowHunks(lines);
     return { ...base, additions, deletions, hunks };
 }
+/**
+ * Reads one diff side's content for every changed path, batching all
+ * git-ref reads into a single `git cat-file --batch` process instead of one
+ * `git show` per file (see ADR 0019) — `WORKTREE` still reads straight off
+ * disk (already process-free) since it isn't a git object. Falls back to
+ * per-file `getFileAtRef` if the batch process fails to spawn or crashes
+ * mid-read, so a batching problem degrades performance rather than
+ * correctness.
+ */
+async function readDiffSide(repoPath, ref, paths) {
+    if (ref === 'WORKTREE' || paths.length === 0) {
+        return Promise.all(paths.map(path => getFileAtRef(repoPath, ref, path)));
+    }
+    try {
+        return await getFilesAtRefBatch(repoPath, paths.map(path => ({ ref, path })));
+    }
+    catch {
+        return Promise.all(paths.map(path => getFileAtRef(repoPath, ref, path)));
+    }
+}
 async function buildDiffFiles(repoPath, diffArgs, oldRef, newRef) {
     const changes = await listChangedPaths(repoPath, diffArgs);
-    return Promise.all(changes.map(async (change) => {
-        const [oldFile, newFile] = await Promise.all([
-            getFileAtRef(repoPath, oldRef, change.oldPath),
-            getFileAtRef(repoPath, newRef, change.newPath)
-        ]);
-        return computeFileDiff(oldFile.content, newFile.content, {
-            oldPath: change.oldPath,
-            newPath: change.newPath,
-            status: change.status,
-            isBinary: oldFile.isBinary || newFile.isBinary
-        });
+    const [oldFiles, newFiles] = await Promise.all([
+        readDiffSide(repoPath, oldRef, changes.map(change => change.oldPath)),
+        readDiffSide(repoPath, newRef, changes.map(change => change.newPath))
+    ]);
+    return changes.map((change, i) => computeFileDiff(oldFiles[i].content, newFiles[i].content, {
+        oldPath: change.oldPath,
+        newPath: change.newPath,
+        status: change.status,
+        isBinary: oldFiles[i].isBinary || newFiles[i].isBinary
     }));
 }
 export async function getStagedDiff(repoPath) {

package/dist/server/services/git.service.js

@@ -1,4 +1,4 @@
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { readFile } from 'node:fs/promises';
 import { basename, resolve, sep } from 'node:path';
@@ -30,6 +30,23 @@ export function assertSafeRef(ref) {
         throw new Error(`Invalid git ref "${ref}": refs may not start with "-"`);
     }
 }
+/**
+ * Builds the `git show`/`cat-file` object spec for a file at a ref (e.g.
+ * `HEAD:src/foo.ts`, or `:src/foo.ts` for the INDEX/staged form). Shared by
+ * `getFileAtRef` and `getFilesAtRefBatch` so both single-file and batched
+ * reads resolve refs identically.
+ */
+function objectSpecFor(ref, path) {
+    if (ref !== 'INDEX') {
+        assertSafeRef(ref);
+    }
+    // No `--` before the spec: for the INDEX form (`:path`) it would make git
+    // treat the pathspec-looking `:path` as a plain path instead of the
+    // special "file staged in the index" syntax, silently changing meaning
+    // (falls back to showing HEAD). assertSafeRef above already rules out
+    // the injection this would otherwise guard against.
+    return ref === 'INDEX' ? `:${path}` : `${ref}:${path}`;
+}
 /**
  * Reads a file's content at a given git ref.
  *
@@ -54,16 +71,8 @@ export async function getFileAtRef(repoPath, ref, path) {
             return { content: '', isBinary: false };
         }
     }
-    if (ref !== 'INDEX') {
-        assertSafeRef(ref);
-    }
-    const gitRef = ref === 'INDEX' ? `:${path}` : `${ref}:${path}`;
+    const gitRef = objectSpecFor(ref, path);
     try {
-        // No `--` before gitRef: for the INDEX form (`:path`) it would make git
-        // treat the pathspec-looking `:path` as a plain path instead of the
-        // special "file staged in the index" syntax, silently changing meaning
-        // (falls back to showing HEAD). assertSafeRef above already rules out
-        // the injection this would otherwise guard against.
         const { stdout } = await execFileAsync('git', ['show', gitRef], {
             cwd: repoPath,
             encoding: 'buffer',
@@ -79,6 +88,89 @@ export async function getFileAtRef(repoPath, ref, path) {
         return { content: '', isBinary: false };
     }
 }
+/**
+ * Parses `git cat-file --batch`'s output for `count` requested objects, in
+ * request order. Each entry is either `<sha> SP <type> SP <size> LF`
+ * followed by exactly `size` bytes of content and a trailing LF, or
+ * `<object> SP missing LF` (or another non-numeric-size error line, e.g.
+ * `ambiguous`/`notdir`) for a request that didn't resolve — treated the
+ * same as a missing file, matching `getFileAtRef`'s catch-all behavior.
+ *
+ * Parses by the announced byte size, not line-by-line — file content can
+ * itself contain arbitrary bytes, including `\n`.
+ */
+function parseCatFileBatchOutput(buffer, count) {
+    const results = [];
+    let offset = 0;
+    for (let i = 0; i < count; i++) {
+        const headerEnd = buffer.indexOf(0x0a, offset);
+        if (headerEnd === -1) {
+            throw new Error('git cat-file --batch: truncated output (missing header)');
+        }
+        const header = buffer.toString('utf-8', offset, headerEnd);
+        offset = headerEnd + 1;
+        const size = Number(header.slice(header.lastIndexOf(' ') + 1));
+        if (!Number.isInteger(size) || size < 0) {
+            results.push({ content: '', isBinary: false });
+            continue;
+        }
+        const content = buffer.subarray(offset, offset + size);
+        if (content.length < size) {
+            throw new Error('git cat-file --batch: truncated output (short content)');
+        }
+        offset += size + 1; // skip content + its trailing LF
+        const isBinary = content.includes(0);
+        results.push({
+            content: isBinary ? '' : content.toString('utf-8'),
+            isBinary
+        });
+    }
+    return results;
+}
+/**
+ * Reads many files' content at git refs in one `git cat-file --batch`
+ * process, instead of one `git show` process per file (see ADR 0019) —
+ * used by `buildDiffFiles` to avoid spawning `2 × changed files` processes
+ * for a single diff. Results come back in the same order as `requests`.
+ *
+ * Does not accept `ref: 'WORKTREE'` — worktree content isn't a git object;
+ * callers read it directly off disk instead (as `getFileAtRef` already
+ * does for that ref).
+ */
+export async function getFilesAtRefBatch(repoPath, requests) {
+    if (requests.length === 0)
+        return [];
+    const specs = requests.map(({ ref, path }) => {
+        if (ref === 'WORKTREE') {
+            throw new Error("getFilesAtRefBatch does not support ref 'WORKTREE' — read worktree files directly instead");
+        }
+        return objectSpecFor(ref, path);
+    });
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn('git', ['cat-file', '--batch'], { cwd: repoPath });
+        const chunks = [];
+        let stderr = '';
+        child.stdout.on('data', (chunk) => chunks.push(chunk));
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString('utf-8');
+        });
+        child.on('error', reject);
+        child.on('close', code => {
+            if (code !== 0) {
+                reject(new Error(`git cat-file --batch exited with code ${code}: ${stderr}`));
+                return;
+            }
+            try {
+                resolvePromise(parseCatFileBatchOutput(Buffer.concat(chunks), requests.length));
+            }
+            catch (err) {
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+        child.stdin.write(specs.join('\n') + '\n');
+        child.stdin.end();
+    });
+}
 /**
  * Lists every file path visible at a git ref, for browsing the whole
  * codebase rather than just a diff. `'WORKTREE'` lists the working directory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tequila99/githuman",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Review AI agent code changes before commit — Vue edition",
   "homepage": "https://github.com/tequila99/githuman#readme",
   "bugs": {