@cueloop/client 0.1.0-alpha.10 → 0.1.0-alpha.101

package/src/diff/view-diff.ts

@@ -0,0 +1,522 @@
+/**
+ * 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.
+ */
+
+import { parsePatchFiles, type FileDiffMetadata } from "@pierre/diffs";
+import {
+  annotationTarget,
+  isAddressed,
+  resolveAnchor,
+  type Annotation,
+  type Block,
+  type Thread,
+} from "@cueloop/schema";
+import { spanRangeInBlock, type TextSpan } from "../annotations/thread-selection";
+import type { Mark } from "../markdown/view-plan";
+import { discussionsFrom } from "../annotations/discussions";
+
+// the diff sheet reads marks over rows as a diff concept; re-export so it need not reach into view-plan
+export type { Mark } from "../markdown/view-plan";
+
+export type DiffRowKind = "file" | "hunk" | "ctx" | "add" | "del";
+
+export interface DiffRow {
+  kind: DiffRowKind;
+  text: string;
+  file: string;
+  oldLine?: number;
+  newLine?: number;
+}
+
+function isCodeRow(row: DiffRow | undefined): row is DiffRow {
+  return row !== undefined && row.kind !== "file" && row.kind !== "hunk";
+}
+
+export function diffRows(patchText: string): DiffRow[] {
+  const rows: DiffRow[] = [];
+  const patches = parsePatchFiles(patchText);
+
+  for (const patch of patches) {
+    for (const file of patch.files) {
+      rows.push({ kind: "file", text: fileLabel(file), file: file.name });
+      for (const hunk of file.hunks) {
+        rows.push({ kind: "hunk", text: hunk.hunkSpecs ?? "@@", file: file.name });
+        let oldLine = hunk.deletionStart;
+        let newLine = hunk.additionStart;
+
+        for (const segment of hunk.hunkContent) {
+          if (segment.type === "context") {
+            for (let lineOffset = 0; lineOffset < segment.lines; lineOffset++) {
+              rows.push({
+                kind: "ctx",
+                text: file.additionLines[segment.additionLineIndex + lineOffset] ?? "",
+                file: file.name,
+                oldLine: oldLine++,
+                newLine: newLine++,
+              });
+            }
+          } else {
+            for (let lineOffset = 0; lineOffset < segment.deletions; lineOffset++) {
+              rows.push({
+                kind: "del",
+                text: file.deletionLines[segment.deletionLineIndex + lineOffset] ?? "",
+                file: file.name,
+                oldLine: oldLine++,
+              });
+            }
+            for (let lineOffset = 0; lineOffset < segment.additions; lineOffset++) {
+              rows.push({
+                kind: "add",
+                text: file.additionLines[segment.additionLineIndex + lineOffset] ?? "",
+                file: file.name,
+                newLine: newLine++,
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return rows;
+}
+
+/** Added and removed line counts per file path, for the file band's badge; base rows only. */
+export function fileChangeCounts(
+  rows: DiffRow[],
+): Map<string, { additions: number; deletions: number }> {
+  const counts = new Map<string, { additions: number; deletions: number }>();
+
+  for (const row of rows) {
+    if (row.kind !== "add" && row.kind !== "del") continue;
+    const entry = counts.get(row.file) ?? { additions: 0, deletions: 0 };
+
+    if (row.kind === "add") entry.additions += 1;
+    else entry.deletions += 1;
+    counts.set(row.file, entry);
+  }
+
+  return counts;
+}
+
+function fileLabel(file: FileDiffMetadata): string {
+  return file.prevName && file.prevName !== file.name
+    ? `${file.prevName} → ${file.name}`
+    : file.name;
+}
+
+/** Row text carries the patch's trailing newline; anchors and rendering strip it. */
+export function diffRowText(row: DiffRow): string {
+  return row.text.replace(/\n$/, "");
+}
+
+/**
+ * The diff rows as anchor blocks, one per row in row order, so a comment span anchors
+ * with the same quote/context/position selectors a plan block does. Header rows are
+ * blocks too (indices stay 1:1 with the rows) but hold no comment.
+ */
+export function diffRowBlocks(rows: DiffRow[]): Block[] {
+  return rows.map((row, index) => ({
+    kind: "code",
+    text: row.kind === "file" || row.kind === "hunk" ? "" : diffRowText(row),
+    lineStart: index,
+    lineEnd: index,
+  }));
+}
+
+/**
+ * Resolve annotations against the diff rows and group marks per row index, with
+ * character ranges and the whole span, so the diff sheet paints and threads them
+ * exactly as the plan view does its blocks.
+ */
+export function marksByRows(
+  annotations: Annotation[],
+  rows: DiffRow[],
+  focusedId?: string,
+): Map<number, Mark[]> {
+  const blocks = diffRowBlocks(rows);
+  const marksByIndex = new Map<number, Mark[]>();
+
+  for (const annotation of annotations) {
+    // an addressed annotation keeps its record but paints no highlight
+    if (isAddressed(annotation)) continue;
+    const resolved = resolveAnchor(annotation.anchor, blocks);
+
+    if (!resolved) continue;
+    const span: TextSpan = {
+      start: { blockIndex: resolved.blockIndex, char: resolved.start },
+      end: { blockIndex: resolved.endBlockIndex, char: resolved.end },
+    };
+
+    // a span paints on every row it covers; the mark carries the whole span
+    for (let rowIndex = resolved.blockIndex; rowIndex <= resolved.endBlockIndex; rowIndex++) {
+      const range = spanRangeInBlock(span, rowIndex, blocks[rowIndex]!.text.length);
+
+      if (!range) continue;
+      const marks = marksByIndex.get(rowIndex) ?? [];
+
+      marks.push({
+        start: range.start,
+        end: range.end,
+        role: annotation.id === focusedId ? "mark-focus" : "mark-comment",
+        annotationId: annotation.id,
+        span,
+      });
+      marksByIndex.set(rowIndex, marks);
+    }
+  }
+
+  return marksByIndex;
+}
+
+function addResolvedMark(
+  marksByIndex: Map<number, Mark[]>,
+  annotation: Annotation,
+  blocks: Block[],
+  startBlockIndex: number,
+  endBlockIndex: number,
+  focusedId?: string,
+): void {
+  const startAnchor = annotation.reviewComment?.startAnchor ?? annotation.anchor;
+  const span: TextSpan = {
+    start: {
+      blockIndex: startBlockIndex,
+      char: Math.min(startAnchor.start ?? 0, blocks[startBlockIndex]!.text.length),
+    },
+    end: {
+      blockIndex: endBlockIndex,
+      char: Math.min(
+        annotation.anchor.end ?? annotation.anchor.quote.length,
+        blocks[endBlockIndex]!.text.length,
+      ),
+    },
+  };
+
+  for (let rowIndex = startBlockIndex; rowIndex <= endBlockIndex; rowIndex++) {
+    const range = spanRangeInBlock(span, rowIndex, blocks[rowIndex]!.text.length);
+
+    const marksEmptyLine =
+      range === null &&
+      startBlockIndex === endBlockIndex &&
+      rowIndex === startBlockIndex &&
+      blocks[rowIndex]!.text.length === 0;
+
+    if (!range && !marksEmptyLine) continue;
+    const marks = marksByIndex.get(rowIndex) ?? [];
+
+    marks.push({
+      start: range?.start ?? 0,
+      end: range?.end ?? 0,
+      role: annotation.id === focusedId ? "mark-focus" : "mark-comment",
+      annotationId: annotation.id,
+      span,
+    });
+    marksByIndex.set(rowIndex, marks);
+  }
+}
+
+function addReviewFindingMark(
+  marksByIndex: Map<number, Mark[]>,
+  annotation: Annotation,
+  rows: DiffRow[],
+  blocks: Block[],
+  focusedId?: string,
+): boolean {
+  const finding = annotation.reviewComment;
+
+  if (!finding || isAddressed(annotation)) return false;
+  const end = resolveReviewAnchorRow(rows, annotation.anchor, finding.path, finding.side);
+  const start = finding.startAnchor
+    ? resolveReviewAnchorRow(rows, finding.startAnchor, finding.path, finding.side)
+    : end;
+
+  if (!start || !end || start.rowIndex > end.rowIndex) return false;
+  addResolvedMark(marksByIndex, annotation, blocks, start.rowIndex, end.rowIndex, focusedId);
+
+  return true;
+}
+
+/**
+ * A whole file rendered as context rows, so the diff sheet can show and annotate a plain file the
+ * same way it does a diff: every line is unchanged, numbered on both sides (the file view collapses
+ * that to one number). A trailing newline does not add an empty final row.
+ */
+export function fileContentsRows(path: string, contents: string): DiffRow[] {
+  const lines = contents.replace(/\n$/, "").split("\n");
+
+  return lines.map((text, index) => ({
+    kind: "ctx",
+    text,
+    file: path,
+    oldLine: index + 1,
+    newLine: index + 1,
+  }));
+}
+
+/** The contiguous row range a file occupies in the aggregate diff, or null when it is not shown. */
+export function fileRowRange(rows: DiffRow[], path: string): { start: number; end: number } | null {
+  const start = rows.findIndex((row) => row.file === path);
+
+  if (start === -1) return null;
+  let end = start;
+
+  while (end < rows.length && rows[end]!.file === path) end++;
+
+  return { start, end };
+}
+
+/**
+ * Marks for file-target notes on the aggregate working-tree diff. Each note resolves against only
+ * its own file's rows, then the row index and span shift back to aggregate coordinates - so a quote
+ * never attaches to the same text in another file or on the opposite diff side.
+ */
+export function fileTargetMarks(
+  annotations: Annotation[],
+  rows: DiffRow[],
+  focusedId?: string,
+): Map<number, Mark[]> {
+  const byFile = new Map<string, Annotation[]>();
+
+  for (const annotation of annotations) {
+    const target = annotationTarget(annotation);
+
+    if (target.kind !== "file") continue;
+    const forPath = byFile.get(target.path) ?? [];
+
+    forPath.push(annotation);
+    byFile.set(target.path, forPath);
+  }
+  const result = new Map<number, Mark[]>();
+
+  for (const [path, fileAnnotations] of byFile) {
+    const range = fileRowRange(rows, path);
+
+    if (!range) continue;
+    const base = range.start;
+    const fileRows = rows.slice(range.start, range.end);
+    const reviewRootIds = new Set(
+      fileAnnotations.flatMap((annotation) =>
+        annotation.reviewComment === undefined ? [] : [annotation.id],
+      ),
+    );
+    const ordinaryAnnotations = fileAnnotations.filter(
+      (annotation) =>
+        annotation.reviewComment === undefined &&
+        (annotation.replyTo === undefined || !reviewRootIds.has(annotation.replyTo)),
+    );
+    const fileMarks = marksByRows(ordinaryAnnotations, fileRows, focusedId);
+    const blocks = diffRowBlocks(fileRows);
+    const resolvedIds = new Set(
+      [...fileMarks.values()]
+        .flat()
+        .flatMap((mark) => (mark.annotationId === undefined ? [] : [mark.annotationId])),
+    );
+
+    for (const annotation of fileAnnotations) {
+      const finding = annotation.reviewComment;
+
+      if (!finding || isAddressed(annotation)) continue;
+      if (addReviewFindingMark(fileMarks, annotation, fileRows, blocks, focusedId)) {
+        resolvedIds.add(annotation.id);
+        continue;
+      }
+      const relativeRow = fileRows.findIndex(
+        (row) =>
+          (finding.side === "RIGHT" ? row.newLine : row.oldLine) === finding.line &&
+          row.kind !== "file" &&
+          row.kind !== "hunk",
+      );
+      const fallbackRow = relativeRow === -1 ? 0 : relativeRow;
+      const mark: Mark = {
+        start: 0,
+        end: 0,
+        role: annotation.id === focusedId ? "mark-focus" : "mark-comment",
+        annotationId: annotation.id,
+        outdated: true,
+        span: {
+          start: { blockIndex: fallbackRow, char: 0 },
+          end: { blockIndex: fallbackRow, char: 0 },
+        },
+      };
+
+      fileMarks.set(fallbackRow, [...(fileMarks.get(fallbackRow) ?? []), mark]);
+      resolvedIds.add(annotation.id);
+    }
+
+    for (const annotation of fileAnnotations) {
+      if (!annotation.replyTo || resolvedIds.has(annotation.id) || isAddressed(annotation))
+        continue;
+      const parent = [...fileMarks.entries()].find(([, marks]) =>
+        marks.some((mark) => mark.annotationId === annotation.replyTo),
+      );
+
+      if (!parent) continue;
+      const [fallbackRow, parentMarks] = parent;
+      const parentMark = parentMarks.find((mark) => mark.annotationId === annotation.replyTo)!;
+      const replyMark: Mark = {
+        ...parentMark,
+        role: annotation.id === focusedId ? "mark-focus" : "mark-comment",
+        annotationId: annotation.id,
+        outdated: parentMark.outdated,
+      };
+
+      fileMarks.set(fallbackRow, [...parentMarks, replyMark]);
+      resolvedIds.add(annotation.id);
+    }
+
+    for (const [relativeRow, marks] of fileMarks) {
+      result.set(
+        relativeRow + base,
+        marks.map((mark) =>
+          mark.span
+            ? {
+                ...mark,
+                span: {
+                  start: { ...mark.span.start, blockIndex: mark.span.start.blockIndex + base },
+                  end: { ...mark.span.end, blockIndex: mark.span.end.blockIndex + base },
+                },
+              }
+            : mark,
+        ),
+      );
+    }
+  }
+
+  return result;
+}
+
+/** A plain diff review's notes anchor to the artifact itself; a working-tree diff's notes target files. */
+export function annotatesArtifact(session: Thread | null): boolean {
+  return session?.artifact.type === "diff" && session.artifact.meta.workbench !== true;
+}
+
+/**
+ * Render the diff from the pinned artifact rather than the live working tree: a plain diff review (the
+ * artifact is the diff), or a shared/served snapshot of a workbench thread (the remote has no tree).
+ */
+export function readsFrozenDiff(session: Thread | null): boolean {
+  return (
+    session?.artifact.type === "diff" &&
+    (session.artifact.meta.workbench !== true || session.artifact.meta.snapshot === true)
+  );
+}
+
+/**
+ * The marks a Changes surface paints. A plain diff review is the artifact itself, so only its
+ * artifact-anchored notes belong; a workbench thread (live or a frozen snapshot) and every other thread
+ * show a working-tree diff, whose notes carry a file target and resolve per file - so a refresh never
+ * rebinds one across files, and a snapshot still surfaces the feedback already on the thread.
+ */
+export function changesMarks(
+  session: Thread,
+  rows: DiffRow[],
+  focusedId?: string,
+): Map<number, Mark[]> {
+  if (annotatesArtifact(session)) {
+    const artifactNotes = session.annotations.filter(
+      (annotation) => annotationTarget(annotation).kind === "artifact",
+    );
+    const marks = marksByRows(artifactNotes, rows, focusedId);
+
+    // Agent PR findings carry a file target so repeated text cannot bind across files.
+    // Plain diff comments still use the artifact target for backward compatibility.
+    if (session.artifact.meta.pr !== undefined) {
+      for (const [row, fileMarks] of fileTargetMarks(session.annotations, rows, focusedId)) {
+        marks.set(row, [...(marks.get(row) ?? []), ...fileMarks]);
+      }
+    }
+
+    return marks;
+  }
+
+  return fileTargetMarks(session.annotations, rows, focusedId);
+}
+
+/**
+ * Comments per file path across the diff: each discussion counts its comments (root plus
+ * replies) toward the file its span ends in. Feeds the changed-files tree and tab badges, so a
+ * file whose tab is closed still shows it carries feedback.
+ */
+export function commentCountsByFile(session: Thread, rows: DiffRow[]): Map<string, number> {
+  const discussions = discussionsFrom(session, marksByRows(session.annotations, rows));
+  const counts = new Map<string, number>();
+
+  for (const discussion of discussions) {
+    const file = rows[discussion.blockIndex]?.file;
+
+    if (file === undefined) continue;
+    counts.set(file, (counts.get(file) ?? 0) + discussion.annotations.length);
+  }
+
+  return counts;
+}
+
+/** Quote-primary anchor for a diff row: neighbors as context selectors. */
+export function diffRowAnchor(rows: DiffRow[], rowIndex: number) {
+  const row = rows[rowIndex]!;
+  const context = diffRowAnchorContext(rows, rowIndex);
+
+  return {
+    quote: diffRowText(row),
+    ...context,
+    blockIndex: rowIndex,
+    endBlockIndex: rowIndex,
+    start: 0,
+    end: diffRowText(row).length,
+  };
+}
+
+function diffRowAnchorContext(
+  rows: DiffRow[],
+  rowIndex: number,
+): Pick<Annotation["anchor"], "prefix" | "suffix"> {
+  const prev = rows[rowIndex - 1];
+  const next = rows[rowIndex + 1];
+
+  return {
+    prefix: isCodeRow(prev) ? diffRowText(prev).slice(-24) : "",
+    suffix: isCodeRow(next) ? diffRowText(next).slice(0, 24) : "",
+  };
+}
+
+/** Resolve a publishable PR finding exactly; fuzzy matches must remain visibly outdated. */
+export function resolveReviewAnchorRow(
+  rows: DiffRow[],
+  anchor: Annotation["anchor"],
+  path: string,
+  side: "LEFT" | "RIGHT",
+): { row: DiffRow; rowIndex: number } | undefined {
+  const candidates = rows.flatMap((row, rowIndex) => {
+    if (
+      row.file !== path ||
+      diffRowText(row) !== anchor.quote ||
+      (side === "RIGHT" ? row.newLine === undefined : row.oldLine === undefined)
+    )
+      return [];
+    const context = diffRowAnchorContext(rows, rowIndex);
+
+    return [
+      {
+        row,
+        rowIndex,
+        score: Number(context.prefix === anchor.prefix) + Number(context.suffix === anchor.suffix),
+      },
+    ];
+  });
+
+  if (candidates.length === 0) return undefined;
+  const bestScore = Math.max(...candidates.map((candidate) => candidate.score));
+  const best = candidates.filter((candidate) => candidate.score === bestScore);
+
+  return best.length === 1 ? best[0] : undefined;
+}
+
+/** Location label for the rail and feedback: file:newLine (or old for del). */
+export function diffRowLocation(row: DiffRow): string {
+  const line = row.newLine ?? row.oldLine;
+
+  return line !== undefined ? `${row.file}:${line}` : row.file;
+}

package/src/diff/walk.test.ts

@@ -0,0 +1,121 @@
+/** Pure walk projections: file steps, resume index, viewed counts, notes. */
+
+import { describe, expect, test } from "bun:test";
+import type { Annotation } from "@cueloop/schema";
+import { diffRows } from "./view-diff";
+import { firstUnviewedIndex, noteForFile, viewedCount, walkFiles, WALK_PREVIEW_ROWS } from "./walk";
+
+const PATCH = `diff --git a/src/a.ts b/src/a.ts
+index 111..222 100644
+--- a/src/a.ts
++++ b/src/a.ts
+@@ -1,3 +1,4 @@
+ export const a = 1;
+-export const b = 2;
++export const b = 3;
++export const c = 4;
+diff --git a/src/b.ts b/src/b.ts
+index 333..444 100644
+--- a/src/b.ts
++++ b/src/b.ts
+@@ -1,2 +1,2 @@
+ // header
+-old line
++new line
+diff --git a/src/c.ts b/src/c.ts
+index 555..666 100644
+--- a/src/c.ts
++++ b/src/c.ts
+@@ -1,1 +1,8 @@
+-gone
++one
++two
++three
++four
++five
++six
++seven
+`;
+
+const rows = diffRows(PATCH);
+const files = walkFiles(rows);
+
+describe("walkFiles", () => {
+  test("one step per changed file, in patch order, with counted stats", () => {
+    expect(files.map((file) => file.path)).toEqual(["src/a.ts", "src/b.ts", "src/c.ts"]);
+    expect(files[0]).toMatchObject({ added: 2, removed: 1 });
+    expect(files[1]).toMatchObject({ added: 1, removed: 1 });
+    expect(files[2]).toMatchObject({ added: 7, removed: 1 });
+  });
+
+  test("previews carry signed changed lines and cap at the preview budget", () => {
+    expect(files[0]!.preview).toEqual([
+      { sign: "-", text: "export const b = 2;" },
+      { sign: "+", text: "export const b = 3;" },
+      { sign: "+", text: "export const c = 4;" },
+    ]);
+    expect(files[2]!.preview.length).toBe(WALK_PREVIEW_ROWS);
+    expect(files[2]!.preview[0]).toEqual({ sign: "-", text: "gone" });
+  });
+});
+
+describe("firstUnviewedIndex", () => {
+  test("starts at the first file when nothing is viewed", () => {
+    expect(firstUnviewedIndex(files, new Set())).toBe(0);
+  });
+
+  test("skips viewed files - a resumed review lands on its first gap", () => {
+    expect(firstUnviewedIndex(files, new Set(["src/a.ts"]))).toBe(1);
+    expect(firstUnviewedIndex(files, new Set(["src/a.ts", "src/b.ts"]))).toBe(2);
+    // a viewed file later in the list does not block the earlier gap
+    expect(firstUnviewedIndex(files, new Set(["src/c.ts"]))).toBe(0);
+  });
+
+  test("all viewed resumes on the end card, not the first file", () => {
+    expect(firstUnviewedIndex(files, new Set(["src/a.ts", "src/b.ts", "src/c.ts"]))).toBe(
+      files.length,
+    );
+  });
+});
+
+describe("viewedCount", () => {
+  test("counts only paths present in the current file set", () => {
+    expect(viewedCount(files, new Set(["src/a.ts", "src/gone-in-rev-2.ts"]))).toBe(1);
+  });
+});
+
+describe("noteForFile", () => {
+  const note = (path: string, body: string): Annotation => ({
+    id: `a_${path}`,
+    kind: "note",
+    anchor: { quote: path, prefix: "", suffix: "" },
+    body,
+    createdAt: "now",
+  });
+
+  test("finds the note anchored at the file path", () => {
+    // Arrange
+    const annotations = [
+      note("src/a.ts", "Renames b and adds c."),
+      note("src/b.ts", "Swaps the line."),
+    ];
+
+    // Assert
+    expect(noteForFile(annotations, "src/b.ts")).toBe("Swaps the line.");
+    expect(noteForFile(annotations, "src/c.ts")).toBeUndefined();
+  });
+
+  test("ignores non-note annotations that happen to quote the path", () => {
+    // Arrange
+    const comment: Annotation = {
+      id: "a_1",
+      kind: "comment",
+      anchor: { quote: "src/a.ts", prefix: "", suffix: "" },
+      body: "not a note",
+      createdAt: "now",
+    };
+
+    // Assert
+    expect(noteForFile([comment], "src/a.ts")).toBeUndefined();
+  });
+});