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

package/src/thread-controller.curate.test.ts

@@ -0,0 +1,476 @@
+import { describe, expect, mock, test } from "bun:test";
+import {
+  applyTextCuts,
+  cutBlock,
+  parseBlocks,
+  restoreBlock,
+  SCHEMA_VERSION,
+  type DiffFileContents,
+  type HunkRejection,
+  type Thread,
+  type TextCut,
+} from "@cueloop/schema";
+import { curateDiff } from "@cueloop/daemon/curate";
+import type { ThreadClient } from "@cueloop/daemon/client";
+import { createReviewController } from "./thread-controller";
+
+const PATCH = `diff --git a/src/store.ts b/src/store.ts
+index 111..222 100644
+--- a/src/store.ts
++++ b/src/store.ts
+@@ -1,4 +1,4 @@
+ export class Store {
+-  private items = [];
++  private items = new Map();
+ }
+`;
+
+const FILES: DiffFileContents[] = [
+  {
+    path: "src/store.ts",
+    oldContents: "export class Store {\n  private items = [];\n}\n",
+    newContents: "export class Store {\n  private items = new Map();\n}\n",
+    status: "modified",
+  },
+];
+
+function diffSession(files?: DiffFileContents[]): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_diff",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "diff", content: PATCH, meta: {}, files },
+    revisions: [{ revision: 1, content: PATCH, submittedAt: "2026-01-01T00:00:00.000Z" }],
+    annotations: [],
+    message: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+interface WorkingCopySink {
+  workingCopy?: string;
+  textCuts?: TextCut[];
+}
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
+/** A fake client that records the working copy the controller writes. */
+function fakeClient(initial: Thread, sink: WorkingCopySink): ThreadClient {
+  let session = initial;
+
+  return {
+    onEvent: () => () => {},
+    subscribe: async () => {},
+    sessionGet: async () => session,
+    sessionList: async () => [session],
+    sessionComment: unimplemented("sessionComment"),
+    sessionAnnotate: unimplemented("sessionAnnotate"),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
+    sessionSetWorkingCopy: mock(
+      async (_id: string, content: string | undefined, textCuts?: TextCut[]) => {
+        sink.workingCopy = content;
+        sink.textCuts = textCuts;
+        session = { ...session, workingCopy: content, textCuts };
+
+        return session;
+      },
+    ),
+    // the daemon's block primitives, stood in for with the same pure helpers it uses
+    sessionCutBlock: mock(async (_id: string, blockIndex: number) => {
+      const working = session.workingCopy ?? session.artifact.content;
+      const content = cutBlock(working, parseBlocks(working)[blockIndex]!);
+
+      sink.workingCopy = content;
+      session = { ...session, workingCopy: content };
+
+      return session;
+    }),
+    sessionRestoreBlock: mock(async (_id: string, baseBlockIndex: number, line?: number) => {
+      const base = session.artifact.content;
+      const working = session.workingCopy ?? base;
+      const content = restoreBlock(
+        base,
+        working,
+        parseBlocks(base)[baseBlockIndex]!,
+        line ?? working.split("\n").length,
+      );
+
+      sink.workingCopy = content;
+      session = { ...session, workingCopy: content };
+      if (content === undefined) delete session.workingCopy;
+
+      return session;
+    }),
+    // the daemon's curation, stood in for: the record carries the decisions and the patch they leave
+    sessionCurate: mock(async (_id: string, rejections: HunkRejection[]) => {
+      const content = rejections.length
+        ? curateDiff(session.artifact.files!, rejections)
+        : undefined;
+
+      sink.workingCopy = content;
+      session = { ...session, workingCopy: content };
+      if (rejections.length) session.curation = rejections;
+      else delete session.curation;
+
+      return session;
+    }),
+    sessionSetAccess: unimplemented("sessionSetAccess"),
+    sessionNavigate: unimplemented("sessionNavigate"),
+    sessionBranch: unimplemented("sessionBranch"),
+    sessionSwitch: unimplemented("sessionSwitch"),
+    sessionLabel: unimplemented("sessionLabel"),
+    sessionFork: unimplemented("sessionFork"),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
+    sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionSetShares: unimplemented("sessionSetShares"),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionSendMessage: unimplemented("sessionSendMessage"),
+    close: () => {},
+  };
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+async function connected(session: Thread) {
+  const sink: WorkingCopySink = {};
+  const client = fakeClient(session, sink);
+  const controller = createReviewController({
+    sessionId: session.id,
+    openClient: async () => client,
+  });
+
+  controller.connect();
+  await tick();
+
+  return { controller, client, sink };
+}
+
+// rows for PATCH: file(0), hunk(1), ctx(2), del(3), add(4), ctx(5)
+describe("diff hunk curation", () => {
+  test("rejecting the only change writes an empty curated working copy", async () => {
+    // Arrange
+    const { controller, sink } = await connected(diffSession(FILES));
+
+    // Act - reject the change on the added line
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert
+    expect(controller.getSnapshot().toast).toBeNull();
+    expect(sink.workingCopy).toBe("");
+  });
+
+  test("both the deletion and addition rows of the change dim", async () => {
+    // Arrange
+    const { controller } = await connected(diffSession(FILES));
+
+    // Act
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - the change spans the del row and the add row
+    expect([...controller.rejectedRows()].sort((a, b) => a - b)).toEqual([3, 4]);
+  });
+
+  test("toggling the same change twice restores the full diff", async () => {
+    // Arrange
+    const { controller, sink } = await connected(diffSession(FILES));
+
+    // Act - reject then restore
+    controller.toggleRejectChange(4);
+    await tick();
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - no decisions left, so the working copy reverts to undefined
+    expect(controller.getSnapshot().toast).toBeNull();
+    expect(sink.workingCopy).toBeUndefined();
+    expect(controller.rejectedRows().size).toBe(0);
+  });
+
+  test("whole-hunk reject drops the hunk from the working copy", async () => {
+    // Arrange
+    const { controller, sink } = await connected(diffSession(FILES));
+
+    // Act - reject the whole hunk from any of its rows
+    controller.toggleRejectHunk(3);
+    await tick();
+
+    // Assert - the single hunk is the whole diff, so nothing remains
+    expect(controller.getSnapshot().toast).toBeNull();
+    expect(sink.workingCopy).toBe("");
+  });
+
+  test("a rejected change becomes a removal card with a source, id, and preview", async () => {
+    // Arrange
+    const { controller } = await connected(diffSession(FILES));
+
+    // Act
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - one item: diff source, revealing the change's row, both lines previewed
+    const items = controller.curationItems();
+
+    expect(items.length).toBe(1);
+    expect(items[0]!.source).toBe("diff");
+    expect(items[0]!.id).toBe("diff:src/store.ts#0#1");
+    expect(items[0]!.revealIndex).toBe(3);
+    expect(items[0]!.preview).toEqual([
+      "-   private items = [];",
+      "+   private items = new Map();",
+    ]);
+  });
+
+  test("a rejected hunk becomes a removal card with the whole-hunk id", async () => {
+    // Arrange
+    const { controller } = await connected(diffSession(FILES));
+
+    // Act
+    controller.toggleRejectHunk(3);
+    await tick();
+
+    // Assert - the whole hunk, id diff:path#hunk#hunk
+    const items = controller.curationItems();
+
+    expect(items.length).toBe(1);
+    expect(items[0]!.source).toBe("diff");
+    expect(items[0]!.id).toBe("diff:src/store.ts#0#hunk");
+  });
+
+  test("restoreCuration drops the diff removal and reverts the working copy", async () => {
+    // Arrange - one change rejected
+    const { controller, sink } = await connected(diffSession(FILES));
+
+    controller.toggleRejectChange(4);
+    await tick();
+    const [item] = controller.curationItems();
+
+    // Act
+    controller.restoreCuration(item!.id);
+    await tick();
+
+    // Assert - the list empties and the working copy reverts to the full diff
+    expect(controller.getSnapshot().toast).toBeNull();
+    expect(controller.curationItems().length).toBe(0);
+    expect(sink.workingCopy).toBeUndefined();
+    expect(controller.rejectedRows().size).toBe(0);
+  });
+
+  test("restoreCuration ignores an unknown id", async () => {
+    // Arrange - one change rejected
+    const { controller } = await connected(diffSession(FILES));
+
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Act
+    controller.restoreCuration("diff:nope#0#0");
+    await tick();
+
+    // Assert - the item stays
+    expect(controller.curationItems().length).toBe(1);
+  });
+
+  test("a second decision before the daemon answers builds on the first", async () => {
+    // Arrange
+    const { controller, client } = await connected(diffSession(FILES));
+
+    // Act - reject, then restore, with no answer in between
+    controller.toggleRejectChange(4);
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - the second request restores; a stale snapshot would reject again
+    expect(client.sessionCurate).toHaveBeenCalledTimes(2);
+    expect(client.sessionCurate).toHaveBeenNthCalledWith(1, "ses_diff", [
+      { path: "src/store.ts", hunkIndex: 0, changeIndex: 1 },
+    ]);
+    expect(client.sessionCurate).toHaveBeenNthCalledWith(2, "ses_diff", []);
+  });
+
+  test("curation is disabled without full file contents", async () => {
+    // Arrange - a legacy diff with no artifact.files
+    const { controller, sink } = await connected(diffSession(undefined));
+
+    // Act
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert
+    expect(controller.getSnapshot().status).toContain("hunk curation needs full file contents");
+    expect(sink.workingCopy).toBeUndefined();
+  });
+
+  test("curation is disabled when a revision cleared its file snapshots", async () => {
+    const { controller, client } = await connected(diffSession([]));
+
+    controller.toggleRejectChange(4);
+    await tick();
+
+    expect(controller.getSnapshot().status).toContain("hunk curation needs full file contents");
+    expect(client.sessionCurate).not.toHaveBeenCalled();
+  });
+});
+
+const PLAN_CONTENT = "# Title\n\nFirst paragraph.\n\nSecond paragraph.\n";
+// the working copy with the "Second paragraph." block cut out
+const PLAN_CUT = "# Title\n\nFirst paragraph.\n";
+
+function planSession(workingCopy?: string): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_plan",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: PLAN_CONTENT, meta: {} },
+    revisions: [{ revision: 1, content: PLAN_CONTENT, submittedAt: "2026-01-01T00:00:00.000Z" }],
+    annotations: [],
+    message: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    workingCopy,
+  };
+}
+
+describe("plan cut removals", () => {
+  test("a cut block becomes a plan removal card previewing its content", async () => {
+    // Arrange - a plan whose working copy dropped the second paragraph
+    const { controller } = await connected(planSession(PLAN_CUT));
+
+    // Act
+    const items = controller.curationItems();
+
+    // Assert - one plan-source removal, keyed on the base line range, content previewed
+    expect(items.length).toBe(1);
+    expect(items[0]!.source).toBe("plan");
+    expect(items[0]!.id).toBe("plan:4-4");
+    expect(items[0]!.preview).toEqual(["Second paragraph."]);
+  });
+
+  test("restoreCuration re-inserts the cut block and returns to pristine", async () => {
+    // Arrange
+    const { controller, sink } = await connected(planSession(PLAN_CUT));
+    const [item] = controller.curationItems();
+
+    // Act
+    controller.restoreCuration(item!.id);
+    await tick();
+
+    // Assert - restoring the only cut round-trips to the submitted revision
+    expect(controller.getSnapshot().toast).toBeNull();
+    expect(sink.workingCopy).toBeUndefined();
+  });
+
+  test("a second cut before the daemon answers indexes the already-cut copy", async () => {
+    // Arrange - pristine plan: title(0), first(1), second(2)
+    const { controller, client, sink } = await connected(planSession());
+
+    // Act - cut the first paragraph, then the second, with no answer in between
+    controller.cut(1);
+    controller.cut(2);
+    await tick();
+
+    // Assert - the second paragraph is block 1 once the first is gone
+    expect(client.sessionCutBlock).toHaveBeenNthCalledWith(1, "ses_plan", 1);
+    expect(client.sessionCutBlock).toHaveBeenNthCalledWith(2, "ses_plan", 1);
+    expect(sink.workingCopy).toBe("# Title\n");
+  });
+
+  test("a whole-block Cut composes with an earlier exact Cut", async () => {
+    const start = PLAN_CONTENT.indexOf("paragraph.");
+    const end = PLAN_CONTENT.indexOf("Second") + "Sec".length;
+    const textCuts = [{ start, end, quote: PLAN_CONTENT.slice(start, end) }];
+    const session = {
+      ...planSession(applyTextCuts(PLAN_CONTENT, textCuts)),
+      textCuts,
+    };
+    const { controller, client, sink } = await connected(session);
+
+    controller.cut(1);
+    await tick();
+
+    expect(client.sessionSetWorkingCopy).toHaveBeenCalledTimes(1);
+    expect(client.sessionCutBlock).not.toHaveBeenCalled();
+    expect(sink.textCuts).toHaveLength(1);
+    expect(sink.workingCopy).toBe("# Title\nond paragraph.\n");
+  });
+});
+
+// a file whose hunk touches line 2 only, so lines 1/3/4 are unchanged tail/context
+const TAIL_PATCH = `diff --git a/src/store.ts b/src/store.ts
+--- a/src/store.ts
++++ b/src/store.ts
+@@ -2,1 +2,1 @@
+-  private items = [];
++  private items = new Map();
+`;
+
+function tailSession(): Thread {
+  return {
+    ...diffSession(),
+    artifact: {
+      type: "diff",
+      content: TAIL_PATCH,
+      meta: {},
+      files: [
+        {
+          path: "src/store.ts",
+          oldContents: "export class Store {\n  private items = [];\n}\nexport const x = 1;\n",
+          newContents:
+            "export class Store {\n  private items = new Map();\n}\nexport const x = 1;\n",
+          status: "modified",
+        },
+      ],
+    },
+  };
+}
+
+describe("diff file fold", () => {
+  test("collapse leaves only the file band; expand restores the body", async () => {
+    // Arrange
+    const { controller } = await connected(tailSession());
+    const bodyRows = () =>
+      controller.rows().filter((row) => row.file === "src/store.ts" && row.kind !== "file").length;
+
+    // Assert - starts unfolded with a body
+    expect(bodyRows()).toBeGreaterThan(0);
+
+    // Act / Assert - collapse hides the body
+    controller.setFileCollapsed("src/store.ts", true);
+    expect(bodyRows()).toBe(0);
+    expect(controller.isFileCollapsed("src/store.ts")).toBe(true);
+
+    // Act / Assert - unfold brings it back
+    controller.setFileCollapsed("src/store.ts", false);
+    expect(bodyRows()).toBeGreaterThan(0);
+  });
+
+  test("expand weaves the file's unchanged tail line the hunk never showed", async () => {
+    // Arrange
+    const { controller } = await connected(tailSession());
+    const hasTail = () => controller.rows().some((row) => row.text.includes("export const x = 1"));
+
+    // Assert - the hunk view does not show the tail line
+    expect(controller.canExpandFile("src/store.ts")).toBe(true);
+    expect(hasTail()).toBe(false);
+
+    // Act - weave the full file
+    controller.setFileExpanded("src/store.ts", true);
+
+    // Assert
+    expect(hasTail()).toBe(true);
+  });
+
+  test("a diff without full contents cannot be expanded", async () => {
+    // Arrange - no artifact.files
+    const { controller } = await connected(diffSession(undefined));
+
+    // Assert
+    expect(controller.canExpandFile("src/store.ts")).toBe(false);
+  });
+});

package/src/thread-controller.derivation.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
+import { sameDerivationInputs } from "./thread-controller";
+
+function threadFixture(overrides: Partial<Thread> = {}): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n\nShip it.\n", meta: {} },
+    revisions: [
+      { revision: 1, content: "# Plan\n\nShip it.\n", submittedAt: "2026-01-01T00:00:00.000Z" },
+    ],
+    annotations: [],
+    message: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+const annotation: Annotation = {
+  id: "ann_1",
+  kind: "comment",
+  anchor: { quote: "Ship it.", prefix: "", suffix: "" },
+  body: "nit",
+  createdAt: "2026-01-01T00:00:00.000Z",
+};
+
+describe("sameDerivationInputs", () => {
+  test("an annotation-only update reuses the projection (a fresh record, identical inputs)", () => {
+    // Arrange - the daemon re-serializes the whole thread on any change, so the record is all-new
+    const before = threadFixture();
+    const after = threadFixture({ annotations: [annotation] });
+
+    // Assert - the artifact and working copy are unchanged, so the projection can be reused
+    expect(sameDerivationInputs(before, after)).toBe(true);
+  });
+
+  test("a content edit forces a re-derivation", () => {
+    const before = threadFixture();
+    const after = threadFixture({
+      artifact: { type: "plan", content: "# Plan\n\nShip it soon.\n", meta: {} },
+    });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+
+  test("a working-copy change forces a re-derivation", () => {
+    const before = threadFixture();
+    const after = threadFixture({ workingCopy: "# Plan\n\nShip it.\n\nedited\n" });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+
+  test("a different thread is never a reuse", () => {
+    const before = threadFixture();
+    const after = threadFixture({ id: "ses_2" });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+});