@cueloop/client 0.1.0-alpha.5 → 0.1.0-alpha.50

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,233 @@
+/**
+ * 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 { parseDiffFromFile, diffAcceptRejectHunk, type FileDiffMetadata } from "@pierre/diffs";
+import { unifiedDiffText, type DiffFileContents, type DiffFileStatus } from "@cueloop/schema";
+import type { DiffRow } from "./view-diff";
+
+/** One reject decision; `changeIndex` absent rejects the whole hunk. */
+export interface HunkRejection {
+  path: string;
+  hunkIndex: number;
+  changeIndex?: number;
+}
+
+/** 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;
+}
+
+/**
+ * Context lines around each change. Matching git's default (3) makes the model
+ * split hunks like the rendered working-tree patch does; git's coalescing can
+ * still merge adjacent hunks differently, but the row is mapped by absolute line
+ * number (not by counting hunks), so a whole-hunk reject can only ever span the
+ * model hunk it lands in - never the wrong file or a crash.
+ */
+const DIFF_CONTEXT = 3;
+
+/** Parse one file's full contents into a non-partial diff model. */
+export function parseFileDiff(file: DiffFileContents): FileDiffMetadata {
+  return parseDiffFromFile(
+    { name: file.path, contents: file.oldContents },
+    { name: file.path, contents: file.newContents },
+    { context: DIFF_CONTEXT },
+  );
+}
+
+/**
+ * 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),
+  );
+}
+
+/**
+ * Apply one file's rejections and return its curated patch, or null when the
+ * curated content equals the old content (every change rejected - no patch).
+ * Whole-hunk rejections supersede change-level ones for the same hunk. Because
+ * `diffAcceptRejectHunk` returns a model with the same hunk/content shape, the
+ * indices stay valid across calls; they are applied high-to-low regardless, so
+ * the order is deterministic.
+ */
+function curateFilePatch(file: DiffFileContents, rejections: HunkRejection[]): string | null {
+  let model = parseFileDiff(file);
+  const wholeHunks = new Set(
+    rejections
+      .filter((rejection) => rejection.changeIndex === undefined)
+      .map((rejection) => rejection.hunkIndex),
+  );
+  for (const hunkIndex of [...wholeHunks].sort((a, b) => b - a)) {
+    model = diffAcceptRejectHunk(model, hunkIndex, "reject");
+  }
+  const changeRejections = rejections
+    .filter(
+      (rejection) => rejection.changeIndex !== undefined && !wholeHunks.has(rejection.hunkIndex),
+    )
+    .sort((a, b) => b.hunkIndex - a.hunkIndex || b.changeIndex! - a.changeIndex!);
+  for (const rejection of changeRejections) {
+    model = diffAcceptRejectHunk(model, rejection.hunkIndex, {
+      type: "reject",
+      changeIndex: rejection.changeIndex!,
+    });
+  }
+  const curatedNew = model.additionLines.join("");
+  if (curatedNew === file.oldContents) return null;
+  const patch = unifiedDiffText(file.oldContents, curatedNew, file.path);
+  if (patch === null) return null;
+  return withFileStateHeaders(patch, file.path, file.status, curatedNew);
+}
+
+/**
+ * Point the diff headers at /dev/null for a created or fully-deleted file so the
+ * curated patch applies. git's status - not empty contents - decides existence,
+ * so editing an existing empty file stays a modify; a deletion whose removals
+ * were partly restored also falls back to a modify.
+ */
+function withFileStateHeaders(
+  patch: string,
+  path: string,
+  status: DiffFileStatus,
+  curatedNew: string,
+): string {
+  if (status === "added") return patch.replace(`--- a/${path}`, "--- /dev/null");
+  if (status === "deleted" && curatedNew === "") {
+    return patch.replace(`+++ b/${path}`, "+++ /dev/null");
+  }
+  return patch;
+}
+
+/**
+ * The curated unified-diff patch of the accepted changes across every file.
+ * Files with no net change (unchanged, or with all changes rejected) drop out.
+ */
+export function curateDiff(files: DiffFileContents[], rejections: HunkRejection[]): string {
+  const parts: string[] = [];
+  for (const file of files) {
+    const fileRejections = rejections.filter((rejection) => rejection.path === file.path);
+    const patch = curateFilePatch(file, fileRejections);
+    if (patch) parts.push(patch);
+  }
+  return parts.join("\n");
+}