@hienlh/ppm 0.21.0 → 0.22.0

package/src/services/file-watcher.service.ts

@@ -36,6 +36,12 @@ interface WatchEntry {
   refCount: number;
   timer?: ReturnType<typeof setTimeout>;
   pending: Set<string>;
+  /** Resolves once the first walk has attached its watchers. Never rejects. */
+  ready: Promise<void>;
+  /** The cap this tree was given — what it counts as while it is still walking. */
+  maxDirs: number;
+  /** True until the first walk lands, successfully or not. */
+  walking: boolean;
 }
 
 const watchers = new Map<string, WatchEntry>();
@@ -47,9 +53,21 @@ export function onFileChange(cb: ChangeCallback): void {
   changeCallbacks.push(cb);
 }
 
+/**
+ * How many directories the live trees account for, for sizing the next project's budget.
+ *
+ * A tree that is still walking counts as the whole cap it was given rather than as what it has
+ * reached so far. The walk hands the event loop back every few hundred directories, so its
+ * count climbs for seconds — and a second project opened during one used to size its budget
+ * against that unfinished number, which is how two projects starting together could each be
+ * told there was room and overshoot `MAX_DIRS_TOTAL` between them. Over-counting is the safe
+ * direction: the reservation is released the moment the walk lands and reports its real size.
+ */
 function totalCoveredDirs(): number {
   let total = 0;
-  for (const entry of watchers.values()) total += entry.tree.stats().dirs;
+  for (const entry of watchers.values()) {
+    total += entry.walking ? entry.maxDirs : entry.tree.stats().dirs;
+  }
   return total;
 }
 
@@ -71,12 +89,25 @@ function queue(entry: WatchEntry, projectName: string, relPath: string): void {
   }, DEBOUNCE_MS);
 }
 
-/** Start watching a project directory (ref-counted — safe to call multiple times) */
-export function startWatching(projectName: string, projectPath: string): void {
+/**
+ * Start watching a project directory (ref-counted — safe to call multiple times).
+ *
+ * The returned promise resolves once the tree's watchers are attached, which is
+ * no longer the moment this returns: covering yields the event loop every few
+ * hundred directories, so a change made in between is not reported. Callers that
+ * act on the filesystem immediately afterwards have to await it. It never
+ * rejects — a failed walk is logged and leaves the project unwatched.
+ *
+ * What those yields cost is *events*, not coverage: a directory created while the
+ * walk is running would otherwise end up in neither the snapshot nor under a live
+ * watcher and stay unwatched for the session, so `WatchTree.start()` makes a
+ * reconciliation pass before resolving. Both halves are why awaiting this matters.
+ */
+export function startWatching(projectName: string, projectPath: string): Promise<void> {
   const existing = watchers.get(projectName);
   if (existing) {
     existing.refCount++;
-    return;
+    return existing.ready;
   }
 
   const maxDirs = Math.max(
@@ -95,28 +126,47 @@ export function startWatching(projectName: string, projectPath: string): void {
     }),
     refCount: 1,
     pending: new Set(),
+    ready: Promise.resolve(),
+    maxDirs,
+    walking: true,
   };
   watchers.set(projectName, entry);
 
-  try {
-    entry.tree.start();
-  } catch (e) {
-    entry.tree.close(); // release whatever attached before the failure
-    watchers.delete(projectName);
-    console.warn(`[file-watcher] Failed to watch ${projectPath}: ${(e as Error).message}`);
-    return;
-  }
-
-  const { dirs, watchers: handles, truncated } = entry.tree.stats();
-  console.log(
-    `[file-watcher] Started watching: ${projectName} (${dirs} dirs, ${handles} handles${truncated ? ", capped" : ""})`,
-  );
-  if (truncated) {
-    console.warn(
-      `[file-watcher] ${projectName} exceeded the ${maxDirs}-directory budget — ` +
-      `parts of the tree are not watched. Add build/cache directories to the ignore list.`,
-    );
-  }
+  // The entry is already in `watchers`, so a second caller arriving while the
+  // walk is still running finds it and bumps the ref count rather than starting
+  // a second tree. Covering is asynchronous now — it hands the event loop back
+  // every few hundred directories instead of holding it for the whole walk — so
+  // the count and the truncation warning can only be reported once it lands.
+  entry.ready = entry.tree
+    .start()
+    .then(() => {
+      entry.walking = false;
+      // Stopped while the walk was still running: `stopWatching` closed this tree, so the
+      // stats are now zeroes and the line would read "Started watching: proj (0 dirs, 0
+      // handles)" for a project nothing is watching.
+      if (watchers.get(projectName) !== entry) return;
+      const { dirs, watchers: handles, truncated } = entry.tree.stats();
+      console.log(
+        `[file-watcher] Started watching: ${projectName} (${dirs} dirs, ${handles} handles${truncated ? ", capped" : ""})`,
+      );
+      if (truncated) {
+        console.warn(
+          `[file-watcher] ${projectName} exceeded the ${maxDirs}-directory budget — ` +
+          `parts of the tree are not watched. Add build/cache directories to the ignore list.`,
+        );
+      }
+    })
+    .catch((e) => {
+      entry.walking = false;
+      entry.tree.close(); // release whatever attached before the failure
+      // By identity: a stop-then-start of the same project while this walk was in flight put
+      // a *new* entry in the map, and deleting unconditionally would drop that one — leaving
+      // its handles unclosed and letting the next `startWatching` build a second tree over
+      // the same directories.
+      if (watchers.get(projectName) === entry) watchers.delete(projectName);
+      console.warn(`[file-watcher] Failed to watch ${projectPath}: ${(e as Error).message}`);
+    });
+  return entry.ready;
 }
 
 /** Decrement ref count — stops watcher when no clients remain */

package/src/services/git-branch-diff/branch-diff-parse.ts

@@ -0,0 +1,151 @@
+/**
+ * Parsing for a whole-branch diff: `git diff --numstat -z` for the line counts
+ * and `git diff --raw -z` for the blob ids and change kinds, merged per path.
+ *
+ * Two commands rather than one because git concatenates the two formats when
+ * both are asked for, and telling them apart afterwards is guesswork. They are
+ * both cheap and run in parallel.
+ *
+ * `-z` throughout: without it a path containing a tab, a quote or a newline is
+ * escaped and the record becomes ambiguous, and a rename is emitted as a single
+ * `old => new` field that cannot be split reliably.
+ *
+ * (`packages/ext-git-graph/src/compare-args.ts` has its own numstat parser. It
+ * stays separate on purpose: an extension is installed from npm into
+ * `~/.ppm/extensions`, so it cannot import from `src/`.)
+ */
+
+import type { BranchDiffFile } from "../../types/git.ts";
+
+type BranchDiffStatus = BranchDiffFile["status"];
+
+interface RawEntry {
+  status: BranchDiffStatus;
+  blob: string;
+  oldPath?: string;
+}
+
+/** One NUL-terminated record at a time, dropping the empty trailing field. */
+function records(stdout: string): string[] {
+  const parts = stdout.split("\0");
+  if (parts[parts.length - 1] === "") parts.pop();
+  return parts;
+}
+
+/**
+ * `git diff --numstat -z` → additions/deletions per path.
+ *
+ * A rename is three records: the counts with an empty path field, then the old
+ * path, then the new one.
+ */
+export function parseNumstatZ(stdout: string): Map<string, { additions: number; deletions: number; binary: boolean; oldPath?: string }> {
+  const parts = records(stdout);
+  const out = new Map<string, { additions: number; deletions: number; binary: boolean; oldPath?: string }>();
+
+  for (let i = 0; i < parts.length; i++) {
+    const record = parts[i];
+    if (!record) continue;
+    const tab1 = record.indexOf("\t");
+    if (tab1 === -1) continue;
+    const tab2 = record.indexOf("\t", tab1 + 1);
+    if (tab2 === -1) continue;
+
+    const addedRaw = record.slice(0, tab1);
+    const deletedRaw = record.slice(tab1 + 1, tab2);
+    const pathPart = record.slice(tab2 + 1);
+    const binary = addedRaw === "-" && deletedRaw === "-";
+    const counts = {
+      additions: binary ? 0 : Number(addedRaw) || 0,
+      deletions: binary ? 0 : Number(deletedRaw) || 0,
+      binary,
+    };
+
+    if (pathPart === "") {
+      const oldPath = parts[++i] ?? "";
+      const newPath = parts[++i] ?? "";
+      out.set(newPath, { ...counts, oldPath });
+      continue;
+    }
+    out.set(pathPart, counts);
+  }
+
+  return out;
+}
+
+/**
+ * `git diff --raw -z --no-abbrev` → status and head-side blob id per path.
+ *
+ * Record shape: `:<srcmode> <dstmode> <srcsha> <dstsha> <status>` then the path,
+ * or two paths when the status is R or C. The status carries a similarity score
+ * there (`R100`), which is dropped — the letter is the part anything acts on.
+ *
+ * `--no-abbrev` matters: the default abbreviates the ids to whatever length is
+ * currently unambiguous in the repository, so the same file yields a different
+ * string as the repository grows, and every stored review flag would clear.
+ */
+export function parseRawZ(stdout: string): Map<string, RawEntry> {
+  const parts = records(stdout);
+  const out = new Map<string, RawEntry>();
+
+  for (let i = 0; i < parts.length; i++) {
+    const record = parts[i];
+    if (!record || !record.startsWith(":")) continue;
+    const fields = record.slice(1).split(" ");
+    if (fields.length < 5) continue;
+    const blob = fields[3] ?? "";
+    const letter = (fields[4] ?? "M").charAt(0).toUpperCase();
+    const status = (["A", "M", "D", "R", "C", "T"].includes(letter) ? letter : "M") as BranchDiffStatus;
+
+    if (status === "R" || status === "C") {
+      const oldPath = parts[++i] ?? "";
+      const newPath = parts[++i] ?? "";
+      out.set(newPath, { status, blob, oldPath });
+      continue;
+    }
+    const path = parts[++i] ?? "";
+    if (path) out.set(path, { status, blob });
+  }
+
+  return out;
+}
+
+/**
+ * Join the two, keyed by head-side path.
+ *
+ * The raw output is the spine rather than numstat's: it is the one that reports
+ * a mode-only change (`T`), which numstat omits entirely, and a file missing
+ * from it has no blob id to remember a review against.
+ */
+export function mergeBranchDiff(
+  numstat: ReturnType<typeof parseNumstatZ>,
+  raw: ReturnType<typeof parseRawZ>,
+): BranchDiffFile[] {
+  const files: BranchDiffFile[] = [];
+  for (const [path, entry] of raw) {
+    const counts = numstat.get(path);
+    files.push({
+      path,
+      ...(entry.oldPath ? { oldPath: entry.oldPath } : {}),
+      status: entry.status,
+      additions: counts?.additions ?? 0,
+      deletions: counts?.deletions ?? 0,
+      binary: counts?.binary ?? false,
+      blob: entry.blob,
+    });
+  }
+  files.sort((a, b) => a.path.localeCompare(b.path));
+  return files;
+}
+
+/**
+ * Refs reach git as argv, so a shell is never involved — but an argument
+ * starting with `-` is still read as an option, and `..` would turn one field
+ * into a range and defeat the caller's choice of comparison.
+ */
+export function assertRef(value: string | undefined, label: string): string {
+  const s = (value ?? "").trim();
+  if (!s || s.startsWith("-") || s.includes("..") || /[\x00-\x1f\x7f~^:?*[\]\\]/.test(s)) {
+    throw new Error(`Invalid git ref for ${label}: "${s}"`);
+  }
+  return s;
+}

package/src/services/git-branch-diff/branch-diff.service.ts

@@ -0,0 +1,79 @@
+/**
+ * The whole of a branch's work in one list: every file that differs between a
+ * base ref and a head ref, with the base the per-file diffs must also use.
+ *
+ * The point of returning `mergeBase` rather than just the file list is that the
+ * caller opens each file separately. In three-dot mode the list is computed
+ * against where the branches diverged, so a viewer handed `base` instead would
+ * show the base branch's own later commits as deletions inside a review of
+ * head — the file list and the file view disagreeing about what is being
+ * reviewed. Every diff here is run against one resolved commit so the two
+ * cannot drift.
+ */
+import simpleGit from "simple-git";
+import type { BranchDiff } from "../../types/git.ts";
+import { assertRef, mergeBranchDiff, parseNumstatZ, parseRawZ } from "./branch-diff-parse.ts";
+
+export type BranchDiffMode = "three-dot" | "two-dot";
+
+/**
+ * How many files one comparison may answer with.
+ *
+ * Both git outputs are buffered as strings and the whole list is returned in
+ * one JSON array, which the review tab then renders un-virtualized in a 288px
+ * sidebar. A branch that vendors a dependency or lands a formatter pass is
+ * 20,000 files — a multi-megabyte response and 20,000 DOM rows for a list
+ * nobody is going to read to the end. Reviewing a branch that large one file at
+ * a time is not the workflow this exists for, so the honest answer is to say
+ * how many were left out.
+ */
+const MAX_FILES = 2000;
+
+export async function branchDiff(
+  repoPath: string,
+  baseRef: string | undefined,
+  headRef: string | undefined,
+  mode: BranchDiffMode = "three-dot",
+  // A parameter only so a test can trip the cap without committing 2001 files.
+  maxFiles: number = MAX_FILES,
+): Promise<BranchDiff> {
+  const base = assertRef(baseRef, "base");
+  const head = assertRef(headRef, "head");
+  const git = simpleGit(repoPath);
+
+  let mergeBase = base;
+  if (mode === "three-dot") {
+    // `git merge-base` exits non-zero on unrelated histories, where a three-dot
+    // diff has no meaning at all. Saying so beats silently answering with the
+    // two-dot list under a three-dot label.
+    try {
+      mergeBase = (await git.raw(["merge-base", base, head])).trim();
+    } catch {
+      throw new Error(`"${base}" and "${head}" have no common ancestor.`);
+    }
+    if (!mergeBase) throw new Error(`"${base}" and "${head}" have no common ancestor.`);
+  }
+
+  const [numstatOut, rawOut, headCommit] = await Promise.all([
+    git.raw(["diff", "--numstat", "-z", "-M", mergeBase, head]),
+    git.raw(["diff", "--raw", "-z", "-M", "--no-abbrev", mergeBase, head]),
+    // Resolved once, here, rather than by each caller opening a file: `head` is
+    // a ref name and a commit landing mid-review would move it, so the viewer
+    // would render a tip the row's counts and blob id do not describe. This
+    // file's own header promises one resolved commit; `mergeBase` was the only
+    // half of that promise being kept.
+    git.raw(["rev-parse", head]).then((s) => s.trim()),
+  ]);
+
+  const all = mergeBranchDiff(parseNumstatZ(numstatOut), parseRawZ(rawOut));
+
+  return {
+    base,
+    head,
+    mode,
+    mergeBase,
+    headCommit,
+    omitted: Math.max(0, all.length - maxFiles),
+    files: all.slice(0, maxFiles),
+  };
+}

package/src/services/git-hunks/git-hunks.service.ts

@@ -1,4 +1,4 @@
-/**
+/**
  * Staging, unstaging and discarding at hunk / line granularity.
  *
  * Each operation is a patch fed to `git apply` on stdin. `simple-git` has no
@@ -51,7 +51,7 @@ interface GitResult {
  *
  * Chunks are collected as `Buffer` and decoded **once**. Decoding each chunk as
  * it arrives (`stdout += c.toString()`) splits any multi-byte sequence that
- * straddles a chunk boundary into two invalid halves, which become U+FFFD — and
+ * straddles a chunk boundary into two invalid halves, which become U+FFFD — and
  * because a patch built from that text still *applies*, the corruption lands in
  * the index with no error anywhere. Measured on a 2 MB all-Japanese diff: 43
  * mangled lines.
@@ -59,7 +59,7 @@ interface GitResult {
  * The decode is **latin1**, not utf8, so it is a lossless byte round-trip: the
  * patch written back to `git apply` is the bytes git gave us, whatever the
  * file's encoding actually is (a Latin-1 file could not be hunk-staged at all
- * before). Everything the parser looks at — `@@`, `+`, `-`, `\` — is ASCII and
+ * before). Everything the parser looks at — `@@`, `+`, `-`, `\` — is ASCII and
  * reads the same either way. Only text leaving for the browser is turned back
  * into UTF-8, by `toDisplay` below.
  */
@@ -136,7 +136,7 @@ class GitHunksService {
    * is describing a file rather than changing one: doing it to the user's index
    * turns `?? file` into `A file` behind their back, on nothing more than
    * opening a dialog, and the exit code went unread so a failure showed up as
-   * "no changes" instead. It goes into a throwaway index instead — git reads the
+   * "no changes" instead. It goes into a throwaway index instead — git reads the
    * same config and the same `.gitattributes`, normalises line endings the same
    * way and produces the same bytes, while the real index is never opened for
    * writing. `git apply --cached` needs no entry of its own to add a new file,
@@ -181,7 +181,7 @@ class GitHunksService {
       // Belt and braces: a future flag or a repository config that reintroduces
       // rename headers must fail loudly rather than reach `git apply --reverse`.
       if (/^rename (from|to) /m.test(res.stdout)) {
-        throw new Error("This file was renamed — stage or unstage it whole rather than by hunk.");
+        throw new Error("This file was renamed — stage or unstage it whole rather than by hunk.");
       }
       return res.stdout;
     } finally {
@@ -213,20 +213,23 @@ class GitHunksService {
     filePath: string,
     scope: HunkScope,
     requested: HunkRequest[],
-    apply: { cached: boolean; reverse: boolean },
+    apply: { cached: boolean; reverse: boolean; refuseMoved?: boolean },
   ): Promise<void> {
     assertSafeFilePath(filePath);
     if (requested.length === 0) throw new Error("No hunks were selected.");
 
     const parsed = parseUnifiedDiff(await this.rawDiff(projectPath, filePath, scope));
-    if (parsed.binary) throw new Error("A binary file cannot be staged by hunk — stage the whole file.");
+    if (parsed.binary) throw new Error("A binary file cannot be staged by hunk — stage the whole file.");
     if (parsed.hunks.length === 0) throw new Error("This file has no changes to apply.");
 
     // The client's indexes describe the diff it was *shown*; this diff was read
     // again just now. Resolving by content is what makes the two the same list
-    // — or refuses. `git apply` cannot be the guard here, because the patch is
+    // — or refuses. `git apply` cannot be the guard here, because the patch is
     // built from this fresh parse and therefore always applies cleanly.
-    const selection = selectionFromRequest(parsed, resolveRequestedHunks(parsed, requested));
+    const selection = selectionFromRequest(
+      parsed,
+      resolveRequestedHunks(parsed, requested, { refuseMoved: apply.refuseMoved }),
+    );
     const patch = buildPatch(parsed, selection, { reverse: apply.reverse });
     if (!patch) throw new Error("The selection contains no actual change.");
 
@@ -255,10 +258,22 @@ class GitHunksService {
     await this.applySelection(projectPath, filePath, "index", hunks, { cached: true, reverse: true });
   }
 
-  /** Throw away the selected worktree changes. Not recoverable. */
+  /**
+   * Throw away the selected worktree changes. Not recoverable.
+   *
+   * `refuseMoved` is what separates this from the other two: they can be undone
+   * by staging or unstaging again, so following a hunk that shifted position is
+   * a convenience. Here there is no reflog and no undo, so a hunk that is not
+   * where the client saw it is refused rather than guessed at.
+   */
   async discard(projectPath: string, filePath: string, hunks: HunkRequest[]): Promise<void> {
-    await this.applySelection(projectPath, filePath, "worktree", hunks, { cached: false, reverse: true });
+    await this.applySelection(projectPath, filePath, "worktree", hunks, {
+      cached: false,
+      reverse: true,
+      refuseMoved: true,
+    });
   }
 }
 
 export const gitHunksService = new GitHunksService();
+

package/src/services/git-hunks/unified-diff.ts

@@ -334,6 +334,7 @@ export function hunkFingerprint(hunk: DiffHunk): string {
 export function resolveRequestedHunks(
   parsed: ParsedDiff,
   requested: { hunk: number; id: string; lines?: number[] }[],
+  opts?: { refuseMoved?: boolean },
 ): { hunk: number; lines?: number[] }[] {
   const fingerprints = parsed.hunks.map(hunkFingerprint);
   const taken = new Set<number>();
@@ -352,7 +353,20 @@ export function resolveRequestedHunks(
     }
     // The same edit can appear twice in one file; prefer the position the
     // client actually saw it at before falling back to the first free match.
-    const index = candidates.includes(entry.hunk) ? entry.hunk : candidates[0]!;
+    const atClientIndex = candidates.includes(entry.hunk);
+    if (!atClientIndex && opts?.refuseMoved) {
+      // The fingerprint is content only, so two identical edits in one file are
+      // the same value here. That makes "the hunk you ticked moved down the
+      // list" and "the copy you ticked is gone, this is the other one"
+      // indistinguishable — both leave one free candidate at a different index.
+      // Following it is right when the change can be undone and wrong when it
+      // cannot, so the caller with no reflog behind it asks the user to look
+      // again instead.
+      throw new Error(
+        "This change moved in the file since it was listed, and the same edit can appear more than once. Reload and pick it again.",
+      );
+    }
+    const index = atClientIndex ? entry.hunk : candidates[0]!;
     taken.add(index);
     return entry.lines ? { hunk: index, lines: entry.lines } : { hunk: index };
   });

package/src/services/git.service.ts

@@ -1,6 +1,8 @@
 import path from "node:path";
 import simpleGit, { type SimpleGit } from "simple-git";
+import { isBinaryContent } from "./binary-content.ts";
 import type {
+  FileFullDiff,
   GitStatus,
   GitFileChange,
   GitCommit,
@@ -9,6 +11,23 @@ import type {
   GitWorktree,
 } from "../types/git.ts";
 
+
+/**
+ * `filePath` resolved inside `projectPath`, or null when it escapes.
+ *
+ * Containment is asked of `relative`, not of a string prefix: a prefix compare
+ * built with a forward slash rejects every path on Windows, where `resolve`
+ * answers with backslashes — the same trap `assertSafeFilePaths` in the git
+ * graph extension documents.
+ */
+function insideProject(projectPath: string, filePath: string): string | null {
+  if (!filePath || path.isAbsolute(filePath) || filePath.includes("\0")) return null;
+  const resolved = path.resolve(projectPath, filePath);
+  const rel = path.relative(projectPath, resolved);
+  if (rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) return null;
+  return resolved;
+}
+
 class GitService {
   private git(projectPath: string): SimpleGit {
     return simpleGit(projectPath);
@@ -125,48 +144,79 @@ class GitService {
     return files;
   }
 
+  /**
+   * The file at a revision, as bytes — null when it does not exist there.
+   *
+   * `showBuffer` rather than `show`: the string form is stdout decoded as
+   * UTF-8, which destroys every byte of a binary file before anything can even
+   * tell that it is one.
+   */
+  async fileBlob(projectPath: string, filePath: string, ref: string): Promise<Uint8Array | null> {
+    try {
+      return await this.git(projectPath).showBuffer([`${ref}:${filePath}`]);
+    } catch {
+      // Absent at that revision (added, renamed, or a ref that resolves to
+      // nothing), which is not an error — the other side still has content.
+      return null;
+    }
+  }
+
   /**
    * Returns full file contents for both sides of a diff (VSCode-style).
    * - original: file at HEAD (empty if new/untracked/ref missing)
    * - modified: working tree content (empty if deleted on disk)
    * Monaco DiffEditor will compute/render the diff from these full contents.
+   *
+   * Both sides are read as bytes so a binary file can be *recognised* as one,
+   * and its content is then withheld unless `opts.text` asks for it — see
+   * `FileFullDiff`.
    */
   async fileFullDiff(
     projectPath: string,
     filePath: string,
     ref: string = "HEAD",
     ref2?: string,
-  ): Promise<{ original: string; modified: string }> {
-    const git = this.git(projectPath);
+    opts: { text?: boolean } = {},
+  ): Promise<FileFullDiff> {
+    const original = await this.fileBlob(projectPath, filePath, ref);
 
-    let original = "";
-    try {
-      original = await git.show([`${ref}:${filePath}`]);
-    } catch {
-      // File does not exist at ref (new/untracked/added) → empty original
-      original = "";
-    }
-
-    let modified = "";
+    let modified: Uint8Array | null = null;
     if (ref2) {
       // Commit-to-commit diff: read modified from git object store
-      try {
-        modified = await git.show([`${ref2}:${filePath}`]);
-      } catch {
-        modified = "";
-      }
+      modified = await this.fileBlob(projectPath, filePath, ref2);
     } else {
-      // Working tree diff: read from disk
-      try {
-        const absPath = path.resolve(projectPath, filePath);
-        const f = Bun.file(absPath);
-        if (await f.exists()) modified = await f.text();
-      } catch {
-        modified = "";
+      // Working tree diff: read from disk.
+      //
+      // The only side of this function that touches the filesystem directly,
+      // and therefore the only one needing a containment check: git refuses
+      // `HEAD:../secret.txt` itself, but `path.resolve` is happy to answer with
+      // anything the caller asks for and `filePath` arrives from a query
+      // string. `fileFullDiff(repo, "../secret.txt", "HEAD")` returned that
+      // file's contents. PPM is routinely reached through a public tunnel URL,
+      // so "behind auth" is not the whole story.
+      const onDisk = insideProject(projectPath, filePath);
+      if (onDisk) {
+        try {
+          const f = Bun.file(onDisk);
+          if (await f.exists()) modified = await f.bytes();
+        } catch {
+          modified = null;
+        }
       }
     }
 
-    return { original, modified };
+    const binary = isBinaryContent(original) || isBinaryContent(modified);
+    const withhold = binary && !opts.text;
+    const decode = (bytes: Uint8Array | null) =>
+      bytes && !withhold ? new TextDecoder().decode(bytes) : "";
+
+    return {
+      original: decode(original),
+      modified: decode(modified),
+      binary,
+      originalSize: original?.length ?? null,
+      modifiedSize: modified?.length ?? null,
+    };
   }
 
   async fileDiff(