@vfarcic/dot-ai 0.1.0

package/dist/interfaces/cli.js

@@ -0,0 +1,769 @@
+"use strict";
+/**
+ * CLI Interface Module
+ *
+ * Command-line interface for dot-ai
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliInterface = void 0;
+const commander_1 = require("commander");
+const yaml = __importStar(require("js-yaml"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const recommend_1 = require("../tools/recommend");
+const choose_solution_1 = require("../tools/choose-solution");
+const answer_question_1 = require("../tools/answer-question");
+const generate_manifests_1 = require("../tools/generate-manifests");
+const deploy_manifests_1 = require("../tools/deploy-manifests");
+const error_handling_1 = require("../core/error-handling");
+const fs_1 = require("fs");
+const path_1 = require("path");
+class CliInterface {
+    dotAI;
+    program;
+    config;
+    logger;
+    constructor(dotAI, config = {}) {
+        this.dotAI = dotAI;
+        this.config = config;
+        this.program = new commander_1.Command();
+        this.logger = new error_handling_1.ConsoleLogger('CLI');
+        this.program.name('dot-ai').description('AI-powered Kubernetes deployment agent');
+        // Add global options that apply to all commands
+        this.program
+            .option('--kubeconfig <path>', 'Path to kubeconfig file (overrides KUBECONFIG env var and default location)')
+            .option('--verbose', 'Enable verbose output globally')
+            .option('--output-file <path>', 'Write clean formatted output to file (respects --output format)')
+            .option('--quiet', 'Suppress tool registration and info logs');
+        this.setupCommands();
+    }
+    setDotAI(dotAI) {
+        this.dotAI = dotAI;
+    }
+    ensureDotAI() {
+        if (!this.dotAI) {
+            throw new Error('Cluster connection required. Please ensure your kubeconfig is valid and cluster is accessible.');
+        }
+        return this.dotAI;
+    }
+    getPackageInfo() {
+        try {
+            const packagePath = (0, path_1.join)(__dirname, '../../package.json');
+            const packageJson = JSON.parse((0, fs_1.readFileSync)(packagePath, 'utf8'));
+            return { name: packageJson.name, version: packageJson.version };
+        }
+        catch (error) {
+            return { name: '@vfarcic/dot-ai', version: '0.1.0' }; // fallback
+        }
+    }
+    setupCommands() {
+        const { name, version } = this.getPackageInfo();
+        this.program
+            .name('dot-ai')
+            .description('Kubernetes application deployment agent with AI-powered orchestration')
+            .version(version, '-v, --version', 'output the version number');
+        // Add custom help with installation and usage examples
+        this.program.addHelpText('after', `
+
+Installation:
+  npm install -g ${name}        Install globally
+  npx ${name} <command>         Run without installing
+
+Examples:
+  npx ${name} recommend --intent "deploy my Node.js app"
+  npx ${name} status --deployment my-app
+  npx ${name} learn --pattern microservice
+  
+For more help on specific commands, use:
+  npx ${name} help <command>
+`);
+        // Status command
+        this.program
+            .command('status')
+            .description('Check deployment status')
+            .option('--deployment <id>', 'Deployment/workflow ID to check')
+            .option('--output <format>', 'Output format (json|yaml|table)', 'json')
+            .action(async (options, command) => {
+            // Get global options from parent command
+            const globalOptions = command.parent?.opts() || {};
+            this.processGlobalOptions(globalOptions);
+            // Validate output format
+            if (options.output && !['json', 'yaml', 'table'].includes(options.output)) {
+                console.error('Error: Invalid output format. Supported: json, yaml, table');
+                process.exit(1);
+            }
+            const result = await this.executeCommand('status', options);
+            this.outputResult(result, options.output || this.config.defaultOutput || 'json', this.config.outputFile);
+        });
+        // Learn command
+        this.program
+            .command('learn')
+            .description('Show learned deployment patterns and recommendations')
+            .option('--pattern <type>', 'Filter by pattern type')
+            .option('--output <format>', 'Output format (json|yaml|table)', 'json')
+            .action(async (options, command) => {
+            // Get global options from parent command
+            const globalOptions = command.parent?.opts() || {};
+            this.processGlobalOptions(globalOptions);
+            // Validate output format
+            if (options.output && !['json', 'yaml', 'table'].includes(options.output)) {
+                console.error('Error: Invalid output format. Supported: json, yaml, table');
+                process.exit(1);
+            }
+            const result = await this.executeCommand('learn', options);
+            this.outputResult(result, options.output || this.config.defaultOutput || 'json', this.config.outputFile);
+        });
+        // Recommend command
+        this.program
+            .command('recommend')
+            .description('Get AI-powered Kubernetes resource recommendations based on your intent')
+            .requiredOption('--intent <description>', 'Describe what you want to deploy or accomplish')
+            .option('--session-dir <path>', 'Directory to store solution files (defaults to DOT_AI_SESSION_DIR env var)')
+            .option('--output <format>', 'Output format (json|yaml|table)', 'json')
+            .action(async (options, command) => {
+            // Get global options from parent command
+            const globalOptions = command.parent?.opts() || {};
+            this.processGlobalOptions(globalOptions);
+            // Validate output format
+            if (options.output && !['json', 'yaml', 'table'].includes(options.output)) {
+                console.error('Error: Invalid output format. Supported: json, yaml, table');
+                process.exit(1);
+            }
+            const result = await this.executeCommand('recommend', options);
+            this.outputResult(result, options.output || this.config.defaultOutput || 'json', this.config.outputFile);
+        });
+        // Choose Solution command
+        this.program
+            .command('choose-solution')
+            .description('Select a solution by ID and return its questions for configuration')
+            .requiredOption('--solution-id <id>', 'Solution ID to choose (e.g., sol_2025-07-01T154349_1e1e242592ff)')
+            .requiredOption('--session-dir <path>', 'Directory containing solution files')
+            .option('--output <format>', 'Output format (json|yaml|table)', 'json')
+            .action(async (options, command) => {
+            // Get global options from parent command
+            const globalOptions = command.parent?.opts() || {};
+            this.processGlobalOptions(globalOptions);
+            // Validate output format
+            if (options.output && !['json', 'yaml', 'table'].includes(options.output)) {
+                console.error('Error: Invalid output format. Supported: json, yaml, table');
+                process.exit(1);
+            }
+            const result = await this.executeCommand('chooseSolution', options);
+            this.outputResult(result, options.output || this.config.defaultOutput || 'json', this.config.outputFile);
+        });
+        // Answer Question command
+        this.program
+            .command('answer-question')
+            .description('Process user answers and return remaining questions or completion status')
+            .requiredOption('--solution-id <id>', 'Solution ID to update (e.g., sol_2025-07-01T154349_1e1e242592ff)')
+            .requiredOption('--session-dir <path>', 'Directory containing solution files')
+            .requiredOption('--answers <json>', 'User answers as JSON object')
+            .requiredOption('--stage <stage>', 'Configuration stage (required, basic, advanced, open)')
+            .option('--done', 'Set when providing final open question answer', false)
+            .option('--output <format>', 'Output format (json|yaml|table)', 'json')
+            .action(async (options, command) => {
+            // Get global options from parent command
+            const globalOptions = command.parent?.opts() || {};
+            this.processGlobalOptions(globalOptions);
+            // Parse answers JSON
+            try {
+                options.answers = JSON.parse(options.answers);
+            }
+            catch (error) {
+                console.error('Error: Invalid JSON in --answers parameter');
+                process.exit(1);
+            }
+            // Validate output format
+            if (options.output && !['json', 'yaml', 'table'].includes(options.output)) {
+                console.error('Error: Invalid output format. Supported: json, yaml, table');
+                process.exit(1);
+            }
+            const result = await this.executeCommand('answerQuestion', options);
+            this.outputResult(result, options.output || this.config.defaultOutput || 'json', this.config.outputFile);
+        });
+        // Generate Manifests command
+        this.program
+            .command('generate-manifests')
+            .description('Generate Kubernetes manifests from solution configuration using AI')
+            .requiredOption('--solution-id <id>', 'Solution ID to generate manifests for (e.g., sol_2025-07-01T154349_1e1e242592ff)')
+            .requiredOption('--session-dir <path>', 'Directory containing solution files')
+            .option('--output <format>', 'Output format (json|yaml|table)', 'json')
+            .action(async (options, command) => {
+            // Get global options from parent command
+            const globalOptions = command.parent?.opts() || {};
+            this.processGlobalOptions(globalOptions);
+            // Validate output format
+            if (options.output && !['json', 'yaml', 'table'].includes(options.output)) {
+                console.error('Error: Invalid output format. Supported: json, yaml, table');
+                process.exit(1);
+            }
+            const result = await this.executeCommand('generateManifests', options);
+            this.outputResult(result, options.output || this.config.defaultOutput || 'json', this.config.outputFile);
+        });
+        // Deploy Manifests command
+        this.program
+            .command('deploy-manifests')
+            .description('Deploy Kubernetes manifests from generated solution')
+            .requiredOption('--solution-id <id>', 'Solution ID to deploy')
+            .requiredOption('--session-dir <path>', 'Session directory path')
+            .option('--timeout <seconds>', 'Deployment timeout in seconds', '30')
+            .option('--output <format>', 'Output format (json|yaml|table)', 'json')
+            .action(async (options, command) => {
+            // Get global options from parent command
+            const globalOptions = command.parent?.opts() || {};
+            this.processGlobalOptions(globalOptions);
+            // Validate output format
+            if (options.output && !['json', 'yaml', 'table'].includes(options.output)) {
+                console.error('Error: Invalid output format. Supported: json, yaml, table');
+                process.exit(1);
+            }
+            const result = await this.executeCommand('deployManifests', options);
+            this.outputResult(result, options.output || this.config.defaultOutput || 'json', this.config.outputFile);
+        });
+        // REMOVED: enhance command - moved to legacy reference
+        // See src/legacy/tools/enhance-solution.ts for reference implementation
+    }
+    getCommands() {
+        return ['dot-ai'];
+    }
+    getSubcommands() {
+        return this.program.commands.map(cmd => cmd.name());
+    }
+    async getHelp() {
+        const { name } = this.getPackageInfo();
+        const basicHelp = this.program.helpInformation();
+        const customHelp = `
+
+Installation:
+  npm install -g ${name}        Install globally
+  npx ${name} <command>         Run without installing
+
+Examples:
+  npx ${name} recommend --intent "deploy my Node.js app"
+  npx ${name} status --deployment my-app
+  npx ${name} learn --pattern microservice
+  
+For more help on specific commands, use:
+  npx ${name} help <command>
+`;
+        return basicHelp + customHelp;
+    }
+    async getCommandHelp(commandName) {
+        const command = this.program.commands.find(cmd => cmd.name() === commandName);
+        if (!command) {
+            throw new Error(`Unknown command: ${commandName}`);
+        }
+        return command.helpInformation();
+    }
+    async parseArguments(args) {
+        if (args.length === 0) {
+            throw new Error('No command provided');
+        }
+        const commandName = args[0];
+        const validCommands = this.getSubcommands();
+        if (!validCommands.includes(commandName)) {
+            throw new Error(`Unknown command: ${commandName}`);
+        }
+        // Validate options based on command
+        const options = {};
+        for (let i = 1; i < args.length; i += 2) {
+            const option = args[i];
+            const value = args[i + 1];
+            if (!option.startsWith('--')) {
+                throw new Error(`Invalid option format: ${option}`);
+            }
+            const optionName = option.substring(2);
+            // Validate known options for each command
+            const validOptions = this.getValidOptionsForCommand(commandName);
+            if (!validOptions.includes(optionName)) {
+                throw new Error(`Unknown option: ${option}`);
+            }
+            // Validate specific option values
+            if (optionName === 'output' && value && !['json', 'yaml', 'table'].includes(value)) {
+                throw new Error('Invalid output format. Supported: json, yaml, table');
+            }
+            options[optionName] = value || true;
+        }
+        // Check required options
+        // (no required option checks needed for current commands)
+        return {
+            command: commandName,
+            options
+        };
+    }
+    getValidOptionsForCommand(command) {
+        const commonOptions = ['output', 'verbose'];
+        switch (command) {
+            case 'discover':
+                return [...commonOptions, 'cluster', 'remember'];
+            case 'status':
+                return [...commonOptions, 'deployment'];
+            case 'learn':
+                return [...commonOptions, 'pattern'];
+            case 'recommend':
+                return [...commonOptions, 'intent', 'session-dir'];
+            case 'chooseSolution':
+                return [...commonOptions, 'solution-id', 'session-dir'];
+            case 'answerQuestion':
+                return [...commonOptions, 'solution-id', 'session-dir', 'stage', 'answers', 'done'];
+            case 'generateManifests':
+                return [...commonOptions, 'solution-id', 'session-dir'];
+            case 'deployManifests':
+                return [...commonOptions, 'solution-id', 'session-dir', 'timeout'];
+            // REMOVED: enhance command, deploy command
+            default:
+                return commonOptions;
+        }
+    }
+    async executeCommand(command, options = {}) {
+        try {
+            // Only initialize DotAI for commands that need cluster access
+            if (command !== 'chooseSolution' && command !== 'answerQuestion' && command !== 'generateManifests') {
+                await this.ensureDotAI().initialize();
+            }
+            switch (command) {
+                case 'status':
+                    return await this.handleStatusCommand(options);
+                case 'learn':
+                    return await this.handleLearnCommand(options);
+                case 'recommend':
+                    return await this.handleRecommendCommand(options);
+                case 'chooseSolution':
+                    return await this.handleChooseSolutionCommand(options);
+                case 'answerQuestion':
+                    return await this.handleAnswerQuestionCommand(options);
+                case 'generateManifests':
+                    return await this.handleGenerateManifestsCommand(options);
+                case 'deployManifests':
+                    return await this.handleDeployManifestsCommand(options);
+                // REMOVED: enhance command, deploy command
+                default:
+                    return {
+                        success: false,
+                        error: `Unknown command: ${command}`
+                    };
+            }
+        }
+        catch (error) {
+            return this.handleError(error, command);
+        }
+    }
+    async handleStatusCommand(options) {
+        try {
+            const phase = this.ensureDotAI().workflow.getCurrentPhase();
+            return {
+                success: true,
+                data: {
+                    workflowId: options.deployment,
+                    phase,
+                    status: 'active'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Status check failed: ${error.message}`
+            };
+        }
+    }
+    async handleLearnCommand(options) {
+        try {
+            const recommendations = await this.ensureDotAI().memory.getRecommendations(options.pattern || 'deployment', {});
+            return {
+                success: true,
+                data: {
+                    recommendations,
+                    patternType: options.pattern || 'deployment'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Learning retrieval failed: ${error.message}`
+            };
+        }
+    }
+    async handleRecommendCommand(options) {
+        try {
+            // Show progress for long-running AI operations
+            this.showProgress('🔍 Analyzing your intent and discovering cluster resources...');
+            // Prepare arguments for the recommend tool including session directory
+            const toolArgs = {
+                intent: options.intent,
+                sessionDir: options.sessionDir // This will be passed to our tool's getSessionDirectory function
+            };
+            this.showProgress('🤖 AI is analyzing resources and generating solutions...');
+            // Execute the recommend tool directly
+            const requestId = `cli_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            const result = await (0, recommend_1.handleRecommendTool)(toolArgs, this.ensureDotAI(), this.logger, requestId);
+            this.clearProgress();
+            // Parse the tool result
+            const responseData = JSON.parse(result.content[0].text);
+            return {
+                success: true,
+                data: responseData
+            };
+        }
+        catch (error) {
+            // Give a moment for user to see progress before clearing
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            this.clearProgress(); // Clear progress indicators on error
+            return {
+                success: false,
+                error: `AI-powered recommendations failed: ${error.message}`
+            };
+        }
+    }
+    async handleChooseSolutionCommand(options) {
+        try {
+            // Show progress for file operations
+            this.showProgress('📋 Loading solution and extracting questions...');
+            // Prepare arguments for the chooseSolution tool
+            const toolArgs = {
+                solutionId: options.solutionId,
+                sessionDir: options.sessionDir
+            };
+            // Execute the chooseSolution tool directly
+            const requestId = `cli_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            const result = await (0, choose_solution_1.handleChooseSolutionTool)(toolArgs, null, this.logger, requestId);
+            this.clearProgress();
+            // Parse the tool result
+            const responseData = JSON.parse(result.content[0].text);
+            return {
+                success: true,
+                data: responseData
+            };
+        }
+        catch (error) {
+            // Give a moment for user to see progress before clearing
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            this.clearProgress(); // Clear progress indicators on error
+            return {
+                success: false,
+                error: `Choose solution failed: ${error.message}`
+            };
+        }
+    }
+    async handleAnswerQuestionCommand(options) {
+        try {
+            // Show progress for file operations
+            this.showProgress('📝 Processing answers and updating solution...');
+            // Prepare arguments for the answerQuestion tool
+            const toolArgs = {
+                solutionId: options.solutionId,
+                sessionDir: options.sessionDir,
+                stage: options.stage,
+                answers: options.answers,
+                done: options.done || false
+            };
+            // Execute the answerQuestion tool directly
+            const requestId = `cli_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            const result = await (0, answer_question_1.handleAnswerQuestionTool)(toolArgs, null, this.logger, requestId);
+            this.clearProgress();
+            // Parse the tool result
+            const responseData = JSON.parse(result.content[0].text);
+            return {
+                success: true,
+                data: responseData
+            };
+        }
+        catch (error) {
+            // Give a moment for user to see progress before clearing
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            this.clearProgress(); // Clear progress indicators on error
+            return {
+                success: false,
+                error: `Answer question failed: ${error.message}`
+            };
+        }
+    }
+    async handleGenerateManifestsCommand(options) {
+        try {
+            // Show progress for manifest generation
+            this.showProgress('🤖 Generating Kubernetes manifests with AI...');
+            // Prepare arguments for the generateManifests tool
+            const toolArgs = {
+                solutionId: options.solutionId,
+                sessionDir: options.sessionDir
+            };
+            // Execute the generateManifests tool directly
+            const requestId = `cli_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            const result = await (0, generate_manifests_1.handleGenerateManifestsTool)(toolArgs, this.dotAI, this.logger, requestId);
+            this.clearProgress();
+            // Parse the tool result
+            const responseData = JSON.parse(result.content[0].text);
+            return {
+                success: true,
+                data: responseData
+            };
+        }
+        catch (error) {
+            // Give a moment for user to see progress before clearing
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            this.clearProgress(); // Clear progress indicators on error
+            return {
+                success: false,
+                error: `Manifest generation failed: ${error.message}`
+            };
+        }
+    }
+    async handleDeployManifestsCommand(options) {
+        try {
+            // Show progress for deployment
+            this.showProgress('🚀 Deploying Kubernetes manifests...');
+            // Prepare arguments for the deployManifests tool
+            const toolArgs = {
+                solutionId: options.solutionId,
+                timeout: parseInt(options.timeout) || 30
+            };
+            // Execute the deployManifests tool directly
+            const requestId = `cli_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            const result = await (0, deploy_manifests_1.handleDeployManifestsTool)(toolArgs, this.ensureDotAI(), this.logger, requestId);
+            this.clearProgress();
+            // Parse the tool result
+            const responseData = JSON.parse(result.content[0].text);
+            return {
+                success: true,
+                data: responseData
+            };
+        }
+        catch (error) {
+            this.clearProgress(); // Clear progress indicators on error
+            return {
+                success: false,
+                error: `Manifest deployment failed: ${error.message}`
+            };
+        }
+    }
+    // REMOVED: handleEnhanceCommand method - moved to legacy reference
+    // See src/legacy/tools/enhance-solution.ts for reference implementation
+    async continueWorkflow(workflowId, input) {
+        try {
+            await this.ensureDotAI().workflow.transitionTo('Validation');
+            const claudeResponse = await this.ensureDotAI().claude.processUserInput(`Continue workflow ${workflowId} with responses: ${JSON.stringify(input.responses)}`);
+            return {
+                success: true,
+                data: claudeResponse
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Workflow continuation failed: ${error.message}`
+            };
+        }
+    }
+    formatOutput(result, format) {
+        // Handle raw format for commands that need it
+        const isRawFormat = result._rawFormat;
+        if (isRawFormat) {
+            switch (format) {
+                case 'json':
+                    return JSON.stringify(result.data, null, 2);
+                case 'yaml':
+                    return yaml.dump(result.data);
+                case 'table':
+                    return this.formatAsTable({ success: true, data: result.data });
+                default:
+                    return JSON.stringify(result.data, null, 2);
+            }
+        }
+        // Standard CLI format for other commands
+        switch (format) {
+            case 'json':
+                return JSON.stringify(result, null, 2);
+            case 'yaml':
+                return yaml.dump(result);
+            case 'table':
+                return this.formatAsTable(result);
+            default:
+                return JSON.stringify(result, null, 2);
+        }
+    }
+    formatAsTable(result) {
+        if (!result.success) {
+            const table = new cli_table3_1.default({
+                head: ['Status', 'Error'],
+                colWidths: [20, 60]
+            });
+            table.push(['Failed', result.error || 'Unknown error']);
+            return table.toString();
+        }
+        // Format data as table based on content
+        if (result.data && (result.data.resources || result.data.crds)) {
+            const table = new cli_table3_1.default({
+                head: ['Resource Type', 'Category'],
+                colWidths: [40, 20]
+            });
+            // Add discovered resources
+            if (result.data.resources && result.data.resources.resources) {
+                result.data.resources.resources.forEach((resource) => {
+                    const category = resource.group === '' ? 'Core' : resource.group;
+                    table.push([resource.kind, category]);
+                });
+            }
+            // Add custom resources (CRDs) - handle both string and object formats
+            if (result.data.crds && Array.isArray(result.data.crds)) {
+                result.data.crds.forEach((crd) => {
+                    const crdName = typeof crd === 'string' ? crd : crd.name;
+                    table.push([crdName, 'Custom']);
+                });
+            }
+            return table.toString();
+        }
+        // Generic table format
+        const table = new cli_table3_1.default({
+            head: ['Property', 'Value'],
+            colWidths: [30, 50]
+        });
+        if (result.data) {
+            Object.entries(result.data).forEach(([key, value]) => {
+                table.push([key, JSON.stringify(value)]);
+            });
+        }
+        return table.toString();
+    }
+    outputResult(result, format, outputFile) {
+        const output = this.formatOutput(result, format);
+        if (outputFile) {
+            // Write clean output to file
+            const fs = require('fs');
+            const path = require('path');
+            // Ensure directory exists
+            const dir = path.dirname(outputFile);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(outputFile, output);
+        }
+        else {
+            // Write to stdout
+            process.stdout.write(`${output}\n`);
+        }
+        if (!result.success) {
+            process.exit(1);
+        }
+    }
+    /**
+     * Process global options and update config
+     */
+    processGlobalOptions(options) {
+        if (options.verbose !== undefined) {
+            this.config.verboseMode = options.verbose;
+        }
+        if (options.outputFile !== undefined) {
+            this.config.outputFile = options.outputFile;
+        }
+        if (options.quiet !== undefined) {
+            this.config.quietMode = options.quiet;
+        }
+    }
+    handleError(error, _command) {
+        this.clearProgress(); // Clear any progress indicators on error
+        let errorMessage = error.message;
+        // Provide helpful error messages for common issues
+        if (errorMessage.includes('ENOTFOUND') || errorMessage.includes('connection')) {
+            errorMessage = 'Cannot connect to Kubernetes cluster. Check your kubeconfig and cluster status.';
+        }
+        else if (errorMessage.includes('Connection failed')) {
+            errorMessage = `Failed to initialize DevOps AI Toolkit: ${errorMessage}`;
+        }
+        return {
+            success: false,
+            error: errorMessage
+        };
+    }
+    /**
+     * Show progress message to user during long-running operations
+     */
+    showProgress(message) {
+        // Only show progress if output is going to console (not when piped or in JSON mode)
+        if (process.stdout.isTTY) {
+            process.stderr.write(`\r\x1b[K${message}`);
+        }
+    }
+    /**
+     * Clear progress indicators
+     */
+    clearProgress() {
+        if (process.stdout.isTTY) {
+            process.stderr.write('\r\x1b[K');
+        }
+    }
+    /**
+     * Find best solutions with detailed progress feedback
+     */
+    async findBestSolutionsWithProgress(recommender, intent, discoverResourcesFn, explainResourceFn) {
+        this.showProgress('🤖 AI is analyzing your intent...');
+        // Start a timer to show elapsed time
+        const startTime = Date.now();
+        const progressInterval = setInterval(() => {
+            const elapsed = Math.floor((Date.now() - startTime) / 1000);
+            this.showProgress(`🤖 AI analysis in progress... (${elapsed}s)`);
+        }, 3000);
+        try {
+            // The ResourceRecommender handles the three phases internally:
+            // 1. Resource discovery and selection
+            // 2. Schema fetching and ranking  
+            // 3. Question generation
+            const solutions = await recommender.findBestSolutions(intent, discoverResourcesFn, explainResourceFn);
+            clearInterval(progressInterval);
+            return solutions;
+        }
+        catch (error) {
+            clearInterval(progressInterval);
+            throw error;
+        }
+    }
+    // CLI entry point
+    async run(args = process.argv) {
+        try {
+            await this.program.parseAsync(args);
+        }
+        catch (error) {
+            const result = this.handleError(error, 'general');
+            this.outputResult(result, 'json');
+            process.exit(1);
+        }
+    }
+}
+exports.CliInterface = CliInterface;
+// Export for CLI entry point
+exports.default = CliInterface;