@wundr.io/cli 1.0.12 → 1.0.13

package/dist/interactive/interactive-mode.js

@@ -0,0 +1,732 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractiveMode = void 0;
+const tslib_1 = require("tslib");
+const blessed_1 = tslib_1.__importDefault(require("blessed"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const error_handler_1 = require("../utils/error-handler");
+const logger_1 = require("../utils/logger");
+/**
+ * Interactive mode manager for wizard, TUI, and chat interfaces
+ */
+class InteractiveMode {
+    configManager;
+    pluginManager;
+    activeSessions = new Map();
+    constructor(configManager, pluginManager) {
+        this.configManager = configManager;
+        this.pluginManager = pluginManager;
+    }
+    /**
+     * Launch interactive wizard mode
+     */
+    async launchWizard(mode = 'setup') {
+        try {
+            logger_1.logger.info('Launching interactive wizard...');
+            const session = {
+                mode: 'wizard',
+                config: { wizardMode: mode },
+                state: {},
+                active: true,
+            };
+            this.activeSessions.set(`wizard-${Date.now()}`, session);
+            switch (mode) {
+                case 'setup':
+                    await this.setupWizard();
+                    break;
+                case 'analyze':
+                    await this.analyzeWizard();
+                    break;
+                case 'create':
+                    await this.createWizard();
+                    break;
+                case 'govern':
+                    await this.governWizard();
+                    break;
+                default:
+                    await this.generalWizard();
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_WIZARD_FAILED', 'Failed to launch wizard', { mode }, true);
+        }
+    }
+    /**
+     * Launch chat interface
+     */
+    async launchChat(options) {
+        try {
+            logger_1.logger.info('Launching chat interface...');
+            // This would integrate with the chat commands
+            const { spawn } = await Promise.resolve().then(() => tslib_1.__importStar(require('child_process')));
+            const chatArgs = ['chat', 'start'];
+            if (options.model) {
+                chatArgs.push('--model', options.model);
+            }
+            if (options.context) {
+                chatArgs.push('--context', options.context);
+            }
+            const child = spawn('wundr', chatArgs, {
+                stdio: 'inherit',
+                shell: true,
+            });
+            child.on('exit', code => {
+                if (code !== 0) {
+                    logger_1.logger.error(`Chat interface exited with code ${code}`);
+                }
+            });
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_CHAT_LAUNCH_FAILED', 'Failed to launch chat interface', { options }, true);
+        }
+    }
+    /**
+     * Launch Terminal User Interface (TUI)
+     */
+    async launchTUI(layout = 'dashboard') {
+        try {
+            logger_1.logger.info(`Launching TUI with layout: ${layout}`);
+            const screen = blessed_1.default.screen({
+                smartCSR: true,
+                title: 'Wundr CLI Dashboard',
+            });
+            await this.setupTUILayout(screen, layout);
+            // Handle exit
+            screen.key(['escape', 'q', 'C-c'], () => {
+                return process.exit(0);
+            });
+            screen.render();
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_TUI_LAUNCH_FAILED', 'Failed to launch TUI', { layout }, true);
+        }
+    }
+    /**
+     * Setup wizard for initial configuration
+     */
+    async setupWizard() {
+        console.log(chalk_1.default.cyan('\n🚀 Welcome to Wundr CLI Setup Wizard\n'));
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'initialize',
+                message: 'Initialize Wundr in this directory?',
+                default: true,
+            },
+            {
+                type: 'list',
+                name: 'projectType',
+                message: 'What type of project is this?',
+                choices: [
+                    { name: 'Single Package', value: 'single' },
+                    { name: 'Monorepo', value: 'monorepo' },
+                    { name: 'Workspace', value: 'workspace' },
+                ],
+                when: answers => answers.initialize,
+            },
+            {
+                type: 'checkbox',
+                name: 'features',
+                message: 'Select features to enable:',
+                choices: [
+                    { name: 'Code Analysis', value: 'analysis', checked: true },
+                    { name: 'Governance Rules', value: 'governance', checked: true },
+                    { name: 'AI Assistance', value: 'ai', checked: false },
+                    { name: 'Dashboard', value: 'dashboard', checked: true },
+                    { name: 'Watch Mode', value: 'watch', checked: false },
+                ],
+                when: answers => answers.initialize,
+            },
+            {
+                type: 'input',
+                name: 'aiProvider',
+                message: 'AI Provider:',
+                default: 'claude',
+                when: answers => answers.features?.includes('ai'),
+            },
+            {
+                type: 'password',
+                name: 'aiApiKey',
+                message: 'AI API Key (optional):',
+                mask: '*',
+                when: answers => answers.features?.includes('ai'),
+            },
+        ]);
+        if (!answers.initialize) {
+            console.log(chalk_1.default.yellow('Setup cancelled'));
+            return;
+        }
+        // Execute setup commands based on answers
+        console.log(chalk_1.default.green('\n✨ Setting up your project...\n'));
+        const setupCommands = [
+            `wundr init ${answers.projectType === 'single' ? 'project' : answers.projectType}`,
+            'wundr init config',
+        ];
+        if (answers.features?.includes('governance')) {
+            setupCommands.push('wundr govern rules add no-console');
+        }
+        if (answers.features?.includes('dashboard')) {
+            setupCommands.push('wundr dashboard config set theme default');
+        }
+        for (const command of setupCommands) {
+            console.log(chalk_1.default.blue(`Running: ${command}`));
+            // Execute command (simplified for demo)
+            await this.simulateCommand(command);
+        }
+        console.log(chalk_1.default.green('\n🎉 Setup complete! Your Wundr project is ready.'));
+        console.log(chalk_1.default.gray('\nNext steps:'));
+        console.log(chalk_1.default.gray('  • Run "wundr analyze" to analyze your code'));
+        console.log(chalk_1.default.gray('  • Run "wundr dashboard start" to launch the dashboard'));
+        console.log(chalk_1.default.gray('  • Run "wundr --help" to see all available commands'));
+    }
+    /**
+     * Analysis wizard
+     */
+    async analyzeWizard() {
+        console.log(chalk_1.default.cyan('\n🔍 Code Analysis Wizard\n'));
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'analysisTypes',
+                message: 'What would you like to analyze?',
+                choices: [
+                    { name: 'Dependencies', value: 'deps', checked: true },
+                    { name: 'Code Quality', value: 'quality', checked: true },
+                    { name: 'Performance', value: 'perf', checked: false },
+                    { name: 'Architecture', value: 'arch', checked: false },
+                    { name: 'Security', value: 'security', checked: true },
+                ],
+            },
+            {
+                type: 'list',
+                name: 'outputFormat',
+                message: 'Output format:',
+                choices: [
+                    { name: 'Table (Console)', value: 'table' },
+                    { name: 'JSON File', value: 'json' },
+                    { name: 'HTML Report', value: 'html' },
+                ],
+                default: 'table',
+            },
+            {
+                type: 'confirm',
+                name: 'autoFix',
+                message: 'Automatically fix issues where possible?',
+                default: false,
+            },
+        ]);
+        console.log(chalk_1.default.green('\n🔬 Running analysis...\n'));
+        for (const analysisType of answers.analysisTypes) {
+            let command = `wundr analyze ${analysisType}`;
+            if (answers.outputFormat !== 'table') {
+                command += ` --format ${answers.outputFormat}`;
+            }
+            if (answers.autoFix) {
+                command += ' --fix';
+            }
+            console.log(chalk_1.default.blue(`Running: ${command}`));
+            await this.simulateCommand(command);
+        }
+        console.log(chalk_1.default.green('\n✅ Analysis complete!'));
+    }
+    /**
+     * Creation wizard
+     */
+    async createWizard() {
+        console.log(chalk_1.default.cyan('\n🛠️  Code Generation Wizard\n'));
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'createType',
+                message: 'What would you like to create?',
+                choices: [
+                    { name: 'Component', value: 'component' },
+                    { name: 'Service', value: 'service' },
+                    { name: 'Package (Monorepo)', value: 'package' },
+                    { name: 'Template', value: 'template' },
+                    { name: 'Workflow', value: 'workflow' },
+                    { name: 'Configuration', value: 'config' },
+                ],
+            },
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Name:',
+                validate: input => input.length > 0 || 'Name is required',
+            },
+        ]);
+        // Get specific options based on type
+        let specificAnswers = {};
+        switch (answers.createType) {
+            case 'component':
+                specificAnswers = await this.getComponentOptions();
+                break;
+            case 'service':
+                specificAnswers = await this.getServiceOptions();
+                break;
+            case 'package':
+                specificAnswers = await this.getPackageOptions();
+                break;
+            default:
+                specificAnswers = {};
+        }
+        console.log(chalk_1.default.green(`\n🏗️  Creating ${answers.createType}: ${answers.name}\n`));
+        let command = `wundr create ${answers.createType} ${answers.name}`;
+        // Add specific options to command
+        Object.entries(specificAnswers).forEach(([key, value]) => {
+            if (typeof value === 'boolean' && value) {
+                command += ` --${key}`;
+            }
+            else if (typeof value === 'string' && value) {
+                command += ` --${key} ${value}`;
+            }
+        });
+        console.log(chalk_1.default.blue(`Running: ${command}`));
+        await this.simulateCommand(command);
+        console.log(chalk_1.default.green(`\n🎉 ${answers.createType} created successfully!`));
+    }
+    /**
+     * Governance wizard
+     */
+    async governWizard() {
+        console.log(chalk_1.default.cyan('\n⚖️  Governance Setup Wizard\n'));
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'ruleCategories',
+                message: 'Select rule categories to enable:',
+                choices: [
+                    { name: 'Code Quality', value: 'quality', checked: true },
+                    { name: 'Security', value: 'security', checked: true },
+                    { name: 'Performance', value: 'performance', checked: false },
+                    { name: 'Testing', value: 'testing', checked: true },
+                    { name: 'Documentation', value: 'docs', checked: false },
+                ],
+            },
+            {
+                type: 'list',
+                name: 'severity',
+                message: 'Default severity level:',
+                choices: [
+                    { name: 'Error (Strict)', value: 'error' },
+                    { name: 'Warning (Balanced)', value: 'warning' },
+                    { name: 'Info (Lenient)', value: 'info' },
+                ],
+                default: 'warning',
+            },
+            {
+                type: 'confirm',
+                name: 'createQualityGate',
+                message: 'Create a quality gate?',
+                default: true,
+            },
+        ]);
+        console.log(chalk_1.default.green('\n⚙️  Setting up governance rules...\n'));
+        // Add rules based on categories
+        for (const category of answers.ruleCategories) {
+            const rules = this.getRulesForCategory(category);
+            for (const rule of rules) {
+                const command = `wundr govern rules add ${rule}`;
+                console.log(chalk_1.default.blue(`Running: ${command}`));
+                await this.simulateCommand(command);
+            }
+        }
+        // Set severity
+        const severityCommand = `wundr govern config set severity ${answers.severity}`;
+        console.log(chalk_1.default.blue(`Running: ${severityCommand}`));
+        await this.simulateCommand(severityCommand);
+        // Create quality gate
+        if (answers.createQualityGate) {
+            const gateCommand = 'wundr govern gate create default --conditions "coverage>80,complexity<10"';
+            console.log(chalk_1.default.blue(`Running: ${gateCommand}`));
+            await this.simulateCommand(gateCommand);
+        }
+        console.log(chalk_1.default.green('\n✅ Governance setup complete!'));
+        console.log(chalk_1.default.gray('\nRun "wundr govern check" to validate your code against the rules.'));
+    }
+    /**
+     * General purpose wizard
+     */
+    async generalWizard() {
+        console.log(chalk_1.default.cyan('\n🧙 Wundr CLI Wizard\n'));
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: 'Setup a new project', value: 'setup' },
+                    { name: 'Analyze existing code', value: 'analyze' },
+                    { name: 'Create new code', value: 'create' },
+                    { name: 'Setup governance', value: 'govern' },
+                    { name: 'Configure AI features', value: 'ai' },
+                    { name: 'Launch dashboard', value: 'dashboard' },
+                ],
+            },
+        ]);
+        switch (answers.action) {
+            case 'setup':
+                await this.setupWizard();
+                break;
+            case 'analyze':
+                await this.analyzeWizard();
+                break;
+            case 'create':
+                await this.createWizard();
+                break;
+            case 'govern':
+                await this.governWizard();
+                break;
+            case 'ai':
+                await this.aiConfigWizard();
+                break;
+            case 'dashboard':
+                await this.launchDashboard();
+                break;
+        }
+    }
+    /**
+     * AI configuration wizard
+     */
+    async aiConfigWizard() {
+        console.log(chalk_1.default.cyan('\n🤖 AI Configuration Wizard\n'));
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'provider',
+                message: 'AI Provider:',
+                choices: [
+                    { name: 'Claude (Anthropic)', value: 'claude' },
+                    { name: 'ChatGPT (OpenAI)', value: 'openai' },
+                    { name: 'Local Model', value: 'local' },
+                ],
+            },
+            {
+                type: 'list',
+                name: 'model',
+                message: 'Model:',
+                choices: answers => {
+                    switch (answers.provider) {
+                        case 'claude':
+                            return ['claude-3', 'claude-3-haiku', 'claude-3-sonnet'];
+                        case 'openai':
+                            return ['gpt-4', 'gpt-4-turbo', 'gpt-3.5-turbo'];
+                        case 'local':
+                            return ['llama2', 'codellama', 'custom'];
+                        default:
+                            return ['claude-3'];
+                    }
+                },
+            },
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: 'API Key:',
+                mask: '*',
+                when: answers => answers.provider !== 'local',
+            },
+            {
+                type: 'checkbox',
+                name: 'features',
+                message: 'Enable AI features:',
+                choices: [
+                    { name: 'Code Generation', value: 'generate', checked: true },
+                    { name: 'Code Review', value: 'review', checked: true },
+                    { name: 'Refactoring', value: 'refactor', checked: false },
+                    { name: 'Documentation', value: 'docs', checked: true },
+                    { name: 'Test Generation', value: 'test', checked: false },
+                ],
+            },
+        ]);
+        console.log(chalk_1.default.green('\n🔧 Configuring AI features...\n'));
+        // Set AI configuration
+        const commands = [
+            `wundr ai config set provider ${answers.provider}`,
+            `wundr ai config set model ${answers.model}`,
+        ];
+        if (answers.apiKey) {
+            commands.push(`wundr ai config set apiKey ${answers.apiKey}`);
+        }
+        for (const command of commands) {
+            console.log(chalk_1.default.blue(`Running: ${command}`));
+            await this.simulateCommand(command);
+        }
+        console.log(chalk_1.default.green('\n✅ AI configuration complete!'));
+        console.log(chalk_1.default.gray('\nTry "wundr ai ask" to start chatting with AI.'));
+    }
+    /**
+     * Launch dashboard shortcut
+     */
+    async launchDashboard() {
+        console.log(chalk_1.default.green('\n📊 Launching Wundr Dashboard...\n'));
+        const command = 'wundr dashboard start --open';
+        console.log(chalk_1.default.blue(`Running: ${command}`));
+        await this.simulateCommand(command);
+    }
+    /**
+     * Setup TUI layout
+     */
+    async setupTUILayout(screen, layoutType) {
+        switch (layoutType) {
+            case 'dashboard':
+                await this.setupDashboardLayout(screen);
+                break;
+            case 'monitor':
+                await this.setupMonitorLayout(screen);
+                break;
+            case 'debug':
+                await this.setupDebugLayout(screen);
+                break;
+            default:
+                await this.setupDashboardLayout(screen);
+        }
+    }
+    /**
+     * Setup dashboard TUI layout
+     */
+    async setupDashboardLayout(screen) {
+        // Header
+        const header = blessed_1.default.box({
+            top: 0,
+            left: 0,
+            width: '100%',
+            height: 3,
+            content: `{center}${chalk_1.default.cyan('🚀 Wundr CLI Dashboard')}{/center}`,
+            tags: true,
+            border: {
+                type: 'line',
+            },
+            style: {
+                fg: 'white',
+                bg: 'blue',
+                border: {
+                    fg: '#f0f0f0',
+                },
+            },
+        });
+        // Sidebar
+        const sidebar = blessed_1.default.box({
+            top: 3,
+            left: 0,
+            width: '25%',
+            height: '100%-6',
+            content: 'Navigation\n\n→ Overview\n  Analysis\n  Governance\n  AI Tools\n  Settings',
+            border: {
+                type: 'line',
+            },
+            style: {
+                fg: 'white',
+                border: {
+                    fg: '#f0f0f0',
+                },
+            },
+        });
+        // Main content
+        const main = blessed_1.default.box({
+            top: 3,
+            left: '25%',
+            width: '75%',
+            height: '100%-6',
+            content: 'Project Overview\n\n' +
+                '📁 Files: 1,234\n' +
+                '🔍 Issues: 5\n' +
+                '✅ Tests: 98% coverage\n' +
+                '📦 Dependencies: 45\n' +
+                '🚀 Performance: Good',
+            border: {
+                type: 'line',
+            },
+            style: {
+                fg: 'white',
+                border: {
+                    fg: '#f0f0f0',
+                },
+            },
+        });
+        // Footer
+        const footer = blessed_1.default.box({
+            bottom: 0,
+            left: 0,
+            width: '100%',
+            height: 3,
+            content: '{center}Press q or Esc to exit{/center}',
+            tags: true,
+            border: {
+                type: 'line',
+            },
+            style: {
+                fg: 'white',
+                bg: 'black',
+                border: {
+                    fg: '#f0f0f0',
+                },
+            },
+        });
+        screen.append(header);
+        screen.append(sidebar);
+        screen.append(main);
+        screen.append(footer);
+        // Focus handling
+        main.focus();
+    }
+    /**
+     * Setup monitor TUI layout
+     */
+    async setupMonitorLayout(screen) {
+        // Real-time monitoring layout with logs and metrics
+        const log = blessed_1.default.log({
+            top: 0,
+            left: 0,
+            width: '100%',
+            height: '100%',
+            border: {
+                type: 'line',
+            },
+            style: {
+                fg: 'white',
+                border: {
+                    fg: '#f0f0f0',
+                },
+            },
+            scrollable: true,
+            alwaysScroll: true,
+        });
+        screen.append(log);
+        // Simulate log entries
+        setInterval(() => {
+            log.log(`[${new Date().toLocaleTimeString()}] Monitoring active...`);
+        }, 2000);
+        log.focus();
+    }
+    /**
+     * Setup debug TUI layout
+     */
+    async setupDebugLayout(screen) {
+        // Debug information layout
+        const debugInfo = blessed_1.default.box({
+            top: 0,
+            left: 0,
+            width: '100%',
+            height: '100%',
+            content: 'Debug Information\n\n' +
+                'CLI Version: 1.0.0\n' +
+                'Node Version: ' +
+                process.version +
+                '\n' +
+                'Platform: ' +
+                process.platform +
+                '\n' +
+                'Working Directory: ' +
+                process.cwd() +
+                '\n' +
+                'Arguments: ' +
+                process.argv.join(' '),
+            border: {
+                type: 'line',
+            },
+            style: {
+                fg: 'white',
+                border: {
+                    fg: '#f0f0f0',
+                },
+            },
+        });
+        screen.append(debugInfo);
+        debugInfo.focus();
+    }
+    /**
+     * Helper methods for wizard options
+     */
+    async getComponentOptions() {
+        return await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Component type:',
+                choices: ['react', 'vue', 'angular'],
+                default: 'react',
+            },
+            {
+                type: 'confirm',
+                name: 'withTests',
+                message: 'Generate test files?',
+                default: true,
+            },
+            {
+                type: 'confirm',
+                name: 'withStories',
+                message: 'Generate Storybook stories?',
+                default: false,
+            },
+        ]);
+    }
+    async getServiceOptions() {
+        return await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Service type:',
+                choices: ['api', 'worker', 'microservice'],
+                default: 'api',
+            },
+            {
+                type: 'list',
+                name: 'framework',
+                message: 'Framework:',
+                choices: ['express', 'fastify', 'nest'],
+                default: 'express',
+            },
+            {
+                type: 'confirm',
+                name: 'withTests',
+                message: 'Generate test files?',
+                default: true,
+            },
+            {
+                type: 'confirm',
+                name: 'withDocs',
+                message: 'Generate API documentation?',
+                default: true,
+            },
+        ]);
+    }
+    async getPackageOptions() {
+        return await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Package type:',
+                choices: ['library', 'app', 'tool'],
+                default: 'library',
+            },
+            {
+                type: 'confirm',
+                name: 'public',
+                message: 'Make package public?',
+                default: false,
+            },
+        ]);
+    }
+    getRulesForCategory(category) {
+        const rulesByCategory = {
+            quality: ['no-console', 'no-debugger', 'prefer-const'],
+            security: ['no-eval', 'no-unsafe-inline'],
+            performance: ['no-inefficient-loops', 'prefer-map-over-loop'],
+            testing: ['require-tests', 'no-skip-tests'],
+            docs: ['require-jsdoc', 'require-readme'],
+        };
+        return rulesByCategory[category] || [];
+    }
+    async simulateCommand(command) {
+        // Simulate command execution with a delay
+        return new Promise(resolve => {
+            setTimeout(() => {
+                console.log(chalk_1.default.green(`  ✓ ${command}`));
+                resolve();
+            }, 500);
+        });
+    }
+}
+exports.InteractiveMode = InteractiveMode;
+//# sourceMappingURL=interactive-mode.js.map