mulby-cli 1.1.5

package/dist/services/ai-generator.js

@@ -0,0 +1,968 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIAgent = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const ai_1 = require("./ai");
+const session_manager_1 = require("./session-manager");
+const file_writer_1 = require("./file-writer");
+const prompts_1 = require("./ai/prompts");
+const tools_1 = require("./ai/tools");
+const context_manager_1 = require("./ai/context-manager");
+const tui_1 = require("./tui");
+const react_1 = require("../commands/create/react");
+const plan_manager_1 = require("./plan-manager");
+const plan_command_handler_1 = require("./plan-command-handler");
+const task_analyzer_1 = require("./task-analyzer");
+class AIAgent {
+    constructor(session, systemPrompt) {
+        this.session = session;
+        this.systemPrompt = systemPrompt;
+        this.aiService = ai_1.AIServiceFactory.create();
+        this.sessionManager = session_manager_1.SessionManager.getInstance();
+        this.autoApproveCommands = false;
+        this.currentPlan = null;
+        this.lastCompressedTokens = 0; // 记录上次压缩后的 token 数
+        this.fileWriter = new file_writer_1.FileWriter(session.targetDir);
+        this.planManager = new plan_manager_1.PlanManager(path.join(session.targetDir, '.mulby'));
+        this.planCommandHandler = new plan_command_handler_1.PlanCommandHandler(this.planManager, () => this.currentPlan, (plan) => { this.currentPlan = plan; }, async (plan) => { await this.planManager.savePlan(plan, this.session.id); });
+    }
+    async start(options = {}) {
+        tui_1.tui.start();
+        tui_1.tui.log(chalk_1.default.blue('🤖 AI Agent 已启动...'));
+        // Load existing plan if available
+        try {
+            this.currentPlan = await this.planManager.loadSessionPlan(this.session.id);
+            if (this.currentPlan) {
+                tui_1.tui.log(chalk_1.default.cyan(`📋 已加载任务计划: ${this.currentPlan.goal}`));
+                const summary = this.planManager.getProgressSummary(this.currentPlan);
+                tui_1.tui.log(chalk_1.default.gray(`   进度: ${summary.completed}/${summary.total} (${Math.round(summary.percentage)}%)`));
+            }
+        }
+        catch (error) {
+            // No plan exists, that's fine
+        }
+        // Initialize history if empty
+        if (this.session.conversationHistory.length === 0) {
+            this.session.conversationHistory.push({
+                role: 'system',
+                content: this.systemPrompt || prompts_1.SYSTEM_PROMPT
+            });
+        }
+        if (this.session.conversationHistory.length > 0) {
+            await this.checkAndCompressContext();
+        }
+        if (options.waitForInput) {
+            await this.handleUserInteraction();
+        }
+        await this.runLoop();
+    }
+    async runLoop() {
+        let loopCount = 0;
+        while (this.session.status !== 'completed' && this.session.status !== 'failed') {
+            loopCount++;
+            try {
+                // 0.1 Check and compress context before each turn
+                await this.checkAndCompressContext();
+                // 0.2 Update Dynamic File Map (The Head)
+                // We update the System Prompt (the first message) with the current file structure
+                // This ensures the AI always has the latest "World View".
+                if (this.session.conversationHistory.length > 0 && this.session.conversationHistory[0].role === 'system') {
+                    const currentFileMap = await this.generateFileMap();
+                    // We need to re-build the system prompt with the new map
+                    // Since we stored the initial systemPrompt in constructor, we can rebuild it.
+                    // But wait, constructure systemPrompt might be the *result* string.
+                    // Actually, prompts.ts exports `buildSystemPrompt`.
+                    // We should probably just replace the "## Current Project Structure" section if we want to be fancy,
+                    // or easier: just rebuild the whole string using `buildSystemPrompt`.
+                    // However, we don't have the original `templates` here easily unless we stored them.
+                    // Plan B: Just Append/Replace the file map at the end of the system prompt if it exists, or rely on a marker.
+                    // Better approach: Let's import buildSystemPrompt and use it.
+                    // But we don't have `templates` or `isScaffolded` state stored in AIAgent.
+                    // Let's modify AIAgent to store the original config or just hack it:
+                    // We will inject a specific marker in the prompts.ts and regex replace it here.
+                    // Or simpler: Just rebuild it if we can. 
+                    // Actually, let's keep it simple. We will update the system prompt by replacing the
+                    // content inside ```...``` of the "Current Project Structure" section if it exists,
+                    // or append it if it doesn't.
+                    const currentContent = this.session.conversationHistory[0].content;
+                    let sysContent = typeof currentContent === 'string' ? currentContent : '';
+                    const mapHeader = '## Current Project Structure';
+                    if (sysContent.includes(mapHeader)) {
+                        // Replace existing map
+                        // Regex to match: ## Current Project Structure\n(Auto-updated file tree)\n```\n[\s\S]*?\n```
+                        sysContent = sysContent.replace(/## Current Project Structure\n\(Auto-updated file tree\)\n```[\s\S]*?```/, `## Current Project Structure\n(Auto-updated file tree)\n\`\`\`\n${currentFileMap}\n\`\`\``);
+                    }
+                    else {
+                        // Append new map (first run or migration)
+                        sysContent += `\n\n## Current Project Structure\n(Auto-updated file tree)\n\`\`\`\n${currentFileMap}\n\`\`\``;
+                    }
+                    this.session.conversationHistory[0].content = sysContent;
+                }
+                tui_1.tui.setStatus(`Thinking... (Turn ${loopCount})`);
+                const startTime = Date.now();
+                let thinkingBuffer = '';
+                let isThinking = false;
+                let lastStatusUpdate = 0;
+                const response = await this.aiService.chatStream(this.session.conversationHistory, (chunk) => {
+                    // Handle thinking tags added by provider
+                    if (chunk.includes('<think>')) {
+                        isThinking = true;
+                        chunk = chunk.replace('<think>', '').trimStart();
+                    }
+                    if (chunk.includes('</think>')) {
+                        isThinking = false;
+                        chunk = chunk.replace('</think>', '').trimEnd();
+                        tui_1.tui.setStatus(`Thinking completed. Generating response...`);
+                    }
+                    if (isThinking && chunk) {
+                        thinkingBuffer += chunk;
+                        // Update partial thinking status (last 80 chars)
+                        // Clean newlines for status bar
+                        // Throttle updates to avoid TUI lag (max 10fps) (every 100ms)
+                        const now = Date.now();
+                        if (now - lastStatusUpdate > 100) {
+                            const display = thinkingBuffer.slice(-80).replace(/\n/g, ' ');
+                            tui_1.tui.setStatus(`Thinking: ${display}`);
+                            lastStatusUpdate = now;
+                        }
+                    }
+                }, {
+                    tools: tools_1.PLUGIN_GENERATION_TOOLS,
+                    toolChoice: 'auto'
+                });
+                const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+                let usageInfo = '';
+                if (response.usage) {
+                    usageInfo = `, ${response.usage.totalTokens} tokens`;
+                }
+                // Clear previous "Thinking..." line and print stats
+                // process.stdout.write(`\r\x1b[K`); // Clear line
+                tui_1.tui.log(chalk_1.default.gray(`Thinking... (Turn ${loopCount}) - ${duration}s${usageInfo}`));
+                // 2. Add Assistant Message
+                const assistantMsg = {
+                    role: 'assistant',
+                    content: response.content,
+                    reasoning_content: response.reasoning_content,
+                    tool_calls: response.toolCalls
+                };
+                this.session.conversationHistory.push(assistantMsg);
+                this.sessionManager.saveSession(this.session);
+                if (response.content) {
+                    tui_1.tui.log(chalk_1.default.white('AI: ' + response.content));
+                }
+                // 3. Handle Tool Calls
+                if (response.toolCalls && response.toolCalls.length > 0) {
+                    for (const toolCall of response.toolCalls) {
+                        const toolName = toolCall.function.name;
+                        const toolCallId = toolCall.id;
+                        let toolArgs;
+                        try {
+                            toolArgs = JSON.parse(toolCall.function.arguments);
+                        }
+                        catch (parseError) {
+                            tui_1.tui.log(chalk_1.default.red(`[Tool] JSON 解析失败: ${parseError.message}`));
+                            tui_1.tui.log(chalk_1.default.gray(`  原始参数: ${toolCall.function.arguments.slice(0, 200)}...`));
+                            // 添加错误响应让 AI 知道参数解析失败
+                            this.session.conversationHistory.push({
+                                role: 'tool',
+                                tool_call_id: toolCallId,
+                                name: toolName,
+                                content: `Error: Failed to parse tool arguments - ${parseError.message}. Please retry with valid JSON.`
+                            });
+                            this.sessionManager.saveSession(this.session);
+                            continue;
+                        }
+                        tui_1.tui.log(chalk_1.default.cyan(`[Tool] Calling ${toolName}...`));
+                        let result;
+                        try {
+                            tui_1.tui.setStatus(`Executing ${toolName}...`);
+                            result = await this.executeTool(toolName, toolArgs);
+                        }
+                        catch (e) {
+                            result = `Error executing tool ${toolName}: ${e.message}`;
+                            tui_1.tui.log(chalk_1.default.red(`[Tool Error] ${result}`));
+                        }
+                        // Add Tool Result Message
+                        this.session.conversationHistory.push({
+                            role: 'tool',
+                            tool_call_id: toolCallId,
+                            name: toolName,
+                            content: result
+                        });
+                        this.sessionManager.saveSession(this.session);
+                    }
+                }
+                else {
+                    // No tools called. Check if it looks like a question to user or just chatter.
+                    // If just chatter, maybe we continue? or wait for user?
+                    // Usually if no tools, it's just talking. We might want to pause for user input?
+                    // For now, if no tools are called, we assume it's waiting for user input or just speaking.
+                    // But in non-interactive CLI loop, we need to prompt user if AI stops acting.
+                    // However, we added 'ask_user' tool. The AI *should* use it.
+                    // If it doesn't use 'ask_user' but stops, we'll prompt user regardless.
+                    await this.handleUserInteraction();
+                }
+            }
+            catch (error) {
+                tui_1.tui.log(chalk_1.default.red('\n❌ Agent 发生错误: ' + error.message));
+                // Check for JSON truncation or parsing errors (likely due to token limit)
+                const isJsonError = error.message.includes('JSON') || error.message.includes('Unterminated string');
+                if (isJsonError) {
+                    tui_1.tui.log(chalk_1.default.yellow('⚠️ 检测到 JSON 解析错误，通常是因为输出被截断 (上下文过长)。'));
+                    const shouldRecover = await this.safePromptTui('是否尝试压缩上下文并重试本轮对话？ (Y/n) [默认: Y]');
+                    if (shouldRecover.toLowerCase() !== 'n') {
+                        // 1. Compress context
+                        await this.compressContext();
+                        // 2. Remove the last assistant message if it was the one that failed parsing
+                        // (If we failed during tool parsing, the assistant message was already added)
+                        const lastMsg = this.session.conversationHistory[this.session.conversationHistory.length - 1];
+                        if (lastMsg && lastMsg.role === 'assistant') {
+                            this.session.conversationHistory.pop();
+                            tui_1.tui.log(chalk_1.default.gray('  Info: Removed partial/failed assistant message from history.'));
+                        }
+                        this.sessionManager.saveSession(this.session);
+                        tui_1.tui.log(chalk_1.default.green('✅ 恢复成功，正在重试...'));
+                        continue; // Retry loop
+                    }
+                }
+                // Generic Retry Prompt
+                const action = await this.safePromptTui('是否重试？(y/n/exit)');
+                if (action.toLowerCase() === 'y') {
+                    continue;
+                }
+                this.session.status = 'failed';
+                this.session.error = error.message;
+                this.sessionManager.saveSession(this.session);
+                tui_1.tui.stop();
+                return;
+            }
+        }
+        tui_1.tui.stop();
+    }
+    async executeTool(name, args) {
+        switch (name) {
+            case 'read_file':
+                return await this.handleReadFile(args.path);
+            case 'replace_in_file':
+                return await this.handleReplaceInFile(args.path, args.target, args.replacement);
+            case 'write_file':
+                return await this.handleWriteFile(args.path, args.content);
+            case 'run_command':
+                return await this.handleRunCommand(args.command);
+            case 'ask_user':
+                return await this.handleAskUser(args.question);
+            case 'scaffold_project':
+                return await this.handleScaffoldProject(args.reason);
+            case 'finish':
+                return await this.handleFinish(args.summary);
+            // New Tools
+            case 'list_dir':
+                return await this.handleListDir(args.path);
+            case 'search_files':
+                return await this.handleSearchFiles(args.query, args.path);
+            case 'read_file_outline':
+                return await this.handleReadFileOutline(args.path);
+            case 'delete_file':
+                return await this.handleDeleteFile(args.path);
+            case 'move_file':
+                return await this.handleMoveFile(args.source, args.destination);
+            case 'fetch_url':
+                return await this.handleFetchUrl(args.url);
+            case 'check_types':
+                return await this.handleCheckTypes();
+            // Legacy/Deprecated
+            case 'plan_files':
+                return "Tool 'plan_files' is deprecated. Please use read_file/write_file directly.";
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    // --- New Tool Handlers ---
+    async handleListDir(dirPath) {
+        const fullPath = path.resolve(this.session.targetDir, dirPath);
+        if (!await fs.pathExists(fullPath))
+            return `Directory not found: ${dirPath}`;
+        try {
+            const files = await fs.readdir(fullPath);
+            const detailed = await Promise.all(files.map(async (f) => {
+                const stat = await fs.stat(path.join(fullPath, f));
+                return `${f}${stat.isDirectory() ? '/' : ''}`;
+            }));
+            return `Contents of ${dirPath}:\n${detailed.join('\n')}`;
+        }
+        catch (e) {
+            return `Error listing directory: ${e.message}`;
+        }
+    }
+    async handleSearchFiles(query, searchPath = '.') {
+        const fullPath = path.resolve(this.session.targetDir, searchPath);
+        if (!await fs.pathExists(fullPath))
+            return `Path not found: ${searchPath}`;
+        const results = [];
+        try {
+            // Recursive walk
+            const walk = async (dir) => {
+                const files = await fs.readdir(dir);
+                for (const file of files) {
+                    if (['node_modules', '.git', 'dist'].includes(file))
+                        continue;
+                    const fPath = path.join(dir, file);
+                    const stat = await fs.stat(fPath);
+                    if (stat.isDirectory()) {
+                        await walk(fPath);
+                    }
+                    else {
+                        const content = await fs.readFile(fPath, 'utf-8');
+                        if (content.includes(query)) { // Simple string match, regex support would need eval or new RegExp
+                            // If query is regex-like, try regex?
+                            // The prompt says "String or Regex". 
+                            // Let's safe-guard: if it looks like regex, use regex.
+                            // Actually, simple includes is safer for now. 
+                            // If user wants regex, we can try new RegExp(query).
+                            let match = false;
+                            try {
+                                if (new RegExp(query).test(content))
+                                    match = true;
+                            }
+                            catch {
+                                if (content.includes(query))
+                                    match = true;
+                            }
+                            if (match) {
+                                // Find line number
+                                const lines = content.split('\n');
+                                lines.forEach((line, idx) => {
+                                    if (line.includes(query) || (new RegExp(query).test(line))) {
+                                        results.push(`${path.relative(this.session.targetDir, fPath)}:${idx + 1}: ${line.trim().slice(0, 100)}`);
+                                    }
+                                });
+                            }
+                        }
+                    }
+                }
+            };
+            await walk(fullPath);
+            return results.length > 0 ? results.join('\n') : 'No matches found.';
+        }
+        catch (e) {
+            return `Error searching files: ${e.message}`;
+        }
+    }
+    async handleReadFileOutline(filePath) {
+        const fullPath = path.resolve(this.session.targetDir, filePath);
+        if (!await fs.pathExists(fullPath))
+            return `File not found: ${filePath}`;
+        try {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            const lines = content.split('\n');
+            const outline = lines
+                .map((line, idx) => ({ line, idx: idx + 1 }))
+                .filter(({ line }) => {
+                const l = line.trim();
+                return (l.startsWith('export ') ||
+                    l.startsWith('class ') ||
+                    l.startsWith('function ') ||
+                    l.startsWith('interface ') ||
+                    l.startsWith('type ') ||
+                    l.match(/^const\s+[A-Z_]+\s+=/) // Constants
+                ) && !l.startsWith('export default'); // Handle default exports maybe?
+            })
+                .map(({ line, idx }) => `${idx}: ${line.trim()}`);
+            return outline.length > 0 ? outline.join('\n') : 'No outline elements found (only imports or internal code?).';
+        }
+        catch (e) {
+            return `Error reading outline: ${e.message}`;
+        }
+    }
+    async handleDeleteFile(filePath) {
+        const fullPath = path.resolve(this.session.targetDir, filePath);
+        try {
+            await fs.remove(fullPath);
+            tui_1.tui.log(chalk_1.default.yellow(`  ✓ Deleted ${filePath}`));
+            return `Deleted ${filePath}`;
+        }
+        catch (e) {
+            return `Error deleting file: ${e.message}`;
+        }
+    }
+    async handleMoveFile(source, dest) {
+        const fullSource = path.resolve(this.session.targetDir, source);
+        const fullDest = path.resolve(this.session.targetDir, dest);
+        try {
+            await fs.move(fullSource, fullDest, { overwrite: true });
+            tui_1.tui.log(chalk_1.default.yellow(`  ✓ Moved ${source} -> ${dest}`));
+            return `Moved ${source} to ${dest}`;
+        }
+        catch (e) {
+            return `Error moving file: ${e.message}`;
+        }
+    }
+    async handleFetchUrl(url) {
+        tui_1.tui.log(chalk_1.default.cyan(`  🌐 Fetching ${url}...`));
+        try {
+            // Using global fetch (Node 18+)
+            const response = await fetch(url);
+            if (!response.ok)
+                return `Failed to fetch: ${response.status} ${response.statusText}`;
+            const text = await response.text();
+            // Simple naive HTML to text or just return raw?
+            // Use a simple heuristic to strip tags if HTML?
+            // For now return raw but truncated
+            const maxLength = 20000;
+            const content = text.length > maxLength
+                ? text.slice(0, maxLength) + `\n...(Truncated ${text.length - maxLength} chars)`
+                : text;
+            return content;
+        }
+        catch (e) {
+            return `Fetch error: ${e.message}`;
+        }
+    }
+    async handleCheckTypes() {
+        tui_1.tui.log(chalk_1.default.cyan(`  🛡️ Checking types...`));
+        try {
+            return await this.handleRunCommand('npm run build'); // Commonly runs tsc
+            // Or explicitly: npx tsc --noEmit
+        }
+        catch (e) {
+            return `Type check failed: ${e.message}`;
+        }
+    }
+    async handleReadFile(filePath) {
+        const fullPath = path.resolve(this.session.targetDir, filePath);
+        if (!await fs.pathExists(fullPath)) {
+            return `File not found: ${filePath}`;
+        }
+        return await fs.readFile(fullPath, 'utf-8');
+    }
+    async handleWriteFile(filePath, content) {
+        await this.fileWriter.writeFile(filePath, content);
+        tui_1.tui.log(chalk_1.default.green(`  ✓ Wrote ${filePath}`));
+        return `Successfully wrote file: ${filePath}`;
+    }
+    async handleScaffoldProject(reason) {
+        tui_1.tui.log(chalk_1.default.cyan(`📦 正在生成项目脚手架... (${reason})`));
+        const targetDir = this.session.targetDir;
+        const pluginName = this.session.pluginName || path.basename(targetDir);
+        try {
+            await (0, react_1.createReactProject)(targetDir, pluginName);
+            tui_1.tui.log(chalk_1.default.green('✓ 脚手架创建完成'));
+            return `Project scaffold created successfully at ${targetDir}. The following files were generated:
+- package.json
+- manifest.json
+- vite.config.ts
+- tsconfig.json
+- src/ui/App.tsx
+- src/ui/main.tsx
+- src/ui/styles.css
+- src/ui/index.html
+- src/main.ts
+
+Now you can start implementing the features by modifying these files.`;
+        }
+        catch (e) {
+            return `Failed to create scaffold: ${e.message}`;
+        }
+    }
+    async handleReplaceInFile(filePath, target, replacement) {
+        const fullPath = path.resolve(this.session.targetDir, filePath);
+        if (!await fs.pathExists(fullPath)) {
+            return `File not found: ${filePath}`;
+        }
+        const content = await fs.readFile(fullPath, 'utf-8');
+        if (!content.includes(target)) {
+            // Check for potential whitespace/formatting issues causing mismatch
+            // For now, strict match failure
+            return `Error: Target string not found in file. Please ensure 'target' matches exactly (including indentation). You might want to use read_file first to verify constraint.`;
+        }
+        const parts = content.split(target);
+        if (parts.length > 2) {
+            return `Error: Target string found multiple times (${parts.length - 1} times). Please provide a more unique target string context to ensure correct replacement.`;
+        }
+        const newContent = content.replace(target, replacement);
+        await this.fileWriter.writeFile(filePath, newContent);
+        tui_1.tui.log(chalk_1.default.green(`  ✓ Modified ${filePath}`));
+        return `Successfully replaced content in ${filePath}.`;
+    }
+    async handleRunCommand(command) {
+        // Security check? whitelist?
+        // simple whitelist for now
+        const allowed = ['npm install', 'npm i', 'yarn add', 'pnpm add', 'mkdir', 'touch'];
+        const isAllowed = allowed.some(p => command.startsWith(p));
+        if (!isAllowed && !this.autoApproveCommands) {
+            const confirm = await this.safePromptTui(`AI wants to run command: "${command}". Allow? (y/n/a[lways])`);
+            const lower = confirm.toLowerCase();
+            if (lower === 'a' || lower === 'always') {
+                this.autoApproveCommands = true;
+            }
+            else if (lower !== 'y') {
+                return "User denied command execution.";
+            }
+        }
+        tui_1.tui.log(chalk_1.default.yellow(`  > Executing: ${command}`));
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(command, {
+                cwd: this.session.targetDir,
+                shell: true,
+                stdio: ['ignore', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (d) => stdout += d.toString());
+            child.stderr.on('data', (d) => stderr += d.toString());
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve(`Command executed successfully.\nOutput: ${stdout}`);
+                }
+                else {
+                    resolve(`Command failed with code ${code}.\nStderr: ${stderr}\nStdout: ${stdout}`);
+                }
+            });
+            child.on('error', (err) => resolve(`Command execution error: ${err.message}`));
+        });
+    }
+    // ... (previous methods)
+    // Centralized handler for user input to intercept Slash Commands
+    async promptUser(message) {
+        tui_1.tui.setStatus('Waiting for user input...');
+        const prefix = chalk_1.default.blue('›');
+        // Use TUI prompt
+        const input = await tui_1.tui.prompt(`${prefix} ${message}`);
+        if (input.startsWith('/')) {
+            const handled = await this.handleSlashCommand(input);
+            if (handled) {
+                // If command handled (e.g. /tokens), we prompt again effectively (or return null to loop)
+                // For simplified flow, we return null to indicate "no input for AI yet, handled by system"
+                return null;
+            }
+            // If /exit, handleSlashCommand handles process exit or session ending
+        }
+        return input;
+    }
+    async handleSlashCommand(command) {
+        const [cmd, ...args] = command.split(' ');
+        switch (cmd) {
+            case '/exit':
+            case '/quit':
+                tui_1.tui.log(chalk_1.default.yellow('👋 Exiting session...'));
+                // Check if we are exiting while tool calls are pending (e.g. at a prompt inside a tool)
+                const last = this.session.conversationHistory[this.session.conversationHistory.length - 1];
+                if (last && last.role === 'assistant' && last.tool_calls && last.tool_calls.length > 0) {
+                    tui_1.tui.log(chalk_1.default.gray('Closing pending tool calls...'));
+                    for (const call of last.tool_calls) {
+                        this.session.conversationHistory.push({
+                            role: 'tool',
+                            tool_call_id: call.id,
+                            name: call.function.name,
+                            content: 'Session exited by user.'
+                        });
+                    }
+                }
+                this.session.status = 'completed';
+                this.sessionManager.saveSession(this.session);
+                tui_1.tui.stop();
+                // 给 TUI 一点时间完成清理
+                setTimeout(() => process.exit(0), 100);
+                return true;
+            case '/clear':
+                tui_1.tui.log(chalk_1.default.yellow('🧹 Clearing context (keeping system prompt)...'));
+                const systemPrompt = this.session.conversationHistory.find(m => m.role === 'system');
+                this.session.conversationHistory = systemPrompt ? [systemPrompt] : [];
+                this.sessionManager.saveSession(this.session);
+                return true;
+            case '/tokens':
+                const count = context_manager_1.ContextManager.estimateTokenCount(this.session.conversationHistory);
+                tui_1.tui.log(chalk_1.default.cyan(`📊 Current Context: ~${count} tokens (${this.session.conversationHistory.length} messages)`));
+                return true;
+            case '/compress':
+                tui_1.tui.log(chalk_1.default.yellow('📦 Compressing context...'));
+                await this.compressContext();
+                return true;
+            case '/use':
+                // Switch Provider
+                if (args.length === 0) {
+                    const providers = ai_1.AIServiceFactory.listProviders();
+                    const defaultProvider = ai_1.AIServiceFactory.getDefaultProvider();
+                    const current = this.currentProvider || defaultProvider || providers[0];
+                    const items = providers.map(p => ({
+                        label: p === current ? `${p} (Current)` : p,
+                        value: p
+                    }));
+                    tui_1.tui.log(chalk_1.default.cyan('Select AI Provider:'));
+                    const selected = await tui_1.tui.select(items);
+                    if (selected) {
+                        const config = ai_1.AIServiceFactory.getProviderConfig(selected);
+                        if (config) {
+                            this.currentProvider = selected;
+                            this.currentModel = undefined;
+                            this.aiService = ai_1.AIServiceFactory.create(selected);
+                            tui_1.tui.log(chalk_1.default.green(`✓ Switched to "${selected}" (${config.provider})`));
+                        }
+                    }
+                }
+                else {
+                    const providerName = args[0];
+                    const config = ai_1.AIServiceFactory.getProviderConfig(providerName);
+                    if (!config) {
+                        tui_1.tui.log(chalk_1.default.red(`❌ Configuration "${providerName}" not found`));
+                    }
+                    else {
+                        this.currentProvider = providerName;
+                        this.currentModel = undefined;
+                        this.aiService = ai_1.AIServiceFactory.create(providerName);
+                        tui_1.tui.log(chalk_1.default.green(`✓ Switched to "${providerName}" (${config.provider})`));
+                    }
+                }
+                return true;
+            case '/model':
+                // Switch Model
+                if (args.length === 0) {
+                    const providers = ai_1.AIServiceFactory.listProviders();
+                    const defaultProvider = ai_1.AIServiceFactory.getDefaultProvider();
+                    const currentProviderName = this.currentProvider || defaultProvider || providers[0];
+                    const config = ai_1.AIServiceFactory.getProviderConfig(currentProviderName);
+                    if (config) {
+                        const currentModel = this.currentModel || config.model || 'Default';
+                        // Import PROVIDER_MODELS
+                        const { PROVIDER_MODELS } = await Promise.resolve().then(() => __importStar(require('../types/ai')));
+                        const availableModels = PROVIDER_MODELS[config.provider];
+                        if (availableModels && availableModels.length > 0) {
+                            const items = availableModels.map(m => ({
+                                label: m === currentModel ? `${m} (Current)` : m,
+                                value: m
+                            }));
+                            tui_1.tui.log(chalk_1.default.cyan(`Select Model for ${currentProviderName}:`));
+                            const selected = await tui_1.tui.select(items);
+                            if (selected) {
+                                this.currentModel = selected;
+                                this.aiService = ai_1.AIServiceFactory.create(currentProviderName, selected);
+                                tui_1.tui.log(chalk_1.default.green(`✓ Switched model to "${selected}"`));
+                            }
+                        }
+                        else {
+                            tui_1.tui.log(chalk_1.default.yellow(`No models predefined for provider type: ${config.provider}`));
+                        }
+                    }
+                }
+                else {
+                    const modelName = args.join(' ');
+                    const providers = ai_1.AIServiceFactory.listProviders();
+                    const defaultProvider = ai_1.AIServiceFactory.getDefaultProvider();
+                    const currentProviderName = this.currentProvider || defaultProvider || providers[0];
+                    this.currentModel = modelName;
+                    this.aiService = ai_1.AIServiceFactory.create(currentProviderName, modelName);
+                    tui_1.tui.log(chalk_1.default.green(`✓ Switched model to "${modelName}"`));
+                }
+                return true;
+            case '/help':
+                tui_1.tui.log(chalk_1.default.green(`
+Available Commands:
+  /exit, /quit   - Save and exit
+  /clear         - Clear conversation history (keeps system prompt)
+  /tokens        - Show estimated token usage
+  /compress      - Manually compress context
+  /use [name]    - Switch AI provider
+  /model [name]  - Switch model
+  /plan [需求]    - Show plan or force plan mode
+  /help          - Show this help
+`));
+                return true;
+            case '/plan':
+                const result = await this.planCommandHandler.handlePlanCommand(args);
+                if (!result.handled && result.requirement) {
+                    // Force plan mode - add to conversation for AI to create plan
+                    this.session.conversationHistory.push({
+                        role: 'user',
+                        content: `请为以下任务创建一个详细的执行计划：\n\n${result.requirement}\n\n请列出具体的步骤（作为 todo list），然后开始执行。`
+                    });
+                    this.sessionManager.saveSession(this.session);
+                    return false; // Let AI process
+                }
+                return true;
+            default:
+                tui_1.tui.log(chalk_1.default.red(`Unknown command: ${cmd}`));
+                return true;
+        }
+    }
+    async checkAndCompressContext() {
+        const inputTokens = context_manager_1.ContextManager.estimateTokenCount(this.session.conversationHistory);
+        // Get model's context window and max output tokens
+        const contextWindow = this.aiService.getContextWindow();
+        const maxOutputTokens = this.aiService.getMaxOutputTokens();
+        // Total tokens = input + output
+        const totalTokens = inputTokens + maxOutputTokens;
+        // 1. Growth check: avoid frequent compression
+        const growth = inputTokens - this.lastCompressedTokens;
+        const MIN_GROWTH = contextWindow * 0.08; // 8% growth threshold
+        if (this.lastCompressedTokens > 0 && growth < MIN_GROWTH) {
+            return; // Skip if growth is insufficient
+        }
+        // 2. Tiered compression zones (based on total tokens including output)
+        const SAFE_ZONE = contextWindow * 0.5; // 50% - safe, no compression
+        const LIGHT_ZONE = contextWindow * 0.65; // 65% - light compression (prune tool outputs)
+        const MEDIUM_ZONE = contextWindow * 0.78; // 78% - medium compression (summarize + keep important)
+        const HEAVY_ZONE = contextWindow * 0.88; // 88% - heavy compression (aggressive summarization)
+        const CRITICAL_ZONE = contextWindow * 0.95; // 95% - critical compression (keep only recent)
+        if (totalTokens < SAFE_ZONE) {
+            return; // Safe zone, no action needed
+        }
+        // Calculate target input tokens (reserve space for output)
+        const getTargetInputTokens = (percentage) => {
+            return Math.floor(contextWindow * percentage) - maxOutputTokens;
+        };
+        if (totalTokens < LIGHT_ZONE) {
+            // Light compression: only prune tool outputs
+            tui_1.tui.log(chalk_1.default.yellow(`⚠️ Context at ${inputTokens} input + ${maxOutputTokens} output = ${totalTokens} tokens (${Math.round(totalTokens / contextWindow * 100)}% of ${contextWindow}). Applying light compression...`));
+            await this.lightCompress();
+            const afterTokens = context_manager_1.ContextManager.estimateTokenCount(this.session.conversationHistory);
+            tui_1.tui.log(chalk_1.default.green(`✅ Light compression: ${inputTokens} -> ${afterTokens} tokens.`));
+            this.lastCompressedTokens = afterTokens;
+        }
+        else if (totalTokens < MEDIUM_ZONE) {
+            // Medium compression: target 50% of context window (minus output)
+            const target = getTargetInputTokens(0.5);
+            tui_1.tui.log(chalk_1.default.yellow(`⚠️ Context at ${inputTokens} input + ${maxOutputTokens} output = ${totalTokens} tokens (${Math.round(totalTokens / contextWindow * 100)}% of ${contextWindow}). Applying medium compression (target: ${target})...`));
+            await this.compressContext(target);
+            const afterTokens = context_manager_1.ContextManager.estimateTokenCount(this.session.conversationHistory);
+            tui_1.tui.log(chalk_1.default.green(`✅ Medium compression: ${inputTokens} -> ${afterTokens} tokens.`));
+            this.lastCompressedTokens = afterTokens;
+        }
+        else if (totalTokens < HEAVY_ZONE) {
+            // Heavy compression: target 35% of context window (minus output)
+            const target = getTargetInputTokens(0.35);
+            tui_1.tui.log(chalk_1.default.red(`⚠️ Context at ${inputTokens} input + ${maxOutputTokens} output = ${totalTokens} tokens (${Math.round(totalTokens / contextWindow * 100)}% of ${contextWindow}). Applying heavy compression (target: ${target})...`));
+            await this.compressContext(target);
+            const afterTokens = context_manager_1.ContextManager.estimateTokenCount(this.session.conversationHistory);
+            tui_1.tui.log(chalk_1.default.green(`✅ Heavy compression: ${inputTokens} -> ${afterTokens} tokens.`));
+            this.lastCompressedTokens = afterTokens;
+        }
+        else if (totalTokens < CRITICAL_ZONE) {
+            // Critical compression: target 25% of context window (minus output)
+            const target = getTargetInputTokens(0.25);
+            tui_1.tui.log(chalk_1.default.red(`🚨 Context at ${inputTokens} input + ${maxOutputTokens} output = ${totalTokens} tokens (${Math.round(totalTokens / contextWindow * 100)}% of ${contextWindow}). Applying critical compression (target: ${target})...`));
+            await this.forceAggressiveCompress(target);
+            const afterTokens = context_manager_1.ContextManager.estimateTokenCount(this.session.conversationHistory);
+            tui_1.tui.log(chalk_1.default.green(`✅ Critical compression: ${inputTokens} -> ${afterTokens} tokens.`));
+            this.lastCompressedTokens = afterTokens;
+        }
+        else {
+            // Emergency: over 95%, immediate aggressive compression
+            const target = getTargetInputTokens(0.15);
+            tui_1.tui.log(chalk_1.default.red(`🚨 EMERGENCY: Context at ${inputTokens} input + ${maxOutputTokens} output = ${totalTokens} tokens (${Math.round(totalTokens / contextWindow * 100)}% of ${contextWindow}). Forcing aggressive compression (target: ${target})...`));
+            await this.forceAggressiveCompress(target);
+            const afterTokens = context_manager_1.ContextManager.estimateTokenCount(this.session.conversationHistory);
+            tui_1.tui.log(chalk_1.default.green(`✅ Emergency compression: ${inputTokens} -> ${afterTokens} tokens.`));
+            this.lastCompressedTokens = afterTokens;
+        }
+    }
+    async lightCompress() {
+        // Only prune tool outputs, no summarization
+        this.session.conversationHistory = context_manager_1.ContextManager.lightCompress(this.session.conversationHistory);
+        this.sessionManager.saveSession(this.session);
+        tui_1.tui.log(chalk_1.default.green('✅ Light compression applied (tool outputs pruned).'));
+    }
+    async compressContext(targetTokens = 8000) {
+        const beforeTokens = context_manager_1.ContextManager.estimateTokenCount(this.session.conversationHistory);
+        // Simple text summarizer - no JSON parsing to avoid truncation/format issues
+        const summarizer = async (text) => {
+            const prompt = `请将以下技术对话历史总结为简洁的上下文摘要，帮助后续继续对话。
+
+格式要求（纯文本，不要用 JSON 或 markdown）：
+- 用户目标：（1-2句话描述核心需求）
+- 关键决策：（已做出的重要决定，用逗号分隔）
+- 当前状态：（进度和状态）
+- 修改的文件：（涉及的文件路径，用逗号分隔）
+- 待完成：（剩余任务，用逗号分隔）
+
+对话历史：
+${text}
+
+请直接输出摘要，不要用代码块或其他格式。`;
+            try {
+                const result = await this.aiService.chat([
+                    { role: 'system', content: '你是一个帮助生成对话摘要的助手。直接输出纯文本摘要，不要使用 JSON、markdown 或代码块格式。' },
+                    { role: 'user', content: prompt }
+                ], { toolChoice: 'none' });
+                return result.content || '无法生成摘要';
+            }
+            catch (error) {
+                console.warn('Failed to generate summary:', error);
+                // Ultra simple fallback
+                return `对话摘要生成失败，保留原始上下文的最后部分。`;
+            }
+        };
+        this.session.conversationHistory = await context_manager_1.ContextManager.compressHistory(this.session.conversationHistory, targetTokens, summarizer);
+        const afterTokens = context_manager_1.ContextManager.estimateTokenCount(this.session.conversationHistory);
+        this.sessionManager.saveSession(this.session);
+        if (afterTokens >= beforeTokens * 0.9) {
+            // Compression didn't help much - this usually means most messages are important
+            // or the summarization couldn't reduce much. Just log a warning.
+            tui_1.tui.log(chalk_1.default.yellow(`⚠️ Compression limited: ${beforeTokens} -> ${afterTokens} tokens (most content deemed important).`));
+        }
+        else {
+            tui_1.tui.log(chalk_1.default.green(`✅ Context compressed: ${beforeTokens} -> ${afterTokens} tokens.`));
+        }
+    }
+    /**
+     * Force aggressive compression - uses the same summarization logic as compressContext
+     * but with a more aggressive target. The key is still summarization, not deletion.
+     */
+    async forceAggressiveCompress(targetTokens) {
+        // Simply delegate to compressContext with the aggressive target
+        // This ensures we still get summarization of removed messages
+        await this.compressContext(targetTokens);
+    }
+    async handleAskUser(question) {
+        tui_1.tui.log(chalk_1.default.magenta(`\n🤖 AI Question: ${question}`));
+        while (true) {
+            const answer = await this.promptUser('Your Answer:');
+            if (answer !== null)
+                return answer;
+            // If answer is null, it meant a slash command was executed, so we loop again to ask for input.
+        }
+    }
+    async handleUserInteraction() {
+        while (true) {
+            const input = await this.promptUser('用户输入 (或直接回车继续):');
+            if (input === null)
+                continue; // Slash command executed
+            if (input && input.trim()) {
+                // Only analyze for complex tasks if no active plan
+                if (!this.currentPlan && !task_analyzer_1.TaskAnalyzer.shouldSkipAnalysis(input)) {
+                    tui_1.tui.log(chalk_1.default.gray('正在分析任务...'));
+                    const analysis = await task_analyzer_1.TaskAnalyzer.analyze(input);
+                    // If complex task, suggest planning
+                    if (analysis.shouldPlan) {
+                        tui_1.tui.log(chalk_1.default.cyan(`\n📊 ${task_analyzer_1.TaskAnalyzer.getAnalysisDescription(analysis)}`));
+                        const choice = await tui_1.tui.select([
+                            { label: '创建计划后执行 (推荐)', value: 'plan' },
+                            { label: '直接执行', value: 'direct' }
+                        ]);
+                        if (choice === 'plan') {
+                            // Ask AI to create plan first
+                            this.session.conversationHistory.push({
+                                role: 'user',
+                                content: `请为以下任务创建一个执行计划，列出具体步骤，然后开始执行：\n\n${input}`
+                            });
+                            this.sessionManager.saveSession(this.session);
+                            break;
+                        }
+                        // else: direct execution, fall through
+                    }
+                }
+                this.session.conversationHistory.push({
+                    role: 'user',
+                    content: input
+                });
+                this.sessionManager.saveSession(this.session);
+                break;
+            }
+            else {
+                // Empty input (Enter)
+                break;
+            }
+        }
+    }
+    // Helper to allow slash commands during any prompt
+    async safePromptTui(message) {
+        while (true) {
+            const input = await tui_1.tui.prompt(message);
+            if (input.startsWith('/')) {
+                const handled = await this.handleSlashCommand(input);
+                if (handled)
+                    continue; // Loop back to prompt if handled (unless exit killed process)
+            }
+            return input;
+        }
+    }
+    // ... (rest of the class)
+    async handleFinish(summary) {
+        tui_1.tui.log(chalk_1.default.green('\n✅ AI 认为任务已完成:'));
+        tui_1.tui.log(chalk_1.default.white(summary));
+        tui_1.tui.log(chalk_1.default.gray('(输入新需求继续，或输入 /exit 退出)'));
+        const input = await this.safePromptTui('请输入修改需求:');
+        // Since we are strictly "continuing" if the user gave input (otherwise /exit would happen in safePromptTui),
+        // we essentially treat this as a user feedback loop.
+        return `User provided new requirement after previous completion: ${input}`;
+    }
+    /**
+     * Generates a simplified file tree for the context.
+     * Ignores node_modules, .git, dist, etc.
+     */
+    async generateFileMap() {
+        const rootDir = this.session.targetDir;
+        let fileMap = '';
+        const walk = async (currentDir, indent) => {
+            try {
+                const files = await fs.readdir(currentDir);
+                // Sort: directories first, then files
+                files.sort((a, b) => {
+                    return a.localeCompare(b);
+                });
+                for (const file of files) {
+                    if (['node_modules', '.git', 'dist', '.DS_Store', 'package-lock.json', 'yarn.lock'].includes(file))
+                        continue;
+                    const fullPath = path.join(currentDir, file);
+                    const stats = await fs.stat(fullPath);
+                    if (stats.isDirectory()) {
+                        fileMap += `${indent}${file}/\n`;
+                        await walk(fullPath, indent + '  ');
+                    }
+                    else {
+                        fileMap += `${indent}${file}\n`;
+                    }
+                }
+            }
+            catch (e) {
+                fileMap += `${indent}(Error reading directory)\n`;
+            }
+        };
+        if (await fs.pathExists(rootDir)) {
+            await walk(rootDir, '');
+        }
+        else {
+            fileMap = '(Target directory not created yet)';
+        }
+        return fileMap.trim();
+    }
+}
+exports.AIAgent = AIAgent;