@juspay/neurolink 7.0.0 → 7.2.0

package/dist/cli/factories/commandFactory.js

@@ -1,97 +1,492 @@
 import { NeuroLink } from "../../lib/neurolink.js";
+import { ContextFactory, } from "../../lib/types/contextTypes.js";
+import { ModelsCommandFactory } from "../commands/models.js";
+import { MCPCommandFactory } from "../commands/mcp.js";
 import ora from "ora";
 import chalk from "chalk";
 import { logger } from "../../lib/utils/logger.js";
+import fs from "fs";
 /**
  * CLI Command Factory for generate commands
  */
 export class CLICommandFactory {
+    // Common options available on all commands
+    static commonOptions = {
+        // Core generation options
+        provider: {
+            choices: [
+                "auto",
+                "openai",
+                "bedrock",
+                "vertex",
+                "googleVertex",
+                "anthropic",
+                "azure",
+                "google-ai",
+                "huggingface",
+                "ollama",
+                "mistral",
+            ],
+            default: "auto",
+            description: "AI provider to use (auto-selects best available)",
+            alias: "p",
+        },
+        model: {
+            type: "string",
+            description: "Specific model to use (e.g. gemini-2.5-pro, gemini-2.5-flash)",
+            alias: "m",
+        },
+        temperature: {
+            type: "number",
+            default: 0.7,
+            description: "Creativity level (0.0 = focused, 1.0 = creative)",
+            alias: "t",
+        },
+        maxTokens: {
+            type: "number",
+            default: 1000,
+            description: "Maximum tokens to generate",
+            alias: "max",
+        },
+        system: {
+            type: "string",
+            description: "System prompt to guide AI behavior",
+            alias: "s",
+        },
+        // Output control options
+        format: {
+            choices: ["text", "json", "table"],
+            default: "text",
+            alias: ["f", "output-format"],
+            description: "Output format",
+        },
+        output: {
+            type: "string",
+            description: "Save output to file",
+            alias: "o",
+        },
+        // Behavior control options
+        timeout: {
+            type: "number",
+            default: 120,
+            description: "Maximum execution time in seconds",
+        },
+        delay: {
+            type: "number",
+            description: "Delay between operations (ms)",
+        },
+        // Tools & features options
+        disableTools: {
+            type: "boolean",
+            default: false,
+            description: "Disable MCP tool integration (tools enabled by default)",
+        },
+        enableAnalytics: {
+            type: "boolean",
+            default: false,
+            description: "Enable usage analytics collection",
+        },
+        enableEvaluation: {
+            type: "boolean",
+            default: false,
+            description: "Enable AI response quality evaluation",
+        },
+        evaluationDomain: {
+            type: "string",
+            description: "Domain expertise for evaluation (e.g., 'AI coding assistant', 'Customer service expert')",
+        },
+        toolUsageContext: {
+            type: "string",
+            description: "Tool usage context for evaluation (e.g., 'Used sales-data MCP tools')",
+        },
+        lighthouseStyle: {
+            type: "boolean",
+            default: false,
+            description: "Use Lighthouse-compatible domain-aware evaluation",
+        },
+        context: {
+            type: "string",
+            description: "JSON context object for custom data",
+        },
+        // Debug & output options
+        debug: {
+            type: "boolean",
+            alias: ["v", "verbose"],
+            default: false,
+            description: "Enable debug mode with verbose output",
+        },
+        quiet: {
+            type: "boolean",
+            alias: "q",
+            default: false,
+            description: "Suppress non-essential output",
+        },
+        noColor: {
+            type: "boolean",
+            default: false,
+            description: "Disable colored output (useful for CI/scripts)",
+        },
+        configFile: {
+            type: "string",
+            description: "Path to custom configuration file",
+        },
+    };
+    // Helper method to build options for commands
+    static buildOptions(yargs, additionalOptions = {}) {
+        return yargs.options({
+            ...this.commonOptions,
+            ...additionalOptions,
+        });
+    }
+    // Helper method to process common options
+    static processOptions(argv) {
+        // Handle noColor option by disabling chalk
+        if (argv.noColor) {
+            process.env.FORCE_COLOR = "0";
+        }
+        // Process context using ContextFactory for type-safe integration
+        let processedContext;
+        let contextConfig;
+        if (argv.context) {
+            let rawContext;
+            if (typeof argv.context === "string") {
+                try {
+                    rawContext = JSON.parse(argv.context);
+                }
+                catch (err) {
+                    const contextStr = argv.context;
+                    const truncatedJson = contextStr.length > 100
+                        ? `${contextStr.slice(0, 100)}...`
+                        : contextStr;
+                    logger.error(`Invalid JSON in --context parameter: ${err.message}. Received: ${truncatedJson}`);
+                    process.exit(1);
+                }
+            }
+            else {
+                rawContext = argv.context;
+            }
+            const validatedContext = ContextFactory.validateContext(rawContext);
+            if (validatedContext) {
+                processedContext = validatedContext;
+                // Configure context integration based on CLI usage
+                contextConfig = {
+                    mode: "prompt_prefix", // Add context as prompt prefix for CLI usage
+                    includeInPrompt: true,
+                    includeInAnalytics: true,
+                    includeInEvaluation: true,
+                    maxLength: 500, // Reasonable limit for CLI context
+                };
+            }
+            else if (argv.debug) {
+                logger.debug("Invalid context provided, skipping context integration");
+            }
+        }
+        return {
+            provider: argv.provider === "auto" ? undefined : argv.provider,
+            model: argv.model,
+            temperature: argv.temperature,
+            maxTokens: argv.maxTokens,
+            systemPrompt: argv.system,
+            timeout: argv.timeout,
+            disableTools: argv.disableTools,
+            enableAnalytics: argv.enableAnalytics,
+            enableEvaluation: argv.enableEvaluation,
+            evaluationDomain: argv.evaluationDomain,
+            toolUsageContext: argv.toolUsageContext,
+            lighthouseStyle: argv.lighthouseStyle,
+            context: processedContext,
+            contextConfig,
+            debug: argv.debug,
+            quiet: argv.quiet,
+            format: argv.format,
+            output: argv.output,
+            delay: argv.delay,
+            noColor: argv.noColor,
+            configFile: argv.configFile,
+        };
+    }
+    // Helper method to handle output
+    static handleOutput(result, options) {
+        let output;
+        if (options.format === "json") {
+            output = JSON.stringify(result, null, 2);
+        }
+        else if (options.format === "table" && Array.isArray(result)) {
+            logger.table(result);
+            return;
+        }
+        else {
+            if (typeof result === "string") {
+                output = result;
+            }
+            else if (result && typeof result === "object" && "content" in result) {
+                const generateResult = result;
+                output = generateResult.content;
+                // Add analytics display for text mode when enabled
+                if (options.enableAnalytics && generateResult.analytics) {
+                    output += this.formatAnalyticsForTextMode(generateResult);
+                }
+            }
+            else if (result && typeof result === "object" && "text" in result) {
+                output = result.text;
+            }
+            else {
+                output = JSON.stringify(result);
+            }
+        }
+        if (options.output) {
+            fs.writeFileSync(options.output, output);
+            if (!options.quiet) {
+                logger.always(`Output saved to ${options.output}`);
+            }
+        }
+        else {
+            logger.always(output);
+        }
+    }
+    // Helper method to validate token usage data
+    static isValidTokenUsage(tokens) {
+        return !!(tokens &&
+            typeof tokens === "object" &&
+            tokens !== null &&
+            typeof tokens.input === "number" &&
+            typeof tokens.output === "number" &&
+            typeof tokens.total === "number");
+    }
+    // Helper method to format analytics for text mode display
+    static formatAnalyticsForTextMode(result) {
+        if (!result.analytics) {
+            return "";
+        }
+        const analytics = result.analytics;
+        let analyticsText = "\n\n📊 Analytics:\n";
+        // Provider and model info
+        analyticsText += `   Provider: ${analytics.provider}`;
+        if (result.model) {
+            analyticsText += ` (${result.model})`;
+        }
+        analyticsText += "\n";
+        // Token usage
+        if (this.isValidTokenUsage(analytics.tokens)) {
+            const tokens = analytics.tokens;
+            analyticsText += `   Tokens: ${tokens.input} input + ${tokens.output} output = ${tokens.total} total\n`;
+        }
+        // Cost information
+        if (analytics.cost !== undefined &&
+            analytics.cost !== null &&
+            typeof analytics.cost === "number") {
+            analyticsText += `   Cost: $${analytics.cost.toFixed(5)}\n`;
+        }
+        // Response time
+        if (analytics.responseTime && typeof analytics.responseTime === "number") {
+            const timeInSeconds = (analytics.responseTime / 1000).toFixed(1);
+            analyticsText += `   Time: ${timeInSeconds}s\n`;
+        }
+        // Tools used
+        if (result.toolsUsed && result.toolsUsed.length > 0) {
+            analyticsText += `   Tools: ${result.toolsUsed.join(", ")}\n`;
+        }
+        // Context information
+        if (analytics.context &&
+            typeof analytics.context === "object" &&
+            analytics.context !== null) {
+            const contextEntries = Object.entries(analytics.context);
+            if (contextEntries.length > 0) {
+                const contextItems = contextEntries.map(([key, value]) => `${key}=${value}`);
+                analyticsText += `   Context: ${contextItems.join(", ")}\n`;
+            }
+        }
+        return analyticsText;
+    }
     /**
      * Create the new primary 'generate' command
      */
     static createGenerateCommand() {
         return {
-            command: "generate <input>",
-            describe: "Generate content using AI (primary command)",
+            command: ["generate <input>", "gen <input>"],
+            describe: "Generate content using AI providers",
             builder: (yargs) => {
-                return yargs
+                return this.buildOptions(yargs
                     .positional("input", {
-                    describe: "Text input for generation",
                     type: "string",
+                    description: "Text prompt for AI generation (or read from stdin)",
                 })
-                    .option("provider", {
-                    describe: "AI provider to use",
-                    type: "string",
-                    choices: [
-                        "google-ai",
-                        "vertex",
-                        "openai",
-                        "anthropic",
-                        "bedrock",
-                        "azure",
-                        "huggingface",
-                        "ollama",
-                        "mistral",
-                    ],
-                    default: "google-ai",
-                })
-                    .option("model", {
-                    describe: "Specific model to use",
-                    type: "string",
-                })
-                    .option("temperature", {
-                    describe: "Temperature (0-1)",
-                    type: "number",
-                })
-                    .option("max-tokens", {
-                    describe: "Maximum tokens",
-                    type: "number",
-                })
-                    .option("system-prompt", {
-                    describe: "System prompt",
+                    .example('$0 generate "Explain quantum computing"', "Basic generation")
+                    .example('$0 gen "Write a Python function" --provider openai', "Use specific provider")
+                    .example('$0 generate "Code review" -m gpt-4 -t 0.3', "Use specific model and temperature")
+                    .example('echo "Summarize this" | $0 generate', "Use stdin input")
+                    .example('$0 generate "Analyze data" --enable-analytics', "Enable usage analytics"));
+            },
+            handler: async (argv) => await this.executeGenerate(argv),
+        };
+    }
+    /**
+     * Create stream command
+     */
+    static createStreamCommand() {
+        return {
+            command: "stream <input>",
+            describe: "Stream generation in real-time",
+            builder: (yargs) => {
+                return this.buildOptions(yargs
+                    .positional("input", {
                     type: "string",
+                    description: "Text prompt for streaming (or read from stdin)",
                 })
-                    .option("timeout", {
-                    describe: "Timeout (e.g., 30s, 2m)",
+                    .example('$0 stream "Write a story about space"', "Stream a creative story")
+                    .example('$0 stream "Explain machine learning" -p anthropic', "Stream with specific provider")
+                    .example('$0 stream "Code walkthrough" --output story.txt', "Stream to file")
+                    .example('echo "Live demo" | $0 stream', "Stream from stdin"));
+            },
+            handler: async (argv) => await this.executeStream(argv),
+        };
+    }
+    /**
+     * Create batch command
+     */
+    static createBatchCommand() {
+        return {
+            command: "batch <file>",
+            describe: "Process multiple prompts from a file",
+            builder: (yargs) => {
+                return this.buildOptions(yargs
+                    .positional("file", {
                     type: "string",
+                    description: "File with prompts (one per line)",
+                    demandOption: true,
                 })
-                    .option("disable-tools", {
-                    describe: "Disable MCP tools",
-                    type: "boolean",
-                    default: false,
+                    .example("$0 batch prompts.txt", "Process prompts from file")
+                    .example("$0 batch questions.txt --format json", "Export results as JSON")
+                    .example("$0 batch tasks.txt -p vertex --delay 2000", "Use Vertex AI with 2s delay")
+                    .example("$0 batch batch.txt --output results.json", "Save results to file"));
+            },
+            handler: async (argv) => await this.executeBatch(argv),
+        };
+    }
+    /**
+     * Create provider commands
+     */
+    static createProviderCommands() {
+        return {
+            command: "provider <subcommand>",
+            describe: "Manage AI provider configurations and status",
+            builder: (yargs) => {
+                return yargs
+                    .command("status", "Check status of all configured AI providers", (y) => this.buildOptions(y)
+                    .example("$0 provider status", "Check all provider status")
+                    .example("$0 provider status --verbose", "Detailed provider diagnostics")
+                    .example("$0 provider status --quiet", "Minimal status output"), (argv) => CLICommandFactory.executeProviderStatus(argv))
+                    .demandCommand(1, "Please specify a provider subcommand");
+            },
+            handler: () => { }, // No-op handler as subcommands handle everything
+        };
+    }
+    /**
+     * Create status command (alias for provider status)
+     */
+    static createStatusCommand() {
+        return {
+            command: "status",
+            describe: "Check AI provider connectivity and performance (alias for provider status)",
+            builder: (yargs) => this.buildOptions(yargs)
+                .example("$0 status", "Quick provider status check")
+                .example("$0 status --verbose", "Detailed connectivity diagnostics")
+                .example("$0 status --format json", "Export status as JSON"),
+            handler: async (argv) => await CLICommandFactory.executeProviderStatus(argv),
+        };
+    }
+    /**
+     * Create models commands
+     */
+    static createModelsCommands() {
+        return ModelsCommandFactory.createModelsCommands();
+    }
+    /**
+     * Create MCP commands
+     */
+    static createMCPCommands() {
+        return MCPCommandFactory.createMCPCommands();
+    }
+    /**
+     * Create discover command
+     */
+    static createDiscoverCommand() {
+        return MCPCommandFactory.createDiscoverCommand();
+    }
+    /**
+     * Create config commands
+     */
+    static createConfigCommands() {
+        return {
+            command: "config <subcommand>",
+            describe: "Manage NeuroLink configuration",
+            builder: (yargs) => {
+                return yargs
+                    .command("init", "Interactive configuration setup wizard", (y) => this.buildOptions(y), async (argv) => {
+                    const { configManager } = await import("../commands/config.js");
+                    await configManager.initInteractive();
                 })
-                    .option("enable-analytics", {
-                    describe: "Enable usage analytics",
-                    type: "boolean",
-                    default: false,
+                    .command("show", "Display current configuration", (y) => this.buildOptions(y), async (argv) => {
+                    const { configManager } = await import("../commands/config.js");
+                    configManager.showConfig();
                 })
-                    .option("enable-evaluation", {
-                    describe: "Enable AI quality evaluation",
-                    type: "boolean",
-                    default: false,
+                    .command("validate", "Validate current configuration", (y) => this.buildOptions(y), async (argv) => {
+                    const { configManager } = await import("../commands/config.js");
+                    const result = configManager.validateConfig();
+                    if (result.valid) {
+                        logger.always(chalk.green("✅ Configuration is valid"));
+                    }
+                    else {
+                        logger.always(chalk.red("❌ Configuration has errors:"));
+                        result.errors.forEach((error) => logger.always(`  • ${error}`));
+                        process.exit(1);
+                    }
                 })
-                    .option("output-format", {
-                    describe: "Output format",
-                    type: "string",
-                    choices: ["text", "structured", "json"],
-                    default: "text",
-                    alias: "format",
+                    .command("reset", "Reset configuration to defaults", (y) => this.buildOptions(y), async (argv) => {
+                    const { configManager } = await import("../commands/config.js");
+                    configManager.resetConfig();
                 })
-                    .option("debug", {
-                    describe: "Enable debug output",
-                    type: "boolean",
-                    default: false,
-                });
+                    .command("export", "Export current configuration", (y) => this.buildOptions(y), (argv) => this.executeConfigExport(argv))
+                    .demandCommand(1, "");
             },
-            handler: async (argv) => await CLICommandFactory.executeGenerate(argv),
+            handler: () => { }, // No-op handler as subcommands handle everything
+        };
+    }
+    /**
+     * Create get-best-provider command
+     */
+    static createBestProviderCommand() {
+        return {
+            command: "get-best-provider",
+            describe: "Show the best available AI provider",
+            builder: (yargs) => this.buildOptions(yargs)
+                .example("$0 get-best-provider", "Get best available provider")
+                .example("$0 get-best-provider --format json", "Get provider as JSON")
+                .example("$0 get-best-provider --quiet", "Just the provider name"),
+            handler: async (argv) => await this.executeGetBestProvider(argv),
+        };
+    }
+    /**
+     * Create completion command
+     */
+    static createCompletionCommand() {
+        return {
+            command: "completion",
+            describe: "Generate shell completion script",
+            builder: (yargs) => this.buildOptions(yargs)
+                .example("$0 completion", "Generate shell completion")
+                .example("$0 completion > ~/.neurolink-completion.sh", "Save completion script")
+                .example("source ~/.neurolink-completion.sh", "Enable completions (bash)")
+                .epilogue("Add the completion script to your shell profile for persistent completions"),
+            handler: async (argv) => await this.executeCompletion(argv),
         };
     }
     /**
      * Execute provider status command
      */
-    async executeProviderStatus(argv) {
+    static async executeProviderStatus(argv) {
         if (argv.verbose && !argv.quiet) {
-            console.log(chalk.yellow("ℹ️ Verbose mode enabled. Displaying detailed status.\n"));
+            logger.always(chalk.yellow("ℹ️ Verbose mode enabled. Displaying detailed status.\n"));
         }
         const spinner = argv.quiet
             ? null
@@ -99,7 +494,7 @@ export class CLICommandFactory {
         try {
             // Use SDK's provider diagnostic method instead of manual testing
             const sdk = new NeuroLink();
-            const results = await sdk.getProviderStatus();
+            const results = await sdk.getProviderStatus({ quiet: !!argv.quiet });
             if (spinner) {
                 const working = results.filter((r) => r.status === "working").length;
                 const configured = results.filter((r) => r.configured).length;
@@ -114,21 +509,21 @@ export class CLICommandFactory {
                         : chalk.gray("⚪ Not configured");
                 const time = result.responseTime ? ` (${result.responseTime}ms)` : "";
                 const model = result.model ? ` [${result.model}]` : "";
-                console.log(`${result.provider}: ${status}${time}${model}`);
+                logger.always(`${result.provider}: ${status}${time}${model}`);
                 if (argv.verbose && result.error) {
-                    console.log(`  Error: ${chalk.red(result.error)}`);
+                    logger.always(`  Error: ${chalk.red(result.error)}`);
                 }
             }
             if (argv.verbose && !argv.quiet) {
-                console.log(chalk.blue("\n📋 Detailed Results:"));
-                console.log(JSON.stringify(results, null, 2));
+                logger.always(chalk.blue("\n📋 Detailed Results:"));
+                logger.always(JSON.stringify(results, null, 2));
             }
         }
         catch (error) {
             if (spinner) {
                 spinner.fail("Provider status check failed");
             }
-            console.error(chalk.red("Error checking provider status:"), error);
+            logger.error(chalk.red("Error checking provider status:"), error);
             process.exit(1);
         }
     }
@@ -136,32 +531,73 @@ export class CLICommandFactory {
      * Execute the generate command
      */
     static async executeGenerate(argv) {
-        const spinner = ora("Generating content...").start();
+        // Handle stdin input if no input provided
+        if (!argv.input && !process.stdin.isTTY) {
+            let stdinData = "";
+            process.stdin.setEncoding("utf8");
+            for await (const chunk of process.stdin) {
+                stdinData += chunk;
+            }
+            argv.input = stdinData.trim();
+            if (!argv.input) {
+                throw new Error("No input received from stdin");
+            }
+        }
+        else if (!argv.input) {
+            throw new Error('Input required. Use: neurolink generate "your prompt" or echo "prompt" | neurolink generate');
+        }
+        const options = this.processOptions(argv);
+        const spinner = argv.quiet ? null : ora("🤖 Generating text...").start();
         try {
+            // Add delay if specified
+            if (options.delay) {
+                await new Promise((resolve) => setTimeout(resolve, options.delay));
+            }
+            // Process context if provided
+            let inputText = argv.input;
+            let contextMetadata;
+            if (options.context && options.contextConfig) {
+                const processedContextResult = ContextFactory.processContext(options.context, options.contextConfig);
+                // Integrate context into prompt if configured
+                if (processedContextResult.processedContext) {
+                    inputText = processedContextResult.processedContext + inputText;
+                }
+                // Add context metadata for analytics
+                contextMetadata = {
+                    ...ContextFactory.extractAnalyticsContext(options.context),
+                    contextMode: processedContextResult.config.mode,
+                    contextTruncated: processedContextResult.metadata.truncated,
+                };
+                if (options.debug) {
+                    logger.debug("Context processed:", {
+                        mode: processedContextResult.config.mode,
+                        truncated: processedContextResult.metadata.truncated,
+                        processingTime: processedContextResult.metadata.processingTime,
+                    });
+                }
+            }
             const sdk = new NeuroLink();
-            const outputFormat = argv.outputFormat || argv.format || "text";
             const result = await sdk.generate({
-                input: { text: argv.input },
-                output: { format: outputFormat },
-                provider: argv.provider,
-                model: argv.model,
-                temperature: argv.temperature,
-                maxTokens: argv.maxTokens,
-                systemPrompt: argv.systemPrompt,
-                timeout: argv.timeout,
-                enableAnalytics: argv.enableAnalytics,
-                enableEvaluation: argv.enableEvaluation,
+                input: { text: inputText },
+                provider: options.provider,
+                model: options.model,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens,
+                systemPrompt: options.systemPrompt,
+                timeout: options.timeout,
+                disableTools: options.disableTools,
+                enableAnalytics: options.enableAnalytics,
+                enableEvaluation: options.enableEvaluation,
+                evaluationDomain: options.evaluationDomain,
+                toolUsageContext: options.toolUsageContext,
+                context: contextMetadata,
             });
-            spinner.succeed("Content generated successfully!");
-            // Handle different output formats
-            if (outputFormat === "json") {
-                console.log(JSON.stringify(result, null, 2));
-            }
-            else {
-                console.log("\n" + chalk.cyan("Generated Content:"));
-                console.log(result.content);
+            if (spinner) {
+                spinner.succeed(chalk.green("✅ Text generated successfully!"));
             }
-            if (argv.debug) {
+            // Handle output with universal formatting
+            this.handleOutput(result, options);
+            if (options.debug) {
                 logger.debug("\n" + chalk.yellow("Debug Information:"));
                 logger.debug("Provider:", result.provider);
                 logger.debug("Model:", result.model);
@@ -172,13 +608,325 @@ export class CLICommandFactory {
                     logger.debug("Evaluation:", JSON.stringify(result.evaluation, null, 2));
                 }
             }
-            // Exit successfully
             process.exit(0);
         }
         catch (error) {
-            spinner.fail("Generation failed");
-            console.error(chalk.red("Error:"), error);
+            if (spinner) {
+                spinner.fail();
+            }
+            logger.error(chalk.red(`❌ Generation failed: ${error.message}`));
+            if (options.debug) {
+                logger.error(chalk.gray(error.stack));
+            }
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute the stream command
+     */
+    static async executeStream(argv) {
+        // Handle stdin input if no input provided
+        if (!argv.input && !process.stdin.isTTY) {
+            let stdinData = "";
+            process.stdin.setEncoding("utf8");
+            for await (const chunk of process.stdin) {
+                stdinData += chunk;
+            }
+            argv.input = stdinData.trim();
+            if (!argv.input) {
+                throw new Error("No input received from stdin");
+            }
+        }
+        else if (!argv.input) {
+            throw new Error('Input required. Use: neurolink stream "your prompt" or echo "prompt" | neurolink stream');
+        }
+        const options = this.processOptions(argv);
+        if (!options.quiet) {
+            logger.always(chalk.blue("🔄 Streaming..."));
+        }
+        try {
+            // Add delay if specified
+            if (options.delay) {
+                await new Promise((resolve) => setTimeout(resolve, options.delay));
+            }
+            // Process context if provided (same as generate command)
+            let inputText = argv.input;
+            let contextMetadata;
+            if (options.context && options.contextConfig) {
+                const processedContextResult = ContextFactory.processContext(options.context, options.contextConfig);
+                // Integrate context into prompt if configured
+                if (processedContextResult.processedContext) {
+                    inputText = processedContextResult.processedContext + inputText;
+                }
+                // Add context metadata for analytics
+                contextMetadata = {
+                    ...ContextFactory.extractAnalyticsContext(options.context),
+                    contextMode: processedContextResult.config.mode,
+                    contextTruncated: processedContextResult.metadata.truncated,
+                };
+                if (options.debug) {
+                    logger.debug("Context processed for streaming:", {
+                        mode: processedContextResult.config.mode,
+                        truncated: processedContextResult.metadata.truncated,
+                        processingTime: processedContextResult.metadata.processingTime,
+                    });
+                }
+            }
+            const sdk = new NeuroLink();
+            const stream = await sdk.stream({
+                input: { text: inputText },
+                provider: options.provider,
+                model: options.model,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens,
+                systemPrompt: options.systemPrompt,
+                timeout: options.timeout,
+                disableTools: options.disableTools,
+                enableAnalytics: options.enableAnalytics,
+                enableEvaluation: options.enableEvaluation,
+                context: contextMetadata,
+            });
+            let fullContent = "";
+            // Process the stream
+            for await (const chunk of stream.stream) {
+                if (options.delay && options.delay > 0) {
+                    // Demo mode - add delay between chunks
+                    await new Promise((resolve) => setTimeout(resolve, options.delay));
+                }
+                process.stdout.write(chunk.content);
+                fullContent += chunk.content;
+            }
+            if (!options.quiet) {
+                process.stdout.write("\n");
+            }
+            // 🔧 NEW: Display analytics and evaluation after streaming (similar to generate command)
+            if (options.enableAnalytics && stream.analytics) {
+                const resolvedAnalytics = await (stream.analytics instanceof Promise
+                    ? stream.analytics
+                    : Promise.resolve(stream.analytics));
+                const streamAnalytics = {
+                    success: true,
+                    content: fullContent,
+                    analytics: resolvedAnalytics,
+                    model: stream.model,
+                    toolsUsed: stream.toolCalls?.map((tc) => tc.toolName) || [],
+                };
+                const analyticsDisplay = this.formatAnalyticsForTextMode(streamAnalytics);
+                logger.always(analyticsDisplay);
+            }
+            // 🔧 NEW: Display evaluation after streaming
+            if (options.enableEvaluation && stream.evaluation) {
+                const resolvedEvaluation = await (stream.evaluation instanceof Promise
+                    ? stream.evaluation
+                    : Promise.resolve(stream.evaluation));
+                logger.always(chalk.blue("\n📊 Response Evaluation:"));
+                logger.always(`   Relevance: ${resolvedEvaluation.relevance}/10`);
+                logger.always(`   Accuracy: ${resolvedEvaluation.accuracy}/10`);
+                logger.always(`   Completeness: ${resolvedEvaluation.completeness}/10`);
+                logger.always(`   Overall: ${resolvedEvaluation.overall}/10`);
+                if (resolvedEvaluation.reasoning) {
+                    logger.always(`   Reasoning: ${resolvedEvaluation.reasoning}`);
+                }
+            }
+            // Handle output file if specified
+            if (options.output) {
+                fs.writeFileSync(options.output, fullContent);
+                if (!options.quiet) {
+                    logger.always(`\nOutput saved to ${options.output}`);
+                }
+            }
+            // 🔧 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));
+                }
+            }
+            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);
+        }
+    }
+    /**
+     * Execute the batch command
+     */
+    static async executeBatch(argv) {
+        const options = this.processOptions(argv);
+        const spinner = options.quiet ? null : ora().start();
+        try {
+            if (!argv.file) {
+                throw new Error("No file specified");
+            }
+            if (!fs.existsSync(argv.file)) {
+                throw new Error(`File not found: ${argv.file}`);
+            }
+            const buffer = fs.readFileSync(argv.file);
+            const prompts = buffer
+                .toString("utf8")
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean);
+            if (prompts.length === 0) {
+                throw new Error("No prompts found in file");
+            }
+            if (spinner) {
+                spinner.text = `📦 Processing ${prompts.length} prompts...`;
+            }
+            else if (!options.quiet) {
+                logger.always(chalk.blue(`📦 Processing ${prompts.length} prompts...\n`));
+            }
+            const results = [];
+            const sdk = new NeuroLink();
+            for (let i = 0; i < prompts.length; i++) {
+                if (spinner) {
+                    spinner.text = `Processing ${i + 1}/${prompts.length}: ${prompts[i].substring(0, 30)}...`;
+                }
+                try {
+                    // Process context for each batch item
+                    let inputText = prompts[i];
+                    let contextMetadata;
+                    if (options.context && options.contextConfig) {
+                        const processedContextResult = ContextFactory.processContext(options.context, options.contextConfig);
+                        if (processedContextResult.processedContext) {
+                            inputText = processedContextResult.processedContext + inputText;
+                        }
+                        contextMetadata = {
+                            ...ContextFactory.extractAnalyticsContext(options.context),
+                            contextMode: processedContextResult.config.mode,
+                            contextTruncated: processedContextResult.metadata.truncated,
+                            batchIndex: i,
+                        };
+                    }
+                    const result = await sdk.generate({
+                        input: { text: inputText },
+                        provider: options.provider,
+                        model: options.model,
+                        temperature: options.temperature,
+                        maxTokens: options.maxTokens,
+                        systemPrompt: options.systemPrompt,
+                        timeout: options.timeout,
+                        disableTools: options.disableTools,
+                        enableAnalytics: options.enableAnalytics,
+                        enableEvaluation: options.enableEvaluation,
+                        context: contextMetadata,
+                    });
+                    results.push({ prompt: prompts[i], response: result.content });
+                    if (spinner) {
+                        spinner.render();
+                    }
+                }
+                catch (error) {
+                    results.push({
+                        prompt: prompts[i],
+                        error: error.message,
+                    });
+                    if (spinner) {
+                        spinner.render();
+                    }
+                }
+                // Add delay between requests
+                if (i < prompts.length - 1) {
+                    await new Promise((resolve) => setTimeout(resolve, options.delay || 1000));
+                }
+            }
+            if (spinner) {
+                spinner.succeed(chalk.green("✅ Batch processing complete!"));
+            }
+            // Handle output with universal formatting
+            this.handleOutput(results, options);
+            process.exit(0);
+        }
+        catch (error) {
+            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);
         }
     }
+    /**
+     * Execute config export command
+     */
+    static async executeConfigExport(argv) {
+        const options = this.processOptions(argv);
+        try {
+            const config = {
+                providers: {
+                    openai: !!process.env.OPENAI_API_KEY,
+                    bedrock: !!(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY),
+                    vertex: !!(process.env.GOOGLE_APPLICATION_CREDENTIALS ||
+                        process.env.GOOGLE_SERVICE_ACCOUNT_KEY),
+                    anthropic: !!process.env.ANTHROPIC_API_KEY,
+                    azure: !!(process.env.AZURE_OPENAI_API_KEY &&
+                        process.env.AZURE_OPENAI_ENDPOINT),
+                    "google-ai": !!process.env.GOOGLE_AI_API_KEY,
+                },
+                defaults: {
+                    temperature: 0.7,
+                    maxTokens: 500,
+                },
+                timestamp: new Date().toISOString(),
+            };
+            this.handleOutput(config, options);
+        }
+        catch (error) {
+            logger.error(chalk.red(`❌ Configuration export failed: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute get best provider command
+     */
+    static async executeGetBestProvider(argv) {
+        const options = this.processOptions(argv);
+        try {
+            const { getBestProvider } = await import("../../lib/utils/providerUtils.js");
+            const bestProvider = await getBestProvider();
+            if (options.format === "json") {
+                this.handleOutput({ provider: bestProvider }, options);
+            }
+            else {
+                if (!options.quiet) {
+                    logger.always(chalk.green(`🎯 Best available provider: ${bestProvider}`));
+                }
+                else {
+                    this.handleOutput(bestProvider, options);
+                }
+            }
+        }
+        catch (error) {
+            logger.error(chalk.red(`❌ Provider selection failed: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute completion command
+     */
+    static async executeCompletion(argv) {
+        // This would need to be implemented with the actual CLI instance
+        logger.always("# Completion script would be generated here");
+        logger.always("# This requires access to the yargs CLI instance");
+    }
 }