@kinqs/brainrouter-cli 0.3.6 → 0.3.8

package/dist/cli/ink/toolFormat.js

@@ -0,0 +1,206 @@
+/**
+ * Tool call display formatters — claude-code-style semantic rendering.
+ *
+ * The raw `tool_name({"path": "...", ...})` JSON dump that fell out of
+ * `agent.runTurn`'s onToolStart callback is hostile to quick scanning
+ * during a long turn. claude-code's transcript format is
+ *
+ *   ⏺ Read(src/auth/login.ts)
+ *   ⏺ Bash(npm test)
+ *   ⏺ Grep("authenticate")
+ *
+ * — one-line, identity-revealing, no JSON. These helpers do the same
+ * mapping for our built-in LOCAL_TOOLS (cli/../agent/agent.ts) + MCP
+ * tool names (which carry an `mcp_<server>_` namespace prefix that
+ * the user doesn't care about).
+ *
+ * Reference for the convention: claude-code transcripts (see
+ * openSrc/claude-code/CHANGELOG.md mentions throughout; the format is
+ * not formally documented but used in every claude-code session).
+ */
+/**
+ * Format a tool call as a one-line `Function(args)` summary.
+ *
+ * Examples:
+ *   formatToolCall('read_file', { path: 'src/foo.ts' })
+ *     → "Read(src/foo.ts)"
+ *   formatToolCall('run_command', { command: 'npm test' })
+ *     → "Bash(npm test)"
+ *   formatToolCall('grep_search', { query: 'authenticate', path: '.' })
+ *     → 'Grep("authenticate")'
+ *   formatToolCall('mcp_brainrouter_memory_search', { q: 'auth' })
+ *     → 'MemorySearch("auth")'
+ *   formatToolCall('spawn_agent', { role: 'researcher', prompt: '...' })
+ *     → 'Spawn(researcher, "...")'
+ *   formatToolCall('task_agent', { role: 'reviewer', prompt: '...' })
+ *     → 'Task(reviewer, "...")'
+ */
+export function formatToolCall(name, args) {
+    const safeArgs = args ?? {};
+    const clean = stripMcpPrefix(name);
+    switch (clean) {
+        case 'read_file': {
+            const path = safeArgs.path ?? '.';
+            const startLine = safeArgs.startLine;
+            const endLine = safeArgs.endLine;
+            if (startLine && endLine)
+                return `Read(${path}:${startLine}-${endLine})`;
+            if (startLine)
+                return `Read(${path}:${startLine})`;
+            return `Read(${path})`;
+        }
+        case 'write_file':
+            return `Write(${safeArgs.path ?? ''})`;
+        case 'edit_file':
+            return `Edit(${safeArgs.path ?? ''})`;
+        case 'list_dir':
+            return `LS(${safeArgs.path ?? '.'})`;
+        case 'grep_search':
+            return `Grep(${quoteShort(safeArgs.query, 50)})`;
+        case 'glob_files':
+            return `Glob(${quoteShort(safeArgs.pattern, 50)})`;
+        case 'run_command':
+            return `Bash(${truncateOneLine(safeArgs.command ?? '', 70)})`;
+        case 'fetch_url':
+            return `Fetch(${truncateOneLine(safeArgs.url ?? '', 70)})`;
+        case 'web_search':
+            return `WebSearch(${quoteShort(safeArgs.query, 50)})`;
+        case 'spawn_agent': {
+            const role = String(safeArgs.role ?? 'agent');
+            const label = safeArgs.label ? ` [${safeArgs.label}]` : '';
+            const task = truncateOneLine(safeArgs.prompt ?? '', 50);
+            return `Spawn(${role}${label}, "${task}")`;
+        }
+        case 'task_agent': {
+            const role = String(safeArgs.role ?? safeArgs.agentId ?? 'agent');
+            const label = safeArgs.label ? ` [${safeArgs.label}]` : '';
+            const task = truncateOneLine(safeArgs.prompt ?? '', 50);
+            return `Task(${role}${label}, "${task}")`;
+        }
+        case 'delegate_agent': {
+            const role = String(safeArgs.role ?? safeArgs.agentId ?? 'agent');
+            const label = safeArgs.label ? ` [${safeArgs.label}]` : '';
+            const task = truncateOneLine(safeArgs.prompt ?? '', 50);
+            return `Delegate(${role}${label}, "${task}")`;
+        }
+        case 'spawn_agents': {
+            const agents = Array.isArray(safeArgs.agents) ? safeArgs.agents : [];
+            const roles = agents.map((a) => String(a?.role ?? 'agent')).join(', ');
+            return `SpawnAll(${agents.length}: ${roles})`;
+        }
+        case 'update_plan':
+            return `UpdatePlan()`;
+        case 'ask_user_choice':
+            return `AskUser(${quoteShort(safeArgs.question, 50)})`;
+    }
+    // Generic fallback: PascalCase the name and surface the first string-shaped
+    // argument as the identifying value. Better than JSON-dumping everything.
+    const pretty = snakeToPascal(clean);
+    const firstString = Object.values(safeArgs).find((v) => typeof v === 'string' && v.length > 0);
+    if (firstString !== undefined) {
+        return `${pretty}(${truncateOneLine(firstString, 60)})`;
+    }
+    // No args, or no string args — just show the name.
+    return `${pretty}()`;
+}
+// Server ids registered at boot. MCP server names may contain underscores
+// (`my_server`), so a naive `^mcp_[^_]+_(.+)$` regex would mis-strip
+// `mcp_my_server_memory_search` to `server_memory_search`. Callers that
+// know the live server inventory register it here so `stripMcpPrefix` can
+// match the longest known id first.
+let knownMcpServerIds = [];
+export function setKnownMcpServerIds(ids) {
+    knownMcpServerIds = [...ids].sort((a, b) => b.length - a.length);
+}
+/**
+ * Strip the `mcp_<server>_` namespace prefix from MCP tool names. As of
+ * 0.3.8-R5 the pool normalises to single-underscore at the boundary, so
+ * downstream call-sites only ever see this shape.
+ *   `mcp_brainrouter_memory_search` → `memory_search`
+ *   `mcp_my_server_memory_search`   → `memory_search` (when `my_server`
+ *                                     is registered via `setKnownMcpServerIds`)
+ */
+export function stripMcpPrefix(name) {
+    if (!name.startsWith('mcp_'))
+        return name;
+    const rest = name.slice('mcp_'.length);
+    for (const id of knownMcpServerIds) {
+        if (rest.startsWith(`${id}_`))
+            return rest.slice(id.length + 1);
+    }
+    // Fallback when no server ids are registered (test fixtures, early boot):
+    // assume the server id has no underscores.
+    const idx = rest.indexOf('_');
+    return idx >= 0 ? rest.slice(idx + 1) : name;
+}
+/**
+ * Convert snake_case to PascalCase for readable display names.
+ * `memory_search` → `MemorySearch`.
+ */
+export function snakeToPascal(name) {
+    return name
+        .split('_')
+        .filter((p) => p.length > 0)
+        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+        .join('');
+}
+/**
+ * Quote + truncate a free-form string argument to fit on one line.
+ * Returns `""` for missing input — the empty-quote pair signals "empty
+ * arg" rather than "no arg" (a no-arg call would not call this at all).
+ */
+export function quoteShort(s, max) {
+    if (typeof s !== 'string' || s.length === 0)
+        return '""';
+    const oneLine = s.replace(/\s+/g, ' ').trim();
+    const truncated = oneLine.length > max ? oneLine.slice(0, max - 1) + '…' : oneLine;
+    return `"${truncated}"`;
+}
+/** Collapse whitespace + truncate a string to one line bounded by `max`. */
+export function truncateOneLine(s, max) {
+    if (typeof s !== 'string')
+        return '';
+    const oneLine = s.replace(/\s+/g, ' ').trim();
+    return oneLine.length > max ? oneLine.slice(0, max - 1) + '…' : oneLine;
+}
+/**
+ * Classify a tool-result preview line as part of a unified diff so the
+ * renderer can color it (red for removals, green for additions, gray
+ * for context). Detects file headers (`+++`, `---`), hunk headers
+ * (`@@`), and the per-line +/- gutter sign. Returns undefined when the
+ * line doesn't look like diff content so callers can leave it alone.
+ */
+export function classifyDiffLine(line) {
+    if (line.startsWith('+++ ') || line.startsWith('--- '))
+        return 'header';
+    if (line.startsWith('@@'))
+        return 'hunk';
+    if (line.startsWith('+'))
+        return 'add';
+    if (line.startsWith('-'))
+        return 'del';
+    return undefined;
+}
+/**
+ * True when a multi-line preview looks like a unified diff (at least one
+ * `@@` hunk header OR multiple +/- gutter lines). Used by the tool-result
+ * renderer to decide whether to apply diff coloring to the whole block.
+ */
+export function looksLikeDiff(preview) {
+    if (!preview)
+        return false;
+    const lines = preview.split('\n');
+    let hunk = false;
+    let gutter = 0;
+    for (const line of lines) {
+        if (line.startsWith('@@')) {
+            hunk = true;
+            break;
+        }
+        if (line.startsWith('+') || line.startsWith('-'))
+            gutter++;
+        if (gutter >= 2)
+            break;
+    }
+    return hunk || gutter >= 2;
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Live terminal dimensions hook — re-renders the component whenever
+ * the user resizes the terminal window.
+ *
+ * Why this exists:
+ *
+ *   Ink's `useStdout()` returns the stdout stream, and `stdout.columns`
+ *   IS a live getter that always returns the current width. Ink also
+ *   subscribes to `stdout.on('resize')` internally and triggers a
+ *   re-render. In theory, reading `stdout?.columns` inside a render
+ *   function automatically picks up the new width on the next resize.
+ *
+ *   In practice, several dynamic parts of the chat REPL — the composer
+ *   divider, the slash palette description column, the footer hints —
+ *   were computed from a single inline `cols` const at the top of
+ *   render. When the user dragged the terminal narrower or wider:
+ *
+ *     - The divider stayed at its old length (overflowing or short).
+ *     - The slash palette's description budget didn't update.
+ *     - The footer right-side hint didn't collapse on narrow widths.
+ *
+ *   Cause: Ink does re-render on resize, but children that received
+ *   `cols` as a stable prop weren't being re-invoked with the new value
+ *   in all of our cases. Explicitly subscribing to `resize` and using a
+ *   React state update guarantees a re-render with the new dimensions
+ *   regardless of Ink's internal heuristics.
+ *
+ * Returns `{ columns, rows }` — both auto-update on every resize event.
+ * Defaults to 80 × 24 when stdout is unavailable (non-TTY tests).
+ */
+export interface TerminalSize {
+    columns: number;
+    rows: number;
+}
+export declare function useTerminalSize(): TerminalSize;

package/dist/cli/ink/useTerminalSize.js

@@ -0,0 +1,26 @@
+import { useState, useEffect } from 'react';
+import { useStdout } from 'ink';
+const DEFAULT_COLUMNS = 80;
+const DEFAULT_ROWS = 24;
+export function useTerminalSize() {
+    const { stdout } = useStdout();
+    const [size, setSize] = useState(() => ({
+        columns: stdout?.columns ?? DEFAULT_COLUMNS,
+        rows: stdout?.rows ?? DEFAULT_ROWS,
+    }));
+    useEffect(() => {
+        if (!stdout)
+            return;
+        const onResize = () => {
+            setSize({
+                columns: stdout.columns ?? DEFAULT_COLUMNS,
+                rows: stdout.rows ?? DEFAULT_ROWS,
+            });
+        };
+        stdout.on('resize', onResize);
+        return () => {
+            stdout.off('resize', onResize);
+        };
+    }, [stdout]);
+    return size;
+}

package/dist/cli/repl.d.ts

@@ -1,9 +1,31 @@
+import 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';
-import type { WorkspaceInfo } from '../config/workspace.js';
-export declare function startREPL(agent: Agent, mcpClient: McpClientWrapper, config: Config, workspace?: WorkspaceInfo): void;
+import type { ReplContext } from './commands/_context.js';
+/**
+ * All slash commands the REPL recognizes. Used for tab autocomplete and for
+ * the readline completer. Keep alphabetically grouped roughly by surface area.
+ *
+ * The Ink chat REPL (cli/ink/runChat.tsx) consumes this same list for its
+ * inline slash palette so both surfaces stay in lockstep as new commands land.
+ */
+export declare const SLASH_COMMANDS: readonly ["/help", "/status", "/workspace", "/where", "/tools", "/skills", "/plan", "/transcript", "/doctor", "/config", "/diff", "/commit", "/clear", "/compact", "/exit", "/quit", "/roles", "/agents", "/agent", "/spawn", "/wait", "/spec", "/feature-dev", "/grill-me", "/review", "/implement-plan", "/skill", "/workflow", "/workflows", "/approve", "/memory", "/recall", "/briefing", "/scenes", "/working", "/forget", "/init", "/login", "/sessions", "/resume", "/model", "/mcp", "/goal", "/copy", "/fork", "/rename", "/permissions", "/hooks", "/hookify", "/loop", "/schedule", "/continue", "/auto-review", "/vim", "/statusline", "/quiet", "/release-notes", "/handover", "/explain", "/trace", "/failed", "/verify", "/audit", "/export", "/import", "/persona", "/skill-hints", "/diagnostics", "/tokens", "/watch", "/yolo", "/mode", "/review-policy", "/sandbox", "/kill", "/theme", "/title", "/personality", "/effort", "/new", "/side", "/btw", "/raw", "/feedback", "/rollout", "/ps", "/stop", "/logout", "/apps", "/plugins", "/experimental", "/memories", "/debug-config", "/mention", "/keymap", "/ide"];
 export declare function renderHelp(category?: string): void;
+/**
+ * Look up a one-line description for a slash command by walking the
+ * help registry. Used to populate the slash-suggest popup. Falls back
+ * to a generic placeholder if the command isn't documented (those
+ * commands still work — they just won't get a custom description
+ * inside the popup until someone adds them to `HELP_CATEGORIES`).
+ *
+ * Description text in `HELP_CATEGORIES` sometimes carries a parenthesised
+ * argument hint (e.g. "/config [key] [value]"); we strip everything
+ * after the first space when matching by cmd token so e.g. `/config`
+ * matches `cmd: "/config [key] [value]"`.
+ */
+export declare function lookupSlashDescription(cmd: string): string;
+export declare function handleSlashCommand(command: string, args: string[], agent: Agent, mcpClient: McpClientWrapper, config: Config, rl: readline.Interface, ctx: ReplContext): Promise<void>;
 /**
  * Tab-completion source for `@path/to/file` mentions. Given a partial workspace
  * path, return the matching files and directories one level deep. Stays inside