@juspay/neurolink 7.1.0 → 7.2.0

package/dist/cli/factories/commandFactory.js

@@ -1,4 +1,7 @@
 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";
@@ -26,24 +29,29 @@ export class CLICommandFactory {
             ],
             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: {
@@ -55,6 +63,7 @@ export class CLICommandFactory {
         output: {
             type: "string",
             description: "Save output to file",
+            alias: "o",
         },
         // Behavior control options
         timeout: {
@@ -112,6 +121,15 @@ export class CLICommandFactory {
             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 = {}) {
@@ -122,6 +140,47 @@ export class CLICommandFactory {
     }
     // 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,
@@ -135,16 +194,15 @@ export class CLICommandFactory {
             evaluationDomain: argv.evaluationDomain,
             toolUsageContext: argv.toolUsageContext,
             lighthouseStyle: argv.lighthouseStyle,
-            context: argv.context
-                ? typeof argv.context === "string"
-                    ? JSON.parse(argv.context)
-                    : argv.context
-                : undefined,
+            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
@@ -154,7 +212,7 @@ export class CLICommandFactory {
             output = JSON.stringify(result, null, 2);
         }
         else if (options.format === "table" && Array.isArray(result)) {
-            console.table(result);
+            logger.table(result);
             return;
         }
         else {
@@ -162,7 +220,12 @@ export class CLICommandFactory {
                 output = result;
             }
             else if (result && typeof result === "object" && "content" in result) {
-                output = result.content;
+                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;
@@ -174,13 +237,67 @@ export class CLICommandFactory {
         if (options.output) {
             fs.writeFileSync(options.output, output);
             if (!options.quiet) {
-                console.log(`Output saved to ${options.output}`);
+                logger.always(`Output saved to ${options.output}`);
             }
         }
         else {
-            console.log(output);
+            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
      */
@@ -189,10 +306,16 @@ export class CLICommandFactory {
             command: ["generate <input>", "gen <input>"],
             describe: "Generate content using AI providers",
             builder: (yargs) => {
-                return this.buildOptions(yargs.positional("input", {
+                return this.buildOptions(yargs
+                    .positional("input", {
                     type: "string",
                     description: "Text prompt for AI generation (or read from stdin)",
-                }));
+                })
+                    .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),
         };
@@ -205,10 +328,15 @@ export class CLICommandFactory {
             command: "stream <input>",
             describe: "Stream generation in real-time",
             builder: (yargs) => {
-                return this.buildOptions(yargs.positional("input", {
+                return this.buildOptions(yargs
+                    .positional("input", {
                     type: "string",
                     description: "Text prompt for streaming (or read from stdin)",
-                }));
+                })
+                    .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),
         };
@@ -221,11 +349,16 @@ export class CLICommandFactory {
             command: "batch <file>",
             describe: "Process multiple prompts from a file",
             builder: (yargs) => {
-                return this.buildOptions(yargs.positional("file", {
+                return this.buildOptions(yargs
+                    .positional("file", {
                     type: "string",
                     description: "File with prompts (one per line)",
                     demandOption: true,
-                }));
+                })
+                    .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),
         };
@@ -239,8 +372,11 @@ export class CLICommandFactory {
             describe: "Manage AI provider configurations and status",
             builder: (yargs) => {
                 return yargs
-                    .command("status", "Check status of all configured AI providers", (y) => this.buildOptions(y), (argv) => CLICommandFactory.executeProviderStatus(argv))
-                    .demandCommand(1, "");
+                    .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
         };
@@ -252,10 +388,31 @@ export class CLICommandFactory {
         return {
             command: "status",
             describe: "Check AI provider connectivity and performance (alias for provider status)",
-            builder: (yargs) => this.buildOptions(yargs),
+            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
      */
@@ -265,6 +422,30 @@ export class CLICommandFactory {
             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();
+                })
+                    .command("show", "Display current configuration", (y) => this.buildOptions(y), async (argv) => {
+                    const { configManager } = await import("../commands/config.js");
+                    configManager.showConfig();
+                })
+                    .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);
+                    }
+                })
+                    .command("reset", "Reset configuration to defaults", (y) => this.buildOptions(y), async (argv) => {
+                    const { configManager } = await import("../commands/config.js");
+                    configManager.resetConfig();
+                })
                     .command("export", "Export current configuration", (y) => this.buildOptions(y), (argv) => this.executeConfigExport(argv))
                     .demandCommand(1, "");
             },
@@ -278,7 +459,10 @@ export class CLICommandFactory {
         return {
             command: "get-best-provider",
             describe: "Show the best available AI provider",
-            builder: (yargs) => this.buildOptions(yargs),
+            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),
         };
     }
@@ -289,7 +473,11 @@ export class CLICommandFactory {
         return {
             command: "completion",
             describe: "Generate shell completion script",
-            builder: (yargs) => this.buildOptions(yargs),
+            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),
         };
     }
@@ -298,7 +486,7 @@ export class CLICommandFactory {
      */
     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
@@ -306,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;
@@ -321,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);
         }
     }
@@ -365,9 +553,32 @@ export class CLICommandFactory {
             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 result = await sdk.generate({
-                input: { text: argv.input },
+                input: { text: inputText },
                 provider: options.provider,
                 model: options.model,
                 temperature: options.temperature,
@@ -379,7 +590,7 @@ export class CLICommandFactory {
                 enableEvaluation: options.enableEvaluation,
                 evaluationDomain: options.evaluationDomain,
                 toolUsageContext: options.toolUsageContext,
-                context: options.context,
+                context: contextMetadata,
             });
             if (spinner) {
                 spinner.succeed(chalk.green("✅ Text generated successfully!"));
@@ -403,9 +614,9 @@ export class CLICommandFactory {
             if (spinner) {
                 spinner.fail();
             }
-            console.error(chalk.red(`❌ Generation failed: ${error.message}`));
+            logger.error(chalk.red(`❌ Generation failed: ${error.message}`));
             if (options.debug) {
-                console.error(chalk.gray(error.stack));
+                logger.error(chalk.gray(error.stack));
             }
             process.exit(1);
         }
@@ -431,16 +642,39 @@ export class CLICommandFactory {
         }
         const options = this.processOptions(argv);
         if (!options.quiet) {
-            console.log(chalk.blue("🔄 Streaming..."));
+            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: argv.input },
+                input: { text: inputText },
                 provider: options.provider,
                 model: options.model,
                 temperature: options.temperature,
@@ -450,7 +684,7 @@ export class CLICommandFactory {
                 disableTools: options.disableTools,
                 enableAnalytics: options.enableAnalytics,
                 enableEvaluation: options.enableEvaluation,
-                context: options.context,
+                context: contextMetadata,
             });
             let fullContent = "";
             // Process the stream
@@ -465,19 +699,69 @@ export class CLICommandFactory {
             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) {
-                    console.log(`\nOutput saved to ${options.output}`);
+                    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) {
-            console.error(chalk.red(`❌ Streaming failed: ${error.message}`));
+            logger.error(chalk.red(`❌ Streaming failed: ${error.message}`));
             if (options.debug) {
-                console.error(chalk.gray(error.stack));
+                logger.error(chalk.gray(error.stack));
             }
             process.exit(1);
         }
@@ -508,7 +792,7 @@ export class CLICommandFactory {
                 spinner.text = `📦 Processing ${prompts.length} prompts...`;
             }
             else if (!options.quiet) {
-                console.log(chalk.blue(`📦 Processing ${prompts.length} prompts...\n`));
+                logger.always(chalk.blue(`📦 Processing ${prompts.length} prompts...\n`));
             }
             const results = [];
             const sdk = new NeuroLink();
@@ -517,8 +801,23 @@ export class CLICommandFactory {
                     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: prompts[i] },
+                        input: { text: inputText },
                         provider: options.provider,
                         model: options.model,
                         temperature: options.temperature,
@@ -528,7 +827,7 @@ export class CLICommandFactory {
                         disableTools: options.disableTools,
                         enableAnalytics: options.enableAnalytics,
                         enableEvaluation: options.enableEvaluation,
-                        context: options.context,
+                        context: contextMetadata,
                     });
                     results.push({ prompt: prompts[i], response: result.content });
                     if (spinner) {
@@ -560,9 +859,9 @@ export class CLICommandFactory {
             if (spinner) {
                 spinner.fail();
             }
-            console.error(chalk.red(`❌ Batch processing failed: ${error.message}`));
+            logger.error(chalk.red(`❌ Batch processing failed: ${error.message}`));
             if (options.debug) {
-                console.error(chalk.gray(error.stack));
+                logger.error(chalk.gray(error.stack));
             }
             process.exit(1);
         }
@@ -593,7 +892,7 @@ export class CLICommandFactory {
             this.handleOutput(config, options);
         }
         catch (error) {
-            console.error(chalk.red(`❌ Configuration export failed: ${error.message}`));
+            logger.error(chalk.red(`❌ Configuration export failed: ${error.message}`));
             process.exit(1);
         }
     }
@@ -610,7 +909,7 @@ export class CLICommandFactory {
             }
             else {
                 if (!options.quiet) {
-                    console.log(chalk.green(`🎯 Best available provider: ${bestProvider}`));
+                    logger.always(chalk.green(`🎯 Best available provider: ${bestProvider}`));
                 }
                 else {
                     this.handleOutput(bestProvider, options);
@@ -618,7 +917,7 @@ export class CLICommandFactory {
             }
         }
         catch (error) {
-            console.error(chalk.red(`❌ Provider selection failed: ${error.message}`));
+            logger.error(chalk.red(`❌ Provider selection failed: ${error.message}`));
             process.exit(1);
         }
     }
@@ -627,7 +926,7 @@ export class CLICommandFactory {
      */
     static async executeCompletion(argv) {
         // This would need to be implemented with the actual CLI instance
-        console.log("# Completion script would be generated here");
-        console.log("# This requires access to the yargs CLI instance");
+        logger.always("# Completion script would be generated here");
+        logger.always("# This requires access to the yargs CLI instance");
     }
 }