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

package/src/diff-fold.test.ts

@@ -0,0 +1,78 @@
+/** Per-file collapse and full-file weave over the flat diff rows. */
+
+import { describe, expect, test } from "bun:test";
+import type { DiffRow } from "./view-diff";
+import { applyFold, weaveFullFileRows } from "./diff-fold";
+
+function row(kind: DiffRow["kind"], text: string, extra: Partial<DiffRow> = {}): DiffRow {
+  return { kind, text, file: "a.ts", ...extra };
+}
+
+// a two-line change in a four-line file: line 2 swapped, lines 1/3/4 unchanged
+const base: DiffRow[] = [
+  row("file", "a.ts"),
+  row("hunk", "@@ -1,3 +1,3 @@"),
+  row("ctx", "line one", { oldLine: 1, newLine: 1 }),
+  row("del", "old two", { oldLine: 2 }),
+  row("add", "new two", { newLine: 2 }),
+  row("ctx", "line three", { oldLine: 3, newLine: 3 }),
+];
+
+const contents = {
+  path: "a.ts",
+  oldContents: "line one\nold two\nline three\nline four\n",
+  newContents: "line one\nnew two\nline three\nline four\n",
+};
+
+describe("applyFold", () => {
+  test("with no fold state it returns the base rows unchanged", () => {
+    expect(applyFold(base, new Set(), new Set(), [contents])).toBe(base);
+  });
+
+  test("a collapsed file keeps only its file band", () => {
+    // Act
+    const folded = applyFold(base, new Set(["a.ts"]), new Set(), [contents]);
+
+    // Assert
+    expect(folded).toHaveLength(1);
+    expect(folded[0]).toEqual(row("file", "a.ts"));
+  });
+
+  test("an expanded file weaves the unchanged tail line the hunk never showed", () => {
+    // Act
+    const folded = applyFold(base, new Set(), new Set(["a.ts"]), [contents]);
+
+    // Assert - the hunk header is gone and "line four" (outside the hunk) now shows
+    expect(folded.some((r) => r.kind === "hunk")).toBe(false);
+    const four = folded.find((r) => r.text === "line four");
+
+    expect(four).toEqual(row("ctx", "line four", { oldLine: 4, newLine: 4 }));
+  });
+
+  test("expand is a no-op without the file's full contents", () => {
+    // Act - no contents entry, so the file keeps its hunks
+    const folded = applyFold(base, new Set(), new Set(["a.ts"]), undefined);
+
+    // Assert
+    expect(folded).toEqual(base);
+  });
+});
+
+describe("weaveFullFileRows", () => {
+  test("keeps the change rows and fills every unchanged line as context in order", () => {
+    // Arrange - the file's code rows (no headers)
+    const codeRows = base.slice(2);
+
+    // Act
+    const woven = weaveFullFileRows("a.ts", codeRows, contents.newContents);
+
+    // Assert - full file: ctx1, del, add, ctx3, ctx4
+    expect(woven.map((r) => `${r.kind}:${r.text}`)).toEqual([
+      "ctx:line one",
+      "del:old two",
+      "add:new two",
+      "ctx:line three",
+      "ctx:line four",
+    ]);
+  });
+});

package/src/diff-fold.ts

@@ -0,0 +1,126 @@
+/**
+ * Per-file fold state for the diff sheet, applied over the flat diff rows so the
+ * cursor, curation, and rendering all read one array. A collapsed file shows only
+ * its file band; an expanded file shows its whole contents with the diff woven in
+ * (unchanged lines become context rows), an "expand all lines" view.
+ */
+
+import type { DiffRow } from "./view-diff";
+
+/** The full old/new contents a diff carries per file (curatable diffs do). */
+export interface FileContents {
+  path: string;
+  newContents: string;
+  oldContents: string;
+}
+
+/** Split file contents into lines, dropping the single trailing newline the file carries. */
+function contentLines(contents: string): string[] {
+  if (contents === "") return [];
+
+  return contents.replace(/\n$/, "").split("\n");
+}
+
+/**
+ * Weave a file's hunk rows into its full contents: unchanged lines between and
+ * around the hunks become context rows, so the whole file renders with the diff
+ * inline. `codeRows` are the file's ctx/add/del rows in order (no headers).
+ */
+export function weaveFullFileRows(
+  fileName: string,
+  codeRows: DiffRow[],
+  newContents: string,
+): DiffRow[] {
+  const newLines = contentLines(newContents);
+  const woven: DiffRow[] = [];
+  // the next unchanged old/new line numbers to emit while filling gaps between hunks
+  let newCursor = 1;
+  let oldCursor = 1;
+  const fillTo = (newLine: number): void => {
+    while (newCursor < newLine) {
+      woven.push({
+        kind: "ctx",
+        text: newLines[newCursor - 1] ?? "",
+        file: fileName,
+        oldLine: oldCursor,
+        newLine: newCursor,
+      });
+      newCursor += 1;
+      oldCursor += 1;
+    }
+  };
+
+  for (const row of codeRows) {
+    if (row.newLine !== undefined) {
+      fillTo(row.newLine);
+      woven.push(row);
+      newCursor = row.newLine + 1;
+      if (row.kind === "ctx") oldCursor = (row.oldLine ?? oldCursor) + 1;
+    } else {
+      // a deletion consumes an old line only; it keeps its place before the additions
+      woven.push(row);
+      oldCursor = (row.oldLine ?? oldCursor) + 1;
+    }
+  }
+  // the unchanged tail after the last hunk
+  while (newCursor <= newLines.length) {
+    woven.push({
+      kind: "ctx",
+      text: newLines[newCursor - 1] ?? "",
+      file: fileName,
+      oldLine: oldCursor,
+      newLine: newCursor,
+    });
+    newCursor += 1;
+    oldCursor += 1;
+  }
+
+  return woven;
+}
+
+/**
+ * Rebuild the diff rows with per-file fold state. A collapsed file keeps only its
+ * file band; an expanded file with known contents shows its whole file woven; every
+ * other file keeps its hunks. Row order and the file bands themselves are preserved.
+ */
+export function applyFold(
+  base: DiffRow[],
+  collapsed: ReadonlySet<string>,
+  expanded: ReadonlySet<string>,
+  files: readonly FileContents[] | undefined,
+): DiffRow[] {
+  if (collapsed.size === 0 && expanded.size === 0) return base;
+  const contentsByPath = new Map((files ?? []).map((file) => [file.path, file]));
+  const out: DiffRow[] = [];
+  let index = 0;
+
+  while (index < base.length) {
+    const row = base[index]!;
+
+    if (row.kind !== "file") {
+      out.push(row);
+      index += 1;
+      continue;
+    }
+    out.push(row);
+    const file = row.file;
+    let end = index + 1;
+
+    while (end < base.length && base[end]!.kind !== "file") end += 1;
+    const body = base.slice(index + 1, end);
+    const contents = contentsByPath.get(file);
+
+    if (collapsed.has(file)) {
+      // only the file band; the body is hidden
+    } else if (expanded.has(file) && contents) {
+      const codeRows = body.filter((bodyRow) => bodyRow.kind !== "hunk");
+
+      out.push(...weaveFullFileRows(file, codeRows, contents.newContents));
+    } else {
+      out.push(...body);
+    }
+    index = end;
+  }
+
+  return out;
+}

package/src/diff-hunk-curate.test.ts

@@ -0,0 +1,315 @@
+import { describe, expect, test } from "bun:test";
+import { unifiedDiffText, type DiffFileContents } from "@cueloop/schema";
+import {
+  changeRejectionForRow,
+  curateDiff,
+  hunkRejectionForRow,
+  isRowRejected,
+  locateLine,
+  parseFileDiff,
+  type HunkRejection,
+} from "./diff-hunk-curate";
+import type { DiffRow } from "./view-diff";
+
+const OLD = "line1\nline2\nline3\nline4\nline5\n";
+// Two changes in one hunk: line2 modified, then a pure addition after line4.
+const NEW = "line1\nCHANGED2\nline3\nline4\nADDED\nline5\n";
+const FILE: DiffFileContents = {
+  path: "src/a.ts",
+  oldContents: OLD,
+  newContents: NEW,
+  status: "modified",
+};
+
+// Two changes far apart, so the model splits into two hunks.
+const MULTI_OLD = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\n";
+const MULTI_NEW = "a\nB\nc\nd\ne\nf\ng\nh\ni\nj\nK\nl\n";
+const MULTI: DiffFileContents = {
+  path: "src/b.ts",
+  oldContents: MULTI_OLD,
+  newContents: MULTI_NEW,
+  status: "modified",
+};
+
+describe("curateDiff", () => {
+  test("no rejections reproduces the full per-file diff", () => {
+    // Arrange
+    const rejections: HunkRejection[] = [];
+
+    // Act
+    const patch = curateDiff([FILE], rejections);
+
+    // Assert
+    expect(patch).toBe(unifiedDiffText(OLD, NEW, FILE.path)!);
+    expect(patch).toContain("+CHANGED2");
+    expect(patch).toContain("+ADDED");
+  });
+
+  test("whole-hunk reject drops every change in that hunk", () => {
+    // Arrange
+    const rejections: HunkRejection[] = [{ path: FILE.path, hunkIndex: 0 }];
+
+    // Act
+    const patch = curateDiff([FILE], rejections);
+
+    // Assert - the only hunk was reverted, so nothing is left to apply
+    expect(patch).toBe("");
+  });
+
+  test("change-level reject keeps the other accepted change exactly", () => {
+    // Arrange - reject the line2 modification (hunkContent index 1), keep ADDED
+    const rejections: HunkRejection[] = [{ path: FILE.path, hunkIndex: 0, changeIndex: 1 }];
+    const expectedNew = "line1\nline2\nline3\nline4\nADDED\nline5\n";
+
+    // Act
+    const patch = curateDiff([FILE], rejections);
+
+    // Assert
+    expect(patch).toBe(unifiedDiffText(OLD, expectedNew, FILE.path)!);
+    expect(patch).not.toContain("CHANGED2");
+    expect(patch).toContain("+ADDED");
+  });
+
+  test("change-level reject of the addition keeps the modification", () => {
+    // Arrange - reject the pure addition (hunkContent index 3), keep CHANGED2
+    const rejections: HunkRejection[] = [{ path: FILE.path, hunkIndex: 0, changeIndex: 3 }];
+    const expectedNew = "line1\nCHANGED2\nline3\nline4\nline5\n";
+
+    // Act
+    const patch = curateDiff([FILE], rejections);
+
+    // Assert
+    expect(patch).toBe(unifiedDiffText(OLD, expectedNew, FILE.path)!);
+    expect(patch).toContain("+CHANGED2");
+    expect(patch).not.toContain("ADDED");
+  });
+
+  test("rejecting every change in a file yields an empty patch", () => {
+    // Arrange
+    const rejections: HunkRejection[] = [
+      { path: FILE.path, hunkIndex: 0, changeIndex: 1 },
+      { path: FILE.path, hunkIndex: 0, changeIndex: 3 },
+    ];
+
+    // Act
+    const patch = curateDiff([FILE], rejections);
+
+    // Assert
+    expect(patch).toBe("");
+  });
+
+  test("whole-hunk reject supersedes a change reject for the same hunk", () => {
+    // Arrange - a redundant change reject alongside the whole-hunk reject
+    const rejections: HunkRejection[] = [
+      { path: FILE.path, hunkIndex: 0 },
+      { path: FILE.path, hunkIndex: 0, changeIndex: 1 },
+    ];
+
+    // Act
+    const patch = curateDiff([FILE], rejections);
+
+    // Assert
+    expect(patch).toBe("");
+  });
+
+  test("multi-file curation keeps each file's accepted changes independent", () => {
+    // Arrange - reject file A's addition; leave file B whole
+    const rejections: HunkRejection[] = [{ path: FILE.path, hunkIndex: 0, changeIndex: 3 }];
+
+    // Act
+    const patch = curateDiff([FILE, MULTI], rejections);
+
+    // Assert
+    expect(patch).toContain("src/a.ts");
+    expect(patch).toContain("src/b.ts");
+    expect(patch).toContain("+CHANGED2");
+    expect(patch).not.toContain("+ADDED");
+    expect(patch).toContain("+B");
+    expect(patch).toContain("+K");
+  });
+
+  test("rejecting one of two hunks reverts only that hunk", () => {
+    // Arrange - reject the first hunk (B), keep the second (K)
+    const rejections: HunkRejection[] = [{ path: MULTI.path, hunkIndex: 0 }];
+    const expectedNew = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nK\nl\n";
+
+    // Act
+    const patch = curateDiff([MULTI], rejections);
+
+    // Assert
+    expect(patch).toBe(unifiedDiffText(MULTI_OLD, expectedNew, MULTI.path)!);
+  });
+});
+
+describe("locateLine and row mapping", () => {
+  test("locateLine resolves a modified new line to its change block", () => {
+    // Arrange
+    const model = parseFileDiff(FILE);
+
+    // Act - CHANGED2 is new line 2
+    const located = locateLine(model, "addition", 2);
+
+    // Assert
+    expect(located).toEqual({ hunkIndex: 0, changeIndex: 1 });
+  });
+
+  test("locateLine resolves the pure addition to its change block", () => {
+    // Arrange
+    const model = parseFileDiff(FILE);
+
+    // Act - ADDED is new line 5
+    const located = locateLine(model, "addition", 5);
+
+    // Assert
+    expect(located).toEqual({ hunkIndex: 0, changeIndex: 3 });
+  });
+
+  test("locateLine resolves a context line to a hunk with no change index", () => {
+    // Arrange
+    const model = parseFileDiff(FILE);
+
+    // Act - line1 is unchanged context
+    const located = locateLine(model, "addition", 1);
+
+    // Assert
+    expect(located).toEqual({ hunkIndex: 0, changeIndex: undefined });
+  });
+
+  test("changeRejectionForRow targets the change under an addition row", () => {
+    // Arrange
+    const model = parseFileDiff(FILE);
+    const row: DiffRow = { kind: "add", text: "CHANGED2\n", file: FILE.path, newLine: 2 };
+
+    // Act
+    const rejection = changeRejectionForRow(FILE.path, model, row);
+
+    // Assert
+    expect(rejection).toEqual({ path: FILE.path, hunkIndex: 0, changeIndex: 1 });
+  });
+
+  test("changeRejectionForRow targets the change under a deletion row", () => {
+    // Arrange
+    const model = parseFileDiff(FILE);
+    const row: DiffRow = { kind: "del", text: "line2\n", file: FILE.path, oldLine: 2 };
+
+    // Act
+    const rejection = changeRejectionForRow(FILE.path, model, row);
+
+    // Assert
+    expect(rejection).toEqual({ path: FILE.path, hunkIndex: 0, changeIndex: 1 });
+  });
+
+  test("changeRejectionForRow returns null on a context row", () => {
+    // Arrange
+    const model = parseFileDiff(FILE);
+    const row: DiffRow = { kind: "ctx", text: "line1\n", file: FILE.path, oldLine: 1, newLine: 1 };
+
+    // Act
+    const rejection = changeRejectionForRow(FILE.path, model, row);
+
+    // Assert
+    expect(rejection).toBeNull();
+  });
+
+  test("hunkRejectionForRow targets the enclosing hunk of a context row", () => {
+    // Arrange
+    const model = parseFileDiff(FILE);
+    const row: DiffRow = { kind: "ctx", text: "line1\n", file: FILE.path, oldLine: 1, newLine: 1 };
+
+    // Act
+    const rejection = hunkRejectionForRow(FILE.path, model, row);
+
+    // Assert
+    expect(rejection).toEqual({ path: FILE.path, hunkIndex: 0 });
+  });
+
+  test("hunkRejectionForRow resolves the second hunk in a multi-hunk file", () => {
+    // Arrange
+    const model = parseFileDiff(MULTI);
+    const row: DiffRow = { kind: "add", text: "K\n", file: MULTI.path, newLine: 11 };
+
+    // Act
+    const rejection = hunkRejectionForRow(MULTI.path, model, row);
+
+    // Assert
+    expect(rejection).toEqual({ path: MULTI.path, hunkIndex: 1 });
+  });
+});
+
+describe("isRowRejected", () => {
+  test("a change row is rejected when its whole hunk is rejected", () => {
+    // Arrange
+    const model = parseFileDiff(FILE);
+    const row: DiffRow = { kind: "add", text: "ADDED\n", file: FILE.path, newLine: 5 };
+    const rejections: HunkRejection[] = [{ path: FILE.path, hunkIndex: 0 }];
+
+    // Act
+    const rejected = isRowRejected(FILE.path, model, row, rejections);
+
+    // Assert
+    expect(rejected).toBe(true);
+  });
+
+  test("a change row is rejected only by its own change-level decision", () => {
+    // Arrange
+    const model = parseFileDiff(FILE);
+    const addedRow: DiffRow = { kind: "add", text: "ADDED\n", file: FILE.path, newLine: 5 };
+    const changedRow: DiffRow = { kind: "add", text: "CHANGED2\n", file: FILE.path, newLine: 2 };
+    const rejections: HunkRejection[] = [{ path: FILE.path, hunkIndex: 0, changeIndex: 3 }];
+
+    // Act + Assert - only the addition's change is dropped
+    expect(isRowRejected(FILE.path, model, addedRow, rejections)).toBe(true);
+    expect(isRowRejected(FILE.path, model, changedRow, rejections)).toBe(false);
+  });
+
+  test("a context row is never marked rejected", () => {
+    // Arrange
+    const model = parseFileDiff(FILE);
+    const row: DiffRow = { kind: "ctx", text: "line1\n", file: FILE.path, oldLine: 1, newLine: 1 };
+    const rejections: HunkRejection[] = [{ path: FILE.path, hunkIndex: 0 }];
+
+    // Act
+    const rejected = isRowRejected(FILE.path, model, row, rejections);
+
+    // Assert
+    expect(rejected).toBe(false);
+  });
+});
+
+describe("curateDiff file-state headers", () => {
+  test("an accepted created file points its old side at /dev/null", () => {
+    // Arrange - a new file has empty old contents
+    const created: DiffFileContents = {
+      path: "src/new.ts",
+      oldContents: "",
+      newContents: "one\ntwo\n",
+      status: "added",
+    };
+
+    // Act
+    const patch = curateDiff([created], []);
+
+    // Assert
+    expect(patch).toContain("--- /dev/null");
+    expect(patch).toContain("+++ b/src/new.ts");
+    expect(patch).toContain("+one");
+  });
+
+  test("an accepted deleted file points its new side at /dev/null", () => {
+    // Arrange - a deleted file has empty new contents
+    const deleted: DiffFileContents = {
+      path: "src/gone.ts",
+      oldContents: "one\ntwo\n",
+      newContents: "",
+      status: "deleted",
+    };
+
+    // Act
+    const patch = curateDiff([deleted], []);
+
+    // Assert
+    expect(patch).toContain("--- a/src/gone.ts");
+    expect(patch).toContain("+++ /dev/null");
+    expect(patch).toContain("-one");
+  });
+});

package/src/diff-hunk-curate.ts

@@ -0,0 +1,153 @@
+/**
+ * Diff hunk curation: turn a set of reject decisions over a working-tree diff
+ * into the curated unified-diff patch of the accepted changes only. Each file
+ * is re-parsed from its FULL old/new contents (isPartial: false), so
+ * `diffAcceptRejectHunk` can revert a whole hunk or a single change and the
+ * serialized patch keeps exact line numbers and stays applyable.
+ *
+ * A rejection is addressed by parse-model coordinates, never by rendered-row
+ * position: `hunkIndex` indexes `model.hunks`, and `changeIndex` indexes that
+ * hunk's `hunkContent` (context and change blocks combined - the same space
+ * `diffAcceptRejectHunk`'s config consumes). A cursor row is mapped to those
+ * coordinates by its absolute file line number, so it stays correct even when
+ * the stored git patch and the model split hunks differently.
+ */
+
+import type { FileDiffMetadata } from "@pierre/diffs";
+import type { HunkRejection } from "@cueloop/schema";
+import type { DiffRow } from "./view-diff";
+
+export { curateDiff, parseFileDiff } from "@cueloop/daemon/curate";
+export type { HunkRejection } from "@cueloop/schema";
+
+/** Which side of the diff a line number addresses. */
+type DiffSide = "addition" | "deletion";
+
+/** A line resolved onto its owning hunk, and its change block when it is one. */
+export interface LocatedLine {
+  hunkIndex: number;
+  /** Present only when the line sits inside a change block (an add/del line). */
+  changeIndex?: number;
+}
+
+/**
+ * Resolve a 1-based file line on one side to its hunk and, when the line is
+ * part of a change block, that block's `hunkContent` index.
+ */
+export function locateLine(
+  model: FileDiffMetadata,
+  side: DiffSide,
+  lineNumber: number,
+): LocatedLine | null {
+  const index = lineNumber - 1;
+
+  for (const [hunkIndex, hunk] of model.hunks.entries()) {
+    for (const [contentIndex, content] of hunk.hunkContent.entries()) {
+      const base = side === "addition" ? content.additionLineIndex : content.deletionLineIndex;
+      const count =
+        content.type === "context"
+          ? content.lines
+          : side === "addition"
+            ? content.additions
+            : content.deletions;
+
+      if (count > 0 && index >= base && index < base + count) {
+        return { hunkIndex, changeIndex: content.type === "change" ? contentIndex : undefined };
+      }
+    }
+  }
+
+  return null;
+}
+
+/** The side and line number a change row addresses; null for headers/context. */
+function changeSideLine(
+  row: Pick<DiffRow, "kind" | "oldLine" | "newLine">,
+): { side: DiffSide; lineNumber: number } | null {
+  if (row.kind === "add" && row.newLine !== undefined)
+    return { side: "addition", lineNumber: row.newLine };
+  if (row.kind === "del" && row.oldLine !== undefined)
+    return { side: "deletion", lineNumber: row.oldLine };
+
+  return null;
+}
+
+/**
+ * The whole-hunk rejection for the row under the cursor, or null when the row
+ * is not inside a hunk. Context rows resolve through their new-file line.
+ */
+export function hunkRejectionForRow(
+  path: string,
+  model: FileDiffMetadata,
+  row: Pick<DiffRow, "kind" | "oldLine" | "newLine">,
+): HunkRejection | null {
+  const change = changeSideLine(row);
+  const located = change
+    ? locateLine(model, change.side, change.lineNumber)
+    : row.newLine !== undefined
+      ? locateLine(model, "addition", row.newLine)
+      : row.oldLine !== undefined
+        ? locateLine(model, "deletion", row.oldLine)
+        : null;
+
+  return located ? { path, hunkIndex: located.hunkIndex } : null;
+}
+
+/**
+ * The change-level rejection for the row under the cursor, or null when the row
+ * carries no change (a header or context line).
+ */
+export function changeRejectionForRow(
+  path: string,
+  model: FileDiffMetadata,
+  row: Pick<DiffRow, "kind" | "oldLine" | "newLine">,
+): HunkRejection | null {
+  const change = changeSideLine(row);
+
+  if (!change) return null;
+  const located = locateLine(model, change.side, change.lineNumber);
+
+  if (!located || located.changeIndex === undefined) return null;
+
+  return { path, hunkIndex: located.hunkIndex, changeIndex: located.changeIndex };
+}
+
+/** Whether two rejections address the same target. */
+export function sameRejection(left: HunkRejection, right: HunkRejection): boolean {
+  return (
+    left.path === right.path &&
+    left.hunkIndex === right.hunkIndex &&
+    left.changeIndex === right.changeIndex
+  );
+}
+
+/** Whether `rejection` drops the whole hunk that `target` sits in. */
+export function rejectsWholeHunk(rejection: HunkRejection, target: HunkRejection): boolean {
+  return (
+    rejection.path === target.path &&
+    rejection.hunkIndex === target.hunkIndex &&
+    rejection.changeIndex === undefined
+  );
+}
+
+/** Whether a change row is dropped by the current decisions (for dimming). */
+export function isRowRejected(
+  path: string,
+  model: FileDiffMetadata,
+  row: Pick<DiffRow, "kind" | "oldLine" | "newLine">,
+  rejections: HunkRejection[],
+): boolean {
+  const change = changeSideLine(row);
+
+  if (!change) return false;
+  const located = locateLine(model, change.side, change.lineNumber);
+
+  if (!located || located.changeIndex === undefined) return false;
+
+  return rejections.some(
+    (rejection) =>
+      rejection.path === path &&
+      rejection.hunkIndex === located.hunkIndex &&
+      (rejection.changeIndex === undefined || rejection.changeIndex === located.changeIndex),
+  );
+}