@wundr.io/cli 1.0.12 → 1.0.14

package/dist/commands/chat.js

@@ -0,0 +1,678 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCommands = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+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");
+/**
+ * Chat commands for natural language interface
+ */
+class ChatCommands {
+    program;
+    configManager;
+    pluginManager;
+    activeSessions = new Map();
+    aiService;
+    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 chatCmd = this.program
+            .command('chat')
+            .alias('c')
+            .description('natural language chat interface');
+        // Start chat session
+        chatCmd
+            .command('start')
+            .description('start a new chat session')
+            .option('--model <model>', 'AI model to use', 'claude-3')
+            .option('--context <path>', 'include project context from path')
+            .option('--persona <persona>', 'AI persona (developer, architect, reviewer)', 'developer')
+            .option('--session-name <name>', 'custom session name')
+            .action(async (options) => {
+            await this.startChatSession(options);
+        });
+        // Resume chat session
+        chatCmd
+            .command('resume <sessionId>')
+            .description('resume existing chat session')
+            .action(async (sessionId) => {
+            await this.resumeChatSession(sessionId);
+        });
+        // List chat sessions
+        chatCmd
+            .command('list')
+            .alias('ls')
+            .description('list chat sessions')
+            .option('--active-only', 'show only active sessions')
+            .action(async (options) => {
+            await this.listChatSessions(options);
+        });
+        // Send single message
+        chatCmd
+            .command('ask <message>')
+            .description('send a single message and get response')
+            .option('--session <sessionId>', 'use specific session')
+            .option('--model <model>', 'AI model to use')
+            .option('--context <path>', 'include context from path')
+            .action(async (message, options) => {
+            await this.askSingleQuestion(message, options);
+        });
+        // Export chat session
+        chatCmd
+            .command('export <sessionId>')
+            .description('export chat session')
+            .option('--format <format>', 'export format (json, markdown, txt)', 'markdown')
+            .option('--output <path>', 'output file path')
+            .action(async (sessionId, options) => {
+            await this.exportChatSession(sessionId, options);
+        });
+        // Import chat session
+        chatCmd
+            .command('import <file>')
+            .description('import chat session')
+            .option('--format <format>', 'import format (json, markdown)')
+            .action(async (file, options) => {
+            await this.importChatSession(file, options);
+        });
+        // Delete chat session
+        chatCmd
+            .command('delete <sessionId>')
+            .description('delete chat session')
+            .option('--force', 'skip confirmation')
+            .action(async (sessionId, options) => {
+            await this.deleteChatSession(sessionId, options);
+        });
+        // Configure chat
+        chatCmd.command('config').description('configure chat settings');
+        chatCmd
+            .command('config set <key> <value>')
+            .description('set chat configuration')
+            .action(async (key, value) => {
+            await this.setChatConfig(key, value);
+        });
+        chatCmd
+            .command('config get [key]')
+            .description('get chat configuration')
+            .action(async (key) => {
+            await this.getChatConfig(key);
+        });
+        // Chat with files
+        chatCmd
+            .command('file <file>')
+            .description('chat about specific file')
+            .option('--action <action>', 'action to perform (explain, review, improve)', 'explain')
+            .option('--model <model>', 'AI model to use')
+            .action(async (file, options) => {
+            await this.chatWithFile(file, options);
+        });
+        // Chat with code
+        chatCmd
+            .command('code')
+            .description('chat about code from clipboard or input')
+            .option('--clipboard', 'read code from clipboard')
+            .option('--action <action>', 'action to perform (explain, review, improve)', 'explain')
+            .action(async (options) => {
+            await this.chatWithCode(options);
+        });
+        // Chat templates
+        chatCmd.command('template').description('manage chat templates');
+        chatCmd
+            .command('template list')
+            .description('list available chat templates')
+            .action(async () => {
+            await this.listChatTemplates();
+        });
+        chatCmd
+            .command('template use <name>')
+            .description('start chat with template')
+            .option('--vars <vars>', 'template variables (JSON or key=value)')
+            .action(async (name, options) => {
+            await this.useChatTemplate(name, options);
+        });
+    }
+    /**
+     * Start a new chat session
+     */
+    async startChatSession(options) {
+        try {
+            logger_1.logger.info('Starting new chat session...');
+            const session = await this.createNewSession(options);
+            this.activeSessions.set(session.id, session);
+            console.log(chalk_1.default.green(`\n🤖 Chat Session Started (${session.model})`));
+            console.log(chalk_1.default.gray(`Session ID: ${session.id}`));
+            if (session.context) {
+                console.log(chalk_1.default.gray(`Context: ${session.context}`));
+            }
+            console.log(chalk_1.default.gray('Type "exit" to end the session, "help" for commands\n'));
+            await this.runChatLoop(session);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_CHAT_START_FAILED', 'Failed to start chat session', { options }, true);
+        }
+    }
+    /**
+     * Resume existing chat session
+     */
+    async resumeChatSession(sessionId) {
+        try {
+            logger_1.logger.info(`Resuming chat session: ${sessionId}`);
+            const session = await this.loadChatSession(sessionId);
+            if (!session) {
+                throw new Error(`Chat session not found: ${sessionId}`);
+            }
+            this.activeSessions.set(sessionId, session);
+            console.log(chalk_1.default.green(`\n🤖 Chat Session Resumed (${session.model})`));
+            console.log(chalk_1.default.gray(`Session ID: ${session.id}`));
+            console.log(chalk_1.default.gray(`Messages: ${session.history.length}`));
+            console.log(chalk_1.default.gray(`Last updated: ${session.updated.toLocaleString()}\n`));
+            // Show recent messages
+            if (session.history.length > 0) {
+                console.log(chalk_1.default.blue('Recent messages:'));
+                session.history.slice(-3).forEach(msg => {
+                    const role = msg.role === 'user' ? 'You' : 'AI';
+                    const content = msg.content.length > 100
+                        ? msg.content.substring(0, 100) + '...'
+                        : msg.content;
+                    console.log(`  ${chalk_1.default.cyan(role)}: ${content}`);
+                });
+                console.log();
+            }
+            await this.runChatLoop(session);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_CHAT_RESUME_FAILED', 'Failed to resume chat session', { sessionId }, true);
+        }
+    }
+    /**
+     * List chat sessions
+     */
+    async listChatSessions(options) {
+        try {
+            const sessions = await this.getAllChatSessions();
+            const filteredSessions = options.activeOnly
+                ? sessions.filter(s => this.activeSessions.has(s.id))
+                : sessions;
+            if (filteredSessions.length === 0) {
+                logger_1.logger.info('No chat sessions found');
+                return;
+            }
+            logger_1.logger.info(`Chat sessions (${filteredSessions.length}):`);
+            const sessionData = filteredSessions.map(session => ({
+                ID: session.id,
+                Model: session.model,
+                Messages: session.history.length,
+                Created: session.created.toLocaleDateString(),
+                Updated: session.updated.toLocaleDateString(),
+                Active: this.activeSessions.has(session.id) ? '✓' : '✗',
+            }));
+            console.table(sessionData);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_CHAT_LIST_FAILED', 'Failed to list chat sessions', { options }, true);
+        }
+    }
+    /**
+     * Ask a single question
+     */
+    async askSingleQuestion(message, options) {
+        try {
+            logger_1.logger.debug('Processing single question...');
+            let session;
+            if (options.session) {
+                session = await this.loadChatSession(options.session);
+                if (!session) {
+                    throw new Error(`Chat session not found: ${options.session}`);
+                }
+            }
+            else {
+                session = await this.createNewSession({
+                    model: options.model,
+                    context: options.context,
+                });
+            }
+            const response = await this.sendMessage(session, message);
+            console.log(chalk_1.default.cyan('\nAI Response:'));
+            console.log(response);
+            console.log();
+            // Save session if it was created for this question
+            if (!options.session) {
+                await this.saveChatSession(session);
+                logger_1.logger.debug(`Session saved: ${session.id}`);
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_CHAT_ASK_FAILED', 'Failed to process question', { message, options }, true);
+        }
+    }
+    /**
+     * Export chat session
+     */
+    async exportChatSession(sessionId, options) {
+        try {
+            logger_1.logger.info(`Exporting chat session: ${sessionId}`);
+            const session = await this.loadChatSession(sessionId);
+            if (!session) {
+                throw new Error(`Chat session not found: ${sessionId}`);
+            }
+            let exportedContent;
+            switch (options.format) {
+                case 'json':
+                    exportedContent = JSON.stringify(session, null, 2);
+                    break;
+                case 'markdown':
+                    exportedContent = this.convertToMarkdown(session);
+                    break;
+                case 'txt':
+                    exportedContent = this.convertToText(session);
+                    break;
+                default:
+                    throw new Error(`Unsupported export format: ${options.format}`);
+            }
+            const outputPath = options.output || `chat-${sessionId}.${options.format}`;
+            await fs_extra_1.default.writeFile(outputPath, exportedContent);
+            logger_1.logger.success(`Chat session exported: ${outputPath}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_CHAT_EXPORT_FAILED', 'Failed to export chat session', { sessionId, options }, true);
+        }
+    }
+    /**
+     * Import chat session
+     */
+    async importChatSession(file, options) {
+        try {
+            logger_1.logger.info(`Importing chat session: ${file}`);
+            if (!(await fs_extra_1.default.pathExists(file))) {
+                throw new Error(`File not found: ${file}`);
+            }
+            let session;
+            switch (options.format) {
+                case 'json':
+                    session = await fs_extra_1.default.readJson(file);
+                    break;
+                case 'markdown':
+                    session = await this.parseMarkdown(file);
+                    break;
+                default:
+                    throw new Error(`Unsupported import format: ${options.format}`);
+            }
+            // Generate new ID for imported session
+            session.id = `imported-${Date.now()}`;
+            session.created = new Date();
+            session.updated = new Date();
+            await this.saveChatSession(session);
+            logger_1.logger.success(`Chat session imported: ${session.id}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_CHAT_IMPORT_FAILED', 'Failed to import chat session', { file, options }, true);
+        }
+    }
+    /**
+     * Delete chat session
+     */
+    async deleteChatSession(sessionId, options) {
+        try {
+            const session = await this.loadChatSession(sessionId);
+            if (!session) {
+                throw new Error(`Chat session not found: ${sessionId}`);
+            }
+            if (!options.force) {
+                const { confirm } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: `Delete chat session ${sessionId}? (${session.history.length} messages)`,
+                        default: false,
+                    },
+                ]);
+                if (!confirm) {
+                    logger_1.logger.info('Deletion cancelled');
+                    return;
+                }
+            }
+            await this.deleteChatSessionFile(sessionId);
+            this.activeSessions.delete(sessionId);
+            logger_1.logger.success(`Chat session deleted: ${sessionId}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_CHAT_DELETE_FAILED', 'Failed to delete chat session', { sessionId, options }, true);
+        }
+    }
+    /**
+     * Chat with specific file
+     */
+    async chatWithFile(file, options) {
+        try {
+            if (!(await fs_extra_1.default.pathExists(file))) {
+                throw new Error(`File not found: ${file}`);
+            }
+            const fileContent = await fs_extra_1.default.readFile(file, 'utf8');
+            const fileName = path_1.default.basename(file);
+            const actionPrompts = {
+                explain: `Please explain this code from ${fileName}:`,
+                review: `Please review this code from ${fileName} for potential issues:`,
+                improve: `Please suggest improvements for this code from ${fileName}:`,
+            };
+            const prompt = actionPrompts[options.action] ||
+                actionPrompts.explain;
+            const message = `${prompt}\n\n\`\`\`\n${fileContent}\n\`\`\``;
+            await this.askSingleQuestion(message, { model: options.model });
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_CHAT_FILE_FAILED', 'Failed to chat with file', { file, options }, true);
+        }
+    }
+    /**
+     * Chat with code
+     */
+    async chatWithCode(options) {
+        try {
+            let code;
+            if (options.clipboard) {
+                // Read from clipboard (would need clipboard library)
+                code = 'Code from clipboard'; // Placeholder
+            }
+            else {
+                const { codeInput } = await inquirer_1.default.prompt([
+                    {
+                        type: 'editor',
+                        name: 'codeInput',
+                        message: 'Enter your code:',
+                    },
+                ]);
+                code = codeInput;
+            }
+            const actionPrompts = {
+                explain: 'Please explain this code:',
+                review: 'Please review this code for potential issues:',
+                improve: 'Please suggest improvements for this code:',
+            };
+            const prompt = actionPrompts[options.action] ||
+                actionPrompts.explain;
+            const message = `${prompt}\n\n\`\`\`\n${code}\n\`\`\``;
+            await this.askSingleQuestion(message, {});
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_CHAT_CODE_FAILED', 'Failed to chat with code', { options }, true);
+        }
+    }
+    /**
+     * Helper methods for chat operations
+     */
+    async createNewSession(options) {
+        const config = this.configManager.getConfig();
+        return {
+            id: options.sessionName || `session-${Date.now()}`,
+            model: options.model || config.ai.model,
+            context: options.context,
+            history: [],
+            created: new Date(),
+            updated: new Date(),
+        };
+    }
+    async runChatLoop(session) {
+        while (true) {
+            try {
+                const { message } = await inquirer_1.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'message',
+                        message: chalk_1.default.green('You:'),
+                        validate: input => input.length > 0 || 'Message cannot be empty',
+                    },
+                ]);
+                if (message.toLowerCase() === 'exit') {
+                    break;
+                }
+                if (message.toLowerCase() === 'help') {
+                    this.showChatHelp();
+                    continue;
+                }
+                if (message.startsWith('/')) {
+                    await this.handleChatCommand(session, message);
+                    continue;
+                }
+                const response = await this.sendMessage(session, message);
+                console.log(chalk_1.default.cyan(`\nAI: ${response}\n`));
+            }
+            catch (error) {
+                logger_1.logger.error('Chat error:', error);
+                console.log(chalk_1.default.red('Sorry, there was an error processing your message.\n'));
+            }
+        }
+        // Save session when exiting
+        await this.saveChatSession(session);
+        this.activeSessions.delete(session.id);
+        logger_1.logger.success('Chat session ended and saved');
+    }
+    async sendMessage(session, message) {
+        // Add user message to history
+        const userMessage = {
+            role: 'user',
+            content: message,
+            timestamp: new Date(),
+        };
+        session.history.push(userMessage);
+        // Call AI service (mock implementation)
+        const response = await this.callAI(session, message);
+        // Add AI response to history
+        const aiMessage = {
+            role: 'assistant',
+            content: response,
+            timestamp: new Date(),
+        };
+        session.history.push(aiMessage);
+        session.updated = new Date();
+        return response;
+    }
+    async callAI(session, message) {
+        if (!this.aiService.isReady()) {
+            throw new Error('AI service not configured. Set ANTHROPIC_API_KEY environment variable to enable chat.');
+        }
+        return this.aiService.sendMessage(session.id, message);
+    }
+    showChatHelp() {
+        console.log(chalk_1.default.blue('\nChat Commands:'));
+        console.log('  exit          - End the chat session');
+        console.log('  help          - Show this help message');
+        console.log('  /clear        - Clear chat history');
+        console.log('  /save         - Save chat session');
+        console.log('  /export       - Export chat session');
+        console.log('  /context      - Show current context');
+        console.log('  /model        - Change AI model');
+        console.log();
+    }
+    async handleChatCommand(session, command) {
+        const [cmd, ...args] = command.slice(1).split(' ');
+        switch (cmd) {
+            case 'clear':
+                session.history = [];
+                console.log(chalk_1.default.green('Chat history cleared\n'));
+                break;
+            case 'save':
+                await this.saveChatSession(session);
+                console.log(chalk_1.default.green(`Session saved: ${session.id}\n`));
+                break;
+            case 'export':
+                const format = args[0] || 'markdown';
+                await this.exportChatSession(session.id, {
+                    format,
+                    output: `${session.id}.${format}`,
+                });
+                break;
+            case 'context':
+                console.log(chalk_1.default.blue('Current Context:'));
+                console.log(`  Model: ${session.model}`);
+                console.log(`  Messages: ${session.history.length}`);
+                console.log(`  Context: ${session.context || 'None'}\n`);
+                break;
+            case 'model':
+                if (args[0]) {
+                    session.model = args[0];
+                    console.log(chalk_1.default.green(`Model changed to: ${args[0]}\n`));
+                }
+                else {
+                    console.log(chalk_1.default.yellow('Current model: ' + session.model + '\n'));
+                }
+                break;
+            default:
+                console.log(chalk_1.default.red(`Unknown command: /${cmd}\n`));
+        }
+    }
+    async saveChatSession(session) {
+        const sessionPath = path_1.default.join(process.cwd(), '.wundr', 'chat', `${session.id}.json`);
+        await fs_extra_1.default.ensureDir(path_1.default.dirname(sessionPath));
+        await fs_extra_1.default.writeJson(sessionPath, session, { spaces: 2 });
+    }
+    async loadChatSession(sessionId) {
+        const sessionPath = path_1.default.join(process.cwd(), '.wundr', 'chat', `${sessionId}.json`);
+        if (await fs_extra_1.default.pathExists(sessionPath)) {
+            const data = await fs_extra_1.default.readJson(sessionPath);
+            data.created = new Date(data.created);
+            data.updated = new Date(data.updated);
+            data.history = data.history.map((msg) => ({
+                ...msg,
+                timestamp: new Date(msg.timestamp),
+            }));
+            return data;
+        }
+        return null;
+    }
+    async getAllChatSessions() {
+        const chatDir = path_1.default.join(process.cwd(), '.wundr', 'chat');
+        if (!(await fs_extra_1.default.pathExists(chatDir))) {
+            return [];
+        }
+        const files = await fs_extra_1.default.readdir(chatDir);
+        const jsonFiles = files.filter(f => f.endsWith('.json'));
+        const sessions = [];
+        for (const file of jsonFiles) {
+            try {
+                const sessionId = path_1.default.basename(file, '.json');
+                const session = await this.loadChatSession(sessionId);
+                if (session) {
+                    sessions.push(session);
+                }
+            }
+            catch (error) {
+                logger_1.logger.debug(`Failed to load session ${file}:`, error);
+            }
+        }
+        return sessions;
+    }
+    async deleteChatSessionFile(sessionId) {
+        const sessionPath = path_1.default.join(process.cwd(), '.wundr', 'chat', `${sessionId}.json`);
+        if (await fs_extra_1.default.pathExists(sessionPath)) {
+            await fs_extra_1.default.remove(sessionPath);
+        }
+    }
+    convertToMarkdown(session) {
+        let markdown = `# Chat Session: ${session.id}\n\n`;
+        markdown += `**Model:** ${session.model}\n`;
+        markdown += `**Created:** ${session.created.toLocaleString()}\n`;
+        markdown += `**Updated:** ${session.updated.toLocaleString()}\n`;
+        if (session.context) {
+            markdown += `**Context:** ${session.context}\n`;
+        }
+        markdown += `**Messages:** ${session.history.length}\n\n`;
+        markdown += '---\n\n';
+        session.history.forEach(msg => {
+            const role = msg.role === 'user' ? '**You**' : '**AI**';
+            markdown += `${role} (${msg.timestamp.toLocaleTimeString()}):\n\n`;
+            markdown += `${msg.content}\n\n`;
+            markdown += '---\n\n';
+        });
+        return markdown;
+    }
+    convertToText(session) {
+        let text = `Chat Session: ${session.id}\n`;
+        text += `Model: ${session.model}\n`;
+        text += `Created: ${session.created.toLocaleString()}\n`;
+        text += `Updated: ${session.updated.toLocaleString()}\n`;
+        text += `Messages: ${session.history.length}\n\n`;
+        text += '='.repeat(50) + '\n\n';
+        session.history.forEach(msg => {
+            const role = msg.role === 'user' ? 'You' : 'AI';
+            text += `[${msg.timestamp.toLocaleTimeString()}] ${role}:\n`;
+            text += `${msg.content}\n\n`;
+            text += '-'.repeat(30) + '\n\n';
+        });
+        return text;
+    }
+    async parseMarkdown(file) {
+        // Implementation to parse markdown format back to session
+        const content = await fs_extra_1.default.readFile(file, 'utf8');
+        // This is a simplified parser - a real implementation would be more robust
+        return {
+            id: `parsed-${Date.now()}`,
+            model: 'claude-3',
+            history: [],
+            created: new Date(),
+            updated: new Date(),
+        };
+    }
+    // Configuration methods
+    async setChatConfig(key, value) {
+        this.configManager.set(`chat.${key}`, value);
+        await this.configManager.saveConfig();
+        logger_1.logger.success(`Chat configuration updated: ${key} = ${value}`);
+    }
+    async getChatConfig(key) {
+        if (key) {
+            const value = this.configManager.get(`chat.${key}`);
+            console.log(`${key}: ${value}`);
+        }
+        else {
+            const chatConfig = this.configManager.get('chat') || {};
+            console.log(JSON.stringify(chatConfig, null, 2));
+        }
+    }
+    // Template methods
+    async listChatTemplates() {
+        const templates = [
+            'code-review',
+            'explain-code',
+            'debug-help',
+            'architecture-review',
+            'performance-optimization',
+        ];
+        console.log('Available chat templates:');
+        templates.forEach(template => {
+            console.log(`  - ${template}`);
+        });
+    }
+    async useChatTemplate(name, options) {
+        const templates = {
+            'code-review': 'Please review the following code for best practices, potential bugs, and improvements:',
+            'explain-code': 'Please explain what this code does and how it works:',
+            'debug-help': "I'm having trouble with this code. Can you help me debug it?",
+            'architecture-review': 'Please review this architectural design and suggest improvements:',
+            'performance-optimization': 'Please suggest performance optimizations for this code:',
+        };
+        const template = templates[name];
+        if (!template) {
+            throw new Error(`Template not found: ${name}`);
+        }
+        // Process template variables if provided
+        let processedTemplate = template;
+        if (options.vars) {
+            const variables = JSON.parse(options.vars);
+            Object.entries(variables).forEach(([key, value]) => {
+                processedTemplate = processedTemplate.replace(`{{${key}}}`, String(value));
+            });
+        }
+        await this.askSingleQuestion(processedTemplate, {});
+    }
+}
+exports.ChatCommands = ChatCommands;
+//# sourceMappingURL=chat.js.map