@cueloop/client 0.1.0-alpha.5 → 0.1.0-alpha.51

package/src/review-panel.ts

@@ -0,0 +1,83 @@
+/**
+ * Pure geometry and state for the resizable review panel. The panel shows the
+ * review rail in one of three modes and the expanded rail resizes within a
+ * clamp; App owns the React state and the mouse wiring, this module owns the
+ * arithmetic so the layout math stays unit-tested and out of the JSX. Bounds
+ * and the compact width carry over verbatim from the approved prototype.
+ */
+
+/** Expanded (full rail), compact (count + dots strip), or hidden (nothing). */
+export type ReviewPanelMode = "expanded" | "compact" | "hidden";
+
+/** Expanded-rail width bounds, in terminal columns. */
+export const REVIEW_MIN_WIDTH = 24;
+export const REVIEW_MAX_WIDTH = 50;
+export const REVIEW_DEFAULT_WIDTH = 34;
+/**
+ * Columns the plan/diff column keeps for itself: the expanded rail yields past
+ * this so a narrow terminal (or a wide persisted width) can never crowd the
+ * plan out to nothing - the whole reason the panel is resizable. On terminals
+ * wide enough for the full 50-col rail this bound never binds.
+ */
+export const REVIEW_PLAN_MIN_WIDTH = 30;
+/** The compact strip is a fixed narrow column: count on top, one dot per card. */
+export const REVIEW_COMPACT_WIDTH = 6;
+/** Keyboard resize step, in columns, for the widen/narrow keys. */
+export const REVIEW_RESIZE_STEP = 2;
+
+/** Round a desired width to a whole column and clamp it to the bounds. */
+export function clampWidth(
+  desiredWidth: number,
+  min = REVIEW_MIN_WIDTH,
+  max = REVIEW_MAX_WIDTH,
+): number {
+  return Math.max(min, Math.min(max, Math.round(desiredWidth)));
+}
+
+/**
+ * The widest the expanded rail may be on a given terminal, reserving the plan
+ * its minimum and one column for the divider. Never drops below REVIEW_MIN_WIDTH
+ * (an extremely narrow terminal is the auto-collapse case, handled elsewhere).
+ */
+export function maxWidthForTerminal(terminalWidth: number): number {
+  return Math.max(
+    REVIEW_MIN_WIDTH,
+    Math.min(REVIEW_MAX_WIDTH, terminalWidth - REVIEW_PLAN_MIN_WIDTH - 1),
+  );
+}
+
+/** Clamp a desired rail width to the bounds AND the terminal, so the plan keeps its room. */
+export function resolveReviewWidth(desiredWidth: number, terminalWidth: number): number {
+  return clampWidth(desiredWidth, REVIEW_MIN_WIDTH, maxWidthForTerminal(terminalWidth));
+}
+
+/** The keybinding cycle: expanded -> compact -> hidden -> expanded. */
+export function cycleReviewPanelMode(mode: ReviewPanelMode): ReviewPanelMode {
+  return mode === "expanded" ? "compact" : mode === "compact" ? "hidden" : "expanded";
+}
+
+/**
+ * The clickable chevron toggles only between expanded and compact - hidden is
+ * reachable by keybinding alone, so it never leaves a leftover tab behind. A
+ * toggle from hidden still opens the panel rather than doing nothing.
+ */
+export function toggleReviewPanelMode(mode: ReviewPanelMode): ReviewPanelMode {
+  return mode === "expanded" ? "compact" : "expanded";
+}
+
+/**
+ * Rail width from an absolute mouse column while dragging the divider: the rail
+ * spans from the mouse column to the terminal's right edge, then clamps.
+ */
+export function widthFromMouseColumn(mouseColumn: number, terminalWidth: number): number {
+  return resolveReviewWidth(terminalWidth - mouseColumn, terminalWidth);
+}
+
+/**
+ * The divider is a single-column stack of vertical glyphs (a text block, not a
+ * bordered box - a one-column box with a border renders a full box). One glyph
+ * per row, at least one so the column never collapses.
+ */
+export function reviewRowsToDivider(rows: number): string {
+  return Array.from({ length: Math.max(1, rows) }, () => "│").join("\n");
+}

package/src/run.ts

@@ -10,17 +10,21 @@ export interface RunClientOptions {
   home?: string;
 }
 
-export async function runClient(opts: RunClientOptions): Promise<number> {
-  const renderer = await createCliRenderer();
+export async function runClient(options: RunClientOptions): Promise<number> {
+  // mouse movement reporting makes multiplexers forward drags to the app,
+  // so the renderer's native selection is the drag driver
+  const renderer = await createCliRenderer({ enableMouseMovement: true });
   return new Promise<number>((resolve) => {
     createRoot(renderer).render(
       React.createElement(App, {
-        home: opts.home,
-        sessionId: opts.sessionId,
+        home: options.home,
+        sessionId: options.sessionId,
         onExit: (code: number) => {
           renderer.destroy();
           resolve(code);
-          process.exit(code);
+          // one microtask between destroy and exit lets the renderer flush
+          // its terminal-restore sequences before the process dies
+          queueMicrotask(() => process.exit(code));
         },
       }),
     );

package/src/serve.test.ts

@@ -38,7 +38,11 @@ afterEach(async () => {
 });
 
 /** Connect, open a PTY shell, resolve with the bytes seen until `until` matches. */
-function sshCapture(port: number, until: (s: string) => boolean, timeoutMs = 8000): Promise<string> {
+function sshCapture(
+  port: number,
+  until: (frame: string) => boolean,
+  timeoutMs = 8000,
+): Promise<string> {
   return new Promise((resolve, reject) => {
     const conn = new Client();
     let out = "";
@@ -48,15 +52,16 @@ function sshCapture(port: number, until: (s: string) => boolean, timeoutMs = 800
       done = true;
       clearTimeout(timer);
       conn.end();
-      err ? reject(err) : resolve(out);
+      if (err) reject(err);
+      else resolve(out);
     };
     const timer = setTimeout(() => finish(new Error(`timed out; captured:\n${out}`)), timeoutMs);
     conn
       .on("ready", () => {
         conn.shell({ term: "xterm-256color", cols: 100, rows: 30 }, (err, stream) => {
           if (err) return finish(err);
-          stream.on("data", (d: Buffer) => {
-            out += d.toString("utf8");
+          stream.on("data", (chunk: Buffer) => {
+            out += chunk.toString("utf8");
             if (until(out)) finish();
           });
           stream.on("close", () => finish(new Error(`stream closed early; captured:\n${out}`)));
@@ -70,6 +75,7 @@ function sshCapture(port: number, until: (s: string) => boolean, timeoutMs = 800
 
 describe("cueloop serve", () => {
   test("listens on localhost, persists a host key under CUELOOP_HOME/ssh", () => {
+    // Assert
     expect(handle.host).toBe("127.0.0.1");
     expect(handle.port).toBeGreaterThan(0);
     expect(handle.fingerprints.length).toBe(1);
@@ -78,18 +84,27 @@ describe("cueloop serve", () => {
   });
 
   test("an anonymous ssh client gets the observer TUI for the session", async () => {
-    const bytes = await sshCapture(handle.port, (s) => s.includes("Rollout Plan") && s.includes("observer"));
+    // Act
+    const bytes = await sshCapture(
+      handle.port,
+      (frame) => frame.includes("Rollout Plan") && frame.includes("observer"),
+    );
+
+    // Assert
     expect(bytes).toContain("cueloop");
     expect(bytes).toContain("Rollout Plan");
-    // observer chrome, not the controller's mutating hint bar
-    expect(bytes).toContain("observer - read-only");
+    // observer chrome: the header badge marks the read-only session
+    expect(bytes).toContain("observer");
   });
 
   test("two observers can watch at once", async () => {
+    // Act
     const [a, b] = await Promise.all([
-      sshCapture(handle.port, (s) => s.includes("Rollout Plan")),
-      sshCapture(handle.port, (s) => s.includes("Rollout Plan")),
+      sshCapture(handle.port, (frame) => frame.includes("Rollout Plan")),
+      sshCapture(handle.port, (frame) => frame.includes("Rollout Plan")),
     ]);
+
+    // Assert
     expect(a).toContain("Rollout Plan");
     expect(b).toContain("Rollout Plan");
   });

package/src/serve.ts

@@ -1,5 +1,5 @@
 /**
- * SSH-served TUI (#22 share path): `cueloop serve` lets teammates join a
+ * SSH-served TUI: `cueloop serve` lets teammates join a
  * review session over plain ssh. Every SSH connection renders <App> in
  * observer mode (readOnly) against the same local daemon; the one writable
  * controller stays the local owner's own `cueloop` TUI.
@@ -44,8 +44,8 @@ export interface ServeHandle {
   close(): Promise<void>;
 }
 
-export async function serveClient(opts: ServeOptions = {}): Promise<ServeHandle> {
-  const home = opts.home ?? cueloopHome();
+export async function serveClient(options: ServeOptions = {}): Promise<ServeHandle> {
+  const home = options.home ?? cueloopHome();
   const sshDir = join(home, "ssh");
   mkdirSync(sshDir, { recursive: true, mode: 0o700 });
 
@@ -53,15 +53,15 @@ export async function serveClient(opts: ServeOptions = {}): Promise<ServeHandle>
     // password-less by design; see the trust model in the module comment
     auth: "open",
     hostKey: { path: join(sshDir, "host_key") },
-    startupBanner: opts.banner ?? true,
+    startupBanner: options.banner ?? true,
     idleTimeout: "2h",
-    onError: opts.onError,
+    onError: options.onError,
   }).serve((session) => {
     const root = createRoot(session.renderer);
     root.render(
       React.createElement(App, {
         home,
-        sessionId: opts.sessionId,
+        sessionId: options.sessionId,
         readOnly: true,
         // q disconnects only this observer, never the server
         onExit: () => session.end(),
@@ -70,6 +70,6 @@ export async function serveClient(opts: ServeOptions = {}): Promise<ServeHandle>
     session.onClose(() => root.unmount());
   });
 
-  const info = await server.listen(opts.port ?? 2222, opts.host ?? "127.0.0.1");
+  const info = await server.listen(options.port ?? 2222, options.host ?? "127.0.0.1");
   return { ...info, close: () => server.close() };
 }

package/src/session-controller.curate.test.ts

@@ -0,0 +1,253 @@
+import { describe, expect, mock, test } from "bun:test";
+import { SCHEMA_VERSION, type DiffFileContents, type ReviewSession } from "@cueloop/schema";
+import type { SessionClient } from "@cueloop/daemon/client";
+import { createReviewController } from "./session-controller";
+
+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();
+ }
+`;
+
+const FILES: DiffFileContents[] = [
+  {
+    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",
+  },
+];
+
+function diffSession(files?: DiffFileContents[]): ReviewSession {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_diff",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "diff", content: PATCH, meta: {}, files },
+    revisions: [{ revision: 1, content: PATCH, submittedAt: "2026-01-01T00:00:00.000Z" }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+/** A fake client that records the working copy the controller writes. */
+function fakeClient(session: ReviewSession, sink: { workingCopy?: string }): SessionClient {
+  return {
+    onEvent: () => () => {},
+    subscribe: async () => {},
+    sessionGet: async () => session,
+    sessionList: async () => [session],
+    sessionSetWorkingCopy: mock(async (_id: string, content: string | undefined) => {
+      sink.workingCopy = content;
+      return { ...session, workingCopy: content };
+    }),
+    close: () => {},
+  } as unknown as SessionClient;
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+async function connected(session: ReviewSession) {
+  const sink: { workingCopy?: string } = {};
+  const client = fakeClient(session, sink);
+  const controller = createReviewController({
+    sessionId: session.id,
+    openClient: async () => client,
+  });
+  controller.connect();
+  await tick();
+  return { controller, client, sink };
+}
+
+// rows for PATCH: file(0), hunk(1), ctx(2), del(3), add(4), ctx(5)
+describe("diff hunk curation", () => {
+  test("rejecting the only change writes an empty curated working copy", async () => {
+    // Arrange
+    const { controller, sink } = await connected(diffSession(FILES));
+
+    // Act - reject the change on the added line
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert
+    expect(controller.getSnapshot().status).toContain("change rejected");
+    expect(sink.workingCopy).toBe("");
+  });
+
+  test("both the deletion and addition rows of the change dim", async () => {
+    // Arrange
+    const { controller } = await connected(diffSession(FILES));
+
+    // Act
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - the change spans the del row and the add row
+    expect([...controller.rejectedRows()].sort((a, b) => a - b)).toEqual([3, 4]);
+  });
+
+  test("toggling the same change twice restores the full diff", async () => {
+    // Arrange
+    const { controller, sink } = await connected(diffSession(FILES));
+
+    // Act - reject then restore
+    controller.toggleRejectChange(4);
+    await tick();
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - no decisions left, so the working copy reverts to undefined
+    expect(controller.getSnapshot().status).toContain("change restored");
+    expect(sink.workingCopy).toBeUndefined();
+    expect(controller.rejectedRows().size).toBe(0);
+  });
+
+  test("whole-hunk reject drops the hunk from the working copy", async () => {
+    // Arrange
+    const { controller, sink } = await connected(diffSession(FILES));
+
+    // Act - reject the whole hunk from any of its rows
+    controller.toggleRejectHunk(3);
+    await tick();
+
+    // Assert - the single hunk is the whole diff, so nothing remains
+    expect(controller.getSnapshot().status).toContain("hunk rejected");
+    expect(sink.workingCopy).toBe("");
+  });
+
+  test("a rejected change becomes a removal card with a source, id, and preview", async () => {
+    // Arrange
+    const { controller } = await connected(diffSession(FILES));
+
+    // Act
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - one item: diff source, revealing the change's row, both lines previewed
+    const items = controller.curationItems();
+    expect(items.length).toBe(1);
+    expect(items[0]!.source).toBe("diff");
+    expect(items[0]!.id).toBe("diff:src/store.ts#0#1");
+    expect(items[0]!.revealIndex).toBe(3);
+    expect(items[0]!.preview).toEqual([
+      "-   private items = [];",
+      "+   private items = new Map();",
+    ]);
+  });
+
+  test("a rejected hunk becomes a removal card with the whole-hunk id", async () => {
+    // Arrange
+    const { controller } = await connected(diffSession(FILES));
+
+    // Act
+    controller.toggleRejectHunk(3);
+    await tick();
+
+    // Assert - the whole hunk, id diff:path#hunk#hunk
+    const items = controller.curationItems();
+    expect(items.length).toBe(1);
+    expect(items[0]!.source).toBe("diff");
+    expect(items[0]!.id).toBe("diff:src/store.ts#0#hunk");
+  });
+
+  test("restoreCuration drops the diff removal and reverts the working copy", async () => {
+    // Arrange - one change rejected
+    const { controller, sink } = await connected(diffSession(FILES));
+    controller.toggleRejectChange(4);
+    await tick();
+    const [item] = controller.curationItems();
+
+    // Act
+    controller.restoreCuration(item!.id);
+    await tick();
+
+    // Assert - the list empties and the working copy reverts to the full diff
+    expect(controller.getSnapshot().status).toContain("removal restored");
+    expect(controller.curationItems().length).toBe(0);
+    expect(sink.workingCopy).toBeUndefined();
+    expect(controller.rejectedRows().size).toBe(0);
+  });
+
+  test("restoreCuration ignores an unknown id", async () => {
+    // Arrange - one change rejected
+    const { controller } = await connected(diffSession(FILES));
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Act
+    controller.restoreCuration("diff:nope#0#0");
+    await tick();
+
+    // Assert - the item stays
+    expect(controller.curationItems().length).toBe(1);
+  });
+
+  test("curation is disabled without full file contents", async () => {
+    // Arrange - a legacy diff with no artifact.files
+    const { controller, sink } = await connected(diffSession(undefined));
+
+    // Act
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert
+    expect(controller.getSnapshot().status).toContain("hunk curation needs full file contents");
+    expect(sink.workingCopy).toBeUndefined();
+  });
+});
+
+const PLAN_CONTENT = "# Title\n\nFirst paragraph.\n\nSecond paragraph.\n";
+// the working copy with the "Second paragraph." block cut out
+const PLAN_CUT = "# Title\n\nFirst paragraph.\n";
+
+function planSession(workingCopy?: string): ReviewSession {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_plan",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: PLAN_CONTENT, meta: {} },
+    revisions: [{ revision: 1, content: PLAN_CONTENT, submittedAt: "2026-01-01T00:00:00.000Z" }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    workingCopy,
+  };
+}
+
+describe("plan cut removals", () => {
+  test("a cut block becomes a plan removal card previewing its content", async () => {
+    // Arrange - a plan whose working copy dropped the second paragraph
+    const { controller } = await connected(planSession(PLAN_CUT));
+
+    // Act
+    const items = controller.curationItems();
+
+    // Assert - one plan-source removal, keyed on the base line range, content previewed
+    expect(items.length).toBe(1);
+    expect(items[0]!.source).toBe("plan");
+    expect(items[0]!.id).toBe("plan:4-4");
+    expect(items[0]!.preview).toEqual(["Second paragraph."]);
+  });
+
+  test("restoreCuration re-inserts the cut block and returns to pristine", async () => {
+    // Arrange
+    const { controller, sink } = await connected(planSession(PLAN_CUT));
+    const [item] = controller.curationItems();
+
+    // Act
+    controller.restoreCuration(item!.id);
+    await tick();
+
+    // Assert - restoring the only cut round-trips to the submitted revision
+    expect(controller.getSnapshot().status).toContain("removal restored");
+    expect(sink.workingCopy).toBeUndefined();
+  });
+});