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

package/src/diff-intraline.test.ts

@@ -0,0 +1,238 @@
+import { describe, expect, spyOn, test } from "bun:test";
+import * as intraline from "./diff-intraline";
+import {
+  createIntralineResolver,
+  intralineRunsByRow,
+  wordLevelChanges,
+  type IntralineRun,
+} from "./diff-intraline";
+import type { DiffRow } from "./view-diff";
+
+function line(kind: DiffRow["kind"], text: string): DiffRow {
+  return { kind, text, file: "a.ts" };
+}
+
+function joinText(runs: IntralineRun[]): string {
+  return runs.map((run) => run.text).join("");
+}
+
+function changedText(runs: IntralineRun[]): string {
+  return runs
+    .filter((run) => run.changed)
+    .map((run) => run.text)
+    .join("");
+}
+
+describe("wordLevelChanges", () => {
+  test("marks only the changed word and stays whitespace-lossless", () => {
+    // Arrange
+    const oldText = "const foo = 1";
+    const newText = "const foo = 2";
+
+    // Act
+    const changes = wordLevelChanges(oldText, newText);
+
+    // Assert
+    expect(
+      changes
+        .filter((change) => change.kind === "common")
+        .map((change) => change.text)
+        .join(""),
+    ).toBe("const foo = ");
+    expect(
+      changes
+        .filter((change) => change.kind === "removed")
+        .map((change) => change.text)
+        .join(""),
+    ).toBe("1");
+    expect(
+      changes
+        .filter((change) => change.kind === "added")
+        .map((change) => change.text)
+        .join(""),
+    ).toBe("2");
+    // old text reconstructs from common + removed, new text from common + added
+    expect(
+      changes
+        .filter((change) => change.kind !== "added")
+        .map((change) => change.text)
+        .join(""),
+    ).toBe(oldText);
+    expect(
+      changes
+        .filter((change) => change.kind !== "removed")
+        .map((change) => change.text)
+        .join(""),
+    ).toBe(newText);
+  });
+});
+
+describe("intralineRunsByRow", () => {
+  test("pairs a deletion with its addition and highlights the changed word on each side", () => {
+    // Arrange
+    const rows = [
+      line("ctx", "unchanged"),
+      line("del", "const foo = 1"),
+      line("add", "const foo = 2"),
+    ];
+
+    // Act
+    const runsByRow = intralineRunsByRow(rows);
+
+    // Assert
+    const deletionRuns = runsByRow.get(1)!;
+    const additionRuns = runsByRow.get(2)!;
+
+    expect(joinText(deletionRuns)).toBe("const foo = 1");
+    expect(joinText(additionRuns)).toBe("const foo = 2");
+    expect(changedText(deletionRuns)).toBe("1");
+    expect(changedText(additionRuns)).toBe("2");
+  });
+
+  test("omits context rows and rows with no counterpart", () => {
+    // Arrange
+    const rows = [line("ctx", "keep me"), line("add", "brand new line")];
+
+    // Act
+    const runsByRow = intralineRunsByRow(rows);
+
+    // Assert
+    expect(runsByRow.size).toBe(0);
+  });
+
+  test("pairs only min(deletions, additions); the surplus stays a plain row", () => {
+    // Arrange - two deletions, one addition
+    const rows = [line("del", "alpha one"), line("del", "beta two"), line("add", "alpha ONE")];
+
+    // Act
+    const runsByRow = intralineRunsByRow(rows);
+
+    // Assert
+    expect(runsByRow.has(0)).toBe(true); // first deletion pairs with the addition
+    expect(runsByRow.has(1)).toBe(false); // second deletion has no counterpart
+    expect(runsByRow.has(2)).toBe(true);
+    expect(changedText(runsByRow.get(0)!)).toBe("one");
+    expect(changedText(runsByRow.get(2)!)).toBe("ONE");
+  });
+
+  test("a fully rewritten single line marks the whole line changed on both sides", () => {
+    // Arrange - a lone deletion opposite a lone addition is unambiguously one edit
+    const rows = [line("del", "aaa"), line("add", "zzz")];
+
+    // Act
+    const runsByRow = intralineRunsByRow(rows);
+
+    // Assert
+    expect(changedText(runsByRow.get(0)!)).toBe("aaa");
+    expect(changedText(runsByRow.get(1)!)).toBe("zzz");
+  });
+
+  test("in a shifted block, alignment matches the real counterpart, not by position", () => {
+    // Arrange - "beta gamma" is modified and an unrelated line sits at each end;
+    // positional pairing would word-diff "alpha" against "beta gamma delta"
+    const rows = [
+      line("del", "alpha"),
+      line("del", "beta gamma"),
+      line("add", "beta gamma delta"),
+      line("add", "zulu"),
+    ];
+
+    // Act
+    const runsByRow = intralineRunsByRow(rows);
+
+    // Assert
+    // the modified pair is found and word-diffed
+    expect(runsByRow.has(1)).toBe(true); // "beta gamma"
+    expect(runsByRow.has(2)).toBe(true); // "beta gamma delta"
+    expect(changedText(runsByRow.get(2)!).trim()).toBe("delta");
+    // the genuinely unrelated lines stay whole-line
+    expect(runsByRow.has(0)).toBe(false); // "alpha"
+    expect(runsByRow.has(3)).toBe(false); // "zulu"
+  });
+
+  test("in a multi-line block, related positional pairs still highlight the changed word", () => {
+    // Arrange - a same-shape 2x2 edit: each row lines up with its counterpart
+    const rows = [
+      line("del", "one two"),
+      line("del", "three four"),
+      line("add", "one TWO"),
+      line("add", "three FOUR"),
+    ];
+
+    // Act
+    const runsByRow = intralineRunsByRow(rows);
+
+    // Assert
+    expect(changedText(runsByRow.get(0)!)).toBe("two");
+    expect(changedText(runsByRow.get(1)!)).toBe("four");
+    expect(changedText(runsByRow.get(2)!)).toBe("TWO");
+    expect(changedText(runsByRow.get(3)!)).toBe("FOUR");
+  });
+});
+
+describe("createIntralineResolver", () => {
+  test("resolves each row to the same runs the eager pass would, on demand", () => {
+    // Arrange - context around two separate change blocks
+    const rows = [
+      line("ctx", "header"),
+      line("del", "one two"),
+      line("add", "one TWO"),
+      line("ctx", "middle"),
+      line("del", "alpha beta"),
+      line("add", "alpha GAMMA"),
+      line("ctx", "footer"),
+    ];
+    const eager = intralineRunsByRow(rows);
+
+    // Act
+    const resolver = createIntralineResolver(rows);
+
+    // Assert - lazy row-by-row output matches the eager map, including undefined for context rows
+    for (let index = 0; index < rows.length; index++) {
+      expect(resolver.runsForRow(index)).toEqual(eager.get(index));
+    }
+  });
+
+  test("a second call for the same row returns the cached runs", () => {
+    const rows = [line("del", "one two"), line("add", "one TWO")];
+    const resolver = createIntralineResolver(rows);
+
+    expect(resolver.runsForRow(0)).toBe(resolver.runsForRow(0));
+  });
+
+  // The performance guard: a virtualized diff must word-diff only the change blocks whose rows are on
+  // screen. This is deterministic (a call count, not a wall-clock), so it fails on any machine if a
+  // future change makes the resolver eager again - the regression the nav-latency benchmark would show.
+  test("word-diffs only the accessed block, not the whole diff", () => {
+    // Arrange - 50 independent change blocks, each a single del/add pair separated by context
+    const rows: DiffRow[] = [];
+
+    for (let block = 0; block < 50; block++) {
+      rows.push(
+        line("ctx", `ctx ${block}`),
+        line("del", `old ${block}`),
+        line("add", `new ${block}`),
+      );
+    }
+    const spy = spyOn(intraline, "wordLevelChanges");
+
+    try {
+      // Act - the eager pass word-diffs every block
+      spy.mockClear();
+      intralineRunsByRow(rows);
+      const eagerCalls = spy.mock.calls.length;
+
+      // Act - the resolver word-diffs only the one block whose row is asked for
+      spy.mockClear();
+      const resolver = createIntralineResolver(rows);
+      resolver.runsForRow(1); // a row in block 0
+      const oneBlockCalls = spy.mock.calls.length;
+
+      // Assert - eager pays for all 50 blocks; lazy pays for one
+      expect(eagerCalls).toBe(50);
+      expect(oneBlockCalls).toBe(1);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+});

package/src/diff-intraline.ts

@@ -0,0 +1,236 @@
+/**
+ * Intra-line word diff: the char-precise "what changed within this line" engine
+ * shared by the plan tracked-changes view and the diff review sheet. Backed by
+ * jsdiff diffWordsWithSpace, so it is punctuation-aware and whitespace-lossless:
+ * the run values always concatenate back to the exact inputs, which keeps quote
+ * anchors intact. Supersedes the coarse LCS wordDiff.
+ */
+
+import { diffWordsWithSpace } from "diff";
+import { lcsDiff } from "@cueloop/schema";
+import type { DiffRow } from "./view-diff";
+
+export type WordChangeKind = "common" | "added" | "removed";
+
+/** One word-level change between two strings; text is verbatim (lossless). */
+export interface WordChange {
+  text: string;
+  kind: WordChangeKind;
+}
+
+/** Word-level changes between two strings, whitespace-lossless and ordered. */
+export function wordLevelChanges(oldText: string, newText: string): WordChange[] {
+  return diffWordsWithSpace(oldText, newText).map((change) => ({
+    text: change.value,
+    kind: change.added ? "added" : change.removed ? "removed" : "common",
+  }));
+}
+
+/** One rendered segment of a diff row: changed marks the intra-line change. */
+export interface IntralineRun {
+  text: string;
+  changed: boolean;
+}
+
+function stripTrailingNewline(text: string): string {
+  return text.replace(/\n$/, "");
+}
+
+/** A change block: a run of deletion rows immediately followed by addition rows. */
+interface IntralineBlock {
+  deletionStart: number;
+  additionStart: number;
+  end: number;
+}
+
+/** The change blocks in row order, found in one cheap pass (no word diff yet). */
+function intralineBlocks(rows: DiffRow[]): IntralineBlock[] {
+  const blocks: IntralineBlock[] = [];
+  let index = 0;
+
+  while (index < rows.length) {
+    if (rows[index]!.kind !== "del") {
+      index++;
+      continue;
+    }
+    const deletionStart = index;
+
+    while (index < rows.length && rows[index]!.kind === "del") index++;
+    const additionStart = index;
+
+    while (index < rows.length && rows[index]!.kind === "add") index++;
+    blocks.push({ deletionStart, additionStart, end: index });
+  }
+
+  return blocks;
+}
+
+/** Word-diff one change block into [rowIndex, runs] pairs; unmatched rows get no entry. */
+function blockRunEntries(rows: DiffRow[], block: IntralineBlock): Array<[number, IntralineRun[]]> {
+  const deletionTexts = rows
+    .slice(block.deletionStart, block.additionStart)
+    .map((row) => stripTrailingNewline(row.text));
+  const additionTexts = rows
+    .slice(block.additionStart, block.end)
+    .map((row) => stripTrailingNewline(row.text));
+  const entries: Array<[number, IntralineRun[]]> = [];
+
+  for (const [deletionOffset, additionOffset] of alignedPairs(deletionTexts, additionTexts)) {
+    const changes = wordLevelChanges(
+      deletionTexts[deletionOffset]!,
+      additionTexts[additionOffset]!,
+    );
+
+    entries.push([block.deletionStart + deletionOffset, sideRuns(changes, "removed")]);
+    entries.push([block.additionStart + additionOffset, sideRuns(changes, "added")]);
+  }
+
+  return entries;
+}
+
+/** The change block whose rows cover `rowIndex`, by binary search over the ordered blocks. */
+function blockContaining(blocks: IntralineBlock[], rowIndex: number): number | undefined {
+  let low = 0;
+  let high = blocks.length - 1;
+
+  while (low <= high) {
+    const mid = (low + high) >> 1;
+    const block = blocks[mid]!;
+
+    if (rowIndex < block.deletionStart) high = mid - 1;
+    else if (rowIndex >= block.end) low = mid + 1;
+    else return mid;
+  }
+
+  return undefined;
+}
+
+/** A row's intra-line runs, resolved on demand. */
+export interface IntralineResolver {
+  runsForRow(rowIndex: number): IntralineRun[] | undefined;
+}
+
+/**
+ * Char-precise intra-line runs for modified diff rows, computed lazily. The change blocks are found
+ * up front in one cheap pass; a block is word-diffed only when a row inside it is first asked for,
+ * so a virtualized diff pays for the rows on screen, not for the whole file. Within a change block -
+ * deletions immediately followed by additions - lines align to their real counterpart (alignedPairs)
+ * and each matched pair is word-diffed; unmatched rows get no runs, so the caller renders those whole.
+ */
+export function createIntralineResolver(rows: DiffRow[]): IntralineResolver {
+  const blocks = intralineBlocks(rows);
+  const computed = new Set<number>();
+  const runsByRow = new Map<number, IntralineRun[]>();
+
+  return {
+    runsForRow(rowIndex) {
+      const blockIndex = blockContaining(blocks, rowIndex);
+
+      if (blockIndex === undefined) return undefined;
+      if (!computed.has(blockIndex)) {
+        computed.add(blockIndex);
+        for (const [row, runs] of blockRunEntries(rows, blocks[blockIndex]!))
+          runsByRow.set(row, runs);
+      }
+
+      return runsByRow.get(rowIndex);
+    },
+  };
+}
+
+/** Every modified row's intra-line runs, eagerly. Prefer createIntralineResolver on a hot path. */
+export function intralineRunsByRow(rows: DiffRow[]): Map<number, IntralineRun[]> {
+  const runsByRow = new Map<number, IntralineRun[]>();
+
+  for (const block of intralineBlocks(rows)) {
+    for (const [row, runs] of blockRunEntries(rows, block)) runsByRow.set(row, runs);
+  }
+
+  return runsByRow;
+}
+
+/** Lines this similar (word-set overlap) are treated as the same line edited. */
+const SIMILAR_MIN_WORD_OVERLAP = 0.3;
+
+/** Lower-cased word set of a line for the similarity gate, cached per distinct line within a block so
+ *  the LCS grid tokenizes each line once instead of once per comparison. */
+function lineWordSetCache(): (text: string) => ReadonlySet<string> {
+  const cache = new Map<string, ReadonlySet<string>>();
+
+  return (text) => {
+    const cached = cache.get(text);
+    if (cached !== undefined) return cached;
+    const words = new Set(text.toLowerCase().split(/\s+/).filter(Boolean));
+    cache.set(text, words);
+
+    return words;
+  };
+}
+
+/** Whether two lines are the same line edited, by case-insensitive word-set
+ *  overlap - the matching gate, distinct from the case-sensitive word diff. */
+function linesSimilar(
+  wordsOf: (text: string) => ReadonlySet<string>,
+  oldText: string,
+  newText: string,
+): boolean {
+  const oldWords = wordsOf(oldText);
+  const newWords = wordsOf(newText);
+
+  if (oldWords.size === 0 && newWords.size === 0) return true;
+  let intersection = 0;
+
+  for (const word of oldWords) if (newWords.has(word)) intersection++;
+  const union = oldWords.size + newWords.size - intersection;
+
+  return union === 0 ? true : intersection / union >= SIMILAR_MIN_WORD_OVERLAP;
+}
+
+/**
+ * Pair each modified line with the addition it became. A lone deletion opposite
+ * a lone addition is one edit (always paired). Otherwise align the lines by
+ * similarity, order-preserving (LCS over `linesSimilar`), so an inserted, removed,
+ * or shifted line finds its real counterpart instead of mispairing by position -
+ * unmatched lines get no pair and render whole-line. Returns [deletionOffset,
+ * additionOffset] pairs into the block.
+ */
+function alignedPairs(deletionTexts: string[], additionTexts: string[]): Array<[number, number]> {
+  if (deletionTexts.length === 1 && additionTexts.length === 1) return [[0, 0]];
+  const pairs: Array<[number, number]> = [];
+  let deletionOffset = 0;
+  let additionOffset = 0;
+  const wordsOf = lineWordSetCache();
+
+  for (const op of lcsDiff(deletionTexts, additionTexts, (deletionText, additionText) =>
+    linesSimilar(wordsOf, deletionText, additionText),
+  )) {
+    if (op.kind === "ctx") {
+      pairs.push([deletionOffset, additionOffset]);
+      deletionOffset++;
+      additionOffset++;
+    } else if (op.kind === "del") {
+      deletionOffset++;
+    } else {
+      additionOffset++;
+    }
+  }
+
+  return pairs;
+}
+
+/** Runs for one side of a word diff: common plus this side's changes, adjacent
+ *  runs of equal changed-ness coalesced so highlighting stays as few spans. */
+function sideRuns(changes: WordChange[], side: "added" | "removed"): IntralineRun[] {
+  const runs: IntralineRun[] = [];
+
+  for (const change of changes) {
+    if (change.kind !== "common" && change.kind !== side) continue;
+    const changed = change.kind === side;
+    const last = runs[runs.length - 1];
+
+    if (last && last.changed === changed) last.text += change.text;
+    else runs.push({ text: change.text, changed });
+  }
+
+  return runs;
+}

package/src/diff-syntax.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, test } from "bun:test";
+import { highlightJobs, spansByLine } from "./diff-syntax";
+import type { DiffRow } from "./view-diff";
+import type { SimpleHighlight } from "@opentui/core";
+
+function row(kind: DiffRow["kind"], text: string, file = "src/x.ts"): DiffRow {
+  return { kind, text, file };
+}
+
+describe("spansByLine", () => {
+  test("maps absolute offsets to line-relative spans", () => {
+    // Arrange
+    const source = "const x = 1;\nfoo";
+    const highlights: SimpleHighlight[] = [
+      [0, 5, "keyword"],
+      [6, 7, "variable"],
+      [13, 16, "variable"],
+    ];
+
+    // Act
+    const lineSpans = spansByLine(source, highlights);
+
+    // Assert
+    expect(lineSpans[0]).toEqual([
+      { start: 0, end: 5, group: "keyword" },
+      { start: 6, end: 7, group: "variable" },
+    ]);
+    expect(lineSpans[1]).toEqual([{ start: 0, end: 3, group: "variable" }]);
+  });
+
+  test("spreads a capture that crosses newlines onto every line it covers", () => {
+    // Arrange - one capture spanning both lines, as a block comment would
+    const source = "aa\nbb";
+    const highlights: SimpleHighlight[] = [[0, 5, "comment"]];
+
+    // Act
+    const lineSpans = spansByLine(source, highlights);
+
+    // Assert
+    expect(lineSpans[0]).toEqual([{ start: 0, end: 2, group: "comment" }]);
+    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";
+    const highlights: SimpleHighlight[] = [
+      [0, 3, "variable"],
+      [0, 3, "type"],
+    ];
+
+    // Act
+    const lineSpans = spansByLine(source, highlights);
+
+    // Assert
+    expect(lineSpans[0]).toEqual([{ start: 0, end: 3, group: "type" }]);
+  });
+});
+
+describe("highlightJobs", () => {
+  test("reconstructs old and new sides of a hunk with row indices", () => {
+    // Arrange
+    const rows = [
+      row("file", "src/x.ts", "src/x.ts"),
+      row("hunk", "@@ -1,2 +1,2 @@"),
+      row("ctx", "const a = 1;"),
+      row("del", "const b = 2;"),
+      row("add", "const b = 3;"),
+    ];
+
+    // Act
+    const jobs = highlightJobs(rows);
+
+    // Assert
+    // old side = context + deletion; new side = context + addition
+    expect(jobs).toEqual([
+      { filetype: "typescript", source: "const a = 1;\nconst b = 2;", rowIndexByLine: [2, 3] },
+      { filetype: "typescript", source: "const a = 1;\nconst b = 3;", rowIndexByLine: [2, 4] },
+    ]);
+  });
+
+  test("skips files with no known filetype", () => {
+    // Arrange
+    const rows = [
+      row("file", "notes/thing.unknownext", "notes/thing.unknownext"),
+      row("hunk", "@@"),
+      row("add", "whatever"),
+    ];
+
+    // Act
+    const jobs = highlightJobs(rows);
+
+    // Assert
+    expect(jobs).toEqual([]);
+  });
+});