@kinqs/brainrouter-cli 0.3.5 → 0.3.7

package/dist/cli/commands/ui.js

@@ -6,16 +6,23 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
 import chalk from 'chalk';
-import ora from 'ora';
+import { spinner as makeSpinner } from '../spinner.js';
 import { LOCAL_TOOLS } from '../../agent/agent.js';
 import { callMcpTool } from '../../runtime/mcpUtils.js';
 import { listSessions, reconcileStale } from '../../orchestration/orchestrator.js';
-import { readPreferences, writePreferences } from '../../state/preferencesStore.js';
+import { readPreferences, resolveEffort, writePreferences } from '../../state/preferencesStore.js';
 import { readPlan } from '../../state/taskStore.js';
-import { getConfigPath } from '../../config/config.js';
+// initAgentMd usage moved to commands/init.ts (0.3.7 wizard). The
+// legacy /config + /init switch cases here are gone — the dispatcher
+// in repl.ts routes them to the new handlers first. getConfigPath
+// stays in scope because /doctor still surfaces the path.
+import { getConfigPath, saveConfig } from '../../config/config.js';
 import { copyToClipboard } from '../../runtime/clipboard.js';
-import { initAgentMd } from '../../prompt/initAgentMd.js';
 import { completeWorkspacePath, renderHelp } from '../repl.js';
+import { PROVIDER_CATALOG, findProvider } from '../wizard/providers.js';
+import { selectModel } from '../wizard/modelsApi.js';
+import { buildTheme } from '../theme.js';
+import { listFilesystemSkills } from '../../prompt/skillCatalog.js';
 export async function tryHandleUiCommand(ctx) {
     const { command, args, agent, mcpClient, config, rl, repl } = ctx;
     // 'ctx' alias to keep references to the old ReplContext name working
@@ -41,7 +48,7 @@ export async function tryHandleUiCommand(ctx) {
                         console.log(`  LLM Endpoint:  ${chalk.blue(llm.endpoint)}`);
                     }
                 }
-                const spinner = ora(chalk.gray('Querying diagnostics & testing latency...')).start();
+                const spinner = makeSpinner(chalk.gray('Querying diagnostics & testing latency...')).start();
                 try {
                     const start = Date.now();
                     const testRes = await mcpClient.callTool('list_skills', { scope: 'local' });
@@ -78,27 +85,10 @@ export async function tryHandleUiCommand(ctx) {
                 console.log();
                 return true;
             }
-        case '/config':
-            {
-                console.log(chalk.bold('\n⚙️  Active Configuration:'));
-                console.log(`  File Path: ${chalk.blue(getConfigPath())}\n`);
-                // Print config without API keys
-                const scrubbedConfig = JSON.parse(JSON.stringify(config));
-                if (scrubbedConfig.llm?.apiKey) {
-                    scrubbedConfig.llm.apiKey = 'br_••••••••••••••••';
-                }
-                for (const s of Object.values(scrubbedConfig.servers)) {
-                    const srv = s;
-                    if (srv.apiKey)
-                        srv.apiKey = 'br_••••••••••••••••';
-                    if (srv.env?.BRAINROUTER_API_KEY) {
-                        srv.env.BRAINROUTER_API_KEY = 'br_••••••••••••••••';
-                    }
-                }
-                console.log(chalk.gray(JSON.stringify(scrubbedConfig, null, 2)));
-                console.log();
-                return true;
-            }
+        // /config now lives in commands/config.ts (0.3.7 settings home panel
+        // + verb-overloaded get/set). The dispatcher in repl.ts routes it
+        // before this case, so leaving anything here is dead — removed.
+        // Use `/config raw` if you want the old scrubbed-JSON dump.
         case '/doctor':
             {
                 console.log(chalk.bold('\nBrainRouter Doctor:'));
@@ -116,7 +106,7 @@ export async function tryHandleUiCommand(ctx) {
                 else {
                     console.log(`  Endpoint: ${chalk.blue(server.url)}`);
                 }
-                const spinner = ora(chalk.gray('Checking MCP tool surface...')).start();
+                const spinner = makeSpinner(chalk.gray('Checking MCP tool surface...')).start();
                 try {
                     const startedAt = Date.now();
                     const res = await mcpClient.listTools();
@@ -178,68 +168,75 @@ export async function tryHandleUiCommand(ctx) {
                 console.log();
                 return true;
             }
-        case '/init':
-            {
-                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, conventions, and boundaries — any AGENT.md-aware coding agent will read it.\n'));
-                }
-                else {
-                    console.log(chalk.yellow(`\nFile already exists: ${result.path}`));
-                    console.log(chalk.gray('Open it and edit by hand if you want to refresh it.\n'));
-                }
-                return true;
-            }
+        // /init is now the onboarding-wizard entrypoint (commands/init.ts).
+        // The AGENT.md-only path lives behind `/init agentmd` for back-compat.
+        // Routed before this case in repl.ts; no fall-through handler needed.
         case '/model':
             {
                 const newModel = args[0];
-                if (!newModel) {
-                    console.log(chalk.bold(`\nCurrent model: ${chalk.cyan(agent.getModel())}`));
-                    console.log(chalk.gray('Switch with: /model <model-name> (e.g. /model gpt-4o-mini, /model gpt-5, /model qwen2.5-coder)\n'));
-                    return true;
-                }
                 const previous = agent.getModel();
-                agent.setModel(newModel);
-                console.log(chalk.green(`\n✓ Model switched: ${chalk.gray(previous)} → ${chalk.cyan(newModel)}\n`));
-                return true;
-            }
-        case '/mcp':
-            {
-                const profileName = config.activeServer;
-                const server = config.servers[profileName];
-                console.log(chalk.bold('\nMCP server'));
-                console.log(`  Profile: ${chalk.green(profileName)} (${chalk.cyan(server?.type ?? 'unknown')})`);
-                if (server?.type === 'http') {
-                    console.log(`  URL:     ${chalk.blue(server.url)}`);
-                }
-                else if (server?.type === 'stdio') {
-                    console.log(`  Cmd:     ${chalk.blue(server.command)} ${server.args?.join(' ') || ''}`);
-                }
-                const spinner = ora(chalk.gray('Fetching MCP tool surface...')).start();
-                try {
-                    const res = await mcpClient.listTools();
-                    const tools = res.tools || [];
-                    spinner.succeed(chalk.green(`${tools.length} MCP tools available`));
-                    const namespaces = {};
-                    for (const t of tools) {
-                        const parts = (t.name || '').split('_');
-                        const ns = parts.length > 1 ? parts[0] : 'misc';
-                        (namespaces[ns] ||= []).push(t.name);
-                    }
-                    for (const ns of Object.keys(namespaces).sort()) {
-                        console.log(`\n  ${chalk.bold.cyan(ns)} (${namespaces[ns].length})`);
-                        for (const name of namespaces[ns].sort()) {
-                            console.log(`    ${chalk.gray('•')} ${name}`);
-                        }
+                // Direct-switch form `/model <name>` stays for scripts and muscle
+                // memory. No-arg opens the picker (0.3.7).
+                if (newModel) {
+                    agent.setModel(newModel);
+                    if (config.llm) {
+                        config.llm.model = newModel;
+                        saveConfig(config);
                     }
+                    console.log(chalk.green(`\n✓ Model switched: ${chalk.gray(previous)} → ${chalk.cyan(newModel)}\n`));
+                    return true;
                 }
-                catch (err) {
-                    spinner.fail(chalk.red(`Failed: ${err.message}`));
+                // No-arg → open the picker. Resolves provider by matching the
+                // saved endpoint against PROVIDER_CATALOG; falls back to the
+                // OpenAI entry when nothing matches (the agent loop also
+                // defaults to OpenAI-compatible shapes).
+                const themeMode = readPreferences(agent.workspaceRoot).theme;
+                const theme = buildTheme(themeMode === 'mono' ? 'mono' : themeMode === 'light' ? 'light' : 'dark');
+                const llm = config.llm;
+                const provider = (llm?.endpoint && PROVIDER_CATALOG.find((p) => p.endpoint.replace(/\/$/, '') === (llm.endpoint ?? '').replace(/\/$/, ''))) ||
+                    findProvider('openai');
+                const result = await selectModel({
+                    theme,
+                    provider,
+                    apiKey: llm?.apiKey ?? '',
+                    endpointOverride: llm?.endpoint,
+                    currentModel: previous,
+                    title: '/model — quick-swap',
+                    badge: provider.label,
+                });
+                if (!result) {
+                    console.log(chalk.yellow('\n  /model cancelled.\n'));
+                    return true;
                 }
-                console.log();
+                if (result.model === previous) {
+                    console.log(chalk.gray(`\n  Model unchanged (${previous}).\n`));
+                    return true;
+                }
+                // Cross-provider sanity check — if the picked model looks like
+                // a different vendor's namespace (anthropic/*, google/*, etc.)
+                // and the active provider isn't a multi-vendor gateway, warn so
+                // the user doesn't hit a confusing 404 on the next turn.
+                if (looksLikeForeignModel(result.model, provider)) {
+                    console.log(chalk.yellow(`\n  ⚠ "${result.model}" looks like a different provider's namespace. ` +
+                        `Active endpoint: ${provider.label}.` +
+                        `\n    Run /config provider <id> to switch endpoints, or /model again to pick a native model.\n`));
+                }
+                agent.setModel(result.model);
+                if (config.llm) {
+                    config.llm.model = result.model;
+                    saveConfig(config);
+                }
+                const sourceTag = result.source === 'live' ? `live · ${result.liveCount} models` :
+                    result.source === 'fallback' ? `offline · static catalog (${result.liveError ?? 'unknown'})` :
+                        'static catalog';
+                console.log(chalk.green(`\n✓ Model switched: ${chalk.gray(previous)} → ${chalk.cyan(result.model)}`));
+                console.log(chalk.gray(`  Source: ${sourceTag}\n`));
                 return true;
             }
+        // /mcp moved to its own command file (commands/mcp.ts) as part of 0.3.6
+        // Item 11. The new dispatcher supports `/mcp list`, `/mcp reconnect`,
+        // and the original no-arg "show tools by namespace" behaviour is now
+        // covered by `/mcp tools` (handled in commands/mcp.ts).
         case '/copy':
             {
                 if (!agent.lastAnswer) {
@@ -267,18 +264,18 @@ export async function tryHandleUiCommand(ctx) {
             {
                 const prefs = readPreferences(agent.workspaceRoot);
                 const arg = args.join(' ').trim();
+                const { SEGMENT_NAMES, isKnownSegment } = await import('../statusline.js');
                 if (!arg) {
                     console.log(chalk.bold('\nStatusline'));
                     console.log(`  Current: ${chalk.cyan(prefs.statusline)}`);
-                    console.log(chalk.gray('  Available segments: mode, branch, dirty, model, tokens, session'));
-                    console.log(chalk.gray('  Example: /statusline mode,branch,dirty,tokens\n'));
+                    console.log(chalk.gray(`  Available segments: ${SEGMENT_NAMES.join(', ')}`));
+                    console.log(chalk.gray('  Example: /statusline mode,workflow,goal,model,session,plan\n'));
                     return true;
                 }
-                const valid = new Set(['mode', 'branch', 'dirty', 'model', 'tokens', 'session']);
                 const requested = arg.split(',').map((s) => s.trim()).filter(Boolean);
-                const unknown = requested.filter((s) => !valid.has(s));
+                const unknown = requested.filter((s) => !isKnownSegment(s));
                 if (unknown.length > 0) {
-                    console.log(chalk.red(`\nUnknown segment(s): ${unknown.join(', ')}. Valid: ${Array.from(valid).join(', ')}\n`));
+                    console.log(chalk.red(`\nUnknown segment(s): ${unknown.join(', ')}. Valid: ${SEGMENT_NAMES.join(', ')}\n`));
                     return true;
                 }
                 writePreferences(agent.workspaceRoot, { statusline: requested.join(',') });
@@ -373,6 +370,63 @@ export async function tryHandleUiCommand(ctx) {
                 console.log(chalk.green(`\n✓ Raw scrollback ${next ? 'enabled' : 'disabled'}. Markdown rendering ${next ? 'OFF' : 'ON'} for next turn.\n`));
                 return true;
             }
+        case '/effort':
+            {
+                const arg = (args[0] ?? '').toLowerCase();
+                const valid = ['low', 'medium', 'high'];
+                if (!arg) {
+                    const resolved = resolveEffort(agent.workspaceRoot);
+                    const sourceTag = resolved.source === 'env' ? chalk.gray(' (env: BRAINROUTER_EFFORT)') :
+                        resolved.source === 'preference' ? chalk.gray(' (preference)') :
+                            chalk.gray(' (default)');
+                    console.log(chalk.bold(`\nReasoning depth: ${chalk.cyan(resolved.effort)}${sourceTag}`));
+                    console.log(chalk.gray('  low     — terse, one-paragraph answers; minimal ceremony.'));
+                    console.log(chalk.gray('  medium  — current default; no overlay, no provider reasoning slot. (default)'));
+                    console.log(chalk.gray('  high    — step-by-step reasoning; audits evidence before each tool call.'));
+                    console.log(chalk.gray('  When the model supports it (gpt-5, o-series, gpt-oss, DeepSeek R1/V3+, Qwen3,'));
+                    console.log(chalk.gray('  Magistral, *-reasoning, *-thinking — works on OpenAI, DeepSeek, OpenRouter,'));
+                    console.log(chalk.gray('  LM Studio 0.3.29+, Ollama), the level is also forwarded as `reasoning_effort`.'));
+                    console.log(chalk.gray('  Toggle with: /effort low | /effort medium | /effort high'));
+                    console.log(chalk.gray('  Env override (one-shot): BRAINROUTER_EFFORT=high brainrouter\n'));
+                    return true;
+                }
+                if (!valid.includes(arg)) {
+                    console.log(chalk.red(`\nUnknown level "${arg}". Choose: ${valid.join(' | ')}\n`));
+                    return true;
+                }
+                writePreferences(agent.workspaceRoot, { effort: arg });
+                agent.refreshSystemPrompt();
+                const after = resolveEffort(agent.workspaceRoot);
+                // Surface a friendly nudge when the env var would still shadow the new
+                // preference on the next process boot.
+                if (process.env.BRAINROUTER_EFFORT && after.source === 'env') {
+                    console.log(chalk.yellow(`\n✓ Preference saved as ${arg}, but BRAINROUTER_EFFORT=${process.env.BRAINROUTER_EFFORT} is still active this process — env wins.\n`));
+                }
+                else {
+                    console.log(chalk.green(`\n✓ Reasoning depth → ${arg}. Applies on the next turn.\n`));
+                }
+                return true;
+            }
+        case '/quiet':
+            {
+                const prefs = readPreferences(agent.workspaceRoot);
+                const arg = (args[0] ?? '').toLowerCase();
+                const next = arg ? (arg === 'on' || arg === 'true' || arg === '1') : !prefs.quiet;
+                writePreferences(agent.workspaceRoot, { quiet: next });
+                // `--quiet` set a one-shot env override at startup; once the user
+                // explicitly toggles in-session their choice wins from now on.
+                if (next) {
+                    process.env.BRAINROUTER_QUIET = '1';
+                }
+                else {
+                    delete process.env.BRAINROUTER_QUIET;
+                }
+                const detail = next
+                    ? 'recall tables, briefing dumps, and tool-completion previews are now hidden.'
+                    : 'full chrome restored — recall tables, previews, and briefings will print again.';
+                console.log(chalk.green(`\n✓ Quiet mode ${next ? 'enabled' : 'disabled'}: ${detail}\n`));
+                return true;
+            }
         case '/apps':
         case '/plugins':
             {
@@ -385,12 +439,22 @@ export async function tryHandleUiCommand(ctx) {
                     console.log(chalk.gray('  Drop a folder under skills/<category>/<name>/SKILL.md to register one.\n'));
                     return true;
                 }
-                for (const root of roots) {
-                    const entries = fs.readdirSync(root, { withFileTypes: true });
-                    for (const entry of entries) {
-                        if (!entry.isDirectory())
-                            continue;
-                        console.log(chalk.cyan(`  ${path.relative(agent.workspaceRoot, path.join(root, entry.name))}`));
+                const skills = listFilesystemSkills(agent.workspaceRoot);
+                if (skills.length > 0) {
+                    console.log(chalk.gray('  Skills'));
+                    for (const skill of skills) {
+                        const category = skill.category ? `${skill.category}/` : '';
+                        console.log(`  • ${chalk.cyan(`${category}${skill.name}`)} (${chalk.gray(skill.scope ?? 'filesystem')})`);
+                    }
+                }
+                if (fs.existsSync(pluginsRoot)) {
+                    const entries = fs.readdirSync(pluginsRoot, { withFileTypes: true });
+                    const pluginDirs = entries.filter((entry) => entry.isDirectory());
+                    if (pluginDirs.length > 0) {
+                        console.log(chalk.gray('  Plugin folders'));
+                        for (const entry of pluginDirs) {
+                            console.log(`  • ${chalk.cyan(path.relative(agent.workspaceRoot, path.join(pluginsRoot, entry.name)))}`);
+                        }
                     }
                 }
                 console.log();
@@ -468,6 +532,29 @@ export async function tryHandleUiCommand(ctx) {
                 console.log(chalk.gray('  Tip: configure IDE to launch brainrouter with -w <workspace> so paths match.\n'));
                 return true;
             }
+        case '/where':
+            {
+                const { gatherWhereInputs, renderWhere } = await import('../whereView.js');
+                const { resolveDisplayedMcpState } = await import('../banner.js');
+                const { resolveTheme } = await import('../theme.js');
+                const theme = resolveTheme(agent.workspaceRoot);
+                const displayedMcp = resolveDisplayedMcpState(config, mcpClient);
+                const briefing = agent.getLastBriefing();
+                const inputs = gatherWhereInputs({
+                    workspaceRoot: agent.workspaceRoot,
+                    sessionKey: agent.sessionKey,
+                    model: agent.getModel(),
+                    mcpProfile: displayedMcp.profile,
+                    mcpTransport: displayedMcp.transport,
+                    mcpOnline: displayedMcp.online,
+                    mcpIdentity: displayedMcp.identity,
+                    accessMode: agent.getAccessMode(),
+                    recalledRecords: agent.getRecalledRecords(),
+                    briefingSources: briefing.sources,
+                });
+                console.log('\n' + renderWhere(inputs, theme) + '\n');
+                return true;
+            }
         case '/help': {
             renderHelp(args[0]?.toLowerCase());
             return true;
@@ -475,3 +562,27 @@ export async function tryHandleUiCommand(ctx) {
     }
     return false;
 }
+/**
+ * Heuristic — does the picked model id look like it belongs to a
+ * different vendor than the active provider's endpoint? Catches the
+ * common foot-gun of picking `anthropic/claude-*` while pointed at
+ * OpenAI direct, where the request 404s at the endpoint and the user
+ * has no obvious "you needed to switch endpoints" signal.
+ *
+ * Returns false for gateway providers (OpenRouter, "anthropic-via-gateway")
+ * since multi-vendor namespaces are expected there.
+ */
+function looksLikeForeignModel(model, provider) {
+    // Gateways are vendor-agnostic by design.
+    if (provider.id === 'openrouter' || provider.id === 'anthropic-via-gateway')
+        return false;
+    const FOREIGN_PREFIXES = {
+        openai: ['anthropic/', 'google/', 'meta/', 'mistralai/', 'qwen/', 'deepseek/'],
+        deepseek: ['anthropic/', 'google/', 'openai/', 'meta/', 'mistralai/'],
+        gemini: ['anthropic/', 'openai/', 'meta/', 'mistralai/', 'deepseek/'],
+        lmstudio: [],
+        ollama: [],
+    };
+    const list = FOREIGN_PREFIXES[provider.id] ?? [];
+    return list.some((prefix) => model.startsWith(prefix));
+}

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

@@ -3,4 +3,24 @@
  * Hand-tune imports if the compiler complains.
  */
 import type { CommandContext } from './_context.js';
+import { type SkillListItem } from '../../prompt/skillCatalog.js';
+/**
+ * Decide whether `/grill-me` should refuse to fire because the current
+ * workflow already has a written `spec.md`. The clarifying pass is meant to
+ * happen BEFORE the spec is committed — once a spec exists, asking again
+ * usually means we're re-litigating answers the user already gave, which
+ * wastes a turn. `--force` is the explicit escape hatch when the user
+ * genuinely wants a second clarifying pass (e.g., scope has drifted).
+ *
+ * Exported helper for unit tests so the guard logic can be exercised
+ * without standing up the whole REPL context. NOT pure: reads workflow
+ * state from disk (`getCurrentWorkflow`, `readArtifact`) and the latter
+ * may mkdirSync the workflow folder as a side effect.
+ */
+export declare function shouldSkipGrillMe(workspaceRoot: string, force: boolean, sessionKey?: string): {
+    skip: boolean;
+    slug?: string;
+    specPath?: string;
+};
 export declare function tryHandleWorkflowCommand(ctx: CommandContext): Promise<boolean>;
+export declare function normalizeSkillsList(payload: any): SkillListItem[] | undefined;