@kinqs/brainrouter-cli 0.3.6 → 0.3.7

package/dist/cli/cliPrompt.d.ts

@@ -55,7 +55,22 @@ export interface PickerKey {
     /** A single printable character for free-text capture (Other phase). */
     char?: string;
 }
-export declare function initPickerState(options: ChoiceOption[], multiSelect: boolean): PickerState;
+/**
+ * `prefilledOther` drops the picker straight into the free-text "Other"
+ * phase with the supplied string already in the buffer. Used by the
+ * 0.3.7 wizard / `/config` panel when a value can be derived from an
+ * env var — the user sees the env value and presses ENTER to accept or
+ * edits to override. Pass an empty string to keep today's behaviour.
+ *
+ * `initialCursor` lets a picker open with a non-zero highlight so the
+ * settings home panel can re-open on the row the user just edited
+ * without re-scrolling them to the top.
+ */
+export interface InitPickerStateOptions {
+    prefilledOther?: string;
+    initialCursor?: number;
+}
+export declare function initPickerState(options: ChoiceOption[], multiSelect: boolean, init?: InitPickerStateOptions): PickerState;
 export declare function reducePicker(state: PickerState, key: PickerKey): PickerState;
 export declare function renderPicker(state: PickerState, question: string, header?: string): string;
 /**
@@ -72,10 +87,32 @@ export declare function renderPicker(state: PickerState, question: string, heade
  * User cancellation (Esc, q, Ctrl+C) throws `CancelledChoiceError` so the
  * tool wrapper can surface "user declined to commit" as a tool-call error.
  */
-export declare function askChoice(question: string, options: ChoiceOption[], opts?: {
+/**
+ * 0.3.7 picker opts.
+ *
+ * `onCursorChange(index)` fires after every arrow-key move that actually
+ * moves the cursor (no-op keys, ENTER, SPACE don't fire it). The 0.3.7
+ * theme picker uses this to live-preview the selected theme by redrawing
+ * the banner accent before the user confirms — pattern lifted from
+ * `openSrc/codex/codex-rs/tui/src/bottom_pane/list_selection_view.rs` and
+ * `openSrc/codex/codex-rs/tui/src/theme_picker.rs`.
+ *
+ * `prefilledOther` opens the picker with the synthetic "Other" row
+ * already selected AND the free-text input pre-filled. Used when a value
+ * is derived from an env var so the user can press ENTER to accept or
+ * edit in-place. Pre-fill flips `awaitingOther` true on init.
+ *
+ * `initialCursor` lets the settings home panel re-open on the row the
+ * user just left, avoiding a snap-to-row-0 after every sub-picker.
+ */
+export interface AskChoiceOptions {
     multiSelect?: boolean;
     header?: string;
-}): Promise<string | string[]>;
+    onCursorChange?: (cursor: number) => void;
+    prefilledOther?: string;
+    initialCursor?: number;
+}
+export declare function askChoice(question: string, options: ChoiceOption[], opts?: AskChoiceOptions): Promise<string | string[]>;
 /**
  * Print a line of output while the prompt is showing, then redraw the prompt
  * with whatever the user was mid-typing. Used by callbacks that fire while the

package/dist/cli/cliPrompt.js

@@ -80,15 +80,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 +205,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
@@ -247,8 +241,12 @@ 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 +263,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 +319,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;