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

package/src/diff-fold.test.ts

@@ -0,0 +1,78 @@
+/** Per-file collapse and full-file weave over the flat diff rows. */
+
+import { describe, expect, test } from "bun:test";
+import type { DiffRow } from "./view-diff";
+import { applyFold, weaveFullFileRows } from "./diff-fold";
+
+function row(kind: DiffRow["kind"], text: string, extra: Partial<DiffRow> = {}): DiffRow {
+  return { kind, text, file: "a.ts", ...extra };
+}
+
+// a two-line change in a four-line file: line 2 swapped, lines 1/3/4 unchanged
+const base: DiffRow[] = [
+  row("file", "a.ts"),
+  row("hunk", "@@ -1,3 +1,3 @@"),
+  row("ctx", "line one", { oldLine: 1, newLine: 1 }),
+  row("del", "old two", { oldLine: 2 }),
+  row("add", "new two", { newLine: 2 }),
+  row("ctx", "line three", { oldLine: 3, newLine: 3 }),
+];
+
+const contents = {
+  path: "a.ts",
+  oldContents: "line one\nold two\nline three\nline four\n",
+  newContents: "line one\nnew two\nline three\nline four\n",
+};
+
+describe("applyFold", () => {
+  test("with no fold state it returns the base rows unchanged", () => {
+    expect(applyFold(base, new Set(), new Set(), [contents])).toBe(base);
+  });
+
+  test("a collapsed file keeps only its file band", () => {
+    // Act
+    const folded = applyFold(base, new Set(["a.ts"]), new Set(), [contents]);
+
+    // Assert
+    expect(folded).toHaveLength(1);
+    expect(folded[0]).toEqual(row("file", "a.ts"));
+  });
+
+  test("an expanded file weaves the unchanged tail line the hunk never showed", () => {
+    // Act
+    const folded = applyFold(base, new Set(), new Set(["a.ts"]), [contents]);
+
+    // Assert - the hunk header is gone and "line four" (outside the hunk) now shows
+    expect(folded.some((r) => r.kind === "hunk")).toBe(false);
+    const four = folded.find((r) => r.text === "line four");
+
+    expect(four).toEqual(row("ctx", "line four", { oldLine: 4, newLine: 4 }));
+  });
+
+  test("expand is a no-op without the file's full contents", () => {
+    // Act - no contents entry, so the file keeps its hunks
+    const folded = applyFold(base, new Set(), new Set(["a.ts"]), undefined);
+
+    // Assert
+    expect(folded).toEqual(base);
+  });
+});
+
+describe("weaveFullFileRows", () => {
+  test("keeps the change rows and fills every unchanged line as context in order", () => {
+    // Arrange - the file's code rows (no headers)
+    const codeRows = base.slice(2);
+
+    // Act
+    const woven = weaveFullFileRows("a.ts", codeRows, contents.newContents);
+
+    // Assert - full file: ctx1, del, add, ctx3, ctx4
+    expect(woven.map((r) => `${r.kind}:${r.text}`)).toEqual([
+      "ctx:line one",
+      "del:old two",
+      "add:new two",
+      "ctx:line three",
+      "ctx:line four",
+    ]);
+  });
+});

package/src/diff-fold.ts

@@ -0,0 +1,126 @@
+/**
+ * Per-file fold state for the diff sheet, applied over the flat diff rows so the
+ * cursor, curation, and rendering all read one array. A collapsed file shows only
+ * its file band; an expanded file shows its whole contents with the diff woven in
+ * (unchanged lines become context rows), matching VSCode's "expand all lines".
+ */
+
+import type { DiffRow } from "./view-diff";
+
+/** The full old/new contents a diff carries per file (curatable diffs do). */
+export interface FileContents {
+  path: string;
+  newContents: string;
+  oldContents: string;
+}
+
+/** Split file contents into lines, dropping the single trailing newline the file carries. */
+function contentLines(contents: string): string[] {
+  if (contents === "") return [];
+
+  return contents.replace(/\n$/, "").split("\n");
+}
+
+/**
+ * Weave a file's hunk rows into its full contents: unchanged lines between and
+ * around the hunks become context rows, so the whole file renders with the diff
+ * inline. `codeRows` are the file's ctx/add/del rows in order (no headers).
+ */
+export function weaveFullFileRows(
+  fileName: string,
+  codeRows: DiffRow[],
+  newContents: string,
+): DiffRow[] {
+  const newLines = contentLines(newContents);
+  const woven: DiffRow[] = [];
+  // the next unchanged old/new line numbers to emit while filling gaps between hunks
+  let newCursor = 1;
+  let oldCursor = 1;
+  const fillTo = (newLine: number): void => {
+    while (newCursor < newLine) {
+      woven.push({
+        kind: "ctx",
+        text: newLines[newCursor - 1] ?? "",
+        file: fileName,
+        oldLine: oldCursor,
+        newLine: newCursor,
+      });
+      newCursor += 1;
+      oldCursor += 1;
+    }
+  };
+
+  for (const row of codeRows) {
+    if (row.newLine !== undefined) {
+      fillTo(row.newLine);
+      woven.push(row);
+      newCursor = row.newLine + 1;
+      if (row.kind === "ctx") oldCursor = (row.oldLine ?? oldCursor) + 1;
+    } else {
+      // a deletion consumes an old line only; it keeps its place before the additions
+      woven.push(row);
+      oldCursor = (row.oldLine ?? oldCursor) + 1;
+    }
+  }
+  // the unchanged tail after the last hunk
+  while (newCursor <= newLines.length) {
+    woven.push({
+      kind: "ctx",
+      text: newLines[newCursor - 1] ?? "",
+      file: fileName,
+      oldLine: oldCursor,
+      newLine: newCursor,
+    });
+    newCursor += 1;
+    oldCursor += 1;
+  }
+
+  return woven;
+}
+
+/**
+ * Rebuild the diff rows with per-file fold state. A collapsed file keeps only its
+ * file band; an expanded file with known contents shows its whole file woven; every
+ * other file keeps its hunks. Row order and the file bands themselves are preserved.
+ */
+export function applyFold(
+  base: DiffRow[],
+  collapsed: ReadonlySet<string>,
+  expanded: ReadonlySet<string>,
+  files: readonly FileContents[] | undefined,
+): DiffRow[] {
+  if (collapsed.size === 0 && expanded.size === 0) return base;
+  const contentsByPath = new Map((files ?? []).map((file) => [file.path, file]));
+  const out: DiffRow[] = [];
+  let index = 0;
+
+  while (index < base.length) {
+    const row = base[index]!;
+
+    if (row.kind !== "file") {
+      out.push(row);
+      index += 1;
+      continue;
+    }
+    out.push(row);
+    const file = row.file;
+    let end = index + 1;
+
+    while (end < base.length && base[end]!.kind !== "file") end += 1;
+    const body = base.slice(index + 1, end);
+    const contents = contentsByPath.get(file);
+
+    if (collapsed.has(file)) {
+      // only the file band; the body is hidden
+    } else if (expanded.has(file) && contents) {
+      const codeRows = body.filter((bodyRow) => bodyRow.kind !== "hunk");
+
+      out.push(...weaveFullFileRows(file, codeRows, contents.newContents));
+    } else {
+      out.push(...body);
+    }
+    index = end;
+  }
+
+  return out;
+}

package/src/diff-syntax.test.ts

@@ -41,6 +41,22 @@ describe("spansByLine", () => {
     expect(lineSpans[1]).toEqual([{ start: 0, end: 2, group: "comment" }]);
   });
 
+  test("a capture ending past the source clamps to its end instead of walking forever", () => {
+    // Arrange - offsets past the string, as byte offsets over a multi-byte line report
+    const source = "a│b\ncc";
+    const highlights: SimpleHighlight[] = [
+      [0, 9, "string"],
+      [12, 20, "comment"],
+    ];
+
+    // Act
+    const lineSpans = spansByLine(source, highlights);
+
+    // Assert - the covered text is colored to the end and the second capture paints nothing
+    expect(lineSpans[0]).toEqual([{ start: 0, end: 3, group: "string" }]);
+    expect(lineSpans[1]).toEqual([{ start: 0, end: 2, group: "string" }]);
+  });
+
   test("resolves overlapping captures with later winning", () => {
     // Arrange
     const source = "foo";

package/src/diff-syntax.ts

@@ -111,10 +111,13 @@ export function spansByLine(source: string, highlights: SimpleHighlight[]): Synt
     return Array.from({ length: Math.max(0, end - start) }, () => undefined);
   });
 
-  for (const [start, end, group] of highlights) {
+  for (const [start, rawEnd, group] of highlights) {
     // A capture can span newlines (block comments, template literals); color the
-    // covered columns on every line it crosses, not just the starting line.
-    let cursor = start;
+    // covered columns on every line it crosses, not just the starting line. Offsets
+    // past the source (byte offsets from a multi-byte line) clamp to its end, or the
+    // walk below would sit on the last line forever.
+    const end = Math.min(rawEnd, source.length);
+    let cursor = Math.max(0, start);
 
     while (cursor < end) {
       const line = lineOf(cursor);

package/src/discussions.ts

@@ -0,0 +1,79 @@
+/**
+ * Discussions: the conversations an annotated surface hosts inline. A root
+ * annotation, its replies, and the span they mark, grouped so two roots on the
+ * very same text read as one conversation. Pure over the resolved marks, so the
+ * plan thread view and the diff sheet group the same way.
+ */
+
+import type { Annotation, ReviewSession } from "@cueloop/schema";
+import type { Mark } from "./view-plan";
+import { comparePositions, type TextSpan } from "./thread-selection";
+
+/** One conversation: a root annotation, its replies, and the span they mark. */
+export interface Discussion {
+  key: string;
+  /** The annotation replies attach to. */
+  rootId: string;
+  /** The block the card renders under: where the span ends. */
+  blockIndex: number;
+  span: TextSpan;
+  annotations: Annotation[];
+}
+
+export function spanKey(span: TextSpan): string {
+  return `${span.start.blockIndex}:${span.start.char}:${span.end.blockIndex}:${span.end.char}`;
+}
+
+/**
+ * Roots group by the span they resolved to (two roots on the very same text
+ * read as one conversation); replies join the discussion their replyTo names, or
+ * stand as roots when that root is gone.
+ */
+export function discussionsFrom(session: ReviewSession, marks: Map<number, Mark[]>): Discussion[] {
+  const byId = new Map(session.annotations.map((annotation) => [annotation.id, annotation]));
+  const spanOf = new Map<string, TextSpan>();
+
+  for (const [displayIndex, blockMarks] of marks) {
+    for (const mark of blockMarks) {
+      if (!mark.annotationId || spanOf.has(mark.annotationId)) continue;
+      spanOf.set(
+        mark.annotationId,
+        mark.span ?? {
+          start: { blockIndex: displayIndex, char: mark.start },
+          end: { blockIndex: displayIndex, char: mark.end },
+        },
+      );
+    }
+  }
+  const resolved = [...spanOf.keys()].map((id) => byId.get(id)!).filter(Boolean);
+  const isRoot = (annotation: Annotation): boolean =>
+    annotation.replyTo === undefined || !spanOf.has(annotation.replyTo);
+  const grouped = new Map<string, Discussion>();
+  const discussionOfRoot = new Map<string, Discussion>();
+
+  for (const annotation of resolved.filter(isRoot)) {
+    const span = spanOf.get(annotation.id)!;
+    const key = spanKey(span);
+    const discussion = grouped.get(key) ?? {
+      key,
+      rootId: annotation.id,
+      blockIndex: span.end.blockIndex,
+      span,
+      annotations: [],
+    };
+
+    discussion.annotations.push(annotation);
+    grouped.set(key, discussion);
+    discussionOfRoot.set(annotation.id, discussion);
+  }
+  for (const annotation of resolved.filter((candidate) => !isRoot(candidate))) {
+    discussionOfRoot.get(annotation.replyTo!)?.annotations.push(annotation);
+  }
+  for (const discussion of grouped.values()) {
+    discussion.annotations.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+  }
+
+  return [...grouped.values()].toSorted((left, right) =>
+    comparePositions(left.span.start, right.span.start),
+  );
+}

package/src/ghostty-terminal.test.ts

@@ -21,10 +21,11 @@ describe("ghostty-terminal FFI", () => {
     term.write(new TextEncoder().encode("hi\x1b[1;32mGO\x1b[0m"));
     const cells = [0, 1, 2, 3].map((x) => term.readCell(x, 0));
 
-    // Assert - glyphs decode, and the green run is bold on ANSI palette index 2
+    // Assert - glyphs decode, the row reads as text, and the green run is bold on ANSI palette index 2
     expect(
       cells.map((c) => (c?.codepoint ? String.fromCodePoint(c.codepoint) : " ")).join(""),
     ).toBe("hiGO");
+    expect(term.rowText(0, 80)).toBe("hiGO");
     expect(cells[2]!.bold).toBe(true);
     expect(cells[2]!.fg).toEqual({ kind: "palette", index: 2 });
     term.free();

package/src/ghostty-terminal.ts

@@ -60,25 +60,31 @@ function nativeLibraryPath(): string | null {
   return existsSync(path) ? path : null;
 }
 
+/** One shared load of the VT library; null when no dylib ships or it failed to load. */
+let ghosttyFactory: GhosttyTerminalFactory | null | undefined;
+
 /**
  * Open the Ghostty VT library for this platform, or return null when the prebuilt
  * dylib is missing (the caller degrades to a herdr split instead of embedding).
+ * The library is opened once per process; later calls return the same factory.
  */
 export function loadGhosttyTerminals(): GhosttyTerminalFactory | null {
+  if (ghosttyFactory !== undefined) return ghosttyFactory;
   const path = nativeLibraryPath();
 
-  if (!path) return null;
+  if (!path) return (ghosttyFactory = null);
   try {
     const lib = dlopen(path, CVT_SYMBOLS);
 
-    return new GhosttyTerminalFactory(lib.symbols);
+    ghosttyFactory = new GhosttyTerminalFactory(lib.symbols);
   } catch (error) {
     // The file exists but failed to load (bad arch, missing symbol) - a real
     // fault, not the expected no-prebuilt case; surface it, then degrade.
     console.error(`cueloop: failed to load ${path}:`, error);
-
-    return null;
+    ghosttyFactory = null;
   }
+
+  return ghosttyFactory;
 }
 
 /** Creates `GhosttyTerminal`s that share one loaded copy of the VT library. */
@@ -146,6 +152,23 @@ export class GhosttyTerminal {
     };
   }
 
+  /**
+   * Row `y` as text: blank cells read as spaces, the trailing half of a wide
+   * glyph is skipped, and trailing spaces are trimmed.
+   */
+  rowText(y: number, cols: number): string {
+    let line = "";
+
+    for (let x = 0; x < cols; x++) {
+      const cell = this.readCell(x, y);
+
+      if (cell === null || cell.width === 2) continue;
+      line += cell.codepoint === 0 ? " " : String.fromCodePoint(cell.codepoint);
+    }
+
+    return line.trimEnd();
+  }
+
   /** The cursor's current viewport position and visibility. */
   readCursor(): GhosttyCursor {
     if (this.freed) return { x: 0, y: 0, visible: false };

package/src/intent-dispatch.test.ts

@@ -71,10 +71,23 @@ function baseController(): ReviewController {
     dismissToast: mock(),
     display: mock(() => []),
     rows: mock(() => []),
+    setFileCollapsed: mock(),
+    isFileCollapsed: mock(() => false),
+    setFileExpanded: mock(),
+    isFileExpanded: mock(() => false),
+    canExpandFile: mock(() => false),
+    copyFilePath: mock(),
+    fileStats: mock(() => new Map()),
     files: mock(() => []),
     working: mock(() => ""),
+    projectFiles: mock(() => Promise.resolve<string[]>([])),
+    readFile: mock(() => Promise.resolve<string | null>(null)),
+    repoFiles: mock(() => Promise.resolve<string[]>([])),
+    repoReadFile: mock(() => Promise.resolve<string | null>(null)),
+    repoChanges: mock(() => Promise.resolve([])),
     open: mock(),
     deleteSession: mock(),
+    renameSession: mock(),
     setSelfName: mock(),
     cut: mock(),
     toggleRejectHunk: mock(),
@@ -106,7 +119,6 @@ function baseController(): ReviewController {
     finishReview: mock(),
     dismissCompletion: mock(),
     optInAutoClose: mock(),
-    saveReviewPanel: mock(),
   };
 }
 
@@ -123,9 +135,6 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     inboxCursor: 0,
     mode: { type: "normal" },
     session: null,
-    reviewMode: "expanded",
-    reviewWidth: 34,
-    terminalWidth: 120,
     focusedAnnotationId: undefined,
     selectedCurationId: undefined,
     railTab: "review",
@@ -133,13 +142,11 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     authorNames: {},
     quickActions: [],
     renameAuthor: mock(),
+    renameThread: mock(),
     liveInput: { current: "" },
-    reviewWidthRef: { current: 34 },
     setCursor: mock(),
     setInboxCursor: mock(),
     setMode: mock(),
-    setReviewMode: mock(),
-    setReviewWidth: mock(),
     setRailTab: mock(),
     setSelectedEntryId: mock(),
     setFocusedAnnotationId: mock(),
@@ -148,6 +155,7 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     selectCardFromDocument: mock(),
     runEditorHandOff: mock(),
     openCardEdit: mock(),
+    toggleDiffView: mock(),
     ...overrides,
   };
 }
@@ -349,17 +357,15 @@ describe("marker-actions popover", () => {
 });
 
 describe("openSubmit", () => {
-  test("force-opens the review rail so the confirm card can never be hidden", () => {
+  test("opens the submit confirm with the default verdict", () => {
     // Arrange
-    const deps = makeDeps({ session: sessionWith([]), reviewMode: "hidden" });
+    const deps = makeDeps({ session: sessionWith([]) });
     const dispatch = createIntentDispatch(deps);
 
     // Act
     dispatch({ type: "openSubmit" });
 
     // Assert
-    expect(deps.setReviewMode).toHaveBeenCalledWith("expanded");
-    expect(deps.setRailTab).toHaveBeenCalledWith("review");
     expect(deps.setMode).toHaveBeenCalledWith({ type: "submit", verdict: "approve", summary: "" });
   });
 
@@ -436,6 +442,20 @@ describe("restoreCuration", () => {
   });
 });
 
+describe("toggleDiffView", () => {
+  test("delegates to the App-owned toggle", () => {
+    // Arrange
+    const deps = makeDeps();
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "toggleDiffView" });
+
+    // Assert
+    expect(deps.toggleDiffView).toHaveBeenCalled();
+  });
+});
+
 describe("exit", () => {
   test("calls the exit hook with 0", () => {
     // Arrange