@cueloop/client 0.1.0-alpha.33 → 0.1.0-alpha.35

package/src/keymap.ts

@@ -19,12 +19,20 @@ export type Intent =
   | { type: "confirmDialog" }
   | { type: "startSpan" }
   | { type: "spanKey"; name: string }
-  | { type: "openCompose"; kind: "comment" | "suggestion"; from: "cursor" | "span" }
+  | { type: "spanCut" }
+  | { type: "openSpanActions" }
+  | { type: "moveSpanAction"; direction: -1 | 1 }
+  | { type: "pickSpanAction"; index?: number }
+  | { type: "closeSpanActions" }
+  | { type: "openCompose"; kind: "comment"; from: "cursor" | "span" }
   | { type: "openSubmit" }
   | { type: "share" }
   | { type: "cut" }
   | { type: "edit" }
   | { type: "editCard" }
+  | { type: "rejectHunk" }
+  | { type: "rejectChange" }
+  | { type: "restoreCuration" }
   | { type: "nextAnnotation" }
   | { type: "prevAnnotation" }
   | { type: "walkStart" }
@@ -64,7 +72,16 @@ export interface KeyState {
   /** Owner-only: publish the plan as a share. A collaborator never re-shares. */
   canShare?: boolean;
   /** Layer that owns keys before the grammar runs. */
-  overlay: "none" | "walk" | "compose" | "submit" | "confirm" | "prompt" | "completion-prompt" | "completion-counting";
+  overlay:
+    | "none"
+    | "walk"
+    | "compose"
+    | "submit"
+    | "confirm"
+    | "prompt"
+    | "spanActions"
+    | "completion-prompt"
+    | "completion-counting";
   view: "inbox" | "plan" | "diff";
   /** Plan-only span selection sub-mode. */
   spanMode: boolean;
@@ -79,9 +96,19 @@ export interface KeyState {
 }
 
 /** Verbs that write session state; an observer never reaches their handlers. */
-const MUTATING_ACTIONS = new Set(["comment", "suggest", "cut", "edit", "delete_annotation", "submit", "walk", "share"]);
+const MUTATING_ACTIONS = new Set([
+  "comment",
+  "cut",
+  "edit",
+  "delete_annotation",
+  "submit",
+  "walk",
+  "share",
+  "reject_hunk",
+  "restore_curation",
+]);
 
-const SPAN_KEYS = ["l", "h", "w", "b", "$", "0"];
+const SPAN_KEYS = new Set(["l", "h", "w", "b", "$", "0"]);
 
 function status(message: string): Intent[] {
   return [{ type: "status", message }];
@@ -126,6 +153,15 @@ export function reduceKey(state: KeyState, key: KeyInput, resolvedAction?: strin
     if (name === "escape") return [{ type: "closeOverlay" }];
     return [];
   }
+  // the quick-actions list owns its keys: j/k move, ⏎ picks the highlighted
+  // action (inserting its preset comment), escape returns to the span toolbar
+  if (state.overlay === "spanActions") {
+    if (name === "j" || name === "down") return [{ type: "moveSpanAction", direction: 1 }];
+    if (name === "k" || name === "up") return [{ type: "moveSpanAction", direction: -1 }];
+    if (name === "return" || name === "enter") return [{ type: "pickSpanAction" }];
+    if (name === "escape") return [{ type: "closeSpanActions" }];
+    return [];
+  }
   if (state.overlay === "completion-prompt" || state.overlay === "completion-counting") {
     if (name === "return" || name === "enter" || name === "q") return [{ type: "finishReview" }];
     if (name === "a") return [{ type: "optInAutoClose" }];
@@ -148,8 +184,10 @@ export function reduceKey(state: KeyState, key: KeyInput, resolvedAction?: strin
   const action = resolvedAction ?? actionFor(state.keys, name, key.shift);
   if (action === "quit") return [{ type: "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"));
+  // (span-mode c, x, and a are hardwired keys, so they gate by name as well)
+  const mutating =
+    MUTATING_ACTIONS.has(action ?? "") ||
+    (state.spanMode && (name === "c" || name === "x" || name === "a"));
   if (state.readOnly && mutating) return status("observer - read-only");
 
   // share is a session-level verb: it works from any view, owner only
@@ -161,7 +199,7 @@ 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
-  if (state.spanMode) return spanGrammar(name);
+  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);
@@ -200,19 +238,40 @@ function diffGrammar(state: KeyState, action: string | undefined): Intent[] {
     if (!state.cursorAnnotatable) return status("move to a code line to comment");
     return [{ type: "openCompose", kind: "comment", from: "cursor" }];
   }
+  // cut rejects the change under the cursor, reject_hunk the whole hunk; both
+  // write the working copy, so they gate on owner like a plan edit.
+  if (action === "cut" || action === "reject_hunk") {
+    if (state.resolved) return status("review submitted - read-only");
+    if (state.canEditPlan === false) return status("only the diff owner can curate hunks");
+    return [{ type: action === "reject_hunk" ? "rejectHunk" : "rejectChange" }];
+  }
+  // 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");
+    if (state.canEditPlan === false) return status("only the diff owner can curate hunks");
+    return [{ type: "restoreCuration" }];
+  }
   const shared = annotationCluster(state, action);
   if (shared) return shared;
-  if (action === "span" || action === "cut" || action === "edit" || action === "suggest") {
+  if (action === "span" || action === "edit") {
     return status("plan-only verb - diff review uses c on a line");
   }
   return [];
 }
 
-function spanGrammar(name: string): Intent[] {
+function spanGrammar(state: KeyState, name: string): Intent[] {
   if (name === "escape") return [{ type: "closeOverlay" }];
-  if (SPAN_KEYS.includes(name)) return [{ type: "spanKey", name }];
-  if (name === "c" || name === "s") {
-    return [{ type: "openCompose", kind: name === "s" ? "suggestion" : "comment", from: "span" }];
+  if (SPAN_KEYS.has(name)) return [{ type: "spanKey", name }];
+  // c comments, x cuts, a opens quick-actions - all mutate, so a resolved
+  // review is read-only, like the plan grammar
+  if (name === "c" || name === "x" || name === "a") {
+    if (state.resolved) return status("review submitted - read-only");
+    if (name === "c") return [{ type: "openCompose", kind: "comment", from: "span" }];
+    if (name === "a") return [{ type: "openSpanActions" }];
+    // partial-span cut is not in the working-copy model, so cut removes the
+    // whole block the span sits in; owner-only, like plan cut
+    if (state.canEditPlan === false) return [];
+    return [{ type: "spanCut" }];
   }
   return [];
 }
@@ -223,16 +282,23 @@ function planGrammar(state: KeyState, action: string | undefined, name: string):
   if (action === "walk") return status("the guided walk is a diff-review mode");
   if (name === "escape") return [{ type: "deselect" }];
   if (action === "span") return state.cursorAnnotatable ? [{ type: "startSpan" }] : [];
-  if (action === "comment" || action === "suggest") {
+  if (action === "comment") {
     if (state.resolved) return status("review submitted - read-only");
     if (!state.cursorAnnotatable) return status("text is cut - restore it first");
-    return [{ type: "openCompose", kind: action === "suggest" ? "suggestion" : "comment", from: "cursor" }];
+    return [{ type: "openCompose", kind: "comment", from: "cursor" }];
+  }
+  // restore un-does a rail removal (a cut block); a plan edit, so owner-only
+  if (action === "restore_curation") {
+    if (state.resolved) return status("review submitted - read-only");
+    if (state.canEditPlan === false) return [];
+    return [{ type: "restoreCuration" }];
   }
   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" ? { type: "removeAnnotation" } : { type: "editCard" }];
+    if (state.hasFocusedAnnotation)
+      return [action === "cut" ? { type: "removeAnnotation" } : { type: "editCard" }];
     // editing the plan itself is the owner's verb; a share viewer only annotates,
     // and has no edit affordance, so the key is silent rather than a nag
     if (state.canEditPlan === false) return [];
@@ -265,7 +331,8 @@ function annotationCluster(state: KeyState, action: string | undefined): Intent[
   }
   if (action === "submit") {
     // a collaborator's notes union back as they go; there is no verdict to submit
-    if (state.canSubmitVerdict === false) return status("shared view - your notes save as you go; q to leave");
+    if (state.canSubmitVerdict === false)
+      return status("shared view - your notes save as you go; q to leave");
     return state.resolved ? [] : [{ type: "openSubmit" }];
   }
   return null;

package/src/review-panel.test.ts

@@ -68,7 +68,9 @@ describe("widthFromMouseColumn", () => {
   });
 
   test("the resize step widens and narrows within the clamp", () => {
-    expect(clampWidth(REVIEW_DEFAULT_WIDTH + REVIEW_RESIZE_STEP)).toBe(REVIEW_DEFAULT_WIDTH + REVIEW_RESIZE_STEP);
+    expect(clampWidth(REVIEW_DEFAULT_WIDTH + REVIEW_RESIZE_STEP)).toBe(
+      REVIEW_DEFAULT_WIDTH + REVIEW_RESIZE_STEP,
+    );
     expect(clampWidth(REVIEW_MIN_WIDTH - REVIEW_RESIZE_STEP)).toBe(REVIEW_MIN_WIDTH);
   });
 });

package/src/review-panel.ts

@@ -26,7 +26,11 @@ export const REVIEW_COMPACT_WIDTH = 6;
 export const REVIEW_RESIZE_STEP = 2;
 
 /** Round a desired width to a whole column and clamp it to the bounds. */
-export function clampWidth(desiredWidth: number, min = REVIEW_MIN_WIDTH, max = REVIEW_MAX_WIDTH): number {
+export function clampWidth(
+  desiredWidth: number,
+  min = REVIEW_MIN_WIDTH,
+  max = REVIEW_MAX_WIDTH,
+): number {
   return Math.max(min, Math.min(max, Math.round(desiredWidth)));
 }
 
@@ -36,7 +40,10 @@ export function clampWidth(desiredWidth: number, min = REVIEW_MIN_WIDTH, max = R
  * (an extremely narrow terminal is the auto-collapse case, handled elsewhere).
  */
 export function maxWidthForTerminal(terminalWidth: number): number {
-  return Math.max(REVIEW_MIN_WIDTH, Math.min(REVIEW_MAX_WIDTH, terminalWidth - REVIEW_PLAN_MIN_WIDTH - 1));
+  return Math.max(
+    REVIEW_MIN_WIDTH,
+    Math.min(REVIEW_MAX_WIDTH, terminalWidth - REVIEW_PLAN_MIN_WIDTH - 1),
+  );
 }
 
 /** Clamp a desired rail width to the bounds AND the terminal, so the plan keeps its room. */

package/src/serve.test.ts

@@ -38,7 +38,11 @@ afterEach(async () => {
 });
 
 /** Connect, open a PTY shell, resolve with the bytes seen until `until` matches. */
-function sshCapture(port: number, until: (frame: string) => boolean, timeoutMs = 8000): Promise<string> {
+function sshCapture(
+  port: number,
+  until: (frame: string) => boolean,
+  timeoutMs = 8000,
+): Promise<string> {
   return new Promise((resolve, reject) => {
     const conn = new Client();
     let out = "";
@@ -48,7 +52,8 @@ function sshCapture(port: number, until: (frame: string) => boolean, timeoutMs =
       done = true;
       clearTimeout(timer);
       conn.end();
-      err ? reject(err) : resolve(out);
+      if (err) reject(err);
+      else resolve(out);
     };
     const timer = setTimeout(() => finish(new Error(`timed out; captured:\n${out}`)), timeoutMs);
     conn
@@ -80,7 +85,10 @@ describe("cueloop serve", () => {
 
   test("an anonymous ssh client gets the observer 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") && frame.includes("observer"),
+    );
 
     // Assert
     expect(bytes).toContain("cueloop");

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

@@ -0,0 +1,253 @@
+import { describe, expect, mock, test } from "bun:test";
+import { SCHEMA_VERSION, type DiffFileContents, type ReviewSession } from "@cueloop/schema";
+import type { SessionClient } from "@cueloop/daemon/client";
+import { createReviewController } from "./session-controller";
+
+const PATCH = `diff --git a/src/store.ts b/src/store.ts
+index 111..222 100644
+--- a/src/store.ts
++++ b/src/store.ts
+@@ -1,4 +1,4 @@
+ export class Store {
+-  private items = [];
++  private items = new Map();
+ }
+`;
+
+const FILES: DiffFileContents[] = [
+  {
+    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",
+  },
+];
+
+function diffSession(files?: DiffFileContents[]): ReviewSession {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_diff",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "diff", content: PATCH, meta: {}, 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",
+  };
+}
+
+/** A fake client that records the working copy the controller writes. */
+function fakeClient(session: ReviewSession, sink: { workingCopy?: string }): SessionClient {
+  return {
+    onEvent: () => () => {},
+    subscribe: async () => {},
+    sessionGet: async () => session,
+    sessionList: async () => [session],
+    sessionSetWorkingCopy: mock(async (_id: string, content: string | undefined) => {
+      sink.workingCopy = content;
+      return { ...session, workingCopy: content };
+    }),
+    close: () => {},
+  } as unknown as SessionClient;
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+async function connected(session: ReviewSession) {
+  const sink: { workingCopy?: string } = {};
+  const client = fakeClient(session, sink);
+  const controller = createReviewController({
+    sessionId: session.id,
+    openClient: async () => client,
+  });
+  controller.connect();
+  await tick();
+  return { controller, client, sink };
+}
+
+// rows for PATCH: file(0), hunk(1), ctx(2), del(3), add(4), ctx(5)
+describe("diff hunk curation", () => {
+  test("rejecting the only change writes an empty curated working copy", async () => {
+    // Arrange
+    const { controller, sink } = await connected(diffSession(FILES));
+
+    // Act - reject the change on the added line
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert
+    expect(controller.getSnapshot().status).toContain("change rejected");
+    expect(sink.workingCopy).toBe("");
+  });
+
+  test("both the deletion and addition rows of the change dim", async () => {
+    // Arrange
+    const { controller } = await connected(diffSession(FILES));
+
+    // Act
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - the change spans the del row and the add row
+    expect([...controller.rejectedRows()].sort((a, b) => a - b)).toEqual([3, 4]);
+  });
+
+  test("toggling the same change twice restores the full diff", async () => {
+    // Arrange
+    const { controller, sink } = await connected(diffSession(FILES));
+
+    // Act - reject then restore
+    controller.toggleRejectChange(4);
+    await tick();
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - no decisions left, so the working copy reverts to undefined
+    expect(controller.getSnapshot().status).toContain("change restored");
+    expect(sink.workingCopy).toBeUndefined();
+    expect(controller.rejectedRows().size).toBe(0);
+  });
+
+  test("whole-hunk reject drops the hunk from the working copy", async () => {
+    // Arrange
+    const { controller, sink } = await connected(diffSession(FILES));
+
+    // Act - reject the whole hunk from any of its rows
+    controller.toggleRejectHunk(3);
+    await tick();
+
+    // Assert - the single hunk is the whole diff, so nothing remains
+    expect(controller.getSnapshot().status).toContain("hunk rejected");
+    expect(sink.workingCopy).toBe("");
+  });
+
+  test("a rejected change becomes a removal card with a source, id, and preview", async () => {
+    // Arrange
+    const { controller } = await connected(diffSession(FILES));
+
+    // Act
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert - one item: diff source, revealing the change's row, both lines previewed
+    const items = controller.curationItems();
+    expect(items.length).toBe(1);
+    expect(items[0]!.source).toBe("diff");
+    expect(items[0]!.id).toBe("diff:src/store.ts#0#1");
+    expect(items[0]!.revealIndex).toBe(3);
+    expect(items[0]!.preview).toEqual([
+      "-   private items = [];",
+      "+   private items = new Map();",
+    ]);
+  });
+
+  test("a rejected hunk becomes a removal card with the whole-hunk id", async () => {
+    // Arrange
+    const { controller } = await connected(diffSession(FILES));
+
+    // Act
+    controller.toggleRejectHunk(3);
+    await tick();
+
+    // Assert - the whole hunk, id diff:path#hunk#hunk
+    const items = controller.curationItems();
+    expect(items.length).toBe(1);
+    expect(items[0]!.source).toBe("diff");
+    expect(items[0]!.id).toBe("diff:src/store.ts#0#hunk");
+  });
+
+  test("restoreCuration drops the diff removal and reverts the working copy", async () => {
+    // Arrange - one change rejected
+    const { controller, sink } = await connected(diffSession(FILES));
+    controller.toggleRejectChange(4);
+    await tick();
+    const [item] = controller.curationItems();
+
+    // Act
+    controller.restoreCuration(item!.id);
+    await tick();
+
+    // Assert - the list empties and the working copy reverts to the full diff
+    expect(controller.getSnapshot().status).toContain("removal restored");
+    expect(controller.curationItems().length).toBe(0);
+    expect(sink.workingCopy).toBeUndefined();
+    expect(controller.rejectedRows().size).toBe(0);
+  });
+
+  test("restoreCuration ignores an unknown id", async () => {
+    // Arrange - one change rejected
+    const { controller } = await connected(diffSession(FILES));
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Act
+    controller.restoreCuration("diff:nope#0#0");
+    await tick();
+
+    // Assert - the item stays
+    expect(controller.curationItems().length).toBe(1);
+  });
+
+  test("curation is disabled without full file contents", async () => {
+    // Arrange - a legacy diff with no artifact.files
+    const { controller, sink } = await connected(diffSession(undefined));
+
+    // Act
+    controller.toggleRejectChange(4);
+    await tick();
+
+    // Assert
+    expect(controller.getSnapshot().status).toContain("hunk curation needs full file contents");
+    expect(sink.workingCopy).toBeUndefined();
+  });
+});
+
+const PLAN_CONTENT = "# Title\n\nFirst paragraph.\n\nSecond paragraph.\n";
+// the working copy with the "Second paragraph." block cut out
+const PLAN_CUT = "# Title\n\nFirst paragraph.\n";
+
+function planSession(workingCopy?: string): ReviewSession {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_plan",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: PLAN_CONTENT, meta: {} },
+    revisions: [{ revision: 1, content: PLAN_CONTENT, submittedAt: "2026-01-01T00:00:00.000Z" }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    workingCopy,
+  };
+}
+
+describe("plan cut removals", () => {
+  test("a cut block becomes a plan removal card previewing its content", async () => {
+    // Arrange - a plan whose working copy dropped the second paragraph
+    const { controller } = await connected(planSession(PLAN_CUT));
+
+    // Act
+    const items = controller.curationItems();
+
+    // Assert - one plan-source removal, keyed on the base line range, content previewed
+    expect(items.length).toBe(1);
+    expect(items[0]!.source).toBe("plan");
+    expect(items[0]!.id).toBe("plan:4-4");
+    expect(items[0]!.preview).toEqual(["Second paragraph."]);
+  });
+
+  test("restoreCuration re-inserts the cut block and returns to pristine", async () => {
+    // Arrange
+    const { controller, sink } = await connected(planSession(PLAN_CUT));
+    const [item] = controller.curationItems();
+
+    // Act
+    controller.restoreCuration(item!.id);
+    await tick();
+
+    // Assert - restoring the only cut round-trips to the submitted revision
+    expect(controller.getSnapshot().status).toContain("removal restored");
+    expect(sink.workingCopy).toBeUndefined();
+  });
+});