@fresh-editor/fresh-editor 0.3.6 → 0.3.8

package/plugins/git_log.ts

@@ -2,13 +2,10 @@
 
 import {
   type GitCommit,
-  buildCommitDetailEntries,
   buildCommitLogEntries,
-  buildDetailPlaceholderEntries,
-  fetchCommitShow,
   fetchGitLog,
 } from "./lib/git_history.ts";
-import { button, flexSpacer, key, list, row, WidgetPanel } from "./lib/index.ts";
+import { button, flexSpacer, list, row, WidgetPanel } from "./lib/index.ts";
 
 const editor = getEditor();
 
@@ -36,32 +33,42 @@ interface GitLogState {
   isOpen: boolean;
   groupId: number | null;
   logBufferId: number | null;
+  /**
+   * The buffer-group's initial detail panel buffer (a virtual buffer
+   * created by `createBufferGroup`). After the first commit is shown,
+   * the panel is retargeted at a file-backed streaming buffer via
+   * `setBufferGroupPanelBuffer`; this id is kept so we can close the
+   * orphaned virtual buffer on group teardown.
+   */
+  initialDetailBufferId: number | null;
+  /**
+   * The buffer id currently displayed in the detail panel (one
+   * file-backed buffer per visited commit). Tracked for focus checks
+   * and cursor placement.
+   */
   detailBufferId: number | null;
   toolbarBufferId: number | null;
-  /** Widget panel rendering the toolbar (Row of Buttons). Created in
-   * `show_git_log` once the buffer group exists; cleaned up in
-   * `git_log_close`. */
+  /** Widget panel rendering the toolbar (Row of Buttons). */
   toolbarPanel: WidgetPanel | null;
-  /** Widget panel rendering the log (List of commit rows). Owns
-   * `selected_index` + `scroll_offset` as instance state — the
-   * plugin's `state.selectedIndex` mirrors what the host reports
-   * via `widget_event "select"`. */
+  /** Widget panel rendering the log (List of commit rows). */
   logPanel: WidgetPanel | null;
   commits: GitCommit[];
   selectedIndex: number;
-  /** Cached `git show` output for the currently-displayed detail commit. */
-  detailCache: { hash: string; output: string } | null;
   /**
-   * In-flight detail request id. Used to ignore stale responses when the
-   * user scrolls through the log faster than `git show` can return.
+   * Per-commit cache: sha → file-backed buffer id. Each visited
+   * commit gets its own buffer pointing at `<dataDir>/git-show/<sha>.diff`,
+   * which a background `git show --patch` writes into. Returning to a
+   * cached commit is just a `setBufferGroupPanelBuffer` call — no
+   * git invocation, scroll position preserved.
    */
-  pendingDetailId: number;
+  commitBuffers: Map<string, number>;
+  /** sha → in-flight spawnProcess handle, for kill-on-supersession. */
+  inFlightSpawns: Map<string, ProcessHandle<SpawnResult>>;
   /**
    * Debounce token for List `select` events. Rapid selection moves
-   * (PageDown, held j/k) would otherwise trigger a full `git show`
-   * spawn per intermediate row; we bump this id on every event
-   * and only do the work after a short delay if no newer event
-   * has arrived.
+   * (PageDown, held j/k) shouldn't churn through buffer swaps + spawns;
+   * we bump this id on every event and only do the work after a short
+   * delay if no newer event has arrived.
    */
   pendingSelectId: number;
 }
@@ -70,14 +77,15 @@ const state: GitLogState = {
   isOpen: false,
   groupId: null,
   logBufferId: null,
+  initialDetailBufferId: null,
   detailBufferId: null,
   toolbarBufferId: null,
   toolbarPanel: null,
   logPanel: null,
   commits: [],
   selectedIndex: 0,
-  detailCache: null,
-  pendingDetailId: 0,
+  commitBuffers: new Map(),
+  inFlightSpawns: new Map(),
   pendingSelectId: 0,
 };
 
@@ -97,20 +105,23 @@ const SELECT_DEBOUNCE_MS = 60;
 // the log, and opens the file at the cursor when pressed in the detail).
 // =============================================================================
 
-// j/k/Up/Down/PageUp/PageDown route to the log List widget so the host
-// owns selection + scroll + auto-scroll. The List's `select` event then
-// fires back into the plugin's `widget_event` handler for detail-pane
-// refresh. Other plugin actions (q/r/y/Tab/Return) stay as direct
-// bindings — they don't depend on which row is highlighted.
+// The log pane is cursor-driven: j/k/Up/Down/PageUp/PageDown move the
+// pane's real buffer cursor (normal editor movement), which scrolls via
+// the standard `ensure_cursor_visible` wheel — only when the cursor
+// crosses the top/bottom edge. The cursor is the source of truth for
+// which commit is selected; a `cursor_moved` subscription mirrors its
+// line into the List highlight + detail pane. On the detail pane the
+// same keys scroll the diff. Other actions (q/r/y/Tab/Return) are direct
+// bindings — they don't depend on the cursor row.
 editor.defineMode(
   "git-log",
   [
-    ["k", "git_log_select_up"],
-    ["j", "git_log_select_down"],
-    ["Up", "git_log_select_up"],
-    ["Down", "git_log_select_down"],
-    ["PageUp", "git_log_select_page_up"],
-    ["PageDown", "git_log_select_page_down"],
+    ["k", "move_up"],
+    ["j", "move_down"],
+    ["Up", "move_up"],
+    ["Down", "move_down"],
+    ["PageUp", "move_page_up"],
+    ["PageDown", "move_page_down"],
     ["Return", "git_log_enter"],
     ["Tab", "git_log_tab"],
     ["q", "git_log_q"],
@@ -122,52 +133,6 @@ editor.defineMode(
   true, // inherit Normal-context bindings for unbound keys
 );
 
-function git_log_select_up(): void {
-  if (isLogPanelActive()) {
-    state.logPanel?.command(key("Up"));
-  } else {
-    editor.executeAction("move_up");
-  }
-}
-function git_log_select_down(): void {
-  if (isLogPanelActive()) {
-    state.logPanel?.command(key("Down"));
-  } else {
-    editor.executeAction("move_down");
-  }
-}
-function git_log_select_page_up(): void {
-  if (isLogPanelActive()) {
-    state.logPanel?.command(key("PageUp"));
-  } else {
-    editor.executeAction("page_up");
-  }
-}
-function git_log_select_page_down(): void {
-  if (isLogPanelActive()) {
-    state.logPanel?.command(key("PageDown"));
-  } else {
-    editor.executeAction("page_down");
-  }
-}
-
-/** True iff the log panel is the focused buffer in the group. The
- * group's bindings (j/k/Up/Down/PageUp/PageDown) apply to all panels
- * uniformly; we only want navigation to drive the List widget when
- * the user is *on* the log panel. From the detail panel, the same
- * keys must move the buffer cursor (so users can scroll the diff
- * before pressing Enter on a diff line to open the file view). */
-function isLogPanelActive(): boolean {
-  return (
-    state.logBufferId !== null &&
-    editor.getActiveBufferId() === state.logBufferId
-  );
-}
-registerHandler("git_log_select_up", git_log_select_up);
-registerHandler("git_log_select_down", git_log_select_down);
-registerHandler("git_log_select_page_up", git_log_select_page_up);
-registerHandler("git_log_select_page_down", git_log_select_page_down);
-
 // =============================================================================
 // Panel layout
 // =============================================================================
@@ -260,19 +225,13 @@ editor.on("widget_event", (data) => {
     }
     return;
   }
-  // Log pane (List of commit rows) — `select` fires on j/k/Up/Down/
-  // PageUp/PageDown navigation and on row clicks; `activate` fires on
-  // Enter or double-click.
+  // Log pane (List of commit rows). Selection is cursor-driven (see the
+  // `cursor_moved` handler), so the List's `select` event is ignored —
+  // a row click places the buffer cursor, and `cursor_moved` mirrors it
+  // into the selection. `activate` (Enter / double-click) still opens.
   if (state.logPanel !== null && data.panel_id === state.logPanel.id()) {
-    if (data.event_type === "select") {
-      const idx =
-        typeof data.payload?.index === "number" ? data.payload.index : -1;
-      if (idx >= 0) void on_log_select(idx);
-      return;
-    }
     if (data.event_type === "activate") {
       void git_log_enter();
-      return;
     }
     return;
   }
@@ -292,6 +251,11 @@ function detailFooter(hash: string): string {
   return editor.t("status.commit_ready", { hash });
 }
 
+/** Stable widget key for the log List. The host keys selection +
+ * scroll instance state off this; the plugin re-pins selection
+ * through it after click/keyboard `select` events. */
+const LOG_LIST_KEY = "git-log-list";
+
 function renderLog(): void {
   if (state.logPanel === null) return;
   // List takes the per-row entries directly. selectedIndex: -1 on the
@@ -313,87 +277,264 @@ function renderLog(): void {
       // scroll handle viewport. Revisit if commit lists grow into the
       // tens of thousands.
       visibleRows: Math.max(1, state.commits.length),
-      key: "git-log-list",
+      key: LOG_LIST_KEY,
     }),
   );
 }
 
-function renderDetailPlaceholder(message: string): void {
-  if (state.groupId === null) return;
-  editor.setPanelContent(
-    state.groupId,
-    "detail",
-    buildDetailPlaceholderEntries(message)
-  );
-}
+// =============================================================================
+// Streaming detail panel
+//
+// Per-commit cached file-backed buffers. On commit switch we either reuse
+// the existing cached buffer (instant) or spawn `git show --patch` into a
+// per-SHA file and open it via `openFileStreaming`, polling for growth
+// while git runs in the background. The buffer-group panel is re-pointed
+// at the chosen buffer via `setBufferGroupPanelBuffer` — the same single
+// tab keeps the side-by-side log/detail UX.
+// =============================================================================
 
-function renderDetailForCommit(commit: GitCommit, showOutput: string): void {
-  if (state.groupId === null) return;
-  const entries = buildCommitDetailEntries(commit, showOutput);
-  editor.setPanelContent(state.groupId, "detail", entries);
-  // Always scroll the detail panel back to the top when the selection changes.
-  if (state.detailBufferId !== null) {
-    editor.setBufferCursor(state.detailBufferId, 0);
-  }
+/**
+ * Path of the per-SHA cache file. Commits are immutable; once we've
+ * written one, repeat visits are zero-git.
+ */
+function cachePathForHash(hash: string): string {
+  // `<dataDir>/git-show/<sha>.diff` — the .diff extension lets the
+  // syntax-highlight grammar kick in for free.
+  return `${editor.getDataDir()}/git-show/${hash}.diff`;
 }
 
+/** Polling interval while git is still writing. ~5 fps is plenty. */
+const STREAM_POLL_MS = 200;
+
 /**
- * Synchronous detail refresh: render from cache if we have it, otherwise
- * a "loading…" placeholder. Never spawns git. Called immediately on every
- * selection change so the user sees instant feedback even while the real
- * `git show` is debounced.
+ * Start a `git show --patch` for `hash`, piping stdout straight into the
+ * cache file. Returns the handle so a later commit switch can `.kill()`
+ * the still-running spawn.
  *
- * Returns the commit that needs fetching (cache miss) or null (cache hit
- * or no commit selected) so the caller can decide whether to spawn.
+ * Caller has already verified the cache file doesn't yet exist (or wants
+ * to overwrite it).
  */
-function refreshDetailImmediate(): GitCommit | null {
-  if (state.groupId === null) return null;
-  if (state.commits.length === 0) {
-    renderDetailPlaceholder(editor.t("status.no_commits"));
-    return null;
-  }
-  const idx = Math.max(0, Math.min(state.selectedIndex, state.commits.length - 1));
-  const commit = state.commits[idx];
-  if (!commit) return null;
+function spawnGitShow(hash: string, cwd: string): ProcessHandle<SpawnResult> {
+  // `--stat --patch` matches what the previous plugin used. The stat
+  // header gives users a per-file changed-lines summary at the top
+  // of the diff and is also what `git show` produces by default, so
+  // its presence is what most readers (and tests) expect.
+  //
+  // The generated d.ts shows `spawnProcess(cmd, args, cwd?, stdoutTo?)`
+  // as flat positional args. The runtime JS wrapper also accepts an
+  // `{stdoutTo}` options object in the 4th slot, but using the flat
+  // form keeps the call type-checked without a cast.
+  return editor.spawnProcess(
+    "git",
+    ["show", "--stat", "--patch", hash],
+    cwd,
+    cachePathForHash(hash),
+  );
+}
+
+/**
+ * Poll `editor.refreshBufferFromDisk` until the spawn handle resolves,
+ * then do one final catch-up refresh. Returns immediately if the
+ * commit is no longer in flight (e.g. user moved on, kill() fired).
+ */
+async function pollUntilSpawnDone(
+  hash: string,
+  bufferId: number,
+  handle: ProcessHandle<SpawnResult>,
+): Promise<void> {
+  // Wrap the handle's settlement in a non-rejecting marker promise so
+  // a fast subscription loop can `await` it (or race it against a
+  // delay) without worrying about whether the spawn errored. The
+  // ProcessHandle is a thenable, not a real Promise, so adapt via
+  // Promise.resolve().
+  let done = false;
+  void Promise.resolve(handle).then(
+    () => {
+      done = true;
+    },
+    () => {
+      done = true;
+    },
+  );
 
-  if (state.detailCache && state.detailCache.hash === commit.hash) {
-    renderDetailForCommit(commit, state.detailCache.output);
-    return null;
+  while (!done) {
+    await editor.delay(STREAM_POLL_MS);
+    if (!state.isOpen) return; // group closed mid-stream
+    if (state.inFlightSpawns.get(hash) !== handle) return; // superseded
+    await editor.refreshBufferFromDisk(bufferId);
   }
+  // Final catch-up so any bytes written between the last poll and
+  // process exit are visible immediately.
+  await editor.refreshBufferFromDisk(bufferId);
+  // Done — clear the in-flight handle if it's still ours.
+  if (state.inFlightSpawns.get(hash) === handle) {
+    state.inFlightSpawns.delete(hash);
+  }
+  // Apply diff coloring once the buffer is complete. Doing this
+  // pre-completion would either churn (re-walk on every refresh) or
+  // double-overlay newly-extended lines; on completion we walk once.
+  await applyDiffHighlights(bufferId);
+}
 
-  renderDetailPlaceholder(
-    editor.t("status.loading_commit", { hash: commit.shortHash })
-  );
-  return commit;
+// =============================================================================
+// Diff syntax highlighting via per-line bg overlays
+//
+// Sublime-syntax's bundled `Diff` definition only scopes the `diff`
+// keyword, so themes only colour that. Plugins are responsible for the
+// rest — same approach `live_diff` uses for inline diff coloring in
+// regular buffers.
+//
+// One overlay per line of added/removed content is fine for the
+// "normal commit" workload but explodes on giant commits (the
+// rewrite-bun commit is 1M lines = 1M overlays = back to the old
+// 500k-overlay problem this rewire eliminated). Gate on buffer size;
+// gracefully degrade to no highlighting for outliers.
+// =============================================================================
+
+const HIGHLIGHT_BG_ADDED = "editor.diff_add_bg";
+const HIGHLIGHT_BG_REMOVED = "editor.diff_remove_bg";
+const HIGHLIGHT_BG_HUNK = "editor.diff_modify_bg";
+const HIGHLIGHT_NAMESPACE = "git-log-diff";
+/** Skip overlay highlighting above this size. ~256 KB covers
+ *  basically every hand-written commit comfortably; very large
+ *  generated-file diffs (lockfiles, minified code) just stay
+ *  uncoloured — the cost would be a few thousand-to-a-million
+ *  overlays for content the user mostly skims. */
+const HIGHLIGHT_MAX_BYTES = 256 * 1024;
+
+async function applyDiffHighlights(bufferId: number): Promise<void> {
+  const total = editor.getBufferLength(bufferId);
+  if (total === 0 || total > HIGHLIGHT_MAX_BYTES) return;
+  const text = await editor.getBufferText(bufferId, 0, total);
+  if (!text) return;
+
+  // Walk lines tracking byte offsets; coalesce consecutive same-kind
+  // rows into single ranges so a 30-line added block costs one
+  // overlay, not 30.
+  let byte = 0;
+  let runKind: "+" | "-" | "@" | null = null;
+  let runStart = 0;
+  let runEnd = 0;
+
+  const flushRun = () => {
+    if (runKind === null) return;
+    const bg =
+      runKind === "+"
+        ? HIGHLIGHT_BG_ADDED
+        : runKind === "-"
+        ? HIGHLIGHT_BG_REMOVED
+        : HIGHLIGHT_BG_HUNK;
+    editor.addOverlay(bufferId, HIGHLIGHT_NAMESPACE, runStart, runEnd, {
+      bg,
+      extendToLineEnd: true,
+    });
+    runKind = null;
+  };
+
+  for (const line of text.split("\n")) {
+    const lineLen = line.length;
+    const ch = line.charAt(0);
+    let kind: "+" | "-" | "@" | null = null;
+    if (ch === "+" && !line.startsWith("+++")) kind = "+";
+    else if (ch === "-" && !line.startsWith("---")) kind = "-";
+    else if (line.startsWith("@@")) kind = "@";
+
+    if (kind !== runKind) {
+      flushRun();
+      if (kind !== null) {
+        runStart = byte;
+        runKind = kind;
+      }
+    }
+    if (kind !== null) {
+      // Include the trailing newline in the range so the bg colour
+      // fills the row even on empty lines that wrap-extend.
+      runEnd = byte + lineLen + 1;
+    }
+    byte += lineLen + 1;
+  }
+  flushRun();
 }
 
 /**
- * Spawn `git show` for `commit` and render the result. Tagged with
- * `pendingDetailId` so a newer selection supersedes in-flight fetches.
+ * Get (or create) the file-backed buffer that displays `commit`.
+ * On first call for a hash: ensure cache file exists, kick off
+ * `git show` if it doesn't, openFileStreaming, start the poll loop.
+ * Returns the buffer id on success or null on failure.
  */
-async function fetchAndRenderDetail(commit: GitCommit): Promise<void> {
-  const myId = ++state.pendingDetailId;
-  const output = await fetchCommitShow(editor, commit.hash);
-  if (myId !== state.pendingDetailId) return;
-  if (state.groupId === null) return;
-  state.detailCache = { hash: commit.hash, output };
-  // Only render if the current selection is still this commit — a rapid
-  // Up/Down burst might have moved on before we got here.
-  const currentIdx = Math.max(
-    0,
-    Math.min(state.selectedIndex, state.commits.length - 1)
-  );
-  if (state.commits[currentIdx]?.hash !== commit.hash) return;
-  renderDetailForCommit(commit, output);
+async function ensureCommitBuffer(commit: GitCommit, cwd: string): Promise<number | null> {
+  const hash = commit.hash;
+  const existing = state.commitBuffers.get(hash);
+  if (existing !== undefined) return existing;
+
+  const path = cachePathForHash(hash);
+  const cacheHit = editor.fileExists(path);
+
+  if (!cacheHit) {
+    // Cache miss: spawn git, polling the file as it grows. The handle
+    // is stashed so a fast-scrolling user can supersede us via kill().
+    const handle = spawnGitShow(hash, cwd);
+    state.inFlightSpawns.set(hash, handle);
+    const bufferId = await editor.openFileStreaming(path);
+    if (bufferId === null) {
+      handle.kill?.();
+      state.inFlightSpawns.delete(hash);
+      return null;
+    }
+    state.commitBuffers.set(hash, bufferId);
+    // Fire-and-forget polling task.
+    void pollUntilSpawnDone(hash, bufferId, handle);
+    return bufferId;
+  }
+
+  // Cache hit: just open the existing file. No git spawned.
+  const bufferId = await editor.openFileStreaming(path);
+  if (bufferId === null) return null;
+  state.commitBuffers.set(hash, bufferId);
+  return bufferId;
 }
 
 /**
- * Combined synchronous + asynchronous refresh used by open/refresh paths
- * where there's no burst of events to collapse.
+ * Show `commit` in the detail panel. Cancels any superseded in-flight
+ * spawn for *other* commits (the user has navigated past them) and
+ * retargets the panel at the chosen commit's buffer.
  */
+async function showCommitInDetail(commit: GitCommit, cwd: string): Promise<void> {
+  // Cancel anything still streaming for a commit that isn't this one —
+  // the user has moved on; no point keeping git running.
+  for (const [hash, handle] of state.inFlightSpawns) {
+    if (hash !== commit.hash) {
+      handle.kill?.();
+      state.inFlightSpawns.delete(hash);
+    }
+  }
+
+  const bufferId = await ensureCommitBuffer(commit, cwd);
+  if (bufferId === null) {
+    editor.setStatus(
+      editor.t("status.failed_open_file", { file: commit.shortHash }),
+    );
+    return;
+  }
+  if (state.groupId === null) return;
+  await editor.setBufferGroupPanelBuffer(state.groupId, "detail", bufferId);
+  state.detailBufferId = bufferId;
+  // Each commit buffer needs the same per-buffer presentation as the
+  // initial virtual one: visible cursor for diff-line navigation,
+  // wrap on (long minified lines unreadable in the 40% panel).
+  editor.setBufferShowCursors(bufferId, true);
+  editor.setLineWrap(bufferId, null, true);
+  // Land at the top of the diff every time we (re-)visit a commit.
+  editor.setBufferCursor(bufferId, 0);
+}
+
 async function refreshDetail(): Promise<void> {
-  const pending = refreshDetailImmediate();
-  if (pending) await fetchAndRenderDetail(pending);
+  if (state.groupId === null) return;
+  if (state.commits.length === 0) return;
+  const idx = Math.max(0, Math.min(state.selectedIndex, state.commits.length - 1));
+  const commit = state.commits[idx];
+  if (!commit) return;
+  await showCommitInDetail(commit, editor.getCwd());
 }
 
 // =============================================================================
@@ -438,7 +579,11 @@ async function show_git_log(): Promise<void> {
   );
   state.groupId = group.groupId as number;
   state.logBufferId = (group.panels["log"] as number | undefined) ?? null;
-  state.detailBufferId = (group.panels["detail"] as number | undefined) ?? null;
+  state.initialDetailBufferId =
+    (group.panels["detail"] as number | undefined) ?? null;
+  // detailBufferId starts as the initial virtual buffer; it gets
+  // retargeted to a file-backed buffer on first commit selection.
+  state.detailBufferId = state.initialDetailBufferId;
   state.toolbarBufferId = (group.panels["toolbar"] as number | undefined) ?? null;
   if (state.toolbarBufferId !== null) {
     state.toolbarPanel = new WidgetPanel(state.toolbarBufferId);
@@ -447,35 +592,36 @@ async function show_git_log(): Promise<void> {
     state.logPanel = new WidgetPanel(state.logBufferId);
   }
   state.selectedIndex = 0;
-  state.detailCache = null;
+  state.commitBuffers = new Map();
+  state.inFlightSpawns = new Map();
   state.isOpen = true;
 
-  // The detail panel still owns a native cursor so diff lines can be
-  // clicked / traversed before pressing Enter to open a file. The log
-  // panel's selection is owned by the List widget — no buffer cursor
-  // needed (the focused-row highlight indicates position).
-  if (state.detailBufferId !== null) {
-    editor.setBufferShowCursors(state.detailBufferId, true);
-    // Wrap long lines in the detail panel — git diffs often exceed the
-    // 40% split width, and horizontal scrolling a commit is awkward.
-    editor.setLineWrap(state.detailBufferId, null, true);
-    // Per-panel mode: the group was created with "git-log" which applies
-    // to the initially-focused panel (log). The detail panel's mode is
-    // set when we focus into it.
+  // The detail panel owns a native cursor so diff lines can be
+  // clicked / traversed before pressing Enter to open a file. We set
+  // the cursor on each retargeted buffer as it gets swapped in, but
+  // wrap-default needs setting too — long minified lines in lock-file
+  // diffs are unreadable without wrap in the 40% panel.
+  if (state.initialDetailBufferId !== null) {
+    editor.setBufferShowCursors(state.initialDetailBufferId, true);
+    editor.setLineWrap(state.initialDetailBufferId, null, true);
   }
 
   renderToolbar();
   renderLog();
-  // List widget's instance state is the source of truth for selection;
-  // no buffer-cursor positioning needed (the renderer auto-scrolls so
-  // the selected row stays visible).
+  // Cursor-driven selection: give the log pane a real, visible cursor and
+  // take ownership of it (`setBufferShowCursors` locks it so the widget
+  // runtime won't clear it on repaint). The cursor's line is the selected
+  // commit; `cursor_moved` mirrors it into the List highlight + detail.
+  // Start on HEAD (line 0). Scrolling is the normal cursor-follow wheel.
+  if (state.logBufferId !== null) {
+    editor.setBufferShowCursors(state.logBufferId, true);
+    editor.setBufferCursor(state.logBufferId, 0);
+  }
   await refreshDetail();
 
-  if (state.groupId !== null) {
-    editor.focusBufferGroupPanel(state.groupId, "log");
-  }
   editor.on("resize", on_git_log_resize);
   editor.on("buffer_closed", on_git_log_buffer_closed);
+  editor.on("cursor_moved", on_git_log_cursor_moved);
 
   editor.setStatus(
     editor.t("status.log_ready", { count: String(state.commits.length) })
@@ -490,20 +636,37 @@ function git_log_cleanup(): void {
   if (!state.isOpen) return;
   editor.off("resize", on_git_log_resize);
   editor.off("buffer_closed", on_git_log_buffer_closed);
-  // The buffer-group's `close` will tear down the panel buffers too,
-  // which implicitly drops the widget panels rendering into them. We
-  // still null out the handles so any stray `renderToolbar()` /
-  // `renderLog()` call post-cleanup is a no-op.
+  editor.off("cursor_moved", on_git_log_cursor_moved);
+  // Kill any still-running `git show` spawns — we no longer care.
+  for (const [, handle] of state.inFlightSpawns) {
+    handle.kill?.();
+  }
+  state.inFlightSpawns.clear();
+  // Close each per-commit buffer we created. The buffer-group's own
+  // `close` (called below in `git_log_close`) tears down the panel
+  // buffers (toolbar/log/initialDetail) — but retargeted file-backed
+  // buffers we allocated via openFileStreaming are *outside* the
+  // group's panel_buffers map by the time we got here, so we must
+  // close them explicitly to avoid leaks.
+  for (const [, bufferId] of state.commitBuffers) {
+    editor.closeBuffer(bufferId);
+  }
+  state.commitBuffers.clear();
+  // The buffer-group's `close` will tear down its own panel buffers
+  // (toolbar/log/initialDetail) too, which implicitly drops the widget
+  // panels rendering into them. We still null out the handles so any
+  // stray `renderToolbar()` / `renderLog()` call post-cleanup is a
+  // no-op.
   state.toolbarPanel = null;
   state.logPanel = null;
   state.isOpen = false;
   state.groupId = null;
   state.logBufferId = null;
+  state.initialDetailBufferId = null;
   state.detailBufferId = null;
   state.toolbarBufferId = null;
   state.commits = [];
   state.selectedIndex = 0;
-  state.detailCache = null;
 }
 
 function git_log_close(): void {
@@ -519,12 +682,26 @@ registerHandler("git_log_close", git_log_close);
 
 function on_git_log_buffer_closed(data: { buffer_id: number }): void {
   if (!state.isOpen) return;
+  // Tear down the whole group only when the *group's* buffers close
+  // (toolbar / log / the initial virtual detail). A retargeted
+  // file-backed commit buffer closing is normal — drop it from our
+  // cache but keep the group alive.
   if (
     data.buffer_id === state.logBufferId ||
-    data.buffer_id === state.detailBufferId ||
+    data.buffer_id === state.initialDetailBufferId ||
     data.buffer_id === state.toolbarBufferId
   ) {
     git_log_cleanup();
+    return;
+  }
+  // Removed from cache so a revisit re-spawns / re-opens.
+  for (const [hash, bufId] of state.commitBuffers) {
+    if (bufId === data.buffer_id) {
+      state.commitBuffers.delete(hash);
+      state.inFlightSpawns.get(hash)?.kill?.();
+      state.inFlightSpawns.delete(hash);
+      break;
+    }
   }
 }
 registerHandler("on_git_log_buffer_closed", on_git_log_buffer_closed);
@@ -533,7 +710,13 @@ async function git_log_refresh(): Promise<void> {
   if (!state.isOpen) return;
   editor.setStatus(editor.t("status.refreshing"));
   state.commits = await fetchGitLog(editor);
-  state.detailCache = null;
+  // The on-disk cache files are keyed by SHA and commits are
+  // immutable, so they remain valid — but our in-memory buffer ids
+  // for commits no longer in the visible list are stale; clear them.
+  for (const [, handle] of state.inFlightSpawns) handle.kill?.();
+  state.inFlightSpawns.clear();
+  for (const [, bufferId] of state.commitBuffers) editor.closeBuffer(bufferId);
+  state.commitBuffers.clear();
   if (state.selectedIndex >= state.commits.length) {
     state.selectedIndex = Math.max(0, state.commits.length - 1);
   }
@@ -604,26 +787,222 @@ function git_log_q(): void {
 }
 registerHandler("git_log_q", git_log_q);
 
+// =============================================================================
+// Folding by file and hunk
+//
+// Publishes structural fold ranges into the buffer's `folding_ranges`
+// via `setFoldingRanges` — the same channel an LSP `foldingRange`
+// response uses. Nothing is pre-collapsed; the user toggles a range
+// with the standard fold keybinding (`za` etc.), which finds the
+// matching range under the cursor.
+//
+// The diff structure gives us two natural fold levels:
+//   * per-file:  each `diff --git a/X b/Y` section
+//   * per-hunk:  each `@@ -A,B +C,D @@` block within a file
+// We publish both; the toggle-fold key picks the innermost containing
+// range at the cursor's line.
+//
+// Computed once after `pollUntilSpawnDone` settles — re-running on
+// every refresh would churn the marker list for no benefit (the diff
+// structure is monotonic-append until exit).
+// =============================================================================
+
+interface DiffFoldRange {
+  startLine: number;
+  endLine: number;
+}
+
+/** Walk the buffer text and return (file-level, hunk-level) fold
+ *  ranges. Lines are 0-indexed, both endpoints inclusive — the LSP
+ *  shape. The "fold header" is the line at `startLine`; everything up
+ *  through `endLine` collapses under it. */
+function computeDiffFoldRanges(text: string): {
+  files: DiffFoldRange[];
+  hunks: DiffFoldRange[];
+} {
+  const lines = text.split("\n");
+  const files: DiffFoldRange[] = [];
+  const hunks: DiffFoldRange[] = [];
+
+  let fileStart: number | null = null;
+  let hunkStart: number | null = null;
+
+  const closeHunk = (endLine: number) => {
+    if (hunkStart !== null && endLine > hunkStart) {
+      hunks.push({ startLine: hunkStart, endLine });
+    }
+    hunkStart = null;
+  };
+  const closeFile = (endLine: number) => {
+    closeHunk(endLine);
+    if (fileStart !== null && endLine > fileStart) {
+      files.push({ startLine: fileStart, endLine });
+    }
+    fileStart = null;
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i];
+    if (l.startsWith("diff --git ")) {
+      closeFile(i - 1);
+      fileStart = i;
+    } else if (l.startsWith("@@ ")) {
+      closeHunk(i - 1);
+      hunkStart = i;
+    }
+  }
+  closeFile(lines.length - 1);
+  return { files, hunks };
+}
+
+async function publishDiffFoldRanges(bufferId: number): Promise<void> {
+  const total = editor.getBufferLength(bufferId);
+  if (total === 0) return;
+  const text = await editor.getBufferText(bufferId, 0, total);
+  if (!text) return;
+
+  const { files, hunks } = computeDiffFoldRanges(text);
+
+  // Merge — the host accepts a single array. "region" kind tags both
+  // levels generically; the LSP spec also defines comment/imports
+  // kinds which don't apply to diffs.
+  const ranges = [...files, ...hunks].map((r) => ({
+    startLine: r.startLine,
+    endLine: r.endLine,
+    kind: "region",
+  }));
+  editor.setFoldingRanges(bufferId, ranges);
+}
+
 // =============================================================================
 // Detail panel — open file at commit
 // =============================================================================
 
+/**
+ * Walk through the streaming diff buffer to find the file + line
+ * context near the cursor. Diff format:
+ *
+ *     diff --git a/<path> b/<path>
+ *     index ...
+ *     --- a/<path>     (or /dev/null for additions)
+ *     +++ b/<path>     (or /dev/null for deletions)
+ *     @@ -old,n +new,m @@
+ *     <context|+|- lines>
+ *
+ * Strategy:
+ *  - Read up to the END of the cursor's line, not just up to the
+ *    cursor's byte offset. This way a cursor sitting on a header line
+ *    (`diff --git`, `+++ b/...`, `@@ ...`) still gets that line
+ *    matched, matching the old text-property behaviour.
+ *  - Walk backwards for the per-file header. Match either:
+ *      `+++ b/<path>`             (preferred — names the new-side path)
+ *      `diff --git a/<src> b/<dst>` (fallback — covers the case where
+ *        the cursor is on the `diff --git` line itself, before the
+ *        `+++` line has appeared in the search range)
+ *  - Walk backwards for the most recent `@@ -... +<new>,<count> @@`
+ *    between the header and cursor, then count context/'+' rows
+ *    forward to the cursor to derive the new-side line number.
+ */
+async function deriveFileAndLineFromDiffCursor(
+  bufferId: number,
+): Promise<{ file: string; line: number } | null> {
+  const cursor = editor.getCursorPosition();
+  if (cursor < 0) return null;
+
+  const bufLen = editor.getBufferLength(bufferId);
+  const readEnd = Math.min(bufLen, cursor + 4096);
+  if (readEnd === 0) return null;
+  const text = await editor.getBufferText(bufferId, 0, readEnd);
+  if (!text) return null;
+  const lines = text.split("\n");
+
+  // Locate the cursor's line index by walking byte offsets. `lines[i]`
+  // covers bytes [byte, byte+len]; the `\n` separator lives at
+  // byte+len, so the next line starts at byte+len+1.
+  let byte = 0;
+  let cursorLineIdx = lines.length - 1;
+  for (let i = 0; i < lines.length; i++) {
+    const lineLen = lines[i].length;
+    if (cursor <= byte + lineLen) {
+      cursorLineIdx = i;
+      break;
+    }
+    byte += lineLen + 1;
+  }
+
+  // Walk back from the cursor's line for the per-file header. Match
+  // either `+++ b/<path>` or `diff --git a/<src> b/<dst>` so cursor-
+  // on-header cases work.
+  let file: string | null = null;
+  let headerIdx = -1;
+  for (let i = cursorLineIdx; i >= 0; i--) {
+    const l = lines[i];
+    if (l.startsWith("+++ b/")) {
+      file = l.slice(6).trim();
+      headerIdx = i;
+      break;
+    }
+    if (l.startsWith("+++ /dev/null")) {
+      // Deletion — no new-side path. Opening the pre-image is a
+      // separate flow.
+      return null;
+    }
+    const m = /^diff --git a\/(.+?) b\/(.+)$/.exec(l);
+    if (m) {
+      const aSide = m[1];
+      const bSide = m[2];
+      file = bSide === "/dev/null" ? aSide : bSide;
+      headerIdx = i;
+      break;
+    }
+  }
+  if (file === null || headerIdx < 0) return null;
+
+  // Find the most recent `@@ ... +start,count @@` between header and
+  // cursor. Default: line 1 (cursor sits on the header itself, or
+  // between the header and the first hunk).
+  let line = 1;
+  for (let i = cursorLineIdx; i > headerIdx; i--) {
+    const l = lines[i];
+    const m = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(l);
+    if (!m) continue;
+    const newStart = parseInt(m[1], 10);
+    if (!Number.isFinite(newStart)) return null;
+    // Walk forward from the hunk header to the cursor's line,
+    // advancing the new-file line counter for context (' ') and
+    // addition ('+') rows; skip deletion ('-') rows since they don't
+    // exist in the new file.
+    let cur = newStart;
+    for (let j = i + 1; j <= cursorLineIdx; j++) {
+      if (j === cursorLineIdx) {
+        line = cur;
+        break;
+      }
+      const ch = lines[j].charAt(0);
+      if (ch === "+" || ch === " " || ch === "") cur += 1;
+      // '-' / '\' (no-newline marker): don't advance.
+    }
+    break;
+  }
+  return { file, line };
+}
+
 async function git_log_detail_open_file(): Promise<void> {
   if (state.detailBufferId === null) return;
   const commit = selectedCommit();
   if (!commit) return;
 
-  const props = editor.getTextPropertiesAtCursor(state.detailBufferId);
-  if (props.length === 0) {
-    editor.setStatus(editor.t("status.move_to_diff"));
-    return;
-  }
-  const file = props[0].file as string | undefined;
-  const line = (props[0].line as number | undefined) ?? 1;
-  if (!file) {
+  // The detail buffer is a plain file-backed view of `git show --patch`,
+  // so we don't have plugin-attached `file`/`line` properties anymore.
+  // Parse the diff backwards from the cursor to find the nearest
+  // `+++ b/<path>` header (a per-file diff section opener) and the
+  // most recent hunk header to derive a line number.
+  const ctx = await deriveFileAndLineFromDiffCursor(state.detailBufferId);
+  if (!ctx) {
     editor.setStatus(editor.t("status.move_to_diff_with_context"));
     return;
   }
+  const { file, line } = ctx;
 
   editor.setStatus(
     editor.t("status.file_loading", { file, hash: commit.shortHash })
@@ -699,19 +1078,33 @@ function git_log_file_view_close(): void {
 registerHandler("git_log_file_view_close", git_log_file_view_close);
 
 // =============================================================================
-// Selection tracking — live-update the detail panel as the user
-// navigates the List. Driven by `widget_event "select"` from the host.
+// Selection tracking — the log pane is cursor-driven. The buffer cursor's
+// line (set by arrow-key movement or a click) is the selected commit; this
+// `cursor_moved` subscription mirrors it into the List highlight and the
+// detail pane. Scrolling is handled by the normal cursor-follow wheel, so
+// the viewport only moves when the cursor crosses the top/bottom edge.
 // =============================================================================
 
-async function on_log_select(idx: number): Promise<void> {
+function on_git_log_cursor_moved(data: { buffer_id: number; line: number }): void {
+  if (!state.isOpen || state.logBufferId === null) return;
+  if (data.buffer_id !== state.logBufferId) return;
+  // `cursor_moved.line` is 1-based; commit rows are 0-based (no header),
+  // so the selected commit index is `line - 1`.
+  const idx = data.line - 1;
+  if (idx < 0 || idx >= state.commits.length) return;
+  void selectCommitLine(idx);
+}
+
+async function selectCommitLine(idx: number): Promise<void> {
   if (!state.isOpen) return;
   if (idx === state.selectedIndex) return;
   state.selectedIndex = idx;
 
-  // Immediate feedback: cached detail or "loading" placeholder.
-  // The host already re-rendered the List with the new selection
-  // highlight, so we only need to update the right-hand pane.
-  const pending = refreshDetailImmediate();
+  // Move the List's highlight bar to the cursor's row. The cursor itself
+  // is the real (plugin-owned) buffer cursor, so it stays exactly where
+  // the user moved or clicked it — this only repaints the row styling,
+  // and the repaint preserves the cursor position.
+  state.logPanel?.setSelectedIndex(LOG_LIST_KEY, idx);
 
   const commit = state.commits[state.selectedIndex];
   if (commit) {
@@ -723,16 +1116,17 @@ async function on_log_select(idx: number): Promise<void> {
     );
   }
 
-  if (!pending) return;
-
   // Debounce: bump the token, wait a beat, bail if a newer event has
-  // arrived. `git show` is expensive; a burst of select events (held
-  // j/k, PageDown) must collapse to one spawn.
+  // arrived. Even though re-pointing the panel at a cached buffer is
+  // ~free, kicking off a new `git show --patch` for every intermediate
+  // row in a held-j burst is wasteful. Collapse rapid selection moves.
   const myId = ++state.pendingSelectId;
   await editor.delay(SELECT_DEBOUNCE_MS);
   if (myId !== state.pendingSelectId) return;
   if (!state.isOpen) return;
-  await fetchAndRenderDetail(pending);
+  const current = state.commits[state.selectedIndex];
+  if (!current) return;
+  await showCommitInDetail(current, editor.getCwd());
 }
 
 // =============================================================================
@@ -757,5 +1151,4 @@ editor.registerCommand(
   "git_log_refresh",
   null
 );
-
 editor.debug("Git Log plugin initialized (modern buffer-group layout)");