@cueloop/client 0.1.0-alpha.9 → 0.1.0-alpha.90

package/src/view-plan.test.ts

@@ -0,0 +1,545 @@
+import { describe, expect, test } from "bun:test";
+import {
+  blockRuns,
+  buildDisplay,
+  displayText,
+  marksByDisplay,
+  nextWorkBlock,
+  overlayMarks,
+  renderedOffsetAtOrAfter,
+  renderedOffsetAtOrBefore,
+  renderedOffsetFor,
+  renderedSpanToWork,
+  renderedStyleRuns,
+  renderedText,
+  safeLinkHref,
+  spanFromRange,
+  spanKey,
+  startSpan,
+  styledRunsFor,
+  workRangeForRendered,
+} from "./view-plan";
+import {
+  applyTextCuts,
+  cutBlock,
+  mergeTextCut,
+  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("a partial Cut stays one modified block even when only a short prefix survives", () => {
+    const base = "A seeded plan so cueloop dev always has a thread to open.";
+    const display = buildDisplay(base, "A seed");
+
+    expect(display).toHaveLength(1);
+    expect(display[0]!.type).toBe("mod");
+  });
+
+  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("a partial-word Cut leaves surviving characters plain instead of inserted", () => {
+    const base = "It lands under unin Threads then in the sidebar rather than a project.";
+    const firstStart = base.indexOf("under");
+    const firstEnd = firstStart + "under".length;
+    const secondStart = base.indexOf("Threads");
+    const secondEnd = secondStart + "Threads".length;
+    const cuts = mergeTextCut(
+      base,
+      mergeTextCut(base, [], firstStart, firstEnd),
+      secondStart,
+      secondEnd,
+    );
+    const [block] = buildDisplay(base, applyTextCuts(base, cuts), cuts);
+    const runs = blockRuns(block!, true);
+
+    expect(runs.filter((run) => run.role === "del").map((run) => run.text)).toEqual([
+      "under",
+      "Threads",
+    ]);
+    expect(
+      runs
+        .filter((run) => run.role !== "del")
+        .map((run) => run.text)
+        .join(""),
+    ).toBe("It lands  unin  then in the sidebar rather than a project.");
+    expect(runs.some((run) => run.role === "ins")).toBe(false);
+  });
+
+  test("a cross-block Cut keeps every survivor plain and strikes only selected characters", () => {
+    const base = "Keep before remove this.\n\n- remove that keep after";
+    const cuts = mergeTextCut(base, [], 12, 40);
+    const display = buildDisplay(base, applyTextCuts(base, cuts), cuts);
+    const runs = display.flatMap((block) => blockRuns(block, true));
+
+    expect(runs.filter((run) => run.role === "ins")).toEqual([]);
+    expect(
+      runs
+        .filter((run) => run.role === "del")
+        .map((run) => run.text)
+        .join(""),
+    ).toBe(base.slice(12, 40).replace("\n\n- ", ""));
+    expect(
+      runs
+        .filter((run) => run.role !== "del")
+        .map((run) => run.text)
+        .join(""),
+    ).toBe("Keep before keep after");
+  });
+
+  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("M4: link hrefs are scheme-validated for OSC 8 (#236)", () => {
+  test("trusts http(s) and mailto, drops everything else", () => {
+    // Assert
+    expect(safeLinkHref("https://example.com")).toBe("https://example.com");
+    expect(safeLinkHref("http://x")).toBe("http://x");
+    expect(safeLinkHref("mailto:a@b.c")).toBe("mailto:a@b.c");
+    expect(safeLinkHref("javascript:alert(1)")).toBeUndefined();
+    expect(safeLinkHref("./relative/path")).toBeUndefined();
+    expect(safeLinkHref(undefined)).toBeUndefined();
+  });
+
+  test("a control byte or space in the target drops the link", () => {
+    // Assert - ESC and BEL could splice into the OSC 8 escape stream
+    expect(safeLinkHref("https://x\x1b]8;;evil\x07")).toBeUndefined();
+    expect(safeLinkHref("https://x\x07")).toBeUndefined();
+    expect(safeLinkHref("https://x y")).toBeUndefined();
+  });
+
+  test("blockRuns carries the link href through to the link run", () => {
+    // Act
+    const block = buildDisplay("see [docs](https://example.com) now\n")[0]!;
+    const link = blockRuns(block, true).find((run) => run.role === "link")!;
+
+    // Assert
+    expect(link.text).toBe("docs");
+    expect(link.href).toBe("https://example.com");
+  });
+});
+
+describe("M3: inline emphasis composes with word-diff (#235)", () => {
+  test("context emphasis survives; added text keeps the green diff role; markers concealed", () => {
+    // Arrange - "**this**" is unchanged (context, stays emphasized); "safe"->"sound" is the edit
+    const block = buildDisplay("keep **this** safe\n", "keep **this** sound\n")[0]!;
+
+    // Act
+    const runs = blockRuns(block, true);
+
+    // Assert - no marker text renders anywhere
+    expect(runs.every((run) => !run.text.includes("*"))).toBe(true);
+    // the unchanged emphasized word keeps its strong role (context, not diffed)
+    expect(runs.find((run) => run.text === "this")!.role).toBe("strong");
+    // the added word is green (ins wins over any emphasis), the removed one opaque
+    expect(runs.find((run) => run.text.includes("sound"))!.role).toBe("ins");
+    expect(runs.some((run) => run.role === "del" && run.start === null)).toBe(true);
+  });
+
+  test("markers inside added text conceal while the run stays a positioned ins", () => {
+    // Arrange - an emphasized word is added into an otherwise unchanged line
+    const block = buildDisplay("keep it safe\n", "keep it **very** safe\n")[0]!;
+
+    // Act
+    const runs = blockRuns(block, true);
+    const added = runs.find((run) => run.text === "very")!;
+
+    // Assert - concealed markers, green role, and an exact work offset back into work text
+    expect(added.role).toBe("ins");
+    expect(added.start).not.toBeNull();
+    expect(block.work!.text.slice(added.start!, added.start! + "very".length)).toBe("very");
+    expect(runs.every((run) => !run.text.includes("*"))).toBe(true);
+  });
+
+  test("an anchor over an emphasized context word round-trips to its work offsets", () => {
+    // Arrange
+    const block = buildDisplay("hold **steady** now\n", "hold **steady** later\n")[0]!;
+    const runs = blockRuns(block, true);
+    const work = block.work!.text;
+    const start = work.indexOf("steady");
+
+    // Act
+    const rendered = renderedOffsetFor(runs, start);
+
+    // Assert
+    expect(rendered).not.toBeNull();
+    expect(workRangeForRendered(runs, rendered!, rendered! + "steady".length)).toEqual({
+      start,
+      end: start + "steady".length,
+    });
+  });
+});
+
+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 renderedString = runs.map((run) => run.text).join("");
+
+    expect(renderedString.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 renderedString = runs.map((run) => run.text).join("");
+
+    // Act
+    // select everything rendered: the work range is the whole work text
+    const range = workRangeForRendered(runs, 0, renderedString.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();
+  });
+
+  test("a span starting/ending on concealed markers snaps to the visible word", () => {
+    // Arrange - the word span over "**very**" covers the markers, which have
+    // no rendered cells; the clamped lookups land on "very" itself
+    const text = "keep it **very** safe\n";
+    const runs = blockRuns(buildDisplay(text)[0]!, true);
+    const spanStart = text.indexOf("**very**");
+    const spanEnd = spanStart + "**very**".length;
+
+    // Act
+    const renderedStart = renderedOffsetAtOrAfter(runs, spanStart)!;
+    const renderedEnd = renderedOffsetAtOrBefore(runs, spanEnd - 1)!;
+
+    // Assert
+    const renderedString = runs.map((run) => run.text).join("");
+
+    expect(renderedString.slice(renderedStart, renderedEnd + 1)).toBe("very");
+    // exact hits behave like renderedOffsetFor
+    expect(renderedOffsetAtOrAfter(runs, 0)).toBe(0);
+    expect(renderedOffsetAtOrBefore(runs, 0)).toBe(0);
+    // nothing positioned beyond the text end
+    expect(renderedOffsetAtOrAfter(runs, 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");
+  });
+
+  test("spanFromRange snaps a mid-word mouse drag to whole words", () => {
+    // Arrange - a drag from inside "two" to inside "three"
+    const dragStart = text.indexOf("two") + 1;
+    const dragEnd = text.indexOf("three") + 2;
+
+    // Act
+    const span = spanFromRange(0, text, dragStart, dragEnd)!;
+
+    // Assert - snaps outward to cover both touched words, ready for w/b/l/h
+    expect(text.slice(span.start, span.end)).toBe("two three");
+    expect(spanKey(span, "l", text)).toMatchObject({ wordEnd: 3 });
+  });
+
+  test("spanFromRange returns null when the range covers no word", () => {
+    // Assert - a range past the last word has nothing to select
+    expect(spanFromRange(0, text, text.length, text.length)).toBeNull();
+  });
+});
+
+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);
+  });
+});
+
+describe("rendered-text projection (markers concealed)", () => {
+  const linkedBlock = () => buildDisplay("Use the `flag` and see [docs](https://x.dev).")[0]!;
+
+  test("renderedText drops inline markers, keeping visible characters", () => {
+    expect(renderedText(linkedBlock())).toBe("Use the flag and see docs.");
+  });
+
+  test("renderedText leaves a table block's source verbatim", () => {
+    const table = buildDisplay("| a | b |\n| --- | --- |\n| 1 | 2 |")[0]!;
+
+    expect(table.kind).toBe("table");
+    expect(renderedText(table)).toBe("| a | b |\n| --- | --- |\n| 1 | 2 |");
+  });
+
+  test("renderedSpanToWork maps a rendered link label back to its work offsets", () => {
+    const display = buildDisplay("Use the `flag` and see [docs](https://x.dev).");
+    // "docs" sits at rendered offset 21 ("Use the flag and see ".length)
+    const work = renderedSpanToWork(display, 0, 0, 21, 25);
+    const workText = display[0]!.work!.text;
+
+    expect(workText.slice(work.start, work.end)).toBe("docs");
+  });
+
+  test("renderedSpanToWork maps rendered inline code back to the backtick content", () => {
+    const display = buildDisplay("Use the `flag` and see docs.");
+    // "flag" sits at rendered offset 8 ("Use the ".length)
+    const work = renderedSpanToWork(display, 0, 0, 8, 12);
+
+    expect(display[0]!.work!.text.slice(work.start, work.end)).toBe("flag");
+  });
+
+  test("styledRunsFor colors a link run and marks the covered stretch", () => {
+    const linkRow = buildDisplay("see [docs](https://x.dev) now")[0]!;
+    const roleRuns = renderedStyleRuns(linkRow);
+    // "see docs now"; mark the whole "docs" label (rendered offsets 4..8)
+    const runs = styledRunsFor(roleRuns, { start: 0, end: renderedText(linkRow).length }, [
+      { start: 4, end: 8 },
+    ]);
+    const link = runs.find((run) => run.role === "link")!;
+
+    expect(link.text).toBe("docs");
+    expect(link.marked).toBe(true);
+    expect(runs.find((run) => run.text === "see ")!.marked).toBe(false);
+  });
+
+  test("syntax tokens split painted code runs without moving annotation marks", () => {
+    const roles = [{ text: "export value", role: "plain" as const, start: 0 }];
+    const runs = styledRunsFor(
+      roles,
+      { start: 0, end: 12 },
+      [{ start: 5, end: 9 }],
+      [{ start: 0, end: 6, group: "keyword" }],
+    );
+
+    expect(runs.map((run) => run.text).join("")).toBe("export value");
+    expect(
+      runs
+        .filter((run) => run.syntaxGroup === "keyword")
+        .map((run) => run.text)
+        .join(""),
+    ).toBe("export");
+    expect(
+      runs
+        .filter((run) => run.marked)
+        .map((run) => run.text)
+        .join(""),
+    ).toBe("t va");
+  });
+});