@juspay/neurolink 1.2.4 → 1.3.0

package/dist/cli/commands/mcp.js

@@ -0,0 +1,434 @@
+#!/usr/bin/env node
+/**
+ * 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';
+// Default MCP config file location
+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');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Invalid MCP config file: ${error.message}`);
+    }
+}
+// Save MCP configuration
+function saveMCPConfig(config) {
+    fs.writeFileSync(MCP_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+// Check if MCP server process is running
+async function checkMCPServerStatus(serverConfig) {
+    try {
+        if (serverConfig.transport === 'stdio') {
+            // For stdio servers, we need to actually try connecting
+            const child = spawn(serverConfig.command, serverConfig.args || [], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...process.env, ...serverConfig.env },
+                cwd: serverConfig.cwd
+            });
+            return new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    child.kill();
+                    resolve(false);
+                }, 3000);
+                child.on('spawn', () => {
+                    clearTimeout(timeout);
+                    child.kill();
+                    resolve(true);
+                });
+                child.on('error', () => {
+                    clearTimeout(timeout);
+                    resolve(false);
+                });
+            });
+        }
+        else if (serverConfig.transport === 'sse' && serverConfig.url) {
+            // For SSE servers, check if URL is accessible
+            try {
+                const response = await fetch(serverConfig.url, { method: 'HEAD' });
+                return response.ok;
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+// Connect to MCP server and get capabilities
+async function getMCPServerCapabilities(serverConfig) {
+    if (serverConfig.transport === 'stdio') {
+        // Spawn MCP server and send initialize request
+        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 connecting to MCP server'));
+            }, 5000);
+            let responseData = '';
+            child.stdout?.on('data', (data) => {
+                responseData += data.toString();
+                // Look for JSON-RPC response
+                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.result && response.result.capabilities) {
+                                clearTimeout(timeout);
+                                child.kill();
+                                resolve(response.result);
+                                return;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Continue parsing
+                }
+            });
+            child.on('spawn', () => {
+                // Send initialize request
+                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.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    throw new Error('SSE transport not yet implemented for capabilities');
+}
+// List available tools from MCP server
+async function listMCPServerTools(serverConfig) {
+    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 listing MCP server tools'));
+            }, 5000);
+            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 list tools
+                                initialized = true;
+                                const listToolsRequest = {
+                                    jsonrpc: '2.0',
+                                    id: 2,
+                                    method: 'tools/list',
+                                    params: {}
+                                };
+                                child.stdin?.write(JSON.stringify(listToolsRequest) + '\n');
+                            }
+                            else if (response.id === 2 && response.result.tools) {
+                                clearTimeout(timeout);
+                                child.kill();
+                                resolve(response.result.tools);
+                                return;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Continue parsing
+                }
+            });
+            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.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    throw new Error('SSE transport not yet implemented for tool listing');
+}
+// MCP Commands for yargs
+export function addMCPCommands(yargs) {
+    return yargs.command('mcp <subcommand>', 'Manage MCP (Model Context Protocol) servers', (yargsBuilder) => {
+        yargsBuilder
+            .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) => {
+            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>'));
+                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(`   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')}`);
+                        }
+                        else {
+                            spinner.fail(`${name}: ${chalk.red('❌ Not available')}`);
+                        }
+                    }
+                    catch (error) {
+                        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) => {
+            const config = loadMCPConfig();
+            const serverConfig = {
+                name: argv.name,
+                command: argv.command,
+                args: argv.args || [],
+                transport: argv.transport,
+                url: argv.url,
+                cwd: argv.cwd
+            };
+            if (argv.env) {
+                try {
+                    serverConfig.env = JSON.parse(argv.env);
+                }
+                catch (error) {
+                    console.error(chalk.red('❌ Invalid JSON for environment variables'));
+                    process.exit(1);
+                }
+            }
+            config.mcpServers[argv.name] = serverConfig;
+            saveMCPConfig(config);
+            console.log(chalk.green(`✅ Added MCP server: ${argv.name}`));
+            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) => {
+            const config = loadMCPConfig();
+            if (!config.mcpServers[argv.name]) {
+                console.error(chalk.red(`❌ MCP server '${argv.name}' not found`));
+                process.exit(1);
+            }
+            delete config.mcpServers[argv.name];
+            saveMCPConfig(config);
+            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) => {
+            const config = loadMCPConfig();
+            const serverConfig = config.mcpServers[argv.name];
+            if (!serverConfig) {
+                console.error(chalk.red(`❌ MCP server '${argv.name}' not found`));
+                process.exit(1);
+            }
+            console.log(chalk.blue(`🔍 Testing MCP server: ${argv.name}\n`));
+            const spinner = ora('Connecting...').start();
+            try {
+                // Test basic connectivity
+                const isRunning = await checkMCPServerStatus(serverConfig);
+                if (!isRunning) {
+                    spinner.fail(chalk.red('❌ Server not available'));
+                    return;
+                }
+                spinner.text = 'Getting capabilities...';
+                const capabilities = await getMCPServerCapabilities(serverConfig);
+                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'}`);
+                if (capabilities.capabilities.tools) {
+                    console.log(`   Tools: ✅ Supported`);
+                }
+                if (capabilities.capabilities.resources) {
+                    console.log(`   Resources: ✅ Supported`);
+                }
+                console.log(chalk.blue('\n🛠️  Available Tools:'));
+                if (tools.length === 0) {
+                    console.log('   No tools available');
+                }
+                else {
+                    tools.forEach((tool) => {
+                        console.log(`   • ${tool.name}: ${tool.description || 'No description'}`);
+                    });
+                }
+            }
+            catch (error) {
+                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) => {
+            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'
+                },
+                github: {
+                    name: 'github',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-github'],
+                    transport: 'stdio'
+                },
+                postgres: {
+                    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'
+                },
+                puppeteer: {
+                    name: 'puppeteer',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-puppeteer'],
+                    transport: 'stdio'
+                }
+            };
+            const serverConfig = serverConfigs[serverName];
+            if (!serverConfig) {
+                console.error(chalk.red(`❌ Unknown server: ${serverName}`));
+                process.exit(1);
+            }
+            console.log(chalk.blue(`📦 Installing MCP server: ${serverName}`));
+            config.mcpServers[serverName] = serverConfig;
+            saveMCPConfig(config);
+            console.log(chalk.green(`✅ Installed MCP server: ${serverName}`));
+            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) => {
+            const config = loadMCPConfig();
+            const serverConfig = config.mcpServers[argv.server];
+            if (!serverConfig) {
+                console.error(chalk.red(`❌ MCP server '${argv.server}' not found`));
+                process.exit(1);
+            }
+            let params = {};
+            if (argv.params) {
+                try {
+                    params = JSON.parse(argv.params);
+                }
+                catch (error) {
+                    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');
+    });
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * NeuroLink CLI - Enhanced Simplified Approach
+ *
+ * Professional CLI experience with minimal maintenance overhead.
+ * Features: Spinners, colors, batch processing, provider testing, rich help
+ * Implementation: ~300 lines using simple JS utility functions
+ */
+export {};

package/dist/cli/index.js

@@ -14,6 +14,7 @@ import chalk from 'chalk';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
+import { addMCPCommands } from './commands/mcp.js';
 // Load environment variables from .env file
 try {
     // Try to import and configure dotenv
@@ -98,6 +99,8 @@ function handleError(error, context) {
         console.error(chalk.yellow('💡 Set API key: export OPENAI_API_KEY=sk-...'));
         console.error(chalk.yellow('💡 Or set AWS credentials & region: export AWS_ACCESS_KEY_ID=... AWS_SECRET_ACCESS_KEY=... AWS_REGION=us-east-1'));
         console.error(chalk.yellow('💡 Or set Google credentials: export GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json'));
+        console.error(chalk.yellow('💡 Or set Anthropic API key: export ANTHROPIC_API_KEY=sk-ant-...'));
+        console.error(chalk.yellow('💡 Or set Azure OpenAI credentials: export AZURE_OPENAI_API_KEY=... AZURE_OPENAI_ENDPOINT=...'));
     }
     if (error.message.toLowerCase().includes('rate limit')) {
         console.error(chalk.yellow('💡 Try again in a few moments or use --provider vertex'));
@@ -564,6 +567,8 @@ const cli = yargs(args)
     }
 })
     .completion('completion', 'Generate shell completion script');
+// Add MCP commands
+addMCPCommands(cli);
 // Use an async IIFE to allow top-level await for parseAsync
 (async () => {
     try {

package/dist/mcp/context-manager.d.ts

@@ -0,0 +1,164 @@
+/**
+ * NeuroLink MCP Context Management System
+ * Unified context creation and management for all tool executions
+ * Ensures rich context flows through tool chain with session tracking
+ */
+import type { NeuroLinkExecutionContext } from './factory.js';
+/**
+ * Context creation request interface
+ */
+export interface ContextRequest {
+    sessionId?: string;
+    userId?: string;
+    aiProvider?: string;
+    modelId?: string;
+    temperature?: number;
+    maxTokens?: number;
+    organizationId?: string;
+    projectId?: string;
+    environmentType?: 'development' | 'staging' | 'production';
+    frameworkType?: 'react' | 'vue' | 'svelte' | 'next' | 'nuxt' | 'sveltekit';
+    permissions?: string[];
+    securityLevel?: 'public' | 'private' | 'organization';
+    [key: string]: any;
+}
+/**
+ * Context manager for creating and managing execution contexts
+ * Provides rich context for all tool executions with session tracking
+ */
+export declare class ContextManager {
+    private sessionCounter;
+    private activeContexts;
+    /**
+     * Create a new execution context with rich information
+     *
+     * @param request Context creation request with optional fields
+     * @returns Complete execution context ready for tool chain
+     */
+    createContext(request?: ContextRequest): NeuroLinkExecutionContext;
+    /**
+     * Add a tool to the execution chain
+     *
+     * @param context Execution context to modify
+     * @param toolName Name of the tool being executed
+     */
+    addToToolChain(context: NeuroLinkExecutionContext, toolName: string): void;
+    /**
+     * Get the current tool chain for a context
+     *
+     * @param context Execution context
+     * @returns Array of tool names in execution order
+     */
+    getToolChain(context: NeuroLinkExecutionContext): string[];
+    /**
+     * Set parent tool for nested tool execution
+     *
+     * @param context Execution context to modify
+     * @param parentToolId ID of the parent tool
+     */
+    setParentTool(context: NeuroLinkExecutionContext, parentToolId: string): void;
+    /**
+     * Create child context for nested tool execution
+     *
+     * @param parentContext Parent execution context
+     * @param childToolName Name of the child tool
+     * @returns New child context with inherited properties
+     */
+    createChildContext(parentContext: NeuroLinkExecutionContext, childToolName: string): NeuroLinkExecutionContext;
+    /**
+     * Get context by session ID
+     *
+     * @param sessionId Session identifier
+     * @returns Execution context or undefined if not found
+     */
+    getContext(sessionId: string): NeuroLinkExecutionContext | undefined;
+    /**
+     * Update context with new information
+     *
+     * @param sessionId Session identifier
+     * @param updates Partial context updates
+     */
+    updateContext(sessionId: string, updates: Partial<NeuroLinkExecutionContext>): void;
+    /**
+     * Remove context from active tracking
+     *
+     * @param sessionId Session identifier
+     */
+    removeContext(sessionId: string): void;
+    /**
+     * Get all active contexts (for debugging/monitoring)
+     *
+     * @returns Array of all active contexts
+     */
+    getActiveContexts(): NeuroLinkExecutionContext[];
+    /**
+     * Clear all active contexts
+     */
+    clearAllContexts(): void;
+    /**
+     * Get context statistics
+     *
+     * @returns Context usage statistics
+     */
+    getStats(): {
+        activeContexts: number;
+        totalSessionsCreated: number;
+        averageToolChainLength: number;
+    };
+    /**
+     * Generate unique session ID
+     *
+     * @returns Unique session identifier
+     */
+    private generateSessionId;
+    /**
+     * Extract custom fields from request (excluding known fields)
+     *
+     * @param request Context creation request
+     * @returns Custom fields object
+     */
+    private extractCustomFields;
+}
+/**
+ * Default context manager instance
+ * Can be used across the application for consistent context management
+ */
+export declare const defaultContextManager: ContextManager;
+/**
+ * Utility function to create context with defaults
+ *
+ * @param request Optional context request
+ * @returns Execution context with sensible defaults
+ */
+export declare function createExecutionContext(request?: ContextRequest): NeuroLinkExecutionContext;
+/**
+ * Utility function to add tool to default context manager
+ *
+ * @param context Execution context
+ * @param toolName Tool name to add
+ */
+export declare function addToolToChain(context: NeuroLinkExecutionContext, toolName: string): void;
+/**
+ * Context validation utilities
+ */
+export declare class ContextValidator {
+    /**
+     * Validate context has required fields for tool execution
+     *
+     * @param context Execution context to validate
+     * @returns Validation result with details
+     */
+    static validateContext(context: NeuroLinkExecutionContext): {
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+    /**
+     * Validate context permissions for tool execution
+     *
+     * @param context Execution context
+     * @param requiredPermissions Permissions required by tool
+     * @returns Whether context has required permissions
+     */
+    static hasPermissions(context: NeuroLinkExecutionContext, requiredPermissions: string[]): boolean;
+}