@juspay/neurolink 7.33.4 → 7.35.0

package/dist/cli/factories/commandFactory.js

@@ -1,7 +1,9 @@
-import { NeuroLink } from "../../lib/neurolink.js";
+import { globalSession } from "../../lib/session/globalSessionState.js";
 import { configManager } from "../commands/config.js";
-import { handleError } from "../index.js";
+import { handleError } from "../errorHandler.js";
 import { normalizeEvaluationData } from "../../lib/utils/evaluationUtils.js";
+import { LoopSession } from "../loop/session.js";
+import { initializeCliParser } from "../parser.js";
 // Use TokenUsage from standard types - no local interface needed
 import { ContextFactory, } from "../../lib/types/contextTypes.js";
 import { ModelsCommandFactory } from "../commands/models.js";
@@ -12,6 +14,7 @@ import ora from "ora";
 import chalk from "chalk";
 import { logger } from "../../lib/utils/logger.js";
 import fs from "fs";
+import { handleSetup } from "../commands/setup.js";
 // Use specific command interfaces from cli.ts instead of universal interface
 /**
  * CLI Command Factory for generate commands
@@ -189,8 +192,7 @@ export class CLICommandFactory {
                     const truncatedJson = contextStr.length > 100
                         ? `${contextStr.slice(0, 100)}...`
                         : contextStr;
-                    logger.error(`Invalid JSON in --context parameter: ${err.message}. Received: ${truncatedJson}`);
-                    process.exit(1);
+                    handleError(new Error(`Invalid JSON in --context parameter: ${err.message}. Received: ${truncatedJson}`), "Context parsing");
                 }
             }
             else {
@@ -494,6 +496,39 @@ export class CLICommandFactory {
     static createDiscoverCommand() {
         return MCPCommandFactory.createDiscoverCommand();
     }
+    /**
+     * Create memory commands
+     */
+    static createMemoryCommands() {
+        return {
+            command: "memory <subcommand>",
+            describe: "Manage conversation memory",
+            builder: (yargs) => {
+                return yargs
+                    .command("stats", "Show conversation memory statistics", (y) => this.buildOptions(y)
+                    .example("$0 memory stats", "Show memory usage statistics")
+                    .example("$0 memory stats --format json", "Export stats as JSON"), async (argv) => await this.executeMemoryStats(argv))
+                    .command("history <sessionId>", "Show conversation history for a session", (y) => this.buildOptions(y)
+                    .positional("sessionId", {
+                    type: "string",
+                    description: "Session ID to retrieve history for",
+                    demandOption: true,
+                })
+                    .example("$0 memory history session-123", "Show conversation history")
+                    .example("$0 memory history session-123 --format json", "Export history as JSON"), async (argv) => await this.executeMemoryHistory(argv))
+                    .command("clear [sessionId]", "Clear conversation history", (y) => this.buildOptions(y)
+                    .positional("sessionId", {
+                    type: "string",
+                    description: "Session ID to clear (omit to clear all sessions)",
+                    demandOption: false,
+                })
+                    .example("$0 memory clear", "Clear all conversation history")
+                    .example("$0 memory clear session-123", "Clear specific session"), async (argv) => await this.executeMemoryClear(argv))
+                    .demandCommand(1, "Please specify a memory subcommand");
+            },
+            handler: () => { }, // No-op handler as subcommands handle everything
+        };
+    }
     /**
      * Create config commands
      */
@@ -515,9 +550,8 @@ export class CLICommandFactory {
                         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);
+                        const errorMessages = result.errors.join("\n  • ");
+                        handleError(new Error(`Configuration has errors:\n  • ${errorMessages}`), "Configuration validation");
                     }
                 })
                     .command("reset", "Reset configuration to defaults", (y) => this.buildOptions(y), async (_argv) => {
@@ -543,9 +577,8 @@ export class CLICommandFactory {
                     logger.always(chalk.green("✅ Configuration is valid"));
                 }
                 else {
-                    logger.always(chalk.red("❌ Configuration has errors:"));
-                    result.errors.forEach((error) => logger.always(`  • ${error}`));
-                    throw new Error("Configuration is invalid. See errors above.");
+                    const errorMessages = result.errors.join("\n  • ");
+                    handleError(new Error(`Configuration has errors:\n  • ${errorMessages}`), "Configuration validation");
                 }
             },
         };
@@ -570,12 +603,99 @@ export class CLICommandFactory {
     static createOllamaCommands() {
         return OllamaCommandFactory.createOllamaCommands();
     }
+    /**
+     * Create setup command
+     */
+    static createSetupCommand() {
+        return {
+            command: ["setup [provider]", "s [provider]"],
+            describe: "Interactive AI provider setup wizard",
+            builder: (yargs) => {
+                return this.buildOptions(yargs
+                    .positional("provider", {
+                    type: "string",
+                    description: "Specific provider to set up",
+                    choices: [
+                        "google-ai",
+                        "openai",
+                        "anthropic",
+                        "azure",
+                        "bedrock",
+                        "vertex",
+                        "huggingface",
+                        "mistral",
+                    ],
+                })
+                    .option("list", {
+                    type: "boolean",
+                    description: "List all available providers",
+                    alias: "l",
+                })
+                    .option("status", {
+                    type: "boolean",
+                    description: "Show provider configuration status",
+                })
+                    .example("$0 setup", "Interactive setup wizard")
+                    .example("$0 setup --provider openai", "Setup specific provider")
+                    .example("$0 setup --list", "List all providers")
+                    .example("$0 setup --status", "Check provider status"));
+            },
+            handler: async (argv) => await handleSetup(argv),
+        };
+    }
     /**
      * Create SageMaker commands
      */
     static createSageMakerCommands() {
         return SageMakerCommandFactory.createSageMakerCommands();
     }
+    /**
+     * Create completion command
+     */
+    /**
+     * Create loop command
+     */
+    static createLoopCommand() {
+        return {
+            command: "loop",
+            describe: "Start an interactive loop session",
+            builder: (yargs) => yargs
+                .option("enable-conversation-memory", {
+                type: "boolean",
+                description: "Enable conversation memory for the loop session",
+                default: false,
+            })
+                .option("max-sessions", {
+                type: "number",
+                description: "Maximum number of conversation sessions to keep",
+                default: 50,
+            })
+                .option("max-turns-per-session", {
+                type: "number",
+                description: "Maximum turns per conversation session",
+                default: 20,
+            })
+                .example("$0 loop", "Start interactive session")
+                .example("$0 loop --enable-conversation-memory", "Start loop with memory"),
+            handler: async (argv) => {
+                if (globalSession.getCurrentSessionId()) {
+                    logger.error("A loop session is already active. Cannot start a new one.");
+                    return;
+                }
+                let conversationMemoryConfig;
+                const { enableConversationMemory, maxSessions, maxTurnsPerSession } = argv;
+                if (enableConversationMemory) {
+                    conversationMemoryConfig = {
+                        enabled: true,
+                        maxSessions: maxSessions,
+                        maxTurnsPerSession: maxTurnsPerSession,
+                    };
+                }
+                const session = new LoopSession(initializeCliParser, conversationMemoryConfig);
+                await session.start();
+            },
+        };
+    }
     /**
      * Create completion command
      */
@@ -601,6 +721,7 @@ export class CLICommandFactory {
         const spinner = argv.quiet
             ? null
             : ora("🔍 Checking AI provider status...\n").start();
+        const sdk = globalSession.getOrCreateNeuroLink();
         try {
             // Handle dry-run mode for provider status
             if (argv.dryRun) {
@@ -652,7 +773,6 @@ export class CLICommandFactory {
                 return;
             }
             // Use SDK's provider diagnostic method instead of manual testing
-            const sdk = new NeuroLink();
             const results = await sdk.getProviderStatus({ quiet: !!argv.quiet });
             if (spinner) {
                 const working = results.filter((r) => r.status === "working").length;
@@ -682,8 +802,19 @@ export class CLICommandFactory {
             if (spinner) {
                 spinner.fail("Provider status check failed");
             }
-            logger.error(chalk.red("Error checking provider status:"), error);
-            process.exit(1);
+            handleError(error, "Provider status check");
+        }
+        finally {
+            // Ensure all background processes are terminated
+            try {
+                await sdk.shutdownExternalMCPServers();
+            }
+            catch (shutdownError) {
+                logger.error("Error during SDK shutdown:", shutdownError);
+            }
+            if (!globalSession.getCurrentSessionId()) {
+                process.exit();
+            }
         }
     }
     /**
@@ -779,9 +910,17 @@ export class CLICommandFactory {
                     logger.debug("Model:", mockResult.model);
                     logger.debug("Mode: DRY-RUN (no actual API calls made)");
                 }
-                process.exit(0);
+                if (!globalSession.getCurrentSessionId()) {
+                    process.exit(0);
+                }
             }
-            const sdk = new NeuroLink();
+            const sdk = globalSession.getOrCreateNeuroLink();
+            const sessionVariables = globalSession.getSessionVariables();
+            const enhancedOptions = { ...options, ...sessionVariables };
+            const sessionId = globalSession.getCurrentSessionId();
+            const context = sessionId
+                ? { ...options.context, sessionId }
+                : options.context;
             if (options.debug) {
                 logger.debug("CLI Tools configuration:", {
                     disableTools: options.disableTools,
@@ -790,21 +929,21 @@ export class CLICommandFactory {
             }
             const result = await sdk.generate({
                 input: { text: inputText },
-                provider: options.provider,
-                model: options.model,
-                temperature: options.temperature,
-                maxTokens: options.maxTokens,
-                systemPrompt: options.systemPrompt,
-                timeout: options.timeout,
-                disableTools: options.disableTools,
-                enableAnalytics: options.enableAnalytics,
-                enableEvaluation: options.enableEvaluation,
-                evaluationDomain: options.evaluationDomain,
-                toolUsageContext: options.toolUsageContext,
-                context: contextMetadata,
-                factoryConfig: options.domain
+                provider: enhancedOptions.provider,
+                model: enhancedOptions.model,
+                temperature: enhancedOptions.temperature,
+                maxTokens: enhancedOptions.maxTokens,
+                systemPrompt: enhancedOptions.systemPrompt,
+                timeout: enhancedOptions.timeout,
+                disableTools: enhancedOptions.disableTools,
+                enableAnalytics: enhancedOptions.enableAnalytics,
+                enableEvaluation: enhancedOptions.enableEvaluation,
+                evaluationDomain: enhancedOptions.evaluationDomain,
+                toolUsageContext: enhancedOptions.toolUsageContext,
+                context: context,
+                factoryConfig: enhancedOptions.domain
                     ? {
-                        domainType: options.domain,
+                        domainType: enhancedOptions.domain,
                         enhancementType: "domain-configuration",
                         validateDomainData: true,
                     }
@@ -813,6 +952,12 @@ export class CLICommandFactory {
             if (spinner) {
                 spinner.succeed(chalk.green("✅ Text generated successfully!"));
             }
+            // Display provider and model info by default (unless quiet mode)
+            if (!options.quiet) {
+                const providerInfo = result.provider || "auto";
+                const modelInfo = result.model || "default";
+                logger.always(chalk.gray(`🔧 Provider: ${providerInfo} | Model: ${modelInfo}`));
+            }
             // Handle output with universal formatting
             this.handleOutput(result, options);
             if (options.debug) {
@@ -826,7 +971,9 @@ export class CLICommandFactory {
                     logger.debug("Evaluation:", JSON.stringify(result.evaluation, null, 2));
                 }
             }
-            process.exit(0);
+            if (!globalSession.getCurrentSessionId()) {
+                process.exit(0);
+            }
         }
         catch (error) {
             if (spinner) {
@@ -981,24 +1128,34 @@ export class CLICommandFactory {
                     logger.debug("Model:", options.model || "test-model");
                     logger.debug("Mode: DRY-RUN (no actual API calls made)");
                 }
-                process.exit(0);
+                if (!globalSession.getCurrentSessionId()) {
+                    process.exit(0);
+                }
             }
-            const sdk = new NeuroLink();
+            const sdk = globalSession.getOrCreateNeuroLink();
+            const sessionVariables = globalSession.getSessionVariables();
+            const enhancedOptions = { ...options, ...sessionVariables };
+            const sessionId = globalSession.getCurrentSessionId();
+            const context = sessionId
+                ? { ...contextMetadata, sessionId }
+                : contextMetadata;
             const stream = await sdk.stream({
                 input: { text: inputText },
-                provider: options.provider,
-                model: options.model,
-                temperature: options.temperature,
-                maxTokens: options.maxTokens,
-                systemPrompt: options.systemPrompt,
-                timeout: options.timeout,
-                disableTools: options.disableTools,
-                enableAnalytics: options.enableAnalytics,
-                enableEvaluation: options.enableEvaluation,
-                context: contextMetadata,
-                factoryConfig: options.domain
+                provider: enhancedOptions.provider,
+                model: enhancedOptions.model,
+                temperature: enhancedOptions.temperature,
+                maxTokens: enhancedOptions.maxTokens,
+                systemPrompt: enhancedOptions.systemPrompt,
+                timeout: enhancedOptions.timeout,
+                disableTools: enhancedOptions.disableTools,
+                enableAnalytics: enhancedOptions.enableAnalytics,
+                enableEvaluation: enhancedOptions.enableEvaluation,
+                evaluationDomain: enhancedOptions.evaluationDomain,
+                toolUsageContext: enhancedOptions.toolUsageContext,
+                context: context,
+                factoryConfig: enhancedOptions.domain
                     ? {
-                        domainType: options.domain,
+                        domainType: enhancedOptions.domain,
                         enhancementType: "domain-configuration",
                         validateDomainData: true,
                     }
@@ -1123,7 +1280,9 @@ export class CLICommandFactory {
             if (options.debug) {
                 await this.logStreamDebugInfo(stream);
             }
-            process.exit(0);
+            if (!globalSession.getCurrentSessionId()) {
+                process.exit(0);
+            }
         }
         catch (error) {
             handleError(error, "Streaming");
@@ -1158,7 +1317,10 @@ export class CLICommandFactory {
                 logger.always(chalk.blue(`📦 Processing ${prompts.length} prompts...\n`));
             }
             const results = [];
-            const sdk = new NeuroLink();
+            const sdk = globalSession.getOrCreateNeuroLink();
+            const sessionVariables = globalSession.getSessionVariables();
+            const enhancedOptions = { ...options, ...sessionVariables };
+            const sessionId = globalSession.getCurrentSessionId();
             for (let i = 0; i < prompts.length; i++) {
                 if (spinner) {
                     spinner.text = `Processing ${i + 1}/${prompts.length}: ${prompts[i].substring(0, 30)}...`;
@@ -1190,21 +1352,24 @@ export class CLICommandFactory {
                             batchIndex: i,
                         };
                     }
+                    const context = sessionId
+                        ? { ...contextMetadata, sessionId }
+                        : contextMetadata;
                     const result = await sdk.generate({
                         input: { text: inputText },
-                        provider: options.provider,
-                        model: options.model,
-                        temperature: options.temperature,
-                        maxTokens: options.maxTokens,
-                        systemPrompt: options.systemPrompt,
-                        timeout: options.timeout,
-                        disableTools: options.disableTools,
-                        enableAnalytics: options.enableAnalytics,
-                        enableEvaluation: options.enableEvaluation,
-                        context: contextMetadata,
-                        factoryConfig: options.domain
+                        provider: enhancedOptions.provider,
+                        model: enhancedOptions.model,
+                        temperature: enhancedOptions.temperature,
+                        maxTokens: enhancedOptions.maxTokens,
+                        systemPrompt: enhancedOptions.systemPrompt,
+                        timeout: enhancedOptions.timeout,
+                        disableTools: enhancedOptions.disableTools,
+                        evaluationDomain: enhancedOptions.evaluationDomain,
+                        toolUsageContext: enhancedOptions.toolUsageContext,
+                        context: context,
+                        factoryConfig: enhancedOptions.domain
                             ? {
-                                domainType: options.domain,
+                                domainType: enhancedOptions.domain,
                                 enhancementType: "domain-configuration",
                                 validateDomainData: true,
                             }
@@ -1234,7 +1399,9 @@ export class CLICommandFactory {
             }
             // Handle output with universal formatting
             this.handleOutput(results, options);
-            process.exit(0);
+            if (!globalSession.getCurrentSessionId()) {
+                process.exit(0);
+            }
         }
         catch (error) {
             if (spinner) {
@@ -1296,6 +1463,189 @@ export class CLICommandFactory {
             handleError(error, "Provider selection");
         }
     }
+    /**
+     * Execute memory stats command
+     */
+    static async executeMemoryStats(argv) {
+        const options = this.processOptions(argv);
+        const spinner = options.quiet
+            ? null
+            : ora("🧠 Getting memory stats...").start();
+        try {
+            const sdk = globalSession.getOrCreateNeuroLink();
+            // Handle dry-run mode
+            if (options.dryRun) {
+                const mockStats = {
+                    totalSessions: 5,
+                    totalTurns: 47,
+                    memoryUsage: "Active",
+                };
+                if (spinner) {
+                    spinner.succeed(chalk.green("✅ Memory stats retrieved (dry-run)"));
+                }
+                this.handleOutput(mockStats, options);
+                return;
+            }
+            const stats = await sdk.getConversationStats();
+            if (spinner) {
+                spinner.succeed(chalk.green("✅ Memory stats retrieved"));
+            }
+            if (options.format === "json") {
+                this.handleOutput(stats, options);
+            }
+            else {
+                logger.always(chalk.blue("📊 Conversation Memory Stats:"));
+                logger.always(`   Total Sessions: ${stats.totalSessions}`);
+                logger.always(`   Total Turns: ${stats.totalTurns}`);
+                logger.always(`   Memory Status: ${stats.totalSessions > 0 ? "Active" : "Empty"}`);
+            }
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail("Memory stats failed");
+            }
+            if (error.message.includes("not enabled")) {
+                logger.always(chalk.yellow("⚠️ Conversation memory is not enabled"));
+                logger.always("Enable it by using --enable-conversation-memory with loop mode");
+            }
+            else {
+                handleError(error, "Memory stats");
+            }
+        }
+    }
+    /**
+     * Execute memory history command
+     */
+    static async executeMemoryHistory(argv) {
+        const options = this.processOptions(argv);
+        const spinner = options.quiet
+            ? null
+            : ora(`🧠 Getting history for ${argv.sessionId}...`).start();
+        try {
+            const sdk = globalSession.getOrCreateNeuroLink();
+            // Handle dry-run mode
+            if (options.dryRun) {
+                const mockHistory = [
+                    { role: "user", content: "Hello, how are you?" },
+                    {
+                        role: "assistant",
+                        content: "I'm doing well, thank you! How can I help you today?",
+                    },
+                    { role: "user", content: "Can you explain quantum computing?" },
+                    {
+                        role: "assistant",
+                        content: "Quantum computing is a revolutionary technology...",
+                    },
+                ];
+                if (spinner) {
+                    spinner.succeed(chalk.green(`✅ History retrieved for ${argv.sessionId} (dry-run)`));
+                }
+                this.handleOutput(mockHistory, options);
+                return;
+            }
+            const history = await sdk.getConversationHistory(argv.sessionId);
+            if (spinner) {
+                spinner.succeed(chalk.green(`✅ History retrieved for ${argv.sessionId}`));
+            }
+            if (history.length === 0) {
+                logger.always(chalk.yellow(`⚠️ No conversation history found for session: ${argv.sessionId}`));
+                return;
+            }
+            if (options.format === "json") {
+                this.handleOutput(history, options);
+            }
+            else {
+                logger.always(chalk.blue(`💬 Conversation History (${argv.sessionId}):`));
+                for (const message of history) {
+                    const roleColor = message.role === "user" ? chalk.cyan : chalk.green;
+                    const roleLabel = message.role === "user" ? "User" : "Assistant";
+                    logger.always(`   [${roleColor(roleLabel)}]: ${message.content}`);
+                }
+            }
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail("Memory history failed");
+            }
+            if (error.message.includes("not enabled")) {
+                logger.always(chalk.yellow("⚠️ Conversation memory is not enabled"));
+                logger.always("Enable it by using --enable-conversation-memory with loop mode");
+            }
+            else {
+                handleError(error, "Memory history");
+            }
+        }
+    }
+    /**
+     * Execute memory clear command
+     */
+    static async executeMemoryClear(argv) {
+        const options = this.processOptions(argv);
+        const isAllSessions = !argv.sessionId;
+        const target = isAllSessions ? "all sessions" : `session ${argv.sessionId}`;
+        const spinner = options.quiet
+            ? null
+            : ora(`🧠 Clearing ${target}...`).start();
+        try {
+            const sdk = globalSession.getOrCreateNeuroLink();
+            // Handle dry-run mode
+            if (options.dryRun) {
+                if (spinner) {
+                    spinner.succeed(chalk.green(`✅ ${isAllSessions ? "All sessions" : "Session"} cleared (dry-run)`));
+                }
+                const result = {
+                    success: true,
+                    action: isAllSessions ? "clear_all" : "clear_session",
+                    sessionId: argv.sessionId || null,
+                    message: `${isAllSessions ? "All sessions" : "Session"} would be cleared`,
+                };
+                this.handleOutput(result, options);
+                return;
+            }
+            let success;
+            if (isAllSessions) {
+                await sdk.clearAllConversations();
+                success = true;
+            }
+            else {
+                success = await sdk.clearConversationSession(argv.sessionId);
+            }
+            if (spinner) {
+                if (success) {
+                    spinner.succeed(chalk.green(`✅ ${isAllSessions ? "All sessions" : "Session"} cleared successfully`));
+                }
+                else {
+                    spinner.warn(chalk.yellow(`⚠️ Session ${argv.sessionId} not found or already empty`));
+                }
+            }
+            if (options.format === "json") {
+                const result = {
+                    success,
+                    action: isAllSessions ? "clear_all" : "clear_session",
+                    sessionId: argv.sessionId || null,
+                };
+                this.handleOutput(result, options);
+            }
+            else if (!success && !isAllSessions) {
+                logger.always(chalk.yellow(`⚠️ Session ${argv.sessionId} not found or already empty`));
+            }
+            else if (!options.quiet) {
+                logger.always(chalk.green(`✅ ${isAllSessions ? "All conversation history" : `Session ${argv.sessionId}`} cleared`));
+            }
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail("Memory clear failed");
+            }
+            if (error.message.includes("not enabled")) {
+                logger.always(chalk.yellow("⚠️ Conversation memory is not enabled"));
+                logger.always("Enable it by using --enable-conversation-memory with loop mode");
+            }
+            else {
+                handleError(error, "Memory clear");
+            }
+        }
+    }
     /**
      * Execute completion command
      */
@@ -1317,7 +1667,7 @@ export class CLICommandFactory {
                 '    prev="${COMP_WORDS[COMP_CWORD - 1]}"\n\n' +
                 "    # Main commands\n" +
                 "    if [[ ${COMP_CWORD} -eq 1 ]]; then\n" +
-                '        opts="generate gen stream batch provider status models mcp discover config get-best-provider completion"\n' +
+                '        opts="generate gen stream batch provider status models mcp discover memory config get-best-provider completion"\n' +
                 '        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )\n' +
                 "        return 0\n" +
                 "    fi\n\n" +
@@ -1379,6 +1729,12 @@ export class CLICommandFactory {
                 "                return 0\n" +
                 "            fi\n" +
                 "            ;;\n" +
+                "        memory)\n" +
+                "            if [[ ${COMP_CWORD} -eq 2 ]]; then\n" +
+                '                COMPREPLY=( $(compgen -W "stats history clear" -- ${cur}) )\n' +
+                "                return 0\n" +
+                "            fi\n" +
+                "            ;;\n" +
                 "        *)\n" +
                 "            # Global options for all commands\n" +
                 '            opts="--help --version --debug --quiet --noColor --configFile"\n' +

package/dist/cli/factories/ollamaCommandFactory.js

@@ -196,7 +196,13 @@ export class OllamaCommandFactory {
      * Handler for starting Ollama service
      */
     static async startHandler() {
-        await OllamaUtils.startOllamaService();
+        try {
+            await OllamaUtils.startOllamaService();
+        }
+        catch (error) {
+            logger.error("Failed to start Ollama service:", error);
+            throw error;
+        }
     }
     /**
      * Handler for stopping Ollama service

package/dist/cli/factories/setupCommandFactory.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Setup Command Factory for NeuroLink
+ * Consolidates all provider setup commands into a unified interface
+ */
+import type { CommandModule } from "yargs";
+/**
+ * Setup Command Factory
+ */
+export declare class SetupCommandFactory {
+    /**
+     * Create the main setup command with all provider subcommands
+     */
+    static createSetupCommands(): CommandModule;
+    /**
+     * Build common options for provider setup commands
+     */
+    private static buildProviderOptions;
+}