@kinqs/brainrouter-cli 0.3.6 → 0.3.8

package/dist/cli/cliPrompt.js

@@ -1,4 +1,5 @@
 import readline from 'node:readline';
+import { getAmbientChat } from './ink/ambientChat.js';
 /**
  * Shared bridge between the REPL's readline interface and modules outside
  * repl.ts that need to (a) write above the prompt without scrambling input,
@@ -33,6 +34,9 @@ export function isPickerActive() { return pickerActive; }
  * (e.g. piped non-interactive runs).
  */
 export function askYesNo(question, defaultValue = false) {
+    if (getAmbientChat() && process.stdin.isTTY) {
+        return runInkYesNo(question, defaultValue);
+    }
     if (!activeReadline || !process.stdin.isTTY) {
         return Promise.resolve(defaultValue);
     }
@@ -80,15 +84,23 @@ export class CancelledChoiceError extends Error {
 /** Synthetic always-on "Other" option appended to every picker. */
 const OTHER_LABEL = 'Other';
 const OTHER_DESCRIPTION = 'Type a free-form answer not listed above';
-export function initPickerState(options, multiSelect) {
+export function initPickerState(options, multiSelect, init = {}) {
     const augmented = [...options, { label: OTHER_LABEL, description: OTHER_DESCRIPTION }];
+    const otherText = init.prefilledOther ?? '';
+    const awaitingOther = otherText.length > 0;
+    // When pre-filled "Other" is requested, position the cursor on the
+    // Other row so a subsequent Esc → re-render lands the user there
+    // (otherwise they'd snap back to row 0 with no explanation).
+    const cursor = awaitingOther
+        ? augmented.length - 1
+        : Math.max(0, Math.min(init.initialCursor ?? 0, augmented.length - 1));
     return {
         options: augmented,
-        cursor: 0,
+        cursor,
         multiSelect,
         selected: new Set(),
-        awaitingOther: false,
-        otherText: '',
+        awaitingOther,
+        otherText,
         done: false,
         cancelled: false,
         result: null,
@@ -197,20 +209,6 @@ export function renderPicker(state, question, header) {
     }
     return lines.join('\n');
 }
-/**
- * Mid-turn multi-choice prompt with arrow-key navigation, a checkbox UI
- * for multi-select, and an always-on "Other" option that drops to free-text
- * input. Pause/resume the parent REPL the same way `askYesNo` does, so it
- * composes cleanly with the existing readline bridge.
- *
- * Non-TTY behavior is strict: throws `NoTTYError` instead of defaulting to
- * option 1. The agent calling this is asking the human for judgment; making
- * the call for them in CI / piped / `brainrouter run` would silently commit
- * to a path the user never saw.
- *
- * User cancellation (Esc, q, Ctrl+C) throws `CancelledChoiceError` so the
- * tool wrapper can surface "user declined to commit" as a tool-call error.
- */
 export function askChoice(question, options, opts = {}) {
     // Input-shape validation first — bad shape is a caller bug regardless of
     // TTY availability, and surfacing it as "no TTY" would misdirect the agent
@@ -241,14 +239,79 @@ export function askChoice(question, options, opts = {}) {
         return Promise.reject(new NoTTYError('ask_user_choice requires an interactive TTY (no readline interface is active or stdin is not a TTY). ' +
             'Fall back to deciding yourself based on the available context, and state which option you picked and why in your reply.'));
     }
+    if (getAmbientChat()) {
+        return runInkChoice(question, options, opts);
+    }
     return runPicker(question, options, opts);
 }
+async function runInkYesNo(question, defaultValue) {
+    const { runPicker } = await import('./ink/runPicker.js');
+    const result = await runPicker({
+        title: question,
+        badge: 'Confirm',
+        rows: [
+            { id: 'yes', label: 'Yes', description: 'Allow this action' },
+            { id: 'no', label: 'No', description: 'Do not allow this action' },
+        ],
+        initialCursor: defaultValue ? 0 : 1,
+        allowOther: false,
+    });
+    if (result.kind !== 'pick')
+        return defaultValue;
+    return result.id === 'yes';
+}
+async function runInkChoice(question, options, opts) {
+    const { runPicker } = await import('./ink/runPicker.js');
+    const rows = options.map((option, i) => ({
+        id: `choice:${i}`,
+        label: option.label,
+        description: option.description,
+    }));
+    const result = await runPicker({
+        title: question,
+        badge: opts.header,
+        rows,
+        initialCursor: opts.initialCursor,
+        allowOther: true,
+        otherLabel: OTHER_LABEL,
+        otherDescription: OTHER_DESCRIPTION,
+        prefilledOther: opts.prefilledOther,
+        multiSelect: !!opts.multiSelect,
+        onCursorChange: opts.onCursorChange
+            ? (_id, index) => {
+                opts.onCursorChange?.(index);
+                return undefined;
+            }
+            : undefined,
+    });
+    if (result.kind === 'cancelled') {
+        throw new CancelledChoiceError();
+    }
+    if (result.kind === 'other') {
+        return result.text;
+    }
+    if (result.kind === 'multi') {
+        const answers = result.ids.map((id) => {
+            const idx = Number(id.slice('choice:'.length));
+            return options[idx]?.label;
+        }).filter((label) => !!label);
+        if (result.otherText)
+            answers.push(result.otherText);
+        return answers;
+    }
+    const idx = Number(result.id.slice('choice:'.length));
+    return options[idx]?.label ?? options[0].label;
+}
 function runPicker(question, options, opts) {
     return new Promise((resolve, reject) => {
         const rl = activeReadline;
         const stdout = process.stdout;
-        let state = initPickerState(options, !!opts.multiSelect);
-        let renderedLines = 0;
+        let state = initPickerState(options, !!opts.multiSelect, {
+            prefilledOther: opts.prefilledOther,
+            initialCursor: opts.initialCursor,
+        });
+        let renderedNewlines = 0;
+        let renderedAtLeastOnce = false;
         // Pause the parent rl so its `line` handler doesn't fire on our ENTER
         // press. We restore on cleanup.
         rl.pause();
@@ -265,16 +328,28 @@ function runPicker(question, options, opts) {
         stdout.write('\x1b[?25l');
         pickerActive = true;
         const clear = () => {
-            if (renderedLines > 0) {
-                // Move cursor up `renderedLines` then clear to end of screen.
-                stdout.write(`\x1b[${renderedLines}A\r\x1b[J`);
+            if (renderedNewlines > 0) {
+                // `\x1b[<n>F` = cursor up n lines AND col 1 (atomic). For an
+                // M-line frame containing M-1 newlines, the cursor sits at
+                // the END of line M after the write (we don't write a
+                // trailing newline). Going up `renderedNewlines` (= M-1)
+                // lines lands EXACTLY at the start of line 1 — no off-by-one.
+                stdout.write(`\x1b[${renderedNewlines}F\x1b[J`);
+            }
+            else if (renderedNewlines === 0 && renderedAtLeastOnce) {
+                // Single-line frame edge case: nothing to scroll up; just
+                // wipe the current line.
+                stdout.write('\r\x1b[K');
             }
         };
         const render = () => {
             clear();
             const text = renderPicker(state, question, opts.header);
-            stdout.write(text + '\n');
-            renderedLines = text.split('\n').length;
+            stdout.write(text);
+            // Track newlines (NOT lines). For "a\nb\nc" that's 2 — which
+            // is exactly the cursor-up count we need for the next clear().
+            renderedNewlines = (text.match(/\n/g) ?? []).length;
+            renderedAtLeastOnce = true;
         };
         const cleanup = () => {
             process.stdin.removeListener('keypress', onKeypress);
@@ -309,10 +384,27 @@ function runPicker(question, options, opts) {
                 sequence: key?.sequence,
                 char: isPrintable ? str : undefined,
             };
+            const prevCursor = state.cursor;
+            const wasAwaitingOther = state.awaitingOther;
             const nextState = reducePicker(state, pk);
             if (nextState === state)
                 return;
             state = nextState;
+            // Live-preview hook (0.3.7): fire on a genuine cursor move in the
+            // picker phase only. Don't fire while collecting free-text in the
+            // "Other" phase — that would spam the callback on every keystroke
+            // for no useful signal. Settling back into picker phase from Other
+            // (Esc) doesn't fire either (the cursor "stayed" on Other).
+            if (opts.onCursorChange
+                && !state.done
+                && !state.awaitingOther
+                && !wasAwaitingOther
+                && state.cursor !== prevCursor) {
+                try {
+                    opts.onCursorChange(state.cursor);
+                }
+                catch { /* preview callbacks must never crash the picker */ }
+            }
             render();
             if (state.done) {
                 cleanup();

package/dist/cli/commands/_context.d.ts

@@ -13,7 +13,7 @@
  */
 import type readline from 'node:readline';
 import type { Agent } from '../../agent/agent.js';
-import type { McpClientWrapper } from '../../runtime/mcpClient.js';
+import type { McpClientPool as McpClientWrapper } from '../../runtime/mcpPool.js';
 import type { Config } from '../../config/config.js';
 /**
  * Lifecycle / REPL-scoped state that command handlers can read or mutate.
@@ -24,6 +24,8 @@ import type { Config } from '../../config/config.js';
 export interface ReplContext {
     /** Refresh the readline prompt (color reflects access mode + status segments). */
     refreshPromptForMode: () => void;
+    /** Replace the startup banner in the active chat scrollback, if the UI supports it. */
+    replaceBanner?: (text: string) => void;
     /** True while the REPL is mid-turn; loop ticks should defer when set. */
     isProcessing: () => boolean;
     /** Programmatically run an agent turn (used by /continue and friends). */

package/dist/cli/commands/_helpers.d.ts

@@ -8,7 +8,7 @@
  * wrapper.
  */
 import type { Agent } from '../../agent/agent.js';
-import type { McpClientWrapper } from '../../runtime/mcpClient.js';
+import type { McpClientPool as McpClientWrapper } from '../../runtime/mcpPool.js';
 /**
  * Memory-aware variant of printMcpCall. Calls the tool, extracts the flat
  * record list from whatever shape it returns, and renders compact cards

package/dist/cli/commands/config.d.ts

@@ -0,0 +1,46 @@
+import type { CommandContext } from './_context.js';
+import { type Theme } from '../theme.js';
+/**
+ * `/config` slash command — 0.3.7 redesign on the new atomic-frame picker
+ * (`../wizard/picker.ts`).
+ *
+ * Verb-overloaded (lifted from
+ * `openSrc/DeepSeek-TUI/crates/tui/src/commands/config.rs:43`):
+ *
+ *   - `/config`              — open the settings home panel
+ *   - `/config <key>`        — print the current value for <key>
+ *   - `/config <key> <val>`  — set <key> to <val> and persist
+ *   - `/config raw|json`     — print scrubbed JSON dump
+ *
+ * Persistence routes through `saveConfig` / `writePreferences` — never
+ * touches JSON files directly so future schema changes stay centralized.
+ */
+export declare function tryHandleConfigCommand(ctx: CommandContext): Promise<boolean>;
+export type ParsedConfigArgs = {
+    mode: 'home';
+} | {
+    mode: 'raw';
+} | {
+    mode: 'get';
+    key: string;
+} | {
+    mode: 'set';
+    key: string;
+    value: string;
+};
+export declare function parseConfigArgs(args: string[]): ParsedConfigArgs;
+export declare function listKnownConfigKeys(): string[];
+export declare function editLlm(ctx: CommandContext): Promise<boolean>;
+/**
+ * Shared prompt for the BrainRouter MCP HTTP API key (the
+ * `BRAINROUTER_API_KEY` bearer token). Pre-fills from the env var if
+ * set, then from the previously-saved key, then blank. Returns:
+ *   - the trimmed key string (possibly empty when user chose "no key")
+ *   - undefined when the user pressed Esc
+ *
+ * Exported so `/login` and any future MCP-setup surfaces share one
+ * prompt copy — same subtitle text, same env-var pre-fill, same
+ * "blank OK" semantics.
+ */
+export declare function promptBrainrouterApiKey(theme: Theme, kind: 'local' | 'remote', existing?: string): Promise<string | undefined>;
+export declare function buildScrubbedConfigJson(config: CommandContext['config']): string;