@cueloop/client 0.1.0-alpha.63 → 0.1.0-alpha.65

package/src/key-bindings.ts

@@ -10,6 +10,7 @@
 
 import { Keymap, type KeymapEvent, type KeymapHost } from "@opentui/keymap";
 import { registerDefaultKeys } from "@opentui/keymap/addons";
+import * as v from "valibot";
 import type { KeyState } from "./keymap";
 
 export interface ResolvableKey {
@@ -111,7 +112,11 @@ const HINT_TEMPLATES: Record<HintMode, HintEntry[]> = {
 };
 
 /** Status-line glyphs for named keys. */
-const KEY_GLYPHS: Record<string, string> = {
+interface KeyGlyphs {
+  [key: string]: string;
+}
+
+const KEY_GLYPHS: KeyGlyphs = {
   return: "enter",
   enter: "enter",
   escape: "esc",
@@ -186,7 +191,7 @@ class HeadlessKeymapHost implements KeymapHost<object, KeymapEvent> {
  * keymap's canonical form is lowercase + the shift modifier. Non-letter
  * single characters ("$", "0") already encode their shift in the character.
  */
-function normalizedEvent(key: ResolvableKey): { name: string; shift: boolean } {
+function normalizedEvent(key: ResolvableKey) {
   if (key.name.length === 1) {
     if (/[a-zA-Z]/.test(key.name)) {
       return {
@@ -220,6 +225,10 @@ const SPAN_COMMANDS: [key: string, command: string][] = [
   ["escape", "span_cancel"],
 ];
 
+function isConditionMatcher(value: unknown): value is () => boolean {
+  return typeof value === "function";
+}
+
 export class KeyBindings {
   private readonly host = new HeadlessKeymapHost();
   private readonly keymap = new Keymap<object, KeymapEvent>(this.host);
@@ -234,7 +243,7 @@ export class KeyBindings {
     // and dispatch only see the layer that owns the current mode
     this.keymap.registerLayerFields({
       when: (value, fieldContext) => {
-        if (typeof value === "function") fieldContext.activeWhen(value as () => boolean);
+        if (isConditionMatcher(value)) fieldContext.activeWhen(value);
       },
     });
     this.registerModeLayers();
@@ -373,10 +382,10 @@ export class KeyBindings {
   /** First active key display for a command, mapped through the glyph table. */
   private keyDisplayFor(command: string): string | null {
     for (const activeKey of this.keymap.getActiveKeys({ includeBindings: true })) {
-      const bindingCommand =
-        typeof activeKey.command === "string"
-          ? activeKey.command
-          : activeKey.bindings?.[0]?.command;
+      const parsedCommand = v.safeParse(v.string(), activeKey.command);
+      const bindingCommand = parsedCommand.success
+        ? parsedCommand.output
+        : activeKey.bindings?.[0]?.command;
 
       if (bindingCommand !== command) continue;
 

package/src/keymap.test.ts

@@ -21,11 +21,7 @@ function state(patch: Partial<KeyState> = {}): KeyState {
   };
 }
 
-function key(
-  name: string,
-  shift = false,
-  meta = false,
-): { name: string; shift: boolean; meta: boolean } {
+function key(name: string, shift = false, meta = false) {
   return { name, shift, meta };
 }
 
@@ -228,7 +224,7 @@ describe("plan normal mode", () => {
     });
   }
 
-  test("resolved sessions guard the mutating verbs", () => {
+  test("resolved sessions guard the mutating primitives", () => {
     // Arrange
     const resolvedState = state({ resolved: true });
 
@@ -390,9 +386,9 @@ describe("diff mode", () => {
     ["p", [{ type: "prevAnnotation" }]],
     ["backspace", [{ type: "removeAnnotation" }]],
     ["return", [{ type: "openSubmit" }]],
-    ["v", [{ type: "status", message: "plan-only verb - diff review uses c on a line" }]],
+    ["v", [{ type: "status", message: "plan-only primitive - diff review uses c on a line" }]],
     ["x", [{ type: "rejectChange" }]],
-    ["e", [{ type: "status", message: "plan-only verb - diff review uses c on a line" }]],
+    ["e", [{ type: "status", message: "plan-only primitive - diff review uses c on a line" }]],
     ["q", [{ type: "exit" }]],
   ];
 
@@ -518,7 +514,7 @@ describe("review panel controls", () => {
     expect(reduceKey(observer, key("]"))).toEqual([{ type: "resizeReviewPanel", direction: 1 }]);
   });
 
-  test("span mode still owns b as a span verb, not a panel cycle", () => {
+  test("span mode still owns b as a span primitive, not a panel cycle", () => {
     // Assert
     expect(reduceKey(state({ spanMode: true }), key("b"))).toEqual([
       { type: "spanKey", name: "b" },
@@ -537,11 +533,13 @@ describe("review panel controls", () => {
 
 describe("duplicated-branch collapse", () => {
   test("plan and diff produce the same intents for annotation nav, delete, and submit", () => {
-    for (const patch of [
+    const patches: Partial<KeyState>[] = [
       {},
       { annotationCount: 0, hasFocusedAnnotation: false },
       { resolved: true },
-    ] as Partial<KeyState>[]) {
+    ];
+
+    for (const patch of patches) {
       for (const name of ["n", "p", "backspace", "return"]) {
         const plan = reduceKey(state(patch), key(name));
         const diff = reduceKey(state({ ...patch, view: "diff" }), key(name));

package/src/keymap.ts

@@ -1,7 +1,7 @@
 /**
  * The keyboard grammar as a pure reducer: view state in, intents out.
  * App builds a KeyState per key event, calls reduceKey, and dispatches the
- * intents to controller verbs and view-state setters - no branch bodies live
+ * intents to controller primitives and view-state setters - no branch bodies live
  * in the key handler. Diff and plan reviews share one path for annotation
  * navigation, deletion, and submit; the read-only rule is one gate here.
  */
@@ -49,7 +49,14 @@ export type Intent =
   | { type: "optInAutoClose" }
   | { type: "dismissCompletion" }
   | { type: "cycleReviewPanel" }
-  | { type: "resizeReviewPanel"; direction: -1 | 1 };
+  | { type: "resizeReviewPanel"; direction: -1 | 1 }
+  | { type: "toggleTree" }
+  | { type: "treeMove"; direction: -1 | 1 }
+  | { type: "treeGo" }
+  | { type: "treeBranch" }
+  | { type: "treeLabel" }
+  | { type: "treeFork" }
+  | { type: "treeForkShare" };
 
 export interface KeyInput {
   name: string;
@@ -63,7 +70,7 @@ export interface KeyState {
   keys: Record<string, string[]>;
   readOnly: boolean;
   /**
-   * Owner-only verbs a share collaborator lacks (undefined = owner, allowed).
+   * Owner-only primitives a share collaborator lacks (undefined = owner, allowed).
    * A collaborator annotates but cannot edit the plan (cut / $EDITOR runs on
    * the gateway) or submit an agent verdict (there is no agent on a share).
    */
@@ -95,7 +102,7 @@ export interface KeyState {
   cursorAnnotatable: boolean;
 }
 
-/** Verbs that write session state; an observer never reaches their handlers. */
+/** Primitives that write session state; an observer never reaches their handlers. */
 const MUTATING_ACTIONS = new Set([
   "comment",
   "cut",
@@ -136,7 +143,7 @@ export function reduceKey(state: KeyState, key: KeyInput, resolvedAction?: strin
 
   if (state.readOnly && mutating) return status("observer - read-only");
 
-  // share is a session-level verb: it works from any view, owner only
+  // share is a session-level primitive: it works from any view, owner only
   if (action === "share") {
     if (state.canShare === false) return status("only the plan owner can share");
 
@@ -305,7 +312,7 @@ function diffGrammar(state: KeyState, action: string | undefined): Intent[] {
 
   if (shared) return shared;
   if (action === "span" || action === "edit") {
-    return status("plan-only verb - diff review uses c on a line");
+    return status("plan-only primitive - diff review uses c on a line");
   }
 
   return [];
@@ -356,7 +363,7 @@ function planGrammar(state: KeyState, action: string | undefined, name: string):
     // the annotation and edit rewrites the card body in place
     if (state.hasFocusedAnnotation)
       return [action === "cut" ? { type: "removeAnnotation" } : { type: "editCard" }];
-    // editing the plan itself is the owner's verb; a share viewer only annotates,
+    // editing the plan itself is the owner's primitive; a share viewer only annotates,
     // and has no edit affordance, so the key is silent rather than a nag
     if (state.canEditPlan === false) return [];
 

package/src/kitty-image.test.ts

@@ -54,13 +54,13 @@ describe("kitty image placement", () => {
 describe("resolveTransmitMedium", () => {
   test("defaults to base64; file transfer is opt-in and never over ssh", () => {
     // Assert
-    expect(resolveTransmitMedium({} as NodeJS.ProcessEnv)).toBe("base64");
-    expect(resolveTransmitMedium({ CUELOOP_KITTY_FILE: "1" } as NodeJS.ProcessEnv)).toBe("file");
+    expect(resolveTransmitMedium({})).toBe("base64");
+    expect(resolveTransmitMedium({ CUELOOP_KITTY_FILE: "1" })).toBe("file");
     expect(
       resolveTransmitMedium({
         CUELOOP_KITTY_FILE: "1",
         SSH_CONNECTION: "1.2.3.4 5 6 7",
-      } as NodeJS.ProcessEnv),
+      }),
     ).toBe("base64");
   });
 });

package/src/prototype-browser.ts

@@ -73,7 +73,7 @@ export function cssBoxToCell(
   box: ElementBox,
   image: { x: number; y: number; width: number; height: number },
   viewport: PrototypeViewport,
-): { column: number; row: number; columns: number; rows: number } {
+) {
   const scaleColumn = image.width / viewport.width;
   const scaleRow = image.height / viewport.height;
 
@@ -174,13 +174,13 @@ export async function launchPrototypeRenderer(options: LaunchOptions): Promise<P
         omitBackground: true,
       });
 
-      return new Uint8Array(buffer as Buffer);
+      return new Uint8Array(buffer);
     },
     async elementAt(cssX, cssY) {
-      return (await page.evaluate(elementAtScript, cssX, cssY)) as PrototypeElement | null;
+      return page.evaluate(elementAtScript, cssX, cssY);
     },
     async scrollBy(deltaY) {
-      return (await page.evaluate(scrollByScript, deltaY)) as boolean;
+      return page.evaluate(scrollByScript, deltaY);
     },
     async close() {
       await page.close().catch(() => undefined);
@@ -189,7 +189,7 @@ export async function launchPrototypeRenderer(options: LaunchOptions): Promise<P
 }
 
 /** Serialized into the page (self-contained for puppeteer): resolve the click to a component element. */
-function elementAtScript(x: number, y: number): unknown {
+function elementAtScript(x: number, y: number) {
   const SEMANTIC = new Set([
     "SECTION",
     "ARTICLE",
@@ -232,7 +232,8 @@ function elementAtScript(x: number, y: number): unknown {
       const parent: Element | null = current.parentElement;
 
       if (parent) {
-        const twins = [...parent.children].filter((child) => child.tagName === current!.tagName);
+        const currentTagName = current.tagName;
+        const twins = [...parent.children].filter((child) => child.tagName === currentTagName);
 
         if (twins.length > 1) part += ":nth-of-type(" + (twins.indexOf(current) + 1) + ")";
       }

package/src/serve.ts

@@ -36,7 +36,7 @@ export interface ServeOptions {
   home?: string;
   /** Silence the @opentui/ssh startup banner (tests). Default true. */
   banner?: boolean;
-  onError?: (err: unknown) => void;
+  onError?: (cause: unknown) => void;
 }
 
 export interface ServeHandle {

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

@@ -1,5 +1,14 @@
 import { describe, expect, mock, test } from "bun:test";
-import { SCHEMA_VERSION, type DiffFileContents, type ReviewSession } from "@cueloop/schema";
+import {
+  cutBlock,
+  parseBlocks,
+  restoreBlock,
+  SCHEMA_VERSION,
+  type DiffFileContents,
+  type HunkRejection,
+  type ReviewSession,
+} from "@cueloop/schema";
+import { curateDiff } from "@cueloop/daemon/curate";
 import type { SessionClient } from "@cueloop/daemon/client";
 import { createReviewController } from "./session-controller";
 
@@ -37,26 +46,87 @@ function diffSession(files?: DiffFileContents[]): ReviewSession {
   };
 }
 
+interface WorkingCopySink {
+  workingCopy?: string;
+}
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
 /** A fake client that records the working copy the controller writes. */
-function fakeClient(session: ReviewSession, sink: { workingCopy?: string }): SessionClient {
+function fakeClient(initial: ReviewSession, sink: WorkingCopySink): SessionClient {
+  let session = initial;
+
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
     sessionGet: async () => session,
     sessionList: async () => [session],
+    sessionAnnotate: unimplemented("sessionAnnotate"),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
     sessionSetWorkingCopy: mock(async (_id: string, content: string | undefined) => {
       sink.workingCopy = content;
 
       return { ...session, workingCopy: content };
     }),
+    // the daemon's block primitives, stood in for with the same pure helpers it uses
+    sessionCutBlock: mock(async (_id: string, blockIndex: number) => {
+      const working = session.workingCopy ?? session.artifact.content;
+      const content = cutBlock(working, parseBlocks(working)[blockIndex]!);
+
+      sink.workingCopy = content;
+      session = { ...session, workingCopy: content };
+
+      return session;
+    }),
+    sessionRestoreBlock: mock(async (_id: string, baseBlockIndex: number, line?: number) => {
+      const base = session.artifact.content;
+      const working = session.workingCopy ?? base;
+      const content = restoreBlock(
+        base,
+        working,
+        parseBlocks(base)[baseBlockIndex]!,
+        line ?? working.split("\n").length,
+      );
+
+      sink.workingCopy = content;
+      session = { ...session, workingCopy: content };
+      if (content === undefined) delete session.workingCopy;
+
+      return session;
+    }),
+    // the daemon's curation, stood in for: the record carries the decisions and the patch they leave
+    sessionCurate: mock(async (_id: string, rejections: HunkRejection[]) => {
+      const content = rejections.length
+        ? curateDiff(session.artifact.files!, rejections)
+        : undefined;
+
+      sink.workingCopy = content;
+      session = { ...session, workingCopy: content };
+      if (rejections.length) session.curation = rejections;
+      else delete session.curation;
+
+      return session;
+    }),
+    sessionNavigate: unimplemented("sessionNavigate"),
+    sessionBranch: unimplemented("sessionBranch"),
+    sessionSwitch: unimplemented("sessionSwitch"),
+    sessionLabel: unimplemented("sessionLabel"),
+    sessionFork: unimplemented("sessionFork"),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionResolve: unimplemented("sessionResolve"),
     close: () => {},
-  } as unknown as SessionClient;
+  };
 }
 
 const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
 
 async function connected(session: ReviewSession) {
-  const sink: { workingCopy?: string } = {};
+  const sink: WorkingCopySink = {};
   const client = fakeClient(session, sink);
   const controller = createReviewController({
     sessionId: session.id,
@@ -196,6 +266,23 @@ describe("diff hunk curation", () => {
     expect(controller.curationItems().length).toBe(1);
   });
 
+  test("a second decision before the daemon answers builds on the first", async () => {
+    // Arrange
+    const { controller, client } = await connected(diffSession(FILES));
+
+    // Act - reject, then restore, with no answer in between
+    controller.toggleRejectChange(4);
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - the second request restores; a stale snapshot would reject again
+    expect(client.sessionCurate).toHaveBeenCalledTimes(2);
+    expect(client.sessionCurate).toHaveBeenNthCalledWith(1, "ses_diff", [
+      { path: "src/store.ts", hunkIndex: 0, changeIndex: 1 },
+    ]);
+    expect(client.sessionCurate).toHaveBeenNthCalledWith(2, "ses_diff", []);
+  });
+
   test("curation is disabled without full file contents", async () => {
     // Arrange - a legacy diff with no artifact.files
     const { controller, sink } = await connected(diffSession(undefined));
@@ -257,4 +344,19 @@ describe("plan cut removals", () => {
     expect(controller.getSnapshot().status).toContain("removal restored");
     expect(sink.workingCopy).toBeUndefined();
   });
+
+  test("a second cut before the daemon answers indexes the already-cut copy", async () => {
+    // Arrange - pristine plan: title(0), first(1), second(2)
+    const { controller, client, sink } = await connected(planSession());
+
+    // Act - cut the first paragraph, then the second, with no answer in between
+    controller.cut(1);
+    controller.cut(2);
+    await tick();
+
+    // Assert - the second paragraph is block 1 once the first is gone
+    expect(client.sessionCutBlock).toHaveBeenNthCalledWith(1, "ses_plan", 1);
+    expect(client.sessionCutBlock).toHaveBeenNthCalledWith(2, "ses_plan", 1);
+    expect(sink.workingCopy).toBe("# Title\n");
+  });
 });