fix(git): cap and stream untracked-file line counting

`countFileLines` previously read each untracked file's full content into
memory as UTF-8 via `fs.readFile(filePath, "utf-8")`. The caller in
`getChangedFilesDetailed` runs this 16-way concurrent against every
untracked path returned by `streamGitStatus` (up to 50k entries). On a
monorepo with multi-MB build artifacts or lockfiles, peak heap was
`16 * file_bytes * 2` (V8's UTF-16 cost), easily several GB. That OOM'd
the main process and froze the renderer waiting on a tRPC call that
would never return — the symptom was the app appearing to freeze a
few seconds after the sidebar painted, with no `[ipc-rate]` warnings,
just a silent V8 `Scavenger: semi-space copy Allocation failed`.

Fix: bail out on files larger than 1 MB, and stream the rest with
`createReadStream`, counting `\n` bytes byte-by-byte. Per-stream memory
stays at ~64 KB regardless of file size, so peak across 16 concurrent
reads is ~1 MB total. Preserves the original return semantics
(trailing-newline-aware line count) for files within the cap.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: pauldambra

packages/git/src/queries.test.ts

@@ -6,6 +6,7 @@ import { createGitClient } from "./client";
 import {
   detectDefaultBranch,
   getBranchDiffPatchesByPath,
+  getChangedFilesDetailed,
   splitUnifiedDiffByFile,
 } from "./queries";
 
@@ -242,3 +243,46 @@ describe("getBranchDiffPatchesByPath", () => {
     }
   });
 });
+
+describe("getChangedFilesDetailed", () => {
+  let repoDir: string;
+
+  afterEach(async () => {
+    if (repoDir) {
+      await rm(repoDir, { recursive: true, force: true });
+      repoDir = "";
+    }
+  });
+
+  it("reports line counts for small untracked files", async () => {
+    repoDir = await setupRepo();
+    await writeFile(path.join(repoDir, "small.txt"), "a\nb\nc\n");
+    await writeFile(path.join(repoDir, "no-trailing.txt"), "a\nb\nc");
+
+    const files = await getChangedFilesDetailed(repoDir);
+    const small = files.find((f) => f.path === "small.txt");
+    const noTrailing = files.find((f) => f.path === "no-trailing.txt");
+
+    expect(small).toMatchObject({ status: "untracked", linesAdded: 3 });
+    expect(noTrailing).toMatchObject({ status: "untracked", linesAdded: 3 });
+  });
+
+  // Regression guard for the OOM in https://github.com/PostHog/code/issues/...
+  // (introduced in c617988f). Before the fix `countFileLines` read each
+  // untracked file's full content into memory, 16-way concurrent, with no
+  // size cap. On a monorepo with multi-MB build artifacts / lockfiles this
+  // exhausted the main-process V8 heap (~3GB+) and froze the renderer
+  // waiting on the dead tRPC call. The fix bails on files larger than
+  // COUNT_FILE_LINES_MAX_BYTES (1MB) and stream-counts the rest, so peak
+  // memory stays ~16 * 64KB regardless of file size.
+  it("skips line counting for files over the size cap", async () => {
+    repoDir = await setupRepo();
+    const oneAndAHalfMB = "a\n".repeat(800_000);
+    await writeFile(path.join(repoDir, "huge.txt"), oneAndAHalfMB);
+
+    const files = await getChangedFilesDetailed(repoDir);
+    const huge = files.find((f) => f.path === "huge.txt");
+
+    expect(huge).toMatchObject({ status: "untracked", linesAdded: 0 });
+  });
+});

packages/git/src/queries.ts

@@ -1,3 +1,4 @@
+import { createReadStream } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { CreateGitClientOptions } from "./client";
@@ -413,11 +414,33 @@ function matchesExcludePattern(filePath: string, patterns: string[]): boolean {
   });
 }
 
+const COUNT_FILE_LINES_MAX_BYTES = 1 * 1024 * 1024;
+
 async function countFileLines(filePath: string): Promise<number> {
   try {
-    const content = await fs.readFile(filePath, "utf-8");
-    if (!content) return 0;
-    return content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
+    const stat = await fs.stat(filePath);
+    if (!stat.isFile() || stat.size === 0) return 0;
+    if (stat.size > COUNT_FILE_LINES_MAX_BYTES) return 0;
+    return await new Promise<number>((resolve) => {
+      let newlines = 0;
+      let lastByte = -1;
+      const stream = createReadStream(filePath);
+      stream.on("data", (chunk) => {
+        const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+        for (let i = 0; i < buf.length; i++) {
+          if (buf[i] === 0x0a) newlines++;
+        }
+        if (buf.length > 0) lastByte = buf[buf.length - 1];
+      });
+      stream.on("end", () => {
+        if (lastByte === -1) {
+          resolve(0);
+          return;
+        }
+        resolve(lastByte === 0x0a ? newlines : newlines + 1);
+      });
+      stream.on("error", () => resolve(0));
+    });
   } catch {
     return 0;
   }