@cueloop/client 0.1.0-alpha.66 → 0.1.0-alpha.67

package/src/keymap.test.ts

@@ -389,6 +389,7 @@ describe("diff mode", () => {
     ["v", [{ type: "status", message: "plan-only primitive - diff review uses c on a line" }]],
     ["x", [{ type: "rejectChange" }]],
     ["e", [{ type: "status", message: "plan-only primitive - diff review uses c on a line" }]],
+    ["s", [{ type: "toggleDiffView" }]],
     ["q", [{ type: "exit" }]],
   ];
 
@@ -490,31 +491,8 @@ describe("guided walk", () => {
   });
 });
 
-describe("review panel controls", () => {
-  const table: [string, Intent[]][] = [
-    ["b", [{ type: "cycleReviewPanel" }]],
-    ["]", [{ type: "resizeReviewPanel", direction: 1 }]],
-    ["[", [{ type: "resizeReviewPanel", direction: -1 }]],
-  ];
-
-  for (const view of ["plan", "diff"] as const) {
-    for (const [name, expected] of table) {
-      test(`${view} ${name} -> ${JSON.stringify(expected)}`, () => {
-        expect(reduceKey(state({ view }), key(name))).toEqual(expected);
-      });
-    }
-  }
-
-  test("observers may still collapse and resize the panel (it is view state, not a mutation)", () => {
-    // Arrange
-    const observer = state({ readOnly: true });
-
-    // Assert
-    expect(reduceKey(observer, key("b"))).toEqual([{ type: "cycleReviewPanel" }]);
-    expect(reduceKey(observer, key("]"))).toEqual([{ type: "resizeReviewPanel", direction: 1 }]);
-  });
-
-  test("span mode still owns b as a span primitive, not a panel cycle", () => {
+describe("span and walk own their keys", () => {
+  test("span mode owns b as a span primitive", () => {
     // Assert
     expect(reduceKey(state({ spanMode: true }), key("b"))).toEqual([
       { type: "spanKey", name: "b" },

package/src/keymap.ts

@@ -33,6 +33,9 @@ export type Intent =
   | { type: "rejectHunk" }
   | { type: "rejectChange" }
   | { type: "restoreCuration" }
+  | { type: "foldFile" }
+  | { type: "unfoldFile" }
+  | { type: "toggleDiffView" }
   | { type: "nextAnnotation" }
   | { type: "prevAnnotation" }
   | { type: "walkStart" }
@@ -48,8 +51,6 @@ export type Intent =
   | { type: "finishReview" }
   | { type: "optInAutoClose" }
   | { type: "dismissCompletion" }
-  | { type: "cycleReviewPanel" }
-  | { type: "resizeReviewPanel"; direction: -1 | 1 }
   | { type: "toggleTree" }
   | { type: "treeMove"; direction: -1 | 1 }
   | { type: "treeGo" }
@@ -151,14 +152,8 @@ export function reduceKey(state: KeyState, key: KeyInput, resolvedAction?: strin
   }
 
   if (state.view === "inbox") return inboxGrammar(state, name);
-  // span mode owns its single-letter keys (b slides the span back) before the
-  // review-panel controls claim them
+  // span mode owns its single-letter keys (b slides the span back)
   if (state.spanMode) return spanGrammar(state, name);
-  // the review panel rides both plan and diff reviews; collapsing and resizing
-  // are view state, so the read-only gate above lets them through
-  const reviewPanel = reviewPanelGrammar(action);
-
-  if (reviewPanel) return reviewPanel;
   if (state.view === "diff") return diffGrammar(state, action);
 
   return planGrammar(state, action, name);
@@ -258,15 +253,6 @@ function walkOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
   return [];
 }
 
-/** The review-panel controls: cycle the mode, widen and narrow the rail. */
-function reviewPanelGrammar(action: string | undefined): Intent[] | null {
-  if (action === "review_cycle") return [{ type: "cycleReviewPanel" }];
-  if (action === "review_wider") return [{ type: "resizeReviewPanel", direction: 1 }];
-  if (action === "review_narrower") return [{ type: "resizeReviewPanel", direction: -1 }];
-
-  return null;
-}
-
 function inboxGrammar(state: KeyState, name: string): Intent[] {
   if (!state.hasInboxItems) return [];
   if (name === "j" || name === "down") return [{ type: "inboxMove", to: "down" }];
@@ -301,6 +287,9 @@ function diffGrammar(state: KeyState, action: string | undefined): Intent[] {
 
     return [{ type: action === "reject_hunk" ? "rejectHunk" : "rejectChange" }];
   }
+  const viewToggle = viewToggleIntent(action);
+
+  if (viewToggle) return viewToggle;
   // restore un-does a curated-out rejection from the rail; same owner gate as reject
   if (action === "restore_curation") {
     if (state.resolved) return status("review submitted - read-only");
@@ -382,6 +371,16 @@ function navigationIntent(action: string | undefined): Intent[] | null {
   return null;
 }
 
+/** Ungated view toggles in the diff: right folds a file to its band, left unfolds it, s flips
+ *  unified/split (split lays out only when the Changes pane is zoomed). */
+function viewToggleIntent(action: string | undefined): Intent[] | null {
+  if (action === "collapse_file") return [{ type: "foldFile" }];
+  if (action === "expand_file") return [{ type: "unfoldFile" }];
+  if (action === "split_diff") return [{ type: "toggleDiffView" }];
+
+  return null;
+}
+
 /** Annotation navigation, deletion, and submit: one path for plan and diff. */
 function annotationCluster(state: KeyState, action: string | undefined): Intent[] | null {
   if (action === "next_annotation" || action === "prev_annotation") {

package/src/mark-runs.ts

@@ -0,0 +1,120 @@
+/**
+ * Mark geometry for an annotated line of text: which stretches are marked
+ * (a discussion span, a held selection) or carry the caret cell, the greedy
+ * word wrap into visual lines, and the printable-key test that starts a
+ * comment. Renderer-free, shared by the plan thread view and the diff sheet.
+ */
+
+import type { KeyEvent } from "@opentui/core";
+import { wordRanges } from "./thread-selection";
+
+export interface MarkRange {
+  start: number;
+  end: number;
+  /** The bare caret's single cell - a cursor, not yet a mark. */
+  caretOnly?: boolean;
+}
+
+export interface Run {
+  text: string;
+  marked: boolean;
+  caretOnly: boolean;
+}
+
+/** Split a block's text into plain/marked runs from the union of ranges. */
+export function runsFor(text: string, ranges: MarkRange[]): Run[] {
+  const cuts = new Set<number>([0, text.length]);
+
+  for (const range of ranges) {
+    cuts.add(Math.max(0, range.start));
+    cuts.add(Math.min(text.length, range.end));
+  }
+  const edges = [...cuts].toSorted((left, right) => left - right);
+  const runs: Run[] = [];
+
+  for (let index = 0; index < edges.length - 1; index++) {
+    const start = edges[index]!;
+    const end = edges[index + 1]!;
+
+    if (end <= start) continue;
+    const covering = ranges.filter((range) => range.start <= start && end <= range.end);
+    // the caret cell shows through a mark, so the head of a selection is visible
+    runs.push({
+      text: text.slice(start, end),
+      marked: covering.some((range) => range.caretOnly !== true),
+      caretOnly: covering.some((range) => range.caretOnly === true),
+    });
+  }
+
+  return runs.length > 0 ? runs : [{ text, marked: false, caretOnly: false }];
+}
+
+/** A visual line of a block: the char range of the block's text it shows. */
+export interface VisualLine {
+  start: number;
+  end: number;
+}
+
+/**
+ * Greedy word wrap into visual-line char ranges, so a comment card can slot
+ * in directly below the line its mark ends on (mid-paragraph when needed).
+ */
+export function wrapLines(text: string, width: number): VisualLine[] {
+  const lines: VisualLine[] = [];
+  let segmentStart = 0;
+
+  // hard breaks first: every visual line must be exactly one terminal row,
+  // or hit-testing and the mark geometry drift from what is painted
+  for (const segment of text.split("\n")) {
+    const segmentEnd = segmentStart + segment.length;
+
+    if (width <= 0 || segment.length <= width) {
+      lines.push({ start: segmentStart, end: segmentEnd });
+    } else {
+      // greedy word wrap inside the segment; the first line keeps its
+      // leading indentation, continuation lines start at a word
+      let lineStart = segmentStart;
+      let lineEnd = segmentStart;
+
+      for (const word of wordRanges(segment)) {
+        const wordStart = segmentStart + word.start;
+        const wordEnd = segmentStart + word.end;
+
+        if (wordEnd - lineStart > width && lineEnd > lineStart) {
+          lines.push({ start: lineStart, end: lineEnd });
+          lineStart = wordStart;
+        }
+        // a token wider than the line (a long identifier, a URL) breaks at the cell edge, so
+        // every visual line stays one terminal row and nothing is clipped away
+        while (wordEnd - lineStart > width) {
+          lines.push({ start: lineStart, end: lineStart + width });
+          lineStart += width;
+        }
+        lineEnd = wordEnd;
+      }
+      lines.push({ start: lineStart, end: Math.max(lineEnd, lineStart) });
+    }
+    segmentStart = segmentEnd + 1;
+  }
+
+  return lines;
+}
+
+/** The block's mark ranges clipped to one visual line, in that line's coordinates. */
+export function lineMarkRanges(ranges: MarkRange[], line: VisualLine): MarkRange[] {
+  return ranges
+    .map((range) => ({
+      start: Math.max(range.start, line.start) - line.start,
+      end: Math.min(range.end, line.end) - line.start,
+      caretOnly: range.caretOnly,
+    }))
+    .filter((range) => range.end > range.start);
+}
+
+/** A printable character: single-width input that should reach a composer. */
+export function printableSequence(key: KeyEvent): string | null {
+  const printable =
+    key.sequence && key.sequence.length === 1 && !key.ctrl && !key.meta && key.sequence >= " ";
+
+  return printable ? key.sequence : null;
+}

package/src/pty.ts

@@ -13,8 +13,10 @@ import { join } from "node:path";
 
 const DEFAULT_COLS = 80;
 const DEFAULT_ROWS = 24;
-/** How long the read loop sleeps when the child produced no output this tick. */
+/** Shortest read-loop sleep, used while the child is actively streaming - keeps output snappy. */
 const READ_IDLE_MS = 8;
+/** Longest read-loop sleep, reached after the child sits quiet - stops the loop burning a core at idle. */
+const READ_IDLE_MAX_MS = 100;
 const READ_BUFFER_BYTES = 4096;
 /** cueloop_pty_read's sentinel: the child has exited and its output is drained. */
 const CHILD_EXITED = -2;
@@ -200,11 +202,15 @@ class Pty implements IPty {
     if (this.reading) return;
     this.reading = true;
     const buffer = Buffer.allocUnsafe(READ_BUFFER_BYTES);
+    // consecutive empty reads; the idle sleep backs off exponentially so a quiet agent prompt
+    // ramps from an 8ms hot poll up to a 100ms idle poll instead of spinning a core forever
+    let idlePolls = 0;
 
     while (!this.closing) {
       const count = this.lib.cueloop_pty_read(this.handle, ptr(buffer), buffer.length);
 
       if (count > 0) {
+        idlePolls = 0;
         // Stream mode buffers a multibyte char split across reads (box-drawing etc.).
         const text = this.decoder.decode(buffer.subarray(0, count), { stream: true });
 
@@ -221,7 +227,9 @@ class Pty implements IPty {
         this.closing = true;
         this.exitEvent.fire({ exitCode });
       } else {
-        await new Promise((resolve) => setTimeout(resolve, READ_IDLE_MS));
+        const delay = Math.min(READ_IDLE_MAX_MS, READ_IDLE_MS * 2 ** Math.min(idlePolls, 5));
+        idlePolls += 1;
+        await new Promise((resolve) => setTimeout(resolve, delay));
       }
     }
   }

package/src/run.ts

@@ -21,18 +21,28 @@ export async function runClient(options: RunClientOptions): Promise<number> {
     (await renderer.waitForThemeMode(THEME_QUERY_TIMEOUT_MS).catch(() => null)) ?? "dark";
 
   return new Promise<number>((resolve) => {
+    let exited = false;
+    const shutdown = (code: number): void => {
+      if (exited) return;
+      exited = true;
+      renderer.destroy();
+      resolve(code);
+      // one microtask between destroy and exit lets the renderer flush
+      // its terminal-restore sequences before the process dies
+      queueMicrotask(() => process.exit(code));
+    };
+
+    // a closed pane/terminal hangs up (or the parent kills us); exit instead of
+    // lingering as an orphan whose pty read loop keeps burning CPU
+    process.once("SIGHUP", () => shutdown(0));
+    process.once("SIGTERM", () => shutdown(0));
+
     createRoot(renderer).render(
       React.createElement(App, {
         home: options.home,
         sessionId: options.sessionId,
         appearance,
-        onExit: (code: number) => {
-          renderer.destroy();
-          resolve(code);
-          // one microtask between destroy and exit lets the renderer flush
-          // its terminal-restore sequences before the process dies
-          queueMicrotask(() => process.exit(code));
-        },
+        onExit: shutdown,
       }),
     );
   });

package/src/serve.test.ts

@@ -84,18 +84,14 @@ describe("cueloop serve", () => {
     expect(existsSync(join(home, "ssh", "host_key"))).toBe(true);
   });
 
-  test("an anonymous ssh client gets the observer TUI for the session", async () => {
+  test("an anonymous ssh client gets the read-only TUI for the session", async () => {
     // Act
-    const bytes = await sshCapture(
-      handle.port,
-      (frame) => frame.includes("Rollout Plan") && frame.includes("observer"),
-    );
+    const bytes = await sshCapture(handle.port, (frame) => frame.includes("Rollout Plan"));
 
-    // Assert
+    // Assert - the viewer sees the session; read-only is enforced behaviorally
+    // (covered by the observer-primitives tests), not by a header badge
     expect(bytes).toContain("cueloop");
     expect(bytes).toContain("Rollout Plan");
-    // observer chrome: the header badge marks the read-only session
-    expect(bytes).toContain("observer");
   });
 
   test("two observers can watch at once", async () => {

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

@@ -114,6 +114,7 @@ function fakeClient(initial: ReviewSession, sink: WorkingCopySink): SessionClien
     sessionLabel: unimplemented("sessionLabel"),
     sessionFork: unimplemented("sessionFork"),
     sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: unimplemented("sessionSetShareId"),
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
@@ -360,3 +361,77 @@ describe("plan cut removals", () => {
     expect(sink.workingCopy).toBe("# Title\n");
   });
 });
+
+// a file whose hunk touches line 2 only, so lines 1/3/4 are unchanged tail/context
+const TAIL_PATCH = `diff --git a/src/store.ts b/src/store.ts
+--- a/src/store.ts
++++ b/src/store.ts
+@@ -2,1 +2,1 @@
+-  private items = [];
++  private items = new Map();
+`;
+
+function tailSession(): ReviewSession {
+  return {
+    ...diffSession(),
+    artifact: {
+      type: "diff",
+      content: TAIL_PATCH,
+      meta: {},
+      files: [
+        {
+          path: "src/store.ts",
+          oldContents: "export class Store {\n  private items = [];\n}\nexport const x = 1;\n",
+          newContents:
+            "export class Store {\n  private items = new Map();\n}\nexport const x = 1;\n",
+          status: "modified",
+        },
+      ],
+    },
+  };
+}
+
+describe("diff file fold", () => {
+  test("collapse leaves only the file band; expand restores the body", async () => {
+    // Arrange
+    const { controller } = await connected(tailSession());
+    const bodyRows = () =>
+      controller.rows().filter((row) => row.file === "src/store.ts" && row.kind !== "file").length;
+
+    // Assert - starts unfolded with a body
+    expect(bodyRows()).toBeGreaterThan(0);
+
+    // Act / Assert - collapse hides the body
+    controller.setFileCollapsed("src/store.ts", true);
+    expect(bodyRows()).toBe(0);
+    expect(controller.isFileCollapsed("src/store.ts")).toBe(true);
+
+    // Act / Assert - unfold brings it back
+    controller.setFileCollapsed("src/store.ts", false);
+    expect(bodyRows()).toBeGreaterThan(0);
+  });
+
+  test("expand weaves the file's unchanged tail line the hunk never showed", async () => {
+    // Arrange
+    const { controller } = await connected(tailSession());
+    const hasTail = () => controller.rows().some((row) => row.text.includes("export const x = 1"));
+
+    // Assert - the hunk view does not show the tail line
+    expect(controller.canExpandFile("src/store.ts")).toBe(true);
+    expect(hasTail()).toBe(false);
+
+    // Act - weave the full file
+    controller.setFileExpanded("src/store.ts", true);
+
+    // Assert
+    expect(hasTail()).toBe(true);
+  });
+
+  test("a diff without full contents cannot be expanded", async () => {
+    // Arrange - no artifact.files
+    const { controller } = await connected(diffSession(undefined));
+
+    // Assert
+    expect(controller.canExpandFile("src/store.ts")).toBe(false);
+  });
+});

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

@@ -78,6 +78,7 @@ function fakeClient(session: ReviewSession): FakeSessionClient {
     sessionLabel: unimplemented("sessionLabel"),
     sessionFork: unimplemented("sessionFork"),
     sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: mock(
       async (_id: string, shareId: string) => ((session.shareId = shareId), session),
     ),

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

@@ -91,6 +91,7 @@ function fakeClient(session: ReviewSession) {
       parentSessionId: id,
     })),
     sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: mock(async (_id: string, _shareId: string) => session),
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
@@ -116,6 +117,31 @@ async function connected(session = sessionFixture()) {
   return { controller, client, session };
 }
 
+describe("read-only guards", () => {
+  test("an observer's rename and delete never reach the daemon", async () => {
+    // Arrange - a read-only controller over a client whose mutations would throw
+    const session = sessionFixture();
+    const client = fakeClient(session);
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => client,
+      readOnly: true,
+      shareTransport,
+    });
+
+    controller.connect();
+    await tick();
+
+    // Act - the sidebar's rename and delete, invoked directly
+    controller.renameSession(session.id, "hijacked");
+    controller.deleteSession(session.id);
+    await tick();
+
+    // Assert - both answer read-only and the throwing client stubs were never called
+    expect(controller.getSnapshot().status).toBe("observer - read-only");
+  });
+});
+
 describe("tree primitives", () => {
   test("a move back shows the earlier path at once and asks the daemon for the same move", async () => {
     // Arrange