@juspay/neurolink 7.33.4 → 7.35.0

package/dist/cli/loop/session.js

@@ -0,0 +1,252 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { logger } from "../../lib/utils/logger.js";
+import { globalSession } from "../../lib/session/globalSessionState.js";
+import { textGenerationOptionsSchema } from "./optionsSchema.js";
+import { handleError } from "../errorHandler.js";
+// Banner Art
+const NEUROLINK_BANNER = `
+▗▖  ▗▖▗▄▄▄▖▗▖ ▗▖▗▄▄▖  ▗▄▖ ▗▖   ▗▄▄▄▖▗▖  ▗▖▗▖ ▗▖
+▐▛▚▖▐▌▐▌   ▐▌ ▐▌▐▌ ▐▌▐▌ ▐▌▐▌     █  ▐▛▚▖▐▌▐▌▗▞▘
+▐▌ ▝▜▌▐▛▀▀▘▐▌ ▐▌▐▛▀▚▖▐▌ ▐▌▐▌     █  ▐▌ ▝▜▌▐▛▚▖ 
+▐▌  ▐▌▐▙▄▄▖▝▚▄▞▘▐▌ ▐▌▝▚▄▞▘▐▙▄▄▖▗▄█▄▖▐▌  ▐▌▐▌ ▐▌
+`;
+export class LoopSession {
+    conversationMemoryConfig;
+    initializeCliParser;
+    isRunning = false;
+    sessionId;
+    sessionVariablesSchema = textGenerationOptionsSchema;
+    constructor(initializeCliParser, conversationMemoryConfig) {
+        this.conversationMemoryConfig = conversationMemoryConfig;
+        this.initializeCliParser = initializeCliParser;
+    }
+    async start() {
+        // Initialize global session state
+        this.sessionId = globalSession.setLoopSession(this.conversationMemoryConfig);
+        this.isRunning = true;
+        logger.always(chalk.bold.green(NEUROLINK_BANNER));
+        logger.always(chalk.bold.green("Welcome to NeuroLink Loop Mode!"));
+        if (this.conversationMemoryConfig?.enabled) {
+            logger.always(chalk.gray(`Session ID: ${this.sessionId}`));
+            logger.always(chalk.gray("Conversation memory enabled"));
+            logger.always(chalk.gray(`Max sessions: ${this.conversationMemoryConfig.maxSessions}`));
+            logger.always(chalk.gray(`Max turns per session: ${this.conversationMemoryConfig.maxTurnsPerSession}\n`));
+        }
+        logger.always(chalk.gray('Type "help" for a list of commands.'));
+        logger.always(chalk.gray('Type "exit", "quit", or ":q" to leave the loop.'));
+        while (this.isRunning) {
+            try {
+                const answers = await inquirer
+                    .prompt([
+                    {
+                        type: "input",
+                        name: "command",
+                        message: chalk.blue.bold("neurolink"),
+                        prefix: chalk.blue.green("⎔"),
+                        suffix: chalk.blue.green(" »"),
+                    },
+                ])
+                    .catch(() => {
+                    // This catch block handles the interruption of inquirer
+                    return { command: "" };
+                });
+                const command = answers.command.trim();
+                if (command.toLowerCase() === "exit" ||
+                    command.toLowerCase() === "quit" ||
+                    command.toLowerCase() === ":q") {
+                    this.isRunning = false;
+                    continue;
+                }
+                if (!command) {
+                    continue;
+                }
+                // Handle session variable commands first
+                if (await this.handleSessionCommands(command)) {
+                    continue;
+                }
+                // Execute the command
+                // The .fail() handler in cli.ts is now session-aware and will
+                // handle all parsing and validation errors without exiting the loop.
+                // We create a fresh instance for each command to prevent state pollution.
+                const yargsInstance = this.initializeCliParser();
+                await yargsInstance
+                    .scriptName("")
+                    .fail((msg, err) => {
+                    // Re-throw the error to be caught by the outer catch block
+                    throw err || new Error(msg);
+                })
+                    .exitProcess(false)
+                    .parse(command);
+            }
+            catch (error) {
+                // Catch errors from the main loop (e.g., inquirer prompt itself failing)
+                handleError(error, "An unexpected error occurred");
+            }
+        }
+        // Cleanup on exit
+        globalSession.clearLoopSession();
+        logger.always(chalk.yellow("Loop session ended."));
+    }
+    async handleSessionCommands(command) {
+        const parts = command.split(" ");
+        const cmd = parts[0].toLowerCase();
+        switch (cmd) {
+            case "help":
+                this.showHelp();
+                return true;
+            case "set":
+                if (parts.length === 2 && parts[1].toLowerCase() === "help") {
+                    this.showSetHelp();
+                }
+                else if (parts.length >= 3) {
+                    const key = parts[1];
+                    const schema = this.sessionVariablesSchema[key];
+                    if (!schema) {
+                        logger.always(chalk.red(`Error: Unknown session variable "${key}".`));
+                        logger.always(chalk.gray('Use "set help" to see available variables.'));
+                        return true;
+                    }
+                    const valueStr = parts.slice(2).join(" ");
+                    let value = this.parseValue(valueStr);
+                    // Validate type
+                    if (schema.type === "boolean" && typeof value !== "boolean") {
+                        logger.always(chalk.red(`Error: Invalid value for "${key}". Expected a boolean (true/false).`));
+                        return true;
+                    }
+                    if (schema.type === "string") {
+                        if (typeof value === "number" || typeof value === "boolean") {
+                            value = String(value);
+                        }
+                        else if (typeof value !== "string") {
+                            logger.always(chalk.red(`Error: Invalid value for "${key}". Expected a string.`));
+                            return true;
+                        }
+                    }
+                    if (schema.type === "number" && typeof value !== "number") {
+                        logger.always(chalk.red(`Error: Invalid value for "${key}". Expected a number.`));
+                        return true;
+                    }
+                    // Validate allowedValues
+                    if (schema.allowedValues &&
+                        !schema.allowedValues.includes(String(value))) {
+                        logger.always(chalk.red(`Error: Invalid value for "${key}".`));
+                        logger.always(chalk.gray(`Allowed values are: ${schema.allowedValues.join(", ")}`));
+                        return true;
+                    }
+                    globalSession.setSessionVariable(key, value);
+                    logger.always(chalk.green(`✓ ${key} set to ${value}`));
+                }
+                else {
+                    logger.always(chalk.red("Usage: set <key> <value> or set help"));
+                }
+                return true;
+            case "get":
+                if (parts.length >= 2) {
+                    const key = parts[1];
+                    const value = globalSession.getSessionVariable(key);
+                    if (value !== undefined) {
+                        logger.always(chalk.cyan(`${key}: ${value}`));
+                    }
+                    else {
+                        logger.always(chalk.yellow(`${key} is not set`));
+                    }
+                }
+                else {
+                    logger.always(chalk.red("Usage: get <key>"));
+                }
+                return true;
+            case "unset":
+                if (parts.length >= 2) {
+                    const key = parts[1];
+                    if (globalSession.unsetSessionVariable(key)) {
+                        logger.always(chalk.green(`✓ ${key} unset`));
+                    }
+                    else {
+                        logger.always(chalk.yellow(`${key} was not set`));
+                    }
+                }
+                else {
+                    logger.always(chalk.red("Usage: unset <key>"));
+                }
+                return true;
+            case "show": {
+                const variables = globalSession.getSessionVariables();
+                if (Object.keys(variables).length > 0) {
+                    logger.always(chalk.cyan("Session Variables:"));
+                    for (const [key, value] of Object.entries(variables)) {
+                        logger.always(chalk.gray(`  ${key}: ${value}`));
+                    }
+                }
+                else {
+                    logger.always(chalk.yellow("No session variables set"));
+                }
+                return true;
+            }
+            case "clear":
+                globalSession.clearSessionVariables();
+                logger.always(chalk.green("✓ All session variables cleared"));
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseValue(value) {
+        // Try to parse as number
+        if (!isNaN(Number(value))) {
+            return Number(value);
+        }
+        // Try to parse as boolean
+        if (value.toLowerCase() === "true") {
+            return true;
+        }
+        if (value.toLowerCase() === "false") {
+            return false;
+        }
+        // Return as string
+        return value;
+    }
+    showHelp() {
+        logger.always(chalk.cyan("Available Loop Mode Commands:"));
+        const commands = [
+            {
+                cmd: "help",
+                desc: "Show this help message.",
+            },
+            {
+                cmd: "set <key> <value>",
+                desc: "Set a session variable. Use 'set help' for details.",
+            },
+            { cmd: "get <key>", desc: "Get a session variable." },
+            { cmd: "unset <key>", desc: "Unset a session variable." },
+            {
+                cmd: "show",
+                desc: "Show all currently set session variables.",
+            },
+            { cmd: "clear", desc: "Clear all session variables." },
+            {
+                cmd: "exit / quit / :q",
+                desc: "Exit the loop mode.",
+            },
+        ];
+        commands.forEach((c) => {
+            logger.always(chalk.yellow(`  ${c.cmd.padEnd(20)}`) + `${c.desc}`);
+        });
+        logger.always("\nAny other command will be executed as a standard neurolink CLI command.");
+        // Also show the standard help output
+        this.initializeCliParser().showHelp("log");
+    }
+    showSetHelp() {
+        logger.always(chalk.cyan("Available Session Variables to Set:"));
+        for (const [key, schema] of Object.entries(this.sessionVariablesSchema)) {
+            logger.always(chalk.yellow(`  ${key}`));
+            logger.always(`    ${schema.description}`);
+            if (schema.allowedValues) {
+                logger.always(chalk.gray(`    Allowed: ${schema.allowedValues.join(", ")}`));
+            }
+            else {
+                logger.always(chalk.gray(`    Type: ${schema.type}`));
+            }
+        }
+    }
+}

package/dist/cli/parser.d.ts

@@ -0,0 +1 @@
+export declare function initializeCliParser(): import("yargs").Argv<{}>;

package/dist/cli/parser.js

@@ -0,0 +1,161 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import chalk from "chalk";
+import packageJson from "../../package.json" with { type: "json" };
+import { CLICommandFactory } from "./factories/commandFactory.js";
+import { globalSession } from "../lib/session/globalSessionState.js";
+import { handleError } from "./errorHandler.js";
+import { logger } from "../lib/utils/logger.js";
+import { SetupCommandFactory } from "./factories/setupCommandFactory.js";
+// Enhanced CLI with Professional UX
+export function initializeCliParser() {
+    return (yargs(hideBin(process.argv))
+        .scriptName("neurolink")
+        .usage("Usage: $0 <command> [options]")
+        .version(packageJson.version)
+        .help()
+        .alias("h", "help")
+        .alias("V", "version")
+        .strictOptions()
+        .strictCommands()
+        .demandCommand(1, "")
+        .recommendCommands()
+        .epilogue("For more info: https://github.com/juspay/neurolink")
+        .showHelpOnFail(true, "Specify --help for available options")
+        .middleware((argv) => {
+        // Handle no-color option globally
+        if (argv.noColor || process.env.NO_COLOR || !process.stdout.isTTY) {
+            process.env.FORCE_COLOR = "0";
+        }
+        // Handle custom config file
+        if (argv.configFile) {
+            process.env.NEUROLINK_CONFIG_FILE = argv.configFile;
+        }
+        // Control SDK logging based on debug flag
+        if (argv.debug) {
+            process.env.NEUROLINK_DEBUG = "true";
+        }
+        else {
+            // Always set to false when debug is not enabled (including when not provided)
+            process.env.NEUROLINK_DEBUG = "false";
+        }
+        // Keep existing quiet middleware
+        if (process.env.NEUROLINK_QUIET === "true" &&
+            typeof argv.quiet === "undefined") {
+            argv.quiet = true;
+        }
+    })
+        .fail((msg, err, yargsInstance) => {
+        // If we are in a loop, we don't want to exit the process.
+        // Instead, we just want to display the error and help text.
+        if (globalSession.getCurrentSessionId()) {
+            if (msg) {
+                logger.error(chalk.red(msg)); // This is a yargs validation error (e.g., missing argument)
+                yargsInstance.showHelp("log");
+            }
+            else if (err) {
+                // This is an error thrown from a command handler
+                // The loop's catch block will handle this, so we just re-throw.
+                // throw err;
+                handleError(err, "CLI Error in Loop Session");
+            }
+            return;
+        }
+        // Original logic for single-command execution
+        const exitProcess = () => {
+            if (!process.exitCode) {
+                process.exit(1);
+            }
+        };
+        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.
+            // 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,
+            // it might be a direct yargs parsing error.
+            const isLikelyYargsInternalError = err.message && // Ensure err.message exists
+                !err.message.includes("Authentication error") &&
+                !err.message.includes("Network error") &&
+                !err.message.includes("Authorization error") &&
+                !err.message.includes("Permission denied") && // from config export
+                !err.message.includes("Invalid or unparseable JSON"); // from config import
+            if (!alreadyExitedByHandleError) {
+                process.stderr.write(chalk.red(`CLI Error: ${err.message || msg || "An unexpected error occurred."}\n`));
+                // If it's a yargs internal parsing error, show help.
+                if (isLikelyYargsInternalError && msg) {
+                    yargsInstance.showHelp((h) => {
+                        process.stderr.write(h + "\n");
+                        exitProcess();
+                    });
+                    return;
+                }
+                exitProcess();
+            }
+            return; // Exit was already called or error handled
+        }
+        // Yargs parsing/validation error (msg is present, err is null)
+        if (msg) {
+            let processedMsg = `Error: ${msg}\n`;
+            if (msg.includes("Not enough non-option arguments") ||
+                msg.includes("Missing required argument") ||
+                msg.includes("Unknown command")) {
+                process.stderr.write(chalk.red(processedMsg)); // Print error first
+                yargsInstance.showHelp((h) => {
+                    process.stderr.write("\n" + h + "\n");
+                    exitProcess();
+                });
+                return; // Exit happens in callback
+            }
+            else if (msg.includes("Unknown argument") ||
+                msg.includes("Invalid values")) {
+                processedMsg = `Error: ${msg}\nUse --help to see available options.\n`;
+            }
+            process.stderr.write(chalk.red(processedMsg));
+        }
+        else {
+            // No specific message, but failure occurred (e.g. demandCommand failed silently)
+            yargsInstance.showHelp((h) => {
+                process.stderr.write(h + "\n");
+                exitProcess();
+            });
+            return; // Exit happens in callback
+        }
+        exitProcess(); // Default exit
+    })
+        // Generate Command (Primary) - Using CLICommandFactory
+        .command(CLICommandFactory.createGenerateCommand())
+        // Stream Text Command - Using CLICommandFactory
+        .command(CLICommandFactory.createStreamCommand())
+        // Batch Processing Command - Using CLICommandFactory
+        .command(CLICommandFactory.createBatchCommand())
+        // Provider Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createProviderCommands())
+        // Status command alias - Using CLICommandFactory
+        .command(CLICommandFactory.createStatusCommand())
+        // Models Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createModelsCommands())
+        // MCP Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createMCPCommands())
+        // Discover Command - Using CLICommandFactory
+        .command(CLICommandFactory.createDiscoverCommand())
+        // Configuration Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createConfigCommands())
+        // Memory Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createMemoryCommands())
+        // Get Best Provider Command - Using CLICommandFactory
+        .command(CLICommandFactory.createBestProviderCommand())
+        // Validate Command (alias for config validate)
+        .command(CLICommandFactory.createValidateCommand())
+        // Completion Command - Using CLICommandFactory
+        .command(CLICommandFactory.createCompletionCommand())
+        // Ollama Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createOllamaCommands())
+        // SageMaker Command Group - Using CLICommandFactory
+        .command(CLICommandFactory.createSageMakerCommands())
+        // Loop Command - Using CLICommandFactory
+        .command(CLICommandFactory.createLoopCommand())
+        // Setup Commands - Using SetupCommandFactory
+        .command(SetupCommandFactory.createSetupCommands())); // Close the main return statement
+}

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

@@ -12,6 +12,7 @@ export interface EnvUpdateResult {
     updated: string[];
     added: string[];
     unchanged: string[];
+    deleted: string[];
 }
 /**
  * Create a timestamped backup of the existing .env file
@@ -24,11 +25,11 @@ export declare function parseEnvFile(content: string): Record<string, string>;
 /**
  * Generate .env file content from key-value pairs
  */
-export declare function generateEnvContent(envVars: Record<string, string>, existingContent?: string): string;
+export declare function generateEnvContent(envVars: Record<string, string>, existingContent?: string, keysToDelete?: string[]): string;
 /**
  * Update .env file with new environment variables
  */
-export declare function updateEnvFile(newVars: Record<string, string>, envPath?: string, createBackup?: boolean): EnvUpdateResult;
+export declare function updateEnvFile(newVars: Record<string, string>, envPath?: string, createBackup?: boolean, keysToDelete?: string[]): EnvUpdateResult;
 /**
  * Display environment file update summary
  */

package/dist/cli/utils/envManager.js

@@ -59,7 +59,7 @@ export function parseEnvFile(content) {
 /**
  * Generate .env file content from key-value pairs
  */
-export function generateEnvContent(envVars, existingContent) {
+export function generateEnvContent(envVars, existingContent, keysToDelete = []) {
     const lines = [];
     const _existingVars = existingContent ? parseEnvFile(existingContent) : {};
     const processedKeys = new Set();
@@ -79,6 +79,10 @@ export function generateEnvContent(envVars, existingContent) {
                 continue;
             }
             const key = trimmedLine.substring(0, equalIndex).trim();
+            // Skip keys that should be deleted
+            if (keysToDelete.includes(key)) {
+                continue; // Skip this line - delete the key
+            }
             if (Object.prototype.hasOwnProperty.call(envVars, key)) {
                 // Update existing variable
                 lines.push(`${key}=${envVars[key]}`);
@@ -108,12 +112,13 @@ export function generateEnvContent(envVars, existingContent) {
 /**
  * Update .env file with new environment variables
  */
-export function updateEnvFile(newVars, envPath = ".env", createBackup = true) {
+export function updateEnvFile(newVars, envPath = ".env", createBackup = true, keysToDelete = []) {
     const result = {
         backup: { existed: false },
         updated: [],
         added: [],
         unchanged: [],
+        deleted: [],
     };
     // Create backup if requested and file exists
     if (createBackup) {
@@ -126,6 +131,12 @@ export function updateEnvFile(newVars, envPath = ".env", createBackup = true) {
         existingContent = fs.readFileSync(envPath, "utf8");
         _existingVars = parseEnvFile(existingContent);
     }
+    // Track keys to be deleted
+    for (const key of keysToDelete) {
+        if (Object.prototype.hasOwnProperty.call(_existingVars, key)) {
+            result.deleted.push(key);
+        }
+    }
     // Categorize changes
     for (const [key, value] of Object.entries(newVars)) {
         if (Object.prototype.hasOwnProperty.call(_existingVars, key)) {
@@ -141,7 +152,7 @@ export function updateEnvFile(newVars, envPath = ".env", createBackup = true) {
         }
     }
     // Generate new content
-    const newContent = generateEnvContent(newVars, existingContent);
+    const newContent = generateEnvContent(newVars, existingContent, keysToDelete);
     // Write updated file
     try {
         fs.writeFileSync(envPath, newContent, "utf8");
@@ -167,10 +178,13 @@ export function displayEnvUpdateSummary(result, quiet = false) {
     if (result.updated.length > 0) {
         logger.always(chalk.yellow(`🔄 Updated ${result.updated.length} existing variables: ${result.updated.join(", ")}`));
     }
+    if (result.deleted.length > 0) {
+        logger.always(chalk.red(`🗑️ Deleted ${result.deleted.length} variables: ${result.deleted.join(", ")}`));
+    }
     if (result.unchanged.length > 0) {
         logger.always(chalk.gray(`✓ ${result.unchanged.length} variables unchanged: ${result.unchanged.join(", ")}`));
     }
-    const totalChanges = result.added.length + result.updated.length;
+    const totalChanges = result.added.length + result.updated.length + result.deleted.length;
     if (totalChanges > 0) {
         logger.always(chalk.blue(`📝 Environment file updated with ${totalChanges} changes`));
     }

package/dist/cli/utils/ollamaUtils.js

@@ -126,6 +126,9 @@ export class OllamaUtils {
                         stdio: "ignore",
                         detached: true,
                     });
+                    child.on("error", (err) => {
+                        logger.error("Error starting Ollama serve process:", err);
+                    });
                     child.unref();
                     logger.always(chalk.green("✅ Ollama service started"));
                 }
@@ -141,6 +144,9 @@ export class OllamaUtils {
                         stdio: "ignore",
                         detached: true,
                     });
+                    child.on("error", (err) => {
+                        logger.error("Error starting Ollama serve process:", err);
+                    });
                     child.unref();
                     logger.always(chalk.green("✅ Ollama service started"));
                 }

package/dist/config/{conversationMemoryConfig.d.ts → conversationMemory.d.ts}

@@ -2,7 +2,7 @@
  * Conversation Memory Configuration
  * Provides default values for conversation memory feature with environment variable support
  */
-import type { ConversationMemoryConfig } from "../types/conversationTypes.js";
+import type { ConversationMemoryConfig } from "../types/conversation.js";
 /**
  * Default maximum number of turns per session
  */

package/dist/core/baseProvider.js

@@ -100,7 +100,15 @@ export class BaseProvider {
                                         yield { content: buffer };
                                         buffer = "";
                                         // Small delay to simulate streaming (1-10ms)
-                                        await new Promise((resolve) => setTimeout(resolve, Math.random() * 9 + 1));
+                                        await new Promise((resolve, reject) => {
+                                            const timeoutId = setTimeout(resolve, Math.random() * 9 + 1);
+                                            // Handle potential timeout issues
+                                            if (!timeoutId) {
+                                                reject(new Error("Failed to create timeout"));
+                                            }
+                                        }).catch((err) => {
+                                            logger.error("Error in streaming delay:", err);
+                                        });
                                     }
                                 }
                                 // Yield all remaining content
@@ -217,8 +225,14 @@ export class BaseProvider {
             // Accumulate the streamed content
             let accumulatedContent = "";
             // Wait for the stream to complete and accumulate content
-            for await (const chunk of streamResult.textStream) {
-                accumulatedContent += chunk;
+            try {
+                for await (const chunk of streamResult.textStream) {
+                    accumulatedContent += chunk;
+                }
+            }
+            catch (streamError) {
+                logger.error(`Error reading text stream for ${this.providerName}:`, streamError);
+                throw streamError;
             }
             // Get the final result - this should include usage, toolCalls, etc.
             const usage = await streamResult.usage;

package/dist/core/conversationMemoryFactory.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Conversation Memory Factory for NeuroLink
+ * Creates appropriate conversation memory manager based on configuration
+ */
+import type { ConversationMemoryConfig, RedisStorageConfig } from "../types/conversation.js";
+import { ConversationMemoryManager } from "./conversationMemoryManager.js";
+import { RedisConversationMemoryManager } from "./redisConversationMemoryManager.js";
+/**
+ * Configuration for memory storage type
+ */
+export type StorageType = "memory" | "redis";
+/**
+ * Creates a conversation memory manager based on configuration
+ */
+export declare function createConversationMemoryManager(config: ConversationMemoryConfig, storageType?: StorageType, redisConfig?: RedisStorageConfig): ConversationMemoryManager | RedisConversationMemoryManager;
+/**
+ * Get storage type from environment variable or configuration
+ */
+export declare function getStorageType(): StorageType;
+/**
+ * Get Redis configuration from environment variables
+ */
+export declare function getRedisConfigFromEnv(): RedisStorageConfig;