@zqagent/core 0.3.12 → 0.3.16

package/dist/tools/files.d.cts

@@ -1,5 +1,5 @@
 import { T as ToolRegistry } from '../ToolRegistry-DouDvn9E.cjs';
-import { C as ConflictGuard } from '../conflictGuard-BBOOIxxK.cjs';
+import { C as ConflictGuard } from '../conflictGuard-BuICnWEI.cjs';
 import '../types-BYyXWWPW.cjs';
 import '@zqagent/shared/model-capabilities';
 

package/dist/tools/files.d.ts

@@ -1,5 +1,5 @@
 import { T as ToolRegistry } from '../ToolRegistry-Cy0fQxrb.js';
-import { C as ConflictGuard } from '../conflictGuard-BBOOIxxK.js';
+import { C as ConflictGuard } from '../conflictGuard-BuICnWEI.js';
 import '../types-BYyXWWPW.js';
 import '@zqagent/shared/model-capabilities';
 

package/dist/tools/files.js

@@ -1,6 +1,8 @@
 // src/tools/files.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { createHash } from "crypto";
+import { StringDecoder } from "string_decoder";
 
 // src/tools/pathSafety.ts
 import * as fs from "fs";
@@ -48,61 +50,220 @@ function resolveWithinRoot(workspace, target) {
   return { root: rootReal, real };
 }
 
+// src/paths.ts
+var IS_WINDOWS = process.platform === "win32";
+
+// src/engine/toolResultBudget.ts
+var DEFAULT_TOOL_RESULT_MAX_CHARS = 24e3;
+var TOOL_MAX_CHARS = {
+  read_file: 24e3,
+  explore: 16e3,
+  run_shell: 12e3,
+  web_fetch: 12e3,
+  git_diff: 12e3,
+  grep: 1e4,
+  web_search: 8e3,
+  list_files: 8e3,
+  shell_task_output: 8e3,
+  /* repo_map 自带 16K 上限（tools/repoMap.ts 的 MAX_CHARS）。这里显式登记，
+   * 而不是落到 24K 默认值 —— 免得将来工具上限调大时被二次裁剪，口径也保持一致。 */
+  repo_map: 16e3,
+  git_log: 6e3,
+  git_status: 4e3
+};
+function globalBudgetChars() {
+  const n = Number(process.env.TOOL_RESULT_MAX_CHARS);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : void 0;
+}
+function toolResultBudget(tool) {
+  return globalBudgetChars() ?? TOOL_MAX_CHARS[tool] ?? DEFAULT_TOOL_RESULT_MAX_CHARS;
+}
+
+// src/tools/ignore.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var ALWAYS_SKIP_DIRS = /* @__PURE__ */ new Set([
+  // JS / TS
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".cache",
+  // JVM
+  "target",
+  ".gradle",
+  ".mvn",
+  // .NET
+  "bin",
+  "obj",
+  ".vs",
+  "TestResults",
+  // Python / Ruby / PHP
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".pytest_cache",
+  ".mypy_cache",
+  "vendor",
+  // 移动端
+  "Pods",
+  ".dart_tool",
+  "DerivedData",
+  // 覆盖率 / 通用
+  "coverage",
+  // 版本库
+  ".git",
+  ".svn",
+  ".hg"
+]);
+function loadGitignore(dir) {
+  const file = path2.join(dir, ".gitignore");
+  let text;
+  try {
+    const stat = fs2.statSync(file);
+    if (stat.size > 64 * 1024) return [];
+    text = fs2.readFileSync(file, "utf-8");
+  } catch {
+    return [];
+  }
+  const matchers = [];
+  for (const rawLine of text.split("\n")) {
+    let line = rawLine.replace(/\r$/, "").trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line.startsWith("!")) continue;
+    const anchored = rawLine.trim().startsWith("/");
+    const dirOnly = /\/\s*$/.test(rawLine.trim());
+    line = line.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!line) continue;
+    const pattern = line.split("").map((ch) => {
+      if (ch === "*") return ".*";
+      if (ch === "?") return ".";
+      return ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }).join("");
+    const re = new RegExp(line.includes("/") || anchored ? `^${pattern}$` : `(^|/)${pattern}$`);
+    matchers.push((rel, isDir) => {
+      if (dirOnly && !isDir) return false;
+      return re.test(rel);
+    });
+  }
+  return matchers;
+}
+function makeIgnoreFilter(root) {
+  const matchers = loadGitignore(root);
+  return (rel, isDir) => {
+    const name = rel.slice(rel.lastIndexOf("/") + 1);
+    if (name.startsWith(".")) return true;
+    if (isDir && ALWAYS_SKIP_DIRS.has(name)) return true;
+    return matchers.some((m) => m(rel, isDir));
+  };
+}
+
 // src/tools/files.ts
 var DEFAULT_MAX_LINES = 2e3;
 var MULTI_READ_MAX_TOTAL_LINES = 1500;
 var MAX_LINE_CHARS = 500;
+var READ_CHUNK_BYTES = 64 * 1024;
+var RESULT_META_RESERVE = 800;
 function makeReadFile(workspace, guard) {
-  const root = path2.resolve(workspace);
-  function readOne(filePath, startLine, maxLines) {
+  const root = path3.resolve(workspace);
+  function readWindow(target, startLine, maxLines, charBudget, onDigest) {
+    const fd = fs3.openSync(target, "r");
+    try {
+      const decoder = new StringDecoder("utf-8");
+      const hash = createHash("sha256");
+      const buf = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+      const lines = [];
+      let lineNo = 0;
+      let pending = "";
+      let chars = 0;
+      let capped = false;
+      let pos = 0;
+      const takeLine = (text) => {
+        lineNo += 1;
+        if (capped || lineNo < startLine || lines.length >= maxLines) return;
+        const clipped = text.length > MAX_LINE_CHARS ? text.slice(0, MAX_LINE_CHARS) + "\u2026 (line truncated)" : text;
+        const rendered = `${lineNo}|${clipped}`;
+        if (chars + rendered.length + 1 > charBudget) {
+          capped = true;
+          return;
+        }
+        chars += rendered.length + 1;
+        lines.push(rendered);
+      };
+      for (; ; ) {
+        const n = fs3.readSync(fd, buf, 0, READ_CHUNK_BYTES, pos);
+        if (n <= 0) break;
+        pos += n;
+        const decoded = decoder.write(buf.subarray(0, n));
+        hash.update(decoded, "utf8");
+        const text = pending + decoded;
+        let from = 0;
+        for (; ; ) {
+          const idx = text.indexOf("\n", from);
+          if (idx < 0) break;
+          takeLine(text.slice(from, idx).replace(/\r$/, ""));
+          from = idx + 1;
+        }
+        pending = text.slice(from);
+      }
+      const rest = decoder.end();
+      if (rest) hash.update(rest, "utf8");
+      const tail = pending + rest;
+      if (tail.length > 0) takeLine(tail.replace(/\r$/, ""));
+      onDigest(hash.digest("hex").slice(0, 16));
+      return { lines, totalLines: lineNo, capped };
+    } finally {
+      fs3.closeSync(fd);
+    }
+  }
+  function readOne(filePath, startLine, maxLines, charBudget) {
     const resolved = resolveWithinRoot(root, filePath);
     if (!resolved) {
       return { path: filePath, error: "\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916" };
     }
     const target = resolved.real;
-    if (!fs2.existsSync(target) || !fs2.statSync(target).isFile()) {
+    if (!fs3.existsSync(target) || !fs3.statSync(target).isFile()) {
       return { path: filePath, error: `\u4E0D\u662F\u6587\u4EF6: ${filePath}` };
     }
-    const selected = [];
-    let total = 0;
+    let read;
     try {
-      const content = fs2.readFileSync(target, "utf-8");
-      guard?.noteRead(target, content);
-      const lines = content.split("\n");
-      total = lines.length;
-      for (let i = startLine - 1; i < Math.min(startLine - 1 + maxLines, lines.length); i++) {
-        let text = lines[i];
-        if (text.length > MAX_LINE_CHARS) {
-          text = text.slice(0, MAX_LINE_CHARS) + "\u2026 (line truncated)";
-        }
-        selected.push(`${i + 1}|${text}`);
-      }
+      read = readWindow(target, startLine, maxLines, charBudget, (digest) => {
+        guard?.noteReadDigest(target, digest);
+      });
     } catch (exc) {
       return { path: filePath, error: `\u8BFB\u53D6\u5931\u8D25: ${String(exc)}` };
     }
+    const { lines: selected, totalLines: total, capped } = read;
     const end = startLine + selected.length - 1;
     const result = {
-      path: path2.relative(resolved.root, target),
+      path: path3.relative(resolved.root, target),
       start_line: startLine,
       end_line: end,
       total_lines: total,
       content: selected.join("\n")
     };
-    if (end < total) {
+    if (capped) {
+      result.note = `\u5DF2\u8FD4\u56DE\u7B2C ${startLine}-${end} \u884C\uFF08\u672C\u6B21\u5DF2\u8FBE\u5355\u6B21\u8BFB\u53D6\u4E0A\u9650\u7EA6 ${charBudget} \u5B57\u7B26\uFF0C\u5171 ${total} \u884C\uFF09\uFF1B\u8C03\u7528 read_file(start_line=${end + 1}) \u7EE7\u7EED\u9605\u8BFB`;
+    } else if (end < total) {
       result.note = `\u663E\u793A\u7B2C ${startLine}-${end} \u884C\uFF0C\u5171 ${total} \u884C\uFF1B\u8C03\u7528 read_file(start_line=${end + 1}) \u7EE7\u7EED\u9605\u8BFB`;
     }
     return result;
   }
   return function read_file(args) {
     const startLine = Math.max(1, Number(args.start_line ?? 1));
-    const maxLines = Math.min(Number(args.max_lines ?? DEFAULT_MAX_LINES), DEFAULT_MAX_LINES);
+    const requestedLines = Number(args.max_lines ?? DEFAULT_MAX_LINES);
+    const maxLines = Number.isFinite(requestedLines) ? Math.min(Math.max(1, Math.floor(requestedLines)), DEFAULT_MAX_LINES) : DEFAULT_MAX_LINES;
+    const fullBudget = Math.max(1e3, toolResultBudget("read_file") - RESULT_META_RESERVE);
     const paths = Array.isArray(args.paths) ? args.paths.map((p) => String(p ?? "")).filter(Boolean) : [];
     if (paths.length > 0) {
+      const perFileBudget = Math.max(1e3, Math.floor(fullBudget / paths.length));
       const files = [];
       let remainingLines = MULTI_READ_MAX_TOTAL_LINES;
       for (const filePath2 of paths) {
         const perFile = Math.min(maxLines, Math.max(1, remainingLines));
-        const one = readOne(filePath2, startLine, perFile);
+        const one = readOne(filePath2, startLine, perFile, perFileBudget);
         files.push(one);
         if (!one.error) remainingLines -= one.content.split("\n").length;
         if (remainingLines <= 0) break;
@@ -117,11 +278,11 @@ function makeReadFile(workspace, guard) {
     if (!filePath) {
       return { error: "\u7F3A\u5C11 path\uFF08\u6216 paths\uFF09\u53C2\u6570" };
     }
-    return readOne(filePath, startLine, maxLines);
+    return readOne(filePath, startLine, maxLines, fullBudget);
   };
 }
 function makeWriteFile(workspace, guard) {
-  const root = path2.resolve(workspace);
+  const root = path3.resolve(workspace);
   return function write_file(args) {
     const filePath = String(args.path ?? "");
     const content = String(args.content ?? "");
@@ -131,53 +292,101 @@ function makeWriteFile(workspace, guard) {
       return { error: "\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916" };
     }
     const target = resolved.real;
-    if (fs2.existsSync(target) && fs2.statSync(target).isDirectory()) {
+    if (fs3.existsSync(target) && fs3.statSync(target).isDirectory()) {
       return { error: "\u8DEF\u5F84\u662F\u76EE\u5F55\uFF0C\u4E0D\u662F\u6587\u4EF6" };
     }
-    if (fs2.existsSync(target) && !overwrite) {
+    if (fs3.existsSync(target) && !overwrite) {
       return { error: "\u6587\u4EF6\u5DF2\u5B58\u5728 (overwrite=false)" };
     }
     const conflict = guard?.checkWrite(target, filePath);
     if (conflict) return { error: conflict.message };
     try {
-      fs2.mkdirSync(path2.dirname(target), { recursive: true });
-      fs2.writeFileSync(target, content, "utf-8");
+      fs3.mkdirSync(path3.dirname(target), { recursive: true });
+      fs3.writeFileSync(target, content, "utf-8");
       guard?.noteWrite(target, content);
     } catch (exc) {
       return { error: `\u5199\u5165\u5931\u8D25: ${String(exc)}` };
     }
-    return path2.relative(resolved.root, target);
+    return path3.relative(resolved.root, target);
   };
 }
+var DEFAULT_LIST_DEPTH = 3;
+var MAX_LIST_DEPTH = 6;
+var DEFAULT_RECURSIVE_LIMIT = 400;
+var MAX_RECURSIVE_LIMIT = 1e3;
 function makeListFiles(workspace) {
-  const root = path2.resolve(workspace);
+  const root = path3.resolve(workspace);
   return function list_files(args) {
     const dirPath = String(args.path ?? ".");
-    const maxResults = Math.min(Number(args.max_results ?? 100), 100);
+    const recursive = args.recursive === true;
+    const requestedMax = Number(args.max_results ?? (recursive ? DEFAULT_RECURSIVE_LIMIT : 100));
+    const hardCap = recursive ? MAX_RECURSIVE_LIMIT : 100;
+    const maxResults = Number.isFinite(requestedMax) ? Math.max(1, Math.min(Math.floor(requestedMax), hardCap)) : hardCap;
+    const requestedDepth = Number(args.max_depth ?? DEFAULT_LIST_DEPTH);
+    const maxDepth = Number.isFinite(requestedDepth) ? Math.max(1, Math.min(Math.floor(requestedDepth), MAX_LIST_DEPTH)) : DEFAULT_LIST_DEPTH;
     const resolved = resolveWithinRoot(root, dirPath);
     if (!resolved) return { error: "\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916" };
     const target = resolved.real;
-    if (!fs2.existsSync(target) || !fs2.statSync(target).isDirectory()) {
+    if (!fs3.existsSync(target) || !fs3.statSync(target).isDirectory()) {
       return { error: `\u4E0D\u662F\u76EE\u5F55: ${dirPath}` };
     }
+    const realRoot = resolved.root;
+    const isIgnored = makeIgnoreFilter(realRoot);
     try {
-      const entries = fs2.readdirSync(target, { withFileTypes: true });
+      if (!recursive) {
+        const results2 = [];
+        for (const e of fs3.readdirSync(target, { withFileTypes: true })) {
+          if (results2.length >= maxResults) break;
+          const rel = path3.relative(realRoot, path3.join(target, e.name)).split(path3.sep).join("/");
+          if (isIgnored(rel, e.isDirectory())) continue;
+          results2.push(e.isDirectory() ? `${e.name}/` : e.name);
+        }
+        results2.sort();
+        return { path: path3.relative(realRoot, target), entries: results2.slice(0, maxResults) };
+      }
       const results = [];
-      for (const e of entries) {
-        if (results.length >= maxResults) break;
-        if (e.name.startsWith(".")) continue;
-        if (e.name === "node_modules" || e.name === "__pycache__" || e.name === "dist") continue;
-        results.push(e.isDirectory() ? `${e.name}/` : e.name);
+      let truncated = false;
+      const queue = [{ dir: target, depth: 1 }];
+      while (queue.length > 0) {
+        const { dir, depth } = queue.shift();
+        let entries;
+        try {
+          entries = fs3.readdirSync(dir, { withFileTypes: true });
+        } catch {
+          continue;
+        }
+        entries.sort((a, b) => {
+          if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+          return a.name.localeCompare(b.name, "zh");
+        });
+        for (const e of entries) {
+          if (results.length >= maxResults) {
+            truncated = true;
+            break;
+          }
+          const full = path3.join(dir, e.name);
+          const rel = path3.relative(realRoot, full).split(path3.sep).join("/");
+          const isDir = e.isDirectory();
+          if (isIgnored(rel, isDir)) continue;
+          results.push(isDir ? `${rel}/` : rel);
+          if (isDir && depth < maxDepth) queue.push({ dir: full, depth: depth + 1 });
+        }
+        if (truncated) break;
       }
-      results.sort();
-      return { path: path2.relative(resolved.root, target), entries: results.slice(0, maxResults) };
+      return {
+        path: path3.relative(realRoot, target),
+        entries: results,
+        ...truncated ? {
+          note: `\u5DF2\u8FBE\u5230\u6761\u76EE\u4E0A\u9650 ${maxResults}\uFF0C\u7ED3\u679C\u88AB\u622A\u65AD\uFF1B\u8BF7\u7F29\u5C0F path \u5230\u5177\u4F53\u5B50\u76EE\u5F55\uFF0C\u6216\u964D\u4F4E max_depth\uFF08\u5F53\u524D ${maxDepth}\uFF09`
+        } : {}
+      };
     } catch (exc) {
       return { error: `\u5217\u51FA\u6587\u4EF6\u5931\u8D25: ${String(exc)}` };
     }
   };
 }
 function makeReplaceInFile(workspace, guard) {
-  const root = path2.resolve(workspace);
+  const root = path3.resolve(workspace);
   return function replace_in_file(args) {
     const filePath = String(args.path ?? "");
     const oldStr = String(args.old ?? "");
@@ -187,22 +396,22 @@ function makeReplaceInFile(workspace, guard) {
     const resolved = resolveWithinRoot(root, filePath);
     if (!resolved) return { error: "\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E4B\u5916" };
     const target = resolved.real;
-    if (!fs2.existsSync(target) || !fs2.statSync(target).isFile()) {
+    if (!fs3.existsSync(target) || !fs3.statSync(target).isFile()) {
       return { error: `\u4E0D\u662F\u6587\u4EF6: ${filePath}` };
     }
     const conflict = guard?.checkWrite(target, filePath);
     if (conflict) return { error: conflict.message };
     try {
-      const content = fs2.readFileSync(target, "utf-8");
+      const content = fs3.readFileSync(target, "utf-8");
       const count = content.split(oldStr).length - 1;
       if (count !== expectedReplacements) {
         return { error: `\u671F\u671B ${expectedReplacements} \u5904\u66FF\u6362\uFF0C\u5B9E\u9645\u627E\u5230 ${count} \u5904: ${filePath}` };
       }
       const updated = content.replaceAll(oldStr, newStr);
-      fs2.writeFileSync(target, updated, "utf-8");
+      fs3.writeFileSync(target, updated, "utf-8");
       guard?.noteWrite(target, updated);
       return {
-        path: path2.relative(resolved.root, target),
+        path: path3.relative(resolved.root, target),
         replacements: count,
         chars_before: content.length,
         chars_after: updated.length
@@ -246,12 +455,23 @@ function registerReadOnlyFileTools(registry, workspace, guard) {
       type: "function",
       function: {
         name: "list_files",
-        description: "\u5217\u51FA\u76EE\u5F55\u4E0B\u7684\u6587\u4EF6\u548C\u5B50\u76EE\u5F55\u3002\u8DF3\u8FC7\u9690\u85CF\u6587\u4EF6\u548C node_modules \u7B49\u76EE\u5F55\u3002",
+        description: "\u5217\u51FA\u76EE\u5F55\u4E0B\u7684\u6587\u4EF6\u548C\u5B50\u76EE\u5F55\u3002\u8DF3\u8FC7\u9690\u85CF\u9879\u3001\u5E38\u89C1\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\uFF0C\u5E76\u9075\u5B88\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55\u7684 .gitignore\u3002\u4E86\u89E3\u5927\u4ED3\u5E93\u7ED3\u6784\u65F6\u7528 recursive=true \u4E00\u6B21\u62FF\u5230\u6709\u9650\u6DF1\u5EA6\uFF08\u9ED8\u8BA4 3 \u5C42\uFF09\u7684\u6811\uFF0C\u6BD4\u9010\u5C42\u8C03\u7528\u7701\u5F88\u591A\u5F80\u8FD4\uFF1B\u6761\u76EE\u8FC7\u591A\u65F6\u4F1A\u622A\u65AD\u5E76\u63D0\u793A\u3002",
         parameters: {
           type: "object",
           properties: {
             path: { type: "string", description: "\u76EE\u5F55\u8DEF\u5F84 (\u76F8\u5BF9\u4E8E\u5DE5\u4F5C\u533A\uFF0C\u9ED8\u8BA4 '.')" },
-            max_results: { type: "integer", description: "\u6700\u5927\u7ED3\u679C\u6570 (\u9ED8\u8BA4 100)" }
+            recursive: {
+              type: "boolean",
+              description: "\u9012\u5F52\u5217\u51FA\u5B50\u76EE\u5F55\uFF08\u9ED8\u8BA4 false\uFF0C\u53EA\u5217\u4E00\u5C42\uFF09"
+            },
+            max_depth: {
+              type: "integer",
+              description: `\u9012\u5F52\u6DF1\u5EA6 (\u9ED8\u8BA4 ${DEFAULT_LIST_DEPTH}\uFF0C\u4E0A\u9650 ${MAX_LIST_DEPTH}\uFF1B\u4EC5 recursive \u65F6\u751F\u6548)`
+            },
+            max_results: {
+              type: "integer",
+              description: `\u6700\u5927\u7ED3\u679C\u6570\uFF08\u975E\u9012\u5F52\u9ED8\u8BA4 100 / \u4E0A\u9650 100\uFF1B\u9012\u5F52\u9ED8\u8BA4 ${DEFAULT_RECURSIVE_LIMIT} / \u4E0A\u9650 ${MAX_RECURSIVE_LIMIT}\uFF09`
+            }
           }
         }
       }