@juspay/neurolink 7.6.1 → 7.7.1

package/dist/cli/commands/mcp.js

@@ -705,31 +705,63 @@ export class MCPCommandFactory {
                 }
                 process.exit(1);
             }
-            // Execute the tool (This would need actual MCP execution logic)
-            // For now, showing a placeholder implementation
-            const result = {
-                tool: toolName,
-                server: serverName,
-                params,
-                result: "Tool execution not yet implemented in NeuroLink SDK",
-                timestamp: new Date().toISOString(),
-            };
-            if (spinner) {
-                spinner.succeed(chalk.green("✅ Tool executed successfully"));
-            }
-            // Display results
-            if (argv.format === "json") {
-                logger.always(JSON.stringify(result, null, 2));
+            // Execute the tool using the NeuroLink MCP tool registry
+            try {
+                const { toolRegistry } = await import("../../lib/mcp/toolRegistry.js");
+                const executionResult = await toolRegistry.executeTool(toolName, params, {
+                    sessionId: `cli-${Date.now()}`,
+                    userId: process.env.USER || "cli-user",
+                    config: {
+                        domainType: "cli-execution",
+                        customData: { serverName },
+                    },
+                });
+                const result = {
+                    tool: toolName,
+                    server: serverName,
+                    params,
+                    result: executionResult,
+                    success: true,
+                    timestamp: new Date().toISOString(),
+                };
+                if (spinner) {
+                    spinner.succeed(chalk.green("✅ Tool executed successfully"));
+                }
+                // Display results
+                if (argv.format === "json") {
+                    logger.always(JSON.stringify(result, null, 2));
+                }
+                else {
+                    logger.always(chalk.green("🔧 Tool Execution Results:"));
+                    logger.always(`   Tool: ${chalk.cyan(toolName)}`);
+                    logger.always(`   Server: ${chalk.cyan(serverName)}`);
+                    logger.always(`   Result: ${JSON.stringify(executionResult, null, 2)}`);
+                    logger.always(`   Timestamp: ${result.timestamp}`);
+                }
             }
-            else {
-                logger.always(chalk.bold("\n🛠️  Tool Execution Result:\n"));
-                logger.always(`Tool: ${toolName}`);
-                logger.always(`Server: ${serverName}`);
-                if (Object.keys(params).length > 0) {
-                    logger.always(`Params: ${JSON.stringify(params)}`);
+            catch (toolError) {
+                const errorMessage = toolError instanceof Error ? toolError.message : String(toolError);
+                if (spinner) {
+                    spinner.fail(chalk.red("❌ Tool execution failed"));
                 }
-                logger.always(`Result: ${result.result}`);
-                logger.always(`Time: ${result.timestamp}`);
+                const result = {
+                    tool: toolName,
+                    server: serverName,
+                    params,
+                    error: errorMessage,
+                    success: false,
+                    timestamp: new Date().toISOString(),
+                };
+                if (argv.format === "json") {
+                    logger.always(JSON.stringify(result, null, 2));
+                }
+                else {
+                    logger.error(chalk.red("🔧 Tool Execution Failed:"));
+                    logger.error(`   Tool: ${chalk.cyan(toolName)}`);
+                    logger.error(`   Server: ${chalk.cyan(serverName)}`);
+                    logger.error(`   Error: ${chalk.red(errorMessage)}`);
+                }
+                process.exit(1);
             }
         }
         catch (error) {
@@ -760,11 +792,28 @@ export class MCPCommandFactory {
             const spinner = argv.quiet
                 ? null
                 : ora(`Removing MCP server: ${serverName}...`).start();
-            // Remove server (This would need actual removal logic in NeuroLink SDK)
-            // For now, showing a placeholder
-            logger.always(chalk.yellow("⚠️  Server removal not yet implemented in NeuroLink SDK"));
-            if (spinner) {
-                spinner.succeed(chalk.green(`✅ Server ${serverName} removed successfully`));
+            // Remove server using the NeuroLink MCP tool registry
+            try {
+                const { toolRegistry } = await import("../../lib/mcp/toolRegistry.js");
+                const removed = toolRegistry.unregisterServer(serverName);
+                if (!removed) {
+                    throw new Error(`Failed to remove server ${serverName} from registry`);
+                }
+                if (spinner) {
+                    spinner.succeed(chalk.green(`✅ Server ${serverName} removed successfully`));
+                }
+                logger.always(chalk.green(`🗑️  Successfully removed MCP server: ${serverName}`));
+                logger.always(chalk.gray("   All associated tools have been unregistered"));
+            }
+            catch (removalError) {
+                const errorMessage = removalError instanceof Error
+                    ? removalError.message
+                    : String(removalError);
+                if (spinner) {
+                    spinner.fail(chalk.red(`❌ Failed to remove server ${serverName}`));
+                }
+                logger.error(chalk.red(`❌ Server removal failed: ${errorMessage}`));
+                process.exit(1);
             }
         }
         catch (error) {

package/dist/cli/factories/commandFactory.js

@@ -93,6 +93,22 @@ export class CLICommandFactory {
             default: false,
             description: "Enable AI response quality evaluation",
         },
+        domain: {
+            type: "string",
+            choices: [
+                "healthcare",
+                "finance",
+                "analytics",
+                "ecommerce",
+                "education",
+                "legal",
+                "technology",
+                "generic",
+                "auto",
+            ],
+            description: "Domain type for specialized processing and optimization",
+            alias: "d",
+        },
         evaluationDomain: {
             type: "string",
             description: "Domain expertise for evaluation (e.g., 'AI coding assistant', 'Customer service expert')",
@@ -101,10 +117,10 @@ export class CLICommandFactory {
             type: "string",
             description: "Tool usage context for evaluation (e.g., 'Used sales-data MCP tools')",
         },
-        lighthouseStyle: {
+        domainAware: {
             type: "boolean",
             default: false,
-            description: "Use Lighthouse-compatible domain-aware evaluation",
+            description: "Use domain-aware evaluation",
         },
         context: {
             type: "string",
@@ -132,6 +148,11 @@ export class CLICommandFactory {
             type: "string",
             description: "Path to custom configuration file",
         },
+        dryRun: {
+            type: "boolean",
+            default: false,
+            description: "Test command without making actual API calls (for testing)",
+        },
     };
     // Helper method to build options for commands
     static buildOptions(yargs, additionalOptions = {}) {
@@ -193,9 +214,10 @@ export class CLICommandFactory {
             disableTools: argv.disableTools,
             enableAnalytics: argv.enableAnalytics,
             enableEvaluation: argv.enableEvaluation,
+            domain: argv.domain,
             evaluationDomain: argv.evaluationDomain,
             toolUsageContext: argv.toolUsageContext,
-            lighthouseStyle: argv.lighthouseStyle,
+            domainAware: argv.domainAware,
             context: processedContext,
             contextConfig,
             debug: argv.debug,
@@ -205,6 +227,7 @@ export class CLICommandFactory {
             delay: argv.delay,
             noColor: argv.noColor,
             configFile: argv.configFile,
+            dryRun: argv.dryRun,
         };
     }
     // Helper method to handle output
@@ -494,6 +517,53 @@ export class CLICommandFactory {
             ? null
             : ora("🔍 Checking AI provider status...\n").start();
         try {
+            // Handle dry-run mode for provider status
+            if (argv.dryRun) {
+                const mockResults = [
+                    {
+                        provider: "google-ai",
+                        status: "working",
+                        configured: true,
+                        responseTime: 150,
+                        model: "gemini-2.5-flash",
+                    },
+                    {
+                        provider: "openai",
+                        status: "working",
+                        configured: true,
+                        responseTime: 200,
+                        model: "gpt-4o-mini",
+                    },
+                    {
+                        provider: "anthropic",
+                        status: "working",
+                        configured: true,
+                        responseTime: 180,
+                        model: "claude-3-haiku",
+                    },
+                    { provider: "bedrock", status: "not configured", configured: false },
+                    { provider: "vertex", status: "not configured", configured: false },
+                ];
+                if (spinner) {
+                    spinner.succeed("Provider check complete (dry-run): 3/3 providers working");
+                }
+                // Display mock results
+                for (const result of mockResults) {
+                    const status = result.status === "working"
+                        ? chalk.green("✅ Working")
+                        : result.status === "failed"
+                            ? chalk.red("❌ Failed")
+                            : chalk.gray("⚪ Not configured");
+                    const time = result.responseTime ? ` (${result.responseTime}ms)` : "";
+                    const model = result.model ? ` [${result.model}]` : "";
+                    logger.always(`${result.provider}: ${status}${time}${model}`);
+                }
+                if (argv.verbose && !argv.quiet) {
+                    logger.always(chalk.blue("\n📋 Detailed Results (Dry-run):"));
+                    logger.always(JSON.stringify(mockResults, null, 2));
+                }
+                return;
+            }
             // Use SDK's provider diagnostic method instead of manual testing
             const sdk = new NeuroLink();
             const results = await sdk.getProviderStatus({ quiet: !!argv.quiet });
@@ -578,6 +648,55 @@ export class CLICommandFactory {
                     });
                 }
             }
+            // Handle dry-run mode for testing
+            if (options.dryRun) {
+                const mockResult = {
+                    content: "Mock response for testing purposes",
+                    provider: options.provider || "auto",
+                    model: options.model || "test-model",
+                    usage: {
+                        inputTokens: 10,
+                        outputTokens: 15,
+                        totalTokens: 25,
+                    },
+                    responseTime: 150,
+                    analytics: options.enableAnalytics
+                        ? {
+                            provider: options.provider || "auto",
+                            model: options.model || "test-model",
+                            tokens: { input: 10, output: 15, total: 25 },
+                            cost: 0.00025,
+                            responseTime: 150,
+                            context: contextMetadata,
+                        }
+                        : undefined,
+                    evaluation: options.enableEvaluation
+                        ? {
+                            relevance: 8,
+                            accuracy: 9,
+                            completeness: 8,
+                            overall: 8.3,
+                            isOffTopic: false,
+                            alertSeverity: "none",
+                            reasoning: "Test evaluation response",
+                            evaluationModel: "test-evaluator",
+                            evaluationTime: 50,
+                        }
+                        : undefined,
+                };
+                if (spinner) {
+                    spinner.succeed(chalk.green("✅ Dry-run completed successfully!"));
+                }
+                this.handleOutput(mockResult, options);
+                if (options.debug) {
+                    logger.debug("\n" + chalk.yellow("Debug Information (Dry-run):"));
+                    logger.debug("Provider:", mockResult.provider);
+                    logger.debug("Model:", mockResult.model);
+                    logger.debug("Mode: DRY-RUN (no actual API calls made)");
+                }
+                process.exit(0);
+                return;
+            }
             const sdk = new NeuroLink();
             const result = await sdk.generate({
                 input: { text: inputText },
@@ -593,6 +712,13 @@ export class CLICommandFactory {
                 evaluationDomain: options.evaluationDomain,
                 toolUsageContext: options.toolUsageContext,
                 context: contextMetadata,
+                factoryConfig: options.domain
+                    ? {
+                        domainType: options.domain,
+                        enhancementType: "domain-configuration",
+                        validateDomainData: true,
+                    }
+                    : undefined,
             });
             if (spinner) {
                 spinner.succeed(chalk.green("✅ Text generated successfully!"));
@@ -674,6 +800,76 @@ export class CLICommandFactory {
                     });
                 }
             }
+            // Handle dry-run mode for testing
+            if (options.dryRun) {
+                if (!options.quiet) {
+                    logger.always(chalk.blue("🔄 Dry-run streaming..."));
+                }
+                // Simulate streaming output
+                const chunks = [
+                    "Mock ",
+                    "streaming ",
+                    "response ",
+                    "for ",
+                    "testing ",
+                    "purposes",
+                ];
+                let fullContent = "";
+                for (const chunk of chunks) {
+                    process.stdout.write(chunk);
+                    fullContent += chunk;
+                    await new Promise((resolve) => setTimeout(resolve, 50)); // Simulate streaming delay
+                }
+                if (!options.quiet) {
+                    process.stdout.write("\n");
+                }
+                // Mock analytics and evaluation for dry-run
+                if (options.enableAnalytics) {
+                    const mockAnalytics = {
+                        provider: options.provider || "auto",
+                        model: options.model || "test-model",
+                        requestDuration: 300,
+                        tokenUsage: {
+                            inputTokens: 10,
+                            outputTokens: 15,
+                            totalTokens: 25,
+                        },
+                        timestamp: Date.now(),
+                        context: contextMetadata,
+                    };
+                    const mockGenerateResult = {
+                        success: true,
+                        content: fullContent,
+                        analytics: mockAnalytics,
+                        model: mockAnalytics.model,
+                        toolsUsed: [],
+                    };
+                    const analyticsDisplay = this.formatAnalyticsForTextMode(mockGenerateResult);
+                    logger.always(analyticsDisplay);
+                }
+                if (options.enableEvaluation) {
+                    logger.always(chalk.blue("\n📊 Response Evaluation (Dry-run):"));
+                    logger.always(`   Relevance: 8/10`);
+                    logger.always(`   Accuracy: 9/10`);
+                    logger.always(`   Completeness: 8/10`);
+                    logger.always(`   Overall: 8.3/10`);
+                    logger.always(`   Reasoning: Test evaluation response`);
+                }
+                if (options.output) {
+                    fs.writeFileSync(options.output, fullContent);
+                    if (!options.quiet) {
+                        logger.always(`\nOutput saved to ${options.output}`);
+                    }
+                }
+                if (options.debug) {
+                    logger.debug("\n" + chalk.yellow("Debug Information (Dry-run Streaming):"));
+                    logger.debug("Provider:", options.provider || "auto");
+                    logger.debug("Model:", options.model || "test-model");
+                    logger.debug("Mode: DRY-RUN (no actual API calls made)");
+                }
+                process.exit(0);
+                return;
+            }
             const sdk = new NeuroLink();
             const stream = await sdk.stream({
                 input: { text: inputText },
@@ -687,6 +883,13 @@ export class CLICommandFactory {
                 enableAnalytics: options.enableAnalytics,
                 enableEvaluation: options.enableEvaluation,
                 context: contextMetadata,
+                factoryConfig: options.domain
+                    ? {
+                        domainType: options.domain,
+                        enhancementType: "domain-configuration",
+                        validateDomainData: true,
+                    }
+                    : undefined,
             });
             let fullContent = "";
             // Process the stream
@@ -803,6 +1006,17 @@ export class CLICommandFactory {
                     spinner.text = `Processing ${i + 1}/${prompts.length}: ${prompts[i].substring(0, 30)}...`;
                 }
                 try {
+                    // Handle dry-run mode for batch processing
+                    if (options.dryRun) {
+                        results.push({
+                            prompt: prompts[i],
+                            response: `Mock batch response ${i + 1} for testing purposes`,
+                        });
+                        if (spinner) {
+                            spinner.render();
+                        }
+                        continue;
+                    }
                     // Process context for each batch item
                     let inputText = prompts[i];
                     let contextMetadata;
@@ -830,6 +1044,13 @@ export class CLICommandFactory {
                         enableAnalytics: options.enableAnalytics,
                         enableEvaluation: options.enableEvaluation,
                         context: contextMetadata,
+                        factoryConfig: options.domain
+                            ? {
+                                domainType: options.domain,
+                                enhancementType: "domain-configuration",
+                                validateDomainData: true,
+                            }
+                            : undefined,
                     });
                     results.push({ prompt: prompts[i], response: result.content });
                     if (spinner) {
@@ -927,8 +1148,140 @@ export class CLICommandFactory {
      * Execute completion command
      */
     static async executeCompletion(argv) {
-        // This would need to be implemented with the actual CLI instance
-        logger.always("# Completion script would be generated here");
-        logger.always("# This requires access to the yargs CLI instance");
+        try {
+            // Generate shell completion script as concatenated strings to avoid template literal issues
+            const completionScript = "#!/usr/bin/env bash\n\n" +
+                "# NeuroLink CLI Bash Completion Script\n" +
+                "# Generated by: neurolink completion\n" +
+                "# \n" +
+                "# Installation instructions:\n" +
+                "#   1. Save this script to a file (e.g., ~/.neurolink-completion.sh)\n" +
+                "#   2. Add to your shell profile: source ~/.neurolink-completion.sh\n" +
+                "#   3. Restart your shell or run: source ~/.bashrc\n\n" +
+                "_neurolink_completion() {\n" +
+                "    local cur prev opts base\n" +
+                "    COMPREPLY=()\n" +
+                '    cur="${COMP_WORDS[COMP_CWORD]}"\n' +
+                '    prev="${COMP_WORDS[COMP_CWORD - 1]}"\n\n' +
+                "    # Main commands\n" +
+                "    if [[ ${COMP_CWORD} -eq 1 ]]; then\n" +
+                '        opts="generate gen stream batch provider status models mcp discover config get-best-provider completion"\n' +
+                '        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )\n' +
+                "        return 0\n" +
+                "    fi\n\n" +
+                "    # Subcommand completion\n" +
+                '    case "${COMP_WORDS[1]}" in\n' +
+                "        generate|gen)\n" +
+                '            case "${prev}" in\n' +
+                "                --provider|-p)\n" +
+                '                    COMPREPLY=( $(compgen -W "auto openai bedrock vertex googleVertex anthropic azure google-ai huggingface ollama mistral litellm" -- ${cur}) )\n' +
+                "                    return 0\n" +
+                "                    ;;\n" +
+                "                --format|-f|--output-format)\n" +
+                '                    COMPREPLY=( $(compgen -W "text json table" -- ${cur}) )\n' +
+                "                    return 0\n" +
+                "                    ;;\n" +
+                "                --model|-m)\n" +
+                '                    COMPREPLY=( $(compgen -W "gemini-2.5-pro gemini-2.5-flash gpt-4o gpt-4o-mini claude-3-5-sonnet" -- ${cur}) )\n' +
+                "                    return 0\n" +
+                "                    ;;\n" +
+                "                *)\n" +
+                '                    opts="--provider --model --temperature --maxTokens --system --format --output --timeout --delay --disableTools --enableAnalytics --enableEvaluation --debug --quiet --noColor --configFile --dryRun"\n' +
+                '                    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )\n' +
+                "                    return 0\n" +
+                "                    ;;\n" +
+                "            esac\n" +
+                "            ;;\n" +
+                "        mcp)\n" +
+                '            case "${COMP_WORDS[2]}" in\n' +
+                "                install)\n" +
+                "                    if [[ ${COMP_CWORD} -eq 3 ]]; then\n" +
+                '                        COMPREPLY=( $(compgen -W "filesystem github postgres sqlite brave puppeteer git memory bitbucket" -- ${cur}) )\n' +
+                "                        return 0\n" +
+                "                    fi\n" +
+                "                    ;;\n" +
+                "                *)\n" +
+                "                    if [[ ${COMP_CWORD} -eq 2 ]]; then\n" +
+                '                        opts="list install add test exec remove"\n' +
+                '                        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )\n' +
+                "                        return 0\n" +
+                "                    fi\n" +
+                "                    ;;\n" +
+                "            esac\n" +
+                "            ;;\n" +
+                "        provider)\n" +
+                "            if [[ ${COMP_CWORD} -eq 2 ]]; then\n" +
+                '                COMPREPLY=( $(compgen -W "status" -- ${cur}) )\n' +
+                "                return 0\n" +
+                "            fi\n" +
+                "            ;;\n" +
+                "        models)\n" +
+                "            if [[ ${COMP_CWORD} -eq 2 ]]; then\n" +
+                '                COMPREPLY=( $(compgen -W "list test" -- ${cur}) )\n' +
+                "                return 0\n" +
+                "            fi\n" +
+                "            ;;\n" +
+                "        config)\n" +
+                "            if [[ ${COMP_CWORD} -eq 2 ]]; then\n" +
+                '                COMPREPLY=( $(compgen -W "init show validate reset export" -- ${cur}) )\n' +
+                "                return 0\n" +
+                "            fi\n" +
+                "            ;;\n" +
+                "        *)\n" +
+                "            # Global options for all commands\n" +
+                '            opts="--help --version --debug --quiet --noColor --configFile"\n' +
+                '            COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )\n' +
+                "            return 0\n" +
+                "            ;;\n" +
+                "    esac\n\n" +
+                "    # File completion for certain options\n" +
+                '    case "${prev}" in\n' +
+                "        --output|-o|--configFile)\n" +
+                "            COMPREPLY=( $(compgen -f -- ${cur}) )\n" +
+                "            return 0\n" +
+                "            ;;\n" +
+                "        batch)\n" +
+                "            COMPREPLY=( $(compgen -f -- ${cur}) )\n" +
+                "            return 0\n" +
+                "            ;;\n" +
+                "    esac\n\n" +
+                "    return 0\n" +
+                "}\n\n" +
+                "# Register the completion function\n" +
+                "complete -F _neurolink_completion neurolink\n\n" +
+                "# Zsh completion (if running zsh)\n" +
+                'if [[ -n "${ZSH_VERSION}" ]]; then\n' +
+                "    autoload -U +X bashcompinit && bashcompinit\n" +
+                "    complete -F _neurolink_completion neurolink\n" +
+                "fi\n\n" +
+                'echo "NeuroLink CLI completion script loaded successfully!"\n' +
+                'echo "Available commands: generate, stream, batch, provider, status, models, mcp, discover, config, get-best-provider, completion"';
+            // Handle output options
+            if (argv.output) {
+                const fs = await import("fs");
+                fs.writeFileSync(argv.output, completionScript);
+                if (!argv.quiet) {
+                    logger.always(`✅ Completion script saved to ${argv.output}`);
+                    logger.always(`💡 Run: source ${argv.output}`);
+                }
+            }
+            else {
+                logger.always(completionScript);
+            }
+            if (!argv.quiet) {
+                logger.always(chalk.blue("\n📋 Installation Instructions:"));
+                logger.always("1. Save the output to a file:");
+                logger.always("   neurolink completion > ~/.neurolink-completion.sh");
+                logger.always("2. Add to your shell profile:");
+                logger.always("   echo 'source ~/.neurolink-completion.sh' >> ~/.bashrc");
+                logger.always("3. Restart your shell or run:");
+                logger.always("   source ~/.bashrc");
+                logger.always(chalk.green("\n🎉 Then enjoy tab completion for NeuroLink commands!"));
+            }
+        }
+        catch (error) {
+            logger.error(chalk.red(`❌ Completion generation failed: ${error.message}`));
+            process.exit(1);
+        }
     }
 }

package/dist/core/analytics.js

@@ -5,6 +5,7 @@
  * including tokens, costs, performance metrics, and custom context.
  */
 import { logger } from "../utils/logger.js";
+import { modelConfig } from "./modelConfiguration.js";
 /**
  * Create analytics data structure from AI response
  */
@@ -89,35 +90,14 @@ function extractTokenUsage(result) {
  */
 function estimateCost(provider, model, tokens) {
     try {
-        // Cost per 1K tokens (USD) - approximate rates as of 2024
-        const costMap = {
-            openai: {
-                "gpt-4": { input: 0.03, output: 0.06 },
-                "gpt-4-turbo": { input: 0.01, output: 0.03 },
-                "gpt-3.5-turbo": { input: 0.0015, output: 0.002 },
-            },
-            anthropic: {
-                "claude-3-opus": { input: 0.015, output: 0.075 },
-                "claude-3-sonnet": { input: 0.003, output: 0.015 },
-                "claude-3-haiku": { input: 0.00025, output: 0.00125 },
-            },
-            "google-ai": {
-                "gemini-pro": { input: 0.00035, output: 0.00105 },
-                "gemini-2.5-flash": { input: 0.000075, output: 0.0003 },
-            },
-        };
-        const providerCosts = costMap[provider.toLowerCase()];
-        if (!providerCosts) {
-            return undefined;
-        }
-        // Find best matching model
-        const modelKey = Object.keys(providerCosts).find((key) => model.toLowerCase().includes(key) || key.includes(model.toLowerCase()));
-        if (!modelKey) {
+        // Use the new configuration system instead of hardcoded costs
+        const costInfo = modelConfig.getCostInfo(provider.toLowerCase(), model);
+        if (!costInfo) {
             return undefined;
         }
-        const rates = providerCosts[modelKey];
-        const inputCost = (tokens.input / 1000) * rates.input;
-        const outputCost = (tokens.output / 1000) * rates.output;
+        // Calculate cost using the configuration system
+        const inputCost = (tokens.input / 1000) * costInfo.input;
+        const outputCost = (tokens.output / 1000) * costInfo.output;
         return Math.round((inputCost + outputCost) * 100000) / 100000; // Round to 5 decimal places
     }
     catch (error) {