@cueloop/client 0.1.0-alpha.3 → 0.1.0-alpha.30

package/src/test-support.ts

@@ -0,0 +1,87 @@
+/**
+ * Shared driving helpers for the virtual-terminal App suites: key presses
+ * settle through a macrotask yield (input parser + React scheduler), one
+ * render pass, and the renderer's visual-idle wait - no fixed-duration
+ * sleeps. Waits on daemon round-trips go through waitForFrame/waitFor with
+ * generous pass budgets.
+ */
+
+import type { TestRendererSetup } from "@opentui/core/testing";
+
+/** Pass budget for waits that include daemon or subprocess round-trips. */
+export const WAIT_PASSES = { maxPasses: 400 };
+
+/**
+ * One macrotask yield lets the input parser and the React scheduler run,
+ * then a render pass commits the result before the visual-idle wait.
+ */
+export async function settle(setup: TestRendererSetup): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await setup.renderOnce();
+  await setup.waitForVisualIdle();
+}
+
+/** Drive one key press: letters type as text; named keys use KeyCodes ids. */
+export async function press(setup: TestRendererSetup, key: string): Promise<void> {
+  if (key === "enter") setup.mockInput.pressKey("RETURN");
+  else if (key === "escape") setup.mockInput.pressKey("ESCAPE");
+  else if (key === "backspace") setup.mockInput.pressKey("BACKSPACE");
+  else if (key === "left") setup.mockInput.pressKey("ARROW_LEFT");
+  else if (key === "right") setup.mockInput.pressKey("ARROW_RIGHT");
+  else return typeText(setup, key);
+  await settle(setup);
+}
+
+export async function typeText(setup: TestRendererSetup, text: string): Promise<void> {
+  await setup.mockInput.typeText(text);
+  await settle(setup);
+}
+
+const WAIT_DEADLINE_MS = 30_000;
+
+/**
+ * waitForFrame gives up as soon as the renderer is idle, but external timers
+ * (the parser's bare-ESC window, daemon IO, spawned editors) settle on the
+ * event loop while nothing is scheduled. Between attempts, one real
+ * event-loop turn plus a render pass lets those land; the deadline bounds
+ * the whole wait.
+ */
+async function waitForFramePredicate(
+  setup: TestRendererSetup,
+  predicate: (frame: string) => boolean,
+): Promise<string> {
+  const deadline = Date.now() + WAIT_DEADLINE_MS;
+  for (;;) {
+    try {
+      return await setup.waitForFrame(predicate, { maxPasses: 50 });
+    } catch (error) {
+      if (Date.now() > deadline) throw error;
+      await new Promise((resolve) => setTimeout(resolve, 1));
+      await setup.renderOnce();
+    }
+  }
+}
+
+/** Wait until a state predicate holds (daemon round-trips included). */
+export async function waitForState(setup: TestRendererSetup, predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + WAIT_DEADLINE_MS;
+  for (;;) {
+    try {
+      return await setup.waitFor(predicate, { maxPasses: 50 });
+    } catch (error) {
+      if (Date.now() > deadline) throw error;
+      await new Promise((resolve) => setTimeout(resolve, 1));
+      await setup.renderOnce();
+    }
+  }
+}
+
+/** Wait until the frame contains the needle (daemon round-trips included). */
+export async function waitForText(setup: TestRendererSetup, needle: string): Promise<string> {
+  return waitForFramePredicate(setup, (frame) => frame.includes(needle));
+}
+
+/** Wait until the frame no longer contains the needle. */
+export async function waitForTextGone(setup: TestRendererSetup, needle: string): Promise<string> {
+  return waitForFramePredicate(setup, (frame) => !frame.includes(needle));
+}

package/src/theme.ts

@@ -1,5 +1,5 @@
 /**
- * Semantic theme tokens (#22). Values carry over from the design-system
+ * Semantic theme tokens. Values carry over from the design-system
  * prototypes (tokens.css). One built-in dark theme for now; the theme
  * registry (palette-derived themes, terminal theme, user overrides) layers
  * on top of these slots without touching consumers.
@@ -23,6 +23,27 @@ export interface Theme {
   markSuggestionBg: string;
   insFg: string;
   delFg: string;
+  /** Dimmed layer painted behind centered dialogs. */
+  backdrop: string;
+}
+
+/**
+ * The dimmed variant behind the walk wizard: every reading color drops to
+ * the dim token so the file list stays legible context, not competition.
+ * Layout tokens (backgrounds, cursor) keep their values.
+ */
+export function dimmedTheme(theme: Theme): Theme {
+  return {
+    ...theme,
+    text: theme.textDim,
+    textMuted: theme.textDim,
+    accent: theme.textDim,
+    green: theme.textDim,
+    red: theme.textDim,
+    blue: theme.textDim,
+    insFg: theme.textDim,
+    delFg: theme.textDim,
+  };
 }
 
 export const DARK: Theme = {
@@ -43,4 +64,5 @@ export const DARK: Theme = {
   markSuggestionBg: "#20351f",
   insFg: "#62d96b",
   delFg: "#ff6b6b",
+  backdrop: "#14141b",
 }

package/src/view-diff.test.ts

@@ -21,23 +21,29 @@ index 111..222 100644
 
 describe("diffRows", () => {
   test("flattens files, hunks, and signed lines with line numbers", () => {
+    // Act
     const rows = diffRows(PATCH);
-    expect(rows[0]).toMatchObject({ t: "file", file: "src/store.ts" });
-    expect(rows[1]!.t).toBe("hunk");
-    const del = rows.find((r) => r.t === "del")!;
+
+    // Assert
+    expect(rows[0]).toMatchObject({ kind: "file", file: "src/store.ts" });
+    expect(rows[1]!.kind).toBe("hunk");
+    const del = rows.find((row) => row.kind === "del")!;
     expect(del.text).toContain("private items = [];");
     expect(del.oldLine).toBe(3);
-    const adds = rows.filter((r) => r.t === "add");
+    const adds = rows.filter((row) => row.kind === "add");
     expect(adds[0]!.text).toContain("new Map()");
     expect(adds[0]!.newLine).toBe(3);
     expect(adds[1]!.newLine).toBe(4);
     // two hunks
-    expect(rows.filter((r) => r.t === "hunk").length).toBe(2);
+    expect(rows.filter((row) => row.kind === "hunk").length).toBe(2);
   });
 
   test("context lines carry both line numbers", () => {
+    // Act
     const rows = diffRows(PATCH);
-    const ctx = rows.find((r) => r.t === "ctx")!;
+
+    // Assert
+    const ctx = rows.find((row) => row.kind === "ctx")!;
     expect(ctx.oldLine).toBe(1);
     expect(ctx.newLine).toBe(1);
   });
@@ -45,9 +51,14 @@ describe("diffRows", () => {
 
 describe("diffRowAnchor", () => {
   test("quote is the line, neighbors are the context selectors", () => {
+    // Arrange
     const rows = diffRows(PATCH);
-    const idx = rows.findIndex((r) => r.text.includes("new Map()"));
-    const anchor = diffRowAnchor(rows, idx);
+    const rowIndex = rows.findIndex((row) => row.text.includes("new Map()"));
+
+    // Act
+    const anchor = diffRowAnchor(rows, rowIndex);
+
+    // Assert
     expect(anchor.quote).toContain("new Map()");
     expect(anchor.prefix.length).toBeGreaterThan(0);
     expect(anchor.suffix.length).toBeGreaterThan(0);

package/src/view-diff.ts

@@ -1,5 +1,5 @@
 /**
- * Diff artifact projection (#18 slice 3): flatten @pierre/diffs' parsed
+ * Diff artifact projection: flatten @pierre/diffs' parsed
  * patch model into render rows. Line-anchored annotations use the same
  * quote-primary anchors as plans: quote = the line content, prefix/suffix =
  * the neighbor lines - so the whole anchor/feedback pipeline is shared.
@@ -7,10 +7,10 @@
 
 import { parsePatchFiles, type FileDiffMetadata } from "@pierre/diffs";
 
-export type DiffRowType = "file" | "hunk" | "ctx" | "add" | "del";
+export type DiffRowKind = "file" | "hunk" | "ctx" | "add" | "del";
 
 export interface DiffRow {
-  t: DiffRowType;
+  kind: DiffRowKind;
   text: string;
   file: string;
   oldLine?: number;
@@ -22,35 +22,35 @@ export function diffRows(patchText: string): DiffRow[] {
   const patches = parsePatchFiles(patchText);
   for (const patch of patches) {
     for (const file of patch.files) {
-      rows.push({ t: "file", text: fileLabel(file), file: file.name });
+      rows.push({ kind: "file", text: fileLabel(file), file: file.name });
       for (const hunk of file.hunks) {
-        rows.push({ t: "hunk", text: hunk.hunkSpecs ?? "@@", file: file.name });
+        rows.push({ kind: "hunk", text: hunk.hunkSpecs ?? "@@", file: file.name });
         let oldLine = hunk.deletionStart;
         let newLine = hunk.additionStart;
-        for (const seg of hunk.hunkContent) {
-          if (seg.type === "context") {
-            for (let i = 0; i < seg.lines; i++) {
+        for (const segment of hunk.hunkContent) {
+          if (segment.type === "context") {
+            for (let lineOffset = 0; lineOffset < segment.lines; lineOffset++) {
               rows.push({
-                t: "ctx",
-                text: file.additionLines[seg.additionLineIndex + i] ?? "",
+                kind: "ctx",
+                text: file.additionLines[segment.additionLineIndex + lineOffset] ?? "",
                 file: file.name,
                 oldLine: oldLine++,
                 newLine: newLine++,
               });
             }
           } else {
-            for (let i = 0; i < seg.deletions; i++) {
+            for (let lineOffset = 0; lineOffset < segment.deletions; lineOffset++) {
               rows.push({
-                t: "del",
-                text: file.deletionLines[seg.deletionLineIndex + i] ?? "",
+                kind: "del",
+                text: file.deletionLines[segment.deletionLineIndex + lineOffset] ?? "",
                 file: file.name,
                 oldLine: oldLine++,
               });
             }
-            for (let i = 0; i < seg.additions; i++) {
+            for (let lineOffset = 0; lineOffset < segment.additions; lineOffset++) {
               rows.push({
-                t: "add",
-                text: file.additionLines[seg.additionLineIndex + i] ?? "",
+                kind: "add",
+                text: file.additionLines[segment.additionLineIndex + lineOffset] ?? "",
                 file: file.name,
                 newLine: newLine++,
               });
@@ -68,14 +68,14 @@ function fileLabel(file: FileDiffMetadata): string {
 }
 
 /** Quote-primary anchor for a diff row: neighbors as context selectors. */
-export function diffRowAnchor(rows: DiffRow[], idx: number): { quote: string; prefix: string; suffix: string } {
-  const row = rows[idx]!;
-  const prev = rows[idx - 1];
-  const next = rows[idx + 1];
+export function diffRowAnchor(rows: DiffRow[], rowIndex: number): { quote: string; prefix: string; suffix: string } {
+  const row = rows[rowIndex]!;
+  const prev = rows[rowIndex - 1];
+  const next = rows[rowIndex + 1];
   return {
     quote: row.text,
-    prefix: prev && (prev.t === "ctx" || prev.t === "add" || prev.t === "del") ? prev.text.slice(-24) : "",
-    suffix: next && (next.t === "ctx" || next.t === "add" || next.t === "del") ? next.text.slice(0, 24) : "",
+    prefix: prev && (prev.kind === "ctx" || prev.kind === "add" || prev.kind === "del") ? prev.text.slice(-24) : "",
+    suffix: next && (next.kind === "ctx" || next.kind === "add" || next.kind === "del") ? next.text.slice(0, 24) : "",
   };
 }
 

package/src/view-plan.test.ts

@@ -0,0 +1,260 @@
+import { describe, expect, test } from "bun:test";
+import {
+  blockRuns,
+  buildDisplay,
+  displayText,
+  marksByDisplay,
+  nextWorkBlock,
+  overlayMarks,
+  renderedOffsetFor,
+  spanKey,
+  startSpan,
+  workRangeForRendered,
+} from "./view-plan";
+import { cutBlock, parseBlocks, restoreBlock, restoreLine, type Annotation } from "@cueloop/schema";
+
+const BASE = `# Plan
+
+## Context
+
+The daemon persists sessions to disk atomically.
+
+- first item
+- second item
+`;
+
+describe("buildDisplay reconciliation", () => {
+  test("no working copy: everything is same", () => {
+    // Act
+    const display = buildDisplay(BASE);
+
+    // Assert
+    expect(display.every((block) => block.type === "same")).toBe(true);
+  });
+
+  test("reworded block pairs as mod (similar)", () => {
+    // Arrange
+    const working = BASE.replace("persists sessions to disk", "writes sessions to disk");
+
+    // Act
+    const display = buildDisplay(BASE, working);
+
+    // Assert
+    const mod = display.find((block) => block.type === "mod")!;
+    expect(mod.base!.text).toContain("persists");
+    expect(mod.work!.text).toContain("writes");
+  });
+
+  test("unrelated cut + insert do NOT merge into a mod", () => {
+    // Arrange
+    const working = BASE.replace("- second item\n", "") + "\nA totally new closing note.\n";
+
+    // Act
+    const display = buildDisplay(BASE, working);
+
+    // Assert
+    expect(display.some((block) => block.type === "del" && block.base!.text === "second item")).toBe(true);
+    expect(display.some((block) => block.type === "add" && block.work!.text.includes("closing note"))).toBe(true);
+    expect(display.some((block) => block.type === "mod")).toBe(false);
+  });
+
+  test("ordered list items get running numbers", () => {
+    // Act
+    const display = buildDisplay("1. one\n2. two\n3. three\n");
+
+    // Assert
+    expect(display.map((block) => block.orderedItemNumber)).toEqual([1, 2, 3]);
+  });
+});
+
+describe("blockRuns + overlayMarks", () => {
+  test("mod blocks emit word-diff runs that reconstruct both sides", () => {
+    // Arrange
+    const block = buildDisplay("plain old text here\n", "plain new text here\n")[0]!;
+
+    // Act
+    const runs = blockRuns(block, true);
+
+    // Assert
+    const oldSide = runs.filter((run) => run.role !== "ins").map((run) => run.text).join("");
+    const newSide = runs.filter((run) => run.role !== "del").map((run) => run.text).join("");
+    expect(oldSide).toBe("plain old text here");
+    expect(newSide).toBe("plain new text here");
+  });
+
+  test("marks bind to working-text offsets and skip del runs", () => {
+    // Arrange
+    const block = buildDisplay("old words linger\n", "new words linger\n")[0]!;
+    const runs = blockRuns(block, true);
+
+    // Act
+    const marked = overlayMarks(runs, [{ start: 4, end: 9, role: "mark-comment" }]); // "words"
+
+    // Assert
+    const markedText = marked.filter((run) => run.role === "mark-comment").map((run) => run.text).join("");
+    expect(markedText).toBe("words");
+    // del run text untouched
+    expect(marked.some((run) => run.role === "del" && run.text === "old")).toBe(true);
+  });
+
+  test("marks never override ins emphasis", () => {
+    // Arrange
+    const block = buildDisplay("keep\n", "keep added\n")[0]!;
+
+    // Act
+    const runs = overlayMarks(blockRuns(block, true), [{ start: 0, end: 10, role: "mark-comment" }]);
+
+    // Assert
+    expect(runs.some((run) => run.role === "ins")).toBe(true);
+  });
+});
+
+describe("marksByDisplay", () => {
+  test("annotations resolve into display coordinates", () => {
+    // Arrange
+    const working = BASE.replace("first item", "first item edited beyond recognition of it");
+    const display = buildDisplay(BASE, working);
+    const ann: Annotation = {
+      id: "a1",
+      kind: "comment",
+      anchor: { quote: "atomically", prefix: "to disk ", suffix: "." },
+      body: "define atomically",
+      createdAt: "",
+    };
+
+    // Act
+    const map = marksByDisplay([ann], display);
+
+    // Assert
+    const [displayIndex, marks] = [...map.entries()][0]!;
+    expect(displayText(display[displayIndex]!)).toContain("atomically");
+    expect(marks[0]!.annotationId).toBe("a1");
+  });
+
+  test("orphaned annotations produce no marks", () => {
+    // Arrange
+    const display = buildDisplay(BASE);
+    const ann: Annotation = {
+      id: "a1",
+      kind: "comment",
+      anchor: { quote: "text that is gone", prefix: "", suffix: "" },
+      body: "",
+      createdAt: "",
+    };
+
+    // Assert
+    expect(marksByDisplay([ann], display).size).toBe(0);
+  });
+});
+
+describe("rendered/work offset mapping", () => {
+  test("plain blocks map 1:1 in both directions", () => {
+    // Arrange
+    const block = buildDisplay("alpha beta gamma\n")[0]!;
+    const runs = blockRuns(block, true);
+
+    // Assert
+    expect(renderedOffsetFor(runs, 6)).toBe(6);
+    expect(workRangeForRendered(runs, 6, 10)).toEqual({ start: 6, end: 10 });
+  });
+
+  test("inline del runs shift rendered offsets in word-diffed blocks", () => {
+    // Arrange
+    // rendered: "old new words linger" - "old " is a del run without offsets
+    const block = buildDisplay("old words linger\n", "new words linger\n")[0]!;
+    const runs = blockRuns(block, true);
+    const workText = displayText(block);
+    const wordsAt = workText.indexOf("words");
+
+    // Act
+    const rendered = renderedOffsetFor(runs, wordsAt)!;
+
+    // Assert
+    const renderedText = runs.map((run) => run.text).join("");
+    expect(renderedText.slice(rendered, rendered + "words".length)).toBe("words");
+    // reading a rendered selection over "words" recovers the work range
+    expect(workRangeForRendered(runs, rendered, rendered + "words".length)).toEqual({
+      start: wordsAt,
+      end: wordsAt + "words".length,
+    });
+  });
+
+  test("a rendered selection spanning a del run keeps only positioned text", () => {
+    // Arrange
+    const block = buildDisplay("old words\n", "new words\n")[0]!;
+    const runs = blockRuns(block, true);
+    const renderedText = runs.map((run) => run.text).join("");
+
+    // Act
+    // select everything rendered: the work range is the whole work text
+    const range = workRangeForRendered(runs, 0, renderedText.length)!;
+
+    // Assert
+    expect(displayText(block).slice(range.start, range.end)).toBe(displayText(block));
+  });
+
+  test("offsets outside any positioned run map to null", () => {
+    // Arrange
+    const runs = blockRuns(buildDisplay("short\n")[0]!, true);
+
+    // Assert
+    expect(renderedOffsetFor(runs, 99)).toBeNull();
+    expect(workRangeForRendered(runs, 90, 99)).toBeNull();
+  });
+});
+
+describe("span mode", () => {
+  const text = "one two three four";
+  test("v selects the first word; l grows; w slides; $ to end", () => {
+    // Act
+    let span = startSpan(0, text)!;
+
+    // Assert
+    expect(text.slice(span.start, span.end)).toBe("one");
+
+    // Act
+    span = spanKey(span, "l", text);
+
+    // Assert
+    expect(text.slice(span.start, span.end)).toBe("one two");
+
+    // Act
+    span = spanKey(span, "w", text);
+
+    // Assert
+    expect(text.slice(span.start, span.end)).toBe("two three");
+
+    // Act
+    span = spanKey(span, "$", text);
+
+    // Assert
+    expect(text.slice(span.start, span.end)).toBe("two three four");
+  });
+});
+
+describe("cut / restore round-trip", () => {
+  test("cut removes the block lines; restore puts them back", () => {
+    // Arrange
+    const blocks = parseBlocks(BASE);
+    const listItem = blocks.find((candidate) => candidate.text === "second item")!;
+
+    // Act
+    const cut = cutBlock(BASE, listItem);
+
+    // Assert
+    expect(cut).not.toContain("second item");
+
+    // Arrange
+    const display = buildDisplay(BASE, cut);
+    const deletedIndex = display.findIndex((block) => block.type === "del");
+    const line = restoreLine(nextWorkBlock(display, deletedIndex), cut.split("\n").length);
+
+    // Act
+    // undefined = the working copy round-tripped back to the submitted revision
+    const restored = restoreBlock(BASE, cut, listItem, line);
+
+    // Assert
+    expect(restored).toBeUndefined();
+    expect(buildDisplay(BASE, restored).every((block) => block.type === "same")).toBe(true);
+  });
+});