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

package/src/thread/thread-controller.switch-cache.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, mock, test } from "bun:test";
+import {
+  SCHEMA_VERSION,
+  type DiffFileContents,
+  type HunkRejection,
+  type Thread,
+} from "@cueloop/schema";
+import { curateDiff } from "@cueloop/daemon/curate";
+import type { ThreadClient } from "@cueloop/daemon/client";
+import { createReviewController } from "./thread-controller";
+
+const PATCH_A = `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,3 @@
+ export class A {
+-  value = 1;
++  value = 2;
+ }
+`;
+
+const PATCH_B = `diff --git a/src/b.ts b/src/b.ts
+index 333..444 100644
+--- a/src/b.ts
++++ b/src/b.ts
+@@ -1,3 +1,3 @@
+ export class B {
+-  flag = false;
++  flag = true;
+ }
+`;
+
+function diffSession(id: string, patch: string, files: DiffFileContents[]): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "diff", content: patch, meta: { title: id }, 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",
+  };
+}
+
+const FILES_A: DiffFileContents[] = [
+  {
+    path: "src/a.ts",
+    oldContents: "export class A {\n  value = 1;\n}\n",
+    newContents: "export class A {\n  value = 2;\n}\n",
+    status: "modified",
+  },
+];
+const FILES_B: DiffFileContents[] = [
+  {
+    path: "src/b.ts",
+    oldContents: "export class B {\n  flag = false;\n}\n",
+    newContents: "export class B {\n  flag = true;\n}\n",
+    status: "modified",
+  },
+];
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
+/** A fake client over a fixed set of sessions, so open(id) can switch between them from the inbox. */
+function fakeClient(sessions: Thread[]): ThreadClient {
+  const byId = new Map(sessions.map((session) => [session.id, session]));
+
+  return {
+    onEvent: () => () => {},
+    subscribe: async () => {},
+    sessionGet: async (id: string) => byId.get(id)!,
+    sessionList: async () => [...byId.values()],
+    sessionCurate: mock(async (id: string, rejections: HunkRejection[]) => {
+      const session = byId.get(id)!;
+      const content = rejections.length
+        ? curateDiff(session.artifact.files!, rejections)
+        : undefined;
+      const next = {
+        ...session,
+        workingCopy: content,
+        curation: rejections.length ? rejections : undefined,
+      };
+
+      byId.set(id, next);
+
+      return next;
+    }),
+    sessionComment: unimplemented("sessionComment"),
+    sessionAnnotate: unimplemented("sessionAnnotate"),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
+    sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
+    sessionCutBlock: unimplemented("sessionCutBlock"),
+    sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
+    sessionNavigate: unimplemented("sessionNavigate"),
+    sessionBranch: unimplemented("sessionBranch"),
+    sessionSwitch: unimplemented("sessionSwitch"),
+    sessionLabel: unimplemented("sessionLabel"),
+    sessionFork: unimplemented("sessionFork"),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
+    sessionSetShares: unimplemented("sessionSetShares"),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionSendMessage: unimplemented("sessionSendMessage"),
+    close: () => {},
+  };
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+// rows for each single-change patch: file(0), hunk(1), ctx(2), del(3), add(4), ctx(5)
+describe("switching threads keeps the cached projection curatable", () => {
+  test("curation still works after switching away and back to a diff thread", async () => {
+    // Arrange - two diff threads in one inbox
+    const controller = createReviewController({
+      sessionId: "ses_a",
+      openClient: async () =>
+        fakeClient([
+          diffSession("ses_a", PATCH_A, FILES_A),
+          diffSession("ses_b", PATCH_B, FILES_B),
+        ]),
+    });
+
+    controller.connect();
+    await tick();
+
+    // Act - visit B, then return to A (A's projection now comes from the per-thread cache)
+    controller.open("ses_b");
+    await tick();
+    controller.open("ses_a");
+    await tick();
+
+    // Assert - the returned thread's file model parses lazily and curation lands
+    controller.toggleRejectChange(4);
+    await tick();
+
+    expect(controller.getSnapshot().toast).toBeNull();
+    expect(controller.getSnapshot().session?.workingCopy).toBe("");
+  });
+
+  test("returning to a diff thread shows the daemon's latest, not the stale sidebar copy", async () => {
+    // The sidebar list trails the daemon for a hot-reloading diff (its session.updated
+    // refreshes the open thread, not the list). Returning to it must revalidate.
+    const staleA = diffSession("ses_a", PATCH_A, FILES_A);
+    const freshA = diffSession("ses_a", PATCH_B, FILES_B);
+    const other = diffSession("ses_b", PATCH_B, FILES_B);
+    const base = fakeClient([staleA, other]);
+    const controller = createReviewController({
+      sessionId: "ses_a",
+      openClient: async () => ({
+        ...base,
+        // the sidebar keeps the stale copy; the daemon serves the fresh one
+        sessionList: async () => [staleA, other],
+        sessionGet: async (id: string) => (id === "ses_a" ? freshA : other),
+      }),
+    });
+
+    controller.connect();
+    await tick();
+
+    // Visit B, then return to A - open() paints the stale sidebar copy, then revalidates
+    controller.open("ses_b");
+    await tick();
+    controller.open("ses_a");
+    await tick();
+
+    expect(controller.getSnapshot().session?.artifact.content).toBe(PATCH_B);
+  });
+});

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

@@ -0,0 +1,263 @@
+/**
+ * The controller's tree primitives over a fake client: a move shows its path
+ * before the daemon answers, refusals surface as status, a fork opens the fork,
+ * and fork-and-share shares the fork while the current session stays put.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import {
+  appendEntry,
+  createBranch,
+  historyFromLinear,
+  SCHEMA_VERSION,
+  switchBranch,
+  type Annotation,
+  type Thread,
+} from "@cueloop/schema";
+import type { ThreadClient } from "@cueloop/daemon/client";
+import { createReviewController, type ShareTransport } from "./thread-controller";
+import { mergeFromShare } from "../integrations/share";
+
+const AT = "2026-01-01T00:00:00.000Z";
+
+function annotation(id: string, body: string): Annotation {
+  return {
+    id,
+    kind: "comment",
+    anchor: { quote: "Plan", prefix: "", suffix: "" },
+    body,
+    createdAt: AT,
+  };
+}
+
+/** A plan with one comment on main and its history. */
+function sessionFixture(): Thread {
+  const session: Thread = {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n", meta: {} },
+    revisions: [{ revision: 1, content: "# Plan\n", submittedAt: AT }],
+    annotations: [annotation("a1", "first")],
+    message: null,
+    status: "pending",
+    createdAt: AT,
+  };
+
+  session.history = historyFromLinear(session);
+
+  return session;
+}
+
+const publish = mock(async (session: Thread) => ({
+  line: `ssh p_${session.id}@cueloop.dev`,
+  copied: true,
+}));
+const shareTransport: ShareTransport = {
+  publish,
+  pull: mock(async () => sessionFixture()),
+  push: mock(async () => {}),
+  watch: () => () => {},
+  revoke: async () => {},
+  parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  formatShareLine: (id: string) => "ssh " + id + "@cueloop.dev",
+  collaboratorAnnotations: (session) => session.annotations.filter((entry) => entry.author),
+  mergeFromShare,
+};
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
+/** Tree requests never resolve here: what the controller shows is its own guess. */
+const pending = () => new Promise<Thread>(() => {});
+
+function fakeClient(session: Thread) {
+  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: mock(pending),
+    sessionBranch: mock(pending),
+    sessionSwitch: mock(pending),
+    sessionLabel: mock(pending),
+    sessionFork: mock(async (id: string) => ({
+      ...sessionFixture(),
+      id: `${id}_fork`,
+      parentSessionId: id,
+    })),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
+    sessionSetShares: mock(async () => session),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionSendMessage: unimplemented("sessionSendMessage"),
+    close: () => {},
+  } satisfies ThreadClient;
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+async function connected(session = sessionFixture()) {
+  const client = fakeClient(session);
+  const controller = createReviewController({
+    sessionId: session.id,
+    openClient: async () => client,
+    shareTransport,
+  });
+
+  controller.connect();
+  await tick();
+
+  return { controller, client, session };
+}
+
+describe("read-only guards", () => {
+  test("an observer's rename and delete never reach the daemon", async () => {
+    // Arrange - a read-only controller over a client whose mutations would throw
+    const session = sessionFixture();
+    const client = fakeClient(session);
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => client,
+      readOnly: true,
+      shareTransport,
+    });
+
+    controller.connect();
+    await tick();
+
+    // Act - the sidebar's rename and delete, invoked directly
+    controller.renameSession(session.id, "hijacked");
+    controller.deleteSession(session.id);
+    await tick();
+
+    // Assert - both answer read-only and the throwing client stubs were never called
+    expect(controller.getSnapshot().status).toBe("observer - read-only");
+  });
+});
+
+describe("tree primitives", () => {
+  test("a move back shows the earlier path at once and asks the daemon for the same move", async () => {
+    // Arrange
+    const { controller, client, session } = await connected();
+    const revision = session.history!.entries[0]!.id;
+
+    // Act
+    controller.goToEntry(revision, "too soon");
+
+    // Assert: the comment is off the shown path before any answer; the summary travels
+    expect(controller.getSnapshot().session!.annotations).toEqual([]);
+    expect(controller.getSnapshot().session!.shelvedAnnotations?.map((entry) => entry.id)).toEqual([
+      "a1",
+    ]);
+    expect(controller.treeRows().find((row) => row.glyph === "↩")?.isCurrentTip).toBe(true);
+    expect(client.sessionNavigate).toHaveBeenCalledWith("ses_1", revision, "too soon", undefined);
+  });
+
+  test("a move on another branch is one request that names the branch", async () => {
+    // Arrange: alt with its own comment entry; the owner stands on main
+    const session = sessionFixture();
+    let history = createBranch(session.history!, "alt");
+
+    history = appendEntry(history, { type: "comment", annotationId: "b1", createdAt: AT }).history;
+    history = appendEntry(history, { type: "comment", annotationId: "b2", createdAt: AT }).history;
+    session.history = switchBranch(history, "main");
+    session.shelvedAnnotations = [annotation("b1", "alt one"), annotation("b2", "alt two")];
+    const { controller, client } = await connected(session);
+    const altFirst = history.entries.find(
+      (entry) => entry.type === "comment" && entry.annotationId === "b1",
+    )!;
+
+    // Act
+    controller.goToEntry(altFirst.id);
+
+    // Assert
+    expect(client.sessionSwitch).not.toHaveBeenCalled();
+    expect(client.sessionNavigate).toHaveBeenCalledWith("ses_1", altFirst.id, undefined, "alt");
+    expect(controller.getSnapshot().session!.annotations.map((entry) => entry.id)).toEqual([
+      "a1",
+      "b1",
+    ]);
+  });
+
+  test("a refused move gives way to the daemon's record", async () => {
+    // Arrange: the daemon refuses; a re-read hands back the untouched record
+    const session = sessionFixture();
+    const { controller, client } = await connected(session);
+
+    client.sessionNavigate.mockImplementationOnce(() => Promise.reject(new Error("resolved")));
+
+    // Act
+    controller.goToEntry(session.history!.entries[0]!.id);
+    const guessed = controller.getSnapshot().session!.annotations.length;
+
+    await tick();
+
+    // Assert: the guess showed, then the record came back
+    expect(guessed).toBe(0);
+    expect(controller.getSnapshot().session!.annotations.map((entry) => entry.id)).toEqual(["a1"]);
+    expect(controller.getSnapshot().status).toBe("resolved");
+  });
+
+  test("branch and label refuse an empty name and a taken branch name", async () => {
+    // Arrange
+    const { controller, client } = await connected();
+
+    // Act
+    controller.branch("  ");
+    controller.branch("main");
+    controller.labelTip("");
+
+    // Assert
+    expect(client.sessionBranch).not.toHaveBeenCalled();
+    expect(client.sessionLabel).not.toHaveBeenCalled();
+    expect(controller.getSnapshot().status).toBe("a checkpoint needs a name");
+  });
+
+  test("a branch shows up on the tip and becomes the current branch", async () => {
+    // Arrange
+    const { controller, client } = await connected();
+
+    // Act
+    controller.branch("alt");
+
+    // Assert
+    expect(controller.getSnapshot().session!.history!.branch).toBe("alt");
+    expect(controller.treeRows().find((row) => row.isCurrentTip)?.tips).toEqual(["main", "alt"]);
+    expect(client.sessionBranch).toHaveBeenCalledWith("ses_1", "alt");
+  });
+
+  test("fork opens the fork; fork-and-share shares the fork and stays on the original", async () => {
+    // Arrange
+    const forked = await connected();
+    const shared = await connected();
+
+    // Act
+    forked.controller.fork();
+    shared.controller.forkAndShare();
+    await tick();
+    await tick();
+
+    // Assert
+    expect(forked.controller.getSnapshot().session!.id).toBe("ses_1_fork");
+    expect(shared.controller.getSnapshot().session!.id).toBe("ses_1");
+    expect(publish).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "ses_1_fork" }),
+      {},
+      { requireAuth: false, allowlist: [], shareBranch: "main" },
+    );
+    expect(shared.client.sessionSetShares).toHaveBeenCalledWith("ses_1_fork", [
+      { id: "p_ses_1_fork", requireAuth: false, allowlist: [], shareBranch: "main" },
+    ]);
+    expect(shared.controller.getSnapshot().toast?.title).toBe("fork shared - link copied");
+  });
+});