@kabmo-labs/kabmo 0.0.0-stage → 0.0.1

package/src/server/lib/fs/git-log.test.ts

@@ -0,0 +1,337 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Commit-history paging against a real repository.
+ *
+ * Two failures have already shipped from this file: an empty stdout was
+ * replaced with 20 rows from a different repository (so every real history
+ * ended with foreign commits), and a branch with no commits was read as a git
+ * failure rather than an empty history. These tests run a REAL repository in a
+ * temp dir and pin the page/next-cursor contract (`limit`/`skip`/`hasMore`/
+ * `total`), the merge/rename/delete rows, the empty and single-commit
+ * repositories, and the MOCK-only sample fallback. The parser's own shapes —
+ * the empty input, the body fence — live in `git-log-parse.test.ts`.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fetchFileDiff, fetchGitCommits, readHeadCommitMessage } from '@/server/lib/fs/git-log';
+import { SAMPLE_GIT_COMMITS } from '@/client/data/mock/git-commits';
+import { removeDir } from '@/test-support/remove-dir';
+
+const tempDirs: string[] = [];
+
+/**
+ * Budget for a hook that SEEDS a repository.
+ *
+ * Each one runs a dozen `git` spawns back to back (`init`, `add`, `commit`,
+ * `rev-parse`, …), and on a Windows runner a single spawn costs an order of
+ * magnitude more than on Linux — measured: the diff fixture crossed Bun's
+ * default 5 s hook budget on `Gates / Checks (Windows)` and the suite failed
+ * with "a beforeEach/afterEach hook timed out", which names the wrong thing and
+ * hides the cause. The budget is the fixture's, not the code's: every assertion
+ * still runs on its own default timeout.
+ */
+const SEED_TIMEOUT_MS = 120_000;
+
+function tempDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kabmo-gitlog-'));
+  tempDirs.push(dir);
+  return dir;
+}
+
+/** Monotonic clock so commit dates — and therefore --date-order — are fixed. */
+let clock = 0;
+
+function git(cwd: string, ...args: string[]): string {
+  const stamp = new Date(Date.UTC(2024, 0, 1, 0, 0, clock++)).toISOString();
+  const result = Bun.spawnSync({
+    cmd: ['git', ...args],
+    cwd,
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Test',
+      GIT_AUTHOR_EMAIL: 'test@example.invalid',
+      GIT_COMMITTER_NAME: 'Test',
+      GIT_COMMITTER_EMAIL: 'test@example.invalid',
+      GIT_AUTHOR_DATE: stamp,
+      GIT_COMMITTER_DATE: stamp,
+    },
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`git ${args.join(' ')} failed: ${result.stderr.toString()}`);
+  }
+  return result.stdout.toString();
+}
+
+function initRepo(dir: string): void {
+  git(dir, 'init', '-q', '-b', 'main');
+}
+
+function write(dir: string, rel: string, content: string): void {
+  const full = path.join(dir, rel);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content);
+}
+
+function commitAll(dir: string, message: string): void {
+  git(dir, 'add', '-A');
+  git(dir, 'commit', '-q', '-m', message);
+}
+
+afterAll(() => {
+  for (const dir of tempDirs) removeDir(dir);
+});
+
+describe('fetchGitCommits against a real repository', () => {
+  const repo = tempDir();
+
+  beforeAll(() => {
+    initRepo(repo);
+    write(repo, 'base.txt', 'base\n');
+    commitAll(repo, 'c1 base');
+    write(repo, 'added.txt', 'added\n');
+    commitAll(repo, 'c2 add');
+    write(repo, 'gone.txt', 'g1\ng2\n');
+    commitAll(repo, 'c3 add gone');
+    git(repo, 'rm', '-q', 'gone.txt');
+    commitAll(repo, 'c4 delete gone');
+    write(repo, 'old.txt', 'r\n');
+    commitAll(repo, 'c5 add old');
+    git(repo, 'mv', 'old.txt', 'new.txt');
+    commitAll(repo, 'c6 rename old');
+    git(repo, 'checkout', '-q', '-b', 'feature');
+    write(repo, 'feature.txt', 'f\n');
+    commitAll(repo, 'c7 feature');
+    git(repo, 'checkout', '-q', 'main');
+    write(repo, 'main-only.txt', 'm\n');
+    commitAll(repo, 'c8 main only');
+    git(repo, 'merge', '-q', '--no-ff', 'feature', '-m', 'c9 merge feature');
+  }, SEED_TIMEOUT_MS);
+
+  test('the first page is the newest commits and carries the real total', async () => {
+    const page = await fetchGitCommits(repo, 2, 0);
+    expect(page.commits).toHaveLength(2);
+    expect(page.commits[0].message).toBe('c9 merge feature');
+    expect(page.total).toBe(9);
+    expect(page.hasMore).toBe(true);
+  });
+
+  test('skip walks the pages without dropping or repeating the boundary', async () => {
+    const first = await fetchGitCommits(repo, 2, 0);
+    const second = await fetchGitCommits(repo, 2, 2);
+    expect(second.commits).toHaveLength(2);
+    expect(second.hasMore).toBe(true);
+    const seen = new Set([...first.commits, ...second.commits].map((c) => c.hash));
+    expect(seen.size).toBe(4);
+  });
+
+  test('the last page does not claim there is more', async () => {
+    const page = await fetchGitCommits(repo, 2, 8);
+    expect(page.commits).toHaveLength(1);
+    expect(page.hasMore).toBe(false);
+    expect(page.total).toBe(9);
+  });
+
+  test('a skip past the end yields no rows but keeps the total', async () => {
+    const page = await fetchGitCommits(repo, 2, 9);
+    expect(page.commits).toEqual([]);
+    expect(page.hasMore).toBe(false);
+    expect(page.total).toBe(9);
+  });
+
+  test('the default page size returns the whole small history', async () => {
+    const page = await fetchGitCommits(repo);
+    expect(page.commits).toHaveLength(9);
+    expect(page.hasMore).toBe(false);
+  });
+
+  test('a merge commit carries both parents and no file rows', async () => {
+    const { commits } = await fetchGitCommits(repo, 20, 0);
+    const merge = commits.find((c) => c.message === 'c9 merge feature');
+    expect(merge?.parents).toHaveLength(2);
+    expect(merge?.files).toEqual([]);
+  });
+
+  test('rename and delete rows keep their numstat statuses', async () => {
+    const { commits } = await fetchGitCommits(repo, 20, 0);
+    const rename = commits.find((c) => c.message === 'c6 rename old');
+    expect(rename?.files).toEqual([
+      { file: 'old.txt => new.txt', status: 'R', additions: 0, deletions: 0 },
+    ]);
+    const remove = commits.find((c) => c.message === 'c4 delete gone');
+    expect(remove?.files).toEqual([
+      { file: 'gone.txt', status: 'D', additions: 0, deletions: 2 },
+    ]);
+  });
+
+  test('an added file is reported as an addition', async () => {
+    const { commits } = await fetchGitCommits(repo, 20, 0);
+    const add = commits.find((c) => c.message === 'c2 add');
+    expect(add?.files).toEqual([
+      { file: 'added.txt', status: 'A', additions: 1, deletions: 0 },
+    ]);
+  });
+});
+
+describe('empty and single-commit repositories', () => {
+  test('a repository with no commits is an empty history', async () => {
+    const repo = tempDir();
+    initRepo(repo);
+    expect(await fetchGitCommits(repo, 5, 0)).toEqual({ commits: [], hasMore: false, total: 0 });
+  });
+
+  test('a repository with one commit reports no more pages', async () => {
+    const repo = tempDir();
+    initRepo(repo);
+    write(repo, 'only.txt', 'one\n');
+    commitAll(repo, 'only');
+    const page = await fetchGitCommits(repo, 5, 0);
+    expect(page.commits).toHaveLength(1);
+    expect(page.commits[0].message).toBe('only');
+    expect(page.hasMore).toBe(false);
+    expect(page.total).toBe(1);
+  });
+});
+
+describe('a commit body travels with the page', () => {
+  const repo = tempDir();
+
+  beforeAll(() => {
+    initRepo(repo);
+    write(repo, 'a.txt', 'a\n');
+    git(repo, 'add', '-A');
+    git(repo, 'commit', '-q', '-m', 'subject line', '-m', 'body para one\n\nbody para two with a tab:\n\tindented');
+    write(repo, 'b.txt', 'b\n');
+    commitAll(repo, 'one line only');
+  }, SEED_TIMEOUT_MS);
+
+  test('the multi-line body is parsed out of the log format', async () => {
+    const { commits } = await fetchGitCommits(repo, 10, 0);
+    const withBody = commits.find((c) => c.message === 'subject line');
+    expect(withBody?.body).toBe('body para one\n\nbody para two with a tab:\n\tindented');
+  });
+
+  test('a one-line commit carries no body', async () => {
+    const { commits } = await fetchGitCommits(repo, 10, 0);
+    const single = commits.find((c) => c.message === 'one line only');
+    expect(single?.body).toBeUndefined();
+  });
+});
+
+describe('readHeadCommitMessage', () => {
+  test('a multi-line HEAD message round-trips whole, subject and body', async () => {
+    const repo = tempDir();
+    initRepo(repo);
+    write(repo, 'a.txt', 'a\n');
+    git(repo, 'add', '-A');
+    git(repo, 'commit', '-q', '-m', 'the subject', '-m', 'the body para');
+    // The amend REPLACES the message, so seeding only the subject would drop
+    // the body it replaced.
+    expect(await readHeadCommitMessage(repo)).toBe('the subject\n\nthe body para');
+  });
+
+  test('HEAD is the newest commit, not the first', async () => {
+    const repo = tempDir();
+    initRepo(repo);
+    write(repo, 'a.txt', 'a\n');
+    commitAll(repo, 'oldest');
+    write(repo, 'b.txt', 'b\n');
+    commitAll(repo, 'newest');
+    expect(await readHeadCommitMessage(repo)).toBe('newest');
+  });
+
+  test('a repository with no commits answers null, not an empty draft', async () => {
+    const repo = tempDir();
+    initRepo(repo);
+    // `git log` exits 128 on an unborn HEAD; the panel must leave the draft
+    // alone rather than seeding an empty message over the placeholder.
+    expect(await readHeadCommitMessage(repo)).toBeNull();
+  });
+});
+
+describe('fetchFileDiff commit patches', () => {
+  const repo = tempDir();
+  let addedHash = '';
+  let deletedHash = '';
+  let renameHash = '';
+
+  beforeAll(() => {
+    initRepo(repo);
+    write(repo, 'base.txt', 'base\n');
+    commitAll(repo, 'base');
+    write(repo, 'added.txt', 'added\n');
+    commitAll(repo, 'add');
+    addedHash = git(repo, 'rev-parse', 'HEAD').trim();
+    write(repo, 'gone.txt', 'g1\ng2\n');
+    commitAll(repo, 'add gone');
+    git(repo, 'rm', '-q', 'gone.txt');
+    commitAll(repo, 'remove gone');
+    deletedHash = git(repo, 'rev-parse', 'HEAD').trim();
+    write(repo, 'old.txt', 'renamed content\n');
+    commitAll(repo, 'add old');
+    git(repo, 'mv', 'old.txt', 'new.txt');
+    commitAll(repo, 'rename old');
+    renameHash = git(repo, 'rev-parse', 'HEAD').trim();
+  }, SEED_TIMEOUT_MS);
+
+  test('an added file yields its creation patch', async () => {
+    const diff = await fetchFileDiff(repo, addedHash, 'added.txt');
+    expect(diff).toContain('new file mode');
+    expect(diff).toContain('+added');
+  });
+
+  test('a deleted file yields its removal patch', async () => {
+    const diff = await fetchFileDiff(repo, deletedHash, 'gone.txt');
+    expect(diff).toContain('deleted file mode');
+    expect(diff).toContain('-g1');
+    expect(diff).toContain('-g2');
+  });
+
+  test('a numstat rename path is resolved to the new name', async () => {
+    const diff = await fetchFileDiff(repo, renameHash, 'old.txt => new.txt');
+    expect(diff).toContain('renamed content');
+  });
+
+  test('an unknown revision falls back to a readable stub, not a throw', async () => {
+    const diff = await fetchFileDiff(repo, 'deadbeefdeadbeef', 'nope.txt');
+    expect(diff).toContain('@@ -0,0 +1,6 @@');
+    expect(diff).toContain('// File: nope.txt');
+    expect(diff).toContain('// Commit: deadbeef');
+  });
+});
+
+describe('the sample fallback is reserved for MOCK mode', () => {
+  const missing = path.join(os.tmpdir(), 'kabmo-gitlog-does-not-exist');
+
+  function withMock(value: string | undefined, fn: () => Promise<void>): Promise<void> {
+    const previous = Bun.env.MOCK;
+    if (value === undefined) delete Bun.env.MOCK;
+    else Bun.env.MOCK = value;
+    return fn().finally(() => {
+      if (previous === undefined) delete Bun.env.MOCK;
+      else Bun.env.MOCK = previous;
+    });
+  }
+
+  test('a git failure in real mode answers empty, never sample rows', async () => {
+    await withMock(undefined, async () => {
+      expect(await fetchGitCommits(missing, 5, 0)).toEqual({ commits: [], hasMore: false, total: 0 });
+    });
+  });
+
+  test('MOCK mode answers a paged slice of the samples', async () => {
+    await withMock('true', async () => {
+      const page = await fetchGitCommits(missing, 3, 1);
+      expect(page.commits).toHaveLength(3);
+      expect(page.commits[0].hash).toBe(SAMPLE_GIT_COMMITS[1].hash);
+      expect(page.total).toBe(SAMPLE_GIT_COMMITS.length);
+      expect(page.hasMore).toBe(true);
+    });
+  });
+});

package/src/server/lib/fs/git-log.ts

@@ -0,0 +1,335 @@
+import path from 'path';
+import type { GitCommit, GitCommitFile } from '@/shared/types/git';
+import { COMMIT_PAGE_SIZE } from '@/shared/lib/fs/commit-page';
+import { SAMPLE_GIT_COMMITS } from '@/client/data/mock/git-commits';
+import { isMockMode } from '@/server/mock.server';
+import { runShell, shellOk } from '@/server/lib/fs/shell';
+import { GIT_ENV, runGit } from '@/server/lib/fs/git-run';
+
+/**
+ * Header/body and record separators in the `git log` format below.
+ *
+ * The body is multi-line and a body line may itself contain a TAB (indented
+ * lists, aligned blocks), which the numstat branch below would otherwise read
+ * as a changed-file row. So the body is fenced instead of guessed: `\x1f`
+ * opens it after the header's last field and `\x1e` closes it — both
+ * non-printable, so neither can appear in a commit message.
+ */
+const HEADER_BODY_SEP = '\x1f';
+const COMMIT_RECORD_SEP = '\x1e';
+
+/**
+ * The status letters a `--raw` row can carry, folded to the four the file row
+ * draws.
+ *
+ * `C` (a detected copy) is a NEW file and `T` (a type change, file↔symlink) is
+ * a modification; anything else git may print (`U` unmerged, `X`) is reported
+ * as `M` rather than invented.
+ */
+const RAW_STATUS_LETTERS: Record<string, string> = { A: 'A', C: 'A', D: 'D', R: 'R' };
+
+/**
+ * Read the status letter off one `--raw` row:
+ * `:<srcmode> <dstmode> <srcsha> <dstsha> <status>\t<path>` — the rename form
+ * carries the old and new path after the same TAB, which is why only the field
+ * before it is read.
+ *
+ * This is the ONLY trustworthy source of a file's state. `--numstat` reports
+ * additions and deletions and nothing else, so a modified file that only lost
+ * lines (`0\t3\tf.txt`) is indistinguishable from a deletion by its counts —
+ * which is how an `M` came to render as a `D`.
+ */
+function parseRawStatus(line: string): string | null {
+  if (!line.startsWith(':')) return null;
+  const tab = line.indexOf('\t');
+  if (tab < 0) return null;
+  const meta = line.slice(0, tab).split(' ');
+  const code = meta[meta.length - 1] || '';
+  const letter = code.charAt(0).toUpperCase();
+  if (!letter) return null;
+  return RAW_STATUS_LETTERS[letter] ?? 'M';
+}
+
+/**
+ * Context lines requested by "Expand all context".
+ *
+ * `git show`'s default is three, which is the whole patch a commit row can
+ * reveal — so the button had nothing to expand. `-U` takes any count, so this
+ * is a cap on the FILE, not on the change.
+ */
+const FULL_DIFF_CONTEXT = 1000000;
+
+export function parseGitLogOutput(stdout: string): GitCommit[] {
+  const commits: GitCommit[] = [];
+  const lines = stdout.split('\n');
+  let currentCommit: GitCommit | null = null;
+  let bodyLines: string[] = [];
+  let inBody = false;
+  // `--raw` and `--numstat` are emitted as two blocks per commit — one row per
+  // file in each, in the same order — so they are collected separately and
+  // zipped when the commit flushes. The status letter comes from git itself;
+  // only the counts and the rendered path come from numstat.
+  let rawStatuses: string[] = [];
+  let numstatRows: GitCommitFile[] = [];
+
+  const flush = () => {
+    if (!currentCommit) return;
+    // `%b` ends with the newline that separates it from the next field, so the
+    // trailing blank lines are the format's, not the author's. A one-line
+    // commit keeps no `body` at all rather than an empty string, which is what
+    // the row's expand affordance keys off.
+    const body = bodyLines.join('\n').trimEnd();
+    if (body) currentCommit.body = body;
+    currentCommit.files = numstatRows.map((row, i) => ({
+      ...row,
+      status: rawStatuses[i] ?? row.status,
+    }));
+    commits.push(currentCommit);
+  };
+
+  for (const line of lines) {
+    if (line.startsWith('COMMIT_SPLIT|~|')) {
+      flush();
+      const sepIdx = line.indexOf(HEADER_BODY_SEP);
+      const header = sepIdx >= 0 ? line.slice(0, sepIdx) : line;
+      const rest = sepIdx >= 0 ? line.slice(sepIdx + 1) : '';
+      const parts = header.split('|~|');
+      const hash = parts[1] || '';
+      const shortHash = parts[2] || hash.slice(0, 8);
+      const author = parts[3] || 'Unknown';
+      const date = parts[4] || '';
+      const message = parts[5] || '';
+      const refStr = parts[6] || '';
+      const parentStr = parts[7] || '';
+
+      const refs = refStr
+        ? refStr
+            .split(',')
+            .map(r => r.trim())
+            .filter(Boolean)
+        : [];
+      const parents = parentStr
+        ? parentStr
+            .split(/\s+/)
+            .map(p => p.trim())
+            .filter(Boolean)
+        : [];
+
+      currentCommit = {
+        hash,
+        shortHash,
+        author,
+        date,
+        message,
+        refs,
+        parents,
+        files: [],
+      };
+      rawStatuses = [];
+      numstatRows = [];
+      // The header's last field is followed by the separator, so the body
+      // begins on this same line (`%b`'s first line) and continues on the next
+      // ones. A commit with no body still emits the record separator here, so
+      // the terminator is looked for on this line too — otherwise the first
+      // numstat row would be read as body text.
+      const bodyEnd = rest.indexOf(COMMIT_RECORD_SEP);
+      if (bodyEnd >= 0) {
+        bodyLines = rest.slice(0, bodyEnd) ? [rest.slice(0, bodyEnd)] : [];
+        inBody = false;
+      } else {
+        bodyLines = rest ? [rest] : [];
+        inBody = sepIdx >= 0;
+      }
+    } else if (inBody) {
+      const end = line.indexOf(COMMIT_RECORD_SEP);
+      if (end >= 0) {
+        bodyLines.push(line.slice(0, end));
+        inBody = false;
+      } else {
+        bodyLines.push(line);
+      }
+    } else if (currentCommit && line.startsWith(':')) {
+      // A `--raw` row. Read BEFORE the numstat branch: a raw RENAME row also
+      // holds three TAB-separated fields (the status, the old path, the new
+      // one), so it would otherwise be read as a numstat row.
+      const status = parseRawStatus(line);
+      if (status) rawStatuses.push(status);
+    } else if (currentCommit && line.trim()) {
+      const parts = line.split('\t');
+      if (parts.length >= 3) {
+        const additions = parts[0] === '-' ? 0 : parseInt(parts[0], 10) || 0;
+        const deletions = parts[1] === '-' ? 0 : parseInt(parts[1], 10) || 0;
+        let file = parts[2].trim();
+        if (file.startsWith('"') && file.endsWith('"')) {
+          try { file = JSON.parse(file); } catch {}
+        }
+        numstatRows.push({ file, status: 'M', additions, deletions });
+      }
+    }
+  }
+
+  flush();
+
+  // An empty stdout is a real answer — `--skip` past the end of history, or a
+  // branch with no commits — so it parses to no rows. This used to return
+  // SAMPLE_GIT_COMMITS, which put 20 commits from a different repository at the
+  // bottom of every history and in every graph, in real mode too.
+  return commits;
+}
+
+export interface FetchCommitsResult {
+  commits: GitCommit[];
+  hasMore: boolean;
+  total?: number;
+}
+
+export async function fetchGitCommits(
+  targetDir: string,
+  limit: number = COMMIT_PAGE_SIZE,
+  skip: number = 0
+): Promise<FetchCommitsResult> {
+  try {
+    let total = 0;
+    try {
+      const countOut = await runShell('git rev-list --count HEAD', { cwd: targetDir, timeout: 5000, env: GIT_ENV });
+      if (shellOk(countOut)) total = parseInt(countOut.stdout.trim(), 10) || 0;
+    } catch {
+      total = 0;
+    }
+
+    const result = await runShell(
+      `git log -n ${limit} --skip=${skip} --raw --numstat --date-order --pretty=format:"COMMIT_SPLIT|~|%H|~|%h|~|%an|~|%ad|~|%s|~|%D|~|%p%x1f%b%x1e" --date=format:"%b %d, %Y, %I:%M %p"`,
+      { cwd: targetDir, timeout: 15000 }
+    );
+
+    // A branch with no commits makes `git log` exit non-zero with "does not
+    // have any commits yet" — an empty history, not a failure. Reading it as a
+    // failure is what let the mock fallback below answer for a real repository.
+    if (!shellOk(result)) {
+      if (total === 0 && (await hasNoCommits(targetDir))) return { commits: [], hasMore: false, total: 0 };
+      throw new Error(result.stderr || 'git log failed');
+    }
+
+    const commits = parseGitLogOutput(result.stdout);
+    const hasMore = total > 0 ? skip + commits.length < total : commits.length === limit;
+    return { commits, hasMore, total };
+  } catch {
+    // Reached only when git could not answer at all (not a repository, a bad
+    // revision, a timeout). Mock rows are reserved for MOCK mode, where the
+    // whole Kabmo runs on presets — returning them here showed 20 commits
+    // from an unrelated repository in real mode.
+    if (isMockMode()) {
+      const paged = SAMPLE_GIT_COMMITS.slice(skip, skip + limit);
+      return {
+        commits: paged,
+        hasMore: skip + paged.length < SAMPLE_GIT_COMMITS.length,
+        total: SAMPLE_GIT_COMMITS.length,
+      };
+    }
+    return { commits: [], hasMore: false, total: 0 };
+  }
+}
+
+/** True when `HEAD` resolves to nothing — a repository with no commits yet. */
+async function hasNoCommits(targetDir: string): Promise<boolean> {
+  const out = await runShell('git rev-parse --verify HEAD', { cwd: targetDir, timeout: 5000, env: GIT_ENV });
+  return !shellOk(out);
+}
+
+/**
+ * The message of the commit `--amend` would rewrite — the draft the panel
+ * pre-fills when the user ticks Amend.
+ *
+ * Read ON DEMAND, never off the status payload: that read is republished on
+ * every tool call, and this is one `git log` per tick of a checkbox.
+ *
+ * `%B` is the raw body, so a multi-line message (and a merge commit's own
+ * message) round-trips intact — the amend replaces the whole message, so
+ * seeding only the subject would silently drop the body it replaced.
+ *
+ * `null` in a repository whose HEAD is unborn (`git log` exits 128 there):
+ * there is nothing to amend, so there is nothing to pre-fill. The panel leaves
+ * the draft alone rather than seeding an empty message.
+ */
+export async function readHeadCommitMessage(targetDir: string): Promise<string | null> {
+  const result = await runGit(['log', '-1', '--pretty=format:%B'], {
+    cwd: targetDir,
+    timeout: 5000,
+    maxBuffer: 1024 * 1024,
+  });
+  if (result.exitCode !== 0 || result.error) return null;
+  // Trailing whitespace only: git terminates `%B` with a newline, and leading
+  // indentation inside the message is the author's.
+  const message = result.stdout.replace(/\s+$/, '');
+  return message.length > 0 ? message : null;
+}
+
+/**
+ * The patch for one file in one commit.
+ *
+ * `fullContext` asks git for the whole file around the change (`-U<large>`),
+ * which is what the modal's "Expand all context" needs: `git show`'s default is
+ * three lines of context, so the button's promise is unreachable from the
+ * default patch — there is simply no more context in the payload to reveal.
+ */
+export async function fetchFileDiff(
+  targetDir: string,
+  hash: string,
+  file: string,
+  fullContext: boolean = false,
+): Promise<string> {
+  let cleanFile = file.replace(/^\.\//, '').trim();
+  const ctx = fullContext ? ` -U${FULL_DIFF_CONTEXT}` : '';
+
+  // If the file in numstat was a rename (e.g. "path/{old.ts => new.ts}" or "old.ts => new.ts")
+  if (cleanFile.includes(' => ')) {
+    if (cleanFile.includes('{') && cleanFile.includes('}')) {
+      cleanFile = cleanFile.replace(/\{.*? => (.*?)\}/, '$1');
+    } else {
+      cleanFile = cleanFile.split(' => ')[1].trim();
+    }
+  }
+
+  // 1. Try standard git show with pretty format patch
+  const showPatch = await runShell(`git show --pretty=format:"" --patch${ctx} "${hash}" -- "${cleanFile}"`, { cwd: targetDir, timeout: 10000, env: GIT_ENV });
+  if (showPatch.stdout.trim()) return showPatch.stdout.trim();
+
+  // 2. Try git diff-tree with root support
+  const diffTree = await runShell(`git diff-tree -r -p --root${ctx} "${hash}" -- "${cleanFile}"`, { cwd: targetDir, timeout: 10000, env: GIT_ENV });
+  if (diffTree.stdout.trim()) return diffTree.stdout.trim();
+
+  // 3. If it is an added file or root commit, show file content directly from git blob
+  const showBlob = await runShell(`git show "${hash}:${cleanFile}"`, { cwd: targetDir, timeout: 10000, env: GIT_ENV });
+  if (showBlob.stdout.length > 0) {
+    const lines = showBlob.stdout.split('\n');
+    const diffLines = lines.map((l) => `+${l}`).join('\n');
+    return `@@ -0,0 +1,${lines.length} @@\n${diffLines}`;
+  }
+
+  // 4. Try previous parent blob for deleted file
+  const showParent = await runShell(`git show "${hash}^:${cleanFile}"`, { cwd: targetDir, timeout: 10000, env: GIT_ENV });
+  if (showParent.stdout.length > 0) {
+    const lines = showParent.stdout.split('\n');
+    const diffLines = lines.map((l) => `-${l}`).join('\n');
+    return `@@ -1,${lines.length} +0,0 @@\n${diffLines}`;
+  }
+
+  // 5. Try reading directly from target filesystem if available
+  try {
+    const diskFile = Bun.file(path.join(targetDir, cleanFile));
+    if ((await diskFile.exists()) && !(await diskFile.stat()).isDirectory()) {
+      const content = await diskFile.text();
+      const lines = content.split('\n');
+      const diffLines = lines.map((l) => `+${l}`).join('\n');
+      return `@@ -0,0 +1,${lines.length} @@\n${diffLines}`;
+    }
+  } catch {}
+
+  // 6. Fall back to mock sample data if exists
+  const sample = SAMPLE_GIT_COMMITS.find(c => c.hash === hash || c.shortHash === hash || hash.startsWith(c.shortHash));
+  const sampleFile = sample?.files?.find(f => f.file === file || f.file === cleanFile);
+  if (sampleFile?.diff) return sampleFile.diff;
+
+  // 7. Generate readable sample diff
+  return `@@ -0,0 +1,6 @@\n+// File: ${cleanFile}\n+// Commit: ${hash.slice(0, 8)}\n+// Changes recorded for this commit\n+export const status = "synced";\n+console.log("Commit updated: ${cleanFile}");`;
+}