@young1lin/dsh-ui-gitworkbench 0.1.6 → 0.1.8

package/src/client/diff-nav.ts

@@ -196,3 +196,31 @@ export function countBlocks(ids: readonly number[]): number {
   for (const id of ids) if (id > top) top = id
   return top + 1
 }
+
+/**
+ * Where each change block sits, derived from the rows rather than measured.
+ *
+ * A windowed pane cannot measure: the block being walked to usually has no
+ * element, because the whole point is that it is not on screen. The rows are a
+ * fixed height there by construction, so the position is arithmetic.
+ *
+ * @param blocks - each row's block id, `-1` for a row that is not part of one.
+ * @param rowH - row height in px.
+ * @param offset - px above the first row, e.g. the grid's top padding.
+ * @returns the first row of each block, in the order the blocks appear.
+ */
+export function blockTopsFromRows(
+  blocks: readonly number[],
+  rowH: number,
+  offset = 0,
+): readonly BlockTop[] {
+  const tops: BlockTop[] = []
+  const seen = new Set<number>()
+  for (let i = 0; i < blocks.length; i += 1) {
+    const block = blocks[i]!
+    if (!Number.isInteger(block) || block < 0 || seen.has(block)) continue
+    seen.add(block)
+    tops.push({ block, top: offset + i * rowH })
+  }
+  return tops
+}

package/src/client/highlight.ts

@@ -223,6 +223,62 @@ export function highlightWholeFile(
   return tokenizeLines(lines, lang, theme)
 }
 
+/**
+ * How many lines above the window are tokenized for context.
+ *
+ * Shiki lexes a string from its start, so a slice beginning inside a block
+ * comment or a template literal would colour as if it were code. Reading a
+ * lead-in restores that state for everything but a construct longer than this,
+ * at a fraction of the cost of the file: at 4,000 lines the whole-file pass was
+ * the entire remaining freeze once the DOM was bounded.
+ */
+export const HIGHLIGHT_LEAD_IN = 240
+
+/**
+ * Runs for the rows in a window, and nothing outside it.
+ *
+ * This is the pane's whole highlighting cost now, and it is proportional to the
+ * viewport rather than to the file. Measured on a 4,000-line file with a
+ * one-line change: whole-file passes plus per-line re-lexing froze the pane for
+ * 1.4 seconds; the same file behind an extension no grammar claims cost 22ms of
+ * script, which is what proved the entire remainder was Shiki.
+ *
+ * Both passes happen inside the window: the slice pass, which knows about
+ * multi-line constructs within its reach, and the per-line re-lex that makes a
+ * diff reconstruction colour as top-level code.
+ *
+ * @param lines - source lines, no leading +/-.
+ * @param lang - from {@link shikiLangOf}.
+ * @param theme - from {@link shikiThemeOf}.
+ * @param from - first row in the window.
+ * @param to - one past the last row in the window.
+ * @returns an array indexed by ROW, filled only inside the window; undefined
+ *   when no grammar applies, which the caller already renders as plain text.
+ */
+export function highlightWindow(
+  lines: readonly string[],
+  lang: string | undefined,
+  theme: string,
+  from: number,
+  to: number,
+): (HighlightRun[] | undefined)[] | undefined {
+  const first = Math.max(0, Math.trunc(from))
+  const last = Math.min(lines.length, Math.trunc(to))
+  if (last <= first) return undefined
+  const lead = Math.max(0, first - HIGHLIGHT_LEAD_IN)
+  const sliceTok = tokenizeLines(lines.slice(lead, last), lang, theme)
+  if (sliceTok === undefined) return undefined
+  const out: (HighlightRun[] | undefined)[] = new Array<HighlightRun[] | undefined>(lines.length)
+  for (let i = first; i < last; i += 1) {
+    const line = lines[i]!
+    const together = sliceTok[i - lead] ?? [{ text: line, color: undefined }]
+    if (looksLikeCommentLine(line)) { out[i] = together; continue }
+    const solo = tokenizeLines([line], lang, theme)?.[0]
+    out[i] = solo !== undefined && solo.length > 0 ? solo : together
+  }
+  return out
+}
+
 function looksLikeCommentLine(text: string): boolean {
   const t = text.trimStart()
   return t.startsWith('//') || t.startsWith('/*') || t.startsWith('*') || t.startsWith('#')

package/src/client/history-layout.ts

@@ -0,0 +1,52 @@
+/**
+ * Which way the History tab arranges its panes.
+ *
+ * Two arrangements, kept because they are good at different things and the
+ * drawer's width is fixed, so neither wins outright.
+ *
+ * `columns` puts the commit list beside the tree and the diff. The list is then
+ * as tall as the drawer, which is what makes a log scannable — but it is a 26%
+ * column, and measured on a 1700px drawer that left about 420px, enough for a
+ * subject of roughly forty characters before the ellipsis.
+ *
+ * `stacked` spans the list across the top instead, the way IDEA's git log does.
+ * No subject is cut and thirty rows fit where the column fitted thirteen, at
+ * the cost of the height the diff below it would otherwise have had.
+ */
+export type HistoryLayout = 'columns' | 'stacked'
+
+/** Every layout, in the order the switch offers them. */
+export const HISTORY_LAYOUTS: readonly HistoryLayout[] = ['columns', 'stacked']
+
+/** The arrangement the tab had first, and what a reader who never touches the
+ *  switch gets. */
+export const DEFAULT_HISTORY_LAYOUT: HistoryLayout = 'columns'
+
+/**
+ * Narrow a stored value to a layout this build has.
+ *
+ * Storage is a durable boundary: the value on disk was written by whatever
+ * build the reader ran last, and a layout this one has since dropped must fall
+ * back rather than reach the stylesheet.
+ * @param value - value read back from storage.
+ * @returns whether it names a layout.
+ */
+export function isHistoryLayout(value: unknown): value is HistoryLayout {
+  return HISTORY_LAYOUTS.some(known => known === value)
+}
+
+/**
+ * How tall one commit row is, per layout.
+ *
+ * The two differ because the row itself differs: a column has no width to
+ * spend, so the hash, the author and the date take a line of their own above
+ * the subject; spanning the drawer they all fit on one line and a 48px row
+ * would spend the stacked layout's scarcest axis on padding.
+ *
+ * This is the ONE home for the number. The panel publishes the active entry as
+ * `--gs-commit-row` and the stylesheet sizes the row from it, while the lane
+ * graph draws each row's segment exactly that tall — the lanes only meet across
+ * the seam between rows if both come from here. Guarded by
+ * `tests/commit-row-height.test.ts`.
+ */
+export const COMMIT_ROW_H: Record<HistoryLayout, number> = { columns: 48, stacked: 28 }

package/src/client/index.ts

@@ -73,11 +73,19 @@ export function apply(ctx: ClientContext): void {
         },
         // On-demand single-file diff. With `commit` it is that commit's change to the
         // file; without it, the working tree (tracked: git diff HEAD --; untracked: synthesized).
-        fetchFileDiff: async (worktreePath: string | undefined, path: string, commit: string | undefined, signal: AbortSignal): Promise<string> => {
+        fetchFileDiff: async (worktreePath: string | undefined, path: string, commit: string | undefined, range: { base: string; head: string } | undefined, signal: AbortSignal): Promise<string> => {
           const result = await connection.rpc.call(
             '/api',
             'gitWorkbench/fileDiff',
-            { args: { worktreePath: worktreePath ?? '', path, ...commit === undefined ? {} : { commit } } },
+            {
+              args: {
+                worktreePath: worktreePath ?? '', path,
+                // Omitted rather than sent as undefined: a JSON payload with an
+                // undefined value is not what the gateway reads back.
+                ...commit === undefined ? {} : { commit },
+                ...range === undefined ? {} : { base: range.base, head: range.head },
+              },
+            },
             signal,
           ) as { ok: true; value: { diff: string } } | { ok: false; error: { message?: string } }
           return result.ok ? result.value.diff : ''

package/src/client/locales.ts

@@ -47,6 +47,8 @@ export type WorkbenchKey =
   | 'bgNone' | 'bgChoose' | 'bgClear' | 'bgBlur' | 'bgVeil' | 'bgWorking' | 'bgFailed' | 'bgTooBig'
   | 'cssPlaceholder' | 'cssImport' | 'cssApply' | 'cssUnapplied' | 'styleFailed'
   | 'resizeLabel' | 'resizeCommits' | 'resizeTree' | 'resizeSides'
+  // History arrangement switch: the commit list beside the diff, or above it
+  | 'historyLayout' | 'layoutColumns' | 'layoutStacked'
   | 'expandAll' | 'collapseAll' | 'noBranch'
   | 'copyCommit' | 'copiedCommit'
   // write operations
@@ -149,6 +151,9 @@ export const zh: Record<WorkbenchKey, string> = {
   styleFailed: '保存失败',
   resizeLabel: '拖动调整抽屉宽度',
   resizeCommits: '拖动调整提交列表宽度',
+  historyLayout: '提交列表布局',
+  layoutColumns: '并排：列表与差异分列',
+  layoutStacked: '上下：列表横跨顶部',
   resizeTree: '拖动调整文件树宽度',
   resizeSides: '拖动调整左右两栏宽度',
   sourceLabel: '统计来源切换',
@@ -384,6 +389,9 @@ export const en: Record<WorkbenchKey, string> = {
   styleFailed: 'Could not save',
   resizeLabel: 'Drag to resize the drawer',
   resizeCommits: 'Drag to resize the commit list',
+  historyLayout: 'Commit list layout',
+  layoutColumns: 'Side by side: list beside the diff',
+  layoutStacked: 'Stacked: list across the top',
   resizeTree: 'Drag to resize the file tree',
   resizeSides: 'Drag to resize the two columns',
   sourceLabel: 'Switch stats source',

package/src/client/row-window.ts

@@ -0,0 +1,132 @@
+/**
+ * Which rows a long diff actually has to put in the DOM.
+ *
+ * The side-by-side pane renders the WHOLE file in two columns, so its cost is
+ * linear in the file's length rather than in the size of the change. Measured
+ * on two files with one changed line each: 22 lines cost 349ms of main thread
+ * and 44 cells; 4,000 lines cost 3,868ms, 8,000 cells and 112,000 token spans,
+ * with a single 3.6-second frame during which nothing on the page moved. The
+ * guard lets a file through at 20,000 lines, which is five times that again.
+ *
+ * Windowing is exact here rather than approximate, because the pane's rows are
+ * a fixed height by construction: `.sideCode` is `white-space: pre` so no line
+ * ever wraps, and `.sideColGrid` sets `line-height` and `align-content: start`,
+ * which puts row `i` at `i * rowH` with no measuring at all.
+ *
+ * Pure: no React, no DOM. `tests/row-window.test.ts` loads it directly.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/client/row-window
+ */
+
+/** The pane's row height, matching `.sideColGrid`'s `line-height`. */
+export const DIFF_ROW_H = 20
+
+/**
+ * The grid's own top padding, from `.sideColGrid`.
+ *
+ * Only the change walk uses it, and only to place a block within the scrolled
+ * content. Being a few pixels out there is invisible — the walk deliberately
+ * leaves three rows of context above whatever it lands on, so this is well
+ * inside the margin it already keeps — which is why it is stated once here
+ * rather than published into the stylesheet as a custom property.
+ */
+export const DIFF_GRID_PAD_TOP = 8
+
+/**
+ * Files at or below this many rows are rendered whole.
+ *
+ * Windowing has its own costs — a scroll listener, two spacers, and rows that
+ * enter and leave the DOM — and none of them buys anything on a file that was
+ * never slow. Below the threshold the pane produces exactly the DOM it
+ * produced before, so the ordinary case is untouched by this change.
+ */
+export const WINDOW_WHOLE_BELOW = 400
+
+/**
+ * Rows kept beyond each edge of the viewport.
+ *
+ * Enough that a flick of the wheel lands on rows that are already there:
+ * dropping this to zero makes a fast scroll show blank bands, and raising it
+ * far just renders the file again.
+ */
+export const WINDOW_OVERSCAN = 40
+
+/**
+ * A viewport height to assume before the scroller has been measured.
+ *
+ * The first paint happens before any layout effect runs. Rendering nothing
+ * until the height is known would flash an empty pane; a screenful is both
+ * safe and close.
+ */
+const ASSUMED_VIEWPORT_PX = 1200
+
+/** The rows to render, and the empty space standing in for the rest. */
+export interface RowWindow {
+  /** First row to render. */
+  readonly start: number
+  /** One past the last row to render. */
+  readonly end: number
+  /** Height of the spacer above, in px. */
+  readonly padTop: number
+  /** Height of the spacer below, in px. */
+  readonly padBottom: number
+}
+
+/**
+ * @param value - a number from the DOM, which can be NaN or negative.
+ * @param fallback - used when it is neither finite nor usable.
+ * @returns a finite, non-negative number.
+ */
+function sane(value: number, fallback: number): number {
+  return Number.isFinite(value) && value > 0 ? value : fallback
+}
+
+/**
+ * The window of rows to render for a given scroll position.
+ *
+ * @param scrollTop - the scroller's current offset in px.
+ * @param viewportH - the scroller's visible height in px; 0 before it is measured.
+ * @param rowCount - how many rows the file has.
+ * @param rowH - row height in px.
+ * @param overscan - rows to keep beyond each edge.
+ * @returns the rows to render and the spacer heights standing in for the rest.
+ */
+export function rowWindow(
+  scrollTop: number,
+  viewportH: number,
+  rowCount: number,
+  rowH: number = DIFF_ROW_H,
+  overscan: number = WINDOW_OVERSCAN,
+): RowWindow {
+  const rows = Math.max(0, Math.trunc(rowCount))
+  const height = sane(rowH, DIFF_ROW_H)
+  if (rows <= WINDOW_WHOLE_BELOW) return { start: 0, end: rows, padTop: 0, padBottom: 0 }
+
+  const top = Number.isFinite(scrollTop) && scrollTop > 0 ? scrollTop : 0
+  const view = sane(viewportH, ASSUMED_VIEWPORT_PX)
+  const pad = Math.max(0, Math.trunc(overscan))
+
+  const first = Math.max(0, Math.floor(top / height) - pad)
+  const last = Math.min(rows, Math.ceil((top + view) / height) + pad)
+  // Scrolled past the end (a file that shrank under a live poll), `last` can
+  // land below `first`; an empty window is still a valid answer, and the
+  // spacers must add up to the full height either way.
+  const start = Math.min(first, rows)
+  const end = Math.max(start, last)
+  return { start, end, padTop: start * height, padBottom: (rows - end) * height }
+}
+
+/**
+ * Where a row sits inside the scroller, without touching the DOM.
+ *
+ * The change walk used to measure this off `getBoundingClientRect`, which
+ * stops working the moment a row it wants is outside the window — and a
+ * windowed pane's next change is very often exactly that.
+ *
+ * @param index - the row's index.
+ * @param rowH - row height in px.
+ * @returns the row's offset from the top of the scrolled content.
+ */
+export function rowTop(index: number, rowH: number = DIFF_ROW_H): number {
+  return Math.max(0, Math.trunc(index)) * sane(rowH, DIFF_ROW_H)
+}

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)