@juspay/neurolink 1.5.3 → 1.9.0

package/dist/cli/commands/mcp.js

@@ -3,20 +3,25 @@
  * MCP Server Management Commands
  * Real MCP server connectivity and management
  */
-import ora from 'ora';
-import chalk from 'chalk';
-import fs from 'fs';
-import { spawn } from 'child_process';
-import path from 'path';
+import ora from "ora";
+import chalk from "chalk";
+import fs from "fs";
+import { spawn } from "child_process";
+import path from "path";
+import { discoverMCPServers } from "../../lib/mcp/auto-discovery.js";
+import { defaultUnifiedRegistry, } from "../../lib/mcp/unified-registry.js";
+import { ContextManager } from "../../lib/mcp/context-manager.js";
+import { initializeNeuroLinkMCP } from "../../lib/mcp/initialize.js";
+import { mcpLogger, setGlobalMCPLogLevel, LogLevel, } from "../../lib/mcp/logging.js";
 // Default MCP config file location
-const MCP_CONFIG_FILE = path.join(process.cwd(), '.mcp-config.json');
+const MCP_CONFIG_FILE = path.join(process.cwd(), ".mcp-config.json");
 // Load MCP configuration
 function loadMCPConfig() {
     if (!fs.existsSync(MCP_CONFIG_FILE)) {
         return { mcpServers: {} };
     }
     try {
-        const content = fs.readFileSync(MCP_CONFIG_FILE, 'utf-8');
+        const content = fs.readFileSync(MCP_CONFIG_FILE, "utf-8");
         return JSON.parse(content);
     }
     catch (error) {
@@ -30,33 +35,33 @@ function saveMCPConfig(config) {
 // Check if MCP server process is running
 async function checkMCPServerStatus(serverConfig) {
     try {
-        if (serverConfig.transport === 'stdio') {
+        if (serverConfig.transport === "stdio") {
             // For stdio servers, we need to actually try connecting
             const child = spawn(serverConfig.command, serverConfig.args || [], {
-                stdio: ['pipe', 'pipe', 'pipe'],
+                stdio: ["pipe", "pipe", "pipe"],
                 env: { ...process.env, ...serverConfig.env },
-                cwd: serverConfig.cwd
+                cwd: serverConfig.cwd,
             });
             return new Promise((resolve) => {
                 const timeout = setTimeout(() => {
                     child.kill();
                     resolve(false);
                 }, 3000);
-                child.on('spawn', () => {
+                child.on("spawn", () => {
                     clearTimeout(timeout);
                     child.kill();
                     resolve(true);
                 });
-                child.on('error', () => {
+                child.on("error", () => {
                     clearTimeout(timeout);
                     resolve(false);
                 });
             });
         }
-        else if (serverConfig.transport === 'sse' && serverConfig.url) {
+        else if (serverConfig.transport === "sse" && serverConfig.url) {
             // For SSE servers, check if URL is accessible
             try {
-                const response = await fetch(serverConfig.url, { method: 'HEAD' });
+                const response = await fetch(serverConfig.url, { method: "HEAD" });
                 return response.ok;
             }
             catch {
@@ -71,24 +76,24 @@ async function checkMCPServerStatus(serverConfig) {
 }
 // Connect to MCP server and get capabilities
 async function getMCPServerCapabilities(serverConfig) {
-    if (serverConfig.transport === 'stdio') {
+    if (serverConfig.transport === "stdio") {
         // Spawn MCP server and send initialize request
         const child = spawn(serverConfig.command, serverConfig.args || [], {
-            stdio: ['pipe', 'pipe', 'pipe'],
+            stdio: ["pipe", "pipe", "pipe"],
             env: { ...process.env, ...serverConfig.env },
-            cwd: serverConfig.cwd
+            cwd: serverConfig.cwd,
         });
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 child.kill();
-                reject(new Error('Timeout connecting to MCP server'));
+                reject(new Error("Timeout connecting to MCP server"));
             }, 5000);
-            let responseData = '';
-            child.stdout?.on('data', (data) => {
+            let responseData = "";
+            child.stdout?.on("data", (data) => {
                 responseData += data.toString();
                 // Look for JSON-RPC response
                 try {
-                    const lines = responseData.split('\n');
+                    const lines = responseData.split("\n");
                     for (const line of lines) {
                         if (line.trim() && line.includes('"result"')) {
                             const response = JSON.parse(line.trim());
@@ -105,50 +110,50 @@ async function getMCPServerCapabilities(serverConfig) {
                     // Continue parsing
                 }
             });
-            child.on('spawn', () => {
+            child.on("spawn", () => {
                 // Send initialize request
                 const initRequest = {
-                    jsonrpc: '2.0',
+                    jsonrpc: "2.0",
                     id: 1,
-                    method: 'initialize',
+                    method: "initialize",
                     params: {
-                        protocolVersion: '2024-11-05',
+                        protocolVersion: "2024-11-05",
                         capabilities: {},
                         clientInfo: {
-                            name: 'neurolink-cli',
-                            version: '1.0.0'
-                        }
-                    }
+                            name: "neurolink-cli",
+                            version: "1.0.0",
+                        },
+                    },
                 };
-                child.stdin?.write(JSON.stringify(initRequest) + '\n');
+                child.stdin?.write(JSON.stringify(initRequest) + "\n");
             });
-            child.on('error', (error) => {
+            child.on("error", (error) => {
                 clearTimeout(timeout);
                 reject(error);
             });
         });
     }
-    throw new Error('SSE transport not yet implemented for capabilities');
+    throw new Error("SSE transport not yet implemented for capabilities");
 }
 // List available tools from MCP server
 async function listMCPServerTools(serverConfig) {
-    if (serverConfig.transport === 'stdio') {
+    if (serverConfig.transport === "stdio") {
         const child = spawn(serverConfig.command, serverConfig.args || [], {
-            stdio: ['pipe', 'pipe', 'pipe'],
+            stdio: ["pipe", "pipe", "pipe"],
             env: { ...process.env, ...serverConfig.env },
-            cwd: serverConfig.cwd
+            cwd: serverConfig.cwd,
         });
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 child.kill();
-                reject(new Error('Timeout listing MCP server tools'));
+                reject(new Error("Timeout listing MCP server tools"));
             }, 5000);
-            let responseData = '';
+            let responseData = "";
             let initialized = false;
-            child.stdout?.on('data', (data) => {
+            child.stdout?.on("data", (data) => {
                 responseData += data.toString();
                 try {
-                    const lines = responseData.split('\n');
+                    const lines = responseData.split("\n");
                     for (const line of lines) {
                         if (line.trim() && line.includes('"result"')) {
                             const response = JSON.parse(line.trim());
@@ -156,12 +161,12 @@ async function listMCPServerTools(serverConfig) {
                                 // Initialize successful, now list tools
                                 initialized = true;
                                 const listToolsRequest = {
-                                    jsonrpc: '2.0',
+                                    jsonrpc: "2.0",
                                     id: 2,
-                                    method: 'tools/list',
-                                    params: {}
+                                    method: "tools/list",
+                                    params: {},
                                 };
-                                child.stdin?.write(JSON.stringify(listToolsRequest) + '\n');
+                                child.stdin?.write(JSON.stringify(listToolsRequest) + "\n");
                             }
                             else if (response.id === 2 && response.result.tools) {
                                 clearTimeout(timeout);
@@ -176,84 +181,377 @@ async function listMCPServerTools(serverConfig) {
                     // Continue parsing
                 }
             });
-            child.on('spawn', () => {
+            child.on("spawn", () => {
                 // Send initialize request first
                 const initRequest = {
-                    jsonrpc: '2.0',
+                    jsonrpc: "2.0",
                     id: 1,
-                    method: 'initialize',
+                    method: "initialize",
                     params: {
-                        protocolVersion: '2024-11-05',
+                        protocolVersion: "2024-11-05",
                         capabilities: {},
                         clientInfo: {
-                            name: 'neurolink-cli',
-                            version: '1.0.0'
+                            name: "neurolink-cli",
+                            version: "1.0.0",
+                        },
+                    },
+                };
+                child.stdin?.write(JSON.stringify(initRequest) + "\n");
+            });
+            child.on("error", (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    throw new Error("SSE transport not yet implemented for tool listing");
+}
+// Execute tool on MCP server
+async function executeMCPTool(serverConfig, toolName, toolParams) {
+    if (serverConfig.transport === "stdio") {
+        const child = spawn(serverConfig.command, serverConfig.args || [], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, ...serverConfig.env },
+            cwd: serverConfig.cwd,
+        });
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                child.kill();
+                reject(new Error("Timeout executing MCP tool"));
+            }, 10000); // Longer timeout for tool execution
+            let responseData = "";
+            let initialized = false;
+            child.stdout?.on("data", (data) => {
+                responseData += data.toString();
+                try {
+                    const lines = responseData.split("\n");
+                    for (const line of lines) {
+                        if (line.trim() && line.includes('"result"')) {
+                            const response = JSON.parse(line.trim());
+                            if (response.id === 1 && response.result.capabilities) {
+                                // Initialize successful, now execute tool
+                                initialized = true;
+                                const toolCallRequest = {
+                                    jsonrpc: "2.0",
+                                    id: 2,
+                                    method: "tools/call",
+                                    params: {
+                                        name: toolName,
+                                        arguments: toolParams,
+                                    },
+                                };
+                                child.stdin?.write(JSON.stringify(toolCallRequest) + "\n");
+                            }
+                            else if (response.id === 2) {
+                                clearTimeout(timeout);
+                                child.kill();
+                                if (response.result) {
+                                    resolve(response.result);
+                                }
+                                else if (response.error) {
+                                    reject(new Error(`MCP Error: ${response.error.message || "Unknown error"}`));
+                                }
+                                else {
+                                    reject(new Error("Unknown MCP response format"));
+                                }
+                                return;
+                            }
+                        }
+                        else if (line.trim() && line.includes('"error"')) {
+                            const response = JSON.parse(line.trim());
+                            if (response.error) {
+                                clearTimeout(timeout);
+                                child.kill();
+                                reject(new Error(`MCP Error: ${response.error.message || "Unknown error"}`));
+                                return;
+                            }
                         }
                     }
+                }
+                catch {
+                    // Continue parsing
+                }
+            });
+            child.stderr?.on("data", (data) => {
+                console.error(chalk.red(`MCP Server Error: ${data.toString()}`));
+            });
+            child.on("spawn", () => {
+                // Send initialize request first
+                const initRequest = {
+                    jsonrpc: "2.0",
+                    id: 1,
+                    method: "initialize",
+                    params: {
+                        protocolVersion: "2024-11-05",
+                        capabilities: {},
+                        clientInfo: {
+                            name: "neurolink-cli",
+                            version: "1.0.0",
+                        },
+                    },
                 };
-                child.stdin?.write(JSON.stringify(initRequest) + '\n');
+                child.stdin?.write(JSON.stringify(initRequest) + "\n");
             });
-            child.on('error', (error) => {
+            child.on("error", (error) => {
                 clearTimeout(timeout);
                 reject(error);
             });
         });
     }
-    throw new Error('SSE transport not yet implemented for tool listing');
+    throw new Error("SSE transport not yet implemented for tool execution");
+}
+/**
+ * Display discovery results in table format
+ */
+function displayTable(discoveryResult) {
+    console.log(chalk.green(`\n📋 Found ${discoveryResult.discovered.length} MCP servers:`));
+    console.log(chalk.gray("─".repeat(80)));
+    discoveryResult.discovered.forEach((server, index) => {
+        const sourceIcon = getSourceIcon(server.source.tool);
+        const typeColor = server.source.type === "global"
+            ? chalk.blue
+            : server.source.type === "workspace"
+                ? chalk.green
+                : chalk.gray;
+        console.log(`${chalk.white(`${index + 1}.`)} ${sourceIcon} ${chalk.cyan(server.id)}`);
+        console.log(`   ${chalk.gray("Title:")} ${server.title}`);
+        console.log(`   ${chalk.gray("Source:")} ${server.source.tool} ${typeColor(`(${server.source.type})`)}`);
+        console.log(`   ${chalk.gray("Command:")} ${server.command} ${server.args?.join(" ") || ""}`);
+        console.log(`   ${chalk.gray("Config:")} ${server.configPath}`);
+        if (server.env && Object.keys(server.env).length > 0) {
+            console.log(`   ${chalk.gray("Environment:")} ${Object.keys(server.env).length} variable(s)`);
+        }
+        console.log();
+    });
+    // Display statistics
+    console.log(chalk.blue("📊 Discovery Statistics:"));
+    console.log(`   ${chalk.gray("Execution time:")} ${discoveryResult.stats.executionTime}ms`);
+    console.log(`   ${chalk.gray("Config files found:")} ${discoveryResult.stats.configFilesFound}`);
+    console.log(`   ${chalk.gray("Servers discovered:")} ${discoveryResult.stats.serversDiscovered}`);
+    console.log(`   ${chalk.gray("Duplicates removed:")} ${discoveryResult.stats.duplicatesRemoved}`);
+    // Display sources
+    if (discoveryResult.sources.length > 0) {
+        console.log(chalk.blue("\n🎯 Search Sources:"));
+        const sourcesByTool = discoveryResult.sources.reduce((acc, source) => {
+            acc[source.tool] = (acc[source.tool] || 0) + 1;
+            return acc;
+        }, {});
+        Object.entries(sourcesByTool).forEach(([tool, count]) => {
+            const icon = getSourceIcon(tool);
+            console.log(`   ${icon} ${tool}: ${count} location(s)`);
+        });
+    }
+}
+/**
+ * Display discovery results in summary format
+ */
+function displaySummary(discoveryResult) {
+    console.log(chalk.green(`\n📊 Discovery Summary`));
+    console.log(chalk.gray("==================="));
+    console.log(`${chalk.cyan("Total servers found:")} ${discoveryResult.discovered.length}`);
+    console.log(`${chalk.cyan("Execution time:")} ${discoveryResult.stats.executionTime}ms`);
+    console.log(`${chalk.cyan("Config files found:")} ${discoveryResult.stats.configFilesFound}`);
+    console.log(`${chalk.cyan("Duplicates removed:")} ${discoveryResult.stats.duplicatesRemoved}`);
+    // Group by source tool
+    const serversByTool = discoveryResult.discovered.reduce((acc, server) => {
+        const tool = server.source.tool;
+        acc[tool] = (acc[tool] || 0) + 1;
+        return acc;
+    }, {});
+    if (Object.keys(serversByTool).length > 0) {
+        console.log(chalk.blue("\n🔧 Servers by Tool:"));
+        Object.entries(serversByTool).forEach(([tool, count]) => {
+            const icon = getSourceIcon(tool);
+            console.log(`   ${icon} ${tool}: ${count} server(s)`);
+        });
+    }
+    // Group by type
+    const serversByType = discoveryResult.discovered.reduce((acc, server) => {
+        const type = server.source.type;
+        acc[type] = (acc[type] || 0) + 1;
+        return acc;
+    }, {});
+    if (Object.keys(serversByType).length > 0) {
+        console.log(chalk.blue("\n📍 Servers by Type:"));
+        Object.entries(serversByType).forEach(([type, count]) => {
+            const typeColor = type === "global"
+                ? chalk.blue
+                : type === "workspace"
+                    ? chalk.green
+                    : chalk.gray;
+            console.log(`   ${typeColor(`${type}:`)} ${count} server(s)`);
+        });
+    }
+}
+/**
+ * Get icon for source tool
+ */
+function getSourceIcon(tool) {
+    const icons = {
+        "Claude Desktop": "🤖",
+        "VS Code": "📝",
+        Cursor: "🖱️",
+        Windsurf: "🏄",
+        "Roo Code": "🦘",
+        Generic: "⚙️",
+        "Cline AI Coder": "🔧",
+        "Continue Dev": "🔄",
+        Aider: "🛠️",
+    };
+    return icons[tool] || "🔧";
+}
+/**
+ * Get icon for source type
+ */
+function getSourceTypeIcon(sourceType) {
+    const icons = {
+        manual: "📝",
+        auto: "🔍",
+        default: "⚙️",
+    };
+    return icons[sourceType] || "❓";
+}
+/**
+ * Get icon for server status
+ */
+function getStatusIcon(status) {
+    const icons = {
+        available: "✅",
+        unavailable: "❌",
+        unknown: "❓",
+    };
+    return icons[status] || "❓";
+}
+// Export the tool execution function for use in other parts of the CLI
+export async function mcpExecuteTool(serverName, toolName, toolParams) {
+    // First try unified registry (includes built-in NeuroLink servers)
+    try {
+        await defaultUnifiedRegistry.initialize();
+        const contextManager = new ContextManager();
+        const context = contextManager.createContext({
+            sessionId: `cli-${Date.now()}`,
+            userId: "cli-user",
+            aiProvider: "unified-mcp",
+        });
+        const result = await defaultUnifiedRegistry.executeTool(toolName, toolParams, context, {
+            preferredSource: "default", // Try built-in servers first
+            fallbackEnabled: true,
+            validateBeforeExecution: true,
+            timeoutMs: 30000,
+        });
+        if (result.success) {
+            return result.data;
+        }
+    }
+    catch (error) {
+        mcpLogger.debug("[mcpExecuteTool] Unified registry failed, trying manual config:", {
+            error: error instanceof Error ? error.message : String(error),
+            serverName,
+            toolName: toolName,
+        });
+    }
+    // Fallback to manual configuration (legacy behavior)
+    const config = loadMCPConfig();
+    const serverConfig = config.mcpServers[serverName];
+    if (!serverConfig) {
+        throw new Error(`MCP server '${serverName}' not found`);
+    }
+    const result = await executeMCPTool(serverConfig, toolName, toolParams);
+    mcpLogger.debug("[mcpExecuteTool] Tool executed via manual config:", {
+        serverName,
+        toolName,
+        hasResult: !!result,
+        resultType: typeof result,
+    });
+    // Extract the text content from MCP result format
+    if (result.content && Array.isArray(result.content)) {
+        const textContent = result.content.find((item) => item.type === "text");
+        if (textContent) {
+            return JSON.parse(textContent.text);
+        }
+    }
+    return result;
 }
 // MCP Commands for yargs
 export function addMCPCommands(yargs) {
-    return yargs.command('mcp <subcommand>', 'Manage MCP (Model Context Protocol) servers', (yargsBuilder) => {
+    return yargs.command("mcp <subcommand>", "Manage MCP (Model Context Protocol) servers", (yargsBuilder) => {
         yargsBuilder
-            .usage('Usage: $0 mcp <subcommand> [options]')
+            .usage("Usage: $0 mcp <subcommand> [options]")
             // List MCP servers
-            .command('list', 'List configured MCP servers', (y) => y
-            .usage('Usage: $0 mcp list [options]')
-            .option('status', { type: 'boolean', description: 'Check server status' })
-            .example('$0 mcp list', 'List all MCP servers')
-            .example('$0 mcp list --status', 'List servers with status check'), async (argv) => {
+            .command("list", "List configured MCP servers", (y) => y
+            .usage("Usage: $0 mcp list [options]")
+            .option("status", {
+            type: "boolean",
+            description: "Check server status",
+        })
+            .example("$0 mcp list", "List all MCP servers")
+            .example("$0 mcp list --status", "List servers with status check"), async (argv) => {
             const config = loadMCPConfig();
             const servers = Object.entries(config.mcpServers);
             if (servers.length === 0) {
-                console.log(chalk.yellow('📭 No MCP servers configured'));
-                console.log(chalk.blue('💡 Add a server with: neurolink mcp add <name> <command>'));
+                console.log(chalk.yellow("📭 No MCP servers configured"));
+                console.log(chalk.blue("💡 Add a server with: neurolink mcp add <name> <command>"));
                 return;
             }
             console.log(chalk.blue(`📋 Configured MCP servers (${servers.length}):\n`));
             for (const [name, serverConfig] of servers) {
                 console.log(chalk.bold(`🔧 ${name}`));
-                console.log(`   Command: ${serverConfig.command} ${(serverConfig.args || []).join(' ')}`);
+                console.log(`   Command: ${serverConfig.command} ${(serverConfig.args || []).join(" ")}`);
                 console.log(`   Transport: ${serverConfig.transport}`);
                 if (argv.status) {
                     const spinner = ora(`Checking ${name}...`).start();
                     try {
                         const isRunning = await checkMCPServerStatus(serverConfig);
                         if (isRunning) {
-                            spinner.succeed(`${name}: ${chalk.green('✅ Available')}`);
+                            spinner.succeed(`${name}: ${chalk.green("✅ Available")}`);
                         }
                         else {
-                            spinner.fail(`${name}: ${chalk.red('❌ Not available')}`);
+                            spinner.fail(`${name}: ${chalk.red("❌ Not available")}`);
                         }
                     }
                     catch (error) {
-                        spinner.fail(`${name}: ${chalk.red('❌ Error')} - ${error.message}`);
+                        spinner.fail(`${name}: ${chalk.red("❌ Error")} - ${error.message}`);
                     }
                 }
                 console.log(); // Empty line
             }
         })
             // Add MCP server
-            .command('add <name> <command>', 'Add a new MCP server', (y) => y
-            .usage('Usage: $0 mcp add <name> <command> [options]')
-            .positional('name', { type: 'string', description: 'Server name', demandOption: true })
-            .positional('command', { type: 'string', description: 'Command to run server', demandOption: true })
-            .option('args', { type: 'array', description: 'Command arguments' })
-            .option('transport', { choices: ['stdio', 'sse'], default: 'stdio', description: 'Transport type' })
-            .option('url', { type: 'string', description: 'URL for SSE transport' })
-            .option('env', { type: 'string', description: 'Environment variables (JSON)' })
-            .option('cwd', { type: 'string', description: 'Working directory' })
-            .example('$0 mcp add filesystem "npx @modelcontextprotocol/server-filesystem"', 'Add filesystem server')
-            .example('$0 mcp add github "npx @modelcontextprotocol/server-github"', 'Add GitHub server'), async (argv) => {
+            .command("add <name> <command>", "Add a new MCP server", (y) => y
+            .usage("Usage: $0 mcp add <name> <command> [options]")
+            .positional("name", {
+            type: "string",
+            description: "Server name",
+            demandOption: true,
+        })
+            .positional("command", {
+            type: "string",
+            description: "Command to run server",
+            demandOption: true,
+        })
+            .option("args", {
+            type: "array",
+            description: "Command arguments",
+        })
+            .option("transport", {
+            choices: ["stdio", "sse"],
+            default: "stdio",
+            description: "Transport type",
+        })
+            .option("url", {
+            type: "string",
+            description: "URL for SSE transport",
+        })
+            .option("env", {
+            type: "string",
+            description: "Environment variables (JSON)",
+        })
+            .option("cwd", {
+            type: "string",
+            description: "Working directory",
+        })
+            .example('$0 mcp add filesystem "npx @modelcontextprotocol/server-filesystem"', "Add filesystem server")
+            .example('$0 mcp add github "npx @modelcontextprotocol/server-github"', "Add GitHub server"), async (argv) => {
             const config = loadMCPConfig();
             const serverConfig = {
                 name: argv.name,
@@ -261,14 +559,14 @@ export function addMCPCommands(yargs) {
                 args: argv.args || [],
                 transport: argv.transport,
                 url: argv.url,
-                cwd: argv.cwd
+                cwd: argv.cwd,
             };
             if (argv.env) {
                 try {
                     serverConfig.env = JSON.parse(argv.env);
                 }
                 catch (error) {
-                    console.error(chalk.red('❌ Invalid JSON for environment variables'));
+                    console.error(chalk.red("❌ Invalid JSON for environment variables"));
                     process.exit(1);
                 }
             }
@@ -278,10 +576,14 @@ export function addMCPCommands(yargs) {
             console.log(chalk.blue(`💡 Test it with: neurolink mcp test ${argv.name}`));
         })
             // Remove MCP server
-            .command('remove <name>', 'Remove an MCP server', (y) => y
-            .usage('Usage: $0 mcp remove <name>')
-            .positional('name', { type: 'string', description: 'Server name to remove', demandOption: true })
-            .example('$0 mcp remove filesystem', 'Remove filesystem server'), async (argv) => {
+            .command("remove <name>", "Remove an MCP server", (y) => y
+            .usage("Usage: $0 mcp remove <name>")
+            .positional("name", {
+            type: "string",
+            description: "Server name to remove",
+            demandOption: true,
+        })
+            .example("$0 mcp remove filesystem", "Remove filesystem server"), async (argv) => {
             const config = loadMCPConfig();
             if (!config.mcpServers[argv.name]) {
                 console.error(chalk.red(`❌ MCP server '${argv.name}' not found`));
@@ -292,10 +594,14 @@ export function addMCPCommands(yargs) {
             console.log(chalk.green(`✅ Removed MCP server: ${argv.name}`));
         })
             // Test MCP server
-            .command('test <name>', 'Test connection to an MCP server', (y) => y
-            .usage('Usage: $0 mcp test <name>')
-            .positional('name', { type: 'string', description: 'Server name to test', demandOption: true })
-            .example('$0 mcp test filesystem', 'Test filesystem server'), async (argv) => {
+            .command("test <name>", "Test connection to an MCP server", (y) => y
+            .usage("Usage: $0 mcp test <name>")
+            .positional("name", {
+            type: "string",
+            description: "Server name to test",
+            demandOption: true,
+        })
+            .example("$0 mcp test filesystem", "Test filesystem server"), async (argv) => {
             const config = loadMCPConfig();
             const serverConfig = config.mcpServers[argv.name];
             if (!serverConfig) {
@@ -303,87 +609,93 @@ export function addMCPCommands(yargs) {
                 process.exit(1);
             }
             console.log(chalk.blue(`🔍 Testing MCP server: ${argv.name}\n`));
-            const spinner = ora('Connecting...').start();
+            const spinner = ora("Connecting...").start();
             try {
                 // Test basic connectivity
                 const isRunning = await checkMCPServerStatus(serverConfig);
                 if (!isRunning) {
-                    spinner.fail(chalk.red('❌ Server not available'));
+                    spinner.fail(chalk.red("❌ Server not available"));
                     return;
                 }
-                spinner.text = 'Getting capabilities...';
+                spinner.text = "Getting capabilities...";
                 const capabilities = await getMCPServerCapabilities(serverConfig);
-                spinner.text = 'Listing tools...';
+                spinner.text = "Listing tools...";
                 const tools = await listMCPServerTools(serverConfig);
-                spinner.succeed(chalk.green('✅ Connection successful!'));
-                console.log(chalk.blue('\n📋 Server Capabilities:'));
-                console.log(`   Protocol Version: ${capabilities.protocolVersion || 'Unknown'}`);
+                spinner.succeed(chalk.green("✅ Connection successful!"));
+                console.log(chalk.blue("\n📋 Server Capabilities:"));
+                console.log(`   Protocol Version: ${capabilities.protocolVersion || "Unknown"}`);
                 if (capabilities.capabilities.tools) {
                     console.log(`   Tools: ✅ Supported`);
                 }
                 if (capabilities.capabilities.resources) {
                     console.log(`   Resources: ✅ Supported`);
                 }
-                console.log(chalk.blue('\n🛠️  Available Tools:'));
+                console.log(chalk.blue("\n🛠️  Available Tools:"));
                 if (tools.length === 0) {
-                    console.log('   No tools available');
+                    console.log("   No tools available");
                 }
                 else {
                     tools.forEach((tool) => {
-                        console.log(`   • ${tool.name}: ${tool.description || 'No description'}`);
+                        console.log(`   • ${tool.name}: ${tool.description || "No description"}`);
                     });
                 }
             }
             catch (error) {
-                spinner.fail(chalk.red('❌ Connection failed'));
+                spinner.fail(chalk.red("❌ Connection failed"));
                 console.error(chalk.red(`Error: ${error.message}`));
             }
         })
             // Install popular MCP servers
-            .command('install <server>', 'Install popular MCP servers', (y) => y
-            .usage('Usage: $0 mcp install <server>')
-            .positional('server', {
-            type: 'string',
-            choices: ['filesystem', 'github', 'postgres', 'brave-search', 'puppeteer'],
-            description: 'Server to install',
-            demandOption: true
-        })
-            .example('$0 mcp install filesystem', 'Install filesystem server')
-            .example('$0 mcp install github', 'Install GitHub server'), async (argv) => {
+            .command("install <server>", "Install popular MCP servers", (y) => y
+            .usage("Usage: $0 mcp install <server>")
+            .positional("server", {
+            type: "string",
+            choices: [
+                "filesystem",
+                "github",
+                "postgres",
+                "brave-search",
+                "puppeteer",
+            ],
+            description: "Server to install",
+            demandOption: true,
+        })
+            .example("$0 mcp install filesystem", "Install filesystem server")
+            .example("$0 mcp install github", "Install GitHub server"), async (argv) => {
             const serverName = argv.server;
             const config = loadMCPConfig();
             // Pre-configured popular MCP servers
             const serverConfigs = {
                 filesystem: {
-                    name: 'filesystem',
-                    command: 'npx',
-                    args: ['-y', '@modelcontextprotocol/server-filesystem', '/'],
-                    transport: 'stdio'
+                    name: "filesystem",
+                    command: "npx",
+                    args: ["-y", "@modelcontextprotocol/server-filesystem", "/"],
+                    transport: "stdio",
                 },
                 github: {
-                    name: 'github',
-                    command: 'npx',
-                    args: ['-y', '@modelcontextprotocol/server-github'],
-                    transport: 'stdio'
+                    name: "github",
+                    command: "npx",
+                    args: ["-y", "@modelcontextprotocol/server-github"],
+                    transport: "stdio",
                 },
                 postgres: {
-                    name: 'postgres',
-                    command: 'npx',
-                    args: ['-y', '@modelcontextprotocol/server-postgres'],
-                    transport: 'stdio'
+                    name: "postgres",
+                    command: "npx",
+                    args: ["-y", "@modelcontextprotocol/server-postgres"],
+                    transport: "stdio",
                 },
-                'brave-search': {
-                    name: 'brave-search',
-                    command: 'npx',
-                    args: ['-y', '@modelcontextprotocol/server-brave-search'],
-                    transport: 'stdio'
+                "brave-search": {
+                    name: "brave-search",
+                    command: "npx",
+                    args: ["-y", "@modelcontextprotocol/server-brave-search"],
+                    transport: "stdio",
                 },
                 puppeteer: {
-                    name: 'puppeteer',
-                    command: 'npx',
-                    args: ['-y', '@modelcontextprotocol/server-puppeteer'],
-                    transport: 'stdio'
-                }
+                    name: "puppeteer",
+                    command: "npx",
+                    args: ["-y", "@modelcontextprotocol/server-puppeteer"],
+                    transport: "stdio",
+                },
             };
             const serverConfig = serverConfigs[serverName];
             if (!serverConfig) {
@@ -397,12 +709,23 @@ export function addMCPCommands(yargs) {
             console.log(chalk.blue(`💡 Test it with: neurolink mcp test ${serverName}`));
         })
             // Execute tool from MCP server
-            .command('exec <server> <tool>', 'Execute a tool from an MCP server', (y) => y
-            .usage('Usage: $0 mcp exec <server> <tool> [options]')
-            .positional('server', { type: 'string', description: 'Server name', demandOption: true })
-            .positional('tool', { type: 'string', description: 'Tool name', demandOption: true })
-            .option('params', { type: 'string', description: 'Tool parameters (JSON)' })
-            .example('$0 mcp exec filesystem read_file --params \'{"path": "README.md"}\'', 'Read file using filesystem server'), async (argv) => {
+            .command("exec <server> <tool>", "Execute a tool from an MCP server", (y) => y
+            .usage("Usage: $0 mcp exec <server> <tool> [options]")
+            .positional("server", {
+            type: "string",
+            description: "Server name",
+            demandOption: true,
+        })
+            .positional("tool", {
+            type: "string",
+            description: "Tool name",
+            demandOption: true,
+        })
+            .option("params", {
+            type: "string",
+            description: "Tool parameters (JSON)",
+        })
+            .example('$0 mcp exec filesystem read_file --params \'{"path": "README.md"}\'', "Read file using filesystem server"), async (argv) => {
             const config = loadMCPConfig();
             const serverConfig = config.mcpServers[argv.server];
             if (!serverConfig) {
@@ -415,20 +738,425 @@ export function addMCPCommands(yargs) {
                     params = JSON.parse(argv.params);
                 }
                 catch (error) {
-                    console.error(chalk.red('❌ Invalid JSON for parameters'));
+                    console.error(chalk.red("❌ Invalid JSON for parameters"));
                     process.exit(1);
                 }
             }
             console.log(chalk.blue(`🔧 Executing tool: ${argv.tool} on server: ${argv.server}`));
-            // This would need full MCP client implementation
-            // For now, show what would happen
-            console.log(chalk.yellow('⚠️  Tool execution not yet implemented'));
-            console.log(`Tool: ${argv.tool}`);
-            console.log(`Parameters: ${JSON.stringify(params, null, 2)}`);
-        })
-            .demandCommand(1, 'Please specify an MCP subcommand')
-            .example('$0 mcp list', 'List configured MCP servers')
-            .example('$0 mcp install filesystem', 'Install filesystem MCP server')
-            .example('$0 mcp test filesystem', 'Test filesystem server connection');
+            const spinner = ora("Executing tool...").start();
+            try {
+                const result = await executeMCPTool(serverConfig, argv.tool, params);
+                spinner.succeed(chalk.green("✅ Tool executed successfully!"));
+                console.log(chalk.blue("\n📋 Result:"));
+                if (result.content) {
+                    // Handle different content types
+                    if (Array.isArray(result.content)) {
+                        result.content.forEach((item) => {
+                            if (item.type === "text") {
+                                console.log(item.text);
+                            }
+                            else {
+                                console.log(JSON.stringify(item, null, 2));
+                            }
+                        });
+                    }
+                    else {
+                        console.log(JSON.stringify(result.content, null, 2));
+                    }
+                }
+                else {
+                    console.log(JSON.stringify(result, null, 2));
+                }
+            }
+            catch (error) {
+                spinner.fail(chalk.red("❌ Tool execution failed"));
+                console.error(chalk.red(`Error: ${error.message}`));
+                process.exit(1);
+            }
+        })
+            // Enhanced unified list command
+            .command("list-all", "List servers from all sources (manual + auto + default)", (y) => y
+            .usage("Usage: $0 mcp list-all [options]")
+            .option("source", {
+            type: "string",
+            choices: ["manual", "auto", "default", "all"],
+            default: "all",
+            description: "Filter by source type",
+        })
+            .option("format", {
+            type: "string",
+            choices: ["table", "json"],
+            default: "table",
+            description: "Output format",
+        })
+            .option("refresh", {
+            type: "boolean",
+            description: "Force refresh auto-discovery cache",
+        })
+            .example("$0 mcp list-all", "List all servers from all sources")
+            .example("$0 mcp list-all --source auto", "List only auto-discovered servers")
+            .example("$0 mcp list-all --refresh", "Refresh auto-discovery and list all"), async (argv) => {
+            console.log(chalk.blue("🌐 NeuroLink Unified MCP Registry"));
+            console.log(chalk.gray("==================================="));
+            const spinner = ora("Initializing NeuroLink MCP...").start();
+            try {
+                // Initialize built-in NeuroLink servers first
+                await initializeNeuroLinkMCP();
+                // Initialize unified registry
+                spinner.text = "Initializing unified registry...";
+                await defaultUnifiedRegistry.initialize();
+                // Force refresh if requested
+                if (argv.refresh) {
+                    spinner.text = "Refreshing auto-discovery...";
+                    await defaultUnifiedRegistry.refreshAutoDiscovery();
+                }
+                spinner.succeed(chalk.green("Registry initialized!"));
+                // Get servers based on source filter
+                const servers = defaultUnifiedRegistry.listAllServers();
+                const filteredServers = argv.source === "all"
+                    ? servers
+                    : servers.filter((s) => s.source.type === argv.source);
+                if (filteredServers.length === 0) {
+                    console.log(chalk.yellow(`\n📭 No servers found from source: ${argv.source}`));
+                    return;
+                }
+                if (argv.format === "json") {
+                    console.log(JSON.stringify(filteredServers, null, 2));
+                    return;
+                }
+                // Table format
+                console.log(chalk.green(`\n📋 Found ${filteredServers.length} servers:`));
+                console.log(chalk.gray("─".repeat(80)));
+                filteredServers.forEach((server, index) => {
+                    const sourceIcon = getSourceTypeIcon(server.source.type);
+                    const priorityColor = server.source.priority >= 9
+                        ? chalk.green
+                        : server.source.priority >= 7
+                            ? chalk.yellow
+                            : chalk.gray;
+                    console.log(`${chalk.white(`${index + 1}.`)} ${sourceIcon} ${chalk.cyan(server.id)}`);
+                    console.log(`   ${chalk.gray("Source:")} ${server.source.type} ${priorityColor(`(priority: ${server.source.priority})`)}`);
+                    console.log(`   ${chalk.gray("Status:")} ${getStatusIcon(server.status)} ${server.status}`);
+                    if (server.config) {
+                        console.log(`   ${chalk.gray("Command:")} ${server.config.command} ${server.config.args?.join(" ") || ""}`);
+                    }
+                    if (server.source.metadata) {
+                        const metadata = server.source.metadata;
+                        if (metadata.configPath) {
+                            console.log(`   ${chalk.gray("Config:")} ${metadata.configPath}`);
+                        }
+                        if (metadata.toolCount) {
+                            console.log(`   ${chalk.gray("Tools:")} ${metadata.toolCount}`);
+                        }
+                    }
+                    console.log();
+                });
+                // Display statistics
+                const stats = defaultUnifiedRegistry.getStats();
+                console.log(chalk.blue("📊 Registry Statistics:"));
+                console.log(`   ${chalk.gray("Manual servers:")} ${stats.manual.servers}`);
+                console.log(`   ${chalk.gray("Auto-discovered:")} ${stats.auto.servers}`);
+                console.log(`   ${chalk.gray("Default registry:")} ${stats.default.servers}`);
+                console.log(`   ${chalk.gray("Total tools:")} ${stats.total.tools}`);
+            }
+            catch (error) {
+                spinner.fail(chalk.red("Registry initialization failed"));
+                console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+                process.exit(1);
+            }
+        })
+            // Enhanced tool execution with unified registry
+            .command("run <tool>", "Execute a tool using unified registry (auto-fallback)", (y) => y
+            .usage("Usage: $0 mcp run <tool> [options]")
+            .positional("tool", {
+            type: "string",
+            description: "Tool name to execute",
+            demandOption: true,
+        })
+            .option("params", {
+            type: "string",
+            description: "Tool parameters (JSON)",
+        })
+            .option("source", {
+            type: "string",
+            choices: ["manual", "auto", "default"],
+            description: "Preferred source (with fallback)",
+        })
+            .option("no-fallback", {
+            type: "boolean",
+            description: "Disable fallback to other sources",
+        })
+            .example('$0 mcp run generate-text --params \'{"prompt": "Hello world"}\'', "Run tool with fallback")
+            .example('$0 mcp run read_file --params \'{"path": "README.md"}\' --source manual', "Prefer manual config"), async (argv) => {
+            console.log(chalk.blue(`🚀 Executing tool: ${argv.tool}`));
+            const spinner = ora("Initializing NeuroLink MCP...").start();
+            try {
+                // Initialize built-in NeuroLink servers first
+                await initializeNeuroLinkMCP();
+                // Initialize unified registry
+                spinner.text = "Initializing unified registry...";
+                await defaultUnifiedRegistry.initialize();
+                let params = {};
+                if (argv.params) {
+                    try {
+                        params = JSON.parse(argv.params);
+                    }
+                    catch (error) {
+                        spinner.fail(chalk.red("❌ Invalid JSON for parameters"));
+                        process.exit(1);
+                    }
+                }
+                // Create execution context
+                const contextManager = new ContextManager();
+                const context = contextManager.createContext({
+                    sessionId: `cli-${Date.now()}`,
+                    userId: "cli-user",
+                    aiProvider: "unified-mcp",
+                });
+                const executionOptions = {
+                    preferredSource: argv.source,
+                    fallbackEnabled: !argv["no-fallback"],
+                    validateBeforeExecution: true,
+                    timeoutMs: 30000,
+                };
+                spinner.text = "Executing tool...";
+                const result = await defaultUnifiedRegistry.executeTool(argv.tool, params, context, executionOptions);
+                if (result.success) {
+                    spinner.succeed(chalk.green("✅ Tool executed successfully!"));
+                    console.log(chalk.blue("\n📋 Result:"));
+                    if (result.data) {
+                        console.log(JSON.stringify(result.data, null, 2));
+                    }
+                    else {
+                        console.log("No data returned");
+                    }
+                    if (result.metadata) {
+                        console.log(chalk.gray("\n🔧 Execution Details:"));
+                        console.log(`   Tool: ${result.metadata.toolName}`);
+                        console.log(`   Server: ${result.metadata.serverId || "unknown"}`);
+                        console.log(`   Execution time: ${result.metadata.executionTime}ms`);
+                        console.log(`   Session: ${result.metadata.sessionId}`);
+                    }
+                }
+                else {
+                    spinner.fail(chalk.red("❌ Tool execution failed"));
+                    console.error(chalk.red(`Error: ${result.error}`));
+                    process.exit(1);
+                }
+            }
+            catch (error) {
+                spinner.fail(chalk.red("❌ Execution failed"));
+                console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+                process.exit(1);
+            }
+        })
+            // Configuration management commands
+            .command("config <action>", "Manage unified registry configuration", (y) => y
+            .usage("Usage: $0 mcp config <action> [options]")
+            .command("show", "Show current configuration", {}, async () => {
+            try {
+                await defaultUnifiedRegistry.initialize();
+                const config = defaultUnifiedRegistry.getConfig();
+                console.log(chalk.blue("🔧 Unified Registry Configuration"));
+                console.log(chalk.gray("================================"));
+                console.log(JSON.stringify(config, null, 2));
+            }
+            catch (error) {
+                console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+                process.exit(1);
+            }
+        })
+            .command("enable-auto-discovery", "Enable auto-discovery", {}, async () => {
+            try {
+                await defaultUnifiedRegistry.initialize();
+                defaultUnifiedRegistry.updateAutoDiscoveryConfig({
+                    enabled: true,
+                });
+                console.log(chalk.green("✅ Auto-discovery enabled"));
+            }
+            catch (error) {
+                console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+                process.exit(1);
+            }
+        })
+            .command("disable-auto-discovery", "Disable auto-discovery", {}, async () => {
+            try {
+                await defaultUnifiedRegistry.initialize();
+                defaultUnifiedRegistry.updateAutoDiscoveryConfig({
+                    enabled: false,
+                });
+                console.log(chalk.green("✅ Auto-discovery disabled"));
+            }
+            catch (error) {
+                console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+                process.exit(1);
+            }
+        })
+            .command("set-sources <sources>", "Set preferred auto-discovery sources", (y) => y.positional("sources", {
+            type: "string",
+            description: "Comma-separated source list",
+            demandOption: true,
+        }), async (argv) => {
+            try {
+                await defaultUnifiedRegistry.initialize();
+                const sources = argv.sources
+                    .split(",")
+                    .map((s) => s.trim());
+                defaultUnifiedRegistry.updateAutoDiscoveryConfig({
+                    sources,
+                });
+                console.log(chalk.green(`✅ Updated preferred sources: ${sources.join(", ")}`));
+            }
+            catch (error) {
+                console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+                process.exit(1);
+            }
+        })
+            .command("set-log-level <level>", "Set MCP logging verbosity", (y) => y.positional("level", {
+            type: "string",
+            choices: ["silent", "error", "warn", "info", "debug"],
+            description: "Log level to set",
+            demandOption: true,
+        }), async (argv) => {
+            try {
+                const level = argv.level;
+                const logLevel = level === "silent"
+                    ? LogLevel.SILENT
+                    : level === "error"
+                        ? LogLevel.ERROR
+                        : level === "warn"
+                            ? LogLevel.WARN
+                            : level === "info"
+                                ? LogLevel.INFO
+                                : LogLevel.DEBUG;
+                setGlobalMCPLogLevel(logLevel);
+                console.log(chalk.green(`✅ MCP log level set to: ${level}`));
+                console.log(chalk.gray("This affects auto-discovery, registry operations, and tool execution logging"));
+            }
+            catch (error) {
+                console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+                process.exit(1);
+            }
+        })
+            .example("$0 mcp config show", "Show current configuration")
+            .example("$0 mcp config enable-auto-discovery", "Enable auto-discovery")
+            .example('$0 mcp config set-sources "claude,vscode,cursor"', "Set preferred sources")
+            .example("$0 mcp config set-log-level debug", "Enable debug logging for troubleshooting"))
+            // Discover MCP servers from all AI tools
+            .command(["discover [options]", "d [options]"], "Discover MCP servers from all AI development tools", (y) => y
+            .usage("Usage: $0 mcp discover [options]")
+            .option("format", {
+            alias: "f",
+            type: "string",
+            choices: ["table", "json", "yaml", "summary"],
+            default: "table",
+            description: "Output format",
+        })
+            .option("include-inactive", {
+            type: "boolean",
+            default: true,
+            description: "Include servers that may not be currently active",
+        })
+            .option("preferred-tools", {
+            type: "string",
+            description: "Prioritize specific tools (comma-separated)",
+        })
+            .option("workspace-only", {
+            type: "boolean",
+            description: "Search only workspace/project configurations",
+        })
+            .option("global-only", {
+            type: "boolean",
+            description: "Search only global configurations",
+        })
+            .example("$0 mcp discover", "Discover all MCP servers")
+            .example("$0 mcp d --format json", "Export as JSON (using alias)")
+            .example('$0 mcp discover --preferred-tools "claude,cursor"', "Prioritize specific tools"), async (argv) => {
+            console.log(chalk.blue("🔍 NeuroLink MCP Server Discovery"));
+            console.log(chalk.gray("====================================="));
+            const options = {
+                searchGlobal: !argv["workspace-only"],
+                searchWorkspace: !argv["global-only"],
+                searchCommonPaths: true,
+                includeInactive: argv["include-inactive"],
+                preferredTools: argv["preferred-tools"]
+                    ? argv["preferred-tools"]
+                        .split(",")
+                        .map((t) => t.trim())
+                    : [],
+            };
+            const spinner = ora("Discovering MCP servers...").start();
+            try {
+                mcpLogger.debug("[MCP Discovery] Starting server discovery:", {
+                    searchGlobal: options.searchGlobal,
+                    searchWorkspace: options.searchWorkspace,
+                    includeInactive: options.includeInactive,
+                    preferredTools: options.preferredTools,
+                });
+                const discoveryResult = await discoverMCPServers(options);
+                mcpLogger.info("[MCP Discovery] Discovery completed:", {
+                    serversFound: discoveryResult.discovered.length,
+                    executionTime: discoveryResult.stats.executionTime,
+                    configFilesFound: discoveryResult.stats.configFilesFound,
+                    duplicatesRemoved: discoveryResult.stats.duplicatesRemoved,
+                });
+                spinner.succeed(chalk.green("Discovery completed!"));
+                if (discoveryResult.discovered.length === 0) {
+                    console.log(chalk.yellow("\n📭 No MCP servers found"));
+                    console.log(chalk.gray("\n💡 Tips for finding MCP servers:"));
+                    console.log(chalk.gray("  • Make sure you have Claude Desktop, VS Code, or Cursor with MCP configurations"));
+                    console.log(chalk.gray("  • Check that MCP configuration files exist in their expected locations"));
+                    console.log(chalk.gray("  • Run with 'neurolink mcp discover' to search all locations"));
+                    return;
+                }
+                // Display results based on format
+                if (argv.format === "json") {
+                    console.log(JSON.stringify(discoveryResult, null, 2));
+                    return;
+                }
+                if (argv.format === "yaml") {
+                    // Simple YAML output
+                    console.log("discovered:");
+                    discoveryResult.discovered.forEach((server) => {
+                        console.log(`  - id: ${server.id}`);
+                        console.log(`    title: ${server.title}`);
+                        console.log(`    source: ${server.source.tool}`);
+                        console.log(`    command: ${server.command}`);
+                        if (server.args && server.args.length > 0) {
+                            console.log("    args:");
+                            server.args.forEach((arg) => console.log(`      - ${arg}`));
+                        }
+                    });
+                    return;
+                }
+                if (argv.format === "summary") {
+                    displaySummary(discoveryResult);
+                    return;
+                }
+                // Table format (default)
+                displayTable(discoveryResult);
+                // Display errors if any
+                if (discoveryResult.errors.length > 0) {
+                    console.log(chalk.yellow("\n⚠️  Discovery warnings:"));
+                    discoveryResult.errors.forEach((error) => {
+                        console.log(chalk.yellow(`  • ${error}`));
+                    });
+                }
+            }
+            catch (error) {
+                mcpLogger.error("[MCP Discovery] Discovery failed:", {
+                    error: error instanceof Error ? error.message : String(error),
+                    options,
+                });
+                spinner.fail(chalk.red("Discovery failed"));
+                console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+                process.exit(1);
+            }
+        })
+            .demandCommand(1, "Please specify an MCP subcommand")
+            .example("$0 mcp list", "List configured MCP servers")
+            .example("$0 mcp discover", "Discover MCP servers from all tools")
+            .example("$0 mcp install filesystem", "Install filesystem MCP server")
+            .example("$0 mcp test filesystem", "Test filesystem server connection");
     });
 }