@cueloop/client 0.1.0-alpha.0

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@cueloop/client",
+  "version": "0.1.0-alpha.0",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@cueloop/daemon": "workspace:*",
+    "@cueloop/extension-api": "workspace:*",
+    "@cueloop/integration-obsidian": "workspace:*",
+    "@cueloop/schema": "workspace:*",
+    "@opentui/core": "^0.4.3",
+    "@opentui/react": "^0.4.3",
+    "@pierre/diffs": "^1.3.5",
+    "react": "^19.2.0",
+    "@opentui/ssh": "0.4.5"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.0",
+    "ssh2": "^1.17.0",
+    "@types/ssh2": "^1.15.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mmurakaru/cueloop.git",
+    "directory": "packages/client"
+  }
+}

package/src/App.diff.test.tsx

@@ -0,0 +1,99 @@
+/** Diff-review flow in the virtual terminal (slice 3). */
+
+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 { App } from "./App";
+
+const PATCH = `diff --git a/src/store.ts b/src/store.ts
+index 111..222 100644
+--- a/src/store.ts
++++ b/src/store.ts
+@@ -1,4 +1,4 @@
+ export class Store {
+-  private items = [];
++  private items = new Map();
+ }
+`;
+
+let home: string;
+let server: DaemonServer;
+let session: ReviewSession;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-diff-"));
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "diff", content: PATCH, meta: { title: "working tree" } },
+  });
+});
+afterEach(() => {
+  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;
+}
+
+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 () => {
+    const setup = await renderApp();
+    const frame = setup.captureCharFrame();
+    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();");
+  });
+
+  test("line comment: quote-anchored, lands in feedback with the code line", async () => {
+    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.");
+    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);
+    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 () => {
+    const setup = await renderApp();
+    await press(setup, "x");
+    expect(setup.captureCharFrame()).toContain("plan-only verb");
+  });
+});

package/src/App.export.test.tsx

@@ -0,0 +1,80 @@
+/**
+ * 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.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+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 { App } from "./App";
+
+const PLAN = `# Migration Plan
+
+Move the store atomically.
+`;
+
+let home: string;
+let vault: string;
+let server: DaemonServer;
+let session: ReviewSession;
+let savedConfigEnv: string | undefined;
+
+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;
+  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" } },
+  });
+});
+afterEach(() => {
+  if (savedConfigEnv === undefined) delete process.env.CUELOOP_CONFIG;
+  else process.env.CUELOOP_CONFIG = savedConfigEnv;
+  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");
+    const dir = join(vault, "cueloop");
+    for (let i = 0; i < 40 && !existsSync(dir); i++) {
+      await Bun.sleep(25);
+      await setup.renderOnce();
+    }
+    await setup.renderOnce();
+
+    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");
+    expect(written).toContain("Move the store atomically.");
+    expect(setup.captureCharFrame()).toContain("exported to");
+  });
+});

package/src/App.readonly.test.tsx

@@ -0,0 +1,148 @@
+/**
+ * Observer mode (tier 2): the App with readOnly renders and navigates like the
+ * controller's, but every mutating verb answers "observer - read-only" and
+ * leaves daemon state untouched.
+ */
+
+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 { makeAnchor, parseBlocks, type ReviewSession } from "@cueloop/schema";
+import { App } from "./App";
+
+const PLAN = `# Migration Plan
+
+## Context
+
+The daemon persists sessions to disk atomically.
+
+## Steps
+
+- move the store
+- add recovery
+`;
+
+let home: string;
+let server: DaemonServer;
+let session: ReviewSession;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-observer-"));
+  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" } },
+  });
+});
+afterEach(() => {
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderObserver() {
+  const setup = await testRender(<App home={home} sessionId={session.id} readOnly />, {
+    width: 120,
+    height: 32,
+  });
+  for (let i = 0; i < 40 && !setup.captureCharFrame().includes("cueloop"); i++) {
+    await Bun.sleep(25);
+    await setup.renderOnce();
+  }
+  await setup.renderOnce();
+  return setup;
+}
+
+type Setup = Awaited<ReturnType<typeof renderObserver>>;
+
+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();
+}
+
+/** Session state that any mutating verb would change. */
+function snapshot() {
+  const s = server.core.sessionGet(session.id);
+  return { annotations: s.annotations.length, workingCopy: s.workingCopy, status: s.status };
+}
+
+describe("observer rendering", () => {
+  test("shows the observer badge and read-only hint bar", async () => {
+    const setup = await renderObserver();
+    const frame = setup.captureCharFrame();
+    expect(frame).toContain("· observer");
+    expect(frame).toContain("observer - read-only · j/k move");
+    expect(frame).not.toContain("⏎ submit");
+  });
+});
+
+describe("observer verbs are blocked", () => {
+  for (const [key, verb] of [
+    ["c", "comment"],
+    ["s", "suggest"],
+    ["x", "cut"],
+    ["e", "edit"],
+    ["enter", "submit"],
+  ] as const) {
+    test(`${verb} (${key}) answers observer - read-only and mutates nothing`, async () => {
+      const setup = await renderObserver();
+      const before = snapshot();
+      await press(setup, "j");
+      await press(setup, "j");
+      await press(setup, key);
+      await Bun.sleep(60);
+      await setup.renderOnce();
+      const frame = setup.captureCharFrame();
+      expect(frame).toContain("observer - read-only");
+      // no overlay opened: compose/submit bars never appear
+      expect(frame).not.toContain("COMMENT ON");
+      expect(frame).not.toContain("SUGGEST REPLACEMENT");
+      expect(frame).not.toContain("verdict ←/→");
+      expect(snapshot()).toEqual(before);
+    });
+  }
+
+  test("span mode c/s is blocked too", async () => {
+    const setup = await renderObserver();
+    await press(setup, "j");
+    await press(setup, "j");
+    await press(setup, "v");
+    await press(setup, "c");
+    await setup.renderOnce();
+    const frame = setup.captureCharFrame();
+    expect(frame).toContain("observer - read-only");
+    expect(frame).not.toContain("COMMENT ON");
+    expect(snapshot().annotations).toBe(0);
+  });
+});
+
+describe("observer navigation still works", () => {
+  test("j/k moves the cursor between blocks", async () => {
+    const setup = await renderObserver();
+    await press(setup, "j");
+    await press(setup, "j");
+    await setup.renderOnce();
+    const lines = setup.captureCharFrame().split("\n");
+    const cursorLine = lines.find((l) => l.includes("▎"))!;
+    expect(cursorLine).toContain("persists sessions");
+  });
+
+  test("n focuses annotations made by the controller", async () => {
+    server.core.sessionAnnotate(session.id, {
+      id: "a_obs1",
+      kind: "comment",
+      anchor: makeAnchor(parseBlocks(PLAN), 2, 0, 10),
+      body: "From the controller.",
+    });
+    const setup = await renderObserver();
+    await press(setup, "n");
+    await setup.renderOnce();
+    expect(setup.captureCharFrame()).toContain("▸ COMMENT");
+  });
+});

package/src/App.test.tsx

@@ -0,0 +1,217 @@
+/**
+ * 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";
+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";
+
+const PLAN = `# Migration Plan
+
+## Context
+
+The daemon persists sessions to disk atomically.
+
+## Steps
+
+- move the store
+- add recovery
+`;
+
+let home: string;
+let server: DaemonServer;
+let session: ReviewSession;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-app-"));
+  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" } },
+  });
+});
+afterEach(() => {
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderApp(sessionId?: string) {
+  const setup = await testRender(<App home={home} sessionId={sessionId ?? session.id} />, {
+    width: 120,
+    height: 32,
+  });
+  // let the async daemon connect + first fetch land
+  for (let i = 0; i < 40 && !setup.captureCharFrame().includes("cueloop"); i++) {
+    await Bun.sleep(25);
+    await setup.renderOnce();
+  }
+  await setup.renderOnce();
+  return setup;
+}
+
+type Setup = Awaited<ReturnType<typeof renderApp>>;
+
+/** Drive one key press: letters type as text; named keys use KeyCodes ids. */
+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 if (k === "backspace") setup.mockInput.pressKey("BACKSPACE");
+  else if (k === "left") setup.mockInput.pressKey("ARROW_LEFT");
+  else if (k === "right") setup.mockInput.pressKey("ARROW_RIGHT");
+  else await type(setup, k);
+  await Bun.sleep(15);
+  await setup.renderOnce();
+}
+
+async function type(setup: Setup, text: string): Promise<void> {
+  await setup.mockInput.typeText(text);
+  await Bun.sleep(15);
+  await setup.renderOnce();
+}
+
+describe("plan rendering", () => {
+  test("renders the plan with headings, list markers, and the rail", async () => {
+    const setup = await renderApp();
+    const frame = setup.captureCharFrame();
+    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 (0)");
+    expect(frame).toContain("Submit review (0)");
+  });
+});
+
+describe("keyboard grammar", () => {
+  test("j/k moves the cursor glyph between blocks", async () => {
+    const setup = await renderApp();
+    await press(setup, "j");
+    await press(setup, "j");
+    await setup.renderOnce();
+    const lines = setup.captureCharFrame().split("\n");
+    const cursorLine = lines.find((l) => l.includes("▎"))!;
+    expect(cursorLine).toContain("persists sessions");
+  });
+
+  test("comment flow: c types a body, ⏎ saves to the daemon", async () => {
+    const setup = await renderApp();
+    await press(setup, "j");
+    await press(setup, "j");
+    await press(setup, "c");
+    await setup.renderOnce();
+    expect(setup.captureCharFrame()).toContain("COMMENT ON");
+    await type(setup, "Define atomically.");
+    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]!.body).toBe("Define atomically.");
+    expect(setup.captureCharFrame()).toContain("COMMENT");
+  });
+
+  test("span mode: v + l selects words, c anchors the exact span", async () => {
+    const setup = await renderApp();
+    await press(setup, "j");
+    await press(setup, "j");
+    await press(setup, "v");
+    await press(setup, "l"); // "The daemon"
+    await press(setup, "c");
+    await type(setup, "Which daemon?");
+    await press(setup, "enter");
+    await Bun.sleep(80);
+    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 () => {
+    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 press(setup, "x");
+    await Bun.sleep(80);
+    await setup.renderOnce();
+    expect(server.core.sessionGet(session.id).workingCopy).not.toContain("move the store");
+    expect(setup.captureCharFrame()).toContain("[cut]");
+    await press(setup, "x");
+    await Bun.sleep(80);
+    await setup.renderOnce();
+    expect(server.core.sessionGet(session.id).workingCopy).toBeUndefined();
+  });
+
+  test("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`);
+    Bun.spawnSync(["chmod", "+x", script]);
+    process.env.CUELOOP_EDITOR = script;
+    try {
+      const setup = await renderApp();
+      await press(setup, "e");
+      await Bun.sleep(150);
+      await setup.renderOnce();
+      expect(server.core.sessionGet(session.id).workingCopy).toContain("very atomically");
+      expect(setup.captureCharFrame()).toContain("[edited]");
+    } finally {
+      delete process.env.CUELOOP_EDITOR;
+    }
+  });
+});
+
+describe("submit", () => {
+  test("⏎ opens the verdict bar; verdict + summary resolve the session", async () => {
+    const setup = await renderApp();
+    await press(setup, "j");
+    await press(setup, "j");
+    await press(setup, "c");
+    await type(setup, "Needs a phase list.");
+    await press(setup, "enter");
+    await Bun.sleep(80);
+    await press(setup, "enter"); // open submit
+    await setup.renderOnce();
+    expect(setup.captureCharFrame()).toContain("[Request changes]");
+    await type(setup, "Expand the steps.");
+    await press(setup, "enter");
+    await Bun.sleep(120);
+    await setup.renderOnce();
+    const stored = server.core.sessionGet(session.id);
+    expect(stored.status).toBe("resolved");
+    expect(stored.verdict!.kind).toBe("request_changes");
+    expect(stored.verdict!.feedback).toContain("Needs a phase list.");
+    expect(setup.captureCharFrame()).toContain("resolved: request changes");
+  });
+
+  test("approve via ←/→ verdict cycling", async () => {
+    const setup = await renderApp();
+    await press(setup, "enter");
+    await setup.renderOnce();
+    expect(setup.captureCharFrame()).toContain("[Approve]"); // no pending items → approve default
+    await press(setup, "enter");
+    await Bun.sleep(120);
+    expect(server.core.sessionGet(session.id).verdict!.kind).toBe("approve");
+  });
+});
+
+describe("inbox", () => {
+  test("inbox mode renders and opens a session", async () => {
+    const setup = await testRender(<App home={home} />, { width: 120, height: 32 });
+    for (let i = 0; i < 40 && !setup.captureCharFrame().includes("inbox"); i++) {
+      await Bun.sleep(25);
+      await setup.renderOnce();
+    }
+    expect(setup.captureCharFrame()).toContain("inbox (1 pending)");
+    expect(setup.captureCharFrame()).toContain("Migration Plan");
+    await press(setup, "enter");
+    await Bun.sleep(80);
+    await setup.renderOnce();
+    expect(setup.captureCharFrame()).toContain("Submit review (0)");
+  });
+});