@cueloop/client 0.1.0-alpha.4 → 0.1.0-alpha.41

package/native/build.sh

@@ -0,0 +1,56 @@
+#!/bin/sh
+# Rebuild libcueloopvt.dylib: libghostty-vt (Ghostty's VT core) statically linked
+# behind the flat FFI shim in src/shim.c. Pinned to a Ghostty commit + Zig 0.16.0.
+# Output lands in native/<os>-<arch>/libcueloopvt.dylib. Requires curl, git, clang.
+set -eu
+
+GHOSTTY_COMMIT="5834a0e3df621802e9578e4562d88b0c2ad4ada8"
+ZIG_VERSION="0.16.0"
+
+here="$(cd "$(dirname "$0")" && pwd)"
+work="${TMPDIR:-/tmp}/cueloop-libghostty-build"
+mkdir -p "$work"
+cd "$work"
+
+# host triple for the prebuilt dir + zig download
+arch="$(uname -m)"; os="$(uname -s | tr '[:upper:]' '[:lower:]')"
+case "$os" in darwin) zig_os="macos"; dylib="libcueloopvt.dylib";; linux) zig_os="linux"; dylib="libcueloopvt.so";; *) echo "unsupported os $os" >&2; exit 1;; esac
+outdir="$here/${os}-${arch}"
+
+if [ ! -x "zig-$arch-$zig_os-$ZIG_VERSION/zig" ]; then
+  echo "== fetching zig $ZIG_VERSION =="
+  curl -sSL -o zig.tar.xz "https://ziglang.org/download/$ZIG_VERSION/zig-$arch-$zig_os-$ZIG_VERSION.tar.xz"
+  tar -xf zig.tar.xz
+fi
+zig="$work/zig-$arch-$zig_os-$ZIG_VERSION/zig"
+
+if [ ! -d ghostty ]; then
+  echo "== cloning ghostty @ $GHOSTTY_COMMIT =="
+  mkdir ghostty && cd ghostty && git init -q
+  git remote add origin https://github.com/ghostty-org/ghostty.git
+  git fetch -q --depth 1 origin "$GHOSTTY_COMMIT"
+  git checkout -q FETCH_HEAD
+  cd ..
+fi
+
+echo "== building libghostty-vt (ReleaseFast) =="
+cd ghostty
+# The final xcframework packaging step can fail while the .a we need is produced,
+# so tolerate a non-zero exit here but assert the static lib exists below.
+ZIG_GLOBAL_CACHE_DIR="$work/zig-gcache" ZIG_LOCAL_CACHE_DIR="$work/zig-lcache" \
+  "$zig" build -Demit-lib-vt -Doptimize=ReleaseFast --prefix "$work/vt-install" || true
+cd ..
+staticlib="$work/vt-install/lib/libghostty-vt.a"
+[ -f "$staticlib" ] || { echo "build failed: $staticlib not produced" >&2; exit 1; }
+
+echo "== linking shim -> $outdir/$dylib =="
+mkdir -p "$outdir"
+if [ "$os" = "darwin" ]; then
+  clang -O2 -dynamiclib -o "$outdir/$dylib" "$here/src/shim.c" \
+    -I"$work/vt-install/include" "$staticlib" \
+    -framework CoreFoundation -framework CoreText -framework CoreGraphics
+else
+  clang -O2 -shared -fPIC -o "$outdir/$dylib" "$here/src/shim.c" \
+    -I"$work/vt-install/include" "$staticlib" -lm -lpthread
+fi
+echo "== done: $outdir/$dylib =="

package/native/src/shim.c

@@ -0,0 +1,107 @@
+// Flat, FFI-trivial wrapper over libghostty-vt: hides the allocator vtable, the
+// by-value GhosttyPoint (which bun:ffi cannot pass), and the packed-cell decode,
+// exposing exactly what an OpenTUI paint loop needs - new/write/resize/cell/free.
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <string.h>
+#include "ghostty/vt/types.h"
+#include "ghostty/vt/allocator.h"
+#include "ghostty/vt/terminal.h"
+#include "ghostty/vt/point.h"
+#include "ghostty/vt/grid_ref.h"
+#include "ghostty/vt/screen.h"
+#include "ghostty/vt/style.h"
+#include "ghostty/vt/color.h"
+
+typedef struct {
+  uint32_t codepoint;    // 0 = blank
+  uint8_t fg_r, fg_g, fg_b, fg_kind;  // kind: 0 default, 1 palette (index in fg_r), 2 rgb
+  uint8_t bg_r, bg_g, bg_b, bg_kind;
+  uint8_t width;         // 0 (wide trailing), 1, 2
+  uint8_t flags;         // bit0 bold, 1 italic, 2 underline, 3 inverse, 4 faint, 5 strikethrough
+  uint16_t _pad;
+} CvtCell;
+
+void *cvt_new(uint16_t cols, uint16_t rows) {
+  GhosttyTerminal t = NULL;
+  // NULL allocator selects libghostty's default (libc malloc/free when linked).
+  if (ghostty_terminal_new(NULL, &t, cols, rows) != GHOSTTY_SUCCESS) return NULL;
+  return (void *)t;
+}
+
+void cvt_free(void *t) {
+  if (t) ghostty_terminal_free((GhosttyTerminal)t);
+}
+
+void cvt_write(void *t, const uint8_t *data, size_t len) {
+  ghostty_terminal_vt_write((GhosttyTerminal)t, data, len);
+}
+
+void cvt_resize(void *t, uint16_t cols, uint16_t rows) {
+  // cell pixel size is irrelevant to the character grid; pass a nominal 1x1.
+  ghostty_terminal_resize((GhosttyTerminal)t, cols, rows, 1, 1);
+}
+
+// Writes cursor state into out8: [0..1] col (u16), [2..3] row (u16), [4] visible (u8).
+void cvt_cursor(void *t, uint8_t *out8) {
+  uint16_t cx = 0, cy = 0;
+  bool vis = false;
+  ghostty_terminal_get((GhosttyTerminal)t, GHOSTTY_TERMINAL_DATA_CURSOR_X, &cx);
+  ghostty_terminal_get((GhosttyTerminal)t, GHOSTTY_TERMINAL_DATA_CURSOR_Y, &cy);
+  ghostty_terminal_get((GhosttyTerminal)t, GHOSTTY_TERMINAL_DATA_CURSOR_VISIBLE, &vis);
+  memcpy(out8, &cx, 2);
+  memcpy(out8 + 2, &cy, 2);
+  out8[4] = vis ? 1 : 0;
+}
+
+static void decode_color(const GhosttyStyleColor *c, uint8_t *r, uint8_t *g, uint8_t *b,
+                         uint8_t *kind) {
+  if (c->tag == GHOSTTY_STYLE_COLOR_RGB) {
+    *kind = 2;
+    *r = c->value.rgb.r;
+    *g = c->value.rgb.g;
+    *b = c->value.rgb.b;
+  } else if (c->tag == GHOSTTY_STYLE_COLOR_PALETTE) {
+    *kind = 1;
+    *r = (uint8_t)c->value.palette;  // palette index in r; JS maps 0-255 -> RGB
+    *g = 0;
+    *b = 0;
+  } else {
+    *kind = 0;
+  }
+}
+
+// Reads the viewport cell at (x, y). Returns 0 on success, -1 otherwise.
+int cvt_cell(void *t, uint16_t x, uint32_t y, CvtCell *out) {
+  memset(out, 0, sizeof(*out));
+  GhosttyPoint p;
+  p.tag = GHOSTTY_POINT_TAG_VIEWPORT;
+  p.value.coordinate.x = x;
+  p.value.coordinate.y = y;
+  GhosttyGridRef ref;
+  if (ghostty_terminal_grid_ref((GhosttyTerminal)t, p, &ref) != GHOSTTY_SUCCESS) return -1;
+  GhosttyCell cell;
+  if (ghostty_grid_ref_cell(&ref, &cell) != GHOSTTY_SUCCESS) return -1;
+  uint32_t cp = 0;
+  ghostty_cell_get(cell, GHOSTTY_CELL_DATA_CODEPOINT, &cp);
+  out->codepoint = cp;
+  uint32_t wide = 0;
+  ghostty_cell_get(cell, GHOSTTY_CELL_DATA_WIDE, &wide);
+  out->width = (uint8_t)wide;
+  GhosttyStyle st;
+  ghostty_style_default(&st);
+  if (ghostty_grid_ref_style(&ref, &st) == GHOSTTY_SUCCESS) {
+    decode_color(&st.fg_color, &out->fg_r, &out->fg_g, &out->fg_b, &out->fg_kind);
+    decode_color(&st.bg_color, &out->bg_r, &out->bg_g, &out->bg_b, &out->bg_kind);
+    uint8_t f = 0;
+    if (st.bold) f |= 1;
+    if (st.italic) f |= 2;
+    if (st.underline) f |= 4;
+    if (st.inverse) f |= 8;
+    if (st.faint) f |= 16;
+    if (st.strikethrough) f |= 32;
+    out->flags = f;
+  }
+  return 0;
+}

package/package.json

@@ -1,40 +1,50 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.41",
+  "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail",
+  "homepage": "https://github.com/mmurakaru/cueloop#readme",
+  "bugs": {
+    "url": "https://github.com/mmurakaru/cueloop/issues"
+  },
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mmurakaru/cueloop.git",
+    "directory": "packages/client"
+  },
+  "files": [
+    "src",
+    "native",
+    "README.md"
+  ],
   "type": "module",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./config": "./src/config.ts"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.4",
-    "@cueloop/extension-api": "0.1.0-alpha.4",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.4",
-    "@cueloop/schema": "0.1.0-alpha.4",
-    "@opentui/core": "^0.4.3",
-    "@opentui/react": "^0.4.3",
+    "@cueloop/daemon": "0.1.0-alpha.41",
+    "@cueloop/extension-api": "0.1.0-alpha.41",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.41",
+    "@cueloop/schema": "0.1.0-alpha.41",
+    "@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"
+    "bun-pty": "^0.4.10",
+    "diff": "^8",
+    "react": "^19.2.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.0",
-    "ssh2": "^1.17.0",
-    "@types/ssh2": "^1.15.5"
+    "@types/ssh2": "^1.15.5",
+    "ssh2": "^1.17.0"
   },
-  "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.autoclose.test.tsx

@@ -0,0 +1,137 @@
+/** 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 { isolateUserConfig, 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 restoreUserConfig: () => void;
+let clock: ManualClock;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-close-"));
+  configPath = join(home, "config.toml");
+  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(() => {
+  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} 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 { isolateUserConfig, press, waitForText } from "./test-support";
 
 const PATCH = `diff --git a/src/store.ts b/src/store.ts
 index 111..222 100644
@@ -22,11 +23,13 @@ index 111..222 100644
 `;
 
 let home: string;
+let restoreUserConfig: () => void;
 let server: DaemonServer;
 let session: ReviewSession;
 
 beforeEach(() => {
   home = mkdtempSync(join(tmpdir(), "cueloop-diff-"));
+  restoreUserConfig = isolateUserConfig(home);
   server = new DaemonServer({ home, idleExitMs: 0 });
   server.start();
   session = server.core.sessionCreate({
@@ -35,31 +38,26 @@ 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();
+  const setup = await testRender(<App home={home} sessionId={session.id} />, {
+    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 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 +66,170 @@ 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 () => {
+  test("curation needs full file contents; a legacy diff answers", async () => {
+    // Arrange - the session carries no artifact.files
     const setup = await renderApp();
+
+    // Act
+    await press(setup, "x");
+
+    // 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 testRender(<App home={home} sessionId={withFiles.id} />, {
+      width: 120,
+      height: 30,
+    });
+    await waitForText(setup, "cueloop");
+
+    // Act - move to the added line and reject its change
+    // 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, "x");
-    expect(setup.captureCharFrame()).toContain("plan-only verb");
+
+    // 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 rejected change lists in the rail and undo (u) restores it", 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 testRender(<App home={home} sessionId={withFiles.id} />, {
+      width: 120,
+      height: 30,
+    });
+    await waitForText(setup, "cueloop");
+
+    // Act - reject the change under the added line
+    // 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, "x");
+
+    // Assert - the rail shows a removal card titled REJECT · me for the change
+    await waitForText(setup, "REJECT · me");
+    expect(server.core.sessionGet(withFiles.id).workingCopy).toBe("");
+
+    // Act - undo restores it (no selection, so the last item)
+    await press(setup, "u");
+
+    // Assert - the change returns to the curated diff (working copy cleared)
+    await waitForText(setup, "removal restored");
+    expect(server.core.sessionGet(withFiles.id).workingCopy).toBeUndefined();
+  });
+
+  test("a selected removal card shows an undo button that restores it on click", 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 testRender(<App home={home} sessionId={withFiles.id} />, {
+      width: 120,
+      height: 30,
+    });
+    await waitForText(setup, "cueloop");
+
+    // Act - reject the change; the removal card lands unselected (no undo button)
+    for (let i = 0; i < 4; i++) await press(setup, "j");
+    await press(setup, "x");
+    await waitForText(setup, "REJECT · me");
+    expect(setup.captureCharFrame()).not.toContain("undo");
+
+    // Act - click the card to select it; the undo button appears
+    const clickText = async (needle: string): Promise<void> => {
+      const lines = setup.captureCharFrame().split("\n");
+      const row = lines.findIndex((line) => line.includes(needle));
+      await setup.mockMouse.click(lines[row]!.indexOf(needle) + 1, row);
+    };
+    await clickText("REJECT · me");
+    await waitForText(setup, "undo");
+
+    // Act - click the undo button
+    await clickText("undo");
+
+    // Assert - the change returns to the curated diff (working copy cleared)
+    await waitForText(setup, "removal restored");
+    expect(server.core.sessionGet(withFiles.id).workingCopy).toBeUndefined();
   });
 });