nexrall-code 0.5.107 → 0.5.108

package/dist/ui/inkReadlineAdapter.js

@@ -0,0 +1,116 @@
+import { EventEmitter } from 'events';
+// ─── readline.Interface-shaped Adapter over Ink ────────────────────────────
+//
+// chat.ts's ~1500 lines of business logic (slash commands, session
+// persistence, agent-turn orchestration…) only ever touch 7 members of the
+// readline.Interface surface: `.on('line', …)`, `.line`, `.cursor`, `.pause()`,
+// `.resume()`, `.prompt()`, `.close()` — plus `.question(query, cb)` for the
+// shared-interface permission-prompt reuse in permissions/handler.ts. Rather
+// than rewriting every one of those call sites to talk to Ink directly (a
+// much larger, much riskier change), this adapter implements exactly that
+// surface backed by the Ink app's input state — so chat.ts's existing
+// `rl.on('line', …)`/`rl.pause()`/`rl.resume()` code keeps working verbatim,
+// it just now reads from/writes to Ink's React state under the hood instead
+// of a real readline.Interface.
+//
+// ─── `pause()`/`resume()` no longer disable the input box ──────────────────
+//
+// They used to call `ink.setInputEnabled(false/true)`, which made Ink's
+// `useInput` bail out on EVERY keystroke while an agent turn was running —
+// no typing, no cursor movement, and (the worst of it) no Ctrl+C and no
+// answering a permission y/n prompt fired mid-turn via `question()`, because
+// that prompt is answered through the SAME input pipeline. A permission
+// question asked while `rl.pause()` was in effect could never be answered at
+// all — verified directly with an isolated harness that called `askLine()`
+// after `setInputEnabled(false)`: it hung indefinitely.
+//
+// `pause()`/`resume()` now toggle `ink.setBusy()` instead, which keeps every
+// keystroke flowing (see inkTerminal.tsx's useInput) and only changes what a
+// submitted line does: while busy, Enter without an outstanding askLine()
+// question queues the text (mirrors the VS Code panel's `_pendingInjections`)
+// instead of emitting `'line'` — which would otherwise start a SECOND
+// concurrent turn on top of the one already running.
+export class InkReadlineAdapter extends EventEmitter {
+    // Kept for API parity with readline.Interface; Ink owns the actual typed
+    // text internally (the input box's own React state), so these are not
+    // read from live — chat.ts never reads them for this adapter's usage.
+    line = '';
+    cursor = 0;
+    ink;
+    busy = false;
+    pendingInput = [];
+    constructor(ink) {
+        super();
+        this.ink = ink;
+        this.ink.onLine((text) => {
+            // Historically this checked `this.paused` and dropped the line
+            // entirely — the mechanism that made typing during a turn a dead end.
+            // Ordinary (non-busy) submits always reach chat.ts's `rl.on('line', …)`
+            // now; busy-time submits go through onQueuedLine below instead, so
+            // this handler firing at all already implies "not busy" (inkTerminal's
+            // Enter branch routes to onLine vs onQueuedLine based on the same
+            // `busy` flag chat.ts sets here).
+            this.emit('line', text);
+        });
+        this.ink.onQueuedLine((text) => {
+            this.pendingInput.push(text);
+        });
+        this.ink.onInterrupt(() => {
+            this.emit('interrupt');
+        });
+        // Ink is exiting (a confirmed Ctrl+C quit, or stdin ending). A real
+        // readline.Interface emits 'close' when its input ends, and chat.ts's
+        // `rl.on('close')` is the ONLY place an interactive session persists the
+        // conversation on the way out — it saves, prints "Goodbye." and exits.
+        //
+        // Nothing used to trigger it for this adapter: `close()` below called
+        // straight through to Ink and never emitted the event, and the main Ink
+        // app's exit was never observed at all (no waitUntilExit subscriber). So
+        // quitting an interactive session with Ctrl+C silently DISCARDED the
+        // whole conversation — verified with an isolated harness: rl.close()
+        // fired no 'close' listener. That was survivable while Ctrl+C was an
+        // undocumented instant-kill; now that it is the confirmed, deliberate way
+        // to leave a session, losing the transcript is not acceptable.
+        this.ink.onExit(() => {
+            this.emit('close');
+        });
+    }
+    prompt(_preserveCursor) {
+        // No-op: Ink re-renders the input box reactively on every state change,
+        // there is no separate "draw the prompt now" step to trigger — unlike
+        // the previous hand-rolled split-screen renderer, which needed an
+        // explicit redraw call at specific points.
+    }
+    pause() {
+        this.busy = true;
+        this.ink.setBusy(true);
+        return this;
+    }
+    resume() {
+        this.busy = false;
+        this.ink.setBusy(false);
+        return this;
+    }
+    close() {
+        this.ink.close();
+    }
+    /** Compatible with readline.Interface#question — used by permissions/handler.ts's shared-interface reuse. */
+    question(query, cb) {
+        this.ink.askLine(query).then(cb);
+    }
+    /**
+     * Drains and returns every follow-up message the user typed and sent while
+     * `pause()` was active (i.e. during a running agent turn). Intended to be
+     * passed straight through as `AgentLoopOptions.takePendingInput` — see
+     * loop.ts, and the VS Code panel's `_pendingInjections.splice(0)` for the
+     * pattern this mirrors. Returns `[]` when nothing is queued, and empties
+     * the queue on every call so the same follow-up is never folded in twice.
+     */
+    takePendingInput() {
+        return this.pendingInput.splice(0);
+    }
+    /** True while a `pause()`/`resume()` pair is in effect (an agent turn is running). */
+    isBusy() {
+        return this.busy;
+    }
+}