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

package/src/intent-dispatch.test.ts

@@ -0,0 +1,698 @@
+/**
+ * The intent reducer in isolation: with the App component's dependencies
+ * mocked, each Intent maps to exactly the controller call or state update it
+ * should - the navigation clamps, the annotation wrap-around, the verdict
+ * cycle, and the submit-reveal fix, none of which needed a rendered TUI.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import type { SetStateAction } from "react";
+import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
+import { createIntentDispatch, type IntentDispatchDeps } from "./intent-dispatch";
+import type { ControllerSnapshot, CurationItem, ReviewController } from "./thread-controller";
+import type { DisplayBlock } from "./view-plan";
+import type { TreeRow } from "./tree-view";
+
+function block(text: string): DisplayBlock {
+  return { type: "same", kind: "p", work: { kind: "p", text, lineStart: 0, lineEnd: 0 } };
+}
+
+function annotation(id: string, overrides: Partial<Annotation> = {}): Annotation {
+  return {
+    id,
+    kind: "comment",
+    anchor: { quote: "", prefix: "", suffix: "" },
+    body: "",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+function sessionWith(annotations: Annotation[], overrides: Partial<Thread> = {}): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n", meta: {} },
+    revisions: [],
+    annotations,
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+const EMPTY_SNAPSHOT: ControllerSnapshot = {
+  session: null,
+  inbox: null,
+  status: "",
+  toast: null,
+  error: null,
+  completion: { phase: "idle" },
+  editOrphanCount: 0,
+  walk: null,
+};
+
+/** A controller where every primitive is a mock; annotate returns undefined by default. */
+function baseController(): ReviewController {
+  return {
+    readOnly: false,
+    subscribe: mock(() => () => {}),
+    getSnapshot: mock(() => EMPTY_SNAPSHOT),
+    connect: mock(),
+    close: mock(),
+    applyConfig: mock(),
+    setStatus: mock(),
+    showToast: mock(),
+    dismissToast: mock(),
+    display: mock(() => []),
+    rows: mock(() => []),
+    setFileCollapsed: mock(),
+    isFileCollapsed: mock(() => false),
+    setFileExpanded: mock(),
+    isFileExpanded: mock(() => false),
+    canExpandFile: mock(() => false),
+    copyFilePath: mock(),
+    fileStats: mock(() => new Map()),
+    files: mock(() => []),
+    working: mock(() => ""),
+    projectFiles: mock(() => Promise.resolve<string[]>([])),
+    readFile: mock(() => Promise.resolve<string | null>(null)),
+    repoFiles: mock(() => Promise.resolve<string[]>([])),
+    repoReadFile: mock(() => Promise.resolve<string | null>(null)),
+    repoChanges: mock(() => Promise.resolve([])),
+    open: mock(),
+    deleteSession: mock(),
+    renameSession: mock(),
+    setSelfName: mock(),
+    cut: mock(),
+    toggleRejectHunk: mock(),
+    toggleRejectChange: mock(),
+    rejectedRows: mock(() => new Set<number>()),
+    curationItems: mock(() => []),
+    restoreCuration: mock(),
+    edit: mock(),
+    annotate: mock(() => undefined),
+    addComment: mock(() => undefined),
+    commentOnWorkbench: mock(() => Promise.resolve()),
+    reply: mock(() => undefined),
+    annotatePrototype: mock(() => undefined),
+    updateAnnotation: mock(),
+    removeAnnotation: mock(),
+    setWorkingCopy: mock(),
+    walkStart: mock(),
+    walkForward: mock(),
+    walkBack: mock(),
+    walkLeave: mock(),
+    submit: mock(),
+    share: mock(),
+    treeRows: mock(() => []),
+    goToEntry: mock(),
+    branch: mock(),
+    labelTip: mock(),
+    fork: mock(),
+    forkAndShare: mock(),
+    pullShared: mock(() => Promise.resolve()),
+    startShareSync: mock(() => () => {}),
+    finishReview: mock(),
+    dismissCompletion: mock(),
+    optInAutoClose: mock(),
+  };
+}
+
+/** A deps bag where every effect is a mock and every read has a plain default. */
+function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDeps {
+  return {
+    controller: baseController(),
+    onExit: mock(),
+    isDiff: false,
+    display: [],
+    rows: [],
+    cursor: 0,
+    inbox: null,
+    inboxCursor: 0,
+    mode: { type: "normal" },
+    session: null,
+    focusedAnnotationId: undefined,
+    selectedCurationId: undefined,
+    railTab: "review",
+    selectedEntryId: undefined,
+    authorNames: {},
+    quickActions: [],
+    renameAuthor: mock(),
+    renameThread: mock(),
+    liveInput: { current: "" },
+    setCursor: mock(),
+    setInboxCursor: mock(),
+    setMode: mock(),
+    setRailTab: mock(),
+    setSelectedEntryId: mock(),
+    setFocusedAnnotationId: mock(),
+    setSelectedCurationId: mock(),
+    setPulsedAnnotationId: mock(),
+    selectCardFromDocument: mock(),
+    runEditorHandOff: mock(),
+    openCardEdit: mock(),
+    toggleDiffView: mock(),
+    ...overrides,
+  };
+}
+
+function isUpdater(action: SetStateAction<number>): action is (current: number) => number {
+  return typeof action === "function";
+}
+
+describe("move", () => {
+  test("down clamps at the last row and up clamps at the first", () => {
+    // Arrange
+    const setCursor = mock((_action: SetStateAction<number>) => {});
+    const deps = makeDeps({ display: [block("a"), block("b"), block("c")], setCursor });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "move", to: "down" });
+
+    // Assert
+    const advance = setCursor.mock.calls[0]![0];
+
+    if (!isUpdater(advance)) throw new Error("expected setCursor to receive an updater");
+    expect(advance(2)).toBe(2); // already at the end, stays
+    expect(advance(0)).toBe(1);
+  });
+
+  test("bottom jumps to the last navigable row", () => {
+    // Arrange
+    const deps = makeDeps({ display: [block("a"), block("b"), block("c")] });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "move", to: "bottom" });
+
+    // Assert
+    expect(deps.setCursor).toHaveBeenCalledWith(2);
+  });
+});
+
+describe("annotation navigation", () => {
+  test("nextAnnotation wraps from the last annotation back to the first", () => {
+    // Arrange
+    const deps = makeDeps({
+      session: sessionWith([annotation("a1"), annotation("a2"), annotation("a3")]),
+      focusedAnnotationId: "a3",
+    });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "nextAnnotation" });
+
+    // Assert
+    expect(deps.selectCardFromDocument).toHaveBeenCalledWith("a1");
+  });
+
+  test("prevAnnotation wraps from the first annotation to the last", () => {
+    // Arrange
+    const deps = makeDeps({
+      session: sessionWith([annotation("a1"), annotation("a2"), annotation("a3")]),
+      focusedAnnotationId: "a1",
+    });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "prevAnnotation" });
+
+    // Assert
+    expect(deps.selectCardFromDocument).toHaveBeenCalledWith("a3");
+  });
+
+  test("cycling skips annotations a revision already addressed", () => {
+    // Arrange: a2 is addressed, so next from a1 lands on a3
+    const session = sessionWith([
+      annotation("a1"),
+      annotation("a2", { resolution: { revision: 2, source: "agent" } }),
+      annotation("a3"),
+    ]);
+    const deps = makeDeps({ session, focusedAnnotationId: "a1" });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "nextAnnotation" });
+
+    // Assert
+    expect(deps.selectCardFromDocument).toHaveBeenCalledWith("a3");
+  });
+});
+
+describe("cycleVerdict", () => {
+  test("advances through the verdict list in the submit overlay", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "submit", verdict: "approve", summary: "" } });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "cycleVerdict", direction: 1 });
+
+    // Assert
+    expect(deps.setMode).toHaveBeenCalledWith({
+      type: "submit",
+      verdict: "request_changes",
+      summary: "",
+    });
+  });
+});
+
+describe("marker-actions popover", () => {
+  const span = { displayIndex: 3, wordIndex: 0, wordEnd: 0, start: 2, end: 9 };
+
+  test("spanCut cuts the span's block and closes the popover", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "span", span } });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "spanCut" });
+
+    // Assert
+    expect(deps.controller.cut).toHaveBeenCalledWith(3);
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+
+  test("openSpanActions enters the list at index 0", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "span", span } });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "openSpanActions" });
+
+    // Assert
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "spanActions", span, index: 0 });
+  });
+
+  test("moveSpanAction clamps within the actions list", () => {
+    // Arrange
+    const deps = makeDeps({
+      mode: { type: "spanActions", span, index: 1 },
+      quickActions: [{ prompt: "one" }, { prompt: "two" }],
+    });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "moveSpanAction", direction: 1 });
+
+    // Assert - already at the last row, so the index holds
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "spanActions", span, index: 1 });
+  });
+
+  test("pickSpanAction inserts the preset comment and returns to normal", () => {
+    // Arrange
+    const annotate = mock(() => "an_new");
+    const deps = makeDeps({
+      mode: { type: "spanActions", span, index: 1 },
+      session: sessionWith([]),
+      quickActions: [{ prompt: "Needs a test" }, { prompt: "YAGNI", metadata: "cut scope" }],
+      controller: { ...baseController(), annotate },
+    });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "pickSpanAction" });
+
+    // Assert - metadata joins the prompt with a blank line
+    expect(annotate).toHaveBeenCalledWith("comment", 3, 2, 9, "YAGNI\n\ncut scope");
+    expect(deps.setFocusedAnnotationId).toHaveBeenCalledWith("an_new");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+
+  test("pickSpanAction honors an explicit index (mouse click)", () => {
+    // Arrange
+    const annotate = mock(() => "an_new");
+    const deps = makeDeps({
+      mode: { type: "spanActions", span, index: 0 },
+      session: sessionWith([]),
+      quickActions: [{ prompt: "Needs a test" }, { prompt: "Extract the duplication" }],
+      controller: { ...baseController(), annotate },
+    });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "pickSpanAction", index: 1 });
+
+    // Assert
+    expect(annotate).toHaveBeenCalledWith("comment", 3, 2, 9, "Extract the duplication");
+  });
+
+  test("closeSpanActions returns to the span toolbar", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "spanActions", span, index: 2 } });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "closeSpanActions" });
+
+    // Assert
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "span", span });
+  });
+});
+
+describe("openSubmit", () => {
+  test("opens the submit confirm with the default verdict", () => {
+    // Arrange
+    const deps = makeDeps({ session: sessionWith([]) });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "openSubmit" });
+
+    // Assert
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "submit", verdict: "approve", summary: "" });
+  });
+
+  test("does nothing without a session", () => {
+    // Arrange
+    const deps = makeDeps({ session: null });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "openSubmit" });
+
+    // Assert
+    expect(deps.setMode).not.toHaveBeenCalled();
+  });
+});
+
+describe("share", () => {
+  test("dispatches to the controller's share", () => {
+    // Arrange
+    const deps = makeDeps();
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "share" });
+
+    // Assert
+    expect(deps.controller.share).toHaveBeenCalled();
+  });
+});
+
+describe("restoreCuration", () => {
+  const items: CurationItem[] = [
+    { id: "diff:f#0#hunk", source: "diff", preview: [], revealIndex: 1 },
+    { id: "diff:f#1#2", source: "diff", preview: [], revealIndex: 9 },
+  ];
+
+  test("restores the selected item and clears the selection", () => {
+    // Arrange
+    const controller = { ...baseController(), curationItems: mock(() => items) };
+    const deps = makeDeps({ selectedCurationId: "diff:f#1#2", controller });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "restoreCuration" });
+
+    // Assert
+    expect(deps.controller.restoreCuration).toHaveBeenCalledWith("diff:f#1#2");
+    expect(deps.setSelectedCurationId).toHaveBeenCalledWith(undefined);
+  });
+
+  test("with nothing selected, undoes the last removal", () => {
+    // Arrange
+    const controller = { ...baseController(), curationItems: mock(() => items) };
+    const deps = makeDeps({ selectedCurationId: undefined, controller });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "restoreCuration" });
+
+    // Assert
+    expect(deps.controller.restoreCuration).toHaveBeenCalledWith("diff:f#1#2");
+  });
+
+  test("does nothing when there is nothing curated out", () => {
+    // Arrange
+    const deps = makeDeps();
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "restoreCuration" });
+
+    // Assert
+    expect(deps.controller.restoreCuration).not.toHaveBeenCalled();
+  });
+});
+
+describe("toggleDiffView", () => {
+  test("delegates to the App-owned toggle", () => {
+    // Arrange
+    const deps = makeDeps();
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "toggleDiffView" });
+
+    // Assert
+    expect(deps.toggleDiffView).toHaveBeenCalled();
+  });
+});
+
+describe("exit", () => {
+  test("calls the exit hook with 0", () => {
+    // Arrange
+    const deps = makeDeps();
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "exit" });
+
+    // Assert
+    expect(deps.onExit).toHaveBeenCalledWith(0);
+  });
+});
+
+describe("inbox delete", () => {
+  test("requestDeleteSession opens the confirm on the cursor row", () => {
+    // Arrange
+    const inbox = [
+      sessionWith([], { artifact: { type: "plan", content: "", meta: { title: "Plan A" } } }),
+    ];
+    const deps = makeDeps({ inbox, inboxCursor: 0 });
+
+    // Act
+    createIntentDispatch(deps)({ type: "requestDeleteSession" });
+
+    // Assert
+    expect(deps.setMode).toHaveBeenCalledWith({
+      type: "confirmDelete",
+      sessionId: "ses_1",
+      title: "Plan A",
+    });
+  });
+
+  test("confirmDialog deletes the session and closes", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "confirmDelete", sessionId: "ses_1", title: "Plan A" } });
+
+    // Act
+    createIntentDispatch(deps)({ type: "confirmDialog" });
+
+    // Assert
+    expect(deps.controller.deleteSession).toHaveBeenCalledWith("ses_1");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+});
+
+describe("rename author", () => {
+  test("openRename seeds the prompt with the author's current local name", () => {
+    // Arrange
+    const session = sessionWith([annotation("a1", { author: "SHA256:x" })]);
+    const deps = makeDeps({
+      session,
+      focusedAnnotationId: "a1",
+      authorNames: { "SHA256:x": "Alex" },
+    });
+
+    // Act
+    createIntentDispatch(deps)({ type: "openRename" });
+
+    // Assert
+    expect(deps.setMode).toHaveBeenCalledWith({
+      type: "rename",
+      authorId: "SHA256:x",
+      text: "Alex",
+    });
+  });
+
+  test("openRename on your own note does nothing but explain", () => {
+    // Arrange
+    const session = sessionWith([annotation("a1")]);
+    const deps = makeDeps({ session, focusedAnnotationId: "a1" });
+
+    // Act
+    createIntentDispatch(deps)({ type: "openRename" });
+
+    // Assert
+    expect(deps.controller.setStatus).toHaveBeenCalled();
+    expect(deps.setMode).not.toHaveBeenCalled();
+  });
+
+  test("confirmDialog in rename mode persists the trimmed name and closes", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "rename", authorId: "SHA256:x", text: "  Alex  " } });
+
+    // Act
+    createIntentDispatch(deps)({ type: "confirmDialog" });
+
+    // Assert
+    expect(deps.renameAuthor).toHaveBeenCalledWith("SHA256:x", "Alex");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+});
+
+describe("collaborator self-name", () => {
+  test("confirmDialog in nameSelf mode records the trimmed name and closes", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "nameSelf", text: "  Robin  " } });
+
+    // Act
+    createIntentDispatch(deps)({ type: "confirmDialog" });
+
+    // Assert
+    expect(deps.controller.setSelfName).toHaveBeenCalledWith("Robin");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+
+  test("an empty name still closes - the collaborator stays anonymous", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "nameSelf", text: "   " } });
+
+    // Act
+    createIntentDispatch(deps)({ type: "confirmDialog" });
+
+    // Assert
+    expect(deps.controller.setSelfName).toHaveBeenCalledWith("");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+});
+
+describe("tree intents", () => {
+  const rows: TreeRow[] = [
+    {
+      entryId: "e1",
+      depth: 0,
+      glyph: "◉",
+      text: "revision 1",
+      onPath: true,
+      tips: [],
+      isCurrentTip: false,
+    },
+    {
+      entryId: "e2",
+      depth: 0,
+      glyph: "·",
+      text: "comment",
+      onPath: true,
+      tips: ["main"],
+      isCurrentTip: false,
+    },
+    {
+      entryId: "e3",
+      depth: 1,
+      glyph: "·",
+      text: "comment",
+      onPath: false,
+      tips: ["alt"],
+      isCurrentTip: true,
+    },
+  ];
+
+  function treeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDeps {
+    const deps = makeDeps({ railTab: "tree", ...overrides });
+
+    deps.controller.treeRows = mock(() => rows);
+
+    return deps;
+  }
+
+  test("toggleTree shows the Tree tab and hides it again", () => {
+    // Arrange
+    const shown = makeDeps({ railTab: "review" });
+    const hidden = makeDeps({ railTab: "tree" });
+
+    // Act
+    createIntentDispatch(shown)({ type: "toggleTree" });
+    createIntentDispatch(hidden)({ type: "toggleTree" });
+
+    // Assert
+    expect(shown.setRailTab).toHaveBeenCalledWith("tree");
+    expect(hidden.setRailTab).toHaveBeenCalledWith("review");
+  });
+
+  test("treeMove starts from the current tip and stays inside the rows", () => {
+    // Arrange
+    const fromTip = treeDeps();
+    const atTop = treeDeps({ selectedEntryId: "e1" });
+
+    // Act
+    createIntentDispatch(fromTip)({ type: "treeMove", direction: -1 });
+    createIntentDispatch(atTop)({ type: "treeMove", direction: -1 });
+
+    // Assert
+    expect(fromTip.setSelectedEntryId).toHaveBeenCalledWith("e2");
+    expect(atTop.setSelectedEntryId).toHaveBeenCalledWith("e1");
+  });
+
+  test("treeGo: the tip answers, a tip of another branch switches, an inner entry asks for a summary", () => {
+    // Arrange
+    const atTip = treeDeps({ selectedEntryId: "e3" });
+    const toTip = treeDeps({ selectedEntryId: "e2" });
+    const inner = treeDeps({ selectedEntryId: "e1" });
+
+    // Act
+    createIntentDispatch(atTip)({ type: "treeGo" });
+    createIntentDispatch(toTip)({ type: "treeGo" });
+    createIntentDispatch(inner)({ type: "treeGo" });
+
+    // Assert
+    expect(atTip.controller.setStatus).toHaveBeenCalledWith("already at the tip");
+    expect(toTip.controller.goToEntry).toHaveBeenCalledWith("e2");
+    expect(inner.setMode).toHaveBeenCalledWith({
+      type: "treePrompt",
+      ask: "navigate",
+      entryId: "e1",
+      text: "",
+    });
+  });
+
+  test("the prompts confirm into branch, label, and a move back with the typed summary", () => {
+    // Arrange
+    const branch = treeDeps({ mode: { type: "treePrompt", ask: "branch", text: "alt" } });
+    const label = treeDeps({ mode: { type: "treePrompt", ask: "label", text: "start" } });
+    const navigate = treeDeps({
+      mode: { type: "treePrompt", ask: "navigate", entryId: "e1", text: " too early " },
+    });
+
+    // Act
+    createIntentDispatch(branch)({ type: "confirmDialog" });
+    createIntentDispatch(label)({ type: "confirmDialog" });
+    createIntentDispatch(navigate)({ type: "confirmDialog" });
+
+    // Assert
+    expect(branch.controller.branch).toHaveBeenCalledWith("alt");
+    expect(label.controller.labelTip).toHaveBeenCalledWith("start");
+    expect(navigate.controller.goToEntry).toHaveBeenCalledWith("e1", "too early");
+    expect(navigate.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+
+  test("treeFork and treeForkShare reach the controller", () => {
+    // Arrange
+    const deps = treeDeps();
+
+    // Act
+    createIntentDispatch(deps)({ type: "treeFork" });
+    createIntentDispatch(deps)({ type: "treeForkShare" });
+
+    // Assert
+    expect(deps.controller.fork).toHaveBeenCalledTimes(1);
+    expect(deps.controller.forkAndShare).toHaveBeenCalledTimes(1);
+  });
+});