@kinqs/brainrouter-cli 0.3.5 → 0.3.7

package/dist/cli/commands/guard.js

@@ -5,7 +5,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
-import { readPreferences, writePreferences } from '../../state/preferencesStore.js';
+import { applyYoloOff, applyYoloOn, readPreferences, writePreferences } from '../../state/preferencesStore.js';
 import { addHook, readHooks, removeHook, setHookEnabled } from '../../state/hooksStore.js';
 import { createHookifyRule, deleteHookifyRule, listHookifyRules, toggleHookifyRule } from '../../state/hookifyStore.js';
 export async function tryHandleGuardCommand(ctx) {
@@ -79,26 +79,91 @@ export async function tryHandleGuardCommand(ctx) {
                 console.log(chalk.red('\nUsage: /hooks [list | add <event> <cmd> | remove <id> | enable <id> | disable <id>]\n'));
                 return true;
             }
-        case '/yolo':
+        case '/mode':
+            {
+                const prefs = readPreferences(agent.workspaceRoot);
+                const arg = (args[0] ?? '').toLowerCase();
+                if (!arg) {
+                    console.log(chalk.bold(`\nExecution mode: ${chalk.cyan(prefs.executionMode)}`));
+                    console.log(chalk.gray('  planning  — run_command asks before executing; agent leans toward clarify-before-act. (default)'));
+                    console.log(chalk.gray('  fast      — run_command auto-approves safe commands (dangerous ones still ask); agent jumps to implementation.'));
+                    console.log(chalk.gray('  Toggle with: /mode planning  |  /mode fast\n'));
+                    return true;
+                }
+                if (arg !== 'planning' && arg !== 'fast') {
+                    console.log(chalk.red(`\nUnknown mode "${arg}". Choose: planning | fast\n`));
+                    return true;
+                }
+                writePreferences(agent.workspaceRoot, { executionMode: arg });
+                agent.refreshSystemPrompt();
+                ctx.repl.refreshPromptForMode();
+                if (arg === 'fast') {
+                    console.log(chalk.yellow(`\n✓ /mode fast — run_command auto-approves safe commands.`));
+                    console.log(chalk.gray('   Dangerous commands (rm -rf, sudo, force-push, …) still prompt for confirmation.'));
+                    console.log(chalk.gray('   Pair with /permissions write (no shell) or BRAINROUTER_SANDBOX=on for tighter guardrails.\n'));
+                }
+                else {
+                    console.log(chalk.green(`\n✓ /mode planning — run_command asks before each shell call.\n`));
+                }
+                return true;
+            }
+        case '/review-policy':
             {
                 const prefs = readPreferences(agent.workspaceRoot);
                 const arg = (args[0] ?? '').toLowerCase();
                 if (!arg) {
-                    console.log(chalk.bold(`\nAuto-approve shell: ${prefs.autoApproveShell ? chalk.red('ON') : chalk.green('off')}`));
-                    console.log(chalk.gray('  When ON, run_command skips the per-call confirmation prompt and executes immediately.'));
-                    console.log(chalk.gray('  Pair with BRAINROUTER_SANDBOX=on if you still want a safety net.'));
+                    console.log(chalk.bold(`\nReview policy: ${chalk.cyan(prefs.reviewPolicy)}`));
+                    console.log(chalk.gray('  request  — at workflow/multi-file gates, agent surfaces the plan and waits for /approve. (default)'));
+                    console.log(chalk.gray('  proceed  — agent applies the plan and reports after; use /approve manually for explicit gates.'));
+                    console.log(chalk.gray('  Toggle with: /review-policy request  |  /review-policy proceed\n'));
+                    return true;
+                }
+                if (arg !== 'request' && arg !== 'proceed') {
+                    console.log(chalk.red(`\nUnknown policy "${arg}". Choose: request | proceed\n`));
+                    return true;
+                }
+                writePreferences(agent.workspaceRoot, { reviewPolicy: arg });
+                agent.refreshSystemPrompt();
+                if (arg === 'proceed') {
+                    console.log(chalk.yellow(`\n✓ /review-policy proceed — agent will apply plans without halting for prose approval.`));
+                    console.log(chalk.gray('   /approve still works as an explicit gesture for workflows that need one.\n'));
+                }
+                else {
+                    console.log(chalk.green(`\n✓ /review-policy request — agent will summarize and ask before applying multi-file changes.\n`));
+                }
+                return true;
+            }
+        case '/yolo':
+            {
+                // /yolo is a one-release alias for `/mode fast` + `/review-policy proceed`.
+                // We keep it because the muscle memory is established; new docs point to
+                // the two split commands for finer control.
+                const arg = (args[0] ?? '').toLowerCase();
+                if (!arg) {
+                    const prefs = readPreferences(agent.workspaceRoot);
+                    const yoloOn = prefs.executionMode === 'fast' && prefs.reviewPolicy === 'proceed';
+                    console.log(chalk.bold(`\nYolo (alias): ${yoloOn ? chalk.red('ON') : chalk.green('off')}`));
+                    console.log(chalk.gray('  Shorthand for `/mode fast` + `/review-policy proceed` — flip both axes at once.'));
+                    console.log(chalk.gray(`  Current state: mode=${prefs.executionMode}, review-policy=${prefs.reviewPolicy}`));
+                    console.log(chalk.gray('  Use /mode and /review-policy directly for finer control.'));
                     console.log(chalk.gray('  Toggle with: /yolo on  |  /yolo off\n'));
                     return true;
                 }
                 const next = arg === 'on' || arg === 'true' || arg === '1';
-                writePreferences(agent.workspaceRoot, { autoApproveShell: next });
                 if (next) {
-                    console.log(chalk.red('\n⚠  /yolo ON — run_command will now execute without asking.'));
-                    console.log(chalk.gray('   You are in access mode "shell" so the agent CAN call shell commands.'));
-                    console.log(chalk.gray('   Lower the risk with /permissions write (no shell), or set BRAINROUTER_SANDBOX=on.\n'));
+                    applyYoloOn(agent.workspaceRoot);
+                    agent.refreshSystemPrompt();
+                    ctx.repl.refreshPromptForMode();
+                    console.log(chalk.red('\n⚠  /yolo ON — shorthand for `/mode fast` + `/review-policy proceed`.'));
+                    console.log(chalk.gray('   run_command will auto-approve safe commands; dangerous ones still prompt.'));
+                    console.log(chalk.gray('   Agent will apply multi-file plans without the prose "ready?" pause.'));
+                    console.log(chalk.gray('   Use /mode and /review-policy for finer control next time.\n'));
                 }
                 else {
-                    console.log(chalk.green('\n✓ /yolo off — run_command will prompt for confirmation again.\n'));
+                    applyYoloOff(agent.workspaceRoot);
+                    agent.refreshSystemPrompt();
+                    ctx.repl.refreshPromptForMode();
+                    console.log(chalk.green('\n✓ /yolo off — restored /mode planning + /review-policy request.\n'));
                 }
                 return true;
             }

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

@@ -0,0 +1,20 @@
+import type { CommandContext } from './_context.js';
+/**
+ * `/init` slash command — 0.3.7 redesign.
+ *
+ * Two behaviours under one verb, picked by the first argument:
+ *
+ *   - `/init` (bare) — re-run the onboarding wizard inside the REPL.
+ *     The REPL already owns the readline, so the wizard reuses it
+ *     (`ownsReadline: false`). Aborting at any step leaves disk
+ *     untouched.
+ *   - `/init agentmd` — back-compat alias for the 0.3.6 behaviour
+ *     that only scaffolded AGENT.md (the wizard now folds this in as
+ *     its final step, but users with muscle memory keep the lever).
+ *
+ * The auto-trigger on REPL start (when no `~/.config/brainrouter/config.json`
+ * exists) calls `runWizard` directly from `index.ts` with
+ * `ownsReadline: true`. That's a separate entry point — this slash
+ * handler is only for the in-REPL invocation.
+ */
+export declare function tryHandleInitCommand(ctx: CommandContext): Promise<boolean>;

package/dist/cli/commands/init.js

@@ -0,0 +1,64 @@
+import chalk from 'chalk';
+import { initAgentMd } from '../../prompt/initAgentMd.js';
+import { runWizard } from '../ink/runWizard.js';
+/**
+ * `/init` slash command — 0.3.7 redesign.
+ *
+ * Two behaviours under one verb, picked by the first argument:
+ *
+ *   - `/init` (bare) — re-run the onboarding wizard inside the REPL.
+ *     The REPL already owns the readline, so the wizard reuses it
+ *     (`ownsReadline: false`). Aborting at any step leaves disk
+ *     untouched.
+ *   - `/init agentmd` — back-compat alias for the 0.3.6 behaviour
+ *     that only scaffolded AGENT.md (the wizard now folds this in as
+ *     its final step, but users with muscle memory keep the lever).
+ *
+ * The auto-trigger on REPL start (when no `~/.config/brainrouter/config.json`
+ * exists) calls `runWizard` directly from `index.ts` with
+ * `ownsReadline: true`. That's a separate entry point — this slash
+ * handler is only for the in-REPL invocation.
+ */
+export async function tryHandleInitCommand(ctx) {
+    const { command, args, agent, repl } = ctx;
+    if (command !== '/init')
+        return false;
+    // Back-compat: explicit subcommand keeps the 0.3.6 one-shot behaviour.
+    if (args[0]?.toLowerCase() === 'agentmd' || args[0]?.toLowerCase() === 'agent') {
+        const result = initAgentMd(agent.workspaceRoot);
+        if (result.status === 'created') {
+            console.log(chalk.green(`\n✓ Created ${result.path}`));
+            console.log(chalk.gray('  Edit it to describe your project — any AGENT.md-aware agent will read it.\n'));
+        }
+        else {
+            console.log(chalk.yellow(`\nFile already exists: ${result.path}`));
+            console.log(chalk.gray('  Run `/init agentmd --overwrite` if you really want to start fresh (TODO).\n'));
+        }
+        return true;
+    }
+    // Wizard mode. Ink owns stdin while the wizard is mounted; once it
+    // unmounts the REPL's readline resumes naturally because we kept the
+    // process.stdin handle around (Ink restores raw mode on exit).
+    try {
+        const result = await runWizard({
+            workspaceRoot: agent.workspaceRoot,
+        });
+        if (result.config?.llm) {
+            // Live-update the in-flight agent so the next turn uses the new
+            // model / endpoint without forcing a restart. Keep the wrapper's
+            // existing MCP connection — switching MCP needs a restart for
+            // now (next item on the polish list).
+            const llm = result.config.llm;
+            agent.setModel(llm.model);
+            // The agent's internal openai client cached the endpoint at
+            // construction time — repl users may need a fresh CLI process
+            // for endpoint changes to fully take effect.
+            console.log(chalk.gray('  (note: endpoint / API-key changes apply on the next CLI restart)\n'));
+        }
+        repl.refreshPromptForMode();
+    }
+    catch (err) {
+        console.error(chalk.red(`\n/init failed: ${err?.message ?? err}\n`));
+    }
+    return true;
+}

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

@@ -0,0 +1,13 @@
+import type { CommandContext } from './_context.js';
+/**
+ * `/login` slash command — 0.3.7 redesign on the new internal picker.
+ *
+ * Opens a small modal that picks a transport (stdio / local-http /
+ * remote-http), gathers fields via the framed text prompt, runs a
+ * single 5s reachability probe, and saves the profile. Probe failure
+ * offers "save anyway / try a different transport / cancel".
+ *
+ * The legacy `brainrouter login` subcommand stays for users who
+ * scripted it.
+ */
+export declare function tryHandleLoginCommand(ctx: CommandContext): Promise<boolean>;

package/dist/cli/commands/login.js

@@ -0,0 +1,179 @@
+import chalk from 'chalk';
+import { saveConfig } from '../../config/config.js';
+import { McpClientWrapper } from '../../runtime/mcpClient.js';
+import { maskApiKey } from '../wizard/providers.js';
+// 0.3.7 — picker / prompt moved to Ink (see commands/config.ts for the
+// full rationale on why the raw-stdout primitives were retired).
+import { runPicker, runTextField } from '../ink/runPicker.js';
+const pickFromList = runPicker;
+const promptText = runTextField;
+import { buildTheme } from '../theme.js';
+import { readPreferences } from '../../state/preferencesStore.js';
+import { editLlm, promptBrainrouterApiKey } from './config.js';
+/**
+ * `/login` slash command — 0.3.7 redesign on the new internal picker.
+ *
+ * Opens a small modal that picks a transport (stdio / local-http /
+ * remote-http), gathers fields via the framed text prompt, runs a
+ * single 5s reachability probe, and saves the profile. Probe failure
+ * offers "save anyway / try a different transport / cancel".
+ *
+ * The legacy `brainrouter login` subcommand stays for users who
+ * scripted it.
+ */
+export async function tryHandleLoginCommand(ctx) {
+    if (ctx.command !== '/login')
+        return false;
+    const theme = buildTheme(readPreferences(ctx.agent.workspaceRoot).theme === 'mono' ? 'mono' : readPreferences(ctx.agent.workspaceRoot).theme === 'light' ? 'light' : 'dark');
+    while (true) {
+        const transport = await pickFromList({
+            theme,
+            title: '/login — MCP profile',
+            subtitle: 'Pick how this CLI reaches the BrainRouter MCP.',
+            rows: [
+                { id: 'local-stdio', label: 'Local stdio', value: 'brainrouter-mcp', description: 'No HTTP server needed' },
+                { id: 'local-http', label: 'Local HTTP', value: 'localhost:3747', description: 'Connect to a brainrouter-mcp HTTP server running locally' },
+                { id: 'remote-http', label: 'Remote HTTP', value: 'custom URL', description: 'Hosted MCP server (URL + optional key)' },
+            ],
+        });
+        if (transport.kind !== 'pick') {
+            console.log(chalk.yellow('\n  /login cancelled.\n'));
+            return true;
+        }
+        let serverConfig;
+        let profileName = '';
+        if (transport.id === 'local-stdio') {
+            serverConfig = { type: 'stdio', command: 'brainrouter-mcp', args: [], identity: 'brainrouter' };
+            profileName = 'local-stdio';
+        }
+        else if (transport.id === 'local-http') {
+            // 0.3.7 — collect the BrainRouter API key even for local-http.
+            // brainrouter-mcp HTTP servers can require auth (BRAINROUTER_API_KEY
+            // set in their server.env). Pre-fill from the env var; blank is OK
+            // for unauthenticated dev servers.
+            const apiKey = await promptBrainrouterApiKey(theme, 'local', ctx.config.servers['local-http']?.apiKey);
+            if (apiKey === undefined) {
+                console.log(chalk.yellow('\n  /login cancelled.\n'));
+                return true;
+            }
+            serverConfig = {
+                type: 'http',
+                url: 'http://localhost:3747/mcp',
+                apiKey: apiKey || undefined,
+                identity: 'brainrouter',
+            };
+            profileName = 'local-http';
+        }
+        else {
+            const urlResult = await promptText({
+                theme,
+                title: 'Remote MCP URL',
+                subtitle: 'Paste the full URL (e.g. https://brainrouter.example.com/mcp).',
+                prefilled: ctx.config.servers['remote']?.url ?? '',
+                placeholder: 'https://...',
+                validate: (raw) => {
+                    const v = raw.trim();
+                    if (!v)
+                        return 'URL required';
+                    try {
+                        new URL(v);
+                    }
+                    catch {
+                        return 'not a valid URL';
+                    }
+                    return undefined;
+                },
+            });
+            if (urlResult.kind !== 'accept') {
+                console.log(chalk.yellow('\n  /login cancelled.\n'));
+                return true;
+            }
+            const url = urlResult.text.trim();
+            const apiKey = await promptBrainrouterApiKey(theme, 'remote', ctx.config.servers['remote']?.apiKey);
+            if (apiKey === undefined) {
+                console.log(chalk.yellow('\n  /login cancelled.\n'));
+                return true;
+            }
+            serverConfig = { type: 'http', url, apiKey: apiKey || undefined, identity: 'brainrouter' };
+            profileName = 'remote';
+        }
+        const probe = await probeMcpProfile(serverConfig, profileName);
+        if (!probe.ok) {
+            const choice = await pickFromList({
+                theme,
+                title: 'MCP probe failed',
+                subtitle: probe.error,
+                rows: [
+                    { id: 'save', label: 'Save anyway', description: 'Persist the profile; run /mcp reconnect once the server is up' },
+                    { id: 'retry', label: 'Try a different transport', description: 'Re-open the picker' },
+                    { id: 'cancel', label: 'Cancel', description: 'Discard — nothing written' },
+                ],
+            });
+            if (choice.kind !== 'pick' || choice.id === 'cancel') {
+                console.log(chalk.yellow('\n  /login cancelled.\n'));
+                return true;
+            }
+            if (choice.id === 'retry')
+                continue;
+        }
+        else {
+            console.log(chalk.green(`\n  ✓ Probe succeeded (${probe.latencyMs}ms).`));
+        }
+        ctx.config.servers[profileName] = serverConfig;
+        ctx.config.activeServer = profileName;
+        saveConfig(ctx.config);
+        const apiKeyDisplay = serverConfig.apiKey ? maskApiKey(serverConfig.apiKey) : '(no key)';
+        console.log(chalk.green(`  ✓ MCP profile "${profileName}" saved as active. ${apiKeyDisplay}`));
+        console.log(chalk.gray('    Run /mcp reconnect to pick up the new transport without restarting.\n'));
+        // 0.3.7 — follow-on LLM credential step. Pre-0.3.7 `/login`
+        // *only* handled the MCP profile; users who wanted to refresh
+        // their LLM API key in the same flow had to bounce out to
+        // `/config` or `/init`. Now we offer it inline.
+        //
+        // Always offer (per user direction); default-No when LLM
+        // creds are already populated, default-Yes when missing.
+        const hasLlm = Boolean(ctx.config.llm?.apiKey?.trim()) && Boolean(ctx.config.llm?.endpoint);
+        const promptSubtitle = hasLlm
+            ? `Current: ${ctx.config.llm?.model ?? '(unset)'} @ ${ctx.config.llm?.endpoint ?? '(no endpoint)'} · key ${maskApiKey(ctx.config.llm?.apiKey ?? '')}`
+            : 'No LLM credentials saved yet — set them now so the next turn works.';
+        const llmChoice = await pickFromList({
+            theme,
+            title: 'Update LLM credentials?',
+            subtitle: promptSubtitle,
+            rows: hasLlm ? [
+                { id: 'skip', label: 'Skip — keep current LLM config', description: 'Press ENTER to exit /login' },
+                { id: 'update', label: 'Update LLM', description: 'Switch provider / paste a new key / change model' },
+            ] : [
+                { id: 'update', label: 'Set LLM now', description: 'Provider → API key → Model' },
+                { id: 'skip', label: 'Skip — set up later via /config', description: 'Exit /login without LLM config' },
+            ],
+            initialCursor: 0,
+        });
+        if (llmChoice.kind === 'pick' && llmChoice.id === 'update') {
+            const ok = await editLlm(ctx);
+            if (!ok) {
+                console.log(chalk.yellow('  /login — LLM step cancelled; MCP profile saved.\n'));
+            }
+        }
+        return true;
+    }
+}
+async function probeMcpProfile(serverConfig, name) {
+    const wrapper = new McpClientWrapper();
+    const start = Date.now();
+    try {
+        await Promise.race([
+            wrapper.connect(serverConfig, undefined, name),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timed out after 5s')), 5_000)),
+        ]);
+        await wrapper.close();
+        return { ok: true, latencyMs: Date.now() - start };
+    }
+    catch (err) {
+        try {
+            await wrapper.close();
+        }
+        catch { /* ignore */ }
+        return { ok: false, error: String(err?.message ?? err) };
+    }
+}

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

@@ -0,0 +1,19 @@
+/**
+ * `/mcp` slash-command surface. 0.3.7 multi-MCP rewrite — third-party
+ * MCPs connect concurrently while BrainRouter MCP profiles are mutually
+ * exclusive so exactly one brain is active at a time.
+ *
+ *   /mcp                    — alias for /mcp list
+ *   /mcp list               — every configured profile + per-server status
+ *   /mcp tools [server]     — MCP tools grouped by `mcp__<server>__*`
+ *                             namespace; pass a server id to scope
+ *   /mcp connect <name>     — connect a configured server that's idle/offline
+ *   /mcp disconnect <name>  — close one server's transport (config preserved)
+ *   /mcp reconnect [name]   — reconnect ONE (when name given) or the selected pool
+ *
+ * Backwards-compat: `/mcp reconnect` with no arg reconnects the same
+ * selected set used at boot: all third-party MCPs plus the active
+ * BrainRouter MCP. Pass an explicit name to target one.
+ */
+import type { CommandContext } from './_context.js';
+export declare function tryHandleMcpCommand(ctx: CommandContext): Promise<boolean>;