aws-runtime-bridge 1.9.33 → 1.9.41

package/package/acode/dist/built-in-file-tools.js

@@ -1,7 +1,36 @@
 import { randomUUID } from "node:crypto";
-import { promises as fs } from "node:fs";
+import { promises as fs, createReadStream } from "node:fs";
 import path from "node:path";
+import readline from "node:readline";
 import { runShellCommand, } from "./builtins/shellCommandRunner.js";
+// ── read_file pagination & truncation constants ──────────────────────────────
+const DEFAULT_READ_LIMIT = 2000;
+const MAX_LINE_LENGTH = 2000;
+const MAX_READ_BYTES = 50 * 1024; // 50 KB
+const BINARY_SAMPLE_BYTES = 4096;
+const BINARY_NON_PRINTABLE_RATIO = 0.3;
+const BINARY_EXTENSIONS = new Set([
+    ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".webp", ".tiff", ".tif",
+    ".zip", ".gz", ".tar", ".rar", ".7z", ".bz2", ".xz", ".lz",
+    ".exe", ".dll", ".so", ".dylib", ".bin", ".o", ".a",
+    ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx",
+    ".mp3", ".mp4", ".avi", ".mov", ".wav", ".flv", ".mkv", ".ogg",
+    ".woff", ".woff2", ".ttf", ".otf", ".eot",
+    ".class", ".jar", ".war", ".ear",
+    ".pyc", ".pyo", ".node",
+    ".sqlite", ".db", ".mdb",
+    ".wasm",
+]);
+// ─────────────────────────────────────────────────────────────────────────────
+// ── grep search constants ────────────────────────────────────────────────────
+const MAX_GREP_FILES = 1000;
+const MAX_GREP_FILE_SIZE = 1024 * 1024; // 1 MB – skip larger files
+const MAX_GREP_OUTPUT_BYTES = 256 * 1024; // 256 KB – cap total output
+const DEFAULT_GREP_MAX_RESULTS = 1000;
+const GREP_SKIP_DIRS = new Set([
+    ".git", "node_modules", "dist", "build", ".next", ".nuxt",
+    ".cache", ".turbo", ".output", "coverage", ".nyc_output",
+]);
 function toDisplayPath(targetPath) {
     return targetPath.replace(/\\/g, "/");
 }
@@ -58,6 +87,42 @@ function readOptionalPositiveIntegerArg(args, names, fallback) {
     }
     return fallback;
 }
+/**
+ * 检测文件是否为二进制文件。
+ * 主流程：先查扩展名黑名单 -> 再采样前 4KB 检测 NUL 字节或高比例不可见字符。
+ */
+async function isBinaryFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (BINARY_EXTENSIONS.has(ext)) {
+        return true;
+    }
+    const handle = await fs.open(filePath, "r");
+    try {
+        const buffer = Buffer.alloc(BINARY_SAMPLE_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, BINARY_SAMPLE_BYTES, 0);
+        if (bytesRead === 0) {
+            return false;
+        }
+        const sample = buffer.subarray(0, bytesRead);
+        // NUL byte = definitely binary
+        if (sample.includes(0)) {
+            return true;
+        }
+        // >30% non-printable characters = likely binary
+        let nonPrintable = 0;
+        for (let i = 0; i < bytesRead; i++) {
+            const byte = sample[i];
+            // Allow: tab(0x09), LF(0x0a), CR(0x0d), printable ASCII (0x20-0x7e), UTF-8 high bytes (0x80-0xff)
+            if (byte < 0x09 || (byte > 0x0d && byte < 0x20)) {
+                nonPrintable++;
+            }
+        }
+        return nonPrintable / bytesRead > BINARY_NON_PRINTABLE_RATIO;
+    }
+    finally {
+        await handle.close();
+    }
+}
 function ensureInsideWorkspace(workspaceRoot, targetPath) {
     const resolvedTargetPath = path.resolve(targetPath);
     const relativePath = path.relative(workspaceRoot, resolvedTargetPath);
@@ -178,6 +243,249 @@ async function readFileInsideWorkspace(workingDirectory, filePath) {
         content: await fs.readFile(realTargetPath, "utf-8"),
     };
 }
+/**
+ * 分页流式读取工作区内文本文件，带行号前缀、双重截断上限和续读提示。
+ *
+ * 主流程：
+ *   1. 路径解析与安全校验（复用 resolveWorkspaceTarget + ensureInsideWorkspace + realpath）
+ *   2. 二进制检测（扩展名黑名单 + 4KB 采样）
+ *   3. createReadStream + readline 逐行流式读取，跳过 offset 前行
+ *   4. 收集 limit 行，同时持续计数总行数（用于底部提示）
+ *   5. 双重上限：行数 2000 + 字节 50KB，先触发先截断
+ *   6. 拼装行号前缀 + 底部续读提示
+ *
+ * 不修改 readFileInsideWorkspace，edit_file 仍使用全量读取。
+ */
+async function readFileWithPagination(workingDirectory, filePath, offset, limit) {
+    const target = await resolveWorkspaceTarget(workingDirectory, filePath);
+    const realTargetPath = ensureInsideWorkspace(target.workspaceRoot, await fs.realpath(target.targetPath));
+    const stat = await fs.stat(realTargetPath);
+    if (!stat.isFile()) {
+        throw new Error(`Path is not a file: ${realTargetPath}`);
+    }
+    // ── 二进制检测 ──
+    if (await isBinaryFile(realTargetPath)) {
+        return {
+            workspaceRoot: target.workspaceRoot,
+            targetPath: realTargetPath,
+            content: "[Binary file, content skipped]",
+            isBinary: true,
+            truncated: false,
+            totalLines: 0,
+            shownFromLine: 0,
+            shownToLine: 0,
+        };
+    }
+    // ── 流式逐行读取 ──
+    const stream = createReadStream(realTargetPath, { encoding: "utf-8" });
+    const rl = readline.createInterface({
+        input: stream,
+        crlfDelay: Infinity,
+    });
+    try {
+        const outputLines = [];
+        let lineNumber = 0; // 0-indexed 内部计数
+        let totalLines = 0;
+        let bytes = 0;
+        let truncatedByLines = false;
+        let truncatedByBytes = false;
+        const startIndex = offset - 1; // 转为 0-indexed
+        for await (const text of rl) {
+            totalLines++;
+            // 跳过 offset 前的行
+            if (lineNumber < startIndex) {
+                lineNumber++;
+                continue;
+            }
+            // 已达 limit 上限：停止收集但继续计数
+            if (outputLines.length >= limit) {
+                truncatedByLines = true;
+                lineNumber++;
+                continue;
+            }
+            // 单行截断
+            let line = text;
+            if (line.length > MAX_LINE_LENGTH) {
+                line =
+                    line.slice(0, MAX_LINE_LENGTH) +
+                        `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
+            }
+            const numberedLine = `${lineNumber + 1}: ${line}`;
+            const lineBytes = Buffer.byteLength(numberedLine, "utf-8") + 1; // +1 for \n
+            // 字节上限：停止读取（totalLines 不再准确）
+            if (bytes + lineBytes > MAX_READ_BYTES) {
+                truncatedByBytes = true;
+                break;
+            }
+            outputLines.push(numberedLine);
+            bytes += lineBytes;
+            lineNumber++;
+        }
+        // offset 超出文件总行数（空文件除外）
+        if (totalLines > 0 &&
+            outputLines.length === 0 &&
+            !truncatedByLines &&
+            !truncatedByBytes &&
+            startIndex >= totalLines) {
+            throw new Error(`offset ${offset} exceeds total line count ${totalLines} in file: ${realTargetPath}`);
+        }
+        const shownFromLine = outputLines.length > 0 ? offset : 0;
+        const shownToLine = outputLines.length > 0 ? offset + outputLines.length - 1 : 0;
+        // ── 底部续读提示 ──
+        let footer;
+        if (truncatedByBytes) {
+            footer = `Output capped at 50 KB. Showing lines ${shownFromLine}-${shownToLine}. Use offset=${shownToLine + 1} to continue.`;
+        }
+        else if (truncatedByLines) {
+            footer = `Showing lines ${shownFromLine}-${shownToLine} of ${totalLines}. Use offset=${shownToLine + 1} to continue.`;
+        }
+        else {
+            footer = `End of file - total ${totalLines} lines`;
+        }
+        const content = outputLines.length > 0
+            ? outputLines.join("\n") + "\n" + footer
+            : footer;
+        return {
+            workspaceRoot: target.workspaceRoot,
+            targetPath: realTargetPath,
+            content,
+            isBinary: false,
+            truncated: truncatedByLines || truncatedByBytes,
+            totalLines: truncatedByBytes ? -1 : totalLines,
+            shownFromLine,
+            shownToLine,
+        };
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+}
+// ── grep helpers ──────────────────────────────────────────────────────────────
+/**
+ * 将 glob 通配符转换为 RegExp（匹配文件 basename）。
+ * 支持：* (不跨 / ), ? (单个非 / 字符), {a,b} (分组), [abc] (字符类)。
+ */
+function globToRegex(pattern) {
+    let regex = "";
+    let i = 0;
+    while (i < pattern.length) {
+        const char = pattern[i];
+        if (char === "*") {
+            regex += "[^/]*";
+        }
+        else if (char === "?") {
+            regex += "[^/]";
+        }
+        else if (char === "{") {
+            const end = pattern.indexOf("}", i);
+            if (end >= 0) {
+                const content = pattern.slice(i + 1, end);
+                regex += `(${content.split(",").join("|")})`;
+                i = end;
+            }
+            else {
+                regex += "\\{";
+            }
+        }
+        else if (char === "[") {
+            const end = pattern.indexOf("]", i);
+            if (end >= 0) {
+                regex += pattern.slice(i, end + 1);
+                i = end;
+            }
+            else {
+                regex += "\\[";
+            }
+        }
+        else if ("+^$.()|\\".includes(char)) {
+            regex += "\\" + char;
+        }
+        else {
+            regex += char;
+        }
+        i++;
+    }
+    return new RegExp(`^${regex}$`);
+}
+/**
+ * 递归遍历目录，返回所有匹配 include/exclude 的文件路径。
+ * 主流程：readdir -> 跳过 GREP_SKIP_DIRS 和隐藏目录 -> 递归子目录 -> 过滤文件名。
+ */
+async function walkDirectory(dir, includeRegex, excludeRegex, maxFiles) {
+    const results = [];
+    async function walk(currentDir) {
+        if (results.length >= maxFiles)
+            return;
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (results.length >= maxFiles)
+                return;
+            if (entry.name.startsWith(".") && entry.isDirectory())
+                continue;
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                if (GREP_SKIP_DIRS.has(entry.name))
+                    continue;
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                if (includeRegex && !includeRegex.test(entry.name))
+                    continue;
+                if (excludeRegex && excludeRegex.test(entry.name))
+                    continue;
+                results.push(fullPath);
+            }
+        }
+    }
+    await walk(dir);
+    return results;
+}
+/**
+ * 在单个文件中搜索正则匹配，返回匹配行（含行号）或计数。
+ * 主流程：文件大小检查 -> 二进制检测 -> 流式逐行读取 -> 正则匹配 -> 收集结果。
+ */
+async function searchInFile(filePath, workspaceRoot, options) {
+    const stat = await fs.stat(filePath);
+    if (stat.size > MAX_GREP_FILE_SIZE) {
+        return { matches: [], count: 0 };
+    }
+    if (await isBinaryFile(filePath)) {
+        return { matches: [], count: 0 };
+    }
+    const relativePath = path.relative(workspaceRoot, filePath).replace(/\\/g, "/");
+    const matches = [];
+    let count = 0;
+    const stream = createReadStream(filePath, { encoding: "utf-8" });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    try {
+        let lineNumber = 0;
+        for await (const text of rl) {
+            lineNumber++;
+            if (options.regex.test(text)) {
+                count++;
+                if (options.collectContent) {
+                    let content = text;
+                    if (content.length > MAX_LINE_LENGTH) {
+                        content =
+                            content.slice(0, MAX_LINE_LENGTH) +
+                                `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
+                    }
+                    matches.push({ file: relativePath, line: lineNumber, content });
+                    if (matches.length >= options.maxResults)
+                        break;
+                }
+                if (options.stopOnFirstMatch)
+                    break;
+            }
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+    return { matches, count };
+}
 const MAX_COMMAND_TIMEOUT_MS = 10 * 60_000;
 const DEFAULT_COMMAND_TIMEOUT_MS = MAX_COMMAND_TIMEOUT_MS;
 const DEFAULT_COMMAND_INACTIVITY_TIMEOUT_MS = 60_000;
@@ -273,7 +581,12 @@ function readFileTool(workingDirectory) {
         kind: "builtin",
         toolName: "read_file",
         exposedName: "read_file",
-        description: "Read a UTF-8 text file inside the current workspace.",
+        description: "Read a UTF-8 text file inside the current workspace. " +
+            "Returns content with line numbers in the format '<line>: <content>'. " +
+            "Supports offset (1-indexed line number to start from) and limit (max lines to return, default 2000). " +
+            "Output is capped at 2000 lines or 50 KB, whichever is reached first. " +
+            "Individual lines longer than 2000 characters are truncated. " +
+            "Avoid tiny repeated slices (e.g. 30-line chunks); read a larger window if more context is needed.",
         inputSchema: {
             type: "object",
             properties: {
@@ -281,19 +594,34 @@ function readFileTool(workingDirectory) {
                     type: "string",
                     description: "Workspace-relative file path to read.",
                 },
+                offset: {
+                    type: "number",
+                    description: "Line number to start reading from (1-indexed). Defaults to 1.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of lines to return. Defaults to 2000.",
+                },
             },
             required: ["file_path"],
             additionalProperties: false,
         },
         async execute(args) {
             const filePath = readStringArg(args, ["file_path", "filePath"], "file_path");
-            const result = await readFileInsideWorkspace(workingDirectory, filePath);
+            const offset = readOptionalPositiveIntegerArg(args, ["offset"], 1);
+            const limit = readOptionalPositiveIntegerArg(args, ["limit"], DEFAULT_READ_LIMIT);
+            const result = await readFileWithPagination(workingDirectory, filePath, offset, limit);
             return {
                 ok: true,
                 tool: "read_file",
                 workspacePath: toDisplayPath(result.workspaceRoot),
                 filePath: toDisplayPath(result.targetPath),
                 content: result.content,
+                isBinary: result.isBinary,
+                truncated: result.truncated,
+                totalLines: result.totalLines,
+                shownFromLine: result.shownFromLine,
+                shownToLine: result.shownToLine,
             };
         },
     };
@@ -371,12 +699,185 @@ function bashTool(workingDirectory, agentId) {
         },
     };
 }
+function grepTool(workingDirectory) {
+    return {
+        kind: "builtin",
+        toolName: "grep",
+        exposedName: "grep",
+        description: "Search file contents using regular expressions within the workspace. " +
+            "Returns matched lines with file paths and line numbers. " +
+            "Supports include/exclude glob patterns, case-insensitive matching, and three output modes " +
+            "(content, files_with_matches, count). Searches recursively through directories, " +
+            "skipping binary files, hidden directories, and common build/dependency directories (node_modules, .git, dist, etc.).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pattern: {
+                    type: "string",
+                    description: "Regular expression pattern to search for in file contents.",
+                },
+                path: {
+                    type: "string",
+                    description: "Workspace-relative file or directory path to search in. Defaults to the workspace root.",
+                },
+                include: {
+                    type: "string",
+                    description: "Glob pattern to filter files by name (e.g. '*.ts', '*.{js,ts}'). Only matching files are searched.",
+                },
+                exclude: {
+                    type: "string",
+                    description: "Glob pattern to exclude files by name (e.g. '*.test.ts'). Matching files are skipped.",
+                },
+                case_insensitive: {
+                    type: "boolean",
+                    description: "Case-insensitive matching. Default false.",
+                },
+                output_mode: {
+                    type: "string",
+                    enum: ["content", "files_with_matches", "count"],
+                    description: "Output format: 'content' returns matched lines with line numbers (default), " +
+                        "'files_with_matches' returns only file paths with matches, " +
+                        "'count' returns match counts per file.",
+                },
+                max_results: {
+                    type: "number",
+                    description: "Maximum number of matched lines to return (content mode). Default 1000.",
+                },
+            },
+            required: ["pattern"],
+            additionalProperties: false,
+        },
+        /**
+         * grep 工具执行主流程：
+         *   1. 解析参数（pattern, path, include/exclude, output_mode 等）
+         *   2. 编译正则（含 case_insensitive 标志）
+         *   3. 解析搜索路径并校验 workspace 边界
+         *   4. 收集待搜索文件列表（单文件或递归遍历目录）
+         *   5. 逐文件搜索（流式读取 + 正则匹配）
+         *   6. 根据 output_mode 构建响应
+         */
+        async execute(args) {
+            const pattern = readStringArg(args, ["pattern"], "pattern");
+            const searchPath = readOptionalStringArg(args, ["path"]) || ".";
+            const includeGlob = readOptionalStringArg(args, ["include"]);
+            const excludeGlob = readOptionalStringArg(args, ["exclude"]);
+            const caseInsensitive = args.case_insensitive === true;
+            const outputMode = (() => {
+                const mode = args.output_mode;
+                if (mode === "files_with_matches" || mode === "count")
+                    return mode;
+                return "content";
+            })();
+            const maxResults = readOptionalPositiveIntegerArg(args, ["max_results"], DEFAULT_GREP_MAX_RESULTS);
+            // ── 编译正则 ──
+            const flags = caseInsensitive ? "i" : "";
+            let regex;
+            try {
+                regex = new RegExp(pattern, flags);
+            }
+            catch (error) {
+                throw new Error(`Invalid regex pattern: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const includeRegex = includeGlob ? globToRegex(includeGlob) : null;
+            const excludeRegex = excludeGlob ? globToRegex(excludeGlob) : null;
+            // ── 解析搜索路径（复用 workspace 安全校验） ──
+            const target = await resolveWorkspaceTarget(workingDirectory, searchPath);
+            const realTargetPath = ensureInsideWorkspace(target.workspaceRoot, await fs.realpath(target.targetPath));
+            const targetStat = await fs.stat(realTargetPath);
+            // ── 收集文件列表 ──
+            let files;
+            if (targetStat.isFile()) {
+                files = [realTargetPath];
+            }
+            else if (targetStat.isDirectory()) {
+                files = await walkDirectory(realTargetPath, includeRegex, excludeRegex, MAX_GREP_FILES);
+            }
+            else {
+                throw new Error(`Path is neither a file nor a directory: ${realTargetPath}`);
+            }
+            // ── 逐文件搜索 ──
+            const allMatches = [];
+            const fileCounts = [];
+            const matchedFiles = [];
+            let totalMatches = 0;
+            let outputBytes = 0;
+            let truncated = false;
+            for (const filePath of files) {
+                // content 模式：全局 maxResults 上限
+                if (outputMode === "content" && allMatches.length >= maxResults) {
+                    truncated = true;
+                    break;
+                }
+                const searchOptions = {
+                    regex,
+                    maxResults: outputMode === "content"
+                        ? maxResults - allMatches.length
+                        : Number.MAX_SAFE_INTEGER,
+                    collectContent: outputMode === "content",
+                    stopOnFirstMatch: outputMode === "files_with_matches",
+                };
+                const result = await searchInFile(filePath, target.workspaceRoot, searchOptions);
+                if (result.count > 0) {
+                    const relativePath = path
+                        .relative(target.workspaceRoot, filePath)
+                        .replace(/\\/g, "/");
+                    matchedFiles.push(relativePath);
+                    totalMatches += result.count;
+                    if (outputMode === "content") {
+                        for (const match of result.matches) {
+                            const matchBytes = Buffer.byteLength(match.content, "utf-8") + 64;
+                            if (outputBytes + matchBytes > MAX_GREP_OUTPUT_BYTES) {
+                                truncated = true;
+                                break;
+                            }
+                            outputBytes += matchBytes;
+                            allMatches.push(match);
+                        }
+                        if (truncated)
+                            break;
+                        // max_results 截断：收集完本文件匹配后检查是否已达上限
+                        if (allMatches.length >= maxResults) {
+                            truncated = true;
+                            break;
+                        }
+                    }
+                    else if (outputMode === "count") {
+                        fileCounts.push({ file: relativePath, count: result.count });
+                    }
+                }
+            }
+            // ── 构建响应 ──
+            const response = {
+                ok: true,
+                tool: "grep",
+                pattern,
+                searchPath: toDisplayPath(target.targetPath),
+                outputMode,
+                filesSearched: files.length,
+                filesMatched: matchedFiles.length,
+                totalMatches,
+                truncated,
+            };
+            if (outputMode === "content") {
+                response.matches = allMatches;
+            }
+            else if (outputMode === "files_with_matches") {
+                response.matches = matchedFiles;
+            }
+            else {
+                response.matches = fileCounts;
+            }
+            return response;
+        },
+    };
+}
 export function createBuiltInFileTools(workingDirectory, agentId) {
     const resolvedAgentId = agentId || "unknown";
     return [
         readFileTool(workingDirectory),
         writeFileTool(workingDirectory),
         editFileTool(workingDirectory),
+        grepTool(workingDirectory),
         bashTool(workingDirectory, resolvedAgentId),
     ];
 }