@cueloop/client 0.1.0-alpha.7 → 0.1.0-alpha.70

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

@@ -0,0 +1,438 @@
+import { describe, expect, mock, test } from "bun:test";
+import {
+  cutBlock,
+  parseBlocks,
+  restoreBlock,
+  SCHEMA_VERSION,
+  type DiffFileContents,
+  type HunkRejection,
+  type Thread,
+} from "@cueloop/schema";
+import { curateDiff } from "@cueloop/daemon/curate";
+import type { SessionClient } 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: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+interface WorkingCopySink {
+  workingCopy?: string;
+}
+
+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): SessionClient {
+  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) => {
+      sink.workingCopy = content;
+
+      return { ...session, workingCopy: content };
+    }),
+    // 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;
+    }),
+    sessionNavigate: unimplemented("sessionNavigate"),
+    sessionBranch: unimplemented("sessionBranch"),
+    sessionSwitch: unimplemented("sessionSwitch"),
+    sessionLabel: unimplemented("sessionLabel"),
+    sessionFork: unimplemented("sessionFork"),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
+    sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionResolve: unimplemented("sessionResolve"),
+    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().status).toContain("change rejected");
+    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().status).toContain("change restored");
+    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().status).toContain("hunk rejected");
+    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().status).toContain("removal restored");
+    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();
+  });
+});
+
+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: [],
+    verdict: 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().status).toContain("removal restored");
+    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");
+  });
+});
+
+// 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.live-diff.test.ts

@@ -0,0 +1,199 @@
+/**
+ * A non-diff thread (here a plan) still renders a real diff in the Changes view:
+ * the controller eagerly captures the live working-tree diff, so repoChanges()
+ * carries file contents and rows() derives from the patch - the same shape a
+ * cueloop diff pins, just computed live.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
+import type { SessionClient } from "@cueloop/daemon/client";
+import { createReviewController, type ShareTransport } from "./thread-controller";
+import { mergeFromShare } from "./share";
+
+const AT = "2026-01-01T00:00:00.000Z";
+
+const PATCH = `diff --git a/src/x.ts b/src/x.ts
+--- a/src/x.ts
++++ b/src/x.ts
+@@ -1,1 +1,1 @@
+-const a = 1;
++const a = 2;
+`;
+
+const FILES = [
+  {
+    path: "src/x.ts",
+    oldContents: "const a = 1;\n",
+    newContents: "const a = 2;\n",
+    status: "modified" as const,
+  },
+];
+
+const shareTransport: ShareTransport = {
+  publish: mock(async (session: Thread) => ({
+    line: `ssh p_${session.id}@cueloop.dev`,
+    copied: true,
+  })),
+  pull: mock(async () => planSession()),
+  push: mock(async () => {}),
+  watch: () => () => {},
+  parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  collaboratorAnnotations: (session) => session.annotations.filter((entry) => entry.author),
+  mergeFromShare,
+};
+
+function planSession(id = "ses_plan", repoRoot = "/repo"): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    workspace: { repoRoot, branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n", meta: {} },
+    revisions: [{ revision: 1, content: "# Plan\n", submittedAt: AT }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: AT,
+  };
+}
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
+function fakeClient(session: Thread): SessionClient {
+  return {
+    onEvent: () => () => {},
+    subscribe: async () => {},
+    sessionGet: async () => session,
+    sessionList: async () => [session],
+    sessionComment: unimplemented("sessionComment"),
+    sessionAnnotate: unimplemented("sessionAnnotate"),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
+    sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
+    sessionCutBlock: unimplemented("sessionCutBlock"),
+    sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
+    sessionCurate: unimplemented("sessionCurate"),
+    sessionNavigate: unimplemented("sessionNavigate"),
+    sessionBranch: unimplemented("sessionBranch"),
+    sessionSwitch: unimplemented("sessionSwitch"),
+    sessionLabel: unimplemented("sessionLabel"),
+    sessionFork: unimplemented("sessionFork"),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
+    sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionResolve: unimplemented("sessionResolve"),
+    repoDiff: async () => ({ patch: PATCH, files: FILES }),
+    close: () => {},
+  } satisfies SessionClient;
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+describe("live working-tree diff for a non-diff thread", () => {
+  test("repoChanges carries file contents and rows derive from the patch", async () => {
+    const session = planSession();
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => fakeClient(session),
+      shareTransport,
+    });
+    controller.connect();
+    await tick();
+
+    // Act - the Changes navigator loads
+    const changes = await controller.repoChanges();
+
+    // Assert - real per-file contents, not empty stubs
+    expect(changes.map((file) => file.path)).toEqual(["src/x.ts"]);
+    expect(changes[0]!.newContents).toBe("const a = 2;\n");
+
+    // and the diff rows derive from the live patch, so an opened file tab shows a diff
+    expect(controller.rows().some((row) => row.file === "src/x.ts")).toBe(true);
+
+    // the live per-file contents let a non-diff thread expand a folded file too
+    expect(controller.canExpandFile("src/x.ts")).toBe(true);
+
+    controller.close();
+  });
+
+  test("annotating the Changes diff stamps a file target anchored to the diff rows", async () => {
+    const session = planSession();
+    let sent: Annotation | undefined;
+    const client = {
+      ...fakeClient(session),
+      sessionComment: async (_id: string, annotation: Annotation) => {
+        sent = annotation;
+
+        return { ...session, annotations: [{ ...annotation, createdAt: AT }] };
+      },
+    } satisfies SessionClient;
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => client,
+      shareTransport,
+    });
+    controller.connect();
+    await tick();
+    await controller.repoChanges();
+
+    // Act - comment the added line of the working-tree diff, as the Changes surface does
+    const rows = controller.rows();
+    const addIndex = rows.findIndex((row) => row.kind === "add");
+    const addText = rows[addIndex]!.text.replace(/\n$/, "");
+
+    controller.annotate("comment", addIndex, 0, addText.length, "eviction?", addIndex, {
+      kind: "file",
+      path: "",
+      rev: "worktree",
+    });
+
+    // Assert - the note carries the file target (path and rev filled from the row) and quotes the diff
+    expect(sent?.target).toEqual({ kind: "file", path: "src/x.ts", rev: "worktree" });
+    expect(sent?.anchor.quote).toContain("const a = 2");
+
+    controller.close();
+  });
+
+  test("a late diff response from a previous thread never overwrites the active one", async () => {
+    const sessionA = planSession("ses_A", "/repoA");
+    const sessionB = planSession("ses_B", "/repoB");
+    let resolveA: (diff: { patch: string; files: typeof FILES }) => void = () => {};
+    const pendingA = new Promise<{ patch: string; files: typeof FILES }>((resolve) => {
+      resolveA = resolve;
+    });
+    const diffB = {
+      patch: PATCH.replace(/x\.ts/g, "y.ts"),
+      files: [{ ...FILES[0]!, path: "src/y.ts" }],
+    };
+    const client = {
+      ...fakeClient(sessionA),
+      sessionList: async () => [sessionA, sessionB],
+      repoDiff: async (cwd: string) => (cwd === "/repoA" ? pendingA : diffB),
+    } satisfies SessionClient;
+
+    const controller = createReviewController({
+      sessionId: sessionA.id,
+      openClient: async () => client,
+      shareTransport,
+    });
+    controller.connect();
+    await tick();
+
+    // thread A's diff is still in flight when the user switches to thread B
+    const inFlightA = controller.repoChanges();
+    controller.open("ses_B");
+    await controller.repoChanges();
+    // B's diff is showing; now A's stale response lands
+    resolveA({ patch: PATCH, files: FILES });
+    await inFlightA;
+
+    // the active thread keeps B's changes; A's late response is dropped
+    expect(controller.rows().some((row) => row.file === "src/y.ts")).toBe(true);
+    expect(controller.rows().some((row) => row.file === "src/x.ts")).toBe(false);
+
+    controller.close();
+  });
+});