fix(diff): skip huge file rendering (#266)

Author: benvinegar

CHANGELOG.md

@@ -10,6 +10,8 @@ All notable user-visible changes to Hunk are documented in this file.
 
 ### Fixed
 
+- Fixed large tracked and untracked file handling so very large diffs render as skipped placeholders instead of slowing startup or overflowing the JavaScript call stack.
+
 ## [0.11.0] - 2026-05-09
 
 ### Added

scripts/test-large-untracked-render.tsx

@@ -0,0 +1,94 @@
+import { testRender } from "@opentui/react/test-utils";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { act } from "react";
+import { loadAppBootstrap } from "../src/core/loaders";
+import { AppHost } from "../src/ui/AppHost";
+
+function runGit(cwd: string, ...args: string[]) {
+  const proc = Bun.spawnSync(["git", ...args], {
+    cwd,
+    stderr: "pipe",
+    stdin: "ignore",
+    stdout: "pipe",
+  });
+
+  if (proc.exitCode !== 0) {
+    throw new Error(Buffer.from(proc.stderr).toString("utf8").trim());
+  }
+}
+
+/** Generate a large untracked file that stays small on disk for manual render checks. */
+function createLargeFileBody(lineCount: number) {
+  return (
+    Array.from({ length: lineCount }, (_, index) => {
+      if (index === 0) {
+        return "visible-first-line";
+      }
+      if (index === lineCount - 1) {
+        return "the widest generated line";
+      }
+      return "x";
+    }).join("\n") + "\n"
+  );
+}
+
+const lineCount = Number.parseInt(process.argv[2] ?? "100000", 10);
+const fixtureKind = process.argv[3] === "tracked" ? "tracked" : "untracked";
+if (!Number.isFinite(lineCount) || lineCount <= 0) {
+  throw new Error("Usage: bun run scripts/test-large-untracked-render.tsx [line-count] [tracked]");
+}
+
+const repo = mkdtempSync(join(tmpdir(), "hunk-large-untracked-render-"));
+try {
+  runGit(repo, "init", "--initial-branch", "main");
+  runGit(repo, "config", "user.name", "Test User");
+  runGit(repo, "config", "user.email", "test@example.com");
+  const largePath = fixtureKind === "tracked" ? "large-tracked.txt" : "large-untracked.txt";
+  writeFileSync(join(repo, "tracked.txt"), "tracked\n");
+  if (fixtureKind === "tracked") {
+    writeFileSync(join(repo, largePath), "original\n");
+  }
+  runGit(repo, "add", ".");
+  runGit(repo, "commit", "-m", "initial");
+  writeFileSync(join(repo, largePath), createLargeFileBody(lineCount));
+
+  const bootstrap = await loadAppBootstrap(
+    { kind: "vcs", staged: false, options: { mode: "stack" } },
+    { cwd: repo },
+  );
+  const setup = await testRender(<AppHost bootstrap={bootstrap} />, { width: 120, height: 30 });
+
+  try {
+    await act(async () => {
+      await setup.renderOnce();
+    });
+
+    const frame = setup.captureCharFrame();
+    console.log(
+      JSON.stringify(
+        {
+          containsHeader: frame.includes(`@@ -0,0 +1,${lineCount} @@`),
+          containsPath: frame.includes(largePath),
+          containsSkippedLargeMessage: frame.includes("File too large to render"),
+          containsVisibleLine: frame.includes("visible-first-line"),
+          fileCount: bootstrap.changeset.files.length,
+          firstFileStats: bootstrap.changeset.files[0]?.stats,
+          firstFileStatsTruncated: bootstrap.changeset.files[0]?.statsTruncated,
+          fixtureKind,
+          lineCount,
+          renderedFrameBytes: Buffer.byteLength(frame),
+        },
+        null,
+        2,
+      ),
+    );
+  } finally {
+    await act(async () => {
+      setup.renderer.destroy();
+    });
+  }
+} finally {
+  rmSync(repo, { force: true, recursive: true });
+}

src/core/git.ts

@@ -49,7 +49,7 @@ function withNormalizedDiffPrefixes(args: string[]) {
 }
 
 /** Build the exact `git diff` arguments used for the shared working-tree and range review path. */
-export function buildGitDiffArgs(input: VcsCommandInput) {
+export function buildGitDiffArgs(input: VcsCommandInput, excludedPathspecs: string[] = []) {
   const args = ["diff", "--no-ext-diff", "--find-renames", "--no-color"];
 
   if (input.staged) {
@@ -60,6 +60,31 @@ export function buildGitDiffArgs(input: VcsCommandInput) {
     args.push(input.range);
   }
 
+  if (excludedPathspecs.length > 0) {
+    args.push(
+      "--",
+      ...(input.pathspecs ?? []),
+      ...excludedPathspecs.map((path) => `:(exclude)${path}`),
+    );
+  } else {
+    appendGitPathspecs(args, input.pathspecs);
+  }
+
+  return withNormalizedDiffPrefixes(args);
+}
+
+/** Build the cheap tracked-file stats query used to skip huge file diffs before patch output. */
+export function buildGitDiffNumstatArgs(input: VcsCommandInput) {
+  const args = ["diff", "--no-ext-diff", "--find-renames", "--no-color", "--numstat", "-z"];
+
+  if (input.staged) {
+    args.push("--staged");
+  }
+
+  if (input.range) {
+    args.push(input.range);
+  }
+
   appendGitPathspecs(args, input.pathspecs);
   return withNormalizedDiffPrefixes(args);
 }

src/core/loaders.test.ts

@@ -297,6 +297,71 @@ describe("loadAppBootstrap", () => {
     expect(bootstrap.changeset.files[1]?.patch).toContain("new file mode");
   });
 
+  test("keeps generated large tracked diffs as skipped placeholders", async () => {
+    const dir = createTempRepo("hunk-git-large-tracked-");
+
+    writeFileSync(join(dir, "large.txt"), "original\n");
+    git(dir, "add", "large.txt");
+    git(dir, "commit", "-m", "initial");
+    writeFileSync(join(dir, "large.txt"), `${"x\n".repeat(100_000)}widest generated line\n`);
+
+    const bootstrap = await loadFromRepo(dir, {
+      kind: "vcs",
+      staged: false,
+      options: { mode: "auto" },
+    });
+
+    expect(bootstrap.changeset.files).toHaveLength(1);
+    expect(bootstrap.changeset.files[0]?.path).toBe("large.txt");
+    expect(bootstrap.changeset.files[0]?.isTooLarge).toBe(true);
+    expect(bootstrap.changeset.files[0]?.stats).toEqual({ additions: 100_001, deletions: 1 });
+    expect(bootstrap.changeset.files[0]?.metadata.hunks).toHaveLength(0);
+  });
+
+  test("keeps generated large untracked files as skipped placeholders", async () => {
+    const dir = createTempRepo("hunk-git-large-untracked-");
+
+    writeFileSync(join(dir, "tracked.ts"), "export const value = 1;\n");
+    git(dir, "add", "tracked.ts");
+    git(dir, "commit", "-m", "initial");
+    writeFileSync(join(dir, "large.txt"), `${"x\n".repeat(100_000)}widest generated line\n`);
+
+    const bootstrap = await loadFromRepo(dir, {
+      kind: "vcs",
+      staged: false,
+      options: { mode: "auto" },
+    });
+
+    expect(bootstrap.changeset.files).toHaveLength(1);
+    expect(bootstrap.changeset.files[0]?.path).toBe("large.txt");
+    expect(bootstrap.changeset.files[0]?.isTooLarge).toBe(true);
+    expect(bootstrap.changeset.files[0]?.stats).toEqual({ additions: 100_001, deletions: 0 });
+    expect(bootstrap.changeset.files[0]?.statsTruncated).toBe(false);
+    expect(bootstrap.changeset.files[0]?.metadata.hunks).toHaveLength(0);
+  });
+
+  test("caps skipped untracked-file stats when byte-size detection would require a full huge read", async () => {
+    const dir = createTempRepo("hunk-git-byte-large-untracked-");
+
+    writeFileSync(join(dir, "tracked.ts"), "export const value = 1;\n");
+    git(dir, "add", "tracked.ts");
+    git(dir, "commit", "-m", "initial");
+    writeFileSync(join(dir, "large-single-line.txt"), "x".repeat(1_000_001));
+
+    const bootstrap = await loadFromRepo(dir, {
+      kind: "vcs",
+      staged: false,
+      options: { mode: "auto" },
+    });
+
+    expect(bootstrap.changeset.files).toHaveLength(1);
+    expect(bootstrap.changeset.files[0]?.path).toBe("large-single-line.txt");
+    expect(bootstrap.changeset.files[0]?.isTooLarge).toBe(true);
+    expect(bootstrap.changeset.files[0]?.stats).toEqual({ additions: 1, deletions: 0 });
+    expect(bootstrap.changeset.files[0]?.statsTruncated).toBe(true);
+    expect(bootstrap.changeset.files[0]?.metadata.hunks).toHaveLength(0);
+  });
+
   test("skips untracked symlinks to directories while loading the rest of the review", async () => {
     const dir = createTempRepo("hunk-git-untracked-dir-symlink-");