@young1lin/dsh-ui-gitworkbench 0.1.7 → 0.1.8

package/src/client/use-change-nav.ts

@@ -29,8 +29,15 @@ export interface ChangeNav {
 /**
  * @param scrollRef - the element that scrolls, and the one whose subtree
  *   carries the `data-block` marks.
+ * @param tops - where the blocks are, when the caller can say. A WINDOWED pane
+ *   must supply this: it renders only the rows near the viewport, so the block
+ *   the reader is walking to usually has no DOM to measure. Omitted, the
+ *   positions are measured off the `data-block` marks as before.
  */
-export function useChangeNav(scrollRef: MutableRefObject<HTMLDivElement | null>): ChangeNav {
+export function useChangeNav(
+  scrollRef: MutableRefObject<HTMLDivElement | null>,
+  tops?: () => readonly BlockTop[],
+): ChangeNav {
   /** What the last press landed on. A ref, not state: it exists to make the
    *  NEXT press correct, and nothing on screen reads it. */
   const navMemory = useRef<NavMemory | null>(null)
@@ -38,12 +45,15 @@ export function useChangeNav(scrollRef: MutableRefObject<HTMLDivElement | null>)
   /**
    * Every change block's position inside the scrolled content.
    *
-   * Measured off the DOM rather than derived from a row model: a model knows
-   * which rows changed, not how many pixels down the page they sit, and the
-   * rows are never the only thing in the scroller — padding, a sticky bar and,
-   * in the armed side-by-side pane, a CodeMirror view of a different height
-   * all move the answer. One layout read per PRESS is cheap; nothing here runs
-   * on scroll.
+   * The fallback, for a pane that renders all of its rows. Measuring is the
+   * more general answer — a model knows which rows changed, not how many
+   * pixels down the page they sit, and the rows are never the only thing in
+   * the scroller. One layout read per PRESS is cheap; nothing here runs on
+   * scroll.
+   *
+   * It stops being available the moment a pane renders only part of its rows,
+   * which is why `tops` exists: what is not in the DOM cannot be measured, and
+   * a walk that skips every change outside the viewport is worse than no walk.
    *
    * `offsetTop` is deliberately not used: it is relative to whichever ancestor
    * happens to be positioned, which no rule in the stylesheet guarantees.
@@ -69,8 +79,8 @@ export function useChangeNav(scrollRef: MutableRefObject<HTMLDivElement | null>)
   const goToChange = (direction: 1 | -1): void => {
     const scroller = scrollRef.current
     if (scroller === null) return
-    const tops = blockTops()
-    const target = stepToBlock(tops, anchorFrom(tops, scroller.scrollTop, navMemory.current), direction)
+    const measured = tops === undefined ? blockTops() : tops()
+    const target = stepToBlock(measured, anchorFrom(measured, scroller.scrollTop, navMemory.current), direction)
     if (target === null) return
     scroller.scrollTop = scrollTopFor(target.top)
     // Read back rather than storing what was asked for: the browser clamps at

package/src/index.ts

@@ -91,8 +91,7 @@ export type { WriteResult }
 const DIFF_CHAR_CAP = 400_000
 /** Untracked files larger than this are listed + counted but never diffed. */
 const UNTRACKED_FILE_BYTE_CAP = 1_000_000
-/** At most this many bytes of synthesized untracked diff ride along in `stats`. */
-const UNTRACKED_TOTAL_CHAR_CAP = 160_000
+
 /** Files with a NUL byte in the first 8k are treated as binary. */
 const BINARY_SNIFF_BYTES = 8_000
 /** Context radius that makes `git diff` emit ONE hunk covering the whole file —
@@ -413,13 +412,21 @@ export class GitWorkbenchService extends TypertRemoteService {
   async stats(worktreePath: string | undefined, signal: AbortSignal): Promise<WorkbenchStats> {
     const cwd = typeof worktreePath === 'string' && worktreePath.length > 0 ? worktreePath : process.cwd()
 
-    // Four independent reads of the same worktree. Running them together is
+    // Three independent reads of the same worktree. Running them together is
     // safe: git takes .git/index.lock only to write back a refreshed index and
     // skips that write when it cannot get the lock, so the reports stay correct.
-    const [statusInfo, numstat, diff, revInfo] = await Promise.all([
+    //
+    // `git diff HEAD` is NOT among them any more. This call is polled — every
+    // 3 seconds while an agent is running — and the full patch is the most
+    // expensive thing in it by a wide margin: measured on a worktree with
+    // 90,000 changed lines it took 595ms and produced 7.43MB, of which the
+    // 400,000-character clip below then discarded 94.6% before it ever reached
+    // the browser. The tree and the counters need only `status` and
+    // `--numstat`, both of which stay around 110-140ms at that size, and the
+    // pane already fetches the file it is actually showing through `fileDiff`.
+    const [statusInfo, numstat, revInfo] = await Promise.all([
       this.git(cwd, ['status', '--porcelain=v1', '--branch', '--untracked-files=all'], signal),
       this.git(cwd, ['diff', 'HEAD', '--numstat'], signal),
-      this.git(cwd, ['diff', 'HEAD'], signal),
       this.git(cwd, ['rev-parse', '--abbrev-ref', 'HEAD'], signal),
     ])
     if (statusInfo.exitCode !== 0) {
@@ -430,25 +437,18 @@ export class GitWorkbenchService extends TypertRemoteService {
     const counts = parseNumstat(numstat.stdout)
     const files = parseStatus(statusInfo.stdout, counts)
 
-    // Untracked files in two passes, because the two halves cost wildly
-    // different amounts. EVERY untracked file needs a line count and a binary
-    // flag, which come off the raw buffer with no utf8 decode; only the handful
-    // that fit the payload budget pay for a decode and a synthesized segment.
+    // Every untracked file needs a line count and a binary flag for the tree,
+    // and both come off the raw buffer with no utf8 decode. The second pass
+    // that used to follow — decoding some of them and synthesizing new-file
+    // segments into the payload — is gone with the payload itself; `fileDiff`
+    // synthesizes the one segment the reader has actually opened.
     const untracked = files.filter(file => file.status === 'untracked')
     const measured = await mapPooled(untracked, UNTRACKED_READ_CONCURRENCY, file => measureUntracked(cwd, file.path))
 
-    let budget = UNTRACKED_TOTAL_CHAR_CAP
-    let untrackedDiff = ''
     for (const [index, file] of untracked.entries()) {
       const measure = measured[index]
       file.addedLines = measure.lineCount
       file.binary = measure.binary
-      if (budget <= 0 || !measure.diffable) continue
-      const segment = await untrackedSegment(cwd, file.path)
-      if (segment === null) continue
-      const text = clipDiff(segment, budget, '…[untracked diff truncated]')
-      untrackedDiff += `${text}\n`
-      budget -= text.length
     }
 
     let addedLines = 0
@@ -481,14 +481,13 @@ export class GitWorkbenchService extends TypertRemoteService {
     }
     const { ahead, behind } = parseBranch(statusInfo.stdout)
 
-    let combined = diff.stdout
-    if (untrackedDiff.length > 0) combined += `\n${untrackedDiff}`
-    combined = clipDiff(combined, DIFF_CHAR_CAP, '…[diff truncated]')
 
     return {
       worktreePath: cwd, branch, ahead, behind, detached,
       addedLines, deletedLines, addedFiles, deletedFiles, modifiedFiles,
-      files, diff: combined,
+      // No bundled patch: every per-file diff is fetched on demand. See the
+      // reads above for what that saves and why it is affordable.
+      files, diff: '',
       // No log here: this call is polled every 15s, and the history list follows
       // a ref this one knows nothing about. `commits` serves it instead.
       commits: [],
@@ -496,14 +495,36 @@ export class GitWorkbenchService extends TypertRemoteService {
   }
 
   /**
-   * One file's diff on demand. With `commit` the diff is that commit's change to
-   * the file; without it, the working tree against HEAD (plain-identifier params;
-   * signal last).
+   * One file's diff on demand, for whichever view is asking.
+   *
+   * Three questions, because the drawer's three tabs are asking three different
+   * things about the same path and only the caller knows which:
+   *
+   *   - with `commit`, that commit's change to the file;
+   *   - with `base` and `head`, what differs between two refs — the Compare
+   *     tab, which until now had no way to ask at all and showed a file with no
+   *     detail whenever the bundled payload did not carry it;
+   *   - with neither, the working tree against HEAD.
+   *
+   * The range answer is deliberately NOT cached, for the same reason
+   * `compareRefs` is not: a ref name is a moving pointer, unlike a commit hash.
+   *
+   * Plain-identifier params, signal last.
    */
   @Remote('fileDiff')
-  async fileDiff(worktreePath: string, path: string, commit: string | undefined, signal: AbortSignal): Promise<{ readonly diff: string }> {
+  async fileDiff(worktreePath: string, path: string, commit: string | undefined, base: string | undefined, head: string | undefined, signal: AbortSignal): Promise<{ readonly diff: string }> {
     const cwd = typeof worktreePath === 'string' && worktreePath.length > 0 ? worktreePath : process.cwd()
     if (typeof path !== 'string' || path.length === 0) return { diff: '' }
+    if (typeof base === 'string' && base.length > 0 && typeof head === 'string' && head.length > 0) {
+      if (!isRefName(base) || !isRefName(head)) return { diff: '' }
+      const ranged = await this.git(cwd, ['diff', '--no-renames', `${base}...${head}`, '--', path], signal)
+      if (ranged.exitCode === 0) return { diff: ranged.stdout }
+      // Unrelated histories have no merge base for `A...B` to diff from; the
+      // two-tip diff still answers what differs, exactly as `compareRefs` does.
+      if (!isNoMergeBaseError(ranged.stderr)) return { diff: '' }
+      const tips = await this.git(cwd, ['diff', '--no-renames', base, head, '--', path], signal)
+      return { diff: tips.exitCode === 0 ? tips.stdout : '' }
+    }
     if (typeof commit === 'string' && commit.length > 0) {
       if (!COMMIT_HASH.test(commit)) return { diff: '' }
       const key = cacheKey(cwd, commit, path)