@juspay/neurolink 1.6.0 → 1.10.0

package/dist/cli/index.js

@@ -6,18 +6,19 @@
  * Features: Spinners, colors, batch processing, provider testing, rich help
  * Implementation: ~300 lines using simple JS utility functions
  */
-import { NeuroLink } from '../lib/neurolink.js';
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
-import ora from 'ora';
-import chalk from 'chalk';
-import fs from 'fs';
-import { addMCPCommands } from './commands/mcp.js';
-import ollamaCommand from './commands/ollama.js';
+import { NeuroLink } from "../lib/neurolink.js";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import ora from "ora";
+import chalk from "chalk";
+import fs from "fs";
+import { addMCPCommands } from "./commands/mcp.js";
+import ollamaCommand from "./commands/ollama.js";
+import { agentGenerateCommand } from "./commands/agent-generate.js";
 // Load environment variables from .env file
 try {
     // Try to import and configure dotenv
-    const { config } = await import('dotenv');
+    const { config } = await import("dotenv");
     config(); // Load .env from current working directory
 }
 catch (error) {
@@ -25,146 +26,124 @@ catch (error) {
     // Environment variables should be set externally in production
 }
 // Utility Functions (Simple, Zero Maintenance)
-function formatOutput(result, format = 'text') {
-    if (format === 'json') {
-        return JSON.stringify(result, null, 2);
-    }
-    // Smart text formatting
-    if (result?.content) {
-        return result.content;
-    }
-    if (typeof result === 'string') {
-        return result;
-    }
-    return JSON.stringify(result, null, 2);
-}
 function handleError(error, context) {
-    let specificErrorMessage = error.message;
-    const originalErrorMessageLowerCase = error.message ? error.message.toLowerCase() : '';
+    const specificErrorMessage = error.message;
+    const originalErrorMessageLowerCase = error.message
+        ? error.message.toLowerCase()
+        : "";
     const errorStringLowerCase = String(error).toLowerCase();
     let isAuthError = false;
     let genericMessage = specificErrorMessage; // Initialize genericMessage with the specific one
-    if (originalErrorMessageLowerCase.includes('api_key') ||
-        originalErrorMessageLowerCase.includes('google_ai_api_key') ||
-        originalErrorMessageLowerCase.includes('aws_access_key_id') ||
-        originalErrorMessageLowerCase.includes('aws_secret_access_key') ||
-        originalErrorMessageLowerCase.includes('aws_session_token') ||
-        originalErrorMessageLowerCase.includes('google_application_credentials') ||
-        originalErrorMessageLowerCase.includes('google_service_account_key') ||
-        originalErrorMessageLowerCase.includes('google_auth_client_email') ||
-        originalErrorMessageLowerCase.includes('anthropic_api_key') ||
-        originalErrorMessageLowerCase.includes('azure_openai_api_key')) {
+    if (originalErrorMessageLowerCase.includes("api_key") ||
+        originalErrorMessageLowerCase.includes("google_ai_api_key") ||
+        originalErrorMessageLowerCase.includes("aws_access_key_id") ||
+        originalErrorMessageLowerCase.includes("aws_secret_access_key") ||
+        originalErrorMessageLowerCase.includes("aws_session_token") ||
+        originalErrorMessageLowerCase.includes("google_application_credentials") ||
+        originalErrorMessageLowerCase.includes("google_service_account_key") ||
+        originalErrorMessageLowerCase.includes("google_auth_client_email") ||
+        originalErrorMessageLowerCase.includes("anthropic_api_key") ||
+        originalErrorMessageLowerCase.includes("azure_openai_api_key")) {
         isAuthError = true;
     }
-    else if ( // Fallback to checking the full stringified error if direct message didn't match
-    errorStringLowerCase.includes('api_key') ||
-        errorStringLowerCase.includes('google_ai_api_key') ||
-        errorStringLowerCase.includes('aws_access_key_id') ||
-        errorStringLowerCase.includes('aws_secret_access_key') ||
-        errorStringLowerCase.includes('aws_session_token') ||
-        errorStringLowerCase.includes('google_application_credentials') ||
-        errorStringLowerCase.includes('google_service_account_key') ||
-        errorStringLowerCase.includes('google_auth_client_email') ||
-        errorStringLowerCase.includes('anthropic_api_key') ||
-        errorStringLowerCase.includes('azure_openai_api_key')) {
+    else if (
+    // Fallback to checking the full stringified error if direct message didn't match
+    errorStringLowerCase.includes("api_key") ||
+        errorStringLowerCase.includes("google_ai_api_key") ||
+        errorStringLowerCase.includes("aws_access_key_id") ||
+        errorStringLowerCase.includes("aws_secret_access_key") ||
+        errorStringLowerCase.includes("aws_session_token") ||
+        errorStringLowerCase.includes("google_application_credentials") ||
+        errorStringLowerCase.includes("google_service_account_key") ||
+        errorStringLowerCase.includes("google_auth_client_email") ||
+        errorStringLowerCase.includes("anthropic_api_key") ||
+        errorStringLowerCase.includes("azure_openai_api_key")) {
         isAuthError = true;
     }
     if (isAuthError) {
-        genericMessage = 'Authentication error: Missing or invalid API key/credentials for the selected provider.';
-    }
-    else if (originalErrorMessageLowerCase.includes('enotfound') || // Prefer direct message checks
-        originalErrorMessageLowerCase.includes('econnrefused') ||
-        originalErrorMessageLowerCase.includes('invalid-endpoint') ||
-        originalErrorMessageLowerCase.includes('network error') ||
-        originalErrorMessageLowerCase.includes('could not connect') ||
-        originalErrorMessageLowerCase.includes('timeout') ||
-        errorStringLowerCase.includes('enotfound') || // Fallback to full string
-        errorStringLowerCase.includes('econnrefused') ||
-        errorStringLowerCase.includes('invalid-endpoint') ||
-        errorStringLowerCase.includes('network error') ||
-        errorStringLowerCase.includes('could not connect') ||
-        errorStringLowerCase.includes('timeout') // General timeout
+        genericMessage =
+            "Authentication error: Missing or invalid API key/credentials for the selected provider.";
+    }
+    else if (originalErrorMessageLowerCase.includes("enotfound") || // Prefer direct message checks
+        originalErrorMessageLowerCase.includes("econnrefused") ||
+        originalErrorMessageLowerCase.includes("invalid-endpoint") ||
+        originalErrorMessageLowerCase.includes("network error") ||
+        originalErrorMessageLowerCase.includes("could not connect") ||
+        originalErrorMessageLowerCase.includes("timeout") ||
+        errorStringLowerCase.includes("enotfound") || // Fallback to full string
+        errorStringLowerCase.includes("econnrefused") ||
+        errorStringLowerCase.includes("invalid-endpoint") ||
+        errorStringLowerCase.includes("network error") ||
+        errorStringLowerCase.includes("could not connect") ||
+        errorStringLowerCase.includes("timeout") // General timeout
     ) {
-        genericMessage = 'Network error: Could not connect to the API endpoint or the request timed out.';
+        genericMessage =
+            "Network error: Could not connect to the API endpoint or the request timed out.";
     }
-    else if (errorStringLowerCase.includes('not authorized') || errorStringLowerCase.includes('permission denied')) {
-        genericMessage = 'Authorization error: You are not authorized to perform this action or access this resource.';
+    else if (errorStringLowerCase.includes("not authorized") ||
+        errorStringLowerCase.includes("permission denied")) {
+        genericMessage =
+            "Authorization error: You are not authorized to perform this action or access this resource.";
     }
     // If no specific condition matched, genericMessage remains error.message
     console.error(chalk.red(`❌ ${context} failed: ${genericMessage}`));
     // Smart hints for common errors (just string matching!)
-    if (genericMessage.toLowerCase().includes('api key') || genericMessage.toLowerCase().includes('credential')) {
-        console.error(chalk.yellow('💡 Set Google AI Studio API key (RECOMMENDED): export GOOGLE_AI_API_KEY=AIza-...'));
-        console.error(chalk.yellow('💡 Or set OpenAI API key: export OPENAI_API_KEY=sk-...'));
-        console.error(chalk.yellow('💡 Or set AWS Bedrock credentials: export AWS_ACCESS_KEY_ID=... AWS_SECRET_ACCESS_KEY=... AWS_REGION=us-east-1'));
-        console.error(chalk.yellow('💡 Or set Google Vertex AI credentials: export GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json'));
-        console.error(chalk.yellow('💡 Or set Anthropic API key: export ANTHROPIC_API_KEY=sk-ant-...'));
-        console.error(chalk.yellow('💡 Or set Azure OpenAI credentials: export AZURE_OPENAI_API_KEY=... AZURE_OPENAI_ENDPOINT=...'));
-    }
-    if (error.message.toLowerCase().includes('rate limit')) {
-        console.error(chalk.yellow('💡 Try again in a few moments or use --provider vertex'));
-    }
-    if (error.message.toLowerCase().includes('not authorized') || error.message.toLowerCase().includes('permission denied')) {
-        console.error(chalk.yellow('💡 Check your account permissions for the selected model/service.'));
-        console.error(chalk.yellow('💡 For AWS Bedrock, ensure you have permissions for the specific model and consider using inference profile ARNs.'));
+    if (genericMessage.toLowerCase().includes("api key") ||
+        genericMessage.toLowerCase().includes("credential")) {
+        console.error(chalk.yellow("💡 Set Google AI Studio API key (RECOMMENDED): export GOOGLE_AI_API_KEY=AIza-..."));
+        console.error(chalk.yellow("💡 Or set OpenAI API key: export OPENAI_API_KEY=sk-..."));
+        console.error(chalk.yellow("💡 Or set AWS Bedrock credentials: export AWS_ACCESS_KEY_ID=... AWS_SECRET_ACCESS_KEY=... AWS_REGION=us-east-1"));
+        console.error(chalk.yellow("💡 Or set Google Vertex AI credentials: export GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json"));
+        console.error(chalk.yellow("💡 Or set Anthropic API key: export ANTHROPIC_API_KEY=sk-ant-..."));
+        console.error(chalk.yellow("💡 Or set Azure OpenAI credentials: export AZURE_OPENAI_API_KEY=... AZURE_OPENAI_ENDPOINT=..."));
+    }
+    if (error.message.toLowerCase().includes("rate limit")) {
+        console.error(chalk.yellow("💡 Try again in a few moments or use --provider vertex"));
+    }
+    if (error.message.toLowerCase().includes("not authorized") ||
+        error.message.toLowerCase().includes("permission denied")) {
+        console.error(chalk.yellow("💡 Check your account permissions for the selected model/service."));
+        console.error(chalk.yellow("💡 For AWS Bedrock, ensure you have permissions for the specific model and consider using inference profile ARNs."));
     }
     process.exit(1);
 }
-function validateConfig() {
-    const hasGoogleAI = !!process.env.GOOGLE_AI_API_KEY;
-    const hasOpenAI = !!process.env.OPENAI_API_KEY;
-    const hasAWS = !!(process.env.AWS_REGION || process.env.AWS_ACCESS_KEY_ID);
-    const hasGoogle = !!(process.env.GOOGLE_APPLICATION_CREDENTIALS || process.env.GOOGLE_SERVICE_ACCOUNT_KEY || process.env.GOOGLE_AUTH_CLIENT_EMAIL);
-    const hasAnthropic = !!process.env.ANTHROPIC_API_KEY;
-    const hasAzure = !!(process.env.AZURE_OPENAI_API_KEY && process.env.AZURE_OPENAI_ENDPOINT);
-    if (!hasGoogleAI && !hasOpenAI && !hasAWS && !hasGoogle && !hasAnthropic && !hasAzure) {
-        console.error(chalk.red('⚠️  No AI provider credentials found'));
-        console.error(chalk.yellow('💡 Set one of:'));
-        console.error(chalk.yellow('   • GOOGLE_AI_API_KEY=AIza-...'));
-        console.error(chalk.yellow('   • OPENAI_API_KEY=sk-...'));
-        console.error(chalk.yellow('   • AWS_REGION=us-east-1 (+ AWS credentials)'));
-        console.error(chalk.yellow('   • GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json'));
-        console.error(chalk.yellow('   • ANTHROPIC_API_KEY=sk-ant-...'));
-        console.error(chalk.yellow('   • AZURE_OPENAI_API_KEY=... (+ AZURE_OPENAI_ENDPOINT)'));
-        console.error(chalk.blue('\n📚 See: https://github.com/juspay/neurolink#setup'));
-        process.exit(1);
-    }
-}
 // Initialize SDK
 const sdk = new NeuroLink();
 // 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]')
+    .scriptName("neurolink")
+    .usage("Usage: $0 <command> [options]")
     .version()
     .help()
-    .alias('h', 'help')
-    .alias('V', 'version')
+    .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')
+    .demandCommand(1, "")
+    .epilogue("For more info: https://github.com/juspay/neurolink")
+    .showHelpOnFail(true, "Specify --help for available options")
     .middleware((argv) => {
     // Control SDK logging based on debug flag
     if (argv.debug) {
-        process.env.NEUROLINK_DEBUG = 'true';
+        process.env.NEUROLINK_DEBUG = "true";
     }
     else {
         // Always set to false when debug is not enabled (including when not provided)
-        process.env.NEUROLINK_DEBUG = 'false';
+        process.env.NEUROLINK_DEBUG = "false";
     }
     // Keep existing quiet middleware
-    if (process.env.NEUROLINK_QUIET === 'true' && typeof argv.quiet === 'undefined') {
+    if (process.env.NEUROLINK_QUIET === "true" &&
+        typeof argv.quiet === "undefined") {
         argv.quiet = true;
     }
 })
     .fail((msg, err, yargsInstance) => {
     const exitProcess = () => {
-        if (!process.exitCode)
+        if (!process.exitCode) {
             process.exit(1);
+        }
     };
     if (err) {
         // Error likely from an async command handler (e.g., via handleError)
@@ -175,16 +154,19 @@ const cli = yargs(args)
         // 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
+            !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`));
+            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(); });
+                yargsInstance.showHelp((h) => {
+                    process.stderr.write(h + "\n");
+                    exitProcess();
+                });
                 return;
             }
             exitProcess();
@@ -194,122 +176,225 @@ const cli = yargs(args)
     // 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')) {
+        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(); });
+            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')) {
+        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(); });
+        yargsInstance.showHelp((h) => {
+            process.stderr.write(h + "\n");
+            exitProcess();
+        });
         return; // Exit happens in callback
     }
     exitProcess(); // Default exit
 })
     // Generate Text Command
-    .command(['generate-text <prompt>', 'generate <prompt>'], 'Generate text using AI providers', (yargsInstance) => yargsInstance
-    .usage('Usage: $0 generate-text <prompt> [options]')
-    .positional('prompt', {
-    type: 'string',
-    description: 'Text prompt for AI generation',
+    .command(["generate-text <prompt>", "generate <prompt>"], "Generate text using AI providers", (yargsInstance) => yargsInstance
+    .usage("Usage: $0 generate-text <prompt> [options]")
+    .positional("prompt", {
+    type: "string",
+    description: "Text prompt for AI generation",
     demandOption: true,
 })
-    .option('provider', {
-    choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'],
-    default: 'auto',
-    description: 'AI provider to use (auto-selects best available)'
-})
-    .option('temperature', { type: 'number', default: 0.7, description: 'Creativity level (0.0 = focused, 1.0 = creative)' })
-    .option('max-tokens', { type: 'number', default: 500, description: 'Maximum tokens to generate' })
-    .option('system', { type: 'string', description: 'System prompt to guide AI behavior' })
-    .option('format', { choices: ['text', 'json'], default: 'text', alias: 'f', description: 'Output format' })
-    .option('debug', { type: 'boolean', default: false, description: 'Enable debug mode with verbose output' }) // Kept for potential specific debug logic
-    .option('timeout', { type: 'number', default: 30000, description: 'Timeout for the request in milliseconds' })
-    .example('$0 generate-text "Hello world"', 'Basic text generation')
-    .example('$0 generate-text "Write a story" --provider openai', 'Use specific provider'), async (argv) => {
+    .option("provider", {
+    choices: [
+        "auto",
+        "openai",
+        "bedrock",
+        "vertex",
+        "anthropic",
+        "azure",
+        "google-ai",
+        "huggingface",
+        "ollama",
+        "mistral",
+    ],
+    default: "auto",
+    description: "AI provider to use (auto-selects best available)",
+})
+    .option("temperature", {
+    type: "number",
+    default: 0.7,
+    description: "Creativity level (0.0 = focused, 1.0 = creative)",
+})
+    .option("max-tokens", {
+    type: "number",
+    default: 500,
+    description: "Maximum tokens to generate",
+})
+    .option("system", {
+    type: "string",
+    description: "System prompt to guide AI behavior",
+})
+    .option("format", {
+    choices: ["text", "json"],
+    default: "text",
+    alias: "f",
+    description: "Output format",
+})
+    .option("debug", {
+    type: "boolean",
+    default: false,
+    description: "Enable debug mode with verbose output",
+}) // Kept for potential specific debug logic
+    .option("timeout", {
+    type: "number",
+    default: 30000,
+    description: "Timeout for the request in milliseconds",
+})
+    .option("disable-tools", {
+    type: "boolean",
+    default: false,
+    description: "Disable MCP tool integration (tools enabled by default)",
+})
+    .example('$0 generate-text "Hello world"', "Basic text generation")
+    .example('$0 generate-text "Write a story" --provider openai', "Use specific provider")
+    .example('$0 generate-text "What time is it?"', "Use with natural tool integration (default)")
+    .example('$0 generate-text "Hello world" --disable-tools', "Use without tool integration"), async (argv) => {
     let originalConsole = {};
-    if (argv.format === 'json' && !argv.quiet) { // Suppress only if not quiet, as quiet implies no spinners anyway
+    if (argv.format === "json" && !argv.quiet) {
+        // Suppress only if not quiet, as quiet implies no spinners anyway
         originalConsole = { ...console };
         Object.keys(originalConsole).forEach((key) => {
-            if (typeof console[key] === 'function') {
+            if (typeof console[key] === "function") {
                 console[key] = () => { };
             }
         });
     }
-    const spinner = argv.format === 'json' || argv.quiet ? null : ora('🤖 Generating text...').start();
+    const spinner = argv.format === "json" || argv.quiet
+        ? null
+        : ora("🤖 Generating text...").start();
     try {
         const timeoutPromise = new Promise((_, reject) => {
             setTimeout(() => reject(new Error(`Request timeout (${argv.timeout}ms)`)), argv.timeout);
         });
+        // Use enhanced NeuroLink SDK with Lighthouse-style natural tool access
         const generatePromise = sdk.generateText({
-            prompt: argv.prompt, // Cast because demandOption is true
-            provider: argv.provider === 'auto' ? undefined : argv.provider,
+            prompt: argv.prompt,
+            provider: argv.provider === "auto"
+                ? undefined
+                : argv.provider,
             temperature: argv.temperature,
             maxTokens: argv.maxTokens,
-            systemPrompt: argv.system
+            systemPrompt: argv.system,
+            // Lighthouse-style: Tools enabled by default, disable only if explicitly requested
+            disableTools: argv.disableTools === true, // Default true, can be disabled with --no-enable-tools
         });
-        const result = await Promise.race([generatePromise, timeoutPromise]);
-        if (argv.format === 'json' && originalConsole.log) {
+        const result = (await Promise.race([
+            generatePromise,
+            timeoutPromise,
+        ]));
+        if (argv.format === "json" && originalConsole.log) {
             Object.assign(console, originalConsole);
         }
-        if (spinner)
-            spinner.succeed(chalk.green('✅ Text generated successfully!'));
-        if (argv.format === 'json') {
+        if (spinner) {
+            spinner.succeed(chalk.green("✅ Text generated successfully!"));
+        }
+        if (argv.format === "json") {
             const jsonOutput = {
-                content: result.content || '', provider: result.provider,
-                usage: result.usage || { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-                responseTime: result.responseTime || 0
+                content: result.content || "",
+                provider: result.provider,
+                usage: result.usage || {
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalTokens: 0,
+                },
+                responseTime: result.responseTime || 0,
             };
-            process.stdout.write(JSON.stringify(jsonOutput, null, 2) + '\n');
+            process.stdout.write(JSON.stringify(jsonOutput, null, 2) + "\n");
         }
         else if (argv.debug) {
             // Debug mode: Show AI response + full metadata
-            if (result.content)
-                console.log('\n' + result.content + '\n');
-            console.log(JSON.stringify({ provider: result.provider, usage: result.usage, responseTime: result.responseTime }, null, 2));
-            if (result.usage)
+            if (result.content) {
+                console.log("\n" + result.content + "\n");
+            }
+            console.log(JSON.stringify({
+                provider: result.provider,
+                usage: result.usage,
+                responseTime: result.responseTime,
+            }, null, 2));
+            if (result.usage) {
                 console.log(chalk.blue(`ℹ️  ${result.usage.totalTokens} tokens used`));
+            }
         }
         else {
             // Default mode: Clean AI response only
-            if (result.content)
+            if (result.content) {
                 console.log(result.content);
+            }
         }
         // Explicitly exit to prevent hanging, especially with Google AI Studio
         process.exit(0);
     }
     catch (error) {
-        if (argv.format === 'json' && originalConsole.log) {
+        if (argv.format === "json" && originalConsole.log) {
             Object.assign(console, originalConsole);
         }
-        if (spinner)
+        if (spinner) {
             spinner.fail();
-        if (argv.format === 'json') {
-            process.stdout.write(JSON.stringify({ error: error.message, success: false }, null, 2) + '\n');
+        }
+        if (argv.format === "json") {
+            process.stdout.write(JSON.stringify({ error: error.message, success: false }, null, 2) + "\n");
             process.exit(1);
         }
         else {
-            handleError(error, 'Text generation');
+            handleError(error, "Text generation");
         }
     }
 })
     // Stream Text Command
-    .command('stream <prompt>', 'Stream text generation in real-time', (yargsInstance) => yargsInstance
-    .usage('Usage: $0 stream <prompt> [options]')
-    .positional('prompt', { type: 'string', description: 'Text prompt for streaming', demandOption: true })
-    .option('provider', { choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'], default: 'auto', description: 'AI provider to use' })
-    .option('temperature', { type: 'number', default: 0.7, description: 'Creativity level' })
-    .option('debug', { type: 'boolean', default: false, description: 'Enable debug mode with interleaved logging' })
-    .example('$0 stream "Tell me a story"', 'Stream a story in real-time'), async (argv) => {
+    .command("stream <prompt>", "Stream text generation in real-time", (yargsInstance) => yargsInstance
+    .usage("Usage: $0 stream <prompt> [options]")
+    .positional("prompt", {
+    type: "string",
+    description: "Text prompt for streaming",
+    demandOption: true,
+})
+    .option("provider", {
+    choices: [
+        "auto",
+        "openai",
+        "bedrock",
+        "vertex",
+        "anthropic",
+        "azure",
+        "google-ai",
+        "huggingface",
+        "ollama",
+        "mistral",
+    ],
+    default: "auto",
+    description: "AI provider to use",
+})
+    .option("temperature", {
+    type: "number",
+    default: 0.7,
+    description: "Creativity level",
+})
+    .option("debug", {
+    type: "boolean",
+    default: false,
+    description: "Enable debug mode with interleaved logging",
+})
+    .example('$0 stream "Tell me a story"', "Stream a story in real-time"), async (argv) => {
     // Default mode: Simple streaming message
     // Debug mode: More detailed information
     if (!argv.quiet && !argv.debug) {
-        console.log(chalk.blue('🔄 Streaming...'));
+        console.log(chalk.blue("🔄 Streaming..."));
     }
     else if (!argv.quiet && argv.debug) {
         console.log(chalk.blue(`🔄 Streaming from ${argv.provider} provider with debug logging...\n`));
@@ -317,271 +402,545 @@ const cli = yargs(args)
     try {
         const stream = await sdk.generateTextStream({
             prompt: argv.prompt,
-            provider: argv.provider === 'auto' ? undefined : argv.provider,
-            temperature: argv.temperature
+            provider: argv.provider === "auto"
+                ? undefined
+                : argv.provider,
+            temperature: argv.temperature,
         });
         for await (const chunk of stream) {
             process.stdout.write(chunk.content);
             // In debug mode, interleaved logging would appear here
             // (SDK logs are controlled by NEUROLINK_DEBUG set in middleware)
         }
-        if (!argv.quiet)
-            process.stdout.write('\n'); // Ensure newline after stream
+        if (!argv.quiet) {
+            process.stdout.write("\n");
+        } // Ensure newline after stream
     }
     catch (error) {
-        handleError(error, 'Text streaming');
+        handleError(error, "Text streaming");
     }
 })
     // Batch Processing Command
-    .command('batch <file>', 'Process multiple prompts from a file', (yargsInstance) => yargsInstance
-    .usage('Usage: $0 batch <file> [options]')
-    .positional('file', { type: 'string', description: 'File with prompts (one per line)', demandOption: true })
-    .option('output', { type: 'string', description: 'Output file for results (default: stdout)' })
-    .option('delay', { type: 'number', default: 1000, description: 'Delay between requests in milliseconds' })
-    .option('provider', { choices: ['auto', 'openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'], default: 'auto', description: 'AI provider to use' })
-    .option('timeout', { type: 'number', default: 30000, description: 'Timeout for each request in milliseconds' })
-    .option('temperature', { type: 'number', description: 'Global temperature for batch jobs' })
-    .option('max-tokens', { type: 'number', description: 'Global max tokens for batch jobs' })
-    .option('system', { type: 'string', description: 'Global system prompt for batch jobs' })
-    .option('debug', { type: 'boolean', default: false, description: 'Enable debug mode with detailed per-item logging' })
-    .example('$0 batch prompts.txt --output results.json', 'Process and save to file'), async (argv) => {
+    .command("batch <file>", "Process multiple prompts from a file", (yargsInstance) => yargsInstance
+    .usage("Usage: $0 batch <file> [options]")
+    .positional("file", {
+    type: "string",
+    description: "File with prompts (one per line)",
+    demandOption: true,
+})
+    .option("output", {
+    type: "string",
+    description: "Output file for results (default: stdout)",
+})
+    .option("delay", {
+    type: "number",
+    default: 1000,
+    description: "Delay between requests in milliseconds",
+})
+    .option("provider", {
+    choices: [
+        "auto",
+        "openai",
+        "bedrock",
+        "vertex",
+        "anthropic",
+        "azure",
+        "google-ai",
+        "huggingface",
+        "ollama",
+        "mistral",
+    ],
+    default: "auto",
+    description: "AI provider to use",
+})
+    .option("timeout", {
+    type: "number",
+    default: 30000,
+    description: "Timeout for each request in milliseconds",
+})
+    .option("temperature", {
+    type: "number",
+    description: "Global temperature for batch jobs",
+})
+    .option("max-tokens", {
+    type: "number",
+    description: "Global max tokens for batch jobs",
+})
+    .option("system", {
+    type: "string",
+    description: "Global system prompt for batch jobs",
+})
+    .option("debug", {
+    type: "boolean",
+    default: false,
+    description: "Enable debug mode with detailed per-item logging",
+})
+    .example("$0 batch prompts.txt --output results.json", "Process and save to file"), async (argv) => {
     const spinner = argv.quiet ? null : ora().start();
     try {
-        if (!fs.existsSync(argv.file))
+        if (!fs.existsSync(argv.file)) {
             throw new Error(`File not found: ${argv.file}`);
+        }
         const buffer = fs.readFileSync(argv.file);
         const isLikelyBinary = buffer.includes(0) ||
-            buffer.toString('hex', 0, 100).includes('0000') ||
-            (!buffer.toString('utf8', 0, 1024).includes('\n') && buffer.length > 512);
-        if (isLikelyBinary)
+            buffer.toString("hex", 0, 100).includes("0000") ||
+            (!buffer.toString("utf8", 0, 1024).includes("\n") &&
+                buffer.length > 512);
+        if (isLikelyBinary) {
             throw new Error(`Invalid file format: Binary file detected at "${argv.file}". Batch processing requires a plain text 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)
+        }
+        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 (!argv.quiet)
+        }
+        else if (!argv.quiet) {
             console.log(chalk.blue(`📦 Processing ${prompts.length} prompts...\n`));
+        }
         const results = [];
         for (let i = 0; i < prompts.length; i++) {
-            if (spinner)
+            if (spinner) {
                 spinner.text = `Processing ${i + 1}/${prompts.length}: ${prompts[i].substring(0, 30)}...`;
+            }
             try {
-                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Request timeout')), argv.timeout));
+                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Request timeout")), argv.timeout));
                 const generatePromise = sdk.generateText({
                     prompt: prompts[i],
-                    provider: argv.provider === 'auto' ? undefined : argv.provider,
-                    temperature: argv.temperature, maxTokens: argv.maxTokens, systemPrompt: argv.system
+                    provider: argv.provider === "auto"
+                        ? undefined
+                        : argv.provider,
+                    temperature: argv.temperature,
+                    maxTokens: argv.maxTokens,
+                    systemPrompt: argv.system,
                 });
-                const result = await Promise.race([generatePromise, timeoutPromise]);
+                const result = (await Promise.race([
+                    generatePromise,
+                    timeoutPromise,
+                ]));
                 results.push({ prompt: prompts[i], response: result.content });
-                if (spinner)
-                    spinner.render(); // Update spinner without changing text
+                if (spinner) {
+                    spinner.render();
+                } // Update spinner without changing text
             }
             catch (error) {
-                results.push({ prompt: prompts[i], error: error.message });
-                if (spinner)
+                results.push({
+                    prompt: prompts[i],
+                    error: error.message,
+                });
+                if (spinner) {
                     spinner.render();
+                }
+            }
+            if (argv.delay && i < prompts.length - 1) {
+                await new Promise((resolve) => setTimeout(resolve, argv.delay));
             }
-            if (argv.delay && i < prompts.length - 1)
-                await new Promise(resolve => setTimeout(resolve, argv.delay));
         }
-        if (spinner)
-            spinner.succeed(chalk.green('✅ Batch processing complete!'));
+        if (spinner) {
+            spinner.succeed(chalk.green("✅ Batch processing complete!"));
+        }
         const outputData = JSON.stringify(results, null, 2);
         if (argv.output) {
             fs.writeFileSync(argv.output, outputData);
-            if (!argv.quiet)
+            if (!argv.quiet) {
                 console.log(chalk.green(`\n✅ Results saved to ${argv.output}`));
+            }
         }
         else {
-            process.stdout.write(outputData + '\n');
+            process.stdout.write(outputData + "\n");
         }
     }
     catch (error) {
-        if (spinner)
+        if (spinner) {
             spinner.fail();
-        handleError(error, 'Batch processing');
+        }
+        handleError(error, "Batch processing");
     }
 })
     // Provider Command Group (Corrected Structure)
-    .command('provider <subcommand>', 'Manage AI provider configurations and status', (yargsProvider) => {
+    .command("provider <subcommand>", "Manage AI provider configurations and status", (yargsProvider) => {
+    // Builder for the main 'provider' command
     yargsProvider
-        .usage('Usage: $0 provider <subcommand> [options]') // Add usage here
-        .command('status', 'Check status of all configured AI providers', (y) => y
-        .usage('Usage: $0 provider status [options]')
-        .option('verbose', { type: 'boolean', alias: 'v', description: 'Show detailed information' }) // Default is handled by middleware if NEUROLINK_DEBUG is set
-        .example('$0 provider status', 'Check all providers')
-        .example('$0 provider status --verbose', 'Show detailed status information'), async (argv) => {
+        .usage("Usage: $0 provider <subcommand> [options]") // Add usage here
+        .command("status", "Check status of all configured AI providers", (y) => y
+        .usage("Usage: $0 provider status [options]")
+        .option("verbose", {
+        type: "boolean",
+        alias: "v",
+        description: "Show detailed information",
+    }) // Default is handled by middleware if NEUROLINK_DEBUG is set
+        .example("$0 provider status", "Check all providers")
+        .example("$0 provider status --verbose", "Show detailed status information"), async (argv) => {
         if (argv.verbose && !argv.quiet) {
-            console.log(chalk.yellow('ℹ️ Verbose mode enabled. Displaying detailed status.\n')); // Added newline
+            console.log(chalk.yellow("ℹ️ Verbose mode enabled. Displaying detailed status.\n")); // Added newline
         }
-        const spinner = argv.quiet ? null : ora('🔍 Checking AI provider status...\n').start();
+        const spinner = argv.quiet
+            ? null
+            : ora("🔍 Checking AI provider status...\n").start();
         // Middleware sets argv.verbose if NEUROLINK_DEBUG is true and --verbose is not specified
         // Removed the spinner.stopAndPersist logic from here as it's handled before spinner start
-        const providers = ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'];
+        const providers = [
+            "openai",
+            "bedrock",
+            "vertex",
+            "anthropic",
+            "azure",
+            "google-ai",
+            "huggingface",
+            "ollama",
+            "mistral",
+        ];
+        // Import hasProviderEnvVars to check environment variables
+        const { hasProviderEnvVars } = await import("../lib/utils/providerUtils.js");
         const results = [];
         for (const p of providers) {
-            if (spinner)
+            if (spinner) {
                 spinner.text = `Testing ${p}...`;
+            }
+            // First check if provider has env vars configured
+            const hasEnvVars = hasProviderEnvVars(p);
+            if (!hasEnvVars && p !== "ollama") {
+                // No env vars, don't even try to test
+                results.push({
+                    provider: p,
+                    status: "not-configured",
+                    configured: false,
+                    error: "Missing required environment variables",
+                });
+                if (spinner) {
+                    spinner.fail(`${p}: ${chalk.gray("⚪ Not configured")} - Missing environment variables`);
+                }
+                else if (!argv.quiet) {
+                    console.log(`${p}: ${chalk.gray("⚪ Not configured")} - Missing environment variables`);
+                }
+                continue;
+            }
+            // Special handling for Ollama
+            if (p === "ollama") {
+                try {
+                    // First, check if the service is running
+                    const serviceResponse = await fetch('http://localhost:11434/api/tags', {
+                        method: 'GET',
+                        signal: AbortSignal.timeout(2000)
+                    });
+                    if (!serviceResponse.ok) {
+                        throw new Error("Ollama service not responding");
+                    }
+                    // Service is running, now check if the default model is available
+                    const { models } = await serviceResponse.json();
+                    const defaultOllamaModel = "llama3.2:latest";
+                    const modelIsAvailable = models.some((m) => m.name === defaultOllamaModel);
+                    if (modelIsAvailable) {
+                        results.push({
+                            provider: p,
+                            status: "working",
+                            configured: true,
+                            authenticated: true,
+                            responseTime: 0,
+                        });
+                        if (spinner) {
+                            spinner.succeed(`${p}: ${chalk.green("✅ Working")} - Service running and model '${defaultOllamaModel}' is available.`);
+                        }
+                    }
+                    else {
+                        results.push({
+                            provider: p,
+                            status: "failed",
+                            configured: true,
+                            authenticated: false,
+                            error: `Ollama service is running, but model '${defaultOllamaModel}' is not found. Please run 'ollama pull ${defaultOllamaModel}'.`,
+                        });
+                        if (spinner) {
+                            spinner.fail(`${p}: ${chalk.red("❌ Model Not Found")} - Run 'ollama pull ${defaultOllamaModel}'`);
+                        }
+                    }
+                }
+                catch (error) {
+                    results.push({
+                        provider: p,
+                        status: "failed",
+                        configured: false,
+                        authenticated: false,
+                        error: "Ollama is not running. Please start with: ollama serve",
+                    });
+                    if (spinner) {
+                        spinner.fail(`${p}: ${chalk.red("❌ Failed")} - Service not running`);
+                    }
+                }
+                continue;
+            }
+            // Provider has env vars, now test authentication
             try {
                 const start = Date.now();
-                await sdk.generateText({ prompt: 'test', provider: p, maxTokens: 1 });
+                // Import AIProviderFactory to test providers directly without fallback
+                const { AIProviderFactory } = await import("../lib/core/factory.js");
+                // Create and test provider directly to avoid automatic fallback
+                const provider = await AIProviderFactory.createProvider(p);
+                await provider.generateText({
+                    prompt: "test",
+                    maxTokens: 1,
+                });
                 const duration = Date.now() - start;
-                results.push({ provider: p, status: 'working', responseTime: duration });
-                if (spinner)
-                    spinner.succeed(`${p}: ${chalk.green('✅ Working')} (${duration}ms)`);
-                else if (!argv.quiet)
-                    console.log(`${p}: ${chalk.green('✅ Working')} (${duration}ms)`);
+                results.push({
+                    provider: p,
+                    status: "working",
+                    configured: true,
+                    authenticated: true,
+                    responseTime: duration,
+                });
+                if (spinner) {
+                    spinner.succeed(`${p}: ${chalk.green("✅ Working")} (${duration}ms)`);
+                }
+                else if (!argv.quiet) {
+                    console.log(`${p}: ${chalk.green("✅ Working")} (${duration}ms)`);
+                }
             }
             catch (error) {
-                results.push({ provider: p, status: 'failed', error: error.message });
-                if (spinner)
-                    spinner.fail(`${p}: ${chalk.red('❌ Failed')} - ${error.message.split('\n')[0]}`);
-                else if (!argv.quiet)
-                    console.error(`${p}: ${chalk.red('❌ Failed')} - ${error.message.split('\n')[0]}`);
+                const errorMsg = error.message;
+                let authStatus = false;
+                let statusText = "Failed";
+                // Check if it's an authentication error
+                if (errorMsg.includes('401') || errorMsg.includes('Unauthorized') ||
+                    errorMsg.includes('Invalid API') || errorMsg.includes('Authentication') ||
+                    errorMsg.includes('API key') || errorMsg.includes('not authorized') ||
+                    errorMsg.includes('ExpiredToken') || errorMsg.includes('expired')) {
+                    statusText = "Invalid credentials";
+                }
+                else if (errorMsg.includes('fetch') || errorMsg.includes('blob')) {
+                    statusText = "Service error";
+                }
+                results.push({
+                    provider: p,
+                    status: "failed",
+                    configured: true,
+                    authenticated: authStatus,
+                    error: errorMsg,
+                });
+                if (spinner) {
+                    spinner.fail(`${p}: ${chalk.red("❌ " + statusText)} - ${errorMsg.split("\n")[0]}`);
+                }
+                else if (!argv.quiet) {
+                    console.error(`${p}: ${chalk.red("❌ " + statusText)} - ${errorMsg.split("\n")[0]}`);
+                }
             }
         }
-        const working = results.filter(r => r.status === 'working').length;
-        if (spinner)
-            spinner.info(chalk.blue(`\n📊 Summary: ${working}/${results.length} providers working`));
-        else if (!argv.quiet)
-            console.log(chalk.blue(`\n📊 Summary: ${working}/${results.length} providers working`));
+        const working = results.filter((r) => r.status === "working").length;
+        const configured = results.filter((r) => r.configured).length;
+        if (spinner) {
+            spinner.info(chalk.blue(`\n📊 Summary: ${working}/${results.length} providers working, ${configured}/${results.length} configured`));
+        }
+        else if (!argv.quiet) {
+            console.log(chalk.blue(`\n📊 Summary: ${working}/${results.length} providers working, ${configured}/${results.length} configured`));
+        }
         if (argv.verbose && !argv.quiet) {
-            console.log(chalk.blue('\n📋 Detailed Results:'));
+            console.log(chalk.blue("\n📋 Detailed Results:"));
             console.log(JSON.stringify(results, null, 2));
         }
     })
-        .command('list', 'List available AI providers', (y) => y.usage('Usage: $0 provider list'), async () => {
-        console.log('Available providers: openai, bedrock, vertex, anthropic, azure, google-ai, huggingface, ollama, mistral');
+        .command("list", "List available AI providers", (y) => y.usage("Usage: $0 provider list"), async () => {
+        console.log("Available providers: openai, bedrock, vertex, anthropic, azure, google-ai, huggingface, ollama, mistral");
     })
-        .command('configure <providerName>', 'Display configuration guidance for a provider', (y) => y
-        .usage('Usage: $0 provider configure <providerName>')
-        .positional('providerName', {
-        type: 'string',
-        choices: ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'],
-        description: 'Name of the provider to configure',
+        .command("configure <providerName>", "Display configuration guidance for a provider", (y) => y
+        .usage("Usage: $0 provider configure <providerName>")
+        .positional("providerName", {
+        type: "string",
+        choices: [
+            "openai",
+            "bedrock",
+            "vertex",
+            "anthropic",
+            "azure",
+            "google-ai",
+            "huggingface",
+            "ollama",
+            "mistral",
+        ],
+        description: "Name of the provider to configure",
         demandOption: true,
     })
-        .example('$0 provider configure openai', 'Show OpenAI configuration help'), async (argv) => {
+        .example("$0 provider configure openai", "Show OpenAI configuration help"), async (argv) => {
         console.log(chalk.blue(`\n🔧 Configuration guidance for ${chalk.bold(argv.providerName)}:`));
-        console.log(chalk.yellow('💡 Set relevant environment variables for API keys and other settings.'));
-        console.log(chalk.gray('   Refer to the documentation for details: https://github.com/juspay/neurolink#configuration'));
+        console.log(chalk.yellow("💡 Set relevant environment variables for API keys and other settings."));
+        console.log(chalk.gray("   Refer to the documentation for details: https://github.com/juspay/neurolink#configuration"));
     })
-        .demandCommand(1, 'Please specify a provider subcommand (status, list, or configure).');
-}
-// Base handler for 'provider' removed.
-// If no subcommand is provided, yargsProvider.demandCommand should trigger an error,
-// which will be caught by the main .fail() handler.
-)
+        .demandCommand(1, "Please specify a provider subcommand (status, list, or configure).");
+})
     // Status Command (Standalone, for backward compatibility or direct access)
-    .command('status', 'Check AI provider connectivity and performance (alias for provider status)', (yargsInstance) => yargsInstance
-    .usage('Usage: $0 status [options]')
-    .option('verbose', {
-    type: 'boolean',
-    alias: 'v', // Default is handled by middleware if NEUROLINK_DEBUG is set
-    description: 'Show detailed information'
-})
-    .example('$0 status', 'Check all providers')
-    .example('$0 status --verbose', 'Show detailed status information'), async (argv) => {
+    .command("status", "Check AI provider connectivity and performance (alias for provider status)", (yargsInstance) => yargsInstance
+    .usage("Usage: $0 status [options]")
+    .option("verbose", {
+    // Ensure status alias also defines verbose
+    type: "boolean",
+    alias: "v", // Default is handled by middleware if NEUROLINK_DEBUG is set
+    description: "Show detailed information",
+})
+    .example("$0 status", "Check all providers")
+    .example("$0 status --verbose", "Show detailed status information"), async (argv) => {
     // This logic is duplicated from 'provider status' for the alias
     if (argv.verbose && !argv.quiet) {
-        console.log(chalk.yellow('ℹ️ Verbose mode enabled. Displaying detailed status.\n')); // Added newline
+        console.log(chalk.yellow("ℹ️ Verbose mode enabled. Displaying detailed status.\n")); // Added newline
     }
-    const spinner = argv.quiet ? null : ora('🔍 Checking AI provider status...\n').start();
+    const spinner = argv.quiet
+        ? null
+        : ora("🔍 Checking AI provider status...\n").start();
     // Middleware sets argv.verbose if NEUROLINK_DEBUG is true and --verbose is not specified
     // Removed the spinner.stopAndPersist logic from here as it's handled before spinner start
-    const providers = ['openai', 'bedrock', 'vertex', 'anthropic', 'azure', 'google-ai', 'huggingface', 'ollama', 'mistral'];
+    const providers = [
+        "openai",
+        "bedrock",
+        "vertex",
+        "anthropic",
+        "azure",
+        "google-ai",
+        "huggingface",
+        "ollama",
+        "mistral",
+    ];
     const results = [];
     for (const p of providers) {
-        if (spinner)
+        if (spinner) {
             spinner.text = `Testing ${p}...`;
+        }
         try {
             const start = Date.now();
-            await sdk.generateText({ prompt: 'test', provider: p, maxTokens: 1 });
+            await sdk.generateText({ prompt: "test", provider: p, maxTokens: 1 });
             const duration = Date.now() - start;
-            results.push({ provider: p, status: 'working', responseTime: duration });
-            if (spinner)
-                spinner.succeed(`${p}: ${chalk.green('✅ Working')} (${duration}ms)`);
-            else if (!argv.quiet)
-                console.log(`${p}: ${chalk.green('✅ Working')} (${duration}ms)`);
+            results.push({
+                provider: p,
+                status: "working",
+                responseTime: duration,
+            });
+            if (spinner) {
+                spinner.succeed(`${p}: ${chalk.green("✅ Working")} (${duration}ms)`);
+            }
+            else if (!argv.quiet) {
+                console.log(`${p}: ${chalk.green("✅ Working")} (${duration}ms)`);
+            }
         }
         catch (error) {
-            results.push({ provider: p, status: 'failed', error: error.message });
-            if (spinner)
-                spinner.fail(`${p}: ${chalk.red('❌ Failed')} - ${error.message.split('\n')[0]}`);
-            else if (!argv.quiet)
-                console.error(`${p}: ${chalk.red('❌ Failed')} - ${error.message.split('\n')[0]}`);
+            results.push({
+                provider: p,
+                status: "failed",
+                error: error.message,
+            });
+            if (spinner) {
+                spinner.fail(`${p}: ${chalk.red("❌ Failed")} - ${error.message.split("\n")[0]}`);
+            }
+            else if (!argv.quiet) {
+                console.error(`${p}: ${chalk.red("❌ Failed")} - ${error.message.split("\n")[0]}`);
+            }
         }
     }
-    const working = results.filter(r => r.status === 'working').length;
-    if (spinner)
+    const working = results.filter((r) => r.status === "working").length;
+    if (spinner) {
         spinner.info(chalk.blue(`\n📊 Summary: ${working}/${results.length} providers working`));
-    else if (!argv.quiet)
+    }
+    else if (!argv.quiet) {
         console.log(chalk.blue(`\n📊 Summary: ${working}/${results.length} providers working`));
+    }
     if (argv.verbose && !argv.quiet) {
-        console.log(chalk.blue('\n📋 Detailed Results:'));
+        console.log(chalk.blue("\n📋 Detailed Results:"));
         console.log(JSON.stringify(results, null, 2));
     }
 })
     // Configuration Commands Refactored
-    .command('config <subcommand>', 'Manage NeuroLink configuration', (yargsConfig) => {
+    .command("config <subcommand>", "Manage NeuroLink configuration", (yargsConfig) => {
     yargsConfig
-        .usage('Usage: $0 config <subcommand> [options]') // Add usage here
-        .command('setup', 'Interactive setup for NeuroLink configuration', () => { }, // No specific builder options for setup
-    async (argv) => {
-        console.log('Config setup: Use interactive prompts. Error: Invalid input, please try again with valid provider names.');
+        .usage("Usage: $0 config <subcommand> [options]") // Add usage here
+        .command("setup", "Interactive setup for NeuroLink configuration", (y) => y
+        .usage("Usage: $0 config setup [options]")
+        .option("quiet", {
+        type: "boolean",
+        alias: "q",
+        description: "Suppress progress messages and interactive prompts",
     })
-        .command('init', 'Alias for setup: Interactive setup for NeuroLink configuration', () => { }, async (argv) => {
-        console.log('Config init (setup): Use interactive prompts. Error: Invalid input, please try again with valid provider names.');
+        .example("$0 config setup", "Run interactive setup wizard")
+        .example("$0 config setup --quiet", "Run setup with minimal output"), async (argv) => {
+        const { configSetup } = await import("./utils/complete-setup.js");
+        await configSetup(argv.quiet);
     })
-        .command('show', 'Show current NeuroLink configuration', () => { }, async (argv) => {
-        console.log('Config show: Displaying current configuration...');
+        .command("init", "Alias for setup: Interactive setup for NeuroLink configuration", (y) => y
+        .usage("Usage: $0 config init [options]")
+        .option("quiet", {
+        type: "boolean",
+        alias: "q",
+        description: "Suppress progress messages and interactive prompts",
+    })
+        .example("$0 config init", "Run interactive setup wizard (alias for setup)")
+        .example("$0 config init --quiet", "Run setup with minimal output"), async (argv) => {
+        const { configInit } = await import("./utils/complete-setup.js");
+        await configInit(argv.quiet);
+    })
+        .command("show", "Show current NeuroLink configuration", () => { }, async (argv) => {
+        console.log("Config show: Displaying current configuration...");
         // Actual show logic here
     })
-        .command('set <key> <value>', 'Set a configuration key-value pair', (y) => y
-        .positional('key', { type: 'string', description: 'Configuration key to set', demandOption: true })
-        .positional('value', { type: 'string', description: 'Value to set for the key', demandOption: true }), async (argv) => {
+        .command("set <key> <value>", "Set a configuration key-value pair", (y) => y
+        .positional("key", {
+        type: "string",
+        description: "Configuration key to set",
+        demandOption: true,
+    })
+        .positional("value", {
+        type: "string",
+        description: "Value to set for the key",
+        demandOption: true,
+    }), async (argv) => {
         console.log(`Config set: Key: ${argv.key}, Value: ${argv.value}`);
         // Actual set logic here
     })
-        .command('import <file>', 'Import configuration from a file', (y) => y.positional('file', { type: 'string', description: 'File path to import from', demandOption: true }), async (argv) => {
+        .command("import <file>", "Import configuration from a file", (y) => y.positional("file", {
+        type: "string",
+        description: "File path to import from",
+        demandOption: true,
+    }), async (argv) => {
         console.log(`Config import: Importing from ${argv.file}`);
-        if (argv.file.includes('invalid-config.json')) {
-            handleError(new Error('Invalid or unparseable JSON in config file.'), 'Config import');
+        if (argv.file.includes("invalid-config.json")) {
+            handleError(new Error("Invalid or unparseable JSON in config file."), "Config import");
         }
         // Actual import logic here
     })
-        .command('export <file>', 'Export current configuration to a file', (y) => y.positional('file', { type: 'string', description: 'File path to export to', demandOption: true }), async (argv) => {
+        .command("export <file>", "Export current configuration to a file", (y) => y.positional("file", {
+        type: "string",
+        description: "File path to export to",
+        demandOption: true,
+    }), async (argv) => {
         console.log(`Config export: Exporting to ${argv.file}`);
-        if (argv.file.includes('read-only-dir')) {
-            handleError(new Error('Permission denied. Cannot write to read-only directory.'), 'Config export');
+        if (argv.file.includes("read-only-dir")) {
+            handleError(new Error("Permission denied. Cannot write to read-only directory."), "Config export");
         }
         // Actual export logic here
     })
-        .command('validate', 'Validate the current configuration', () => { }, async (argv) => {
-        console.log('Config validate: Validating configuration...');
+        .command("validate", "Validate the current configuration", () => { }, async (argv) => {
+        console.log("Config validate: Validating configuration...");
         // Actual validation logic here
     })
-        .command('reset', 'Reset NeuroLink configuration to defaults', () => { }, async (argv) => {
-        console.log('Config reset: Resetting configuration...');
+        .command("reset", "Reset NeuroLink configuration to defaults", () => { }, async (argv) => {
+        console.log("Config reset: Resetting configuration...");
         // Actual reset logic here
     })
-        .demandCommand(1, 'Please specify a config subcommand (e.g., setup, show, set).')
-        .example('$0 config setup', 'Run interactive setup')
-        .example('$0 config set provider openai', 'Set default provider (using key/value)');
-}
-// Base handler for 'config' removed.
-// If no subcommand is provided, yargsConfig.demandCommand should trigger an error,
-// which will be caught by the main .fail() handler.
-)
+        .demandCommand(1, "Please specify a config subcommand (e.g., setup, show, set).")
+        .example("$0 config setup", "Run interactive setup")
+        .example("$0 config set provider openai", "Set default provider (using key/value)");
+})
     // Get Best Provider Command
-    .command('get-best-provider', 'Show the best available AI provider', (yargsInstance) => yargsInstance
-    .usage('Usage: $0 get-best-provider [options]')
-    .option('debug', { type: 'boolean', default: false, description: 'Enable debug mode with selection reasoning' })
-    .example('$0 get-best-provider', 'Get best provider')
-    .example('$0 get-best-provider --debug', 'Show selection logic'), async (argv) => {
-    const spinner = argv.quiet ? null : ora('🎯 Finding best provider...').start();
+    .command("get-best-provider", "Show the best available AI provider", (yargsInstance) => yargsInstance
+    .usage("Usage: $0 get-best-provider [options]")
+    .option("debug", {
+    type: "boolean",
+    default: false,
+    description: "Enable debug mode with selection reasoning",
+})
+    .example("$0 get-best-provider", "Get best provider")
+    .example("$0 get-best-provider --debug", "Show selection logic"), async (argv) => {
+    const spinner = argv.quiet
+        ? null
+        : ora("🎯 Finding best provider...").start();
     try {
         const provider = await sdk.getBestProvider();
         if (spinner) {
@@ -589,7 +948,7 @@ const cli = yargs(args)
                 spinner.succeed(chalk.green(`✅ Best provider selected: ${provider}`));
             }
             else {
-                spinner.succeed(chalk.green('✅ Provider found'));
+                spinner.succeed(chalk.green("✅ Provider found"));
             }
         }
         if (argv.debug) {
@@ -603,16 +962,19 @@ const cli = yargs(args)
         }
     }
     catch (error) {
-        if (spinner && spinner.isSpinning)
+        if (spinner && spinner.isSpinning) {
             spinner.fail();
-        handleError(error, 'Provider selection');
+        }
+        handleError(error, "Provider selection");
     }
 })
-    .completion('completion', 'Generate shell completion script');
+    .completion("completion", "Generate shell completion script");
 // Add MCP commands
 addMCPCommands(cli);
 // Add Ollama command
 cli.command(ollamaCommand);
+// Add Agent-Generate command
+cli.command(agentGenerateCommand);
 // Use an async IIFE to allow top-level await for parseAsync
 (async () => {
     try {