@cueloop/client 0.1.0-alpha.77 → 0.1.0-alpha.78

package/src/pasted-image.ts

@@ -0,0 +1,60 @@
+/** Detects an image or other binary paste so a composer shows an [Image #n] placeholder instead of dumping raw bytes into the draft. */
+
+const IMAGE_MAGIC_SIGNATURES: number[][] = [
+  [0x89, 0x50, 0x4e, 0x47], // PNG
+  [0xff, 0xd8, 0xff], // JPEG
+  [0x47, 0x49, 0x46, 0x38], // GIF87a / GIF89a
+];
+
+const CONTROL_RATIO_THRESHOLD = 0.15;
+const PASTE_DECODER = new TextDecoder("utf-8", { fatal: false });
+
+function hasImageMagic(bytes: Uint8Array): boolean {
+  for (const signature of IMAGE_MAGIC_SIGNATURES) {
+    if (signature.every((byte, index) => bytes[index] === byte)) return true;
+  }
+
+  const isRiffWebp =
+    bytes.length >= 12 &&
+    bytes[0] === 0x52 && // R
+    bytes[1] === 0x49 && // I
+    bytes[2] === 0x46 && // F
+    bytes[3] === 0x46 && // F
+    bytes[8] === 0x57 && // W
+    bytes[9] === 0x45 && // E
+    bytes[10] === 0x42 && // B
+    bytes[11] === 0x50; // P
+
+  return isRiffWebp;
+}
+
+function isControlCodePoint(codePoint: number): boolean {
+  if (codePoint === 0x09 || codePoint === 0x0a || codePoint === 0x0d) return false;
+
+  return codePoint < 0x20 || codePoint === 0x7f;
+}
+
+/** True when a paste is an image or other non-text binary payload and should collapse to a placeholder. */
+export function looksLikeBinaryPaste(bytes: Uint8Array): boolean {
+  if (bytes.length === 0) return false;
+  if (hasImageMagic(bytes)) return true;
+
+  const decoded = PASTE_DECODER.decode(bytes);
+  let controlCount = 0;
+  let total = 0;
+
+  for (const character of decoded) {
+    total += 1;
+    const codePoint = character.codePointAt(0) ?? 0;
+
+    if (codePoint === 0 || codePoint === 0xfffd) return true;
+    if (isControlCodePoint(codePoint)) controlCount += 1;
+  }
+
+  return total > 0 && controlCount / total > CONTROL_RATIO_THRESHOLD;
+}
+
+/** The draft placeholder for the nth image pasted into a composer: [Image #1], [Image #2], … */
+export function imagePlaceholder(index: number): string {
+  return `[Image #${index}]`;
+}

package/src/run.ts

@@ -4,6 +4,7 @@ import React from "react";
 import { createCliRenderer } from "@opentui/core";
 import { createRoot } from "@opentui/react";
 import { App } from "./App";
+import type { Appearance } from "./theme-presets";
 import { loadConfig } from "./config";
 import { perfMark } from "./perf/perf-timings";
 import { reportPerfMarks } from "./perf/perf-report";
@@ -38,12 +39,6 @@ export async function runClient(options: RunClientOptions): Promise<number> {
     renderer.useMouse = false;
     renderer.useMouse = true;
   });
-  // block first paint on the theme query only briefly, so an answering terminal paints its real theme
-  // with no flash while a non-answering one falls back to dark within the budget
-  const appearance =
-    (await renderer.waitForThemeMode(THEME_QUERY_TIMEOUT_MS).catch(() => null)) ?? "dark";
-  perfMark("themeQuery");
-
   return new Promise<number>((resolve) => {
     let exited = false;
     const shutdown = (code: number): void => {
@@ -61,19 +56,36 @@ export async function runClient(options: RunClientOptions): Promise<number> {
     process.once("SIGHUP", () => shutdown(0));
     process.once("SIGTERM", () => shutdown(0));
 
-    createRoot(renderer).render(
-      React.createElement(App, {
-        home: options.home,
-        sessionId: options.sessionId,
-        appearance,
-        layout,
-        onExit: shutdown,
-        onReady: () => {
-          perfMark("firstFrame");
-          reportPerfMarks("startup");
-        },
-      }),
-    );
+    const root = createRoot(renderer);
+    const renderApp = (appearance: Appearance): void => {
+      root.render(
+        React.createElement(App, {
+          home: options.home,
+          sessionId: options.sessionId,
+          appearance,
+          layout,
+          onExit: shutdown,
+          onReady: () => {
+            perfMark("firstFrame");
+            reportPerfMarks("startup");
+          },
+        }),
+      );
+    };
+
+    // Paint immediately with the default appearance; the OSC theme query resolves off the
+    // first-paint path and upgrades the theme in place when the terminal answers, so launch
+    // never blocks on it. A non-answering terminal simply stays dark.
+    renderApp("dark");
     perfMark("render");
+
+    void renderer
+      .waitForThemeMode(THEME_QUERY_TIMEOUT_MS)
+      .then((mode) => {
+        perfMark("themeQuery");
+        // the query can answer after a fast quit; never render onto a destroyed renderer
+        if (!exited && mode && mode !== "dark") renderApp(mode);
+      })
+      .catch(() => {});
   });
 }

package/src/serve.ts

@@ -1,6 +1,6 @@
 /**
  * SSH-served TUI: `cueloop serve` lets teammates join a
- * review session over plain ssh. Every SSH connection renders <App> in
+ * thread 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.
  *

package/src/share.ts

@@ -1,5 +1,5 @@
 /**
- * Publish a review session as a share: pack it, stream it to the gateway's
+ * Publish a thread as a share: pack it, stream it to the gateway's
  * `share` user over SSH, and copy the returned `ssh p_…@host` line to the
  * clipboard. The planner holds no key, so all this side does is upload; the
  * gateway seals and stores. Used by both `cueloop share` and the in-TUI

package/src/slash-palette.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import {
   activeSlashToken,
+  insertSlashItem,
   isStandaloneSlashQuery,
   scoreMatch,
   slashFilter,
@@ -84,3 +85,19 @@ describe("isStandaloneSlashQuery", () => {
     expect(isStandaloneSlashQuery("just prose")).toBe(false);
   });
 });
+
+describe("insertSlashItem", () => {
+  test("replaces the active slash token with the reference and lands the caret after it", () => {
+    const result = insertSlashItem("look at /rev", 12, "review");
+
+    expect(result.text).toBe("look at /review ");
+    expect(result.caret).toBe("look at /review ".length);
+  });
+
+  test("keeps text after the caret intact", () => {
+    const result = insertSlashItem("/pl tail", 3, "plan");
+
+    expect(result.text).toBe("/plan  tail");
+    expect(result.caret).toBe("/plan ".length);
+  });
+});

package/src/slash-palette.ts

@@ -86,6 +86,17 @@ export function isStandaloneSlashQuery(text: string): boolean {
   return /^\/\S*$/.test(text.trim());
 }
 
+export function insertSlashItem(text: string, caret: number, itemName: string) {
+  const token = activeSlashToken(text, caret) ?? "";
+  const cut = caret - token.length;
+  const insertion = `/${itemName} `;
+
+  return {
+    text: text.slice(0, cut) + insertion + text.slice(caret),
+    caret: cut + insertion.length,
+  };
+}
+
 /**
  * The character ranges of every completed "/name" in the draft that names a real
  * action or skill, so a surface can paint the references. A half-typed "/na" is

package/src/thread-controller.derivation.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
+import { sameDerivationInputs } from "./thread-controller";
+
+function threadFixture(overrides: Partial<Thread> = {}): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n\nShip it.\n", meta: {} },
+    revisions: [
+      { revision: 1, content: "# Plan\n\nShip it.\n", submittedAt: "2026-01-01T00:00:00.000Z" },
+    ],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+const annotation: Annotation = {
+  id: "ann_1",
+  kind: "comment",
+  anchor: { quote: "Ship it.", prefix: "", suffix: "" },
+  body: "nit",
+  createdAt: "2026-01-01T00:00:00.000Z",
+};
+
+describe("sameDerivationInputs", () => {
+  test("an annotation-only update reuses the projection (a fresh record, identical inputs)", () => {
+    // Arrange - the daemon re-serializes the whole thread on any change, so the record is all-new
+    const before = threadFixture();
+    const after = threadFixture({ annotations: [annotation] });
+
+    // Assert - the artifact and working copy are unchanged, so the projection can be reused
+    expect(sameDerivationInputs(before, after)).toBe(true);
+  });
+
+  test("a content edit forces a re-derivation", () => {
+    const before = threadFixture();
+    const after = threadFixture({
+      artifact: { type: "plan", content: "# Plan\n\nShip it soon.\n", meta: {} },
+    });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+
+  test("a working-copy change forces a re-derivation", () => {
+    const before = threadFixture();
+    const after = threadFixture({ workingCopy: "# Plan\n\nShip it.\n\nedited\n" });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+
+  test("a different thread is never a reuse", () => {
+    const before = threadFixture();
+    const after = threadFixture({ id: "ses_2" });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+});

package/src/thread-controller.optimistic.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
+import { withAnnotationUpserted } from "./thread-controller";
+
+function threadFixture(annotations: Annotation[] = []): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n\nShip it.\n", meta: {} },
+    revisions: [
+      { revision: 1, content: "# Plan\n\nShip it.\n", submittedAt: "2026-01-01T00:00:00.000Z" },
+    ],
+    annotations,
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+const existing: Annotation = {
+  id: "ann_1",
+  kind: "comment",
+  anchor: { quote: "Ship it.", prefix: "", suffix: "" },
+  body: "first",
+  createdAt: "2026-01-01T00:00:00.000Z",
+};
+
+describe("withAnnotationUpserted", () => {
+  test("a new comment is appended so it paints immediately", () => {
+    // Arrange
+    const session = threadFixture([existing]);
+    const wire = { id: "ann_2", kind: "comment", anchor: existing.anchor, body: "second" };
+
+    // Act
+    const next = withAnnotationUpserted(session, wire);
+
+    // Assert
+    expect(next.annotations.map((entry) => entry.id)).toEqual(["ann_1", "ann_2"]);
+    expect(next.annotations[1]!.body).toBe("second");
+    expect(next.annotations[1]!.createdAt).not.toBe("");
+  });
+
+  test("an edit replaces the note in place and keeps its timestamp", () => {
+    // Arrange
+    const session = threadFixture([existing]);
+    const wire = { id: "ann_1", kind: "comment", anchor: existing.anchor, body: "edited" };
+
+    // Act
+    const next = withAnnotationUpserted(session, wire);
+
+    // Assert - same position, same createdAt, new body (no reorder or timestamp flash)
+    expect(next.annotations.map((entry) => entry.id)).toEqual(["ann_1"]);
+    expect(next.annotations[0]!.body).toBe("edited");
+    expect(next.annotations[0]!.createdAt).toBe(existing.createdAt);
+  });
+
+  test("the input session is not mutated", () => {
+    // Arrange
+    const session = threadFixture([existing]);
+    const wire = { id: "ann_2", kind: "comment", anchor: existing.anchor, body: "second" };
+
+    // Act
+    withAnnotationUpserted(session, wire);
+
+    // Assert
+    expect(session.annotations).toHaveLength(1);
+  });
+});

package/src/thread-controller.switch-cache.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, mock, test } from "bun:test";
+import {
+  SCHEMA_VERSION,
+  type DiffFileContents,
+  type HunkRejection,
+  type Thread,
+} from "@cueloop/schema";
+import { curateDiff } from "@cueloop/daemon/curate";
+import type { SessionClient } from "@cueloop/daemon/client";
+import { createReviewController } from "./thread-controller";
+
+const PATCH_A = `diff --git a/src/a.ts b/src/a.ts
+index 111..222 100644
+--- a/src/a.ts
++++ b/src/a.ts
+@@ -1,3 +1,3 @@
+ export class A {
+-  value = 1;
++  value = 2;
+ }
+`;
+
+const PATCH_B = `diff --git a/src/b.ts b/src/b.ts
+index 333..444 100644
+--- a/src/b.ts
++++ b/src/b.ts
+@@ -1,3 +1,3 @@
+ export class B {
+-  flag = false;
++  flag = true;
+ }
+`;
+
+function diffSession(id: string, patch: string, files: DiffFileContents[]): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "diff", content: patch, meta: { title: id }, 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",
+  };
+}
+
+const FILES_A: DiffFileContents[] = [
+  {
+    path: "src/a.ts",
+    oldContents: "export class A {\n  value = 1;\n}\n",
+    newContents: "export class A {\n  value = 2;\n}\n",
+    status: "modified",
+  },
+];
+const FILES_B: DiffFileContents[] = [
+  {
+    path: "src/b.ts",
+    oldContents: "export class B {\n  flag = false;\n}\n",
+    newContents: "export class B {\n  flag = true;\n}\n",
+    status: "modified",
+  },
+];
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
+/** A fake client over a fixed set of sessions, so open(id) can switch between them from the inbox. */
+function fakeClient(sessions: Thread[]): SessionClient {
+  const byId = new Map(sessions.map((session) => [session.id, session]));
+
+  return {
+    onEvent: () => () => {},
+    subscribe: async () => {},
+    sessionGet: async (id: string) => byId.get(id)!,
+    sessionList: async () => [...byId.values()],
+    sessionCurate: mock(async (id: string, rejections: HunkRejection[]) => {
+      const session = byId.get(id)!;
+      const content = rejections.length
+        ? curateDiff(session.artifact.files!, rejections)
+        : undefined;
+      const next = {
+        ...session,
+        workingCopy: content,
+        curation: rejections.length ? rejections : undefined,
+      };
+
+      byId.set(id, next);
+
+      return next;
+    }),
+    sessionComment: unimplemented("sessionComment"),
+    sessionAnnotate: unimplemented("sessionAnnotate"),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
+    sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
+    sessionCutBlock: unimplemented("sessionCutBlock"),
+    sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
+    sessionSetAccess: unimplemented("sessionSetAccess"),
+    sessionNavigate: unimplemented("sessionNavigate"),
+    sessionBranch: unimplemented("sessionBranch"),
+    sessionSwitch: unimplemented("sessionSwitch"),
+    sessionLabel: unimplemented("sessionLabel"),
+    sessionFork: unimplemented("sessionFork"),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
+    sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionResolve: unimplemented("sessionResolve"),
+    close: () => {},
+  };
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+// rows for each single-change patch: file(0), hunk(1), ctx(2), del(3), add(4), ctx(5)
+describe("switching threads keeps the cached projection curatable", () => {
+  test("curation still works after switching away and back to a diff thread", async () => {
+    // Arrange - two diff threads in one inbox
+    const controller = createReviewController({
+      sessionId: "ses_a",
+      openClient: async () =>
+        fakeClient([
+          diffSession("ses_a", PATCH_A, FILES_A),
+          diffSession("ses_b", PATCH_B, FILES_B),
+        ]),
+    });
+
+    controller.connect();
+    await tick();
+
+    // Act - visit B, then return to A (A's projection now comes from the per-thread cache)
+    controller.open("ses_b");
+    await tick();
+    controller.open("ses_a");
+    await tick();
+
+    // Assert - the returned thread's file model parses lazily and curation lands
+    controller.toggleRejectChange(4);
+    await tick();
+
+    expect(controller.getSnapshot().status).toContain("change rejected");
+    expect(controller.getSnapshot().session?.workingCopy).toBe("");
+  });
+});