@juspay/neurolink 7.33.3 → 7.34.0

package/dist/cli/index.js

@@ -5,15 +5,8 @@
  * Professional CLI experience with minimal maintenance overhead.
  * Features: Spinners, colors, batch processing, provider testing, rich help
  */
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
+import { initializeCliParser } from "./parser.js";
 import chalk from "chalk";
-import _fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { CLICommandFactory } from "./factories/commandFactory.js";
-import { AuthenticationError, AuthorizationError, NetworkError, RateLimitError, } from "../lib/types/errors.js";
-import { logger } from "../lib/utils/logger.js";
 // Clean up pnpm-specific environment variables that cause npm warnings
 // These variables are set by pnpm but cause "Unknown env config" warnings in npm
 if (process.env.npm_config_verify_deps_before_run) {
@@ -22,11 +15,6 @@ if (process.env.npm_config_verify_deps_before_run) {
 if (process.env.npm_config__jsr_registry) {
     delete process.env.npm_config__jsr_registry;
 }
-// Get version from package.json
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const packageJson = JSON.parse(_fs.readFileSync(path.resolve(__dirname, "../../package.json"), "utf-8"));
-const cliVersion = packageJson.version;
 // Load environment variables from .env file
 try {
     // Try to import and configure dotenv
@@ -37,158 +25,8 @@ 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)
-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"));
-        logger.error(chalk.yellow("💡 Or set Google Vertex AI credentials: export GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json"));
-        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) {
-        logger.error(chalk.yellow("💡 Try again in a few moments or use --provider vertex"));
-    }
-    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) {
-        logger.error(chalk.yellow("💡 Check your internet connection and the provider's status page."));
-    }
-    process.exit(1);
-}
-// Manual pre-validation for unknown flags
-const args = hideBin(process.argv);
 // Enhanced CLI with Professional UX
-const cli = yargs(args)
-    .scriptName("neurolink")
-    .usage("Usage: $0 <command> [options]")
-    .version(cliVersion)
-    .help()
-    .alias("h", "help")
-    .alias("V", "version")
-    .strictOptions()
-    .strictCommands()
-    .demandCommand(1, "")
-    .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) => {
-    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())
-    // 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());
+const cli = initializeCliParser();
 // Execute CLI
 (async () => {
     try {
@@ -201,3 +39,10 @@ const cli = yargs(args)
         process.exit(1);
     }
 })();
+// Cleanup on exit
+process.on("SIGINT", () => {
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    process.exit(0);
+});

package/dist/cli/loop/optionsSchema.d.ts

@@ -0,0 +1,15 @@
+import { type TextGenerationOptions } from "../../lib/core/types.js";
+/**
+ * Defines the schema for a session variable or a generation option.
+ */
+export interface OptionSchema {
+    type: "string" | "boolean" | "number";
+    description: string;
+    allowedValues?: string[];
+}
+/**
+ * Master schema for all text generation options.
+ * This object provides metadata for validation and help text in the CLI loop.
+ * It is derived from the main TextGenerationOptions interface to ensure consistency.
+ */
+export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria">, OptionSchema>;

package/dist/cli/loop/optionsSchema.js

@@ -0,0 +1,59 @@
+import { AIProviderName, } from "../../lib/core/types.js";
+/**
+ * Master schema for all text generation options.
+ * This object provides metadata for validation and help text in the CLI loop.
+ * It is derived from the main TextGenerationOptions interface to ensure consistency.
+ */
+export const textGenerationOptionsSchema = {
+    provider: {
+        type: "string",
+        description: "The AI provider to use.",
+        allowedValues: Object.values(AIProviderName)
+            .filter((p) => typeof p === "string")
+            .filter((p) => p !== AIProviderName.AUTO),
+    },
+    model: {
+        type: "string",
+        description: "The specific model to use from the provider.",
+    },
+    temperature: {
+        type: "number",
+        description: "Controls randomness of the output (e.g., 0.2, 0.8).",
+    },
+    maxTokens: {
+        type: "number",
+        description: "The maximum number of tokens to generate.",
+    },
+    systemPrompt: {
+        type: "string",
+        description: "The system prompt to guide the AI's behavior.",
+    },
+    timeout: {
+        type: "number",
+        description: "Timeout for the generation request in milliseconds.",
+    },
+    disableTools: {
+        type: "boolean",
+        description: "Disable all tool usage for the AI.",
+    },
+    maxSteps: {
+        type: "number",
+        description: "Maximum number of tool execution steps.",
+    },
+    enableAnalytics: {
+        type: "boolean",
+        description: "Enable or disable analytics for responses.",
+    },
+    enableEvaluation: {
+        type: "boolean",
+        description: "Enable or disable AI-powered evaluation of responses.",
+    },
+    evaluationDomain: {
+        type: "string",
+        description: 'Domain expertise for evaluation (e.g., "general AI assistant").',
+    },
+    toolUsageContext: {
+        type: "string",
+        description: "Context about tools/MCPs used in the interaction.",
+    },
+};

package/dist/cli/loop/session.d.ts

@@ -0,0 +1,15 @@
+import type { Argv } from "yargs";
+import type { ConversationMemoryConfig } from "../../lib/types/conversation.js";
+export declare class LoopSession {
+    private conversationMemoryConfig?;
+    private initializeCliParser;
+    private isRunning;
+    private sessionId?;
+    private sessionVariablesSchema;
+    constructor(initializeCliParser: () => Argv, conversationMemoryConfig?: ConversationMemoryConfig | undefined);
+    start(): Promise<void>;
+    private handleSessionCommands;
+    private parseValue;
+    private showHelp;
+    private showSetHelp;
+}

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<{}>;