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

package/src/App.autoclose.test.tsx

@@ -1,4 +1,4 @@
-/** Post-submit completion overlay: prompt, opt-in persistence, countdown, dismissal. */
+/** Post-submit completion overlay: prompt, opt-in persistence, countdown, dismissal. Countdown seconds tick on an injected ManualClock, so tests advance time instead of waiting it out. */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -6,113 +6,139 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import React from "react";
 import { testRender } from "@opentui/react/test-utils";
+import { ManualClock } from "@opentui/core/testing";
 import { DaemonServer } from "@cueloop/daemon";
-import type { ReviewSession } from "@cueloop/schema";
+import type { Thread } from "@cueloop/schema";
 import { App } from "./App";
+import { isolateUserConfig, press, settle, waitForText, pressKey } from "./test-support";
 
 const PLAN = "# Plan\n\nShip the thing.\n";
 
 let home: string;
 let server: DaemonServer;
-let session: ReviewSession;
+let session: Thread;
 let configPath: string;
+let restoreUserConfig: () => void;
+let clock: ManualClock;
 
 beforeEach(() => {
   home = mkdtempSync(join(tmpdir(), "cueloop-close-"));
   configPath = join(home, "config.toml");
-  process.env.CUELOOP_CONFIG = configPath;
+  restoreUserConfig = isolateUserConfig(home, "config.toml");
   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" } },
   });
+  clock = new ManualClock();
 });
 afterEach(() => {
-  delete process.env.CUELOOP_CONFIG;
+  restoreUserConfig();
   server.stop();
   rmSync(home, { recursive: true, force: true });
 });
 
 async function renderApp(onExit?: (code: number) => void) {
-  const setup = await testRender(<App home={home} sessionId={session.id} onExit={onExit} />, {
-    width: 120,
-    height: 30,
-  });
-  for (let i = 0; i < 40 && !setup.captureCharFrame().includes("cueloop"); i++) {
-    await Bun.sleep(25);
-    await setup.renderOnce();
-  }
+  const setup = await testRender(
+    <App home={home} sessionId={session.id} onExit={onExit} clock={clock} />,
+    {
+      width: 120,
+      height: 30,
+    },
+  );
+
+  await waitForText(setup, "cueloop");
+
   return setup;
 }
 
 type Setup = Awaited<ReturnType<typeof renderApp>>;
-async function press(setup: Setup, k: string): Promise<void> {
-  if (k === "enter") setup.mockInput.pressKey("RETURN");
-  else if (k === "escape") setup.mockInput.pressKey("ESCAPE");
-  else await setup.mockInput.typeText(k);
-  await Bun.sleep(15);
-  await setup.renderOnce();
-}
 
 async function submitApprove(setup: Setup): Promise<void> {
-  await press(setup, "enter"); // open submit (approve default: no pending items)
+  await pressKey(setup, "RETURN", { meta: true }); // open submit (approve default: no pending items)
   await press(setup, "enter"); // confirm
-  const deadline = Date.now() + 10_000;
-  while (Date.now() < deadline && !setup.captureCharFrame().includes("review approved")) {
-    await Bun.sleep(25);
-    await setup.renderOnce();
-  }
+  await waitForText(setup, "review approved");
 }
 
 describe("completion overlay", () => {
-  test("submit with auto-close off shows the prompt; ⏎ exits", async () => {
+  test("submit with auto-close off counts down from 5; ⏎ exits now", async () => {
+    // Arrange
     let exited = -1;
     const setup = await renderApp((code) => (exited = code));
+
+    // Act
     await submitApprove(setup);
-    const frame = setup.captureCharFrame();
-    expect(frame).toContain("✓ review approved");
-    expect(frame).toContain("a always close after submit");
+
+    // Assert
+    const frame = await waitForText(setup, "closing in 5s");
+
+    expect(frame).toContain("review approved");
+    expect(frame).toContain("close [return]");
+    expect(frame).toContain("return to plan [esc]");
+
+    // Act
     await press(setup, "enter");
+
+    // Assert
     expect(exited).toBe(0);
   });
 
-  test("a opts in: persists the config and starts the countdown", async () => {
+  test("a remembers the countdown as the persisted default", async () => {
+    // Arrange
     const setup = await renderApp();
+
     await submitApprove(setup);
+    await waitForText(setup, "closing in 5s");
+
+    // Act
     await press(setup, "a");
-    expect(setup.captureCharFrame()).toContain("closing in 3s");
+
+    // Assert
     expect(existsSync(configPath)).toBe(true);
-    expect(readFileSync(configPath, "utf8")).toContain("auto_close = 3");
+    expect(readFileSync(configPath, "utf8")).toContain("auto_close = 5");
+
+    // Act
+    // the countdown keeps running; each second is one manual-clock tick
+    clock.advance(1000);
+
+    // Assert
+    await waitForText(setup, "closing in 4s");
   });
 
   test("esc dismisses to the resolved read-only view", async () => {
+    // Arrange
     const setup = await renderApp();
+
     await submitApprove(setup);
-    await press(setup, "escape");
+    await waitForText(setup, "closing in 5s");
+
+    // Act
     // a bare ESC sits in the input parser's escape-sequence disambiguation
-    // window before it is delivered - poll for the dismissal
-    const deadline = Date.now() + 5_000;
-    while (Date.now() < deadline && !setup.captureCharFrame().includes("resolved: approve")) {
-      await Bun.sleep(50);
-      await setup.renderOnce();
-    }
-    const frame = setup.captureCharFrame();
-    expect(frame).toContain("resolved: approve");
-    expect(frame).not.toContain("always close after submit");
+    // window before it is delivered - the frame wait absorbs it
+    await press(setup, "escape");
+
+    // Assert - the countdown is cancelled and we are back in the (resolved) thread view
+    const frame = await waitForText(setup, "Ship the thing");
+
+    expect(frame).not.toContain("closing in");
   });
 
   test("configured auto_close counts down and exits without interaction", async () => {
+    // Arrange
     writeFileSync(configPath, "[ui]\nauto_close = 1\n");
     let exited = -1;
     const setup = await renderApp((code) => (exited = code));
+
     await submitApprove(setup);
-    expect(setup.captureCharFrame()).toContain("closing in 1s");
-    const deadline = Date.now() + 10_000;
-    while (Date.now() < deadline && exited === -1) {
-      await Bun.sleep(100);
-      await setup.renderOnce();
-    }
+    await waitForText(setup, "closing in 1s");
+    expect(exited).toBe(-1);
+
+    // Act
+    clock.advance(1000);
+    await settle(setup);
+
+    // Assert
     expect(exited).toBe(0);
-  }, 20_000);
+  });
 });

package/src/App.diff.test.tsx

@@ -1,14 +1,25 @@
-/** Diff-review flow in the virtual terminal (slice 3). */
+/** Diff-review flow in the virtual terminal: the diff sheet annotates like the thread view. */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, 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 type { Thread } from "@cueloop/schema";
 import { App } from "./App";
+import { NERD } from "./components/primitives/icons";
+import {
+  clickText,
+  dragText,
+  isolateUserConfig,
+  press,
+  pressKey,
+  renderReadyApp,
+  typeText,
+  waitForState,
+  waitForText,
+} from "./test-support";
 
 const PATCH = `diff --git a/src/store.ts b/src/store.ts
 index 111..222 100644
@@ -22,11 +33,13 @@ index 111..222 100644
 `;
 
 let home: string;
+let restoreUserConfig: () => void;
 let server: DaemonServer;
-let session: ReviewSession;
+let session: Thread;
 
 beforeEach(() => {
   home = mkdtempSync(join(tmpdir(), "cueloop-diff-"));
+  restoreUserConfig = isolateUserConfig(home);
   server = new DaemonServer({ home, idleExitMs: 0 });
   server.start();
   session = server.core.sessionCreate({
@@ -35,65 +48,166 @@ beforeEach(() => {
   });
 });
 afterEach(() => {
+  restoreUserConfig();
   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 });
-  for (let i = 0; i < 40 && !setup.captureCharFrame().includes("cueloop"); i++) {
-    await Bun.sleep(25);
-    await setup.renderOnce();
-  }
-  await setup.renderOnce();
-  return setup;
-}
+async function renderApp(sessionId = session.id) {
+  const setup = await renderReadyApp(<App home={home} sessionId={sessionId} />, {
+    width: 120,
+    height: 30,
+  });
 
-type Setup = Awaited<ReturnType<typeof renderApp>>;
-async function press(setup: Setup, k: string): Promise<void> {
-  if (k === "enter") setup.mockInput.pressKey("RETURN");
-  else await setup.mockInput.typeText(k);
-  await Bun.sleep(15);
-  await setup.renderOnce();
+  await waitForText(setup, "new Map()");
+
+  return setup;
 }
 
 describe("diff review", () => {
   test("renders file header, hunks, and signed lines", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Assert
     const frame = setup.captureCharFrame();
-    expect(frame).toContain("■ src/store.ts");
+
+    expect(frame).toContain("src/store.ts");
     expect(frame).toContain("@@ -1,4 +1,4 @@");
-    expect(frame).toContain("-  private items = [];");
-    expect(frame).toContain("+  private items = new Map();");
+    expect(frame).toMatch(/- {2,}private items = \[\];/);
+    expect(frame).toMatch(/\+ {2,}private items = new Map\(\);/);
   });
 
-  test("line comment: quote-anchored, lands in feedback with the code line", async () => {
+  test("a drag marks the code, typing comments on it, and the comment lands in feedback", async () => {
+    // Arrange
     const setup = await renderApp();
-    // rows: file(0), hunk(1), ctx(2), del(3), add(4)
-    for (let i = 0; i < 4; i++) await press(setup, "j");
-    await press(setup, "c");
-    expect(setup.captureCharFrame()).toContain("COMMENT ON");
-    await setup.mockInput.typeText("Map needs an eviction story.");
+
+    // Act - mark "new Map()" on the added line and just start typing, as in the thread view
+    await dragText(setup, "new Map()", "new Map()", "new Map()".length);
+    await typeText(setup, "Map needs an eviction story.");
+    await waitForText(setup, "● Map needs an eviction story.");
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert - the discussion card hangs under the line; the anchor is the marked words
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
+    await waitForText(setup, "● Map needs an eviction story.");
+    expect(server.core.sessionGet(session.id).annotations[0]!.anchor.quote).toBe("new Map()");
+
+    // Act - submit with the session chord (cmd+enter, no composer open), confirm request_changes
+    await pressKey(setup, "RETURN", { meta: true });
     await press(setup, "enter");
-    await Bun.sleep(80);
-    await setup.renderOnce();
-    const stored = server.core.sessionGet(session.id);
-    expect(stored.annotations.length).toBe(1);
-    expect(stored.annotations[0]!.anchor.quote).toContain("new Map()");
-    // inline annotation card rendered under the line
-    expect(setup.captureCharFrame()).toContain("◆ Map needs an eviction story.");
-
-    await press(setup, "enter"); // submit
-    await press(setup, "enter"); // confirm request_changes
-    await Bun.sleep(100);
+
+    // Assert
+    await waitForText(setup, "feedback sent");
     const resolved = server.core.sessionGet(session.id);
+
     expect(resolved.verdict!.feedback).toContain("new Map()");
     expect(resolved.verdict!.feedback).toContain("Map needs an eviction story.");
   });
 
-  test("plan verbs are guarded in diff sessions", async () => {
+  test("a comment reopens with its mark painted on the code", async () => {
+    // Arrange - a stored comment anchored to the added line's words
+    server.core.sessionAnnotate(session.id, {
+      id: "a_existing",
+      kind: "comment",
+      anchor: { quote: "new Map()", prefix: "  private items = ", suffix: ";" },
+      body: "Existing note.",
+    });
+
+    // Act
+    const setup = await renderApp();
+
+    // Assert
+    await waitForText(setup, "● Existing note.");
+  });
+
+  test("option+c folds the caret's file to its band; the chevron restores its body", async () => {
+    // Arrange - the caret opens on the file's first code line
+    const setup = await renderApp();
+
+    // Act
+    await pressKey(setup, "c", { meta: true });
+
+    // Assert - the body is gone but the band (with its counts) remains
+    await waitForState(setup, () => !setup.captureCharFrame().includes("new Map()"));
+    const collapsed = setup.captureCharFrame();
+
+    expect(collapsed).toContain("src/store.ts");
+    expect(collapsed).toContain("+1");
+
+    // Act - the band's chevron unfolds it again
+    await clickText(setup, NERD.chevronRight);
+
+    // Assert
+    await waitForText(setup, "new Map()");
+  });
+
+  test("curation needs full file contents; a legacy diff answers", async () => {
+    // Arrange - the session carries no artifact.files
     const setup = await renderApp();
-    await press(setup, "x");
-    expect(setup.captureCharFrame()).toContain("plan-only verb");
+
+    // Act
+    await pressKey(setup, "x", { meta: true });
+
+    // Assert
+    await waitForText(setup, "hunk curation needs full file contents");
+  });
+
+  test("rejecting the only change empties the curated working copy", async () => {
+    // Arrange - a diff session that carries full file contents
+    const withFiles = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "main" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: { title: "working tree" },
+        files: [
+          {
+            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",
+          },
+        ],
+      },
+    });
+    const setup = await renderApp(withFiles.id);
+
+    // Act - place the caret on the added line and reject its change
+    await clickText(setup, "new Map()");
+    await pressKey(setup, "x", { meta: true });
+
+    // Assert - the single change is gone, so the curated working copy is empty
+    await waitForText(setup, "change rejected");
+    const stored = server.core.sessionGet(withFiles.id);
+
+    expect(stored.workingCopy).toBe("");
+  });
+
+  test("a diff opens with the Changes column listing every changed file", async () => {
+    // Arrange - two changed files; config.ts is not in the patch text, so it can
+    // only appear here by way of the Changes column reading artifact.files
+    const withFiles = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "main" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: { title: "working tree" },
+        files: [
+          { path: "src/store.ts", oldContents: "a", newContents: "b", status: "modified" },
+          { path: "src/config.ts", oldContents: "", newContents: "c", status: "added" },
+        ],
+      },
+    });
+    const setup = await renderReadyApp(<App home={home} sessionId={withFiles.id} />, {
+      width: 120,
+      height: 30,
+    });
+
+    await waitForText(setup, "cueloop");
+
+    // Assert - the context default opens the column for a diff, so both files show
+    await waitForText(setup, "config.ts");
+    expect(setup.captureCharFrame()).toContain("store.ts");
   });
 });

package/src/App.export.test.tsx

@@ -1,18 +1,29 @@
-/**
- * Tier-2 wiring test for the notes-vault export: with [integrations.obsidian]
- * configured to export on resolve, submitting a review writes the note into
- * the vault and surfaces the path in the status line.
- */
+/** Tier-2 wiring for the notes-vault export: with [integrations.obsidian] set to export on resolve, submitting a review writes the note into the vault and surfaces the path in the status line. */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} 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 type { Thread } from "@cueloop/schema";
 import { App } from "./App";
+import {
+  isolateUserConfig,
+  press,
+  waitForState,
+  waitForText,
+  pressKey,
+  renderReadyApp,
+} from "./test-support";
 
 const PLAN = `# Migration Plan
 
@@ -22,63 +33,70 @@ Move the store atomically.
 let home: string;
 let vault: string;
 let server: DaemonServer;
-let session: ReviewSession;
-let savedConfigEnv: string | undefined;
+let session: Thread;
+let restoreUserConfig: () => void;
 
 beforeEach(() => {
   home = mkdtempSync(join(tmpdir(), "cueloop-app-export-"));
   vault = join(home, "vault");
   mkdirSync(vault);
   const configPath = join(home, "config.toml");
-  writeFileSync(configPath, `[integrations.obsidian]\nvault = ${JSON.stringify(vault)}\nexportOn = "resolve"\n`);
-  savedConfigEnv = process.env.CUELOOP_CONFIG;
-  process.env.CUELOOP_CONFIG = configPath;
+
+  writeFileSync(
+    configPath,
+    `[integrations.obsidian]\nvault = ${JSON.stringify(vault)}\nexportOn = "resolve"\n`,
+  );
+  restoreUserConfig = isolateUserConfig(home, "config.toml");
   server = new DaemonServer({ home, idleExitMs: 0 });
   server.start();
   session = server.core.sessionCreate({
     workspace: { repoRoot: "/repo", branch: "main" },
-    artifact: { type: "plan", content: PLAN, meta: { title: "Migration Plan", planPath: "plan.md" } },
+    artifact: {
+      type: "plan",
+      content: PLAN,
+      meta: { title: "Migration Plan", planPath: "plan.md" },
+    },
   });
 });
 afterEach(() => {
-  if (savedConfigEnv === undefined) delete process.env.CUELOOP_CONFIG;
-  else process.env.CUELOOP_CONFIG = savedConfigEnv;
+  restoreUserConfig();
   server.stop();
   rmSync(home, { recursive: true, force: true });
 });
 
 describe("obsidian export on resolve", () => {
   test("submitting a review writes the plan into the vault and shows the path", async () => {
-    const setup = await testRender(<App home={home} sessionId={session.id} />, { width: 120, height: 32 });
-    for (let i = 0; i < 40 && !setup.captureCharFrame().includes("cueloop"); i++) {
-      await Bun.sleep(25);
-      await setup.renderOnce();
-    }
-    // open the submit overlay, keep the default verdict (approve), submit
-    setup.mockInput.pressKey("RETURN");
-    await Bun.sleep(15);
-    await setup.renderOnce();
-    expect(setup.captureCharFrame()).toContain("verdict");
-    setup.mockInput.pressKey("RETURN");
-    // wall-clock deadlines: the export is an async round-trip after resolve,
-    // and an iteration count times out on a loaded runner
+    // Arrange
+    const setup = await renderReadyApp(<App home={home} sessionId={session.id} />, {
+      width: 120,
+      height: 32,
+    });
+
+    await waitForText(setup, "cueloop");
+
+    // Act
+    await pressKey(setup, "RETURN", { meta: true }); // open the submit overlay, keep the default verdict (approve)
+
+    // Assert
+    await waitForText(setup, "[Approve]");
+
+    // Act
+    await press(setup, "enter"); // submit
+
+    // Assert
+    // the export is an async round-trip after resolve; the status line lands
+    // on a later render than the file write
     const dir = join(vault, "cueloop");
-    const fileDeadline = Date.now() + 30_000;
-    while (Date.now() < fileDeadline && !existsSync(dir)) {
-      await Bun.sleep(25);
-      await setup.renderOnce();
-    }
-    // the status line lands on a later render than the file write
-    const statusDeadline = Date.now() + 30_000;
-    while (Date.now() < statusDeadline && !setup.captureCharFrame().includes("exported to")) {
-      await Bun.sleep(25);
-      await setup.renderOnce();
-    }
+
+    await waitForState(setup, () => existsSync(dir));
+    await waitForText(setup, "exported to");
 
     const notes = readdirSync(dir);
+
     expect(notes.length).toBe(1);
     expect(notes[0]).toMatch(/^\d{4}-\d{2}-\d{2} - Migration Plan\.md$/);
     const written = readFileSync(join(dir, notes[0]!), "utf8");
+
     expect(written).toContain("source: cueloop");
     expect(written).toContain(`session: ${session.id}`);
     expect(written).toContain("verdict: approve");