@cueloop/client 0.1.0-alpha.65 → 0.1.0-alpha.67

package/src/config.ts

@@ -2,8 +2,7 @@
  * Layered TOML config: built-in defaults → user config → trusted repo
  * config → env. Sections: [keys] action = "combo" (every action rebindable),
  * [theme] per-token overrides, [ui] auto_close + editor + theme (a named
- * preset) + the review-panel layout (review_width + review_state),
- * [integrations.obsidian] notes-vault export.
+ * preset) + pins, [integrations.obsidian] notes-vault export.
  */
 
 import { existsSync, readFileSync } from "node:fs";
@@ -15,7 +14,6 @@ import { dirname } from "node:path";
 import * as v from "valibot";
 import { DARK, type Theme } from "./theme";
 import { DEFAULT_THEME_NAME, isThemeName, themeForName, type ThemeName } from "./theme-presets";
-import { REVIEW_DEFAULT_WIDTH, clampWidth, type ReviewPanelMode } from "./review-panel";
 
 export interface KeymapConfig {
   [action: string]: string | string[];
@@ -28,6 +26,9 @@ export interface IntegrationsConfig {
 /** Post-submit behavior: "off" prompts, 0 closes instantly, N counts down. */
 export type AutoClose = "off" | number;
 
+/** How the Changes diff renders: one inline column, or old|new side by side (only when zoomed). */
+export type DiffViewMode = "unified" | "split";
+
 /** One marker-popover quick action: a preset comment body, plus optional extra lines. */
 export interface QuickAction {
   prompt: string;
@@ -93,17 +94,15 @@ export interface CueloopConfig {
   theme: Theme;
   /** The `[theme]` per-token overrides alone, so a live theme switch can re-compose them onto a new preset. */
   themeOverrides: Partial<Theme>;
-  /**
-   * ui.reviewState / ui.reviewWidth are CLIENT VIEW STATE: the review panel's
-   * collapse mode and expanded-rail width, persisted so they survive restarts.
-   */
   ui: {
     autoClose: AutoClose;
     editor?: string;
-    reviewState: ReviewPanelMode;
-    reviewWidth: number;
     /** The selected theme preset name; its tokens are the base for `theme`, before any `[theme]` overrides. */
     theme: ThemeName;
+    /** How the Changes diff renders when zoomed: one inline column or old|new side by side. */
+    diffView: DiffViewMode;
+    /** Session ids the user has pinned to the top of the sidebar; client-local view state. */
+    pins: string[];
   };
   /** Planner-local author renames: identity id → display name ([authors] table). */
   authors: Record<string, string>;
@@ -123,6 +122,9 @@ export const DEFAULT_KEYS: CueloopConfig["keys"] = {
   cut: ["x"],
   reject_hunk: ["X"],
   restore_curation: ["u"],
+  collapse_file: ["right"],
+  expand_file: ["left"],
+  split_diff: ["s"],
   edit: ["e"],
   next_annotation: ["n"],
   prev_annotation: ["p"],
@@ -132,9 +134,6 @@ export const DEFAULT_KEYS: CueloopConfig["keys"] = {
   share: ["S"],
   quit: ["q"],
   walk: ["w"],
-  review_cycle: ["b"],
-  review_wider: ["]"],
-  review_narrower: ["["],
 };
 
 const ConfigDocumentSchema = v.object({
@@ -165,9 +164,9 @@ const UiSchema = v.object({
     undefined,
   ),
   editor: v.fallback(v.optional(v.string()), undefined),
-  review_width: v.fallback(v.optional(v.pipe(v.number(), v.finite())), undefined),
-  review_state: v.fallback(v.optional(v.picklist(["expanded", "compact", "hidden"])), undefined),
   theme: v.fallback(v.optional(v.string()), undefined),
+  diff_view: v.fallback(v.optional(v.picklist(["unified", "split"])), undefined),
+  pins: v.fallback(v.optional(v.array(v.string())), undefined),
 });
 const ObsidianSchema = v.object({
   vault: v.fallback(v.optional(v.string()), undefined),
@@ -252,9 +251,8 @@ function layer(
   if (ui.success) {
     if (ui.output.auto_close !== undefined) out.ui.autoClose = ui.output.auto_close;
     if (ui.output.editor?.trim()) out.ui.editor = ui.output.editor.trim();
-    if (ui.output.review_width !== undefined)
-      out.ui.reviewWidth = clampWidth(ui.output.review_width);
-    if (ui.output.review_state !== undefined) out.ui.reviewState = ui.output.review_state;
+    if (ui.output.diff_view !== undefined) out.ui.diffView = ui.output.diff_view;
+    if (ui.output.pins !== undefined) out.ui.pins = ui.output.pins;
   }
   if (integrations.success && integrations.output.obsidian) {
     mergeObsidian(out.integrations.obsidian, integrations.output.obsidian);
@@ -272,9 +270,9 @@ export function loadConfig(
     themeOverrides: {},
     ui: {
       autoClose: "off",
-      reviewState: "expanded",
-      reviewWidth: REVIEW_DEFAULT_WIDTH,
       theme: DEFAULT_THEME_NAME,
+      diffView: "unified",
+      pins: [],
     },
     authors: {},
     actions: [...DEFAULT_QUICK_ACTIONS],
@@ -403,19 +401,19 @@ export function persistAutoClose(value: AutoClose, userConfigPath?: string): voi
   persistUiSetting("auto_close", value === "off" ? '"off"' : String(value), userConfigPath);
 }
 
-/** Persist the expanded-rail width (`[ui] review_width`) into the user config. */
-export function persistReviewWidth(width: number, userConfigPath?: string): void {
-  persistUiSetting("review_width", String(clampWidth(width)), userConfigPath);
+/** Persist the selected theme preset (`[ui] theme`) into the user config. */
+export function persistTheme(name: ThemeName, userConfigPath?: string): void {
+  persistUiSetting("theme", `"${name}"`, userConfigPath);
 }
 
-/** Persist the review-panel collapse mode (`[ui] review_state`) into the config. */
-export function persistReviewState(state: ReviewPanelMode, userConfigPath?: string): void {
-  persistUiSetting("review_state", `"${state}"`, userConfigPath);
+/** Persist the diff-view choice (`[ui] diff_view`) into the user config. */
+export function persistDiffView(mode: DiffViewMode, userConfigPath?: string): void {
+  persistUiSetting("diff_view", `"${mode}"`, userConfigPath);
 }
 
-/** Persist the selected theme preset (`[ui] theme`) into the user config. */
-export function persistTheme(name: ThemeName, userConfigPath?: string): void {
-  persistUiSetting("theme", `"${name}"`, userConfigPath);
+/** Persist the pinned-thread ids (`[ui] pins`) into the user config. */
+export function persistPins(ids: readonly string[], userConfigPath?: string): void {
+  persistUiSetting("pins", `[${ids.map(tomlString).join(", ")}]`, userConfigPath);
 }
 
 function escapeRegExp(text: string): string {

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/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