@kinqs/brainrouter-cli 0.3.5 → 0.3.7

package/dist/cli/ink/runPicker.js

@@ -0,0 +1,139 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Picker } from './Picker.js';
+import { TextField } from './TextField.js';
+import { NoTTYError } from '../cliPrompt.js';
+import { resetStdinForReadline, snapshotStdinListeners } from './stdinHandoff.js';
+import { getAmbientChat } from './ambientChat.js';
+import { renderWithResizeClear } from './renderWithResizeClear.js';
+/**
+ * One-shot Ink mount helpers. Used by `/config`, `/login`, and any
+ * slash command that needs a single picker / text prompt without
+ * managing Ink lifecycle by hand.
+ *
+ * Two paths:
+ *
+ *   1. **Overlay path** — when the Ink chat REPL is running, the
+ *      ambient ChatController is set (see ambientChat.ts +
+ *      runChat.tsx). We render <Picker> inside the chat's overlay
+ *      slot, NOT as a second Ink mount — that would race the chat
+ *      for stdin + terminal state and break the picker's interaction.
+ *
+ *   2. **Standalone path** — for the legacy readline REPL, mount a
+ *      fresh Ink instance. Unmount via `instance.unmount()` from
+ *      outside the React tree (no `useApp().exit()`) so the wrapper
+ *      doesn't risk exiting the wrong Ink instance if something goes
+ *      sideways. The Picker/TextField components are exit-agnostic;
+ *      they call onResolve and trust the caller to handle unmount.
+ *
+ * Stdin handoff for the standalone path: snapshot + detach existing
+ * listeners before mount, restore them and reset stdin state after
+ * Ink unmounts (matches the pattern in runWizard.tsx / runSlashPalette).
+ */
+// --- Picker -----------------------------------------------------------
+export async function runPicker(opts) {
+    // OVERLAY PATH — running inside the Ink chat REPL.
+    const ambient = getAmbientChat();
+    if (ambient) {
+        return new Promise((resolve) => {
+            let resolved = false;
+            const overlayNode = (_jsx(Picker, { ...opts, onResolve: (r) => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    ambient.clearOverlay();
+                    resolve(r);
+                } }));
+            ambient.showOverlay(overlayNode).catch(() => {
+                if (!resolved) {
+                    resolved = true;
+                    resolve({ kind: 'cancelled' });
+                }
+            });
+        });
+    }
+    // STANDALONE PATH — readline REPL fallback. Mounts a fresh Ink.
+    if (!process.stdin.isTTY) {
+        throw new NoTTYError('runPicker requires an interactive TTY.');
+    }
+    const snap = snapshotStdinListeners(['keypress', 'data']);
+    return new Promise((resolve) => {
+        let captured;
+        // We need `instance` inside the onResolve closure but it doesn't
+        // exist yet when we build the JSX. Use a forward-declared variable
+        // that the closure captures by reference and we assign before the
+        // user can possibly interact with the picker. instance.unmount()
+        // is cleaner than useApp().exit() — works even if the Picker
+        // somehow ends up rendered in the wrong Ink tree.
+        let instance;
+        const node = (_jsx(Picker, { ...opts, onResolve: (r) => {
+                if (!captured)
+                    captured = r;
+                if (instance)
+                    instance.unmount();
+            } }));
+        const mounted = renderWithResizeClear(node, { exitOnCtrlC: true });
+        instance = mounted.instance;
+        instance.waitUntilExit().then(() => {
+            mounted.cleanupResizeClear();
+            snap.restore();
+            resetStdinForReadline();
+            resolve(captured ?? { kind: 'cancelled' });
+        }).catch(() => {
+            mounted.cleanupResizeClear();
+            snap.restore();
+            resetStdinForReadline();
+            resolve(captured ?? { kind: 'cancelled' });
+        });
+    });
+}
+// --- TextField --------------------------------------------------------
+export async function runTextField(opts) {
+    // OVERLAY PATH
+    const ambient = getAmbientChat();
+    if (ambient) {
+        return new Promise((resolve) => {
+            let resolved = false;
+            const overlayNode = (_jsx(TextField, { ...opts, onResolve: (r) => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    ambient.clearOverlay();
+                    resolve(r);
+                } }));
+            ambient.showOverlay(overlayNode).catch(() => {
+                if (!resolved) {
+                    resolved = true;
+                    resolve({ kind: 'cancelled' });
+                }
+            });
+        });
+    }
+    // STANDALONE PATH
+    if (!process.stdin.isTTY) {
+        throw new NoTTYError('runTextField requires an interactive TTY.');
+    }
+    const snap = snapshotStdinListeners(['keypress', 'data']);
+    return new Promise((resolve) => {
+        let captured;
+        let instance;
+        const node = (_jsx(TextField, { ...opts, onResolve: (r) => {
+                if (!captured)
+                    captured = r;
+                if (instance)
+                    instance.unmount();
+            } }));
+        const mounted = renderWithResizeClear(node, { exitOnCtrlC: true });
+        instance = mounted.instance;
+        instance.waitUntilExit().then(() => {
+            mounted.cleanupResizeClear();
+            snap.restore();
+            resetStdinForReadline();
+            resolve(captured ?? { kind: 'cancelled' });
+        }).catch(() => {
+            mounted.cleanupResizeClear();
+            snap.restore();
+            resetStdinForReadline();
+            resolve(captured ?? { kind: 'cancelled' });
+        });
+    });
+}

package/dist/cli/ink/runSlashPalette.d.ts

@@ -0,0 +1,23 @@
+import { type SlashCommandDef, type SlashPaletteResult } from './SlashPalette.js';
+/**
+ * Mount the slash palette Ink app and await the user's selection.
+ *
+ * Returns:
+ *   { kind: 'submit', text }  — full command line to feed to the REPL
+ *   { kind: 'cancelled' }     — user pressed Esc / backspaced past `/`
+ *
+ * Stdin handoff (matters):
+ *   - Before mount: snapshot + remove ALL `keypress` / `data`
+ *     listeners on process.stdin. Otherwise readline (which is paused
+ *     but still listening) AND Ink both consume bytes — arrow keys
+ *     get split between them and the palette appears frozen.
+ *   - After Ink unmount: restore the snapshotted listeners + run
+ *     `resetStdinForReadline` so the surrounding REPL doesn't exit
+ *     due to Ink's `stdin.unref()` cleanup.
+ */
+export interface RunSlashPaletteOptions {
+    initialQuery: string;
+    commands: SlashCommandDef[];
+    accentColor?: string;
+}
+export declare function runSlashPalette(opts: RunSlashPaletteOptions): Promise<SlashPaletteResult>;

package/dist/cli/ink/runSlashPalette.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { SlashPalette } from './SlashPalette.js';
+import { resetStdinForReadline, snapshotStdinListeners } from './stdinHandoff.js';
+import { renderWithResizeClear } from './renderWithResizeClear.js';
+export async function runSlashPalette(opts) {
+    if (!process.stdin.isTTY) {
+        return { kind: 'cancelled' };
+    }
+    // Snapshot + detach existing stdin listeners so Ink owns stdin
+    // alone for its mount lifetime.
+    const snap = snapshotStdinListeners(['keypress', 'data']);
+    return new Promise((resolve) => {
+        let captured;
+        const { instance, cleanupResizeClear } = renderWithResizeClear(_jsx(SlashPalette, { initialQuery: opts.initialQuery, commands: opts.commands, accentColor: opts.accentColor, onResolve: (r) => {
+                // Capture; the actual `resolve()` runs after Ink's unmount
+                // finishes via `waitUntilExit().then`.
+                if (captured)
+                    return;
+                captured = r;
+            } }), { exitOnCtrlC: false });
+        instance.waitUntilExit().then(() => {
+            cleanupResizeClear();
+            snap.restore();
+            resetStdinForReadline();
+            resolve(captured ?? { kind: 'cancelled' });
+        }).catch(() => {
+            cleanupResizeClear();
+            snap.restore();
+            resetStdinForReadline();
+            resolve(captured ?? { kind: 'cancelled' });
+        });
+    });
+}

package/dist/cli/ink/runWizard.d.ts

@@ -0,0 +1,22 @@
+import type { WizardState } from '../wizard/types.js';
+import { type Config } from '../../config/config.js';
+export declare function isOnboarded(): boolean;
+export declare function markOnboarded(): void;
+export interface WizardRunOptions {
+    workspaceRoot: string;
+}
+export interface WizardRunResult {
+    state: WizardState;
+    config?: Config;
+}
+/**
+ * Mount the Ink wizard and wait for it to finish. Returns the final
+ * `WizardState` (which includes `committed` / `aborted` flags) and,
+ * when committed, the freshly-saved Config.
+ *
+ * Why Ink instead of the previous raw-stdout runner? Ink owns the
+ * render loop and diffs the cell grid between frames, so we don't
+ * track cursor positions ourselves. Every redraw bug the previous
+ * approach had (creep, stacking, off-by-one) is eliminated by design.
+ */
+export declare function runWizard(opts: WizardRunOptions): Promise<WizardRunResult>;

package/dist/cli/ink/runWizard.js

@@ -0,0 +1,133 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { WizardApp } from './WizardApp.js';
+import { writePreferences } from '../../state/preferencesStore.js';
+import { loadOrInitConfig, saveConfig } from '../../config/config.js';
+import { initAgentMd } from '../../prompt/initAgentMd.js';
+import { NoTTYError } from '../cliPrompt.js';
+import { resetStdinForReadline } from './stdinHandoff.js';
+import { renderWithResizeClear } from './renderWithResizeClear.js';
+const ONBOARDED_MARKER = path.join(os.homedir(), '.config', 'brainrouter', '.onboarded');
+export function isOnboarded() {
+    try {
+        return fs.existsSync(ONBOARDED_MARKER);
+    }
+    catch {
+        return false;
+    }
+}
+export function markOnboarded() {
+    try {
+        fs.mkdirSync(path.dirname(ONBOARDED_MARKER), { recursive: true });
+        fs.writeFileSync(ONBOARDED_MARKER, '', 'utf8');
+    }
+    catch {
+        /* non-fatal */
+    }
+}
+/**
+ * Mount the Ink wizard and wait for it to finish. Returns the final
+ * `WizardState` (which includes `committed` / `aborted` flags) and,
+ * when committed, the freshly-saved Config.
+ *
+ * Why Ink instead of the previous raw-stdout runner? Ink owns the
+ * render loop and diffs the cell grid between frames, so we don't
+ * track cursor positions ourselves. Every redraw bug the previous
+ * approach had (creep, stacking, off-by-one) is eliminated by design.
+ */
+export async function runWizard(opts) {
+    if (!process.stdin.isTTY) {
+        throw new NoTTYError('BrainRouter has no config and stdin is not a TTY — run `brainrouter` in an interactive terminal at least once to complete the setup wizard.');
+    }
+    const finalState = await new Promise((resolve) => {
+        let captured;
+        const { instance, cleanupResizeClear } = renderWithResizeClear(_jsx(WizardApp, { workspaceRoot: opts.workspaceRoot, onFinish: (s) => {
+                // Capture but DON'T resolve yet — we want to wait for Ink's
+                // own unmount to complete (next tick) before handing stdin
+                // back to readline. Resolving prematurely would let our
+                // caller try to read stdin while Ink is still tearing down,
+                // which breaks the next readline.createInterface.
+                captured = s;
+            } }), {
+            // Don't put Ink's output into the alt-screen buffer — we want
+            // the final frame (Done summary) to stay in scrollback after
+            // unmount. Ink's default is `exitOnCtrlC: true` which is fine
+            // for our Ctrl+C abort path.
+            exitOnCtrlC: true,
+        });
+        instance.waitUntilExit().then(() => {
+            cleanupResizeClear();
+            // Hand stdin back to the caller in a state where readline (or
+            // anything else) can take it. Ink leaves stdin unref'd, in raw
+            // mode false, with its 'readable' listener removed; without
+            // this reset the post-wizard REPL would print its banner and
+            // then immediately exit because nothing kept the event loop
+            // alive. See cli/ink/stdinHandoff.ts for the full rationale.
+            resetStdinForReadline();
+            resolve(captured ?? { aborted: true, committed: false, currentStep: 'welcome', draft: {}, warnings: [] });
+        }).catch(() => {
+            cleanupResizeClear();
+            resetStdinForReadline();
+            resolve(captured ?? { aborted: true, committed: false, currentStep: 'welcome', draft: {}, warnings: [] });
+        });
+    });
+    let savedConfig;
+    if (finalState.committed) {
+        savedConfig = commitWizardDraft(finalState.draft, opts.workspaceRoot);
+        markOnboarded();
+    }
+    return { state: finalState, config: savedConfig };
+}
+function commitWizardDraft(draft, workspaceRoot) {
+    const config = loadOrInitConfig();
+    if (draft.provider) {
+        config.llm = {
+            provider: 'openai',
+            apiKey: draft.apiKey ?? '',
+            model: draft.model ?? draft.provider.defaultModel,
+            endpoint: draft.customEndpoint ?? draft.provider.endpoint,
+        };
+    }
+    if (draft.mcp && draft.mcp.kind !== 'skip') {
+        const profileName = draft.mcp.kind === 'remote-http' ? 'remote' : draft.mcp.kind === 'local-http' ? 'local-http' : 'local-stdio';
+        const serverConfig = mcpPickToServerConfig(draft.mcp);
+        if (serverConfig) {
+            config.servers[profileName] = serverConfig;
+            config.activeServer = profileName;
+        }
+    }
+    else if (draft.mcp?.kind === 'skip') {
+        // Skip means skip — clear any previously-active profile so the CLI doesn't
+        // silently re-spawn an MCP child from a stale config. The user can re-add
+        // a profile via `/login` later.
+        config.activeServer = '';
+    }
+    saveConfig(config);
+    if (draft.theme) {
+        try {
+            writePreferences(workspaceRoot, { theme: draft.theme });
+        }
+        catch { /* non-fatal */ }
+    }
+    if (draft.writeAgentMd) {
+        try {
+            initAgentMd(workspaceRoot);
+        }
+        catch { /* non-fatal */ }
+    }
+    return config;
+}
+function mcpPickToServerConfig(pick) {
+    if (pick.kind === 'local-stdio') {
+        return { type: 'stdio', command: 'brainrouter-mcp', args: [], identity: 'brainrouter' };
+    }
+    if (pick.kind === 'local-http') {
+        return { type: 'http', url: 'http://localhost:3747/mcp', apiKey: pick.apiKey, identity: 'brainrouter' };
+    }
+    if (pick.kind === 'remote-http') {
+        return { type: 'http', url: pick.url, apiKey: pick.apiKey, identity: 'brainrouter' };
+    }
+    return undefined;
+}

package/dist/cli/ink/stdinHandoff.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Restore stdin to a state where readline (or any other consumer) can
+ * own it, AFTER an Ink app has unmounted.
+ *
+ * Why this is necessary:
+ *   Ink's `App.js` calls `stdin.unref()` during its `disableRawMode`
+ *   cleanup (node_modules/ink/build/components/App.js:137). `unref()`
+ *   removes the stdin handle from the event-loop refcount. Once Ink
+ *   hands stdin back, NOTHING in the event loop keeps Node alive —
+ *   readline's 'readable' listener does NOT auto-ref the stream.
+ *   Node sees zero refs, fires `beforeExit`, and exits cleanly with
+ *   no `close` event.
+ *
+ *   Symptom: the post-wizard REPL printed its banner ("Type /help…")
+ *   and then the process exited to bash. No `Goodbye!` from
+ *   readline's close handler — readline never got a chance to run.
+ *
+ * Fix order (matters):
+ *   1. `process.stdin.ref()` — counter Ink's unref so the event loop
+ *      doesn't drain.
+ *   2. `process.stdin.resume()` — re-enable flowing/readable events.
+ *      Ink may have paused via `stdin.read()` draining.
+ *   3. `setRawMode(true)` on TTY — readline expects raw mode for
+ *      keypress events. Ink restored it to false on unmount.
+ *   4. `readline.emitKeypressEvents(process.stdin)` — re-arm the
+ *      keypress decoder. Ink's `clearInputState` removed the
+ *      'readable' listener (App.js:126); we want our handler back.
+ *
+ * Call this on the next `setImmediate` after `instance.unmount()` /
+ * `waitUntilExit()` resolves — Ink writes its final unmount barrier
+ * on the next tick (Ink.js:549-554).
+ */
+export declare function resetStdinForReadline(): void;
+/**
+ * Snapshot every listener attached to a stdin event so we can remove
+ * them while Ink owns stdin and re-attach them on Ink unmount.
+ *
+ * Without this, readline's keypress + 'data' listeners stay subscribed
+ * while Ink is mounted — both consumers fight for the same bytes,
+ * arrow keys go missing, the picker doesn't see Enter, etc. (See
+ * `cli-prompt.test.ts` notes on why we use `rl.pause()` AND remove
+ * stdin listeners during ask_user_choice.)
+ *
+ * Usage:
+ *   const snap = snapshotStdinListeners(['keypress', 'data']);
+ *   try { await runInk(...); } finally { snap.restore(); resetStdinForReadline(); }
+ */
+export interface StdinListenerSnapshot {
+    restore(): void;
+}
+export declare function snapshotStdinListeners(events?: readonly string[]): StdinListenerSnapshot;

package/dist/cli/ink/stdinHandoff.js

@@ -0,0 +1,78 @@
+import readline from 'node:readline';
+/**
+ * Restore stdin to a state where readline (or any other consumer) can
+ * own it, AFTER an Ink app has unmounted.
+ *
+ * Why this is necessary:
+ *   Ink's `App.js` calls `stdin.unref()` during its `disableRawMode`
+ *   cleanup (node_modules/ink/build/components/App.js:137). `unref()`
+ *   removes the stdin handle from the event-loop refcount. Once Ink
+ *   hands stdin back, NOTHING in the event loop keeps Node alive —
+ *   readline's 'readable' listener does NOT auto-ref the stream.
+ *   Node sees zero refs, fires `beforeExit`, and exits cleanly with
+ *   no `close` event.
+ *
+ *   Symptom: the post-wizard REPL printed its banner ("Type /help…")
+ *   and then the process exited to bash. No `Goodbye!` from
+ *   readline's close handler — readline never got a chance to run.
+ *
+ * Fix order (matters):
+ *   1. `process.stdin.ref()` — counter Ink's unref so the event loop
+ *      doesn't drain.
+ *   2. `process.stdin.resume()` — re-enable flowing/readable events.
+ *      Ink may have paused via `stdin.read()` draining.
+ *   3. `setRawMode(true)` on TTY — readline expects raw mode for
+ *      keypress events. Ink restored it to false on unmount.
+ *   4. `readline.emitKeypressEvents(process.stdin)` — re-arm the
+ *      keypress decoder. Ink's `clearInputState` removed the
+ *      'readable' listener (App.js:126); we want our handler back.
+ *
+ * Call this on the next `setImmediate` after `instance.unmount()` /
+ * `waitUntilExit()` resolves — Ink writes its final unmount barrier
+ * on the next tick (Ink.js:549-554).
+ */
+export function resetStdinForReadline() {
+    const stdin = process.stdin;
+    try {
+        stdin.ref?.();
+    }
+    catch { /* node version w/o ref */ }
+    try {
+        stdin.resume();
+    }
+    catch { /* already resumed */ }
+    if (stdin.isTTY) {
+        try {
+            stdin.setRawMode?.(true);
+        }
+        catch { /* not a real TTY */ }
+    }
+    try {
+        readline.emitKeypressEvents(stdin);
+    }
+    catch { /* already wired */ }
+}
+export function snapshotStdinListeners(events = ['keypress', 'data']) {
+    const stdin = process.stdin;
+    const captured = [];
+    for (const event of events) {
+        const listeners = (stdin.listeners?.(event) ?? []);
+        for (const listener of listeners) {
+            captured.push({ event, listener });
+            try {
+                stdin.removeListener(event, listener);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return {
+        restore() {
+            for (const { event, listener } of captured) {
+                try {
+                    stdin.on(event, listener);
+                }
+                catch { /* ignore */ }
+            }
+        },
+    };
+}

package/dist/cli/ink/toolFormat.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Tool call display formatters — claude-code-style semantic rendering.
+ *
+ * The raw `tool_name({"path": "...", ...})` JSON dump that fell out of
+ * `agent.runTurn`'s onToolStart callback is hostile to quick scanning
+ * during a long turn. claude-code's transcript format is
+ *
+ *   ⏺ Read(src/auth/login.ts)
+ *   ⏺ Bash(npm test)
+ *   ⏺ Grep("authenticate")
+ *
+ * — one-line, identity-revealing, no JSON. These helpers do the same
+ * mapping for our built-in LOCAL_TOOLS (cli/../agent/agent.ts) + MCP
+ * tool names (which carry an `mcp__<server>__` namespace prefix that
+ * the user doesn't care about).
+ *
+ * Reference for the convention: claude-code transcripts (see
+ * openSrc/claude-code/CHANGELOG.md mentions throughout; the format is
+ * not formally documented but used in every claude-code session).
+ */
+/**
+ * Format a tool call as a one-line `Function(args)` summary.
+ *
+ * Examples:
+ *   formatToolCall('read_file', { path: 'src/foo.ts' })
+ *     → "Read(src/foo.ts)"
+ *   formatToolCall('run_command', { command: 'npm test' })
+ *     → "Bash(npm test)"
+ *   formatToolCall('grep_search', { query: 'authenticate', path: '.' })
+ *     → 'Grep("authenticate")'
+ *   formatToolCall('mcp__brainrouter__memory_search', { q: 'auth' })
+ *     → 'MemorySearch("auth")'
+ *   formatToolCall('spawn_agent', { role: 'researcher', prompt: '...' })
+ *     → 'Spawn(researcher, "...")'
+ */
+export declare function formatToolCall(name: string, args: Record<string, any> | undefined): string;
+/**
+ * Strip the `mcp__<server>__` or `mcp_<server>_` namespace prefix from MCP tool
+ * names. Server ids may contain underscores (e.g. `my_server`), so the
+ * double-underscore form uses a lazy match. Both prefix conventions are in use
+ * across the multi-MCP codepaths until naming is unified.
+ *   `mcp__brainrouter__memory_search` → `memory_search`
+ *   `mcp__my_server__memory_search`    → `memory_search`
+ *   `mcp_brainrouter_memory_search`    → `memory_search`
+ */
+export declare function stripMcpPrefix(name: string): string;
+/**
+ * Convert snake_case to PascalCase for readable display names.
+ * `memory_search` → `MemorySearch`.
+ */
+export declare function snakeToPascal(name: string): string;
+/**
+ * Quote + truncate a free-form string argument to fit on one line.
+ * Returns `""` for missing input — the empty-quote pair signals "empty
+ * arg" rather than "no arg" (a no-arg call would not call this at all).
+ */
+export declare function quoteShort(s: unknown, max: number): string;
+/** Collapse whitespace + truncate a string to one line bounded by `max`. */
+export declare function truncateOneLine(s: unknown, max: number): string;
+/**
+ * Classify a tool-result preview line as part of a unified diff so the
+ * renderer can color it (red for removals, green for additions, gray
+ * for context). Detects file headers (`+++`, `---`), hunk headers
+ * (`@@`), and the per-line +/- gutter sign. Returns undefined when the
+ * line doesn't look like diff content so callers can leave it alone.
+ */
+export declare function classifyDiffLine(line: string): 'header' | 'hunk' | 'add' | 'del' | 'context' | undefined;
+/**
+ * True when a multi-line preview looks like a unified diff (at least one
+ * `@@` hunk header OR multiple +/- gutter lines). Used by the tool-result
+ * renderer to decide whether to apply diff coloring to the whole block.
+ */
+export declare function looksLikeDiff(preview: string): boolean;