@wundr.io/cli 1.0.12 → 1.0.13

package/dist/commands/ai.js

@@ -0,0 +1,954 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AICommands = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const ai_service_1 = require("../ai/ai-service");
+const error_handler_1 = require("../utils/error-handler");
+const logger_1 = require("../utils/logger");
+/**
+ * AI commands for AI-powered development features
+ */
+class AICommands {
+    program;
+    configManager;
+    aiService;
+    pluginManager;
+    constructor(program, configManager, pluginManager) {
+        this.program = program;
+        this.configManager = configManager;
+        this.pluginManager = pluginManager;
+        this.aiService = new ai_service_1.AIService(configManager);
+        this.registerCommands();
+    }
+    registerCommands() {
+        const aiCmd = this.program
+            .command('ai')
+            .description('AI-powered development features');
+        // Code generation
+        aiCmd
+            .command('generate <type>')
+            .alias('gen')
+            .description('generate code using AI')
+            .option('--prompt <prompt>', 'generation prompt')
+            .option('--template <template>', 'use specific template')
+            .option('--context <path>', 'include context from path')
+            .option('--output <path>', 'output file path')
+            .action(async (type, options) => {
+            await this.generateCode(type, options);
+        });
+        // Code review
+        aiCmd
+            .command('review [files...]')
+            .description('AI-powered code review')
+            .option('--focus <aspect>', 'review focus (security, performance, style)', 'all')
+            .option('--severity <level>', 'minimum issue severity', 'info')
+            .option('--suggest-fixes', 'suggest fixes for issues')
+            .action(async (files, options) => {
+            await this.reviewCode(files, options);
+        });
+        // Code refactoring
+        aiCmd
+            .command('refactor <target>')
+            .description('AI-assisted code refactoring')
+            .option('--type <type>', 'refactoring type (extract, rename, optimize)', 'optimize')
+            .option('--scope <scope>', 'refactoring scope (function, class, file)', 'function')
+            .option('--dry-run', 'show refactoring plan without applying')
+            .action(async (target, options) => {
+            await this.refactorCode(target, options);
+        });
+        // Documentation generation
+        aiCmd
+            .command('docs <target>')
+            .description('generate documentation using AI')
+            .option('--type <type>', 'documentation type (api, readme, comments)', 'api')
+            .option('--format <format>', 'output format (markdown, html, json)', 'markdown')
+            .option('--include-examples', 'include code examples')
+            .action(async (target, options) => {
+            await this.generateDocs(target, options);
+        });
+        // Test generation
+        aiCmd
+            .command('test <target>')
+            .description('generate tests using AI')
+            .option('--framework <framework>', 'testing framework (jest, mocha, vitest)', 'jest')
+            .option('--coverage <level>', 'coverage level (unit, integration, e2e)', 'unit')
+            .option('--mocks', 'generate mock objects')
+            .action(async (target, options) => {
+            await this.generateTests(target, options);
+        });
+        // Chat interface
+        aiCmd
+            .command('chat')
+            .alias('c')
+            .description('start AI chat session')
+            .option('--model <model>', 'AI model to use')
+            .option('--context <path>', 'include project context')
+            .option('--session <id>', 'resume existing session')
+            .action(async (options) => {
+            await this.startChatSession(options);
+        });
+        // Code analysis
+        aiCmd
+            .command('analyze <target>')
+            .description('AI-powered code analysis')
+            .option('--aspect <aspect>', 'analysis aspect (complexity, maintainability, security)', 'all')
+            .option('--suggestions', 'include improvement suggestions')
+            .action(async (target, options) => {
+            await this.analyzeCode(target, options);
+        });
+        // Performance optimization
+        aiCmd
+            .command('optimize <target>')
+            .description('AI-powered performance optimization')
+            .option('--focus <focus>', 'optimization focus (speed, memory, bundle)', 'speed')
+            .option('--benchmarks', 'run before/after benchmarks')
+            .action(async (target, options) => {
+            await this.optimizeCode(target, options);
+        });
+        // AI Setup Command
+        aiCmd
+            .command('setup')
+            .description('setup AI configuration and API keys')
+            .option('--provider <provider>', 'AI provider (claude, openai)', 'claude')
+            .option('--api-key <key>', 'API key for the provider')
+            .option('--validate', 'validate the API key after setup')
+            .action(async (options) => {
+            await this.setupAI(options);
+        });
+        // Status Command
+        aiCmd
+            .command('status')
+            .description('check AI configuration status')
+            .action(async () => {
+            await this.showAIStatus();
+        });
+        // Validate Command
+        aiCmd
+            .command('validate')
+            .description('validate AI connection and API key')
+            .action(async () => {
+            await this.validateAI();
+        });
+        // Configuration
+        aiCmd.command('config').description('configure AI settings');
+        aiCmd
+            .command('config set <key> <value>')
+            .description('set AI configuration')
+            .action(async (key, value) => {
+            await this.setAIConfig(key, value);
+        });
+        aiCmd
+            .command('config get [key]')
+            .description('get AI configuration')
+            .action(async (key) => {
+            await this.getAIConfig(key);
+        });
+    }
+    /**
+     * Generate code using AI
+     */
+    async generateCode(type, options) {
+        try {
+            // Check if AI is ready
+            if (!this.aiService.isReady()) {
+                console.log(chalk_1.default.red('\n❌ AI service not configured'));
+                console.log(chalk_1.default.yellow('Run `wundr ai setup` to configure your API key first'));
+                return;
+            }
+            logger_1.logger.info(`Generating ${chalk_1.default.cyan(type)} code...`);
+            const prompt = options.prompt || (await this.promptForGeneration(type));
+            const context = options.context
+                ? await this.loadContext(options.context)
+                : '';
+            const generatedCode = await this.callAI('generate', {
+                type,
+                prompt,
+                context,
+                template: options.template,
+            });
+            if (options.output) {
+                await this.saveGeneratedCode(generatedCode, options.output);
+                logger_1.logger.success(`Code generated and saved to ${options.output}`);
+            }
+            else {
+                console.log(chalk_1.default.green('\nGenerated Code:'));
+                console.log(generatedCode);
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_GENERATE_FAILED', 'Failed to generate code', { type, options }, true);
+        }
+    }
+    /**
+     * AI-powered code review
+     */
+    async reviewCode(files, options) {
+        try {
+            // Check if AI is ready
+            if (!this.aiService.isReady()) {
+                console.log(chalk_1.default.red('\n❌ AI service not configured'));
+                console.log(chalk_1.default.yellow('Run `wundr ai setup` to configure your API key first'));
+                return;
+            }
+            logger_1.logger.info('Starting AI code review...');
+            const filesToReview = files.length > 0 ? files : await this.getChangedFiles();
+            const reviewResults = [];
+            for (const file of filesToReview) {
+                logger_1.logger.debug(`Reviewing ${file}...`);
+                const code = await this.readFile(file);
+                const review = await this.callAI('review', {
+                    code,
+                    file,
+                    focus: options.focus,
+                    severity: options.severity,
+                });
+                reviewResults.push({
+                    file,
+                    issues: review.issues,
+                    suggestions: review.suggestions,
+                    score: review.score,
+                });
+            }
+            this.displayReviewResults(reviewResults);
+            if (options.suggestFixes) {
+                await this.suggestFixes(reviewResults);
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_REVIEW_FAILED', 'Failed to review code', { files, options }, true);
+        }
+    }
+    /**
+     * AI-assisted code refactoring
+     */
+    async refactorCode(target, options) {
+        try {
+            // Check if AI is ready
+            if (!this.aiService.isReady()) {
+                console.log(chalk_1.default.red('\n❌ AI service not configured'));
+                console.log(chalk_1.default.yellow('Run `wundr ai setup` to configure your API key first'));
+                return;
+            }
+            logger_1.logger.info(`Refactoring ${chalk_1.default.cyan(target)}...`);
+            const code = await this.readFile(target);
+            const refactoringPlan = await this.callAI('refactor', {
+                code,
+                target,
+                type: options.type,
+                scope: options.scope,
+            });
+            if (options.dryRun) {
+                logger_1.logger.info('Refactoring Plan:');
+                console.log(refactoringPlan.description);
+                console.log('\nProposed Changes:');
+                refactoringPlan.changes.forEach((change, i) => {
+                    console.log(`${i + 1}. ${change.description}`);
+                });
+                return;
+            }
+            const { proceed } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'proceed',
+                    message: 'Apply refactoring changes?',
+                    default: false,
+                },
+            ]);
+            if (proceed) {
+                await this.applyRefactoring(target, refactoringPlan);
+                logger_1.logger.success(`Refactoring applied to ${target}`);
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_REFACTOR_FAILED', 'Failed to refactor code', { target, options }, true);
+        }
+    }
+    /**
+     * Generate documentation using AI
+     */
+    async generateDocs(target, options) {
+        try {
+            // Check if AI is ready
+            if (!this.aiService.isReady()) {
+                console.log(chalk_1.default.red('\n❌ AI service not configured'));
+                console.log(chalk_1.default.yellow('Run `wundr ai setup` to configure your API key first'));
+                return;
+            }
+            logger_1.logger.info(`Generating ${options.type} documentation for ${chalk_1.default.cyan(target)}...`);
+            const code = await this.readFile(target);
+            const docs = await this.callAI('docs', {
+                code,
+                target,
+                type: options.type,
+                format: options.format,
+                includeExamples: options.includeExamples,
+            });
+            const outputPath = this.getDocsOutputPath(target, options.type, options.format);
+            await this.saveGeneratedDocs(docs, outputPath);
+            logger_1.logger.success(`Documentation generated: ${outputPath}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_DOCS_FAILED', 'Failed to generate documentation', { target, options }, true);
+        }
+    }
+    /**
+     * Generate tests using AI
+     */
+    async generateTests(target, options) {
+        try {
+            // Check if AI is ready
+            if (!this.aiService.isReady()) {
+                console.log(chalk_1.default.red('\n❌ AI service not configured'));
+                console.log(chalk_1.default.yellow('Run `wundr ai setup` to configure your API key first'));
+                return;
+            }
+            logger_1.logger.info(`Generating tests for ${chalk_1.default.cyan(target)}...`);
+            const code = await this.readFile(target);
+            const tests = await this.callAI('test', {
+                code,
+                target,
+                framework: options.framework,
+                coverage: options.coverage,
+                mocks: options.mocks,
+            });
+            const testPath = this.getTestOutputPath(target, options.framework);
+            await this.saveGeneratedCode(tests, testPath);
+            logger_1.logger.success(`Tests generated: ${testPath}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_TEST_FAILED', 'Failed to generate tests', { target, options }, true);
+        }
+    }
+    /**
+     * Start AI chat session
+     */
+    async startChatSession(options) {
+        try {
+            // Check if AI is ready
+            if (!this.aiService.isReady()) {
+                console.log(chalk_1.default.red('\n❌ AI service not configured'));
+                console.log(chalk_1.default.yellow('Run `wundr ai setup` to configure your API key first'));
+                return;
+            }
+            logger_1.logger.info('Starting AI chat session...');
+            const session = options.session
+                ? await this.loadChatSession(options.session)
+                : await this.createChatSession(options);
+            await this.runChatLoop(session);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_CHAT_FAILED', 'Failed to start chat session', { options }, true);
+        }
+    }
+    /**
+     * AI-powered code analysis
+     */
+    async analyzeCode(target, options) {
+        try {
+            // Check if AI is ready
+            if (!this.aiService.isReady()) {
+                console.log(chalk_1.default.red('\n❌ AI service not configured'));
+                console.log(chalk_1.default.yellow('Run `wundr ai setup` to configure your API key first'));
+                return;
+            }
+            logger_1.logger.info(`Analyzing ${chalk_1.default.cyan(target)}...`);
+            const code = await this.readFile(target);
+            const analysis = await this.callAI('analyze', {
+                code,
+                target,
+                aspect: options.aspect,
+                suggestions: options.suggestions,
+            });
+            this.displayAnalysisResults(analysis);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_ANALYZE_FAILED', 'Failed to analyze code', { target, options }, true);
+        }
+    }
+    /**
+     * AI-powered performance optimization
+     */
+    async optimizeCode(target, options) {
+        try {
+            // Check if AI is ready
+            if (!this.aiService.isReady()) {
+                console.log(chalk_1.default.red('\n❌ AI service not configured'));
+                console.log(chalk_1.default.yellow('Run `wundr ai setup` to configure your API key first'));
+                return;
+            }
+            logger_1.logger.info(`Optimizing ${chalk_1.default.cyan(target)}...`);
+            const code = await this.readFile(target);
+            let beforeBenchmark;
+            if (options.benchmarks) {
+                beforeBenchmark = await this.runBenchmark(target);
+            }
+            const optimization = await this.callAI('optimize', {
+                code,
+                target,
+                focus: options.focus,
+            });
+            const { apply } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'apply',
+                    message: 'Apply optimization changes?',
+                    default: false,
+                },
+            ]);
+            if (apply) {
+                await this.applyOptimization(target, optimization);
+                if (options.benchmarks && beforeBenchmark) {
+                    const afterBenchmark = await this.runBenchmark(target);
+                    this.displayBenchmarkComparison(beforeBenchmark, afterBenchmark);
+                }
+                logger_1.logger.success(`Code optimized: ${target}`);
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_OPTIMIZE_FAILED', 'Failed to optimize code', { target, options }, true);
+        }
+    }
+    /**
+     * Set AI configuration
+     */
+    async setAIConfig(key, value) {
+        try {
+            this.configManager.set(`ai.${key}`, value);
+            await this.configManager.saveConfig();
+            logger_1.logger.success(`AI configuration updated: ${key} = ${value}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_CONFIG_SET_FAILED', 'Failed to set AI configuration', { key, value }, true);
+        }
+    }
+    /**
+     * Get AI configuration
+     */
+    async getAIConfig(key) {
+        try {
+            if (key) {
+                const value = this.configManager.get(`ai.${key}`);
+                console.log(`${key}: ${value}`);
+            }
+            else {
+                const aiConfig = this.configManager.get('ai');
+                console.log(JSON.stringify(aiConfig, null, 2));
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_CONFIG_GET_FAILED', 'Failed to get AI configuration', { key }, true);
+        }
+    }
+    /**
+     * Setup AI configuration
+     */
+    async setupAI(options) {
+        try {
+            console.log(chalk_1.default.blue('\n🤖 Wundr AI Setup'));
+            console.log(chalk_1.default.gray('Configure your AI assistant for enhanced CLI features\n'));
+            let { provider, apiKey } = options;
+            // Ask for provider if not specified
+            if (!provider) {
+                const providerAnswer = await inquirer_1.default.prompt([
+                    {
+                        type: 'list',
+                        name: 'provider',
+                        message: 'Select AI provider:',
+                        choices: [
+                            { name: 'Claude (Anthropic)', value: 'claude' },
+                            { name: 'OpenAI GPT', value: 'openai' },
+                        ],
+                        default: 'claude',
+                    },
+                ]);
+                provider = providerAnswer.provider;
+            }
+            // Ask for API key if not provided
+            if (!apiKey) {
+                const keyPrompt = provider === 'claude'
+                    ? 'Enter your Claude API key (from https://console.anthropic.com):'
+                    : 'Enter your OpenAI API key (from https://platform.openai.com):';
+                const keyAnswer = await inquirer_1.default.prompt([
+                    {
+                        type: 'password',
+                        name: 'apiKey',
+                        message: keyPrompt,
+                        validate: input => {
+                            if (!input || input.length < 10) {
+                                return 'Please enter a valid API key';
+                            }
+                            return true;
+                        },
+                    },
+                ]);
+                apiKey = keyAnswer.apiKey;
+            }
+            // Set up the AI service
+            await this.aiService.setupAI(apiKey, provider);
+            // Validate if requested
+            if (options.validate) {
+                console.log(chalk_1.default.blue('\nValidating API key...'));
+                const validation = await this.aiService.validateConnection();
+                if (validation.connected) {
+                    console.log(chalk_1.default.green('✅ API key is valid and working!'));
+                }
+                else {
+                    console.log(chalk_1.default.red(`❌ API key validation failed: ${validation.error}`));
+                    return;
+                }
+            }
+            console.log(chalk_1.default.green('\n✅ AI setup completed successfully!'));
+            console.log(chalk_1.default.gray('\nYou can now use AI features like:'));
+            console.log(chalk_1.default.gray('  • wundr ai chat - Interactive AI assistant'));
+            console.log(chalk_1.default.gray('  • wundr ai generate - Code generation'));
+            console.log(chalk_1.default.gray('  • wundr ai review - Code review'));
+            console.log(chalk_1.default.gray('\nRun `wundr ai status` to check configuration'));
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_SETUP_FAILED', 'Failed to setup AI configuration', { options }, true);
+        }
+    }
+    /**
+     * Show AI status
+     */
+    async showAIStatus() {
+        try {
+            const status = this.aiService.getStatus();
+            console.log(chalk_1.default.blue('\n🤖 AI Configuration Status\n'));
+            console.log(`Provider: ${chalk_1.default.cyan(status.provider)}`);
+            console.log(`Model: ${chalk_1.default.cyan(status.model)}`);
+            console.log(`API Key: ${status.hasApiKey ? chalk_1.default.green('✅ Configured') : chalk_1.default.red('❌ Missing')}`);
+            console.log(`Status: ${status.ready ? chalk_1.default.green('✅ Ready') : chalk_1.default.yellow('⚠️  Not Ready')}`);
+            if (!status.hasApiKey) {
+                console.log(chalk_1.default.yellow('\n⚠️  API key not configured'));
+                console.log(chalk_1.default.gray('Run `wundr ai setup` to configure your API key'));
+                console.log(chalk_1.default.gray('Or set the CLAUDE_API_KEY environment variable'));
+            }
+            else if (!status.ready) {
+                console.log(chalk_1.default.yellow('\n⚠️  AI service not ready'));
+                console.log(chalk_1.default.gray('Try running `wundr ai validate` to check connection'));
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_STATUS_FAILED', 'Failed to get AI status', {}, true);
+        }
+    }
+    /**
+     * Validate AI connection
+     */
+    async validateAI() {
+        try {
+            console.log(chalk_1.default.blue('\n🔍 Validating AI connection...'));
+            const validation = await this.aiService.validateConnection();
+            console.log(`\nProvider: ${chalk_1.default.cyan(validation.provider)}`);
+            console.log(`Model: ${chalk_1.default.cyan(validation.model)}`);
+            if (validation.connected) {
+                console.log(chalk_1.default.green('\n✅ Connection successful!'));
+                console.log(chalk_1.default.gray('AI features are ready to use.'));
+            }
+            else {
+                console.log(chalk_1.default.red('\n❌ Connection failed'));
+                console.log(chalk_1.default.red(`Error: ${validation.error}`));
+                if (validation.error?.includes('API key')) {
+                    console.log(chalk_1.default.yellow('\n💡 Try:'));
+                    console.log(chalk_1.default.gray('1. Run `wundr ai setup` to configure your API key'));
+                    console.log(chalk_1.default.gray('2. Check your API key is valid and has sufficient credits'));
+                    console.log(chalk_1.default.gray('3. Verify your internet connection'));
+                }
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_AI_VALIDATE_FAILED', 'Failed to validate AI connection', {}, true);
+        }
+    }
+    /**
+     * Helper methods
+     */
+    async callAI(operation, params) {
+        // Check if AI service is ready
+        if (!this.aiService.isReady()) {
+            throw new Error('AI service not configured. Set ANTHROPIC_API_KEY or OPENAI_API_KEY, or run `wundr ai setup`.');
+        }
+        logger_1.logger.debug(`Calling AI for operation: ${operation}`);
+        const sessionId = `ai-cmd-${operation}-${Date.now()}`;
+        switch (operation) {
+            case 'generate': {
+                const prompt = [
+                    `Generate ${params.type} code.`,
+                    params.prompt ? `Requirements: ${params.prompt}` : '',
+                    params.template ? `Use template style: ${params.template}` : '',
+                    params.context ? `Context:\n${params.context}` : '',
+                    'Return only the code, no explanation.',
+                ]
+                    .filter(Boolean)
+                    .join('\n');
+                return this.aiService.sendMessage(sessionId, prompt);
+            }
+            case 'review': {
+                const prompt = [
+                    `Review the following ${params.file} code for issues.`,
+                    `Focus: ${params.focus || 'all'}. Minimum severity: ${params.severity || 'info'}.`,
+                    'Return a JSON object with this exact shape: {"issues":[{"severity":"string","description":"string"}],"suggestions":["string"],"score":number}',
+                    `Code:\n${params.code}`,
+                ].join('\n');
+                const raw = await this.aiService.sendMessage(sessionId, prompt);
+                try {
+                    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+                    return jsonMatch
+                        ? JSON.parse(jsonMatch[0])
+                        : { issues: [], suggestions: [], score: 0 };
+                }
+                catch {
+                    return { issues: [], suggestions: [], score: 0 };
+                }
+            }
+            case 'refactor': {
+                const prompt = [
+                    `Create a refactoring plan for the following code in ${params.target}.`,
+                    `Refactoring type: ${params.type || 'optimize'}. Scope: ${params.scope || 'function'}.`,
+                    'Return a JSON object with this exact shape: {"description":"string","changes":[{"description":"string","code":"string"}]}',
+                    `Code:\n${params.code}`,
+                ].join('\n');
+                const raw = await this.aiService.sendMessage(sessionId, prompt);
+                try {
+                    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+                    return jsonMatch
+                        ? JSON.parse(jsonMatch[0])
+                        : { description: '', changes: [] };
+                }
+                catch {
+                    return { description: '', changes: [] };
+                }
+            }
+            case 'docs': {
+                const prompt = [
+                    `Generate ${params.type || 'api'} documentation in ${params.format || 'markdown'} format for ${params.target}.`,
+                    params.includeExamples ? 'Include code examples.' : '',
+                    `Code:\n${params.code}`,
+                ]
+                    .filter(Boolean)
+                    .join('\n');
+                return this.aiService.sendMessage(sessionId, prompt);
+            }
+            case 'test': {
+                const prompt = [
+                    `Generate ${params.coverage || 'unit'} tests using ${params.framework || 'jest'} for ${params.target}.`,
+                    params.mocks ? 'Include mock objects where appropriate.' : '',
+                    'Return only the test code, no explanation.',
+                    `Code:\n${params.code}`,
+                ]
+                    .filter(Boolean)
+                    .join('\n');
+                return this.aiService.sendMessage(sessionId, prompt);
+            }
+            case 'analyze': {
+                const prompt = [
+                    `Analyze the following code from ${params.target}.`,
+                    `Aspect: ${params.aspect || 'all'}.`,
+                    params.suggestions ? 'Include improvement suggestions.' : '',
+                    'Return a JSON object with this exact shape: {"complexity":"string","maintainability":"string","suggestions":["string"]}',
+                    `Code:\n${params.code}`,
+                ]
+                    .filter(Boolean)
+                    .join('\n');
+                const raw = await this.aiService.sendMessage(sessionId, prompt);
+                try {
+                    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+                    return jsonMatch
+                        ? JSON.parse(jsonMatch[0])
+                        : {
+                            complexity: 'unknown',
+                            maintainability: 'unknown',
+                            suggestions: [],
+                        };
+                }
+                catch {
+                    return {
+                        complexity: 'unknown',
+                        maintainability: 'unknown',
+                        suggestions: [],
+                    };
+                }
+            }
+            case 'optimize': {
+                const prompt = [
+                    `Create a performance optimization plan for the following code in ${params.target}.`,
+                    `Optimization focus: ${params.focus || 'speed'}.`,
+                    'Return a JSON object with this exact shape: {"description":"string","changes":[{"description":"string"}],"optimizedCode":"string"}',
+                    `Code:\n${params.code}`,
+                ].join('\n');
+                const raw = await this.aiService.sendMessage(sessionId, prompt);
+                try {
+                    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+                    return jsonMatch
+                        ? JSON.parse(jsonMatch[0])
+                        : { description: '', changes: [], optimizedCode: params.code };
+                }
+                catch {
+                    return { description: '', changes: [], optimizedCode: params.code };
+                }
+            }
+            case 'chat':
+                return this.aiService.sendMessage(sessionId, params.message || '');
+            case 'suggest-fix': {
+                const prompt = [
+                    `Suggest a fix for the following issue in ${params.file}:`,
+                    `Issue (${params.severity}): ${params.issue}`,
+                    'Return a JSON object with this shape: {"suggestion":"string"}',
+                ].join('\n');
+                const raw = await this.aiService.sendMessage(sessionId, prompt);
+                try {
+                    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+                    return jsonMatch ? JSON.parse(jsonMatch[0]) : { suggestion: raw };
+                }
+                catch {
+                    return { suggestion: raw };
+                }
+            }
+            default:
+                throw new Error(`Unknown AI operation: ${operation}`);
+        }
+    }
+    async promptForGeneration(type) {
+        const { prompt } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'prompt',
+                message: `Describe the ${type} you want to generate:`,
+                validate: input => input.length > 0 || 'Prompt is required',
+            },
+        ]);
+        return prompt;
+    }
+    async loadContext(contextPath) {
+        const fs = await Promise.resolve().then(() => tslib_1.__importStar(require('fs/promises')));
+        const path = await Promise.resolve().then(() => tslib_1.__importStar(require('path')));
+        const stat = await fs.stat(contextPath);
+        if (stat.isDirectory()) {
+            // Read all TypeScript/JavaScript files in the directory (non-recursive, shallow)
+            const entries = await fs.readdir(contextPath);
+            const parts = [];
+            for (const entry of entries) {
+                if (/\.(ts|tsx|js|jsx)$/.test(entry)) {
+                    const filePath = path.join(contextPath, entry);
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    parts.push(`// ${filePath}\n${content}`);
+                }
+            }
+            return parts.join('\n\n');
+        }
+        return fs.readFile(contextPath, 'utf-8');
+    }
+    async saveGeneratedCode(code, outputPath) {
+        const fs = await Promise.resolve().then(() => tslib_1.__importStar(require('fs/promises')));
+        const path = await Promise.resolve().then(() => tslib_1.__importStar(require('path')));
+        // Ensure directory exists
+        const dir = path.dirname(outputPath);
+        await fs.mkdir(dir, { recursive: true });
+        // Write the generated code to file
+        await fs.writeFile(outputPath, code, 'utf-8');
+        logger_1.logger.debug(`Saved generated code to ${outputPath}`);
+    }
+    async readFile(filePath) {
+        const fs = await Promise.resolve().then(() => tslib_1.__importStar(require('fs/promises')));
+        return fs.readFile(filePath, 'utf-8');
+    }
+    async getChangedFiles() {
+        const { execSync } = await Promise.resolve().then(() => tslib_1.__importStar(require('child_process')));
+        try {
+            const output = execSync('git diff --name-only HEAD', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            if (!output) {
+                return [];
+            }
+            return output.split('\n').filter(Boolean);
+        }
+        catch {
+            // Fall back to staged changes if HEAD diff fails (e.g. no commits yet)
+            try {
+                const { execSync: exec } = await Promise.resolve().then(() => tslib_1.__importStar(require('child_process')));
+                const output = exec('git diff --name-only --cached', {
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                }).trim();
+                return output ? output.split('\n').filter(Boolean) : [];
+            }
+            catch {
+                return [];
+            }
+        }
+    }
+    displayReviewResults(results) {
+        console.log(chalk_1.default.blue('\nCode Review Results:'));
+        results.forEach(result => {
+            console.log(`\n${chalk_1.default.cyan(result.file)} (Score: ${result.score}/100)`);
+            if (result.issues.length > 0) {
+                result.issues.forEach(issue => {
+                    console.log(`  ${issue.severity}: ${issue.description}`);
+                });
+            }
+        });
+    }
+    async suggestFixes(results) {
+        logger_1.logger.info('Generating fix suggestions...');
+        for (const result of results) {
+            if (result.issues.length > 0) {
+                console.log(chalk_1.default.yellow(`\nSuggested fixes for ${result.file}:`));
+                for (const issue of result.issues) {
+                    const fix = await this.callAI('suggest-fix', {
+                        file: result.file,
+                        issue: issue.description,
+                        severity: issue.severity,
+                    });
+                    console.log(`  - ${issue.description}: ${fix.suggestion || 'No automatic fix available'}`);
+                }
+            }
+        }
+    }
+    async applyRefactoring(target, plan) {
+        const fs = await Promise.resolve().then(() => tslib_1.__importStar(require('fs/promises')));
+        logger_1.logger.debug(`Applying refactoring to ${target}`);
+        logger_1.logger.info(`Refactoring: ${plan.description}`);
+        // Apply each change from the refactoring plan
+        for (const change of plan.changes) {
+            logger_1.logger.debug(`  Applying: ${change.description}`);
+            if (change.code) {
+                await fs.writeFile(target, change.code, 'utf-8');
+            }
+        }
+    }
+    getDocsOutputPath(target, type, format) {
+        const ext = format === 'markdown' ? 'md' : format;
+        return `docs/${target}.${type}.${ext}`;
+    }
+    async saveGeneratedDocs(docs, outputPath) {
+        const fs = await Promise.resolve().then(() => tslib_1.__importStar(require('fs/promises')));
+        const path = await Promise.resolve().then(() => tslib_1.__importStar(require('path')));
+        // Ensure docs directory exists
+        const dir = path.dirname(outputPath);
+        await fs.mkdir(dir, { recursive: true });
+        // Write the generated documentation to file
+        await fs.writeFile(outputPath, docs, 'utf-8');
+        logger_1.logger.debug(`Saved documentation to ${outputPath}`);
+    }
+    getTestOutputPath(target, framework) {
+        const path = require('path');
+        const baseName = path.basename(target, path.extname(target));
+        const dirName = path.dirname(target);
+        // Use framework-specific test file extensions
+        const extension = framework === 'vitest' ? '.test.ts' : '.test.js';
+        return path.join(dirName, '__tests__', `${baseName}${extension}`);
+    }
+    async loadChatSession(sessionId) {
+        // Load existing chat session
+        return {
+            id: sessionId,
+            model: 'claude-3',
+            history: [],
+            created: new Date(),
+            updated: new Date(),
+        };
+    }
+    async createChatSession(options) {
+        return {
+            id: `session-${Date.now()}`,
+            model: options.model || 'claude-3',
+            context: options.context,
+            history: [],
+            created: new Date(),
+            updated: new Date(),
+        };
+    }
+    async runChatLoop(session) {
+        console.log(chalk_1.default.green(`\nAI Chat Session (${session.model})`));
+        console.log(chalk_1.default.gray('Type "exit" to end the session\n'));
+        // Load existing session into AI service
+        this.aiService.loadChatSession(session);
+        while (true) {
+            const { message } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'message',
+                    message: 'You:',
+                    validate: input => input.length > 0 || 'Message cannot be empty',
+                },
+            ]);
+            if (message.toLowerCase() === 'exit') {
+                break;
+            }
+            try {
+                // Use real AI service for chat
+                const response = await this.aiService.sendMessage(session.id, message, {
+                    projectPath: process.cwd(),
+                    currentGoal: 'Interactive chat session',
+                });
+                console.log(chalk_1.default.cyan(`AI: ${response}`));
+                // Update session history from AI service
+                session.history = this.aiService.exportChatSession(session.id);
+                session.updated = new Date();
+            }
+            catch (error) {
+                console.log(chalk_1.default.red(`Error: ${error.message}`));
+                console.log(chalk_1.default.yellow('\nTip: Try `wundr ai validate` to check your connection'));
+            }
+        }
+        logger_1.logger.success('Chat session ended');
+    }
+    displayAnalysisResults(analysis) {
+        console.log(chalk_1.default.blue('\nCode Analysis Results:'));
+        console.log(`Complexity: ${analysis.complexity}`);
+        console.log(`Maintainability: ${analysis.maintainability}`);
+        if (analysis.suggestions.length > 0) {
+            console.log('\nSuggestions:');
+            analysis.suggestions.forEach((suggestion, i) => {
+                console.log(`${i + 1}. ${suggestion}`);
+            });
+        }
+    }
+    async runBenchmark(target) {
+        const { performance } = await Promise.resolve().then(() => tslib_1.__importStar(require('perf_hooks')));
+        logger_1.logger.debug(`Running benchmark for ${target}`);
+        const startTime = performance.now();
+        const startMemory = process.memoryUsage().heapUsed / 1024 / 1024;
+        // Simulate loading and analyzing the file for benchmarking
+        const code = await this.readFile(target);
+        // Simple analysis to measure time
+        const lines = code.split('\n').length;
+        logger_1.logger.debug(`Analyzed ${lines} lines`);
+        const endTime = performance.now();
+        const endMemory = process.memoryUsage().heapUsed / 1024 / 1024;
+        return {
+            time: Math.round(endTime - startTime),
+            memory: Math.round(endMemory - startMemory),
+        };
+    }
+    async applyOptimization(target, optimization) {
+        const fs = await Promise.resolve().then(() => tslib_1.__importStar(require('fs/promises')));
+        logger_1.logger.debug(`Applying optimization to ${target}`);
+        logger_1.logger.info(`Optimization: ${optimization.description}`);
+        // Log each change being applied
+        for (const change of optimization.changes) {
+            logger_1.logger.debug(`  Applying: ${change.description}`);
+        }
+        // Write the optimized code to the file
+        if (optimization.optimizedCode) {
+            await fs.writeFile(target, optimization.optimizedCode, 'utf-8');
+            logger_1.logger.success(`Optimization applied to ${target}`);
+        }
+    }
+    displayBenchmarkComparison(before, after) {
+        console.log(chalk_1.default.blue('\nBenchmark Comparison:'));
+        const timeDiff = after.time - before.time;
+        const memDiff = after.memory - before.memory;
+        const timeColor = timeDiff < 0 ? chalk_1.default.green : chalk_1.default.yellow;
+        const memColor = memDiff < 0 ? chalk_1.default.green : chalk_1.default.yellow;
+        console.log(`Time: ${before.time}ms → ${after.time}ms (${timeColor(timeDiff > 0 ? '+' : '')}${timeColor(timeDiff + 'ms')})`);
+        console.log(`Memory: ${before.memory}MB → ${after.memory}MB (${memColor(memDiff > 0 ? '+' : '')}${memColor(memDiff + 'MB')})`);
+    }
+}
+exports.AICommands = AICommands;
+//# sourceMappingURL=ai.js.map