@cueloop/client 0.1.0-alpha.66 → 0.1.0-alpha.68

package/src/session-controller.tree.test.ts

@@ -91,6 +91,7 @@ function fakeClient(session: ReviewSession) {
       parentSessionId: id,
     })),
     sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: mock(async (_id: string, _shareId: string) => session),
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
@@ -116,6 +117,31 @@ async function connected(session = sessionFixture()) {
   return { controller, client, session };
 }
 
+describe("read-only guards", () => {
+  test("an observer's rename and delete never reach the daemon", async () => {
+    // Arrange - a read-only controller over a client whose mutations would throw
+    const session = sessionFixture();
+    const client = fakeClient(session);
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => client,
+      readOnly: true,
+      shareTransport,
+    });
+
+    controller.connect();
+    await tick();
+
+    // Act - the sidebar's rename and delete, invoked directly
+    controller.renameSession(session.id, "hijacked");
+    controller.deleteSession(session.id);
+    await tick();
+
+    // Assert - both answer read-only and the throwing client stubs were never called
+    expect(controller.getSnapshot().status).toBe("observer - read-only");
+  });
+});
+
 describe("tree primitives", () => {
   test("a move back shows the earlier path at once and asks the daemon for the same move", async () => {
     // Arrange

package/src/session-controller.ts

@@ -27,6 +27,7 @@ import {
   switchBranch,
   viewOfPath,
   type Annotation,
+  type DiffFileContents,
   type ReviewSession,
   type SessionHistory,
   type VerdictKind,
@@ -43,7 +44,9 @@ import {
 } from "./share";
 import { buildDisplay, nextWorkBlock, type DisplayBlock } from "./view-plan";
 import { entryTarget, treeRows, type TreeRow } from "./tree-view";
-import { diffRowAnchor, diffRows, type DiffRow } from "./view-diff";
+import { diffRowBlocks, diffRows, fileChangeCounts, type DiffRow } from "./view-diff";
+import { applyFold } from "./diff-fold";
+import { copyToClipboard } from "./clipboard";
 import {
   changeRejectionForRow,
   hunkRejectionForRow,
@@ -57,14 +60,7 @@ import type { FileDiffMetadata } from "@pierre/diffs";
 import { firstUnviewedIndex, walkFiles, type WalkFile } from "./walk";
 import { editInEditor } from "./editor";
 import { focusHerdrPane } from "./herdr";
-import {
-  persistAutoClose,
-  persistReviewState,
-  persistReviewWidth,
-  type AutoClose,
-  type CueloopConfig,
-} from "./config";
-import type { ReviewPanelMode } from "./review-panel";
+import { persistAutoClose, type AutoClose, type CueloopConfig } from "./config";
 
 /**
  * Post-submit lifecycle (a review pane should hand you back to the agent,
@@ -167,6 +163,8 @@ const DEFAULT_SHARE_TRANSPORT: ShareTransport = {
 export interface ReviewControllerOptions {
   home?: string;
   sessionId?: string;
+  /** The directory the client launched in; its git repo backs the no-session welcome tree. Defaults to process.cwd(). */
+  cwd?: string;
   /** Observer mode: stored for the key reducer's read-only gate. */
   readOnly?: boolean;
   onExit?: (code: number) => void;
@@ -197,13 +195,37 @@ export interface ReviewController {
   /** Derived projections, cached per session identity. */
   display(): DisplayBlock[];
   rows(): DiffRow[];
+  /** Fold a file's diff body to just its band, or unfold it; rows() reflects the change. */
+  setFileCollapsed(file: string, collapsed: boolean): void;
+  isFileCollapsed(file: string): boolean;
+  /** Weave a file's full contents inline (unchanged lines as context), or fold back to hunks. */
+  setFileExpanded(file: string, expanded: boolean): void;
+  isFileExpanded(file: string): boolean;
+  /** Whether the file carries the full contents weaving needs (curatable diffs do). */
+  canExpandFile(file: string): boolean;
+  /** Copy a file's path to the clipboard; reports the outcome via status. */
+  copyFilePath(file: string): void;
+  /** Per-file added/removed line counts from the base rows (survives collapse). */
+  fileStats(): Map<string, { additions: number; deletions: number }>;
   /** The walk's step list, derived from the diff rows. */
   files(): WalkFile[];
   working(): string;
+  /** The workspace's tracked files (git ls-files) for the Project tree; empty when unavailable. */
+  projectFiles(): Promise<string[]>;
+  /** Read a workspace file's contents for a Changes file tab; null when it cannot be read. */
+  readFile(path: string): Promise<string | null>;
+  /** The launch repo's tracked files for the no-session welcome Project tree; empty when not a repo. */
+  repoFiles(): Promise<string[]>;
+  /** Read a launch-repo file's contents for a welcome file tab; null when it cannot be read. */
+  repoReadFile(path: string): Promise<string | null>;
+  /** The launch repo's working-tree changed files for the no-session welcome Changes tree. */
+  repoChanges(): Promise<readonly DiffFileContents[]>;
   /** Open a session from the inbox. */
   open(id: string): void;
   /** Delete a session for good (inbox delete); the inbox refreshes on the event. */
   deleteSession(id: string): void;
+  /** Rename a session's title; the inbox refreshes on the event. */
+  renameSession(id: string, title: string): void;
   /** Record the viewer's own name into the share's participant registry (collaborator self-naming). */
   setSelfName(name: string): void;
   /** Cut the block under the cursor, or restore a cut one. */
@@ -279,12 +301,6 @@ export interface ReviewController {
   dismissCompletion(): void;
   /** From the completion prompt: persist auto-close and start the countdown. */
   optInAutoClose(): void;
-  /**
-   * Persist the review-panel layout (client view state) to the user config so
-   * the collapse mode and rail width survive a restart. A read-only config dir
-   * never blocks the review.
-   */
-  saveReviewPanel(layout: { mode?: ReviewPanelMode; width?: number }): void;
 }
 
 export function createReviewController(options: ReviewControllerOptions): ReviewController {
@@ -332,6 +348,10 @@ class Controller implements ReviewController {
     models: new Map(),
     tree: [],
   };
+  /** File paths whose diff body is folded to just the file band. */
+  private collapsedFiles = new Set<string>();
+  /** File paths woven to their full contents (unchanged lines shown as context). */
+  private expandedFiles = new Set<string>();
   /** The diff's reject decisions live on the session record; the daemon curates from them. */
   private get rejections(): HunkRejection[] {
     return this.snapshot.session?.curation ?? EMPTY_REJECTIONS;
@@ -367,12 +387,13 @@ class Controller implements ReviewController {
         if (this.closed) return void client.close();
         this.client = client;
         client.onEvent((event) => {
-          // another controller/observer changed state: re-fetch
+          // another controller/observer changed state: re-fetch the active session's content
           const session = this.snapshot.session;
 
           if (session && event.sessionId === session.id) void this.refreshSession(session.id);
-          // the Threads sidebar shows the inbox even on a direct open, so keep it fresh
-          void this.refreshInbox();
+          // only the list-changing events touch the Threads sidebar; refreshing on every
+          // content edit (session.updated) would amplify an active review into a request storm
+          if (event.event !== "session.updated") void this.refreshInbox();
         });
         await client.subscribe();
         // load the inbox in both cases so the sidebar can jump between threads
@@ -428,6 +449,9 @@ class Controller implements ReviewController {
 
     if (this.derivedFor === session) return;
     this.derivedFor = session;
+    // a new session starts fully expanded, never inheriting the prior diff's fold state
+    this.collapsedFiles.clear();
+    this.expandedFiles.clear();
     const rows =
       session && session.artifact.type === "diff" ? diffRows(session.artifact.content) : [];
     const models = new Map<string, FileDiffMetadata>();
@@ -456,8 +480,58 @@ class Controller implements ReviewController {
 
   rows(): DiffRow[] {
     this.ensureDerived();
+    if (this.collapsedFiles.size === 0 && this.expandedFiles.size === 0) return this.derived.rows;
+
+    return applyFold(
+      this.derived.rows,
+      this.collapsedFiles,
+      this.expandedFiles,
+      this.snapshot.session?.artifact.files,
+    );
+  }
+
+  setFileCollapsed(file: string, collapsed: boolean): void {
+    if (collapsed) {
+      this.collapsedFiles.add(file);
+      this.expandedFiles.delete(file);
+    } else {
+      this.collapsedFiles.delete(file);
+    }
+    this.update({});
+  }
+
+  isFileCollapsed(file: string): boolean {
+    return this.collapsedFiles.has(file);
+  }
+
+  setFileExpanded(file: string, expanded: boolean): void {
+    if (expanded) {
+      this.expandedFiles.add(file);
+      this.collapsedFiles.delete(file);
+    } else {
+      this.expandedFiles.delete(file);
+    }
+    this.update({});
+  }
+
+  isFileExpanded(file: string): boolean {
+    return this.expandedFiles.has(file);
+  }
+
+  canExpandFile(file: string): boolean {
+    return (this.snapshot.session?.artifact.files ?? []).some((entry) => entry.path === file);
+  }
+
+  copyFilePath(file: string): void {
+    void copyToClipboard(file).then((copied) =>
+      this.setStatus(copied ? `copied ${file}` : "no clipboard tool available"),
+    );
+  }
+
+  fileStats(): Map<string, { additions: number; deletions: number }> {
+    this.ensureDerived();
 
-    return this.derived.rows;
+    return fileChangeCounts(this.derived.rows);
   }
 
   files(): WalkFile[] {
@@ -472,6 +546,52 @@ class Controller implements ReviewController {
     return session ? (session.workingCopy ?? session.artifact.content) : "";
   }
 
+  async projectFiles(): Promise<string[]> {
+    const session = this.snapshot.session;
+    if (this.client?.projectFiles === undefined || !session) return [];
+
+    return this.client.projectFiles(session.id);
+  }
+
+  async readFile(path: string): Promise<string | null> {
+    const session = this.snapshot.session;
+    if (this.client?.fileContents === undefined || !session) return null;
+
+    return this.client.fileContents(session.id, path);
+  }
+
+  /** The repo the sidebar tree/changes point at: the thread's own repo, else the launch directory. */
+  private sidebarRepoRoot(): string {
+    return this.snapshot.session?.workspace.repoRoot || this.options.cwd || process.cwd();
+  }
+
+  async repoFiles(): Promise<string[]> {
+    if (this.client?.repoFiles === undefined) return [];
+
+    return this.client.repoFiles(this.sidebarRepoRoot());
+  }
+
+  async repoReadFile(path: string): Promise<string | null> {
+    if (this.client?.repoFileContents === undefined) return null;
+
+    return this.client.repoFileContents(this.sidebarRepoRoot(), path);
+  }
+
+  async repoChanges(): Promise<readonly DiffFileContents[]> {
+    // a diff review pins its captured snapshot; every other thread reflects the live working tree
+    const session = this.snapshot.session;
+    if (session?.artifact.type === "diff") return session.artifact.files ?? [];
+    if (this.client?.repoChanges === undefined) return [];
+    const changes = await this.client.repoChanges(this.sidebarRepoRoot());
+
+    return changes.map((change) => ({
+      path: change.path,
+      status: change.status,
+      oldContents: "",
+      newContents: "",
+    }));
+  }
+
   // Refreshes race the connection teardown: an event can arrive while close()
   // is rejecting in-flight requests, and a fire-and-forget refresh must never
   // surface that as an unhandled rejection.
@@ -526,6 +646,7 @@ class Controller implements ReviewController {
   }
 
   deleteSession(id: string): void {
+    if (this.readOnly) return this.setStatus("observer - read-only");
     this.client
       ?.sessionDelete(id)
       .then(() => this.setStatus("plan deleted"))
@@ -534,6 +655,16 @@ class Controller implements ReviewController {
       );
   }
 
+  renameSession(id: string, title: string): void {
+    if (this.readOnly) return this.setStatus("observer - read-only");
+    this.client
+      ?.sessionSetTitle(id, title)
+      .then(() => this.setStatus("thread renamed"))
+      .catch((cause: unknown) =>
+        this.setStatus(`rename failed: ${cause instanceof Error ? cause.message : String(cause)}`),
+      );
+  }
+
   setSelfName(name: string): void {
     const session = this.snapshot.session;
 
@@ -823,7 +954,9 @@ class Controller implements ReviewController {
     let anchor;
 
     if (session.artifact.type === "diff") {
-      anchor = { ...diffRowAnchor(this.rows(), displayIndex), blockIndex: displayIndex };
+      // rows are the diff's blocks: a span over one or more code rows anchors with the
+      // same quote, context, and position selectors a plan span does
+      anchor = makeAnchor(diffRowBlocks(this.rows()), displayIndex, start, end, endDisplayIndex);
     } else {
       const display = this.display();
       const workBlocks = display.filter((entry) => entry.work).map((entry) => entry.work!);
@@ -1262,13 +1395,4 @@ class Controller implements ReviewController {
     }
     this.autoClose = DEFAULT_AUTO_CLOSE;
   }
-
-  saveReviewPanel(layout: { mode?: ReviewPanelMode; width?: number }): void {
-    try {
-      if (layout.mode !== undefined) persistReviewState(layout.mode);
-      if (layout.width !== undefined) persistReviewWidth(layout.width);
-    } catch {
-      // a read-only config dir must never block collapsing or resizing the rail
-    }
-  }
 }

package/src/slash-palette.ts

@@ -0,0 +1,83 @@
+/**
+ * The "/" quick-action palette behind a composer: the skill list a leading
+ * slash opens, its prefix > substring > subsequence filter, and the inline
+ * "/word" completion offered mid-sentence. Pure; the surfaces render it.
+ */
+
+import { quickActionBody, type QuickAction } from "./config";
+
+export interface SlashItem {
+  name: string;
+  description: string;
+  body: string;
+}
+
+export function slashItemsFrom(quickActions: QuickAction[]): SlashItem[] {
+  return quickActions.map((action) => ({
+    name: action.prompt
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, ""),
+    description: action.metadata ?? action.prompt,
+    body: quickActionBody(action),
+  }));
+}
+
+/** Prefix beats substring beats subsequence. */
+export function slashFilter(items: SlashItem[], query: string): SlashItem[] {
+  const needle = query.toLowerCase();
+
+  if (needle.length === 0) return items;
+  const scored: Array<{ item: SlashItem; score: number }> = [];
+
+  for (const item of items) {
+    const name = item.name.toLowerCase();
+    let score = 0;
+
+    if (name.startsWith(needle)) score = 3;
+    else if (name.includes(needle)) score = 2;
+    else {
+      let matched = 0;
+
+      for (const character of name) {
+        if (character === needle[matched]) matched++;
+      }
+      if (matched === needle.length) score = 1;
+    }
+    if (score > 0) scored.push({ item, score });
+  }
+
+  return scored.toSorted((left, right) => right.score - left.score).map((entry) => entry.item);
+}
+
+/**
+ * A skill invoked mid-sentence: the trailing "/word" token when text already
+ * precedes it (a draft that starts with "/" is the palette, not an inline
+ * completion). Newline-safe, since the token may sit at the start of a new line.
+ */
+export function inlineSlashToken(text: string): string | null {
+  if (text.startsWith("/")) return null;
+  const match = /(?:^|\s)(\/[a-zA-Z0-9-]*)$/.exec(text);
+
+  return match ? match[1]! : null;
+}
+
+export interface InlineSlash {
+  token: string;
+  suggestion: SlashItem;
+}
+
+/** The inline completion state: the trailing "/word" and its closest skill, or null. */
+export function resolveInlineSuggestion(
+  slashActive: boolean,
+  text: string,
+  quickActions: QuickAction[],
+): InlineSlash | null {
+  if (slashActive) return null;
+  const token = inlineSlashToken(text);
+
+  if (token === null) return null;
+  const suggestion = slashFilter(slashItemsFrom(quickActions), token.slice(1))[0];
+
+  return suggestion ? { token, suggestion } : null;
+}

package/src/split-diff.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, test } from "bun:test";
+import { diffRows } from "./view-diff";
+import { splitDiffRows, splitRowOffsets, type SplitRow } from "./split-diff";
+
+const PATCH = `diff --git a/greet.ts b/greet.ts
+--- a/greet.ts
++++ b/greet.ts
+@@ -1,4 +1,4 @@
+ const name = "world";
+-console.log("hi " + name);
+-console.log("done");
++console.log("hello " + name);
++console.log("finished");
+ export {};
+`;
+
+function pairs(rows: SplitRow[]): SplitRow[] {
+  return rows.filter((row) => row.kind === "pair");
+}
+
+describe("splitDiffRows", () => {
+  test("carries the file and hunk headers through unchanged", () => {
+    // Act
+    const split = splitDiffRows(diffRows(PATCH));
+
+    // Assert
+    expect(split[0]).toMatchObject({ kind: "file", file: "greet.ts", text: "greet.ts" });
+    expect(split[1]?.kind).toBe("hunk");
+  });
+
+  test("a context line sits on both sides with its own line numbers", () => {
+    // Act
+    const first = pairs(splitDiffRows(diffRows(PATCH)))[0]!;
+
+    // Assert
+    expect(first.left).toMatchObject({ kind: "ctx", lineNumber: 1 });
+    expect(first.right).toMatchObject({ kind: "ctx", lineNumber: 1 });
+    expect(first.left?.text).toBe(first.right?.text);
+  });
+
+  test("a balanced change block pairs each deletion against an addition", () => {
+    // Act - the two deletions zip against the two additions, one per row
+    const changed = pairs(splitDiffRows(diffRows(PATCH))).filter(
+      (row) => row.left?.kind === "del" || row.right?.kind === "add",
+    );
+
+    // Assert
+    expect(changed).toHaveLength(2);
+    expect(changed[0]).toMatchObject({
+      left: { kind: "del", lineNumber: 2 },
+      right: { kind: "add", lineNumber: 2 },
+    });
+    expect(changed[1]).toMatchObject({
+      left: { kind: "del", lineNumber: 3 },
+      right: { kind: "add", lineNumber: 3 },
+    });
+  });
+
+  test("an unbalanced block blank-fills the shorter side", () => {
+    // Arrange - one deletion, three additions
+    const patch = `diff --git a/x.ts b/x.ts
+--- a/x.ts
++++ b/x.ts
+@@ -1,2 +1,4 @@
+ keep;
+-old;
++new1;
++new2;
++new3;
+`;
+
+    // Act
+    const changed = pairs(splitDiffRows(diffRows(patch))).filter(
+      (row) => row.left?.kind === "del" || row.right?.kind === "add",
+    );
+
+    // Assert - three rows tall, only the first has a left deletion
+    expect(changed).toHaveLength(3);
+    expect(changed[0]?.left?.kind).toBe("del");
+    expect(changed[1]?.left).toBeUndefined();
+    expect(changed[2]?.left).toBeUndefined();
+    expect(changed.map((row) => row.right?.text.trim())).toEqual(["new1;", "new2;", "new3;"]);
+  });
+
+  test("each side keeps its originating unified row for anchoring", () => {
+    // Act
+    const base = diffRows(PATCH);
+    const changed = pairs(splitDiffRows(base)).find((row) => row.right?.kind === "add")!;
+
+    // Assert - the split line points back at a row from the base list
+    expect(base[changed.right!.rowIndex]).toBe(changed.right!.row);
+  });
+});
+
+describe("splitRowOffsets", () => {
+  test("maps both sides of a pair to the same y and steps a file band by three", () => {
+    // Arrange
+    const base = diffRows(PATCH);
+    const split = splitDiffRows(base);
+
+    // Act
+    const offsets = splitRowOffsets(split);
+
+    // Assert - the file band is three rows and the hunk one, so the first context pair sits at y 4
+    const firstContext = split.find((row) => row.kind === "pair" && row.left?.kind === "ctx")!;
+
+    expect(offsets.get(firstContext.left!.rowIndex)).toBe(4);
+    expect(offsets.get(firstContext.right!.rowIndex)).toBe(4);
+  });
+});

package/src/split-diff.ts

@@ -0,0 +1,149 @@
+/**
+ * Side-by-side diff projection: fold the unified DiffRow list into paired rows,
+ * old on the left and new on the right. A context line sits on both sides; a
+ * change block zips its deletions against its additions to the taller side, with
+ * a blank filler where one side runs out. Each side keeps its originating unified
+ * row, so the cursor, anchors, and curation keep working through the base rows.
+ */
+
+import type { DiffRow } from "./view-diff";
+
+/** One code line on one side of the split, carrying its originating unified row. */
+export interface SplitLine {
+  /** The unified diff row this side renders; the anchor and curation target. */
+  row: DiffRow;
+  /** Index of the originating row in the base list; the cursor and curation index. */
+  rowIndex: number;
+  kind: "ctx" | "del" | "add";
+  text: string;
+  /** Old line number for the left column, new line number for the right column. */
+  lineNumber?: number;
+}
+
+/** A rendered split row: a file band, a hunk header, or an old|new line pair. */
+export interface SplitRow {
+  kind: "file" | "hunk" | "pair";
+  file: string;
+  /** Header text for file and hunk rows. */
+  text?: string;
+  /** Index of the header in the base list, for file and hunk rows. */
+  rowIndex?: number;
+  /** Old side: a context or deletion line, or absent (blank filler). */
+  left?: SplitLine;
+  /** New side: a context or addition line, or absent (blank filler). */
+  right?: SplitLine;
+}
+
+/** A base row paired with its index in the base list. */
+interface IndexedRow {
+  row: DiffRow;
+  index: number;
+}
+
+function contextLine({ row, index }: IndexedRow, side: "left" | "right"): SplitLine {
+  return {
+    row,
+    rowIndex: index,
+    kind: "ctx",
+    text: row.text,
+    lineNumber: side === "left" ? row.oldLine : row.newLine,
+  };
+}
+
+function deletionLine({ row, index }: IndexedRow): SplitLine {
+  return { row, rowIndex: index, kind: "del", text: row.text, lineNumber: row.oldLine };
+}
+
+function additionLine({ row, index }: IndexedRow): SplitLine {
+  return { row, rowIndex: index, kind: "add", text: row.text, lineNumber: row.newLine };
+}
+
+/** Zip a change block's deletions against its additions, blank-filling the shorter side. */
+function zipChangeBlock(
+  deletions: IndexedRow[],
+  additions: IndexedRow[],
+  file: string,
+): SplitRow[] {
+  const pairs: SplitRow[] = [];
+  const height = Math.max(deletions.length, additions.length);
+
+  for (let index = 0; index < height; index++) {
+    const del = deletions[index];
+    const add = additions[index];
+
+    pairs.push({
+      kind: "pair",
+      file,
+      left: del ? deletionLine(del) : undefined,
+      right: add ? additionLine(add) : undefined,
+    });
+  }
+
+  return pairs;
+}
+
+/** Project unified diff rows into side-by-side split rows. */
+export function splitDiffRows(rows: DiffRow[]): SplitRow[] {
+  const split: SplitRow[] = [];
+  let pendingDeletions: IndexedRow[] = [];
+  let pendingAdditions: IndexedRow[] = [];
+  let blockFile = "";
+
+  const flushChangeBlock = (): void => {
+    if (pendingDeletions.length === 0 && pendingAdditions.length === 0) return;
+    split.push(...zipChangeBlock(pendingDeletions, pendingAdditions, blockFile));
+    pendingDeletions = [];
+    pendingAdditions = [];
+  };
+
+  rows.forEach((row, index) => {
+    if (row.kind === "add") {
+      blockFile = row.file;
+      pendingAdditions.push({ row, index });
+      return;
+    }
+    if (row.kind === "del") {
+      blockFile = row.file;
+      pendingDeletions.push({ row, index });
+      return;
+    }
+    // any non-change row closes the current change block before it renders
+    flushChangeBlock();
+    if (row.kind === "file" || row.kind === "hunk") {
+      split.push({ kind: row.kind, file: row.file, text: row.text, rowIndex: index });
+    } else
+      split.push({
+        kind: "pair",
+        file: row.file,
+        left: contextLine({ row, index }, "left"),
+        right: contextLine({ row, index }, "right"),
+      });
+  });
+  flushChangeBlock();
+
+  return split;
+}
+
+/**
+ * Visual y of each base row index in the split layout, so the cursor scrolls into
+ * view. A file band spans three rows (rule, name, rule), a hunk one, a pair one; a
+ * pair's two sides share the row, so both base indices map to the same y.
+ */
+export function splitRowOffsets(splitRows: SplitRow[]): Map<number, number> {
+  const offsets = new Map<number, number>();
+  let contentY = 0;
+
+  for (const row of splitRows) {
+    if (row.kind === "file") {
+      contentY += 3;
+    } else if (row.kind === "hunk") {
+      contentY += 1;
+    } else {
+      if (row.left) offsets.set(row.left.rowIndex, contentY);
+      if (row.right) offsets.set(row.right.rowIndex, contentY);
+      contentY += 1;
+    }
+  }
+
+  return offsets;
+}