@cueloop/client 0.1.0-alpha.20 → 0.1.0-alpha.22

package/src/App.review-panel.test.tsx

@@ -0,0 +1,120 @@
+/** The review panel end to end: the b key cycles expanded -> compact -> hidden -> expanded on the live App, and the collapse mode persists to the user config so it survives a restart. Rendering details are locked by the ReviewPanel stories; this suite proves the App wiring and the persistence. */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { DaemonServer } from "@cueloop/daemon";
+import type { ReviewSession } from "@cueloop/schema";
+import { App } from "./App";
+import { loadConfig } from "./config";
+import { press, waitForText } from "./test-support";
+
+const PLAN = "# Plan\n\nShip the thing.\n";
+
+let home: string;
+let server: DaemonServer;
+let session: ReviewSession;
+let configPath: string;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-panel-"));
+  configPath = join(home, "config.toml");
+  process.env.CUELOOP_CONFIG = configPath;
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: PLAN, meta: { title: "Plan" } },
+  });
+});
+afterEach(() => {
+  delete process.env.CUELOOP_CONFIG;
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderApp() {
+  const setup = await testRender(<App home={home} sessionId={session.id} />, { width: 120, height: 30 });
+  await waitForText(setup, "Review");
+  return setup;
+}
+
+describe("review panel", () => {
+  test("b cycles expanded -> compact -> hidden -> expanded", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    // Assert
+    expect(setup.captureCharFrame()).toContain("Submit review"); // expanded rail
+
+    // Act
+    await press(setup, "b");
+
+    // Assert
+    let frame = setup.captureCharFrame();
+    expect(frame).toContain("«"); // compact strip shows the expand chevron
+    expect(frame).not.toContain("Submit review");
+
+    // Act
+    await press(setup, "b");
+
+    // Assert
+    frame = setup.captureCharFrame();
+    expect(frame).not.toContain("«"); // hidden: no strip, no divider
+    expect(frame).not.toContain("│");
+
+    // Act
+    await press(setup, "b");
+
+    // Assert
+    expect(setup.captureCharFrame()).toContain("Submit review"); // back to expanded
+  });
+
+  test("the collapse mode persists to the user config", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    // Act
+    await press(setup, "b"); // -> compact
+
+    // Assert
+    expect(loadConfig({ userConfigPath: configPath }).ui.reviewState).toBe("compact");
+  });
+
+  test("] widens the rail and persists the new width", async () => {
+    // Arrange
+    const setup = await renderApp();
+    const startWidth = loadConfig({ userConfigPath: configPath }).ui.reviewWidth;
+
+    // Act
+    await press(setup, "]");
+
+    // Assert
+    const widened = loadConfig({ userConfigPath: configPath }).ui.reviewWidth;
+    expect(widened).toBeGreaterThan(startWidth);
+  });
+
+  test("submitting from a hidden panel force-opens the rail so the confirm card is reachable", async () => {
+    // Arrange
+    const setup = await renderApp();
+    await press(setup, "b"); // -> compact
+    await press(setup, "b"); // -> hidden
+
+    // Assert
+    expect(setup.captureCharFrame()).not.toContain("Submit review"); // rail is gone
+
+    // Act
+    await press(setup, "enter"); // submit while hidden must not trap in an invisible modal
+
+    // Assert
+    const frame = setup.captureCharFrame();
+    expect(frame).toContain("submit review"); // the confirm card is visible again
+    expect(frame).toContain("[Approve]");
+
+    // the reveal is live-only: the saved panel preference stays as the user left it
+    expect(loadConfig({ userConfigPath: configPath }).ui.reviewState).toBe("hidden");
+  });
+});

package/src/App.submit-confirm.test.tsx

@@ -1,9 +1,4 @@
-/**
- * The rail submit confirm (tier 2): pressing submit expands the rail's
- * Submit button into a bordered confirm card - counts, verdict selector,
- * summary input, word-buttons. Char-frame assertions over the real App
- * and an in-process daemon, like App.test.tsx.
- */
+/** The rail submit confirm (tier 2): pressing submit expands the rail's Submit button into a bordered confirm card - counts, verdict selector, summary input, word-buttons. Char-frame assertions over the real App and an in-process daemon, like App.test.tsx. */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
@@ -72,9 +67,16 @@ function seedAnnotations(count: number): void {
 
 describe("rail submit confirm", () => {
   test("submit expands the Submit button into the confirm card", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("Submit review (0)");
+
+    // Act
     await press(setup, "enter");
+
+    // Assert
     const frame = setup.captureCharFrame();
     // the card: title, honest counts, verdict selector, word-buttons
     expect(frame).toContain("submit review");
@@ -89,22 +91,44 @@ describe("rail submit confirm", () => {
   });
 
   test("left/right cycles the verdict selector in the card", async () => {
+    // Arrange
     const setup = await renderApp();
     await press(setup, "enter");
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("[Approve]");
+
+    // Act
     await press(setup, "right");
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("[Changes]");
+
+    // Act
     await press(setup, "right");
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("[Comment]");
+
+    // Act
     await press(setup, "left");
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("[Changes]");
   });
 
   test("esc cancels the card and restores the plain Submit button", async () => {
+    // Arrange
     const setup = await renderApp();
     await press(setup, "enter");
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("[Approve]");
+
+    // Act
     await press(setup, "escape");
+
+    // Assert
     // a bare ESC settles after the parser's escape-sequence window
     const frame = await waitForTextGone(setup, "[Approve]");
     expect(frame).not.toContain("0 annotations");
@@ -112,14 +136,23 @@ describe("rail submit confirm", () => {
   });
 
   test("enter in the card resolves the session through the controller", async () => {
+    // Arrange
     seedAnnotations(1);
     const setup = await renderApp();
+
+    // Act
     await press(setup, "enter");
+
+    // Assert
     const frame = setup.captureCharFrame();
     expect(frame).toContain("1 annotations · 0 blocking");
     expect(frame).toContain("[Changes]"); // pending items: request changes default
+
+    // Act
     await setup.mockInput.typeText("Tighten the steps.");
     await press(setup, "enter");
+
+    // Assert
     // the completion flow after submit is unchanged
     await waitForText(setup, "feedback sent");
     const stored = server.core.sessionGet(session.id);
@@ -128,23 +161,36 @@ describe("rail submit confirm", () => {
   });
 
   test("the annotation stack stays scrollable while the card is open", async () => {
+    // Arrange
     seedAnnotations(12);
     const setup = await renderApp();
+
+    // Act
     // walk annotation focus to the last card: the rail scrolls it into view
     for (let index = 0; index < 12; index++) await press(setup, "n");
+
+    // Assert
     const scrolled = setup.captureCharFrame();
     expect(scrolled).toContain("note 12");
     expect(scrolled).not.toContain("note 01");
+
+    // Act
     await press(setup, "enter");
+
+    // Assert
     const opened = setup.captureCharFrame();
     // the card is pinned outside the scrollbox; the stack above stays
     // scrolled away from the top when the card takes its space
     expect(opened).toContain("12 annotations · 0 blocking");
     expect(opened).not.toContain("note 01");
+
+    // Act
     // the stack still scrolls with the card open: wheel over the rail
     // brings the last card back into view while the confirm card stays put
     for (let turn = 0; turn < 12; turn++) await setup.mockMouse.scroll(100, 10, "down");
     await settle(setup);
+
+    // Assert
     const scrolledWithCard = setup.captureCharFrame();
     expect(scrolledWithCard).toContain("note 12");
     expect(scrolledWithCard).toContain("12 annotations · 0 blocking");
@@ -152,9 +198,14 @@ describe("rail submit confirm", () => {
   });
 
   test("read-only observers never see the confirm card", async () => {
+    // Arrange
     seedAnnotations(1);
     const setup = await renderApp({ readOnly: true });
+
+    // Act
     await press(setup, "enter");
+
+    // Assert
     const frame = setup.captureCharFrame();
     expect(frame).toContain("observer - read-only");
     expect(frame).not.toContain("1 annotations");

package/src/App.test.tsx

@@ -1,8 +1,4 @@
-/**
- * Virtual-terminal component tests (tier 2): the real App over a real
- * in-process daemon in a temp home. Char-frame assertions + mock keys -
- * the whole review loop drivable without a terminal.
- */
+/** Virtual-terminal component tests (tier 2): the real App over a real in-process daemon in a temp home. Char-frame assertions + mock keys - the whole review loop drivable without a terminal. */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
@@ -57,7 +53,10 @@ async function renderApp(sessionId?: string) {
 
 describe("plan rendering", () => {
   test("renders the plan with headings, list markers, and the rail", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Assert
     const frame = setup.captureCharFrame();
     expect(frame).toContain("Migration Plan");
     expect(frame).toContain("Context");
@@ -70,24 +69,38 @@ describe("plan rendering", () => {
 
 describe("keyboard grammar", () => {
   test("j/k moves the cursor glyph between blocks", async () => {
+    // Arrange
     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("▎"))!;
     expect(cursorLine).toContain("persists sessions");
   });
 
   test("comment flow: c types a body, ⏎ saves to the daemon", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Act
     await press(setup, "j");
     await press(setup, "j");
     await press(setup, "c");
     await setup.renderOnce();
+
+    // Assert
     expect(setup.captureCharFrame()).toContain('comment on "The daemon');
+
+    // Act
     await type(setup, "Define atomically.");
     await press(setup, "enter");
+
+    // Assert
     await waitForText(setup, "COMMENT");
     const stored = server.core.sessionGet(session.id);
     expect(stored.annotations.length).toBe(1);
@@ -95,7 +108,10 @@ describe("keyboard grammar", () => {
   });
 
   test("span mode: v + l selects words, c anchors the exact span", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Act
     await press(setup, "j");
     await press(setup, "j");
     await press(setup, "v");
@@ -103,19 +119,30 @@ describe("keyboard grammar", () => {
     await press(setup, "c");
     await type(setup, "Which daemon?");
     await press(setup, "enter");
+
+    // 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");
   });
 
   test("x cuts a block into the working copy; 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");
+
+    // Act
     await press(setup, "x");
+
+    // Assert
     await waitForText(setup, "[cut]");
     expect(server.core.sessionGet(session.id).workingCopy).not.toContain("move the store");
+
+    // Act
     await press(setup, "x");
+
+    // Assert
     await waitForState(setup, () => server.core.sessionGet(session.id).workingCopy === undefined);
   });
 
@@ -125,8 +152,13 @@ describe("keyboard grammar", () => {
     Bun.spawnSync(["chmod", "+x", script]);
     process.env.CUELOOP_EDITOR = script;
     try {
+      // Arrange
       const setup = await renderApp();
+
+      // Act
       await press(setup, "e");
+
+      // Assert
       await waitForText(setup, "[edited]");
       expect(server.core.sessionGet(session.id).workingCopy).toContain("very atomically");
     } finally {
@@ -137,6 +169,7 @@ describe("keyboard grammar", () => {
 
 describe("submit", () => {
   test("⏎ opens the rail confirm card; verdict + summary resolve the session", async () => {
+    // Arrange
     const setup = await renderApp();
     await press(setup, "j");
     await press(setup, "j");
@@ -144,10 +177,18 @@ describe("submit", () => {
     await type(setup, "Needs a phase list.");
     await press(setup, "enter");
     await waitForText(setup, "Review (1)");
+
+    // Act
     await press(setup, "enter"); // open submit
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("[Changes]");
+
+    // Act
     await type(setup, "Expand the steps.");
     await press(setup, "enter");
+
+    // Assert
     await waitForText(setup, "feedback sent");
     const stored = server.core.sessionGet(session.id);
     expect(stored.status).toBe("resolved");
@@ -158,10 +199,19 @@ describe("submit", () => {
   });
 
   test("approve via ←/→ verdict cycling", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Act
     await press(setup, "enter");
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("[Approve]"); // no pending items → approve default
+
+    // Act
     await press(setup, "enter");
+
+    // Assert
     await waitForState(setup, () => server.core.sessionGet(session.id).verdict !== undefined);
     expect(server.core.sessionGet(session.id).verdict!.kind).toBe("approve");
   });
@@ -169,11 +219,18 @@ describe("submit", () => {
 
 describe("inbox", () => {
   test("inbox mode renders and opens a session", async () => {
+    // Arrange
     const setup = await testRender(<App home={home} />, { width: 120, height: 32 });
     await waitForText(setup, "inbox");
+
+    // Assert
     expect(setup.captureCharFrame()).toContain("inbox (1 pending)");
     expect(setup.captureCharFrame()).toContain("Migration Plan");
+
+    // Act
     await press(setup, "enter");
+
+    // Assert
     await waitForText(setup, "Submit review (0)");
   });
 });