@cueloop/client 0.1.0-alpha.66 → 0.1.0-alpha.68

package/src/test-support.test.ts

@@ -14,6 +14,7 @@ import {
   frameRow,
   isolateUserConfig,
   locateText,
+  locateTextInFrame,
   pressKey,
   waitForText,
   type FrameLocation,
@@ -25,7 +26,7 @@ describe("isolateUserConfig", () => {
     const home = mkdtempSync(join(tmpdir(), "cueloop-isolate-"));
     const userConfigPath = join(home, "config.toml");
 
-    writeFileSync(userConfigPath, '[ui]\nreview_state = "compact"\n');
+    writeFileSync(userConfigPath, "[ui]\nauto_close = 5\n");
     const priorEnv = process.env.CUELOOP_CONFIG;
 
     process.env.CUELOOP_CONFIG = userConfigPath;
@@ -39,9 +40,9 @@ describe("isolateUserConfig", () => {
       const restored = loadConfig({ repoRoot: home });
 
       // Assert
-      expect(isolated.ui.reviewState).toBe("expanded");
+      expect(isolated.ui.autoClose).toBe("off");
       expect(process.env.CUELOOP_CONFIG).toBe(userConfigPath);
-      expect(restored.ui.reviewState).toBe("compact");
+      expect(restored.ui.autoClose).toBe(5);
     } finally {
       if (priorEnv === undefined) delete process.env.CUELOOP_CONFIG;
       else process.env.CUELOOP_CONFIG = priorEnv;
@@ -250,3 +251,14 @@ describe("dragText", () => {
     expect(log.mouseEvents).toContainEqual({ type: "up", x: 9, y: 3 });
   });
 });
+
+describe("locateTextInFrame", () => {
+  test("finds the 0-based row and column of the first match, null when absent", () => {
+    // Arrange
+    const frame = "header\n  ● draft here\nfooter";
+
+    // Act + Assert
+    expect(locateTextInFrame(frame, "draft")).toEqual({ row: 1, column: 4 });
+    expect(locateTextInFrame(frame, "missing")).toBeNull();
+  });
+});

package/src/test-support.ts

@@ -1,7 +1,7 @@
 /**
- * Shared driving helpers for the virtual-terminal App suites: key presses
- * settle through a macrotask yield (input parser + React scheduler), one
- * render pass, and the renderer's visual-idle wait - no fixed-duration
+ * Shared driving helpers for the virtual-terminal App suites: an input settles
+ * when its painted frame stops changing across consecutive event-loop turns
+ * (macrotask yield, render pass, visual-idle wait per turn) - no fixed-duration
  * sleeps. Waits on daemon round-trips go through waitForFrame/waitFor with
  * generous pass budgets.
  */
@@ -12,6 +12,16 @@ import type { TestRendererSetup } from "@opentui/core/testing";
 /** Pass budget for waits that include daemon or subprocess round-trips. */
 export const WAIT_PASSES = { maxPasses: 400 };
 
+/**
+ * The CUELOOP_CONFIG path that isolates a test from the developer's real user
+ * config: a file inside the test home that does not exist unless the test
+ * writes it. Subprocess harnesses set this in the child env; in-process suites
+ * use `isolateUserConfig`.
+ */
+export function isolatedUserConfigPath(home: string, fileName = "no-config.toml"): string {
+  return join(home, fileName);
+}
+
 /**
  * Isolate the user config: point CUELOOP_CONFIG into the test home so
  * loadConfig never reads the developer's real ~/.config/cueloop (a persisted
@@ -20,10 +30,10 @@ export const WAIT_PASSES = { maxPasses: 400 };
  * defaults; pass a file name for suites that write and assert a config of
  * their own. Call in beforeEach; invoke the returned restore in afterEach.
  */
-export function isolateUserConfig(home: string, fileName = "no-config.toml"): () => void {
+export function isolateUserConfig(home: string, fileName?: string): () => void {
   const priorUserConfig = process.env.CUELOOP_CONFIG;
 
-  process.env.CUELOOP_CONFIG = join(home, fileName);
+  process.env.CUELOOP_CONFIG = isolatedUserConfigPath(home, fileName);
 
   return () => {
     if (priorUserConfig === undefined) delete process.env.CUELOOP_CONFIG;
@@ -40,15 +50,44 @@ export function allowEventLoopUpdates(): void {
   globalThis.IS_REACT_ACT_ENVIRONMENT = false;
 }
 
+/** Turns of the event loop a frame must survive unchanged before an input counts as settled. */
+const SETTLE_QUIET_TURNS = 2;
+
+/** Upper bound on settle turns, so a surface that keeps changing never stalls a test. */
+const SETTLE_MAX_TURNS = 40;
+
+/** The painted frame with its colors, so a caret cell (background only) counts as a change. */
+function paintedFrame(setup: TestRendererSetup): string {
+  return JSON.stringify(
+    setup
+      .captureSpans()
+      .lines.map((line) =>
+        line.spans.map((span) => [span.text, span.fg?.toInts(), span.bg?.toInts()]),
+      ),
+  );
+}
+
 /**
- * One macrotask yield lets the input parser and the React scheduler run,
- * then a render pass commits the result before the visual-idle wait.
+ * Wait for an input to land: React commits its state on its own scheduler, which the renderer's
+ * idle check cannot see, so on a slow machine a single idle wait returns between the key and its
+ * paint. Instead, run turns of the loop until the painted frame is unchanged across
+ * `SETTLE_QUIET_TURNS` consecutive turns.
  */
 export async function settle(setup: TestRendererSetup): Promise<void> {
   allowEventLoopUpdates();
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  await setup.renderOnce();
-  await setup.waitForVisualIdle();
+  let previous = "";
+  let quietTurns = 0;
+
+  for (let turn = 0; turn < SETTLE_MAX_TURNS; turn++) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await setup.renderOnce();
+    await setup.waitForVisualIdle();
+    const frame = paintedFrame(setup);
+
+    quietTurns = frame === previous ? quietTurns + 1 : 0;
+    if (quietTurns >= SETTLE_QUIET_TURNS) return;
+    previous = frame;
+  }
 }
 
 /** Drive one key press: letters type as text; named keys use KeyCodes ids. */
@@ -58,6 +97,8 @@ export async function press(setup: TestRendererSetup, key: string): Promise<void
   else if (key === "backspace") setup.mockInput.pressKey("BACKSPACE");
   else if (key === "left") setup.mockInput.pressKey("ARROW_LEFT");
   else if (key === "right") setup.mockInput.pressKey("ARROW_RIGHT");
+  else if (key === "up") setup.mockInput.pressKey("ARROW_UP");
+  else if (key === "down") setup.mockInput.pressKey("ARROW_DOWN");
   else return typeText(setup, key);
   await settle(setup);
 }
@@ -83,17 +124,27 @@ export interface FrameLocation {
   column: number;
 }
 
-/** Locate the first visual line containing the needle: 0-based row and start column. */
-export function locateText(setup: TestRendererSetup, needle: string): FrameLocation {
-  const frame = setup.captureCharFrame();
-
+/** Locate the first line of a text frame containing the needle; null when absent. */
+export function locateTextInFrame(frame: string, needle: string): FrameLocation | null {
   for (const [row, line] of frame.split("\n").entries()) {
     const column = line.indexOf(needle);
 
     if (column !== -1) return { row, column };
   }
 
-  throw new Error(`locateText ${JSON.stringify(needle)} not found.\nframe:\n${frame}`);
+  return null;
+}
+
+/** Locate the first visual line containing the needle: 0-based row and start column. */
+export function locateText(setup: TestRendererSetup, needle: string): FrameLocation {
+  const frame = setup.captureCharFrame();
+  const location = locateTextInFrame(frame, needle);
+
+  if (location === null) {
+    throw new Error(`locateText ${JSON.stringify(needle)} not found.\nframe:\n${frame}`);
+  }
+
+  return location;
 }
 
 /** The 0-based visual row of the needle - for relative vertical-layout assertions. */

package/src/thread-chords.test.ts

@@ -21,8 +21,31 @@ describe("resolveThreadChord", () => {
     // Assert
     expect(resolveThreadChord({ name: "e", ctrl: true }, owner)).toEqual({ type: "edit" });
     expect(resolveThreadChord({ name: "s", ctrl: true }, owner)).toEqual({ type: "share" });
-    expect(resolveThreadChord({ name: "r", ctrl: true }, owner)).toEqual({
-      type: "cycleReviewPanel",
+  });
+
+  test("in a diff, option chords act on the caret's row and file; the rest still reach the rail", () => {
+    // Arrange
+    const diff = { ...owner, isDiff: true };
+
+    // Assert - the code-row primitives
+    expect(resolveThreadChord({ name: "x", meta: true }, diff)).toEqual({ type: "rejectChange" });
+    expect(resolveThreadChord({ name: "X", meta: true }, diff)).toEqual({ type: "rejectHunk" });
+    expect(resolveThreadChord({ name: "u", meta: true }, diff)).toEqual({
+      type: "restoreCuration",
+    });
+    expect(resolveThreadChord({ name: "c", meta: true }, diff)).toEqual({ type: "foldFile" });
+    expect(resolveThreadChord({ name: "d", meta: true }, diff)).toEqual({ type: "toggleDiffView" });
+    expect(resolveThreadChord({ name: "k", meta: true }, diff)).toEqual({ type: "walkStart" });
+    // the rail letters are untouched
+    expect(resolveThreadChord({ name: "n", meta: true }, diff)).toEqual({ type: "nextAnnotation" });
+    // rejecting is the owner's, and closed once resolved
+    expect(resolveThreadChord({ name: "x", meta: true }, { ...diff, isOwner: false })).toEqual({
+      type: "status",
+      message: "observer - read-only",
+    });
+    expect(resolveThreadChord({ name: "k", meta: true }, { ...diff, resolved: true })).toEqual({
+      type: "status",
+      message: "review submitted - read-only",
     });
   });
 
@@ -43,10 +66,6 @@ describe("resolveThreadChord", () => {
     expect(resolveThreadChord({ name: "u", meta: true }, owner)).toEqual({
       type: "restoreCuration",
     });
-    expect(resolveThreadChord({ name: "w", meta: true }, owner)).toEqual({
-      type: "resizeReviewPanel",
-      direction: 1,
-    });
     expect(resolveThreadChord({ name: "x", meta: true }, { ...owner, isOwner: false })).toEqual({
       type: "status",
       message: "observer - read-only",
@@ -76,9 +95,6 @@ describe("resolveThreadChord", () => {
     expect(resolveThreadChord({ name: "return", ctrl: true }, collaborator)).toEqual(readOnly);
     expect(resolveThreadChord({ name: "e", ctrl: true }, collaborator)).toEqual(readOnly);
     expect(resolveThreadChord({ name: "s", ctrl: true }, collaborator)).toEqual(readOnly);
-    expect(resolveThreadChord({ name: "r", ctrl: true }, collaborator)).toEqual({
-      type: "cycleReviewPanel",
-    });
     expect(
       resolveThreadChord({ name: "return", ctrl: true }, { ...owner, resolved: true }),
     ).toBeNull();

package/src/thread-chords.ts

@@ -24,8 +24,19 @@ export interface ThreadChordContext {
   resolved: boolean;
   /** The rail shows the tree: next / previous move its selection instead of the cards. */
   treeActive: boolean;
+  /** A diff review: the block chords act on the code row under the caret (reject, fold, walk). */
+  isDiff?: boolean;
 }
 
+/** The diff-review chords: option plus a letter, acting on the caret's row or file. */
+export const DIFF_CHORD_ENTRIES = [
+  { keys: "⌥x / ⌥X", label: "reject the change / the hunk" },
+  { keys: "⌥u", label: "restore the last rejection" },
+  { keys: "⌥c", label: "collapse the file to its band" },
+  { keys: "⌥d", label: "unified / split (when zoomed)" },
+  { keys: "⌥k", label: "start the guided walk" },
+] as const;
+
 /** The cheatsheet rows for the chords, in the same order they are resolved. */
 export const THREAD_CHORD_ENTRIES = [
   { keys: "⌃enter", label: "submit the review" },
@@ -70,11 +81,32 @@ export function resolveThreadChord(
     return context.resolved ? null : { type: "openSubmit" };
   }
   if (key.ctrl) return resolveSessionChord(key.name, context);
-  if (key.meta) return resolveRailChord(key.name, context);
+  if (key.meta)
+    return (
+      (context.isDiff && resolveDiffChord(key.name, context)) || resolveRailChord(key.name, context)
+    );
 
   return null;
 }
 
+/** The diff's row and file chords; null lets the rail chords answer the letter. */
+function resolveDiffChord(name: string, context: ThreadChordContext): Intent | null {
+  switch (name) {
+    case "x":
+      return mutating({ type: "rejectChange" }, context);
+    case "X":
+      return mutating({ type: "rejectHunk" }, context);
+    case "c":
+      return { type: "foldFile" };
+    case "d":
+      return { type: "toggleDiffView" };
+    case "k":
+      return context.resolved ? RESOLVED : { type: "walkStart" };
+    default:
+      return null;
+  }
+}
+
 /** The answers a blocked primitive gets - the same words the keymap uses. */
 const READ_ONLY: Intent = { type: "status", message: "observer - read-only" };
 const RESOLVED: Intent = { type: "status", message: "review submitted - read-only" };
@@ -93,8 +125,6 @@ function resolveSessionChord(name: string, context: ThreadChordContext): Intent
       return mutating({ type: "edit" }, context);
     case "s":
       return context.isOwner ? { type: "share" } : READ_ONLY;
-    case "r":
-      return { type: "cycleReviewPanel" };
     default:
       return null;
   }
@@ -133,11 +163,6 @@ function resolveRailChord(name: string, context: ThreadChordContext): Intent | n
       return mutating({ type: "cut" }, context);
     case "u":
       return mutating({ type: "restoreCuration" }, context);
-    // letters only: escape-prefixed punctuation reads as control sequences, not keys
-    case "w":
-      return { type: "resizeReviewPanel", direction: 1 };
-    case "s":
-      return { type: "resizeReviewPanel", direction: -1 };
     default:
       return null;
   }