ikie-cli 0.1.32 → 0.1.34

package/dist/skills.js

@@ -11,16 +11,38 @@ function parseFrontmatter(raw) {
     if (!m)
         return { meta: {}, body: text.trim() };
     const meta = {};
-    for (const line of m[1].split(/\r?\n/)) {
+    const lines = m[1].split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
         const kv = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line);
-        if (!kv)
+        if (!kv) {
+            i++;
             continue;
+        }
+        const key = kv[1].toLowerCase();
         let value = kv[2].trim();
+        // YAML list continuation: values that end without content may start a block list.
+        if (value === '') {
+            const listValues = [];
+            i++;
+            while (i < lines.length && /^\s*-\s+/.test(lines[i])) {
+                listValues.push(lines[i].replace(/^\s*-\s+/, '').trim());
+                i++;
+            }
+            if (listValues.length) {
+                meta[key] = listValues.join(', ');
+                continue;
+            }
+            meta[key] = '';
+            continue;
+        }
         // Strip matching surrounding quotes.
         if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
             value = value.slice(1, -1);
         }
-        meta[kv[1].toLowerCase()] = value;
+        meta[key] = value;
+        i++;
     }
     return { meta, body: (m[2] ?? '').trim() };
 }
@@ -87,6 +109,14 @@ export function discoverSkills(cwd = process.cwd()) {
             const key = name.toLowerCase();
             if (!name || byName.has(key))
                 continue;
+            const allowedTools = parseAllowedTools(meta['allowed-tools'] || meta.allowedtools || '');
+            const disallowedTools = parseAllowedTools(meta['disallowed-tools'] || meta.disallowedtools || '');
+            const disableModelInvocation = truthy(meta['disable-model-invocation'] || meta.disablemodelinvocation);
+            const userInvocable = truthy(meta['user-invocable'] || meta.userinvocable);
+            const whenToUse = (meta['when_to_use'] || meta['when-to-use'] || meta.whentouse || '').trim();
+            // Skills marked disable-model-invocation are not offered to the model.
+            if (disableModelInvocation)
+                continue;
             byName.set(key, {
                 name,
                 description,
@@ -95,6 +125,11 @@ export function discoverSkills(cwd = process.cwd()) {
                 file,
                 source: root.source,
                 origin: root.origin,
+                allowedTools,
+                disallowedTools,
+                disableModelInvocation,
+                userInvocable,
+                whenToUse,
             });
         }
     }
@@ -141,20 +176,62 @@ export function listSkillFiles(skill) {
     walk(skill.dir, '');
     return out.sort();
 }
+function truthy(v) {
+    return /^(true|yes|1|on)$/i.test((v ?? '').trim());
+}
+function parseAllowedTools(raw) {
+    const v = raw.trim();
+    if (!v)
+        return undefined;
+    return v.split(/[,\s]+/).map(t => t.trim()).filter(Boolean);
+}
 /**
  * Render the skill catalog for the system prompt: each skill's name +
  * description, so the model knows what exists and when to reach for one.
  * Returns '' when no skills are installed (so the section is omitted).
+ * Skips skills marked disable-model-invocation.
  */
 export function formatSkillsForPrompt(skills) {
-    if (!skills.length)
+    const visible = skills.filter(s => !s.disableModelInvocation);
+    if (!visible.length)
         return '';
-    const lines = skills.map(s => {
+    const lines = visible.map(s => {
         const desc = s.description || '(no description)';
-        return `- **${s.name}** — ${desc}`;
+        const when = s.whenToUse ? ` — when to use: ${s.whenToUse}` : '';
+        return `- **${s.name}** — ${desc}${when}`;
     });
     return lines.join('\n');
 }
+/**
+ * Map Claude-style allowed-tools tokens to ikie tool names.
+ * Strips arguments, lowercases, and maps known tokens.
+ */
+export function mapAllowedTools(tokens) {
+    if (!tokens?.length)
+        return [];
+    const map = {
+        read: 'read_file',
+        write: 'write_file',
+        edit: 'edit_file',
+        bash: 'bash',
+        grep: 'grep',
+        glob: 'search_files',
+    };
+    const out = [];
+    for (const raw of tokens) {
+        const token = raw.replace(/\([^)]*\)/g, '').trim().toLowerCase();
+        if (!token)
+            continue;
+        if (token.startsWith('mcp__')) {
+            out.push(token);
+            continue;
+        }
+        const mapped = map[token] ?? token;
+        if (!out.includes(mapped))
+            out.push(mapped);
+    }
+    return out;
+}
 /**
  * Build the full text returned to the model when it loads a skill via
  * `use_skill`: the instructions plus a manifest of bundled files and the

package/dist/theme.d.ts

@@ -80,7 +80,7 @@ export declare function toolMeta(rawName: string): {
 };
 export declare function toolLine(name: string, args: string): string;
 /** Multi-line output block shown after a tool runs. */
-export declare function toolOutputBlock(result: string, ms: number, indent?: string): string;
+export declare function toolOutputBlock(result: string, ms: number, indent?: string, savePath?: string): string;
 interface DiffOpts {
     path?: string;
     indent?: string;

package/dist/theme.js

@@ -397,12 +397,16 @@ export function toolLine(name, args) {
     return `${tint('●')} ${c.white.bold(verb + badge)}${c.dim('(')}${c.muted(args)}${c.dim(')')}`;
 }
 /** Multi-line output block shown after a tool runs. */
-export function toolOutputBlock(result, ms, indent = '  ') {
+export function toolOutputBlock(result, ms, indent = '  ', savePath) {
     const time = c.muted(formatDuration(ms));
+    // Skip display if output was already streamed
+    if (result.includes('__STREAMED__')) {
+        return `${indent}${c.muted('⎿')} ${time}`;
+    }
     const lines = result.split('\n').filter(l => l.trim() !== '');
     if (!lines.length)
         return `${indent}${c.muted('⎿')} ${time}`;
-    const MAX = 5;
+    const MAX = 10;
     const shown = lines.slice(0, MAX);
     const hidden = lines.length - MAX;
     const cont = indent + '  ';
@@ -412,7 +416,13 @@ export function toolOutputBlock(result, ms, indent = '  ') {
         out.push(`${cont}${c.dim(clampLine(shown[i]))}`);
     }
     if (hidden > 0) {
-        out.push(`${cont}${c.muted(`… +${hidden} lines`)}`);
+        const outputId = Math.random().toString(36).substring(7);
+        const savedOutputs = global;
+        if (!savedOutputs._ikieOutputs)
+            savedOutputs._ikieOutputs = new Map();
+        savedOutputs._ikieOutputs.set(outputId, result);
+        out.push(`${cont}${c.muted(`… +${hidden} lines`)} ${c.dim('│')} ${c.info('Full output available')}`);
+        out.push(`${cont}${c.muted('└─')} ${c.accent('ikie')} ${c.muted('show-output')} ${c.secondary(outputId)} ${c.dim('# View full output')}`);
     }
     return out.join('\n');
 }
@@ -528,7 +538,14 @@ export function toolDiffBlock(oldStr, newStr, ms, opts = {}) {
         }
     }
     const out = [];
-    out.push(`${indent}${c.muted('⎿')} ${time}  ${c.dim(summary)}`);
+    // Enhanced header with file path
+    if (opts.path) {
+        out.push(`${indent}${c.muted('⎿')} ${time}  ${c.info('📝')} ${c.white.bold(opts.path)}`);
+        out.push(`${indent}  ${c.dim(summary)}`);
+    }
+    else {
+        out.push(`${indent}${c.muted('⎿')} ${time}  ${c.dim(summary)}`);
+    }
     const MAX = 16;
     const codeWidth = cols - indent.length - gw - 4; // gutter + " x " marker + space
     const render = rowsRaw.slice(0, MAX);

package/dist/tools.d.ts

@@ -1,5 +1,6 @@
 import type OpenAI from 'openai';
 export declare const TOOL_DEFS: OpenAI.Chat.ChatCompletionTool[];
+export declare function getMcpToolDefs(): OpenAI.Chat.ChatCompletionTool[];
 export declare const SAFE_TOOLS: Set<string>;
 export declare const PLAN_TOOLS: Set<string>;
 export declare function isRestrictedPath(path: string): boolean;

package/dist/tools.js

@@ -3,6 +3,7 @@ import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSy
 import { dirname, join, resolve } from 'path';
 import { promisify } from 'util';
 import { glob } from 'glob';
+import { getMcpManager, parseClaudeMcpAddCommand } from './mcp-manager.js';
 const execAsync = promisify(exec);
 // ─── OpenAI-format Tool Definitions ──────────────────────────────────────────
 export const TOOL_DEFS = [
@@ -64,6 +65,7 @@ export const TOOL_DEFS = [
                     command: { type: 'string', description: 'Shell command' },
                     timeout_ms: { type: 'number', description: 'Timeout ms (default 30000)' },
                     cwd: { type: 'string', description: 'Working directory' },
+                    interactive: { type: 'boolean', description: 'Set true for commands that need an interactive terminal — ones that show arrow-key menus or prompts that cannot be skipped with flags (e.g. `shadcn init`, `create-next-app`, `npm init` without -y). The command is connected to the real terminal so the USER answers the prompts directly. Output is shown live, not captured, so the result only reports the exit status — read any files it creates afterward.' },
                 },
                 required: ['command'],
             },
@@ -328,28 +330,11 @@ export const TOOL_DEFS = [
             },
         },
     },
-    {
-        type: 'function',
-        function: {
-            name: 'mcp_install',
-            description: 'Install a new MCP (Model Context Protocol) server to extend capabilities. MCPs provide specialized tools like GitHub API, database access, browser automation, etc.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', description: 'Unique name for this MCP' },
-                    source: { type: 'string', description: 'Source: npm package (npm:package-name), git URL, or local path' },
-                    description: { type: 'string', description: 'Description of what this MCP does' },
-                    autoStart: { type: 'boolean', description: 'Start automatically on ikie launch (default: false)' },
-                },
-                required: ['name', 'source'],
-            },
-        },
-    },
     {
         type: 'function',
         function: {
             name: 'mcp_list',
-            description: 'List all installed MCP servers and their available tools.',
+            description: 'List all configured MCP servers and their available tools.',
             parameters: {
                 type: 'object',
                 properties: {},
@@ -357,50 +342,6 @@ export const TOOL_DEFS = [
             },
         },
     },
-    {
-        type: 'function',
-        function: {
-            name: 'mcp_start',
-            description: 'Start an installed MCP server to make its tools available.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', description: 'Name of the MCP server to start' },
-                },
-                required: ['name'],
-            },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'mcp_stop',
-            description: 'Stop a running MCP server.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', description: 'Name of the MCP server to stop' },
-                },
-                required: ['name'],
-            },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'mcp_call',
-            description: 'Call a tool from a running MCP server. Use mcp_list first to see available tools and their parameters.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    server: { type: 'string', description: 'MCP server name' },
-                    tool: { type: 'string', description: 'Tool name from the MCP server' },
-                    arguments: { type: 'object', description: 'Arguments to pass to the tool' },
-                },
-                required: ['server', 'tool', 'arguments'],
-            },
-        },
-    },
     {
         type: 'function',
         function: {
@@ -418,29 +359,20 @@ export const TOOL_DEFS = [
             },
         },
     },
-    {
-        type: 'function',
-        function: {
-            name: 'mcp_uninstall',
-            description: 'Uninstall an MCP server (cannot uninstall built-in MCPs).',
-            parameters: {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', description: 'Name of the MCP server to uninstall' },
-                },
-                required: ['name'],
-            },
-        },
-    },
 ];
+// ─── MCP first-class tool definitions ─────────────────────────────────────────
+export function getMcpToolDefs() {
+    return getMcpManager().getToolDefsSync();
+}
 // ─── Safe tools (auto-approved) ───────────────────────────────────────────────
 // spawn_agent is "safe" at the dispatch layer — the tools the sub-agent itself
 // runs go through their own approval inside the sub-agent loop.
-export const SAFE_TOOLS = new Set(['read_file', 'list_dir', 'search_files', 'grep', 'memory_write', 'spawn_agent', 'ask_user', 'fetch_url', 'web_search', 'git_status', 'git_diff', 'git_log', 'git_branch', 'use_skill', 'install_skill', 'remove_skill', 'mcp_list', 'mcp_start', 'mcp_stop', 'mcp_call', 'mcp_add']);
+export const SAFE_TOOLS = new Set(['read_file', 'list_dir', 'search_files', 'grep', 'memory_write', 'spawn_agent', 'ask_user', 'fetch_url', 'web_search', 'git_status', 'git_diff', 'git_log', 'git_branch', 'use_skill', 'install_skill', 'remove_skill', 'mcp_list']);
 // Tools available in PLAN mode — read-only exploration plus delegation/questions.
 // Everything that mutates the filesystem or runs commands (write_file, edit_file,
 // bash, memory_write) is intentionally excluded so plan mode can only research.
-export const PLAN_TOOLS = new Set(['read_file', 'list_dir', 'search_files', 'grep', 'spawn_agent', 'ask_user', 'fetch_url', 'web_search', 'git_status', 'git_diff', 'git_log', 'git_branch', 'use_skill', 'install_skill', 'remove_skill', 'mcp_list', 'mcp_call', 'mcp_add']);
+// MCP tools are also excluded because we cannot prove they are read-only.
+export const PLAN_TOOLS = new Set(['read_file', 'list_dir', 'search_files', 'grep', 'spawn_agent', 'ask_user', 'fetch_url', 'web_search', 'git_status', 'git_diff', 'git_log', 'git_branch', 'use_skill', 'install_skill', 'remove_skill', 'mcp_list']);
 // Paths that may contain secrets, credentials, or system configuration.
 // Reading these requires explicit user permission even though read_file is normally safe.
 const RESTRICTED_PATTERNS = [
@@ -524,8 +456,17 @@ export function formatToolArgs(name, input) {
             return `"${p(input.source)}"${input.force ? ' --force' : ''}`;
         case 'remove_skill':
             return input.name ? `"${p(input.name)}"` : '(list installed)';
-        default:
+        case 'mcp_list':
+            return '(status)';
+        case 'mcp_add':
+            return `"${p(input.name)}"`;
+        default: {
+            if (name.startsWith('mcp__')) {
+                const parts = name.split('__');
+                return `${parts[1] ?? '?'}.${parts[2] ?? '?'}`;
+            }
             return JSON.stringify(input).slice(0, 80);
+        }
     }
 }
 // ─── Security Validation Functions ───────────────────────────────────────────
@@ -623,6 +564,9 @@ async function bash(input) {
         cwd = resolve(input.cwd);
     }
     const command = input.command.trim();
+    if (input.interactive) {
+        return bashInteractive(command, cwd);
+    }
     if (command.endsWith('&')) {
         const bgCmd = command.slice(0, -1).trim();
         try {
@@ -645,6 +589,11 @@ async function bash(input) {
     }
     const maxTimeout = 300000;
     const timeout = Math.min(input.timeout_ms ?? 60000, maxTimeout);
+    // For build commands or when stream is enabled, use streaming output
+    const shouldStream = input.stream || /\b(build|compile|test|deploy|install)\b/i.test(command);
+    if (shouldStream) {
+        return bashStreaming(command, cwd, timeout);
+    }
     try {
         const { stdout, stderr } = await execAsync(command, {
             cwd,
@@ -670,6 +619,126 @@ async function bash(input) {
         return `Exit ${e.code ?? 1}\n${parts.join('\n')}`;
     }
 }
+function bashStreaming(command, cwd, timeout) {
+    return new Promise((resolve, reject) => {
+        const isWindows = process.platform === 'win32';
+        const child = spawn(isWindows ? 'cmd.exe' : 'bash', isWindows ? ['/d', '/s', '/c', command] : ['-c', command], { cwd, timeout });
+        let stdout = '';
+        let stderr = '';
+        const indent = '  ';
+        const MAX_LINES_SHOWN = 3;
+        let linesShown = 0;
+        let totalLines = 0;
+        // Print a blank line before streaming output
+        process.stdout.write('\n');
+        // Stream stdout line by line - show only first few lines
+        child.stdout?.on('data', (data) => {
+            const text = data.toString();
+            stdout += text;
+            const lines = text.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                totalLines++;
+                if (linesShown < MAX_LINES_SHOWN) {
+                    process.stdout.write(`${indent}${line}\n`);
+                    linesShown++;
+                }
+            }
+        });
+        child.stderr?.on('data', (data) => {
+            const text = data.toString();
+            stderr += text;
+            const lines = text.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                totalLines++;
+                if (linesShown < MAX_LINES_SHOWN) {
+                    process.stdout.write(`${indent}${line}\n`);
+                    linesShown++;
+                }
+            }
+        });
+        child.on('error', (err) => {
+            reject(new Error(`Failed to execute command: ${sanitizeError(err)}`));
+        });
+        child.on('exit', (code) => {
+            // Show truncation message if there are hidden lines
+            const hiddenLines = totalLines - linesShown;
+            if (hiddenLines > 0) {
+                process.stdout.write(`${indent}... +${hiddenLines} lines\n`);
+            }
+            const parts = [];
+            if (stdout.trim())
+                parts.push(stdout.trim());
+            if (stderr.trim())
+                parts.push(`[stderr]\n${stderr.trim()}`);
+            // Return special marker to prevent re-display
+            const output = parts.join('\n') || '(no output)';
+            if (code !== 0) {
+                resolve(`Exit ${code}\n__STREAMED__\n${output}`);
+            }
+            else {
+                resolve(`__STREAMED__\n${output}`);
+            }
+        });
+    });
+}
+/**
+ * Runs a command attached to the real terminal (stdio: 'inherit') so the USER
+ * can answer interactive prompts (arrow-key menus, y/N questions) that the
+ * non-interactive path cannot handle. Temporarily detaches the REPL's own stdin
+ * listeners and raw mode while the child owns the terminal, then restores them.
+ * Output is not captured — only the exit status is reported back to the agent.
+ */
+function bashInteractive(command, cwd) {
+    return new Promise((resolvePromise) => {
+        const stdin = process.stdin;
+        const isTTY = Boolean(stdin.isTTY);
+        const wasRaw = isTTY ? Boolean(stdin.isRaw) : false;
+        // Save and detach whatever the REPL has on stdin (cancel handler, etc.) so
+        // the child receives keystrokes directly.
+        const saved = isTTY ? stdin.rawListeners('data').slice() : [];
+        for (const l of saved)
+            stdin.removeListener('data', l);
+        const restore = () => {
+            if (isTTY) {
+                try {
+                    stdin.setRawMode(wasRaw);
+                }
+                catch { /* ignore */ }
+                if (process.stdout.isTTY)
+                    process.stdout.write('\x1b[?2004h'); // re-arm bracketed paste
+            }
+            for (const l of saved)
+                stdin.on('data', l);
+        };
+        if (isTTY) {
+            try {
+                stdin.setRawMode(false);
+            }
+            catch { /* ignore */ }
+            if (process.stdout.isTTY)
+                process.stdout.write('\x1b[?2004l'); // disable bracketed paste for the child
+        }
+        process.stdout.write('\n');
+        try {
+            const isWindows = process.platform === 'win32';
+            const child = spawn(isWindows ? 'cmd.exe' : 'bash', isWindows ? ['/d', '/s', '/c', command] : ['-c', command], { cwd, stdio: 'inherit' });
+            child.on('error', (err) => {
+                restore();
+                resolvePromise(`Error running interactive command: ${sanitizeError(err)}`);
+            });
+            child.on('exit', (code) => {
+                restore();
+                resolvePromise(code === 0
+                    ? '(interactive command completed — output was shown to the user; read any created/changed files to see the result)'
+                    : `Exit ${code ?? 1} (interactive command)`);
+            });
+        }
+        catch (err) {
+            restore();
+            resolvePromise(`Error running interactive command: ${sanitizeError(err)}`);
+        }
+    });
+}
 function listDir(input) {
     const root = resolve(input.path ?? '.');
     if (!existsSync(root))
@@ -1065,98 +1134,40 @@ async function removeSkill(input) {
     return removed ? `Removed skill "${name}".` : `No skill named "${name}" found.`;
 }
 // ─── MCP Functions ────────────────────────────────────────────────────────────
-async function mcpInstall(input) {
-    const { getMCPManager } = await import('./mcp-manager.js');
-    const manager = getMCPManager();
-    const result = await manager.installMCP({
-        name: input.name,
-        source: input.source,
-        description: input.description,
-        autoStart: input.autoStart,
-    });
-    if (!result.success) {
-        return `Error installing MCP: ${result.error}`;
-    }
-    return `✓ Installed MCP "${input.name}".\nRun mcp_start to activate it.`;
-}
 async function mcpList() {
-    const { getMCPManager } = await import('./mcp-manager.js');
-    const manager = getMCPManager();
-    const mcps = manager.listMCPs();
-    if (!mcps.length) {
-        return 'No MCPs installed. Use mcp_install to add MCP servers.';
+    const servers = getMcpManager().listServers();
+    if (!servers.length) {
+        return 'No MCP servers configured. Use mcp_add or create a .mcp.json file.';
     }
-    const lines = ['Available MCPs:\n'];
-    for (const mcp of mcps) {
-        const status = mcp.running ? '🟢 Running' : mcp.enabled ? '⚪ Stopped' : '⚫ Disabled';
-        const builtIn = mcp.builtIn ? ' [Built-in]' : '';
-        lines.push(`${status} ${mcp.name}${builtIn}`);
-        lines.push(`   ${mcp.description}`);
-        if (mcp.running && mcp.tools) {
-            lines.push(`   Tools: ${mcp.tools.map(t => t.name).join(', ')}`);
+    const lines = ['MCP servers:\n'];
+    for (const s of servers) {
+        const status = s.connected ? '🟢 connected' : s.enabled ? '⚪ disabled/not connected' : '⚫ disabled';
+        lines.push(`${status} ${s.name}`);
+        if (s.error)
+            lines.push(`   error: ${s.error}`);
+        if (s.tools.length) {
+            lines.push(`   tools: ${s.tools.map(t => t.name).join(', ')}`);
         }
         lines.push('');
     }
     return lines.join('\n');
 }
-async function mcpStart(input) {
-    const { getMCPManager } = await import('./mcp-manager.js');
-    const manager = getMCPManager();
-    const result = await manager.startMCP(input.name);
-    if (!result.success) {
-        return `Error starting MCP: ${result.error}`;
-    }
-    const toolCount = result.tools?.length || 0;
-    const toolNames = result.tools?.map(t => t.name).join(', ') || 'none';
-    return `✓ Started MCP "${input.name}".\nAvailable tools (${toolCount}): ${toolNames}`;
-}
-async function mcpStop(input) {
-    const { getMCPManager } = await import('./mcp-manager.js');
-    const manager = getMCPManager();
-    const result = manager.stopMCP(input.name);
-    if (!result.success) {
-        return `Error stopping MCP: ${result.error}`;
+async function mcpAdd(input) {
+    const parsed = parseClaudeMcpAddCommand(`mcp add ${input.name} ${input.commandArgs}`);
+    if ('error' in parsed) {
+        return `Error adding MCP: ${parsed.error}`;
     }
-    return `✓ Stopped MCP "${input.name}".`;
-}
-async function mcpCall(input) {
-    const { getMCPManager } = await import('./mcp-manager.js');
-    const manager = getMCPManager();
-    const result = await manager.callMCPTool(input.server, input.tool, input.arguments);
-    if (!result.success) {
-        return `Error calling MCP tool: ${result.error}`;
+    if (parsed.name !== input.name) {
+        return `Error adding MCP: name mismatch`;
     }
-    return typeof result.result === 'string'
-        ? result.result
-        : JSON.stringify(result.result, null, 2);
-}
-async function mcpUninstall(input) {
-    const { getMCPManager } = await import('./mcp-manager.js');
-    const manager = getMCPManager();
-    const result = manager.uninstallMCP(input.name);
-    if (!result.success) {
-        return `Error uninstalling MCP: ${result.error}`;
+    const entry = { ...parsed.entry, description: input.description, env: input.env ?? parsed.entry.env };
+    try {
+        await getMcpManager().addServer(input.name, entry, 'user');
+        return `✓ Added MCP "${input.name}" and connected.\n  Command: ${input.commandArgs}`;
     }
-    return `✓ Uninstalled MCP "${input.name}".`;
-}
-async function mcpAdd(input) {
-    const { getMCPManager } = await import('./mcp-manager.js');
-    const manager = getMCPManager();
-    const parts = input.commandArgs.trim().split(/\s+/);
-    const cmd = parts[0];
-    const args = parts.slice(1);
-    const result = manager.addMCP({
-        name: input.name,
-        command: cmd,
-        args,
-        env: input.env,
-        description: input.description,
-    });
-    if (!result.success) {
-        return `Error adding MCP: ${result.error}`;
+    catch (err) {
+        return `Error adding MCP: ${err instanceof Error ? err.message : String(err)}`;
     }
-    const envStr = input.env ? `\n  Env: ${Object.keys(input.env).join(', ')}` : '';
-    return `✓ Added MCP "${input.name}".\n  Command: ${input.commandArgs}${envStr}\n  Run mcp_start to activate it.`;
 }
 // ─── Dispatcher ───────────────────────────────────────────────────────────────
 export async function executeTool(name, input) {
@@ -1180,13 +1191,13 @@ export async function executeTool(name, input) {
         case 'use_skill': return useSkill(input);
         case 'install_skill': return installSkill(input);
         case 'remove_skill': return removeSkill(input);
-        case 'mcp_install': return mcpInstall(input);
         case 'mcp_list': return mcpList();
-        case 'mcp_start': return mcpStart(input);
-        case 'mcp_stop': return mcpStop(input);
-        case 'mcp_call': return mcpCall(input);
-        case 'mcp_uninstall': return mcpUninstall(input);
         case 'mcp_add': return mcpAdd(input);
-        default: return `Unknown tool: ${name}`;
+        default: {
+            if (name.startsWith('mcp__')) {
+                return getMcpManager().callTool(name, input);
+            }
+            return `Unknown tool: ${name}`;
+        }
     }
 }

package/dist/tree.d.ts

@@ -0,0 +1,19 @@
+interface TreeOptions {
+    maxDepth?: number;
+    showHidden?: boolean;
+    showSize?: boolean;
+    exclude?: string[];
+    currentDepth?: number;
+}
+/**
+ * Generate a visual file tree
+ */
+export declare function generateTree(rootPath: string, options?: TreeOptions): string;
+/**
+ * Parse tree command arguments
+ */
+export declare function parseTreeArgs(args: string[]): {
+    path: string;
+    options: TreeOptions;
+};
+export {};