@kinqs/brainrouter-cli 0.3.5 → 0.3.7

package/dist/cli/banner.d.ts

@@ -0,0 +1,80 @@
+import type { Config } from '../config/config.js';
+import type { Goal } from '../state/goalStore.js';
+import { type Theme } from './theme.js';
+export interface BannerInputs {
+    workspaceRoot: string;
+    /** "local-http", "stdio", "custom" — config.activeServer. */
+    mcpProfile: string;
+    /** "stdio" | "http". */
+    mcpTransport: string;
+    /** True when the MCP handshake succeeded. */
+    mcpOnline: boolean;
+    /**
+     * 10c: which MCP this profile actually IS — drives the distinct "brain"
+     * row when the active MCP is BrainRouter (or unknown, which we treat as
+     * "likely brain"). When the active MCP is explicitly third-party, the
+     * brain row is omitted entirely so the box stays compact.
+     */
+    mcpIdentity?: 'brainrouter' | 'third-party' | 'unknown';
+    /** Resolved sessionKey for this CLI process. */
+    sessionKey: string;
+    /** Chat-LLM model name (e.g. gpt-4o-mini). */
+    model: string;
+    /** Slug + status of the currently-bound workflow, if any. */
+    workflow?: {
+        slug: string;
+        status: string;
+    };
+    /**
+     * Slug of the last workflow that was active in this workspace, surfaced
+     * only when the current session has NO workflow bound. Rendered as a
+     * one-line hint so the user can `/workflow switch <slug>` to resume.
+     * Doesn't auto-bind anything — workflows are pure storage now (goals
+     * are session-scoped runtime state). Empty / matching the active
+     * workflow → no hint row.
+     */
+    lastUsedWorkflow?: string;
+    /** Goal-store snapshot, if any. */
+    goal?: Goal;
+    /** Version override (test fixture). */
+    version?: string;
+}
+export interface DisplayedMcpState {
+    profile: string;
+    transport: string;
+    online: boolean;
+    identity: 'brainrouter' | 'third-party' | 'unknown';
+}
+/**
+ * Pure renderer — returns the box as a single newline-joined string with
+ * ANSI sequences from `theme`. Caller appends the trailing newline.
+ */
+export declare function renderBanner(inputs: BannerInputs, theme: Theme): string;
+/**
+ * Convenience: assemble the inputs from live agent + config + workspace
+ * state. Pure read; no side effects. Anything that throws while reading the
+ * goal or current-workflow files is treated as "not set" so a half-set-up
+ * workspace doesn't crash the banner.
+ */
+export declare function buildBannerInputs(config: Config, agent: {
+    sessionKey: string;
+    workspaceRoot: string;
+    getModel: () => string;
+}, mcpClient: {
+    isConnected: () => boolean;
+    getIdentity?: () => 'brainrouter' | 'third-party' | 'unknown';
+    getStatus?: (serverId: string) => {
+        status: string;
+        identity: 'brainrouter' | 'third-party' | 'unknown';
+    } | undefined;
+    getActiveBrainrouterServerId?: () => string | undefined;
+}): BannerInputs;
+export declare function resolveDisplayedMcpState(config: Config, mcpClient: {
+    isConnected: () => boolean;
+    getIdentity?: () => 'brainrouter' | 'third-party' | 'unknown';
+    getStatus?: (serverId: string) => {
+        status: string;
+        identity: 'brainrouter' | 'third-party' | 'unknown';
+    } | undefined;
+    getActiveBrainrouterServerId?: () => string | undefined;
+}): DisplayedMcpState;

package/dist/cli/banner.js

@@ -0,0 +1,232 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { formatBudget } from '../state/goalStore.js';
+import { getCurrentWorkflow, getLastUsedWorkflow } from '../state/workflowArtifacts.js';
+import { readGoal } from '../state/goalStore.js';
+import { BOX } from './theme.js';
+/**
+ * Compose the boxed startup banner. Replaces the prior three-line text dump
+ * (chalk title + workspace line + connecting-to line) with a single visually
+ * scannable block:
+ *
+ *   ╭─ 🧠 BrainRouter CLI 0.3.7 ──────────────────────────────╮
+ *   │ workspace  BrainRouter  ·  c5b8c12d                     │
+ *   │ mcp        local-http  ·  http  ·  online               │
+ *   │ workflow   cli-shell-redesign  (in-progress)            │
+ *   │ goal       active 3 of unlimited iterations             │
+ *   │ session    7f3a1e0c                                     │
+ *   │ model      gpt-4o-mini                                  │
+ *   ╰─────────────────────────────────────────────────────────╯
+ *
+ * Designed so a glance tells the user where they are: which repo, which MCP
+ * profile, what's the in-flight goal, which model is running. Anything not
+ * applicable (e.g. no goal set, no current workflow) is silently omitted —
+ * the box shrinks to fit instead of showing "—" placeholders.
+ *
+ * The function returns a single string with embedded ANSI; the caller prints
+ * it once. Pure-function so tests can assert against the rendered output.
+ */
+const VERSION = '0.3.7';
+const TITLE = '🧠 BrainRouter CLI';
+// Width floor for the BOXED banner. Below this we fall through to the
+// `renderPlainBanner` plaintext format. Was 56 — that caused the box to
+// overflow on terminals narrower than 58 cols (each row wrapped to
+// multiple terminal rows with broken border alignment). 38 fits a
+// 40-col terminal (the smallest realistic phone / split-pane width).
+const MIN_BOX_WIDTH = 38;
+const MAX_WIDTH = 100;
+// Below this width we skip the box entirely and render the rows as
+// "label: value" lines. The boxed format with horizontal borders +
+// title is meaningless when each border row wraps.
+const PLAIN_TEXT_THRESHOLD = 38;
+function shortHash(absPath) {
+    return crypto.createHash('sha1').update(absPath).digest('hex').slice(0, 8);
+}
+function formatGoalSummary(goal) {
+    const cap = formatBudget(goal.budget.maxIterations);
+    const used = goal.budget.iterationsUsed;
+    // Status verbs read naturally inline. "usage_limited" → "limited".
+    const statusWord = goal.status === 'usage_limited' ? 'limited' :
+        goal.status === 'active' ? 'active' :
+            goal.status;
+    if (goal.status === 'complete')
+        return 'complete';
+    if (goal.status === 'blocked')
+        return `blocked — ${goal.blockedReason?.slice(0, 40) ?? 'see /goal'}`;
+    return `${statusWord} ${used} of ${cap} iterations`;
+}
+/**
+ * Workspace label — basename of the workspace root, with a short hash so
+ * two repos with the same basename (e.g. two clones of "playground") don't
+ * look identical.
+ */
+function formatWorkspace(workspaceRoot) {
+    const base = path.basename(workspaceRoot) || workspaceRoot;
+    return `${base}  ·  ${shortHash(workspaceRoot)}`;
+}
+function formatMcp(profile, transport, online) {
+    const dot = online ? 'online' : 'offline';
+    return `${profile}  ·  ${transport}  ·  ${dot}`;
+}
+/**
+ * 10c: brain row — distinct from the generic MCP row so the user can tell
+ * "the BrainRouter cloud brain is down" from "a third-party MCP is down".
+ * Renders only when the active MCP is BrainRouter (or unknown). Returns
+ * `undefined` when there's nothing meaningful to say (e.g. user only has a
+ * third-party MCP connected).
+ */
+function formatBrain(identity, online) {
+    if (identity === 'third-party')
+        return undefined;
+    if (identity === 'unknown')
+        return undefined; // wait for tool-signature detection
+    if (online)
+        return '🟢 online';
+    return '🔴 offline · cloud unreachable';
+}
+function formatWorkflow(workflow) {
+    if (!workflow)
+        return undefined;
+    return `${workflow.slug}  (${workflow.status})`;
+}
+function clipValue(value, width) {
+    if (value.length <= width)
+        return value;
+    if (width <= 1)
+        return value.slice(0, width);
+    return value.slice(0, width - 1) + '…';
+}
+function padRight(s, width) {
+    return s.length >= width ? s : s + ' '.repeat(width - s.length);
+}
+/**
+ * Pure renderer — returns the box as a single newline-joined string with
+ * ANSI sequences from `theme`. Caller appends the trailing newline.
+ */
+export function renderBanner(inputs, theme) {
+    const rows = [];
+    rows.push({ label: 'workspace', value: formatWorkspace(inputs.workspaceRoot) });
+    rows.push({ label: 'mcp', value: formatMcp(inputs.mcpProfile, inputs.mcpTransport, inputs.mcpOnline) });
+    // 10c: brain status sits below the mcp row — same level of visibility,
+    // but distinct so multi-MCP setups (Item 11) won't be ambiguous.
+    const brain = formatBrain(inputs.mcpIdentity, inputs.mcpOnline);
+    if (brain)
+        rows.push({ label: 'brain', value: brain });
+    const wf = formatWorkflow(inputs.workflow);
+    if (wf) {
+        rows.push({ label: 'workflow', value: wf });
+    }
+    else if (inputs.lastUsedWorkflow) {
+        // Fresh session with no current workflow but a known last-used
+        // workflow in this workspace — offer the resume incantation without
+        // auto-binding. Quiet so the user notices but isn't pushed into it.
+        rows.push({ label: 'last on', value: `${inputs.lastUsedWorkflow}   /workflow switch ${inputs.lastUsedWorkflow}` });
+    }
+    if (inputs.goal)
+        rows.push({ label: 'goal', value: formatGoalSummary(inputs.goal) });
+    rows.push({ label: 'session', value: inputs.sessionKey.slice(0, 8) });
+    rows.push({ label: 'model', value: inputs.model });
+    const version = inputs.version ?? VERSION;
+    const titleText = `${TITLE} ${version}`;
+    const labelWidth = rows.reduce((w, r) => Math.max(w, r.label.length), 0);
+    // Inner width is the widest "label + 2 spaces + value", clamped.
+    const naturalInner = rows.reduce((w, r) => Math.max(w, labelWidth + 2 + r.value.length), titleText.length + 4);
+    const targetCols = process.stdout.columns && process.stdout.columns > 0 ? process.stdout.columns : MAX_WIDTH;
+    // Below the plaintext threshold the boxed layout is hostile (each
+    // border row wraps and looks chaotic). Fall back to a label:value
+    // text dump that the terminal can wrap naturally.
+    if (targetCols < PLAIN_TEXT_THRESHOLD) {
+        return renderPlainBanner(titleText, rows, theme);
+    }
+    // Reserve 2 columns for the side borders.
+    const innerWidth = Math.max(MIN_BOX_WIDTH, Math.min(MAX_WIDTH, Math.min(naturalInner, targetCols - 2)));
+    const top = (() => {
+        // ╭─ <title> ──╮  — title sits inline at the top border.
+        const titlePiece = ` ${titleText} `;
+        const horizontalFill = Math.max(0, innerWidth - 1 - titlePiece.length);
+        return theme.primary(BOX.topLeft + BOX.horizontal + titlePiece + BOX.horizontal.repeat(horizontalFill) + BOX.topRight);
+    })();
+    const bodyLines = rows.map((row) => {
+        const valueWidth = innerWidth - labelWidth - 3; // 1 left pad + 2 gap
+        const clipped = clipValue(row.value, valueWidth);
+        const inside = ' ' + theme.muted(padRight(row.label, labelWidth)) + '  ' + theme.plain(padRight(clipped, valueWidth));
+        return theme.primary(BOX.vertical) + inside + theme.primary(BOX.vertical);
+    });
+    const bottom = theme.primary(BOX.bottomLeft + BOX.horizontal.repeat(innerWidth) + BOX.bottomRight);
+    return [top, ...bodyLines, bottom].join('\n');
+}
+/**
+ * Compact label:value text banner — used on terminals narrower than
+ * PLAIN_TEXT_THRESHOLD cols where the boxed layout's border rows
+ * would wrap and look broken. Same information, no chrome.
+ */
+function renderPlainBanner(titleText, rows, theme) {
+    const labelWidth = rows.reduce((w, r) => Math.max(w, r.label.length), 0);
+    const headerLine = theme.primary(titleText);
+    const bodyLines = rows.map((row) => theme.muted(padRight(row.label, labelWidth) + '  ') + theme.plain(row.value));
+    return [headerLine, ...bodyLines].join('\n');
+}
+/**
+ * Convenience: assemble the inputs from live agent + config + workspace
+ * state. Pure read; no side effects. Anything that throws while reading the
+ * goal or current-workflow files is treated as "not set" so a half-set-up
+ * workspace doesn't crash the banner.
+ */
+export function buildBannerInputs(config, agent, mcpClient) {
+    const displayedMcp = resolveDisplayedMcpState(config, mcpClient);
+    let workflow;
+    let lastUsedWorkflow;
+    try {
+        // 9d-bugfix: read the session-scoped binding so a fresh CLI session
+        // shows no workflow row even when another CLI in the same workspace
+        // has one bound.
+        const slug = getCurrentWorkflow(agent.workspaceRoot, agent.sessionKey);
+        if (slug) {
+            // We don't crack open workflowArtifacts.listWorkflows here — just the
+            // pointer file. Status would require parsing meta.json, which has its
+            // own cost on a slow disk; "bound" is enough to communicate state.
+            workflow = { slug, status: 'bound' };
+        }
+        else {
+            // Fresh session in a workspace where a previous CLI was on
+            // workflow X — surface that as a hint so the user can rebind via
+            // `/workflow switch X` if they want continuity. Doesn't auto-bind
+            // (per the decoupling design — workflows are storage, goals are
+            // runtime, the two have orthogonal lifecycles).
+            try {
+                lastUsedWorkflow = getLastUsedWorkflow(agent.workspaceRoot);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch { /* ignore — no workflow bound */ }
+    let goal;
+    try {
+        goal = readGoal(agent.workspaceRoot, agent.sessionKey) ?? undefined;
+    }
+    catch { /* ignore — no goal yet */ }
+    return {
+        workspaceRoot: agent.workspaceRoot,
+        mcpProfile: displayedMcp.profile,
+        mcpTransport: displayedMcp.transport,
+        mcpOnline: displayedMcp.online,
+        mcpIdentity: displayedMcp.identity,
+        sessionKey: agent.sessionKey,
+        model: agent.getModel(),
+        workflow,
+        lastUsedWorkflow,
+        goal,
+    };
+}
+export function resolveDisplayedMcpState(config, mcpClient) {
+    const liveBrain = mcpClient.getActiveBrainrouterServerId?.();
+    const profile = liveBrain || config.activeServer;
+    const server = config.servers[profile];
+    const status = profile ? mcpClient.getStatus?.(profile) : undefined;
+    return {
+        profile,
+        transport: server?.type ?? 'unknown',
+        online: status ? status.status === 'connected' : mcpClient.isConnected(),
+        identity: status?.identity ?? server?.identity ?? mcpClient.getIdentity?.() ?? 'unknown',
+    };
+}

package/dist/cli/cliPrompt.d.ts

@@ -1,12 +1,118 @@
 import readline from 'node:readline';
 export declare function setActiveReadline(rl: readline.Interface | undefined): void;
 export declare function getActiveReadline(): readline.Interface | undefined;
+export declare function isPickerActive(): boolean;
 /**
  * One-shot yes/no question. Returns true only when the user types y/yes
  * (case-insensitive). Returns the supplied default when stdin isn't a TTY
  * (e.g. piped non-interactive runs).
  */
 export declare function askYesNo(question: string, defaultValue?: boolean): Promise<boolean>;
+/**
+ * Surfaced when `askChoice` is called outside an interactive TTY. The tool
+ * wrapper turns this into a tool-call error so the LLM falls back to deciding
+ * itself — silently picking option 1 for the agent in CI / piped runs would
+ * make a load-bearing decision the user never saw.
+ */
+export declare class NoTTYError extends Error {
+    constructor(message: string);
+}
+/**
+ * Surfaced when the user pressed Esc / q / Ctrl+C inside the picker.
+ * The tool wrapper converts this into a tool-call error so the LLM knows
+ * the user declined to commit and can re-plan instead of guessing.
+ */
+export declare class CancelledChoiceError extends Error {
+    constructor(message?: string);
+}
+export interface ChoiceOption {
+    label: string;
+    description: string;
+}
+export interface PickerState {
+    /** Includes the synthetic Other entry at the last index. */
+    options: ChoiceOption[];
+    cursor: number;
+    multiSelect: boolean;
+    /** Indices of options the user has toggled on (multi-select only). */
+    selected: Set<number>;
+    /** True once the user confirmed Other and we're collecting free text. */
+    awaitingOther: boolean;
+    /** Accumulated free-text for the Other prompt. */
+    otherText: string;
+    done: boolean;
+    cancelled: boolean;
+    /** Final resolved value when `done && !cancelled`. */
+    result: string | string[] | null;
+}
+/** Normalized keystroke shape the reducer consumes. Decoupled from Node's
+ * raw `keypress` event so the reducer can be driven by test inputs that
+ * don't go through `emitKeypressEvents`. */
+export interface PickerKey {
+    name?: string;
+    ctrl?: boolean;
+    sequence?: string;
+    /** A single printable character for free-text capture (Other phase). */
+    char?: string;
+}
+/**
+ * `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;
+/**
+ * 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.
+ */
+/**
+ * 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;
+    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