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

package/src/keymap.test.ts

@@ -126,14 +126,15 @@ describe("plan normal mode", () => {
     ["v", false, [{ t: "startSpan" }]],
     ["c", false, [{ t: "openCompose", kind: "comment", from: "cursor" }]],
     ["s", false, [{ t: "openCompose", kind: "suggestion", from: "cursor" }]],
-    ["x", false, [{ t: "cut" }]],
-    ["e", false, [{ t: "edit" }]],
+    // 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, []],
+    ["escape", false, [{ t: "deselect" }]],
     ["z", false, []],
   ];
   for (const [name, shift, expected] of table) {
@@ -164,6 +165,12 @@ describe("plan normal mode", () => {
     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", () => {

package/src/keymap.ts

@@ -20,9 +20,11 @@ export type Intent =
   | { t: "openSubmit" }
   | { t: "cut" }
   | { t: "edit" }
+  | { t: "editCard" }
   | { t: "nextAnn" }
   | { t: "prevAnn" }
   | { t: "removeAnnotation" }
+  | { t: "deselect" }
   | { t: "closeOverlay" }
   | { t: "saveCompose" }
   | { t: "submitVerdict" }
@@ -92,7 +94,7 @@ export function reduceKey(state: KeyState, key: KeyInput): Intent[] {
   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);
+  return planGrammar(state, action, name);
 }
 
 function inboxGrammar(state: KeyState, name: string): Intent[] {
@@ -128,9 +130,10 @@ function spanGrammar(name: string): Intent[] {
   return [];
 }
 
-function planGrammar(state: KeyState, action: string | undefined): Intent[] {
+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");
@@ -139,6 +142,9 @@ function planGrammar(state: KeyState, action: string | undefined): Intent[] {
   }
   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) ?? [];

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, {

package/src/session-controller.ts

@@ -12,6 +12,8 @@ import {
   cutBlock,
   makeAnchor,
   newAnnotationId,
+  parseBlocks,
+  resolveAnchor,
   restoreBlock,
   restoreLine,
   type ReviewSession,
@@ -42,6 +44,11 @@ export interface ControllerSnapshot {
   status: string;
   error: string | null;
   completion: Completion;
+  /**
+   * Annotations whose anchor stopped resolving after the last editor
+   * hand-off - the reconciliation banner count. 0 = no banner.
+   */
+  editOrphanCount: number;
 }
 
 export interface ReviewControllerOptions {
@@ -73,8 +80,13 @@ export interface ReviewController {
   cut(dispIdx: number): void;
   /** The $EDITOR hand-off on the working copy. */
   edit(): void;
-  /** Anchor and store an annotation; both plan and diff anchor constructions. */
-  annotate(kind: "comment" | "suggestion", dispIdx: number, start: number, end: number, body: string): void;
+  /**
+   * Anchor and store an annotation; both plan and diff anchor constructions.
+   * Returns the minted annotation id so the view can select the new card.
+   */
+  annotate(kind: "comment" | "suggestion", dispIdx: number, start: number, end: number, body: string): string | undefined;
+  /** Rewrite a stored annotation's body in place (the rail-card edit). */
+  updateAnnotation(id: string, body: string): void;
   removeAnnotation(id: string): void;
   setWorkingCopy(content: string | undefined): void;
   /** Resolve the review, run the export, start the completion hand-back. */
@@ -100,6 +112,7 @@ class Controller implements ReviewController {
     status: "",
     error: null,
     completion: { phase: "idle" },
+    editOrphanCount: 0,
   };
   private listeners = new Set<() => void>();
   private autoClose: AutoClose = "off";
@@ -244,6 +257,7 @@ class Controller implements ReviewController {
       const result = editInEditor(this.working(), "plan.md");
       if (result.changed) {
         this.setWorkingCopy(result.content);
+        this.reconcileAnnotations(session, result.content);
         this.setStatus("edits tracked - one diff");
       } else this.setStatus("no changes");
     } catch (err) {
@@ -251,9 +265,29 @@ class Controller implements ReviewController {
     }
   }
 
-  annotate(kind: "comment" | "suggestion", dispIdx: number, start: number, end: number, body: string): void {
+  /**
+   * Edit-exit reconciliation: re-resolve every annotation against the edited
+   * working copy with the quote-primary cascade. Annotations that stop
+   * resolving stay stored (the feedback serializer flags orphaned anchors);
+   * the count feeds the one-line banner above the sheet.
+   */
+  private reconcileAnnotations(session: ReviewSession, editedContent: string): void {
+    const editedBlocks = parseBlocks(editedContent);
+    const orphanCount = session.annotations.filter(
+      (annotation) => resolveAnchor(annotation.anchor, editedBlocks) === null,
+    ).length;
+    this.update({ editOrphanCount: orphanCount });
+  }
+
+  annotate(
+    kind: "comment" | "suggestion",
+    dispIdx: number,
+    start: number,
+    end: number,
+    body: string,
+  ): string | undefined {
     const session = this.snap.session;
-    if (!session) return;
+    if (!session) return undefined;
     let anchor;
     if (session.artifact.type === "diff") {
       anchor = { ...diffRowAnchor(this.rows(), dispIdx), blockIndex: dispIdx };
@@ -263,15 +297,34 @@ class Controller implements ReviewController {
       const workIdx = display.slice(0, dispIdx + 1).filter((d) => d.work).length - 1;
       anchor = makeAnchor(workBlocks, workIdx, start, end);
     }
+    const annotationId = newAnnotationId();
     this.apply(
       this.client!.sessionAnnotate(session.id, {
-        id: newAnnotationId(),
+        id: annotationId,
         kind,
         anchor,
         body,
       }),
     );
     this.setStatus(kind === "suggestion" ? "suggestion added - the agent applies it" : "comment added");
+    return annotationId;
+  }
+
+  updateAnnotation(id: string, body: string): void {
+    const session = this.snap.session;
+    if (!session) return;
+    const existing = session.annotations.find((annotation) => annotation.id === id);
+    if (!existing) return;
+    // the daemon's annotate verb upserts by id: same id + anchor, new body
+    this.apply(
+      this.client!.sessionAnnotate(session.id, {
+        id: existing.id,
+        kind: existing.kind,
+        anchor: existing.anchor,
+        body,
+      }),
+    );
+    this.setStatus("annotation updated");
   }
 
   removeAnnotation(id: string): void {

package/src/view.ts

@@ -218,7 +218,11 @@ export function overlayMarks(runs: StyleRun[], marks: Mark[]): StyleRun[] {
   return out;
 }
 
-/** Wrap styled runs into lines of at most `width` display cells. */
+/**
+ * Wrap styled runs into lines of at most `width` display cells. Split pieces
+ * keep exact `start` offsets into the block text, so wrapped lines stay
+ * addressable for the native selection primitive.
+ */
 export function wrapRuns(runs: StyleRun[], width: number): StyleRun[][] {
   const lines: StyleRun[][] = [];
   let line: StyleRun[] = [];
@@ -231,20 +235,29 @@ export function wrapRuns(runs: StyleRun[], width: number): StyleRun[][] {
   for (const run of runs) {
     // split run into word/space tokens; newlines force breaks
     const tokens = run.text.split(/(\n|\s+)/).filter((t) => t !== "");
+    let consumed = 0;
+    const startAt = (offsetInRun: number): number | null => (run.start === null ? null : run.start + offsetInRun);
     for (const tok of tokens) {
       if (tok === "\n") {
+        consumed += 1;
         pushLine();
         continue;
       }
       if (used + tok.length > width && used > 0 && tok.trim() !== "") pushLine();
-      if (tok.trim() === "" && used === 0 && lines.length > 0) continue; // no leading spaces after wrap
+      if (tok.trim() === "" && used === 0 && lines.length > 0) {
+        consumed += tok.length;
+        continue; // no leading spaces after wrap
+      }
       let slice = tok;
       while (slice.length > width) {
-        line.push({ ...run, text: slice.slice(0, width - used) });
-        slice = slice.slice(width - used);
+        const piece = slice.slice(0, width - used);
+        line.push({ ...run, text: piece, start: startAt(consumed) });
+        consumed += piece.length;
+        slice = slice.slice(piece.length);
         pushLine();
       }
-      line.push({ ...run, text: slice });
+      line.push({ ...run, text: slice, start: startAt(consumed) });
+      consumed += slice.length;
       used += slice.length;
     }
   }
@@ -252,6 +265,45 @@ export function wrapRuns(runs: StyleRun[], width: number): StyleRun[][] {
   return lines;
 }
 
+/**
+ * Locate a block-text offset inside wrapped run lines: the wrapped line index
+ * and the column within the line's rendered run text. Drives the renderer's
+ * native selection from keyboard span offsets.
+ */
+export function locateOffset(lines: StyleRun[][], offset: number): { lineIndex: number; column: number } | null {
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    let column = 0;
+    for (const run of lines[lineIndex]!) {
+      if (run.start !== null && offset >= run.start && offset < run.start + run.text.length) {
+        return { lineIndex, column: column + (offset - run.start) };
+      }
+      column += run.text.length;
+    }
+  }
+  return null;
+}
+
+/**
+ * Inline compose box height, shared by layout and render so the row math and
+ * the mounted box never drift: top border (title), the single-row input, the
+ * Save/Cancel button row, bottom border.
+ */
+export function composeBoxHeight(): number {
+  return 4;
+}
+
+/** Line delta between two revision contents, for the sheet-header summary. */
+export function revisionDelta(previousContent: string, nextContent: string): { added: number; removed: number } {
+  const ops = lcsDiff(previousContent.split("\n"), nextContent.split("\n"), (a, b) => a === b);
+  let added = 0;
+  let removed = 0;
+  for (const op of ops) {
+    if (op.t === "add") added++;
+    else if (op.t === "del") removed++;
+  }
+  return { added, removed };
+}
+
 // ── keyboard span mode ────────────────────────
 
 export interface SpanState {