@kinqs/brainrouter-cli 0.3.6 → 0.3.7

package/dist/cli/commands/workflow.js

@@ -17,6 +17,7 @@ import { askYesNo } from '../cliPrompt.js';
 import { formatPlan, readPlan, updatePlan } from '../../state/taskStore.js';
 import { getLoopState, parseInterval, startLoop, stopLoop } from '../../runtime/loopRunner.js';
 import { SLASH_TO_SKILL } from '../../prompt/skillRunner.js';
+import { listFilesystemSkills, mergeSkillLists } from '../../prompt/skillCatalog.js';
 import { buildGoalKickoffPrompt, runSkillByName, runSkillCommand } from './_helpers.js';
 // Promise-flavored exec for case bodies that shell out.
 const execPromise = promisify(exec);
@@ -83,16 +84,29 @@ export async function tryHandleWorkflowCommand(ctx) {
     switch (command) {
         case '/skills':
             {
+                const verbose = args.includes('--verbose') || args.includes('-v');
                 const spinner = makeSpinner(chalk.gray('Fetching skills...')).start();
                 try {
                     const res = await callMcpTool(mcpClient, 'list_skills', { scope: 'all' });
                     spinner.stop();
-                    if (!res.isError && Array.isArray(res.parsed)) {
-                        const skillsList = res.parsed;
-                        console.log(chalk.bold('\n🧠 BrainRouter Skills:'));
+                    const mcpSkills = !res.isError ? normalizeSkillsList(res.parsed) : undefined;
+                    const filesystemSkills = listFilesystemSkills(agent.workspaceRoot);
+                    const skillsList = mcpSkills
+                        ? mergeSkillLists(mcpSkills, filesystemSkills)
+                        : filesystemSkills;
+                    if (skillsList) {
+                        console.log(chalk.bold(`\n🧠 BrainRouter Skills (${skillsList.length}):`));
                         if (skillsList.length > 0) {
                             for (const skill of skillsList) {
-                                console.log(`  • ${chalk.cyan(skill.name)} (${chalk.gray(skill.scope)}) - ${skill.description}`);
+                                const category = skill.category ? `${skill.category}/` : '';
+                                const suffix = verbose && skill.description ? ` - ${skill.description}` : '';
+                                console.log(`  • ${chalk.cyan(`${category}${skill.name}`)} (${chalk.gray(skill.scope ?? 'unknown')})${suffix}`);
+                            }
+                            if (mcpSkills && skillsList.length > mcpSkills.length) {
+                                console.log(chalk.gray(`  Showing ${skillsList.length} skills (${mcpSkills.length} from MCP, ${skillsList.length - mcpSkills.length} filled from local files).`));
+                            }
+                            else if (!mcpSkills && filesystemSkills.length > 0) {
+                                console.log(chalk.gray('  MCP list unavailable; showing local filesystem skills.'));
                             }
                         }
                         else {
@@ -101,6 +115,8 @@ export async function tryHandleWorkflowCommand(ctx) {
                     }
                     else {
                         console.log(chalk.red('\nFailed to parse skills list response.'));
+                        if (res.text)
+                            console.log(chalk.gray(`  ${res.text.slice(0, 300)}`));
                     }
                 }
                 catch (err) {
@@ -112,24 +128,29 @@ export async function tryHandleWorkflowCommand(ctx) {
             }
         case '/tools':
             {
-                console.log(chalk.bold('\nLocal Workspace Tools:'));
+                const verbose = args.includes('--verbose') || args.includes('-v');
+                console.log(chalk.bold(`\nLocal Workspace Tools (${LOCAL_TOOLS.length}):`));
                 for (const tool of LOCAL_TOOLS) {
-                    console.log(`  ${chalk.cyan(tool.name)} - ${tool.description}`);
+                    const suffix = verbose ? ` - ${tool.description}` : '';
+                    console.log(`  • ${chalk.cyan(tool.name)}${suffix}`);
                 }
                 const spinner = makeSpinner(chalk.gray('Fetching MCP tools...')).start();
                 try {
                     const res = await mcpClient.listTools();
                     spinner.stop();
                     const tools = res.tools || [];
-                    console.log(chalk.bold('\nMCP Tools:'));
+                    console.log(chalk.bold(`\nMCP Tools (${tools.length}):`));
                     if (tools.length === 0) {
                         console.log(chalk.yellow('  No MCP tools exposed by the active server.'));
                     }
                     else {
                         for (const tool of tools) {
-                            console.log(`  ${chalk.cyan(tool.name)} - ${tool.description || 'No description'}`);
+                            const suffix = verbose ? ` - ${tool.description || 'No description'}` : '';
+                            console.log(`  • ${chalk.cyan(tool.name)}${suffix}`);
                         }
                     }
+                    if (!verbose)
+                        console.log(chalk.gray('  Use /tools --verbose to include descriptions.'));
                 }
                 catch (err) {
                     spinner.fail(chalk.red('Failed to list MCP tools.'));
@@ -960,3 +981,28 @@ export async function tryHandleWorkflowCommand(ctx) {
     }
     return false;
 }
+export function normalizeSkillsList(payload) {
+    const list = Array.isArray(payload)
+        ? payload
+        : Array.isArray(payload?.skills)
+            ? payload.skills
+            : Array.isArray(payload?.items)
+                ? payload.items
+                : Array.isArray(payload?.results)
+                    ? payload.results
+                    : undefined;
+    if (!Array.isArray(list))
+        return undefined;
+    return list
+        .filter((item) => item && typeof item === 'object' && typeof item.name === 'string')
+        .map((item) => {
+        const normalized = { name: item.name };
+        if (typeof item.scope === 'string')
+            normalized.scope = item.scope;
+        if (typeof item.category === 'string')
+            normalized.category = item.category;
+        if (typeof item.description === 'string')
+            normalized.description = item.description;
+        return normalized;
+    });
+}

package/dist/cli/ink/ChatApp.d.ts

@@ -0,0 +1,206 @@
+import React from 'react';
+import { type SlashCommandDef } from './SlashPalette.js';
+/**
+ * Ink-based chat REPL — replaces the readline-based `startREPL` shell.
+ *
+ * Layout (matches claude-code's chrome):
+ *
+ *   ┌─────────────────────────────────────────────────────────────┐
+ *   │  banner (one-time, at top of scrollback)                    │
+ *   │  ⏺ assistant turn 1                                          │
+ *   │    ⎿ tool call result                                        │
+ *   │  ❯ user: what about X?                                       │
+ *   │  ⏺ assistant turn 2                                          │
+ *   │  ...                                                         │
+ *   │                                                              │
+ *   ├──────────────────────────────────────────────────────────────┤
+ *   │  ❯ <input cursor here>                                       │  ← composer
+ *   ├──────────────────────────────────────────────────────────────┤
+ *   │  model · session · ◉ effort                ? for shortcuts   │  ← footer
+ *   └──────────────────────────────────────────────────────────────┘
+ *
+ * Scrollback stays in Ink's normal render tree. It is tempting to use
+ * `<Static>` for finished entries, but a chat shell has a permanently
+ * live composer below it; on terminal resize, the Static/dynamic split
+ * can leave old composer frames behind because the resize clear only
+ * applies to Ink's live region. Keeping the full frame diffable makes
+ * resize redraw exactly one prompt block.
+ *
+ * Slash palette is a child component: when the input buffer becomes
+ * `/`, the palette renders BELOW the composer with the filtered
+ * command list. No more readline detach/Ink mount cycle — Ink owns
+ * stdin for the entire REPL lifetime.
+ *
+ * State machine:
+ *   - phase: 'idle' | 'turn-running' | 'side-conversation'
+ *   - scrollback: ScrollbackEntry[] — completed entries (banner, turns, slash output)
+ *   - composerValue: string — current input buffer
+ *   - palette: 'closed' | 'open' — visible when value starts with `/`
+ */
+export interface ChatAppProps {
+    initialBanner: string;
+    initialOfflineWarning?: string;
+    initialHint: string;
+    /** Static description of the slash commands the user can run. */
+    slashCommands: SlashCommandDef[];
+    /** Initial prompt label, e.g. "brainrouter[effort:low]". */
+    promptLabel: string;
+    /** Accent color (hex) for chrome. */
+    accentColor?: string;
+    /** Called when the user submits a line (slash command OR free-form prompt). */
+    onSubmit: (text: string, push: PushScrollback) => Promise<void>;
+    /**
+     * Imperative hook — invoked once during mount with a controller object the
+     * orchestrator can use to push scrollback / footer updates from outside the
+     * React tree (e.g. when the parent-turn closure wants to print a side-channel
+     * message after `agent.runTurn` resolved but before the next prompt cycle).
+     */
+    onReady?: (controller: ChatController) => void;
+    /**
+     * Cycle the access mode (read → write → shell → read). Returned label is
+     * appended to the footer pill. Called when the user presses Shift+Tab.
+     */
+    onAccessModeCycle?: () => string;
+    /**
+     * Initial access mode for the footer pill — kept in sync via
+     * `controller.setFooter({ accessMode })`. Defaults to 'read'.
+     */
+    initialAccessMode?: 'read' | 'write' | 'shell';
+    /**
+     * Initial extra footer segments (model, session, effort, branch). Updated
+     * after each turn via `controller.setFooter`.
+     */
+    initialFooter?: FooterState;
+}
+export interface FooterState {
+    /** e.g. "gpt-4o-mini". */
+    model?: string;
+    /** e.g. "rep-2026-…-abc123". Truncated for display. */
+    session?: string;
+    /** e.g. "main". */
+    branch?: string;
+    /** "low" | "medium" | "high". Rendered as a pill. */
+    effort?: string;
+    /** Free-form right-side text (statusline segments). */
+    rightExtra?: string;
+}
+export interface ChatController {
+    /** Push entries from outside the React tree (e.g. after the parent turn ended). */
+    push: PushScrollback;
+    /** Replace the startup banner row without clearing the chat scrollback. */
+    replaceBanner: (text: string) => void;
+    /** Update the footer status row (model, session, access mode, effort, etc.). */
+    setFooter: (patch: Partial<FooterState & {
+        accessMode: 'read' | 'write' | 'shell';
+    }>) => void;
+    /** Programmatically inject text into the composer (e.g. workflow.ts loop tick). */
+    setComposer: (text: string) => void;
+    /**
+     * Render `node` as an overlay above the chat composer. The composer
+     * hides while the overlay is active so the overlay's own useInput
+     * handlers own keystrokes. Used by `runPicker` / `runTextField` to
+     * show /config, /login, /init pickers WITHOUT mounting a second Ink
+     * instance (which would race the chat for stdin and terminal state).
+     * Promise resolves when `clearOverlay()` is called.
+     */
+    showOverlay: (node: React.ReactElement) => Promise<void>;
+    /** Remove whatever overlay is currently shown; safe to call when none is set. */
+    clearOverlay: () => void;
+    /** Exit the chat app gracefully. */
+    exit: () => void;
+}
+export type ScrollbackEntry = {
+    id: number;
+    kind: 'raw';
+    text: string;
+    noWrap?: boolean;
+} | {
+    id: number;
+    kind: 'user';
+    text: string;
+} | {
+    id: number;
+    kind: 'assistant';
+    text: string;
+    raw?: boolean;
+    durationMs?: number;
+    tokensIn?: number;
+    tokensOut?: number;
+    calls?: number;
+}
+/**
+ * Tool call result row — claude-code style:
+ *   ⏺ Read(src/foo.ts)            (green ⏺ when ok, red when failed)
+ *     ⎿ <preview line 1>          (if preview present, with ⎿ connector)
+ *       <preview line 2>           (continuation lines plain indent)
+ *       (+N more lines hidden)     (truncation hint)
+ * `header` is the formatToolCall'd string. `kind` of preview rendering
+ * is derived: if the preview looks like a diff, lines colored +green/-red.
+ */
+ | {
+    id: number;
+    kind: 'tool';
+    header: string;
+    ok: boolean;
+    durationMs?: number;
+    preview?: string;
+} | {
+    id: number;
+    kind: 'memory';
+    level: 'info' | 'warn';
+    text: string;
+}
+/** Plan rendering: optional `explanation` renders above the checklist as a dim line. */
+ | {
+    id: number;
+    kind: 'plan';
+    items: {
+        step: string;
+        status: 'pending' | 'in_progress' | 'completed';
+    }[];
+    explanation?: string;
+}
+/** Notice severity:  info → gray dim · warn → yellow · error → red bold. */
+ | {
+    id: number;
+    kind: 'notice';
+    text: string;
+    level?: 'info' | 'warn' | 'error';
+};
+export interface PushScrollback {
+    raw(text: string, opts?: {
+        noWrap?: boolean;
+    }): void;
+    user(text: string): void;
+    /** `raw: true` skips marked-terminal rendering (use when caller already pre-rendered or user wants raw scrollback). */
+    assistant(text: string, meta?: {
+        raw?: boolean;
+        durationMs?: number;
+        tokensIn?: number;
+        tokensOut?: number;
+        calls?: number;
+    }): void;
+    /**
+     * `header` is the formatted call (e.g. `Read(src/foo.ts)` from
+     * `formatToolCall` in toolFormat.ts), NOT the raw tool name. Pass the
+     * full result preview unmodified — the renderer applies diff coloring
+     * + truncation hints.
+     */
+    tool(header: string, ok: boolean, opts?: {
+        preview?: string;
+        durationMs?: number;
+    }): void;
+    memory(level: 'info' | 'warn', text: string): void;
+    plan(items: {
+        step: string;
+        status: 'pending' | 'in_progress' | 'completed';
+    }[], explanation?: string): void;
+    /** Severity defaults to 'info' when omitted (back-compat). */
+    notice(text: string, level?: 'info' | 'warn' | 'error'): void;
+    /** Update the live spinner label (e.g. "Thinking  5s  1.2k↑ 0.4k↓"). */
+    setStatus(label: string): void;
+    /** Show / hide the spinner without pushing a scrollback entry. */
+    setPhase(phase: 'idle' | 'turn-running'): void;
+}
+export declare function ChatApp({ initialBanner, initialOfflineWarning, initialHint, slashCommands, promptLabel, accentColor, onSubmit, onReady, onAccessModeCycle, initialAccessMode, initialFooter, }: ChatAppProps): import("react/jsx-runtime").JSX.Element;
+export declare function filterPaletteCommands(commands: SlashCommandDef[], query: string): SlashCommandDef[];