@juspay/neurolink 3.0.0 → 4.0.0

package/dist/cli/index.js

@@ -1,4 +1,11 @@
 #!/usr/bin/env node
+// CRITICAL: Set MCP logging level before ANY imports
+if (!process.argv.includes("--debug")) {
+    process.env.MCP_LOG_LEVEL = "error"; // Only show MCP errors unless debugging
+}
+else {
+    process.env.MCP_LOG_LEVEL = "info"; // Show MCP logs when debugging
+}
 /**
  * NeuroLink CLI - Enhanced Simplified Approach
  *
@@ -16,6 +23,84 @@ import { addMCPCommands } from "./commands/mcp.js";
 import { addOllamaCommands } from "./commands/ollama.js";
 import { agentGenerateCommand } from "./commands/agent-generate.js";
 import { AgentEnhancedProvider } from "../lib/providers/agent-enhanced-provider.js";
+import { logger } from "../lib/utils/logger.js";
+/**
+ * Helper functions for displaying analytics and evaluation results
+ * Addresses DRY principle - extracted shared parts into reusable functions
+ */
+function displayDebugInfo(title, data, debug) {
+    if (debug) {
+        console.log(chalk.blue(title));
+        console.log(JSON.stringify(data, null, 2));
+        console.log();
+    }
+}
+function displayMissingDataWarning(type) {
+    console.log();
+    console.log(chalk.red(`⚠️  ${type} enabled but no data received`));
+    console.log();
+}
+function formatAnalytics(analytics) {
+    console.log();
+    console.log(chalk.blue("📊 Analytics:"));
+    console.log(`   🚀 Provider: ${analytics.provider}`);
+    console.log(`   🤖 Model: ${analytics.model}`);
+    if (analytics.tokens) {
+        console.log(`   💬 Tokens: ${analytics.tokens.totalTokens || analytics.tokens.total || "unknown"}`);
+    }
+    console.log(`   ⏱️  Response Time: ${analytics.responseTime}ms`);
+    if (analytics.context) {
+        console.log(`   📋 Context: ${Object.keys(analytics.context).length} fields`);
+    }
+    console.log();
+}
+function formatEvaluation(evaluation) {
+    console.log();
+    console.log(chalk.blue("⭐ Response Quality Evaluation:"));
+    console.log(`   📊 Scores: Relevance ${evaluation.relevanceScore || evaluation.relevance}/10, Accuracy ${evaluation.accuracyScore || evaluation.accuracy}/10, Completeness ${evaluation.completenessScore || evaluation.completeness}/10`);
+    console.log(`   🎯 Overall Quality: ${evaluation.overall}/10`);
+    const severity = evaluation.alertSeverity || "none";
+    const severityColors = {
+        high: chalk.red,
+        medium: chalk.yellow,
+        low: chalk.blue,
+        none: chalk.green,
+    };
+    const severityColor = severityColors[severity] || chalk.gray;
+    console.log(`   🚨 Alert Level: ${severityColor(severity)}`);
+    if (evaluation.reasoning) {
+        console.log(`   💭 Analysis: ${evaluation.reasoning}`);
+    }
+    if (evaluation.suggestedImprovements) {
+        console.log(`   💡 Improvements: ${evaluation.suggestedImprovements}`);
+    }
+    const evalModel = evaluation.evaluationModel || "unknown";
+    const evalTime = evaluation.evaluationTime
+        ? `${evaluation.evaluationTime}ms`
+        : "unknown";
+    console.log(`   🤖 Evaluated by: ${evalModel} (${evalTime})`);
+    console.log();
+}
+function displayAnalyticsAndEvaluation(result, argv) {
+    if (result && result.analytics) {
+        displayDebugInfo("📊 Analytics:", result.analytics, argv.debug);
+        if (!argv.debug) {
+            formatAnalytics(result.analytics);
+        }
+    }
+    else if (argv.enableAnalytics) {
+        displayMissingDataWarning("Analytics");
+    }
+    if (result && result.evaluation) {
+        displayDebugInfo("⭐ Response Evaluation:", result.evaluation, argv.debug);
+        if (!argv.debug) {
+            formatEvaluation(result.evaluation);
+        }
+    }
+    else if (argv.enableEvaluation) {
+        displayMissingDataWarning("Evaluation");
+    }
+}
 // Load environment variables from .env file
 try {
     // Try to import and configure dotenv
@@ -129,10 +214,12 @@ const cli = yargs(args)
     // Control SDK logging based on debug flag
     if (argv.debug) {
         process.env.NEUROLINK_DEBUG = "true";
+        process.env.MCP_LOG_LEVEL = "info"; // Show MCP logs in debug mode
     }
     else {
         // Always set to false when debug is not enabled (including when not provided)
         process.env.NEUROLINK_DEBUG = "false";
+        process.env.MCP_LOG_LEVEL = "error"; // Hide MCP info logs when not debugging
     }
     // Keep existing quiet middleware
     if (process.env.NEUROLINK_QUIET === "true" &&
@@ -252,15 +339,46 @@ const cli = yargs(args)
     default: false,
     description: "Enable debug mode with verbose output",
 }) // Kept for potential specific debug logic
-    .option("timeout", {
+    .option("model", {
     type: "string",
-    default: "30s",
-    description: "Timeout for the request (e.g., 30s, 2m, 1h, 5000)",
+    description: "Specific model to use (e.g. gemini-2.5-pro, gemini-2.5-flash)",
+})
+    .option("timeout", {
+    type: "number",
+    default: 120,
+    description: "Maximum execution time in seconds (default: 120)",
 })
     .option("disable-tools", {
     type: "boolean",
     default: false,
     description: "Disable MCP tool integration (tools enabled by default)",
+})
+    .option("enable-analytics", {
+    type: "boolean",
+    default: false,
+    description: "Enable usage analytics collection",
+})
+    .option("enable-evaluation", {
+    type: "boolean",
+    default: false,
+    description: "Enable AI response quality evaluation",
+})
+    .option("evaluation-domain", {
+    type: "string",
+    description: "Domain expertise for evaluation (e.g., 'AI coding assistant', 'Customer service expert')",
+})
+    .option("tool-usage-context", {
+    type: "string",
+    description: "Tool usage context for evaluation (e.g., 'Used sales-data MCP tools')",
+})
+    .option("lighthouse-style", {
+    type: "boolean",
+    default: false,
+    description: "Use Lighthouse-compatible domain-aware evaluation",
+})
+    .option("context", {
+    type: "string",
+    description: "JSON context object for custom data",
 })
     .example('$0 generate-text "Hello world"', "Basic text generation")
     .example('$0 generate-text "Write a story" --provider openai', "Use specific provider")
@@ -285,10 +403,25 @@ const cli = yargs(args)
         ? null
         : ora("🤖 Generating text...").start();
     try {
-        // The SDK will handle the timeout internally, so we don't need this wrapper anymore
-        // Just pass the timeout to the SDK
+        // CRITICAL: Add master timeout to prevent infinite hangs
+        const cliTimeout = argv.timeout ? argv.timeout * 1000 : 120000; // Default 2 minutes
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`CLI operation timed out after ${cliTimeout / 1000} seconds. Use --timeout to adjust.`));
+            }, cliTimeout);
+        });
         // Use AgentEnhancedProvider when tools are enabled, otherwise use standard SDK
         let generatePromise;
+        // Parse context if provided
+        let contextObj;
+        if (argv.context) {
+            try {
+                contextObj = JSON.parse(argv.context);
+            }
+            catch {
+                throw new Error("Invalid JSON provided for --context option");
+            }
+        }
         if (argv.disableTools === true) {
             // Tools disabled - use standard SDK
             generatePromise = sdk.generateText({
@@ -296,10 +429,18 @@ const cli = yargs(args)
                 provider: argv.provider === "auto"
                     ? undefined
                     : argv.provider,
+                model: argv.model,
                 temperature: argv.temperature,
                 maxTokens: argv.maxTokens,
                 systemPrompt: argv.system,
                 timeout: argv.timeout,
+                // NEW: Analytics and evaluation support
+                enableAnalytics: argv.enableAnalytics,
+                enableEvaluation: argv.enableEvaluation,
+                context: contextObj,
+                // NEW: Lighthouse-compatible domain-aware evaluation
+                evaluationDomain: argv.evaluationDomain,
+                toolUsageContext: argv.toolUsageContext,
             });
         }
         else {
@@ -318,40 +459,55 @@ const cli = yargs(args)
             })();
             const agentProvider = new AgentEnhancedProvider({
                 provider: supportedProvider,
-                model: undefined, // Use default model for provider
+                model: argv.model, // Use specified model or default
                 toolCategory: "all", // Enable all tool categories
             });
-            generatePromise = agentProvider.generateText(argv.prompt);
+            generatePromise = agentProvider.generateText({
+                prompt: argv.prompt,
+                temperature: argv.temperature,
+                maxTokens: argv.maxTokens, // Respect user's token limit - no artificial caps
+                systemPrompt: argv.system,
+                // NEW: Analytics and evaluation support
+                enableAnalytics: argv.enableAnalytics,
+                enableEvaluation: argv.enableEvaluation,
+                context: contextObj,
+                // NEW: Lighthouse-compatible domain-aware evaluation
+                evaluationDomain: argv.evaluationDomain,
+                toolUsageContext: argv.toolUsageContext,
+            });
         }
-        const result = await generatePromise;
+        // Wrap generation with master timeout to prevent infinite hangs
+        const result = await Promise.race([generatePromise, timeoutPromise]);
         if (argv.format === "json" && originalConsole.log) {
             Object.assign(console, originalConsole);
         }
         if (spinner) {
             spinner.succeed(chalk.green("✅ Text generated successfully!"));
         }
-        // Handle both AgentEnhancedProvider (AI SDK) and standard NeuroLink SDK responses
-        const responseText = result
-            ? result.text || result.content || ""
-            : "";
-        const responseUsage = result
-            ? result.usage || {
-                promptTokens: 0,
-                completionTokens: 0,
-                totalTokens: 0,
-            }
-            : { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+        const typedResult = result;
+        const responseText = typedResult?.text || typedResult?.content || "";
+        const responseUsage = typedResult?.usage || {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+        };
         if (argv.format === "json") {
             const jsonOutput = {
                 content: responseText,
-                provider: result
-                    ? result.provider || argv.provider
-                    : argv.provider,
+                provider: typedResult?.provider || argv.provider,
                 usage: responseUsage,
-                responseTime: result ? result.responseTime || 0 : 0,
-                toolCalls: result ? result.toolCalls || [] : [],
-                toolResults: result ? result.toolResults || [] : [],
+                responseTime: typedResult?.responseTime || 0,
+                toolCalls: typedResult?.toolCalls || [],
+                toolResults: typedResult?.toolResults || [],
             };
+            // Include analytics if present
+            if (typedResult?.analytics) {
+                jsonOutput.analytics = typedResult.analytics;
+            }
+            // Include evaluation if present
+            if (typedResult?.evaluation) {
+                jsonOutput.evaluation = typedResult.evaluation;
+            }
             process.stdout.write(JSON.stringify(jsonOutput, null, 2) + "\n");
         }
         else if (argv.debug) {
@@ -381,6 +537,21 @@ const cli = yargs(args)
                 }
                 console.log();
             }
+            // DEBUG: Show what's in the result object
+            if (argv.debug) {
+                logger.debug("Result object keys:", {
+                    keys: Object.keys(result || {}),
+                });
+                logger.debug("Enhancement status:", {
+                    hasAnalytics: !!(result && result.analytics),
+                    hasEvaluation: !!(result && result.evaluation),
+                    enableAnalytics: argv.enableAnalytics,
+                    enableEvaluation: argv.enableEvaluation,
+                    hasContext: !!contextObj,
+                });
+            }
+            // Show analytics and evaluation if enabled
+            displayAnalyticsAndEvaluation(result, argv);
             console.log(JSON.stringify({
                 provider: result
                     ? result.provider || argv.provider
@@ -397,6 +568,8 @@ const cli = yargs(args)
             if (responseText) {
                 console.log(responseText);
             }
+            // Show analytics and evaluation if enabled
+            displayAnalyticsAndEvaluation(result, argv);
         }
         // Explicitly exit to prevent hanging, especially with Google AI Studio
         process.exit(0);
@@ -450,6 +623,10 @@ const cli = yargs(args)
     type: "string",
     default: "2m",
     description: "Timeout for streaming (e.g., 30s, 2m, 1h)",
+})
+    .option("model", {
+    type: "string",
+    description: "Specific model to use (e.g., gemini-2.5-pro, gemini-2.5-flash)",
 })
     .option("debug", {
     type: "boolean",
@@ -460,6 +637,33 @@ const cli = yargs(args)
     type: "boolean",
     default: false,
     description: "Disable MCP tool integration (tools enabled by default)",
+})
+    .option("enable-analytics", {
+    type: "boolean",
+    default: false,
+    description: "Enable usage analytics collection",
+})
+    .option("enable-evaluation", {
+    type: "boolean",
+    default: false,
+    description: "Enable AI response quality evaluation",
+})
+    .option("evaluation-domain", {
+    type: "string",
+    description: "Domain expertise for evaluation (e.g., 'AI coding assistant', 'Customer service expert')",
+})
+    .option("tool-usage-context", {
+    type: "string",
+    description: "Tool usage context for evaluation (e.g., 'Used sales-data MCP tools')",
+})
+    .option("lighthouse-style", {
+    type: "boolean",
+    default: false,
+    description: "Use Lighthouse-compatible domain-aware evaluation",
+})
+    .option("context", {
+    type: "string",
+    description: "JSON context object for custom data",
 })
     .example('$0 stream "Tell me a story"', "Stream a story in real-time")
     .example('$0 stream "What time is it?"', "Stream with natural tool integration (default)")
@@ -473,6 +677,16 @@ const cli = yargs(args)
         console.log(chalk.blue(`🔄 Streaming from ${argv.provider} provider with debug logging...\n`));
     }
     try {
+        // Parse context if provided
+        let contextObj;
+        if (argv.context) {
+            try {
+                contextObj = JSON.parse(argv.context);
+            }
+            catch {
+                throw new Error("Invalid JSON provided for --context option");
+            }
+        }
         let stream;
         if (argv.disableTools === true) {
             // Tools disabled - use standard SDK
@@ -481,8 +695,13 @@ const cli = yargs(args)
                 provider: argv.provider === "auto"
                     ? undefined
                     : argv.provider,
+                model: argv.model,
                 temperature: argv.temperature,
                 timeout: argv.timeout,
+                // NEW: Analytics and evaluation support
+                enableAnalytics: argv.enableAnalytics,
+                enableEvaluation: argv.enableEvaluation,
+                context: contextObj,
             });
         }
         else {
@@ -501,12 +720,19 @@ const cli = yargs(args)
             })();
             const agentProvider = new AgentEnhancedProvider({
                 provider: supportedProvider,
-                model: undefined, // Use default model for provider
+                model: argv.model, // Use specified model or default
                 toolCategory: "all", // Enable all tool categories
             });
             // Note: AgentEnhancedProvider doesn't support streaming with tools yet
             // Fall back to generateText for now
-            const result = await agentProvider.generateText(argv.prompt);
+            const result = await agentProvider.generateText({
+                prompt: argv.prompt,
+                temperature: argv.temperature,
+                // NEW: Analytics and evaluation support
+                enableAnalytics: argv.enableAnalytics,
+                enableEvaluation: argv.enableEvaluation,
+                context: contextObj,
+            });
             // Simulate streaming by outputting the result
             const text = result?.text || "";
             const CHUNK_SIZE = 10;
@@ -518,6 +744,9 @@ const cli = yargs(args)
             if (!argv.quiet) {
                 process.stdout.write("\n");
             }
+            // Show analytics if enabled
+            // Show analytics and evaluation if enabled
+            displayAnalyticsAndEvaluation(result, argv);
             return; // Exit early for agent mode
         }
         for await (const chunk of stream) {

package/dist/config/configManager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * NeuroLink Config Manager with Backup/Restore System
+ * Industry standard configuration management with safety mechanisms
+ */
+import type { NeuroLinkConfig, ProviderConfig, BackupInfo, ConfigValidationResult, ConfigUpdateOptions } from "./types.js";
+/**
+ * Enhanced Config Manager with automatic backup/restore capabilities
+ */
+export declare class NeuroLinkConfigManager {
+    private configPath;
+    private backupDir;
+    private config;
+    private configCache;
+    /**
+     * Load configuration with caching
+     */
+    loadConfig(): Promise<NeuroLinkConfig>;
+    /**
+     * Update configuration with automatic backup
+     */
+    updateConfig(updates: Partial<NeuroLinkConfig>, options?: ConfigUpdateOptions): Promise<void>;
+    /**
+     * Create a backup with metadata
+     */
+    createBackup(reason?: string): Promise<string>;
+    /**
+     * List all available backups
+     */
+    listBackups(): Promise<BackupInfo[]>;
+    /**
+     * Restore from specific backup
+     */
+    restoreFromBackup(backupFilename: string): Promise<void>;
+    /**
+     * Restore from latest backup
+     */
+    restoreLatestBackup(): Promise<void>;
+    /**
+     * Clean up old backups
+     */
+    cleanupOldBackups(keepCount?: number): Promise<void>;
+    /**
+     * Update provider status
+     */
+    updateProviderStatus(providerId: string, status: Partial<ProviderConfig>): Promise<void>;
+    /**
+     * Validate configuration
+     */
+    validateConfig(config: NeuroLinkConfig): Promise<ConfigValidationResult>;
+    /**
+     * Generate default configuration
+     */
+    generateDefaultConfig(): Promise<NeuroLinkConfig>;
+    private ensureBackupDirectory;
+    private readConfigFile;
+    private persistConfig;
+    private generateConfigHash;
+    private extractMetadataFromBackup;
+    private extractConfigFromBackup;
+}