yuangs 5.57.0 → 5.58.0

package/dist/agent/executor.js

@@ -8,43 +8,138 @@ const child_process_1 = require("child_process");
 const util_1 = require("util");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
+const toolCapability_1 = require("./toolCapability");
+const CapabilityLevel_1 = require("../core/capability/CapabilityLevel");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * 增强的工具执行器
+ * 支持丰富的原子工具操作
+ * 集成能力感知的工具调用
+ */
 class ToolExecutor {
     static MAX_OUTPUT_LENGTH = 2000; // Maximum output length in characters
+    static READ_POSITIONS = new Map(); // 记录文件读取位置用于 continue_reading
+    static currentCapabilityLevel = CapabilityLevel_1.CapabilityLevel.STRUCTURAL; // 当前模型的能力等级（可配置）
     /**
-     * Truncates output if too long and adds helpful suggestions
+     * 设置当前能力等级
      */
-    static maybeTruncate(output) {
+    static setCapabilityLevel(level) {
+        this.currentCapabilityLevel = level;
+    }
+    /**
+     * 获取当前能力等级
+     */
+    static getCapabilityLevel() {
+        return this.currentCapabilityLevel;
+    }
+    /**
+     * 检查工具是否可以被当前能力等级执行
+     */
+    static checkToolCapability(toolName) {
+        const required = (0, toolCapability_1.getToolCapabilityRequirement)(toolName);
+        if (required === null) {
+            return { allowed: false }; // 工具不存在
+        }
+        const allowed = (0, toolCapability_1.canExecuteTool)(toolName, this.currentCapabilityLevel);
+        return { allowed, required, current: this.currentCapabilityLevel };
+    }
+    /**
+     * 获取指定能力等级下可用的工具列表
+     */
+    static getAvailableTools() {
+        const tools = [];
+        for (const [name] of Object.entries(toolCapability_1.TOOL_CAPABILITY_MAP)) {
+            if ((0, toolCapability_1.canExecuteTool)(name, this.currentCapabilityLevel)) {
+                tools.push(name);
+            }
+        }
+        return tools;
+    }
+    /**
+     * 获取能力等级的可读名称
+     */
+    static getCapabilityName(level) {
+        switch (level) {
+            case CapabilityLevel_1.CapabilityLevel.SEMANTIC: return 'SEMANTIC (极致语义)';
+            case CapabilityLevel_1.CapabilityLevel.STRUCTURAL: return 'STRUCTURAL (结构分析)';
+            case CapabilityLevel_1.CapabilityLevel.LINE: return 'LINE (行级分析)';
+            case CapabilityLevel_1.CapabilityLevel.TEXT: return 'TEXT (文本处理)';
+            case CapabilityLevel_1.CapabilityLevel.NONE: return 'NONE (无智能要求)';
+            default: return 'UNKNOWN';
+        }
+    }
+    /**
+     * 智能截断输出
+     * 当输出过长时，返回特殊标记和继续读取的提示
+     */
+    static maybeTruncate(output, toolName, filePath) {
         if (output.length <= this.MAX_OUTPUT_LENGTH) {
             return output;
         }
         const truncated = output.slice(0, this.MAX_OUTPUT_LENGTH);
-        const suggestion = `
+        const remaining = output.length - this.MAX_OUTPUT_LENGTH;
+        // 根据工具类型提供不同的建议
+        let suggestion = `
 
 [⚠️ OUTPUT TRUNCATED]
-The output was too long (${output.length} chars). Here are some ways to get what you need:
+输出被截断，还有 ${remaining} 个字符未显示。
 
-1. Use \`head\` to see the first lines:
+`;
+        if (toolName === 'read_file' && filePath) {
+            // 记录读取位置
+            this.READ_POSITIONS.set(filePath, this.MAX_OUTPUT_LENGTH);
+            suggestion += `
+**建议操作**：
+1. 使用 \`read_file_lines\` 工具读取特定行范围：
+   { "tool_name": "read_file_lines", "parameters": { "path": "${filePath}", "start_line": 1, "end_line": 100 } }
+
+2. 使用 \`continue_reading\` 工具继续读取：
+   { "tool_name": "continue_reading", "parameters": { "path": "${filePath}" } }
+
+3. 使用 \`search_in_files\` 工具搜索关键词：
+   { "tool_name": "search_in_files", "parameters": { "pattern": "关键词", "path": "${filePath}" } }
+`;
+        }
+        else if (toolName === 'shell_cmd') {
+            suggestion += `
+**建议操作**：
+1. 使用 \`head\` 查看前几行：
    head -n 50 filename
 
-2. Use \`tail\` to see the last lines:
+2. 使用 \`tail\` 查看后几行：
    tail -n 50 filename
 
-3. Use \`grep\` to filter relevant content:
+3. 使用 \`grep\` 过滤内容：
    grep "keyword" filename
 
-4. Use specific line ranges with read_file
+4. 将输出重定向到文件再读取：
+   command > output.txt && read_file output.txt
 `;
+        }
+        else {
+            suggestion += `
+**建议操作**：
+1. 检查输出是否已经包含所需信息
+2. 使用更精确的搜索参数
+3. 将结果分批处理
+`;
+        }
         return truncated + suggestion;
     }
     static async execute(action) {
         const { type, payload } = action;
         try {
             const result = await this.executeAction(type, payload);
-            const truncated = this.maybeTruncate(result.output);
+            // 智能截断，提取文件路径用于继续读取
+            let filePath;
+            if (type === 'tool_call' && payload?.tool_name === 'read_file') {
+                filePath = payload?.parameters?.path;
+            }
+            const truncated = this.maybeTruncate(result.output, type, filePath);
             return {
                 ...result,
-                output: truncated
+                output: truncated,
+                needsContinue: result.output.length > this.MAX_OUTPUT_LENGTH
             };
         }
         catch (error) {
@@ -79,13 +174,59 @@ The output was too long (${output.length} chars). Here are some ways to get what
     }
     static async executeTool(payload) {
         const toolName = payload.tool_name;
+        // 能力检查：验证工具是否可以被当前能力等级执行
+        const capabilityCheck = this.checkToolCapability(toolName);
+        if (!capabilityCheck.allowed) {
+            if (capabilityCheck.required === undefined) {
+                return {
+                    success: false,
+                    error: `Unknown tool: ${toolName}`,
+                    output: ''
+                };
+            }
+            // 工具存在但当前能力等级不足
+            const currentLevel = capabilityCheck.current ?? this.currentCapabilityLevel;
+            return {
+                success: false,
+                error: `Tool "${toolName}" requires ${this.getCapabilityName(capabilityCheck.required)} capability, current is ${this.getCapabilityName(currentLevel)}`,
+                output: ''
+            };
+        }
         switch (toolName) {
+            // ===== 基础文件操作 =====
             case 'read_file':
                 return await this.toolReadFile(payload.parameters);
+            case 'read_file_lines':
+                return await this.toolReadFileLines(payload.parameters);
             case 'write_file':
                 return await this.toolWriteFile(payload.parameters);
+            case 'append_file':
+                return await this.toolAppendFile(payload.parameters);
+            // ===== 文件搜索和列表 =====
             case 'list_files':
                 return await this.toolListFiles(payload.parameters);
+            case 'list_directory_tree':
+                return await this.toolListDirectoryTree(payload.parameters);
+            case 'search_in_files':
+                return await this.toolSearchInFiles(payload.parameters);
+            // ===== 代码分析工具 =====
+            case 'search_symbol':
+                return await this.toolSearchSymbol(payload.parameters);
+            case 'analyze_dependencies':
+                return await this.toolAnalyzeDependencies(payload.parameters);
+            // ===== Git 操作 =====
+            case 'git_status':
+                return await this.toolGitStatus(payload.parameters);
+            case 'git_diff':
+                return await this.toolGitDiff(payload.parameters);
+            case 'git_log':
+                return await this.toolGitLog(payload.parameters);
+            // ===== 上下文管理工具 =====
+            case 'continue_reading':
+                return await this.toolContinueReading(payload.parameters);
+            case 'file_info':
+                return await this.toolFileInfo(payload.parameters);
+            // ===== 已弃用/未实现 =====
             case 'web_search':
                 return {
                     success: false,
@@ -200,7 +341,7 @@ The output was too long (${output.length} chars). Here are some ways to get what
         try {
             const tempFile = path_1.default.join(process.cwd(), '.yuangs_temp.patch');
             await promises_1.default.writeFile(tempFile, diff, 'utf-8');
-            const { stdout, stderr } = await execAsync(`git apply --check ${tempFile}`, {
+            await execAsync(`git apply --check ${tempFile}`, {
                 cwd: process.cwd()
             });
             const { stdout: applyOutput } = await execAsync(`git apply ${tempFile}`, {
@@ -221,6 +362,510 @@ The output was too long (${output.length} chars). Here are some ways to get what
             };
         }
     }
+    // ===== 新增工具方法实现 =====
+    /**
+     * 读取文件的指定行范围
+     */
+    static async toolReadFileLines(params) {
+        const filePath = params.path;
+        const startLine = params.start_line || 1;
+        const endLine = params.end_line;
+        const encoding = params.encoding || 'utf-8';
+        try {
+            const content = await promises_1.default.readFile(filePath, encoding);
+            const lines = String(content).split('\n');
+            const startIndex = Math.max(0, startLine - 1);
+            const endIndex = endLine ? Math.min(lines.length, endLine) : lines.length;
+            if (startIndex >= lines.length) {
+                return {
+                    success: false,
+                    error: `起始行号 ${startLine} 超出文件范围（文件共 ${lines.length} 行）`,
+                    output: ''
+                };
+            }
+            const selectedLines = lines.slice(startIndex, endIndex);
+            const result = selectedLines
+                .map((line, idx) => `${startIndex + idx + 1}: ${line}`)
+                .join('\n');
+            return {
+                success: true,
+                output: result,
+                artifacts: [filePath]
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                output: ''
+            };
+        }
+    }
+    /**
+     * 向文件末尾追加内容
+     */
+    static async toolAppendFile(params) {
+        const filePath = params.path;
+        const content = params.content;
+        const encoding = params.encoding || 'utf-8';
+        try {
+            await promises_1.default.mkdir(path_1.default.dirname(filePath), { recursive: true });
+            await promises_1.default.appendFile(filePath, content, encoding);
+            return {
+                success: true,
+                output: `Successfully appended to ${filePath}`,
+                artifacts: [filePath]
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                output: ''
+            };
+        }
+    }
+    /**
+     * 生成目录结构的树形展示
+     */
+    static async toolListDirectoryTree(params) {
+        const dirPath = params.path || '.';
+        const maxDepth = params.max_depth || 3;
+        const includeFiles = params.include_files !== false;
+        const excludePatterns = params.exclude_patterns || ['node_modules', '.git', 'dist', 'build'];
+        try {
+            const tree = await this.buildDirectoryTree(dirPath, maxDepth, includeFiles, excludePatterns, 0);
+            return {
+                success: true,
+                output: tree,
+                artifacts: []
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                output: ''
+            };
+        }
+    }
+    static async buildDirectoryTree(dirPath, maxDepth, includeFiles, excludePatterns, currentDepth) {
+        if (currentDepth >= maxDepth)
+            return '';
+        const entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
+        const lines = [];
+        const isLast = (index) => index === entries.length - 1;
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            const fullName = entry.name;
+            // 跳过排除的目录/文件
+            if (excludePatterns.some(pattern => fullName.includes(pattern))) {
+                continue;
+            }
+            const prefix = currentDepth === 0 ? '' : '│   '.repeat(currentDepth);
+            const connector = isLast(i) ? '└── ' : '├── ';
+            if (entry.isDirectory()) {
+                lines.push(`${prefix}${connector}${fullName}/`);
+                const subTree = await this.buildDirectoryTree(path_1.default.join(dirPath, fullName), maxDepth, includeFiles, excludePatterns, currentDepth + 1);
+                if (subTree) {
+                    lines.push(subTree);
+                }
+            }
+            else if (includeFiles) {
+                lines.push(`${prefix}${connector}${fullName}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * 在文件中搜索指定内容（类似 grep）
+     */
+    static async toolSearchInFiles(params) {
+        const pattern = params.pattern;
+        const searchPath = params.path || '.';
+        const filePattern = params.file_pattern;
+        const ignoreCase = params.ignore_case || false;
+        const contextLines = params.context_lines || 0;
+        const maxResults = params.max_results || 50;
+        try {
+            let grepCmd = 'grep';
+            // 构建 grep 命令
+            if (ignoreCase)
+                grepCmd += ' -i';
+            grepCmd += ' -r';
+            if (contextLines > 0)
+                grepCmd += ` -C ${contextLines}`;
+            grepCmd += ` -n`; // 显示行号
+            // 转义 pattern
+            const escapedPattern = pattern.replace(/'/g, "'\\''");
+            grepCmd += ` -- '${escapedPattern}'`;
+            // 添加路径
+            grepCmd += ` ${searchPath}`;
+            // 执行搜索
+            const { stdout } = await execAsync(grepCmd, {
+                maxBuffer: 10 * 1024 * 1024,
+                cwd: process.cwd()
+            });
+            // 解析结果并限制数量
+            const lines = String(stdout).split('\n').filter(line => line.trim());
+            const limitedLines = lines.slice(0, maxResults);
+            // 如果指定了文件模式，进行过滤
+            let filteredLines = limitedLines;
+            if (filePattern) {
+                const regex = new RegExp(filePattern.replace(/\*/g, '.*'));
+                filteredLines = limitedLines.filter((line) => {
+                    const match = line.match(/^([^:]+):/);
+                    return match && regex.test(match[1]);
+                });
+            }
+            return {
+                success: true,
+                output: filteredLines.join('\n'),
+                artifacts: []
+            };
+        }
+        catch (error) {
+            // grep 没有找到结果时会返回错误码
+            if (error.code === 1) {
+                return {
+                    success: true,
+                    output: '未找到匹配结果',
+                    artifacts: []
+                };
+            }
+            return {
+                success: false,
+                error: error.message,
+                output: ''
+            };
+        }
+    }
+    /**
+     * 搜索代码符号（函数、类、变量等）
+     * 使用 grep 进行简化搜索
+     */
+    static async toolSearchSymbol(params) {
+        const symbol = params.symbol;
+        const symbolType = params.symbol_type;
+        const searchPath = params.path || '.';
+        const filePattern = params.file_pattern;
+        try {
+            let pattern = symbol;
+            // 根据符号类型构建搜索模式
+            switch (symbolType) {
+                case 'function':
+                    pattern = `function\\s+${symbol}|${symbol}\\s*[:=]\\s*function|const\\s+${symbol}\\s*=`;
+                    break;
+                case 'class':
+                    pattern = `class\\s+${symbol}`;
+                    break;
+                case 'interface':
+                    pattern = `interface\\s+${symbol}`;
+                    break;
+                default:
+                    pattern = symbol;
+            }
+            let grepCmd = `grep -rn --color=never -E "${pattern}" ${searchPath}`;
+            if (filePattern) {
+                grepCmd += ` --include="${filePattern}"`;
+            }
+            const { stdout } = await execAsync(grepCmd, {
+                maxBuffer: 10 * 1024 * 1024,
+                cwd: process.cwd()
+            });
+            if (!stdout.trim()) {
+                return {
+                    success: true,
+                    output: `未找到符号 "${symbol}"`,
+                    artifacts: []
+                };
+            }
+            return {
+                success: true,
+                output: stdout,
+                artifacts: []
+            };
+        }
+        catch (error) {
+            if (error.code === 1) {
+                return {
+                    success: true,
+                    output: `未找到符号 "${symbol}"`,
+                    artifacts: []
+                };
+            }
+            return {
+                success: false,
+                error: error.message,
+                output: ''
+            };
+        }
+    }
+    /**
+     * 分析文件的依赖关系（import/require）
+     */
+    static async toolAnalyzeDependencies(params) {
+        const targetPath = params.path;
+        // recursive 参数保留用于未来扩展
+        params.recursive;
+        try {
+            const stat = await promises_1.default.stat(targetPath);
+            let files = [];
+            if (stat.isFile()) {
+                files = [targetPath];
+            }
+            else if (stat.isDirectory()) {
+                // 获取目录下所有文件
+                const allFiles = await this.getFiles(targetPath, true);
+                files = allFiles
+                    .filter(f => f.type === 'file')
+                    .filter(f => /\.(ts|js|tsx|jsx|vue|svelte)$/.test(f.path))
+                    .map(f => f.path);
+            }
+            const dependencies = {};
+            for (const file of files) {
+                const content = await promises_1.default.readFile(file, 'utf-8');
+                const deps = [];
+                // 匹配 ES6 imports
+                const importRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g;
+                let match;
+                while ((match = importRegex.exec(content)) !== null) {
+                    deps.push(match[1]);
+                }
+                // 匹配 CommonJS requires
+                const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
+                while ((match = requireRegex.exec(content)) !== null) {
+                    deps.push(match[1]);
+                }
+                // 匹配动态 imports
+                const dynamicImportRegex = /import\(['"]([^'"]+)['"]\)/g;
+                while ((match = dynamicImportRegex.exec(content)) !== null) {
+                    deps.push(match[1]);
+                }
+                if (deps.length > 0) {
+                    dependencies[file] = [...new Set(deps)]; // 去重
+                }
+            }
+            // 格式化输出
+            let output = '依赖关系分析结果：\n\n';
+            for (const [file, deps] of Object.entries(dependencies)) {
+                output += `${file}:\n`;
+                for (const dep of deps) {
+                    output += `  - ${dep}\n`;
+                }
+                output += '\n';
+            }
+            return {
+                success: true,
+                output: output || '未找到依赖关系',
+                artifacts: []
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                output: ''
+            };
+        }
+    }
+    /**
+     * Git 状态
+     */
+    static async toolGitStatus(params) {
+        const repoPath = params.path || '.';
+        try {
+            const { stdout } = await execAsync(`git -C ${repoPath} status --porcelain -b`, {
+                cwd: process.cwd()
+            });
+            const { stdout: branchInfo } = await execAsync(`git -C ${repoPath} branch --show-current`, {
+                cwd: process.cwd()
+            });
+            let output = `当前分支: ${branchInfo.trim()}\n\n`;
+            if (!stdout.trim()) {
+                output += '工作区干净，没有未提交的更改';
+            }
+            else {
+                output += '未提交的更改:\n';
+                output += stdout;
+            }
+            return {
+                success: true,
+                output,
+                artifacts: []
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                output: '不是 Git 仓库或 Git 命令执行失败'
+            };
+        }
+    }
+    /**
+     * Git 差异
+     */
+    static async toolGitDiff(params) {
+        const filePath = params.file;
+        const cached = params.cached || false;
+        const lines = params.lines;
+        try {
+            let cmd = 'git diff';
+            if (cached)
+                cmd += ' --cached';
+            if (filePath)
+                cmd += ` -- ${filePath}`;
+            if (lines)
+                cmd += ` | head -n ${lines}`;
+            const { stdout } = await execAsync(cmd, {
+                maxBuffer: 10 * 1024 * 1024,
+                cwd: process.cwd()
+            });
+            if (!stdout.trim()) {
+                return {
+                    success: true,
+                    output: filePath ? `文件 ${filePath} 没有更改` : '没有更改',
+                    artifacts: []
+                };
+            }
+            return {
+                success: true,
+                output: stdout,
+                artifacts: []
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                output: ''
+            };
+        }
+    }
+    /**
+     * Git 日志
+     */
+    static async toolGitLog(params) {
+        const maxCount = params.max_count || 10;
+        const filePath = params.file;
+        const oneline = params.oneline !== false;
+        try {
+            let cmd = `git log -n ${maxCount}`;
+            if (oneline)
+                cmd += ' --oneline';
+            if (filePath)
+                cmd += ` -- ${filePath}`;
+            const { stdout } = await execAsync(cmd, {
+                cwd: process.cwd()
+            });
+            return {
+                success: true,
+                output: stdout || '没有提交历史',
+                artifacts: []
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                output: ''
+            };
+        }
+    }
+    /**
+     * 继续读取之前被截断的文件内容
+     */
+    static async toolContinueReading(params) {
+        const filePath = params.path;
+        const fromPosition = params.from_position;
+        const length = params.length || this.MAX_OUTPUT_LENGTH;
+        try {
+            let startPos = fromPosition;
+            // 如果没有指定位置，尝试从记录中获取
+            if (startPos === undefined) {
+                startPos = this.READ_POSITIONS.get(filePath) || this.MAX_OUTPUT_LENGTH;
+            }
+            const content = await promises_1.default.readFile(filePath, 'utf-8');
+            if (startPos >= content.length) {
+                return {
+                    success: true,
+                    output: '[EOF] 已到达文件末尾',
+                    artifacts: []
+                };
+            }
+            const endPos = Math.min(startPos + length, content.length);
+            const result = content.slice(startPos, endPos);
+            // 更新读取位置
+            this.READ_POSITIONS.set(filePath, endPos);
+            const prefix = `[从位置 ${startPos} 读取，共 ${result.length} 字符]\n\n`;
+            const remaining = content.length - endPos;
+            let suffix = '';
+            if (remaining > 0) {
+                suffix = `\n\n[还有 ${remaining} 字符未读取，使用 continue_reading 继续]`;
+                this.READ_POSITIONS.set(filePath, endPos);
+            }
+            else {
+                this.READ_POSITIONS.delete(filePath); // 到达末尾，清除记录
+            }
+            return {
+                success: true,
+                output: prefix + result + suffix,
+                readPosition: endPos,
+                artifacts: [filePath]
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                output: ''
+            };
+        }
+    }
+    /**
+     * 获取文件元信息
+     */
+    static async toolFileInfo(params) {
+        const filePath = params.path;
+        try {
+            const stat = await promises_1.default.stat(filePath);
+            const info = {
+                path: filePath,
+                type: stat.isDirectory() ? 'directory' : 'file',
+                size: stat.size,
+                sizeHuman: this.formatBytes(stat.size),
+                modified: stat.mtime.toISOString(),
+                created: stat.birthtime.toISOString(),
+                permissions: stat.mode.toString(8),
+                isReadable: !!(stat.mode & parseInt('0400', 8)), // 检查读权限
+                isWritable: !!(stat.mode & parseInt('0200', 8)) // 检查写权限
+            };
+            return {
+                success: true,
+                output: JSON.stringify(info, null, 2),
+                artifacts: []
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                output: ''
+            };
+        }
+    }
+    /**
+     * 格式化字节数
+     */
+    static formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+    }
 }
 exports.ToolExecutor = ToolExecutor;
 //# sourceMappingURL=executor.js.map