@juspay/neurolink 7.29.2 → 7.30.0

package/dist/cli/factories/commandFactory.js

@@ -1,5 +1,8 @@
 import { NeuroLink } from "../../lib/neurolink.js";
 import { configManager } from "../commands/config.js";
+import { handleError } from "../index.js";
+import { normalizeEvaluationData } from "../../lib/utils/evaluationUtils.js";
+// Use TokenUsage from standard types - no local interface needed
 import { ContextFactory, } from "../../lib/types/contextTypes.js";
 import { ModelsCommandFactory } from "../commands/models.js";
 import { MCPCommandFactory } from "../commands/mcp.js";
@@ -9,6 +12,7 @@ import ora from "ora";
 import chalk from "chalk";
 import { logger } from "../../lib/utils/logger.js";
 import fs from "fs";
+// Use specific command interfaces from cli.ts instead of universal interface
 /**
  * CLI Command Factory for generate commands
  */
@@ -209,7 +213,9 @@ export class CLICommandFactory {
             }
         }
         return {
-            provider: argv.provider === "auto" ? undefined : argv.provider,
+            provider: argv.provider === "auto"
+                ? undefined
+                : argv.provider,
             model: argv.model,
             temperature: argv.temperature,
             maxTokens: argv.maxTokens,
@@ -339,7 +345,7 @@ export class CLICommandFactory {
         }
         analyticsText += "\n";
         // Token usage with fallback handling
-        const normalizedTokens = this.normalizeTokenUsage(analytics.tokens);
+        const normalizedTokens = this.normalizeTokenUsage(analytics.tokenUsage);
         if (normalizedTokens) {
             analyticsText += `   Tokens: ${normalizedTokens.input} input + ${normalizedTokens.output} output = ${normalizedTokens.total} total\n`;
         }
@@ -350,8 +356,8 @@ export class CLICommandFactory {
             analyticsText += `   Cost: $${analytics.cost.toFixed(5)}\n`;
         }
         // Response time with fallback handling for requestDuration vs responseTime
-        const duration = analytics.responseTime ||
-            analytics.requestDuration ||
+        const duration = analytics.requestDuration ||
+            analytics.responseTime ||
             analytics.duration;
         if (duration && typeof duration === "number") {
             const timeInSeconds = (duration / 1000).toFixed(1);
@@ -603,21 +609,21 @@ export class CLICommandFactory {
                         provider: "google-ai",
                         status: "working",
                         configured: true,
-                        responseTime: 150,
+                        requestDuration: 150,
                         model: "gemini-2.5-flash",
                     },
                     {
                         provider: "openai",
                         status: "working",
                         configured: true,
-                        responseTime: 200,
+                        requestDuration: 200,
                         model: "gpt-4o-mini",
                     },
                     {
                         provider: "anthropic",
                         status: "working",
                         configured: true,
-                        responseTime: 180,
+                        requestDuration: 180,
                         model: "claude-3-haiku",
                     },
                     { provider: "bedrock", status: "not configured", configured: false },
@@ -633,7 +639,9 @@ export class CLICommandFactory {
                         : result.status === "failed"
                             ? chalk.red("❌ Failed")
                             : chalk.gray("⚪ Not configured");
-                    const time = result.responseTime ? ` (${result.responseTime}ms)` : "";
+                    const time = result.requestDuration
+                        ? ` (${result.requestDuration}ms)`
+                        : "";
                     const model = result.model ? ` [${result.model}]` : "";
                     logger.always(`${result.provider}: ${status}${time}${model}`);
                 }
@@ -734,33 +742,31 @@ export class CLICommandFactory {
                     provider: options.provider || "auto",
                     model: options.model || "test-model",
                     usage: {
-                        inputTokens: 10,
-                        outputTokens: 15,
-                        totalTokens: 25,
+                        input: 10,
+                        output: 15,
+                        total: 25,
                     },
                     responseTime: 150,
                     analytics: options.enableAnalytics
                         ? {
                             provider: options.provider || "auto",
                             model: options.model || "test-model",
-                            tokens: { input: 10, output: 15, total: 25 },
+                            tokenUsage: { input: 10, output: 15, total: 25 },
                             cost: 0.00025,
-                            responseTime: 150,
+                            requestDuration: 150,
                             context: contextMetadata,
                         }
                         : undefined,
                     evaluation: options.enableEvaluation
-                        ? {
+                        ? normalizeEvaluationData({
                             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) {
@@ -774,7 +780,6 @@ export class CLICommandFactory {
                     logger.debug("Mode: DRY-RUN (no actual API calls made)");
                 }
                 process.exit(0);
-                return;
             }
             const sdk = new NeuroLink();
             if (options.debug) {
@@ -827,18 +832,36 @@ export class CLICommandFactory {
             if (spinner) {
                 spinner.fail();
             }
-            logger.error(chalk.red(`❌ Generation failed: ${error.message}`));
-            if (options.debug) {
-                logger.error(chalk.gray(error.stack));
-            }
-            process.exit(1);
+            handleError(error, "Generation");
         }
     }
     /**
-     * Execute the stream command
+     * Log debug information for stream result
      */
-    static async executeStream(argv) {
-        // Handle stdin input if no input provided
+    static async logStreamDebugInfo(stream) {
+        logger.debug("\n" + chalk.yellow("Debug Information (Streaming):"));
+        logger.debug("Provider:", stream.provider);
+        logger.debug("Model:", stream.model);
+        if (stream.analytics) {
+            const resolvedAnalytics = await (stream.analytics instanceof Promise
+                ? stream.analytics
+                : Promise.resolve(stream.analytics));
+            logger.debug("Analytics:", JSON.stringify(resolvedAnalytics, null, 2));
+        }
+        if (stream.evaluation) {
+            const resolvedEvaluation = await (stream.evaluation instanceof Promise
+                ? stream.evaluation
+                : Promise.resolve(stream.evaluation));
+            logger.debug("Evaluation:", JSON.stringify(resolvedEvaluation, null, 2));
+        }
+        if (stream.metadata) {
+            logger.debug("Metadata:", JSON.stringify(stream.metadata, null, 2));
+        }
+    }
+    /**
+     * Handle stdin input for stream command
+     */
+    static async handleStdinInput(argv) {
         if (!argv.input && !process.stdin.isTTY) {
             let stdinData = "";
             process.stdin.setEncoding("utf8");
@@ -853,6 +876,12 @@ export class CLICommandFactory {
         else if (!argv.input) {
             throw new Error('Input required. Use: neurolink stream "your prompt" or echo "prompt" | neurolink stream');
         }
+    }
+    /**
+     * Execute the stream command
+     */
+    static async executeStream(argv) {
+        await this.handleStdinInput(argv);
         const options = this.processOptions(argv);
         if (!options.quiet) {
             logger.always(chalk.blue("🔄 Streaming..."));
@@ -915,11 +944,11 @@ export class CLICommandFactory {
                         model: options.model || "test-model",
                         requestDuration: 300,
                         tokenUsage: {
-                            inputTokens: 10,
-                            outputTokens: 15,
-                            totalTokens: 25,
+                            input: 10,
+                            output: 15,
+                            total: 25,
                         },
-                        timestamp: Date.now(),
+                        timestamp: new Date().toISOString(),
                         context: contextMetadata,
                     };
                     const mockGenerateResult = {
@@ -953,7 +982,6 @@ export class CLICommandFactory {
                     logger.debug("Mode: DRY-RUN (no actual API calls made)");
                 }
                 process.exit(0);
-                return;
             }
             const sdk = new NeuroLink();
             const stream = await sdk.stream({
@@ -1079,33 +1107,12 @@ export class CLICommandFactory {
             }
             // 🔧 NEW: Debug output for streaming (similar to generate command)
             if (options.debug) {
-                logger.debug("\n" + chalk.yellow("Debug Information (Streaming):"));
-                logger.debug("Provider:", stream.provider);
-                logger.debug("Model:", stream.model);
-                if (stream.analytics) {
-                    const resolvedAnalytics = await (stream.analytics instanceof Promise
-                        ? stream.analytics
-                        : Promise.resolve(stream.analytics));
-                    logger.debug("Analytics:", JSON.stringify(resolvedAnalytics, null, 2));
-                }
-                if (stream.evaluation) {
-                    const resolvedEvaluation = await (stream.evaluation instanceof Promise
-                        ? stream.evaluation
-                        : Promise.resolve(stream.evaluation));
-                    logger.debug("Evaluation:", JSON.stringify(resolvedEvaluation, null, 2));
-                }
-                if (stream.metadata) {
-                    logger.debug("Metadata:", JSON.stringify(stream.metadata, null, 2));
-                }
+                await this.logStreamDebugInfo(stream);
             }
             process.exit(0);
         }
         catch (error) {
-            logger.error(chalk.red(`❌ Streaming failed: ${error.message}`));
-            if (options.debug) {
-                logger.error(chalk.gray(error.stack));
-            }
-            process.exit(1);
+            handleError(error, "Streaming");
         }
     }
     /**
@@ -1219,11 +1226,7 @@ export class CLICommandFactory {
             if (spinner) {
                 spinner.fail();
             }
-            logger.error(chalk.red(`❌ Batch processing failed: ${error.message}`));
-            if (options.debug) {
-                logger.error(chalk.gray(error.stack));
-            }
-            process.exit(1);
+            handleError(error, "Batch processing");
         }
     }
     /**
@@ -1252,8 +1255,7 @@ export class CLICommandFactory {
             this.handleOutput(config, options);
         }
         catch (error) {
-            logger.error(chalk.red(`❌ Configuration export failed: ${error.message}`));
-            process.exit(1);
+            handleError(error, "Configuration export");
         }
     }
     /**
@@ -1277,8 +1279,7 @@ export class CLICommandFactory {
             }
         }
         catch (error) {
-            logger.error(chalk.red(`❌ Provider selection failed: ${error.message}`));
-            process.exit(1);
+            handleError(error, "Provider selection");
         }
     }
     /**
@@ -1417,8 +1418,7 @@ export class CLICommandFactory {
             }
         }
         catch (error) {
-            logger.error(chalk.red(`❌ Completion generation failed: ${error.message}`));
-            process.exit(1);
+            handleError(error, "Completion generation");
         }
     }
 }

package/dist/cli/factories/ollamaCommandFactory.js

@@ -183,7 +183,9 @@ export class OllamaCommandFactory {
                 logger.always(chalk.green(`\n${modelsData.models.length} models available`));
             }
         }
-        catch (_error) {
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.debug("Error:", errorMessage);
             spinner.fail("Ollama service is not running");
             logger.always(chalk.yellow("\nStart Ollama with: ollama serve"));
             logger.always(chalk.blue("Or restart the Ollama app if using the desktop version"));

package/dist/cli/factories/sagemakerCommandFactory.js

@@ -309,9 +309,10 @@ export class SageMakerCommandFactory {
                     logger.always(chalk.yellow("No SageMaker endpoints found"));
                 }
             }
-            catch (_awsError) {
+            catch (error) {
                 spinner.fail("Failed to list endpoints");
-                logger.error(chalk.red("AWS SDK credentials error or insufficient permissions"));
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.error(chalk.red("Error:", errorMessage));
                 logger.always(chalk.yellow("\nTo list endpoints, please:"));
                 logger.always("1. Set AWS_ACCESS_KEY_ID environment variable");
                 logger.always("2. Set AWS_SECRET_ACCESS_KEY environment variable");

package/dist/cli/index.d.ts

@@ -5,4 +5,4 @@
  * Professional CLI experience with minimal maintenance overhead.
  * Features: Spinners, colors, batch processing, provider testing, rich help
  */
-export {};
+export declare function handleError(_error: Error, context: string): void;

package/dist/cli/index.js

@@ -33,14 +33,14 @@ try {
     const { config } = await import("dotenv");
     config(); // Load .env from current working directory
 }
-catch (error) {
+catch {
     // dotenv is not available (dev dependency only) - this is fine for production
     // Environment variables should be set externally in production
 }
 // Utility Functions (Simple, Zero Maintenance)
-function handleError(error, context) {
-    logger.error(chalk.red(`❌ ${context} failed: ${error.message}`));
-    if (error instanceof AuthenticationError) {
+export function handleError(_error, context) {
+    logger.error(chalk.red(`❌ ${context} failed: ${_error.message}`));
+    if (_error instanceof AuthenticationError) {
         logger.error(chalk.yellow("💡 Set Google AI Studio API key (RECOMMENDED): export GOOGLE_AI_API_KEY=AIza-..."));
         logger.error(chalk.yellow("💡 Or set OpenAI API key: export OPENAI_API_KEY=sk-..."));
         logger.error(chalk.yellow("💡 Or set AWS Bedrock credentials: export AWS_ACCESS_KEY_ID=... AWS_SECRET_ACCESS_KEY=... AWS_REGION=us-east-1"));
@@ -48,14 +48,14 @@ function handleError(error, context) {
         logger.error(chalk.yellow("💡 Or set Anthropic API key: export ANTHROPIC_API_KEY=sk-ant-..."));
         logger.error(chalk.yellow("💡 Or set Azure OpenAI credentials: export AZURE_OPENAI_API_KEY=... AZURE_OPENAI_ENDPOINT=..."));
     }
-    else if (error instanceof RateLimitError) {
+    else if (_error instanceof RateLimitError) {
         logger.error(chalk.yellow("💡 Try again in a few moments or use --provider vertex"));
     }
-    else if (error instanceof AuthorizationError) {
+    else if (_error instanceof AuthorizationError) {
         logger.error(chalk.yellow("💡 Check your account permissions for the selected model/service."));
         logger.error(chalk.yellow("💡 For AWS Bedrock, ensure you have permissions for the specific model and consider using inference profile ARNs."));
     }
-    else if (error instanceof NetworkError) {
+    else if (_error instanceof NetworkError) {
         logger.error(chalk.yellow("💡 Check your internet connection and the provider's status page."));
     }
     process.exit(1);
@@ -105,9 +105,9 @@ const cli = yargs(args)
         }
     };
     if (err) {
-        // Error likely from an async command handler (e.g., via handleError)
-        // handleError already prints and calls process.exit(1).
-        // If we're here, it means handleError's process.exit might not have been caught by the top-level async IIFE.
+        // Error likely from an async command handler (e.g., via _handleError)
+        // _handleError already prints and calls process.exit(1).
+        // If we're here, it means _handleError's process.exit might not have been caught by the top-level async IIFE.
         // Or, it's a synchronous yargs error during parsing that yargs itself throws.
         const alreadyExitedByHandleError = err?.exitCode !== undefined;
         // A simple heuristic: if the error message doesn't look like one of our handled generic messages,
@@ -197,7 +197,7 @@ const cli = yargs(args)
     }
     catch (error) {
         // Global error handler - should not reach here due to fail() handler
-        process.stderr.write(chalk.red(`Unexpected CLI error: ${error.message}\n`));
+        process.stderr.write(chalk.red(`Unexpected CLI _error: ${error.message}\n`));
         process.exit(1);
     }
 })();

package/dist/cli/utils/envManager.js

@@ -61,7 +61,7 @@ export function parseEnvFile(content) {
  */
 export function generateEnvContent(envVars, existingContent) {
     const lines = [];
-    const existingVars = existingContent ? parseEnvFile(existingContent) : {};
+    const _existingVars = existingContent ? parseEnvFile(existingContent) : {};
     const processedKeys = new Set();
     // If we have existing content, preserve its structure and comments
     if (existingContent) {
@@ -121,15 +121,15 @@ export function updateEnvFile(newVars, envPath = ".env", createBackup = true) {
     }
     // Read existing content
     let existingContent = "";
-    let existingVars = {};
+    let _existingVars = {};
     if (fs.existsSync(envPath)) {
         existingContent = fs.readFileSync(envPath, "utf8");
-        existingVars = parseEnvFile(existingContent);
+        _existingVars = parseEnvFile(existingContent);
     }
     // Categorize changes
     for (const [key, value] of Object.entries(newVars)) {
-        if (Object.prototype.hasOwnProperty.call(existingVars, key)) {
-            if (existingVars[key] !== value) {
+        if (Object.prototype.hasOwnProperty.call(_existingVars, key)) {
+            if (_existingVars[key] !== value) {
                 result.updated.push(key);
             }
             else {

package/dist/cli/utils/ollamaUtils.d.ts

@@ -8,6 +8,18 @@ export declare class OllamaUtils {
      * Secure wrapper around spawnSync to prevent command injection.
      */
     static safeSpawn(command: AllowedCommand, args: string[], options?: SpawnSyncOptions): SpawnSyncReturns<string>;
+    /**
+     * Check if Ollama command line is available
+     */
+    private static isOllamaCommandReady;
+    /**
+     * Validate HTTP API response from Ollama
+     */
+    private static validateApiResponse;
+    /**
+     * Check if Ollama HTTP API is ready
+     */
+    private static isOllamaApiReady;
     /**
      * Wait for Ollama service to become ready with exponential backoff
      */

package/dist/cli/utils/ollamaUtils.js

@@ -16,6 +16,55 @@ export class OllamaUtils {
         };
         return spawnSync(command, args, defaultOptions);
     }
+    /**
+     * Check if Ollama command line is available
+     */
+    static isOllamaCommandReady() {
+        const cmdCheck = this.safeSpawn("ollama", ["list"]);
+        return !cmdCheck.error && cmdCheck.status === 0;
+    }
+    /**
+     * Validate HTTP API response from Ollama
+     */
+    static validateApiResponse(output) {
+        const httpCodeMatch = output.match(/(\d{3})$/);
+        if (!httpCodeMatch || httpCodeMatch[1] !== "200") {
+            return false;
+        }
+        // Try to parse the JSON response (excluding HTTP code)
+        const jsonResponse = output.replace(/\d{3}$/, "");
+        try {
+            const parsedResponse = JSON.parse(jsonResponse);
+            return parsedResponse && typeof parsedResponse === "object";
+        }
+        catch {
+            // JSON parsing failed, but HTTP 200 is good enough
+            return true;
+        }
+    }
+    /**
+     * Check if Ollama HTTP API is ready
+     */
+    static isOllamaApiReady() {
+        try {
+            const apiCheck = this.safeSpawn("curl", [
+                "-s",
+                "--max-time",
+                "3",
+                "--fail", // Fail on HTTP error codes
+                "-w",
+                "%{http_code}",
+                "http://localhost:11434/api/tags",
+            ]);
+            if (apiCheck.error || apiCheck.status !== 0 || !apiCheck.stdout.trim()) {
+                return false;
+            }
+            return this.validateApiResponse(apiCheck.stdout.trim());
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Wait for Ollama service to become ready with exponential backoff
      */
@@ -23,49 +72,16 @@ export class OllamaUtils {
         let delay = initialDelay;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
             try {
-                // Try both command line and HTTP API checks
-                const cmdCheck = this.safeSpawn("ollama", ["list"]);
-                if (!cmdCheck.error && cmdCheck.status === 0) {
-                    // Stronger HTTP API probe with response validation
-                    try {
-                        const apiCheck = this.safeSpawn("curl", [
-                            "-s",
-                            "--max-time",
-                            "3",
-                            "--fail", // Fail on HTTP error codes
-                            "-w",
-                            "%{http_code}",
-                            "http://localhost:11434/api/tags",
-                        ]);
-                        if (!apiCheck.error &&
-                            apiCheck.status === 0 &&
-                            apiCheck.stdout.trim()) {
-                            // Validate that we get a proper HTTP 200 response and JSON structure
-                            const output = apiCheck.stdout.trim();
-                            const httpCodeMatch = output.match(/(\d{3})$/);
-                            if (httpCodeMatch && httpCodeMatch[1] === "200") {
-                                // Try to parse the JSON response (excluding HTTP code)
-                                const jsonResponse = output.replace(/\d{3}$/, "");
-                                try {
-                                    const parsedResponse = JSON.parse(jsonResponse);
-                                    // Verify it has the expected structure
-                                    if (parsedResponse && typeof parsedResponse === "object") {
-                                        return true; // Strong verification passed
-                                    }
-                                }
-                                catch {
-                                    // JSON parsing failed, but HTTP 200 is good enough
-                                    return true;
-                                }
-                            }
-                        }
-                    }
-                    catch {
-                        // If curl fails, fall back to command check only
-                        return true;
-                    }
-                    return true; // Command check passed
+                // Try command line check first
+                if (!this.isOllamaCommandReady()) {
+                    continue;
+                }
+                // If command check passes, verify HTTP API
+                if (this.isOllamaApiReady()) {
+                    return true;
                 }
+                // Command check passed but API not ready, still consider ready
+                return true;
             }
             catch {
                 // Service not ready yet

package/dist/config/configManager.js

@@ -6,6 +6,7 @@ import { promises as fs } from "fs";
 import path from "path";
 import crypto from "crypto";
 import { logger } from "../utils/logger.js";
+import { DEFAULT_CONFIG } from "./types.js";
 const { readFile, writeFile, readdir, mkdir, unlink, access } = fs;
 /**
  * Enhanced Config Manager with automatic backup/restore capabilities
@@ -237,7 +238,6 @@ export default ${JSON.stringify(currentConfig, null, 2)};`;
      * Generate default configuration
      */
     async generateDefaultConfig() {
-        const { DEFAULT_CONFIG } = await import("./types.js");
         return {
             ...DEFAULT_CONFIG,
             lastUpdated: Date.now(),
@@ -266,7 +266,10 @@ export default ${JSON.stringify(currentConfig, null, 2)};`;
             throw new Error("Invalid config file format");
         }
         catch (error) {
-            logger.info("Config file not found, generating default...");
+            logger.info("Config file not found or invalid, generating default...", {
+                error: error instanceof Error ? error.message : String(error),
+                configPath: this.configPath,
+            });
             return await this.generateDefaultConfig();
         }
     }

package/dist/config/conversationMemoryConfig.js

@@ -36,5 +36,10 @@ export function getConversationMemoryDefaults() {
         maxSessions: Number(process.env.NEUROLINK_MEMORY_MAX_SESSIONS) || DEFAULT_MAX_SESSIONS,
         maxTurnsPerSession: Number(process.env.NEUROLINK_MEMORY_MAX_TURNS_PER_SESSION) ||
             DEFAULT_MAX_TURNS_PER_SESSION,
+        enableSummarization: process.env.NEUROLINK_SUMMARIZATION_ENABLED === "true",
+        summarizationThresholdTurns: Number(process.env.NEUROLINK_SUMMARIZATION_THRESHOLD_TURNS) || 20,
+        summarizationTargetTurns: Number(process.env.NEUROLINK_SUMMARIZATION_TARGET_TURNS) || 10,
+        summarizationProvider: process.env.NEUROLINK_SUMMARIZATION_PROVIDER || "vertex",
+        summarizationModel: process.env.NEUROLINK_SUMMARIZATION_MODEL || "gemini-2.5-flash",
     };
 }

package/dist/core/analytics.d.ts

@@ -4,30 +4,8 @@
  * Provides lightweight analytics tracking for AI provider usage,
  * including tokens, costs, performance metrics, and custom context.
  */
-import type { JsonValue, UnknownRecord } from "../types/common.js";
-export interface AnalyticsData {
-    provider: string;
-    model: string;
-    tokens: {
-        input: number;
-        output: number;
-        total: number;
-    };
-    cost?: number;
-    responseTime: number;
-    context?: Record<string, JsonValue>;
-    timestamp: string;
-    evaluation?: {
-        relevanceScore: number;
-        accuracyScore: number;
-        completenessScore: number;
-        overall: number;
-        evaluationProvider?: string;
-        evaluationTime?: number;
-        evaluationAttempt?: number;
-    };
-    costDetails?: UnknownRecord;
-}
+import type { AnalyticsData } from "../types/providers.js";
+export type { AnalyticsData, TokenUsage } from "../types/providers.js";
 /**
  * Create analytics data structure from AI response
  */