@cueloop/client 0.1.0-alpha.64 → 0.1.0-alpha.66

package/src/App.test.tsx

@@ -10,8 +10,12 @@ import { DaemonServer } from "@cueloop/daemon";
 import type { ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
 import {
+  clickText,
+  dragText,
+  frameRow,
   isolateUserConfig,
   press,
+  pressKey,
   typeText as type,
   waitForState,
   waitForText,
@@ -67,7 +71,7 @@ async function renderApp(sessionId?: string) {
 }
 
 describe("plan rendering", () => {
-  test("renders the plan with headings, list markers, and the rail", async () => {
+  test("renders the plan with headings, list markers, and the footer", async () => {
     // Arrange
     const setup = await renderApp();
 
@@ -77,96 +81,97 @@ describe("plan rendering", () => {
     expect(frame).toContain("Migration Plan");
     expect(frame).toContain("Context");
     expect(frame).toContain("persists sessions to disk atomically");
-    expect(frame).toContain("- move the store");
-    expect(frame).toContain("Review");
-    expect(frame).toContain("Submit review");
+    expect(frame).toContain("· move the store");
+    expect(frame).toContain("send message");
   });
-});
 
-describe("keyboard grammar", () => {
-  test("j/k moves the cursor glyph between blocks", async () => {
-    // Arrange
+  test("a direct open still populates the Threads sidebar with other pending reviews", async () => {
+    // Arrange - a second pending review exists alongside the one opened directly
+    server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "main" },
+      artifact: { type: "plan", content: "# Other Plan\n", meta: { title: "Other Plan" } },
+    });
     const setup = await renderApp();
 
-    // Act
-    await press(setup, "j");
-    await press(setup, "j");
-    await setup.renderOnce();
-
-    // Assert
-    const lines = setup.captureCharFrame().split("\n");
-    const cursorLine = lines.find((line) => line.includes("▎"))!;
+    // Act - open the collapsed Threads sidebar (the mirrored panel toggle by the gear)
+    await setup.mockMouse.click(3, 1);
 
-    expect(cursorLine).toContain("persists sessions");
+    // Assert - the sidebar lists the other pending review, so you can jump to it
+    await waitForText(setup, "Other Plan");
   });
+});
 
-  test("comment flow: c types a body, ⏎ saves to the daemon", async () => {
+describe("thread view grammar", () => {
+  test("↓ moves the caret between blocks and typing anchors to the block under it", async () => {
     // Arrange
     const setup = await renderApp();
 
-    // Act
-    await press(setup, "j");
-    await press(setup, "j");
-    await press(setup, "c");
-    await setup.renderOnce();
+    // Act: two blocks down lands on the paragraph; a printable opens a draft there
+    await pressKey(setup, "ARROW_DOWN");
+    await pressKey(setup, "ARROW_DOWN");
+    await type(setup, "x");
 
-    // Assert
-    await waitForText(setup, 'comment on "The daemon');
+    // Assert: the draft card sits right under the paragraph's row
+    await waitForText(setup, "● x");
+    expect(frameRow(setup, "● x")).toBeGreaterThan(frameRow(setup, "persists sessions"));
+    expect(frameRow(setup, "● x")).toBeLessThan(frameRow(setup, "Steps"));
+  });
+
+  test("comment flow: click a word, type a body, cmd+⏎ saves to the daemon", async () => {
+    // Arrange
+    const setup = await renderApp();
 
     // Act
+    await clickText(setup, "daemon");
     await type(setup, "Define atomically.");
-    await press(setup, "enter");
+    await pressKey(setup, "RETURN", { meta: true });
 
     // Assert
-    await waitForText(setup, "COMMENT");
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
     const stored = server.core.sessionGet(session.id);
 
     expect(stored.annotations.length).toBe(1);
     expect(stored.annotations[0]!.body).toBe("Define atomically.");
+    expect(stored.annotations[0]!.anchor.quote).toBe("daemon");
   });
 
-  test("span mode: v + l selects words, c anchors the exact span", async () => {
+  test("a drag marks the exact span the comment anchors to", async () => {
     // Arrange
     const setup = await renderApp();
 
-    // Act
-    await press(setup, "j");
-    await press(setup, "j");
-    await press(setup, "v");
-    await press(setup, "l"); // "The daemon"
-    await press(setup, "c");
+    // Act: from the start of "The" to the end of "daemon"
+    await dragText(setup, "The daemon", "daemon persists", "daemon".length);
     await type(setup, "Which daemon?");
-    await press(setup, "enter");
+    await pressKey(setup, "RETURN", { meta: true });
 
     // Assert
     await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
-    const stored = server.core.sessionGet(session.id);
-
-    expect(stored.annotations[0]!.anchor.quote).toBe("The daemon");
+    expect(server.core.sessionGet(session.id).annotations[0]!.anchor.quote).toBe("The daemon");
   });
 
-  test("x cuts a block into the working copy; x restores it", async () => {
+  test("option+x cuts the caret's block into the working copy; option+x restores it", async () => {
     // Arrange
     const setup = await renderApp();
 
-    // move to "- move the store" (h1, h2, p, h2 = 4 steps in)
-    for (let i = 0; i < 4; i++) await press(setup, "j");
+    await clickText(setup, "move the store");
 
     // Act
-    await press(setup, "x");
+    await pressKey(setup, "x", { meta: true });
 
-    // Assert - the rail shows the cut as a removal card titled CUT · me
-    await waitForText(setup, "CUT · me");
-    expect(server.core.sessionGet(session.id).workingCopy).not.toContain("move the store");
+    // Assert - the cut lands in the working copy
+    await waitForState(
+      setup,
+      () => !(server.core.sessionGet(session.id).workingCopy ?? "").includes("move the store"),
+    );
 
     // Act
-    await press(setup, "x");
+    await pressKey(setup, "x", { meta: true });
 
     // Assert
     await waitForState(setup, () => server.core.sessionGet(session.id).workingCopy === undefined);
   });
 
-  test("e runs $EDITOR on the working copy and tracks the diff", async () => {
+  test("ctrl+e runs $EDITOR on the working copy and tracks the diff", async () => {
     const script = join(home, "fake-editor.sh");
 
     await Bun.write(script, `#!/bin/sh\nsed -i '' 's/atomically/very atomically/' "$1"\n`);
@@ -177,7 +182,7 @@ describe("keyboard grammar", () => {
       const setup = await renderApp();
 
       // Act
-      await press(setup, "e");
+      await pressKey(setup, "e", { ctrl: true });
 
       // Assert
       await waitForText(setup, "[edited]");
@@ -189,19 +194,17 @@ describe("keyboard grammar", () => {
 });
 
 describe("submit", () => {
-  test("⏎ opens the rail confirm card; verdict + summary resolve the session", async () => {
+  test("cmd+⏎ opens the rail confirm card; verdict + summary resolve the session", async () => {
     // Arrange
     const setup = await renderApp();
 
-    await press(setup, "j");
-    await press(setup, "j");
-    await press(setup, "c");
+    await clickText(setup, "daemon");
     await type(setup, "Needs a phase list.");
-    await press(setup, "enter");
+    await pressKey(setup, "RETURN", { meta: true });
     await waitForText(setup, "Needs a phase list");
 
-    // Act
-    await press(setup, "enter"); // open submit
+    // Act: with no composer open the same chord opens submit
+    await pressKey(setup, "RETURN", { meta: true });
 
     // Assert
     await waitForText(setup, "[Changes]");
@@ -226,7 +229,7 @@ describe("submit", () => {
     const setup = await renderApp();
 
     // Act
-    await press(setup, "enter");
+    await pressKey(setup, "RETURN", { meta: true });
 
     // Assert
     await waitForText(setup, "[Approve]"); // no pending items → approve default
@@ -241,25 +244,24 @@ describe("submit", () => {
 });
 
 describe("inbox", () => {
-  test("inbox mode wears the review chrome (header + menu bar) and opens a session", async () => {
+  test("inbox mode wears the review header and opens a session", async () => {
     // Arrange
     const setup = await testRender(<App home={home} />, { width: 120, height: 32 });
 
     await waitForText(setup, "cueloop");
 
-    // Assert - the same header/menu chrome as review, plus the session row
+    // Assert - the same header as review, plus the session row
     const frame = setup.captureCharFrame();
 
     expect(frame).toContain("cueloop · resume");
     expect(frame).toContain("Migration Plan");
-    expect(frame).toContain("menu"); // the shared MenuBar sits at the bottom
     expect(frame).not.toContain("inbox ("); // the old inline header is gone
 
     // Act
     await press(setup, "enter");
 
     // Assert
-    await waitForText(setup, "Submit review");
+    await waitForText(setup, "send message");
   });
 
   test("the menu opens from the inbox and escape is not a trap", async () => {
@@ -267,12 +269,9 @@ describe("inbox", () => {
     const setup = await testRender(<App home={home} />, { width: 120, height: 32 });
 
     await waitForText(setup, "cueloop · resume");
-    const lines = setup.captureCharFrame().split("\n");
-    const menuRow = lines.findIndex((line) => line.includes("menu"));
-    const menuColumn = lines[menuRow]!.indexOf("menu");
 
-    // Act - open the drop-up from the shared menu bar
-    await setup.mockMouse.click(menuColumn + 1, menuRow);
+    // Act - open the drop-down from the top-left settings gear (header content row)
+    await setup.mockMouse.click(1, 1);
 
     // Assert - the drop-up options appear
     await waitForText(setup, "Keybinds");
@@ -284,6 +283,77 @@ describe("inbox", () => {
     await press(setup, "enter");
 
     // Assert
-    await waitForText(setup, "Submit review");
+    await waitForText(setup, "send message");
+  });
+});
+
+describe("the thread view and the menu", () => {
+  test("the keybinds dialog lists the thread view grammar, keeps keys away from the text, and closes on escape", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    await waitForText(setup, "The daemon persists");
+
+    // Act - open the menu from the top-left settings gear, then the keybinds dialog
+    await setup.mockMouse.click(1, 1);
+    await waitForText(setup, "Keybinds");
+    const dropUp = setup.captureCharFrame().split("\n");
+    const keybindsRow = dropUp.findIndex((line) => line.includes("Keybinds"));
+
+    await setup.mockMouse.click(dropUp[keybindsRow]!.indexOf("Keybinds") + 1, keybindsRow);
+    await waitForText(setup, "mark text, across blocks");
+
+    // Assert - the thread grammar, not the plan sheet's
+    const dialog = setup.captureCharFrame();
+
+    expect(dialog).toContain("⌘⌥m");
+    expect(dialog).toContain("place the caret");
+    expect(dialog).not.toContain("grow/shrink");
+
+    // Act - a printable behind the dialog must not open a comment; escape closes it
+    await press(setup, "x");
+    expect(setup.captureCharFrame()).not.toContain("● x");
+    await press(setup, "escape");
+
+    // Assert
+    await waitForState(setup, () => !setup.captureCharFrame().includes("mark text, across blocks"));
+    expect(setup.captureCharFrame()).not.toContain("● x");
+  });
+
+  test("clicking the Settings nav group is inert and never corrupts the active category", async () => {
+    // Arrange - open the settings dialog from the gear
+    const setup = await renderApp();
+
+    await setup.mockMouse.click(1, 1);
+    await waitForText(setup, "Keybinds");
+
+    // the nav folder is the last "Settings" on screen (the first is the dialog title)
+    const lines = setup.captureCharFrame().split("\n");
+    let folderRow = -1;
+    let folderColumn = -1;
+
+    lines.forEach((line, row) => {
+      const column = line.indexOf("Settings");
+
+      if (column !== -1) {
+        folderColumn = column;
+        folderRow = row;
+      }
+    });
+
+    // Act - click the synthetic Settings group folder, then press a nav key. The
+    // key handler dereferences the active category, so a corrupt id would throw
+    // (the global key handler swallows the throw into console.error).
+    const keyHandlerErrors: string[] = [];
+    const originalConsoleError = console.error;
+
+    console.error = (...args: unknown[]) => keyHandlerErrors.push(args.map(String).join(" "));
+    await setup.mockMouse.click(folderColumn + 1, folderRow);
+    await pressKey(setup, "ARROW_DOWN");
+    console.error = originalConsoleError;
+
+    // Assert - no key-handler crash, and the dialog is still up
+    expect(keyHandlerErrors.filter((line) => line.includes("keypress handler"))).toEqual([]);
+    expect(setup.captureCharFrame()).toContain("Keybinds");
   });
 });

package/src/App.toast.test.tsx

@@ -10,7 +10,15 @@ import { DaemonServer } from "@cueloop/daemon";
 import type { ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
 import type { ShareTransport } from "./session-controller";
-import { isolateUserConfig, press, waitForText, waitForTextGone } from "./test-support";
+import {
+  clickText,
+  isolateUserConfig,
+  press,
+  pressKey,
+  typeText,
+  waitForText,
+  waitForTextGone,
+} from "./test-support";
 
 const publishShare = mock(async () => ({ line: "ssh p_share01@cueloop.dev", copied: true }));
 const shareTransport: ShareTransport = {
@@ -19,8 +27,10 @@ const shareTransport: ShareTransport = {
     throw new Error("Unexpected share pull");
   }),
   push: mock(async () => {}),
+  watch: () => () => {},
   parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
   collaboratorAnnotations: () => [],
+  mergeFromShare: () => ({ annotations: [] }),
 };
 
 const PLAN = `# Migration Plan\n\n## Context\n\nThe daemon persists sessions to disk atomically.\n`;
@@ -63,18 +73,17 @@ describe("share toast", () => {
 
     await waitForText(setup, "cueloop");
 
-    // Act: share raises the toast, then open a composer under it
-    await press(setup, "S");
+    // Act: share raises the toast, then open a composer under it by typing
+    await pressKey(setup, "s", { ctrl: true });
     await waitForText(setup, "share link copied");
-    await press(setup, "j");
-    await press(setup, "j");
-    await press(setup, "c");
-    await waitForText(setup, 'comment on "');
+    await clickText(setup, "daemon");
+    await typeText(setup, "x");
+    await waitForText(setup, "● x");
 
     // Act: escape must reach the composer, not get eaten by the toast
     await press(setup, "escape");
 
     // Assert: the composer closed on the first escape
-    await waitForTextGone(setup, 'comment on "');
+    await waitForTextGone(setup, "● x");
   });
 });