@cueloop/client 0.1.0-alpha.7 → 0.1.0-alpha.9

package/src/keymap.test.ts

@@ -0,0 +1,270 @@
+/**
+ * The keyboard grammar as data: every mode x key produces a known intent
+ * list, the read-only rule is one gate, and plan and diff reviews share one
+ * path for annotation navigation, deletion, and submit.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { DEFAULT_KEYS } from "./config";
+import { reduceKey, type Intent, type KeyState } from "./keymap";
+
+function state(patch: Partial<KeyState> = {}): KeyState {
+  return {
+    keys: DEFAULT_KEYS,
+    readOnly: false,
+    overlay: "none",
+    view: "plan",
+    spanMode: false,
+    resolved: false,
+    hasInboxItems: true,
+    annotationCount: 1,
+    hasFocusedAnnotation: true,
+    cursorAnnotatable: true,
+    ...patch,
+  };
+}
+
+function key(name: string, shift = false): { name: string; shift: boolean } {
+  return { name, shift };
+}
+
+describe("compose overlay", () => {
+  const s = state({ overlay: "compose" });
+  const table: [string, Intent[]][] = [
+    ["escape", [{ t: "closeOverlay" }]],
+    ["return", [{ t: "saveCompose" }]],
+    ["enter", [{ t: "saveCompose" }]],
+    ["left", []],
+    ["right", []],
+    ["j", []],
+    ["q", []],
+  ];
+  for (const [name, expected] of table) {
+    test(`${name} -> ${JSON.stringify(expected)}`, () => {
+      expect(reduceKey(s, key(name))).toEqual(expected);
+    });
+  }
+});
+
+describe("submit overlay", () => {
+  const s = state({ overlay: "submit" });
+  const table: [string, Intent[]][] = [
+    ["escape", [{ t: "closeOverlay" }]],
+    ["return", [{ t: "submitVerdict" }]],
+    ["enter", [{ t: "submitVerdict" }]],
+    ["left", [{ t: "cycleVerdict", dir: -1 }]],
+    ["right", [{ t: "cycleVerdict", dir: 1 }]],
+    ["j", []],
+    ["q", []],
+  ];
+  for (const [name, expected] of table) {
+    test(`${name} -> ${JSON.stringify(expected)}`, () => {
+      expect(reduceKey(s, key(name))).toEqual(expected);
+    });
+  }
+});
+
+describe("completion overlay", () => {
+  const prompt = state({ overlay: "completion-prompt" });
+  const counting = state({ overlay: "completion-counting" });
+  const table: [KeyState, string, Intent[]][] = [
+    [prompt, "return", [{ t: "finishReview" }]],
+    [prompt, "enter", [{ t: "finishReview" }]],
+    [prompt, "q", [{ t: "finishReview" }]],
+    [prompt, "a", [{ t: "optInAutoClose" }]],
+    [prompt, "escape", [{ t: "dismissCompletion" }]],
+    [prompt, "j", []],
+    [counting, "return", [{ t: "finishReview" }]],
+    [counting, "q", [{ t: "finishReview" }]],
+    [counting, "a", []],
+    [counting, "escape", [{ t: "dismissCompletion" }]],
+  ];
+  for (const [s, name, expected] of table) {
+    test(`${s.overlay} ${name} -> ${JSON.stringify(expected)}`, () => {
+      expect(reduceKey(s, key(name))).toEqual(expected);
+    });
+  }
+});
+
+describe("inbox mode", () => {
+  const s = state({ view: "inbox" });
+  const table: [string, Intent[]][] = [
+    ["j", [{ t: "inboxMove", to: "down" }]],
+    ["down", [{ t: "inboxMove", to: "down" }]],
+    ["k", [{ t: "inboxMove", to: "up" }]],
+    ["up", [{ t: "inboxMove", to: "up" }]],
+    ["return", [{ t: "openSession" }]],
+    ["enter", [{ t: "openSession" }]],
+    ["q", [{ t: "exit" }]],
+    ["c", []],
+    ["escape", []],
+  ];
+  for (const [name, expected] of table) {
+    test(`${name} -> ${JSON.stringify(expected)}`, () => {
+      expect(reduceKey(s, key(name))).toEqual(expected);
+    });
+  }
+
+  test("an empty inbox swallows every non-quit key", () => {
+    const empty = state({ view: "inbox", hasInboxItems: false });
+    for (const name of ["j", "k", "down", "up", "return", "enter"]) {
+      expect(reduceKey(empty, key(name))).toEqual([]);
+    }
+    expect(reduceKey(empty, key("q"))).toEqual([{ t: "exit" }]);
+  });
+});
+
+describe("plan normal mode", () => {
+  const s = state();
+  const table: [string, boolean, Intent[]][] = [
+    ["j", false, [{ t: "move", to: "down" }]],
+    ["down", false, [{ t: "move", to: "down" }]],
+    ["k", false, [{ t: "move", to: "up" }]],
+    ["up", false, [{ t: "move", to: "up" }]],
+    ["g", false, [{ t: "move", to: "top" }]],
+    ["g", true, [{ t: "move", to: "bottom" }]],
+    ["v", false, [{ t: "startSpan" }]],
+    ["c", false, [{ t: "openCompose", kind: "comment", from: "cursor" }]],
+    ["s", false, [{ t: "openCompose", kind: "suggestion", from: "cursor" }]],
+    // the default state has a selected card, so Cut and edit act on the card
+    ["x", false, [{ t: "removeAnnotation" }]],
+    ["e", false, [{ t: "editCard" }]],
+    ["n", false, [{ t: "nextAnn" }]],
+    ["p", false, [{ t: "prevAnn" }]],
+    ["backspace", false, [{ t: "removeAnnotation" }]],
+    ["return", false, [{ t: "openSubmit" }]],
+    ["q", false, [{ t: "exit" }]],
+    ["escape", false, [{ t: "deselect" }]],
+    ["z", false, []],
+  ];
+  for (const [name, shift, expected] of table) {
+    test(`${shift ? "shift+" : ""}${name} -> ${JSON.stringify(expected)}`, () => {
+      expect(reduceKey(s, key(name, shift))).toEqual(expected);
+    });
+  }
+
+  test("resolved sessions guard the mutating verbs", () => {
+    const r = state({ resolved: true });
+    for (const name of ["c", "s", "x", "e"]) {
+      expect(reduceKey(r, key(name))).toEqual([{ t: "status", msg: "review submitted - read-only" }]);
+    }
+    expect(reduceKey(r, key("return"))).toEqual([]);
+    expect(reduceKey(r, key("backspace"))).toEqual([]);
+  });
+
+  test("cut text cannot host a comment or a span", () => {
+    const cut = state({ cursorAnnotatable: false });
+    expect(reduceKey(cut, key("c"))).toEqual([{ t: "status", msg: "text is cut - restore it first" }]);
+    expect(reduceKey(cut, key("s"))).toEqual([{ t: "status", msg: "text is cut - restore it first" }]);
+    expect(reduceKey(cut, key("v"))).toEqual([]);
+  });
+
+  test("annotation navigation without annotations reports, delete without focus is silent", () => {
+    const none = state({ annotationCount: 0, hasFocusedAnnotation: false });
+    expect(reduceKey(none, key("n"))).toEqual([{ t: "status", msg: "no annotations" }]);
+    expect(reduceKey(none, key("p"))).toEqual([{ t: "status", msg: "no annotations" }]);
+    expect(reduceKey(none, key("backspace"))).toEqual([]);
+  });
+
+  test("without a selected card x cuts the block and e opens the editor", () => {
+    const unfocused = state({ hasFocusedAnnotation: false });
+    expect(reduceKey(unfocused, key("x"))).toEqual([{ t: "cut" }]);
+    expect(reduceKey(unfocused, key("e"))).toEqual([{ t: "edit" }]);
+  });
+});
+
+describe("span mode", () => {
+  const s = state({ spanMode: true });
+  const table: [string, Intent[]][] = [
+    ["l", [{ t: "spanKey", name: "l" }]],
+    ["h", [{ t: "spanKey", name: "h" }]],
+    ["w", [{ t: "spanKey", name: "w" }]],
+    ["b", [{ t: "spanKey", name: "b" }]],
+    ["$", [{ t: "spanKey", name: "$" }]],
+    ["0", [{ t: "spanKey", name: "0" }]],
+    ["c", [{ t: "openCompose", kind: "comment", from: "span" }]],
+    ["s", [{ t: "openCompose", kind: "suggestion", from: "span" }]],
+    ["escape", [{ t: "closeOverlay" }]],
+    ["q", [{ t: "exit" }]],
+    ["j", []],
+  ];
+  for (const [name, expected] of table) {
+    test(`${name} -> ${JSON.stringify(expected)}`, () => {
+      expect(reduceKey(s, key(name))).toEqual(expected);
+    });
+  }
+});
+
+describe("diff mode", () => {
+  const s = state({ view: "diff" });
+  const table: [string, Intent[]][] = [
+    ["j", [{ t: "move", to: "down" }]],
+    ["k", [{ t: "move", to: "up" }]],
+    ["g", [{ t: "move", to: "top" }]],
+    ["c", [{ t: "openCompose", kind: "comment", from: "cursor" }]],
+    ["n", [{ t: "nextAnn" }]],
+    ["p", [{ t: "prevAnn" }]],
+    ["backspace", [{ t: "removeAnnotation" }]],
+    ["return", [{ t: "openSubmit" }]],
+    ["v", [{ t: "status", msg: "plan-only verb - diff review uses c on a line" }]],
+    ["x", [{ t: "status", msg: "plan-only verb - diff review uses c on a line" }]],
+    ["e", [{ t: "status", msg: "plan-only verb - diff review uses c on a line" }]],
+    ["s", [{ t: "status", msg: "plan-only verb - diff review uses c on a line" }]],
+    ["q", [{ t: "exit" }]],
+  ];
+  for (const [name, expected] of table) {
+    test(`${name} -> ${JSON.stringify(expected)}`, () => {
+      expect(reduceKey(s, key(name))).toEqual(expected);
+    });
+  }
+
+  test("comment guards: resolved first, then non-code rows", () => {
+    expect(reduceKey(state({ view: "diff", resolved: true }), key("c"))).toEqual([
+      { t: "status", msg: "review submitted - read-only" },
+    ]);
+    expect(reduceKey(state({ view: "diff", cursorAnnotatable: false }), key("c"))).toEqual([
+      { t: "status", msg: "move to a code line to comment" },
+    ]);
+  });
+});
+
+describe("duplicated-branch collapse", () => {
+  test("plan and diff produce the same intents for annotation nav, delete, and submit", () => {
+    for (const patch of [
+      {},
+      { annotationCount: 0, hasFocusedAnnotation: false },
+      { resolved: true },
+    ] as Partial<KeyState>[]) {
+      for (const name of ["n", "p", "backspace", "return"]) {
+        const plan = reduceKey(state(patch), key(name));
+        const diff = reduceKey(state({ ...patch, view: "diff" }), key(name));
+        expect(diff).toEqual(plan);
+      }
+    }
+  });
+});
+
+describe("read-only filter", () => {
+  test("every mutating key answers observer - read-only, in plan and diff", () => {
+    for (const view of ["plan", "diff"] as const) {
+      const s = state({ view, readOnly: true });
+      for (const name of ["c", "s", "x", "e", "backspace", "return", "enter"]) {
+        expect(reduceKey(s, key(name))).toEqual([{ t: "status", msg: "observer - read-only" }]);
+      }
+    }
+  });
+
+  test("navigation and annotation focus still work for observers", () => {
+    const s = state({ readOnly: true });
+    expect(reduceKey(s, key("j"))).toEqual([{ t: "move", to: "down" }]);
+    expect(reduceKey(s, key("n"))).toEqual([{ t: "nextAnn" }]);
+    expect(reduceKey(s, key("q"))).toEqual([{ t: "exit" }]);
+  });
+
+  test("span-mode c/s are gated by key name even under a rebound keymap", () => {
+    const rebound = { ...DEFAULT_KEYS, comment: ["m"], suggest: ["t"] };
+    const s = state({ spanMode: true, readOnly: true, keys: rebound });
+    expect(reduceKey(s, key("c"))).toEqual([{ t: "status", msg: "observer - read-only" }]);
+    expect(reduceKey(s, key("s"))).toEqual([{ t: "status", msg: "observer - read-only" }]);
+  });
+});

package/src/keymap.ts

@@ -0,0 +1,173 @@
+/**
+ * The keyboard grammar as a pure reducer (#70): 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
+ * 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.
+ */
+
+import { actionFor } from "./config";
+
+export type Intent =
+  | { t: "exit" }
+  | { t: "status"; msg: string }
+  | { t: "move"; to: "down" | "up" | "top" | "bottom" }
+  | { t: "inboxMove"; to: "down" | "up" }
+  | { t: "openSession" }
+  | { t: "startSpan" }
+  | { t: "spanKey"; name: string }
+  | { t: "openCompose"; kind: "comment" | "suggestion"; from: "cursor" | "span" }
+  | { t: "openSubmit" }
+  | { t: "cut" }
+  | { t: "edit" }
+  | { t: "editCard" }
+  | { t: "nextAnn" }
+  | { t: "prevAnn" }
+  | { t: "removeAnnotation" }
+  | { t: "deselect" }
+  | { t: "closeOverlay" }
+  | { t: "saveCompose" }
+  | { t: "submitVerdict" }
+  | { t: "cycleVerdict"; dir: -1 | 1 }
+  | { t: "finishReview" }
+  | { t: "optInAutoClose" }
+  | { t: "dismissCompletion" };
+
+export interface KeyInput {
+  name: string;
+  shift: boolean;
+}
+
+export interface KeyState {
+  /** Loaded keymap (config.ts): action -> key combos. */
+  keys: Record<string, string[]>;
+  readOnly: boolean;
+  /** Layer that owns keys before the grammar runs. */
+  overlay: "none" | "compose" | "submit" | "completion-prompt" | "completion-counting";
+  view: "inbox" | "plan" | "diff";
+  /** Plan-only span selection sub-mode. */
+  spanMode: boolean;
+  resolved: boolean;
+  hasInboxItems: boolean;
+  annotationCount: number;
+  hasFocusedAnnotation: boolean;
+  /** Cursor sits on annotatable text: a work block (plan) or a code row (diff). */
+  cursorAnnotatable: boolean;
+}
+
+/** Verbs that write session state; an observer never reaches their handlers. */
+const MUTATING_ACTIONS = new Set(["comment", "suggest", "cut", "edit", "delete_annotation", "submit"]);
+
+const SPAN_KEYS = ["l", "h", "w", "b", "$", "0"];
+
+function status(msg: string): Intent[] {
+  return [{ t: "status", msg }];
+}
+
+export function reduceKey(state: KeyState, key: KeyInput): Intent[] {
+  const name = key.name;
+  // compose/submit overlays own the keys via focused inputs; only escape,
+  // return, and verdict arrows route through the grammar
+  if (state.overlay === "compose" || state.overlay === "submit") {
+    if (name === "escape") return [{ t: "closeOverlay" }];
+    if (name === "return" || name === "enter") {
+      return [state.overlay === "compose" ? { t: "saveCompose" } : { t: "submitVerdict" }];
+    }
+    if (state.overlay === "submit" && (name === "left" || name === "right")) {
+      return [{ t: "cycleVerdict", dir: name === "left" ? -1 : 1 }];
+    }
+    return [];
+  }
+  if (state.overlay === "completion-prompt" || state.overlay === "completion-counting") {
+    if (name === "return" || name === "enter" || name === "q") return [{ t: "finishReview" }];
+    if (name === "a" && state.overlay === "completion-prompt") return [{ t: "optInAutoClose" }];
+    if (name === "escape") return [{ t: "dismissCompletion" }];
+    return [];
+  }
+  const action = actionFor(state.keys, name, key.shift);
+  if (action === "quit") return [{ t: "exit" }];
+  // the ONE read-only rule: any mutating attempt answers instead of acting
+  // (span-mode c/s are hardwired keys, so they gate by name as well)
+  const mutating = MUTATING_ACTIONS.has(action ?? "") || (state.spanMode && (name === "c" || name === "s"));
+  if (state.readOnly && mutating) return status("observer - read-only");
+
+  if (state.view === "inbox") return inboxGrammar(state, name);
+  if (state.view === "diff") return diffGrammar(state, action);
+  if (state.spanMode) return spanGrammar(name);
+  return planGrammar(state, action, name);
+}
+
+function inboxGrammar(state: KeyState, name: string): Intent[] {
+  if (!state.hasInboxItems) return [];
+  if (name === "j" || name === "down") return [{ t: "inboxMove", to: "down" }];
+  if (name === "k" || name === "up") return [{ t: "inboxMove", to: "up" }];
+  if (name === "return" || name === "enter") return [{ t: "openSession" }];
+  return [];
+}
+
+function diffGrammar(state: KeyState, action: string | undefined): Intent[] {
+  const nav = navIntent(action);
+  if (nav) return nav;
+  if (action === "comment") {
+    if (state.resolved) return status("review submitted - read-only");
+    if (!state.cursorAnnotatable) return status("move to a code line to comment");
+    return [{ t: "openCompose", kind: "comment", from: "cursor" }];
+  }
+  const shared = annotationCluster(state, action);
+  if (shared) return shared;
+  if (action === "span" || action === "cut" || action === "edit" || action === "suggest") {
+    return status("plan-only verb - diff review uses c on a line");
+  }
+  return [];
+}
+
+function spanGrammar(name: string): Intent[] {
+  if (name === "escape") return [{ t: "closeOverlay" }];
+  if (SPAN_KEYS.includes(name)) return [{ t: "spanKey", name }];
+  if (name === "c" || name === "s") {
+    return [{ t: "openCompose", kind: name === "s" ? "suggestion" : "comment", from: "span" }];
+  }
+  return [];
+}
+
+function planGrammar(state: KeyState, action: string | undefined, name: string): Intent[] {
+  const nav = navIntent(action);
+  if (nav) return nav;
+  if (name === "escape") return [{ t: "deselect" }];
+  if (action === "span") return state.cursorAnnotatable ? [{ t: "startSpan" }] : [];
+  if (action === "comment" || action === "suggest") {
+    if (state.resolved) return status("review submitted - read-only");
+    if (!state.cursorAnnotatable) return status("text is cut - restore it first");
+    return [{ t: "openCompose", kind: action === "suggest" ? "suggestion" : "comment", from: "cursor" }];
+  }
+  if (action === "cut" || action === "edit") {
+    if (state.resolved) return status("review submitted - read-only");
+    // the document selects, the rail edits: with a card selected, Cut deletes
+    // the annotation and edit rewrites the card body in place
+    if (state.hasFocusedAnnotation) return [action === "cut" ? { t: "removeAnnotation" } : { t: "editCard" }];
+    return [{ t: action }];
+  }
+  return annotationCluster(state, action) ?? [];
+}
+
+/** Cursor movement is the same intent everywhere; views clamp their own bounds. */
+function navIntent(action: string | undefined): Intent[] | null {
+  if (action === "down" || action === "up" || action === "top" || action === "bottom") {
+    return [{ t: "move", to: action }];
+  }
+  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") {
+    if (!state.annotationCount) return status("no annotations");
+    return [{ t: action === "next_annotation" ? "nextAnn" : "prevAnn" }];
+  }
+  if (action === "delete_annotation") {
+    if (state.resolved || !state.hasFocusedAnnotation) return [];
+    return [{ t: "removeAnnotation" }];
+  }
+  if (action === "submit") return state.resolved ? [] : [{ t: "openSubmit" }];
+  return null;
+}

package/src/run.ts

@@ -11,7 +11,9 @@ export interface RunClientOptions {
 }
 
 export async function runClient(opts: RunClientOptions): Promise<number> {
-  const renderer = await createCliRenderer();
+  // 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, {