@cueloop/client 0.1.0-alpha.3 → 0.1.0-alpha.31

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.31",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.3",
-    "@cueloop/extension-api": "0.1.0-alpha.3",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.3",
-    "@cueloop/schema": "0.1.0-alpha.3",
-    "@opentui/core": "^0.4.3",
-    "@opentui/react": "^0.4.3",
+    "@cueloop/daemon": "0.1.0-alpha.31",
+    "@cueloop/extension-api": "0.1.0-alpha.31",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.31",
+    "@cueloop/schema": "0.1.0-alpha.31",
+    "@opentui/core": "^0.5.2",
+    "@opentui/keymap": "0.5.2",
+    "@opentui/react": "^0.5.2",
+    "@opentui/ssh": "0.5.2",
     "@pierre/diffs": "^1.3.5",
-    "react": "^19.2.0",
-    "@opentui/ssh": "0.4.5"
+    "react": "^19.2.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.0",
@@ -36,5 +37,10 @@
     "type": "git",
     "url": "git+https://github.com/mmurakaru/cueloop.git",
     "directory": "packages/client"
-  }
-}
+  },
+  "homepage": "https://github.com/mmurakaru/cueloop#readme",
+  "bugs": {
+    "url": "https://github.com/mmurakaru/cueloop/issues"
+  },
+  "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail"
+}

package/src/App.autoclose.test.tsx

@@ -0,0 +1,133 @@
+/** 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";
+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 { App } from "./App";
+import { press, settle, waitForText } from "./test-support";
+
+const PLAN = "# Plan\n\nShip the thing.\n";
+
+let home: string;
+let server: DaemonServer;
+let session: ReviewSession;
+let configPath: string;
+let clock: ManualClock;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-close-"));
+  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" } },
+  });
+  clock = new ManualClock();
+});
+afterEach(() => {
+  delete process.env.CUELOOP_CONFIG;
+  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} clock={clock} />, {
+    width: 120,
+    height: 30,
+  });
+  await waitForText(setup, "cueloop");
+  return setup;
+}
+
+type Setup = Awaited<ReturnType<typeof renderApp>>;
+
+async function submitApprove(setup: Setup): Promise<void> {
+  await press(setup, "enter"); // open submit (approve default: no pending items)
+  await press(setup, "enter"); // confirm
+  await waitForText(setup, "review approved");
+}
+
+describe("completion overlay", () => {
+  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);
+
+    // 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 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");
+
+    // Assert
+    expect(existsSync(configPath)).toBe(true);
+    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 waitForText(setup, "closing in 5s");
+
+    // Act
+    // a bare ESC sits in the input parser's escape-sequence disambiguation
+    // window before it is delivered - the frame wait absorbs it
+    await press(setup, "escape");
+
+    // Assert
+    const frame = await waitForText(setup, "resolved: approve");
+    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);
+    await waitForText(setup, "closing in 1s");
+    expect(exited).toBe(-1);
+
+    // Act
+    clock.advance(1000);
+    await settle(setup);
+
+    // Assert
+    expect(exited).toBe(0);
+  });
+});

package/src/App.diff.test.tsx

@@ -9,6 +9,7 @@ import { testRender } from "@opentui/react/test-utils";
 import { DaemonServer } from "@cueloop/daemon";
 import type { ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
+import { press, waitForText } from "./test-support";
 
 const PATCH = `diff --git a/src/store.ts b/src/store.ts
 index 111..222 100644
@@ -41,25 +42,16 @@ afterEach(() => {
 
 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();
+  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 await setup.mockInput.typeText(k);
-  await Bun.sleep(15);
-  await setup.renderOnce();
-}
-
 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("@@ -1,4 +1,4 @@");
@@ -68,32 +60,47 @@ describe("diff review", () => {
   });
 
   test("line comment: quote-anchored, lands in feedback with the code line", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Act
     // 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");
+
+    // Assert
+    await waitForText(setup, "COMMENT ON");
+
+    // Act
     await setup.mockInput.typeText("Map needs an eviction story.");
     await press(setup, "enter");
-    await Bun.sleep(80);
-    await setup.renderOnce();
+
+    // Assert
+    // inline annotation card rendered under the line
+    await waitForText(setup, "◆ Map needs an eviction story.");
     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.");
 
+    // Act
     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 () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Act
     await press(setup, "x");
-    expect(setup.captureCharFrame()).toContain("plan-only verb");
+
+    // Assert
+    await waitForText(setup, "plan-only verb");
   });
 });

package/src/App.export.test.tsx

@@ -1,8 +1,4 @@
-/**
- * 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";
@@ -13,6 +9,7 @@ import { testRender } from "@opentui/react/test-utils";
 import { DaemonServer } from "@cueloop/daemon";
 import type { ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
+import { press, waitForState, waitForText } from "./test-support";
 
 const PLAN = `# Migration Plan
 
@@ -49,31 +46,25 @@ afterEach(() => {
 
 describe("obsidian export on resolve", () => {
   test("submitting a review writes the plan into the vault and shows the path", async () => {
+    // Arrange
     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
+    await waitForText(setup, "cueloop");
+
+    // Act
+    await press(setup, "enter"); // open the submit overlay, keep the default verdict (approve)
+
+    // Assert
+    await waitForText(setup, "verdict");
+
+    // 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);