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

package/src/view-diff.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, test } from "bun:test";
-import { diffRowAnchor, diffRows } from "./view-diff";
+import { makeAnchor, type Annotation, type Thread } from "@cueloop/schema";
+import {
+  changesMarks,
+  diffRowAnchor,
+  diffRowBlocks,
+  diffRows,
+  fileRowRange,
+  fileTargetMarks,
+} from "./view-diff";
 
 const PATCH = `diff --git a/src/store.ts b/src/store.ts
 index 111..222 100644
@@ -21,23 +29,32 @@ 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,11 +62,264 @@ 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);
   });
 });
+
+describe("fileTargetMarks", () => {
+  // two files whose added line is byte-identical; a note on one must never mark the other
+  const TWO_FILE = `diff --git a/a.ts b/a.ts
+--- a/a.ts
++++ b/a.ts
+@@ -1,1 +1,2 @@
+ const keep = 0;
++const dup = 1;
+diff --git a/b.ts b/b.ts
+--- a/b.ts
++++ b/b.ts
+@@ -1,1 +1,2 @@
+ const keep = 0;
++const dup = 1;
+`;
+
+  test("a file-target note marks only its own file, never identical text in another", () => {
+    // Arrange - anchor the added line inside a.ts, file-relative like the controller does
+    const rows = diffRows(TWO_FILE);
+    const range = fileRowRange(rows, "a.ts")!;
+    const fileRows = rows.slice(range.start, range.end);
+    const addRelative = fileRows.findIndex((row) => row.kind === "add");
+    const quote = fileRows[addRelative]!.text.replace(/\n$/, "");
+    const anchor = makeAnchor(diffRowBlocks(fileRows), addRelative, 0, quote.length, addRelative);
+    const annotation: Annotation = {
+      id: "a1",
+      kind: "comment",
+      anchor,
+      target: { kind: "file", path: "a.ts", rev: "worktree" },
+      body: "note",
+      createdAt: "2026-01-01T00:00:00Z",
+    };
+
+    // Act
+    const marked = [...fileTargetMarks([annotation], rows).keys()];
+
+    // Assert - every marked row sits inside a.ts's range, and b.ts's identical line is untouched
+    expect(marked.length).toBeGreaterThan(0);
+    expect(marked.every((index) => index >= range.start && index < range.end)).toBe(true);
+  });
+});
+
+describe("changesMarks", () => {
+  const PATCH = `diff --git a/x.ts b/x.ts
+--- a/x.ts
++++ b/x.ts
+@@ -1,1 +1,2 @@
+ const keep = 0;
++const added = 1;
+`;
+
+  function diffThread(meta: Thread["artifact"]["meta"], annotations: Annotation[]): Thread {
+    return {
+      schemaVersion: "1",
+      id: "s_changes",
+      workspace: { repoRoot: "/repo", branch: "main" },
+      artifact: { type: "diff", content: PATCH, meta },
+      revisions: [{ revision: 1, content: PATCH, submittedAt: "2026-01-01T00:00:00Z" }],
+      annotations,
+      message: null,
+      status: "pending",
+      createdAt: "2026-01-01T00:00:00Z",
+    };
+  }
+
+  function fileNote(rows: ReturnType<typeof diffRows>): Annotation {
+    const range = fileRowRange(rows, "x.ts")!;
+    const fileRows = rows.slice(range.start, range.end);
+    const addRelative = fileRows.findIndex((row) => row.kind === "add");
+    const quote = fileRows[addRelative]!.text.replace(/\n$/, "");
+    const anchor = makeAnchor(diffRowBlocks(fileRows), addRelative, 0, quote.length, addRelative);
+
+    return {
+      id: "f1",
+      kind: "comment",
+      anchor,
+      target: { kind: "file", path: "x.ts", rev: "worktree" },
+      body: "note",
+      createdAt: "2026-01-01T00:00:00Z",
+    };
+  }
+
+  test("a workbench thread paints its file-targeted working-tree notes", () => {
+    const rows = diffRows(PATCH);
+    const session = diffThread({ workbench: true }, [fileNote(rows)]);
+
+    expect([...changesMarks(session, rows).keys()].length).toBeGreaterThan(0);
+  });
+
+  test("a pinned PR diff paints its file-scoped agent findings", () => {
+    const rows = diffRows(PATCH);
+    const finding = {
+      ...fileNote(rows),
+      author: "agent",
+      reviewComment: {
+        severity: "p1" as const,
+        title: "Finding",
+        path: "x.ts",
+        line: 2,
+        side: "RIGHT" as const,
+      },
+    };
+    const session = diffThread({ pr: "org/repo#1" }, [finding]);
+
+    expect([...changesMarks(session, rows).keys()].length).toBeGreaterThan(0);
+  });
+
+  test("an outdated PR finding stays on its recorded line without rebinding", () => {
+    const rows = diffRows(PATCH);
+    const finding: Annotation = {
+      ...fileNote(rows),
+      anchor: { quote: "text that is no longer present", prefix: "", suffix: "" },
+      author: "agent",
+      reviewComment: {
+        severity: "p1",
+        title: "Finding",
+        path: "x.ts",
+        line: 2,
+        side: "RIGHT",
+      },
+    };
+    const session = diffThread({ pr: "org/repo#1" }, [finding]);
+    const marks = changesMarks(session, rows);
+
+    const findingMark = [...marks.values()].flat().find((mark) => mark.annotationId === finding.id);
+
+    expect(findingMark?.outdated).toBe(true);
+  });
+
+  test("a PR finding does not fuzzily rebind to different text", () => {
+    const rows = diffRows(PATCH);
+    const finding: Annotation = {
+      ...fileNote(rows),
+      anchor: {
+        quote: "  private item = new Map();",
+        prefix: "export class Store {",
+        suffix: "}",
+      },
+      author: "agent",
+      reviewComment: {
+        severity: "p1",
+        title: "Finding",
+        path: "x.ts",
+        line: 2,
+        side: "RIGHT",
+      },
+    };
+    const marks = changesMarks(diffThread({ pr: "org/repo#1" }, [finding]), rows);
+    const findingMark = [...marks.values()].flat().find((mark) => mark.annotationId === finding.id);
+
+    expect(findingMark?.outdated).toBe(true);
+    expect(findingMark?.start).toBe(0);
+    expect(findingMark?.end).toBe(0);
+  });
+
+  test("a PR finding on an empty line remains visible with its replies", () => {
+    const patch = `diff --git a/x.ts b/x.ts
+--- a/x.ts
++++ b/x.ts
+@@ -1,1 +1,2 @@
+ const keep = 0;
++
+`;
+    const rows = diffRows(patch);
+    const range = fileRowRange(rows, "x.ts")!;
+    const fileRows = rows.slice(range.start, range.end);
+    const emptyRow = fileRows.findIndex((row) => row.kind === "add" && row.text === "\n");
+    const finding: Annotation = {
+      id: "empty-finding",
+      kind: "comment",
+      anchor: diffRowAnchor(fileRows, emptyRow),
+      target: { kind: "file", path: "x.ts", rev: "worktree" },
+      body: "Keep this blank line.",
+      author: "agent",
+      createdAt: "2026-01-01T00:00:00Z",
+      reviewComment: {
+        severity: "p2",
+        title: "Empty line",
+        path: "x.ts",
+        line: 2,
+        side: "RIGHT",
+      },
+    };
+    const reply: Annotation = {
+      ...finding,
+      id: "empty-reply",
+      body: "Visible reply.",
+      author: "reviewer",
+      replyTo: finding.id,
+      reviewComment: undefined,
+    };
+    const marks = changesMarks(diffThread({ pr: "org/repo#1" }, [finding, reply]), rows);
+    const marked = [...marks.values()].flat();
+    const findingMark = marked.find((mark) => mark.annotationId === finding.id);
+    const replyMark = marked.find((mark) => mark.annotationId === reply.id);
+
+    expect(findingMark).toMatchObject({ start: 0, end: 0 });
+    expect(findingMark?.outdated).toBeUndefined();
+    expect(replyMark?.span).toEqual(findingMark?.span);
+  });
+
+  test("replies stay grouped with an outdated PR finding", () => {
+    const rows = diffRows(PATCH);
+    const finding: Annotation = {
+      ...fileNote(rows),
+      anchor: { quote: "text that is no longer present", prefix: "", suffix: "" },
+      author: "agent",
+      reviewComment: {
+        severity: "p1",
+        title: "Finding",
+        path: "x.ts",
+        line: 2,
+        side: "RIGHT",
+      },
+    };
+    const reply: Annotation = {
+      ...finding,
+      id: "reply-1",
+      author: "reviewer",
+      body: "Keep this discussion visible.",
+      replyTo: finding.id,
+      reviewComment: undefined,
+    };
+    const marks = changesMarks(diffThread({ pr: "org/repo#1" }, [finding, reply]), rows);
+    const marked = [...marks.values()].flat();
+    const findingMark = marked.find((mark) => mark.annotationId === finding.id);
+    const replyMark = marked.find((mark) => mark.annotationId === reply.id);
+
+    expect(replyMark?.span).toEqual(findingMark?.span);
+    expect(replyMark?.outdated).toBe(true);
+  });
+
+  test("a plain pinned diff ignores working-tree file targets", () => {
+    const rows = diffRows(PATCH);
+    const session = diffThread({}, [fileNote(rows)]);
+
+    expect([...changesMarks(session, rows).keys()]).toEqual([]);
+  });
+
+  test("a shared snapshot still paints the workbench's file-targeted feedback", () => {
+    const rows = diffRows(PATCH);
+    // a served/shared snapshot keeps the workbench marker, so its notes stay file-targeted and visible
+    const session = diffThread({ workbench: true, snapshot: true }, [fileNote(rows)]);
+
+    expect([...changesMarks(session, rows).keys()].length).toBeGreaterThan(0);
+  });
+});