@livx.cc/agentx 0.99.32 → 0.99.34

package/dist/cli.js

@@ -302,7 +302,24 @@ var init_redact = __esm({
 function ckAbort(signal) {
   if (signal?.aborted) throw new Error("aborted");
 }
-async function walkFiles(fs, dir, signal, out = []) {
+function realOf(fs, p) {
+  const rp = fs.canonicalPath;
+  if (typeof rp !== "function") return p;
+  try {
+    return rp.call(fs, p) || p;
+  } catch {
+    return p;
+  }
+}
+async function walkFiles(fs, dir, signal, out = [], st, depth = 0) {
+  const state = st ?? { skip: new Set(DEFAULT_SKIP_DIRS), maxDepth: DEFAULT_MAX_DEPTH, seen: /* @__PURE__ */ new Set(), prunedDirs: /* @__PURE__ */ new Set(), depthCuts: 0 };
+  if (depth > state.maxDepth) {
+    state.depthCuts++;
+    return out;
+  }
+  const real = realOf(fs, dir);
+  if (state.seen.has(real)) return out;
+  state.seen.add(real);
   let entries;
   try {
     entries = await fs.readDir(dir);
@@ -311,12 +328,57 @@ async function walkFiles(fs, dir, signal, out = []) {
   }
   for (const name of entries.sort()) {
     ckAbort(signal);
+    if (state.skip.has(name)) {
+      state.prunedDirs.add(name);
+      continue;
+    }
     const p = dir === "/" ? `/${name}` : `${dir}/${name}`;
-    if (await fs.isDirectory(p)) await walkFiles(fs, p, signal, out);
+    if (await fs.isDirectory(p)) await walkFiles(fs, p, signal, out, state, depth + 1);
     else out.push(p);
   }
   return out;
 }
+function scanRoots(fs, path, opts) {
+  const asked = path == null ? [] : (Array.isArray(path) ? path : [path]).map((p) => String(p)).filter(Boolean);
+  const roots = (asked.length ? asked : opts?.roots?.length ? opts.roots : [fsCwd(fs)]).map((r) => r.length > 1 && r.endsWith("/") ? r.slice(0, -1) : r);
+  return [...new Set(roots)].filter((r, _i, all) => !all.some((other) => other !== r && r.startsWith(`${other}/`)));
+}
+function scanNote(states) {
+  const pruned = [...new Set(states.flatMap((st) => [...st.prunedDirs]))].sort();
+  const cuts = states.reduce((n, st) => n + st.depthCuts, 0);
+  const parts = [];
+  if (pruned.length) parts.push(`skipped ${pruned.join(", ")} (pass skipDirs to include them)`);
+  if (cuts) parts.push(`stopped at depth ${states[0]?.maxDepth} in ${cuts} place${cuts === 1 ? "" : "s"} (pass maxDepth to go deeper)`);
+  return parts.length ? `
+[scan: ${parts.join("; ")}]` : "";
+}
+async function walkRoots(fs, roots, signal, opts, call) {
+  const skip = new Set(call?.skipDirs ?? opts?.skipDirs ?? DEFAULT_SKIP_DIRS);
+  const maxDepth = call?.maxDepth ?? opts?.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const out = [];
+  const states = [];
+  for (const root of roots) {
+    const state = { skip, maxDepth, seen: /* @__PURE__ */ new Set(), prunedDirs: /* @__PURE__ */ new Set(), depthCuts: 0 };
+    states.push(state);
+    await walkFiles(fs, root, signal, out, state, 0);
+  }
+  return { files: out, note: scanNote(states) };
+}
+function callScan(args) {
+  const sd = args.skipDirs;
+  return {
+    skipDirs: Array.isArray(sd) ? sd.map(String) : typeof sd === "string" ? sd.split(",").map((x) => x.trim()).filter(Boolean) : void 0,
+    maxDepth: args.maxDepth == null ? void 0 : Number(args.maxDepth)
+  };
+}
+function anchoredGlobAt(root, glob) {
+  if (glob.startsWith("/")) return globToRegExp(glob);
+  return globToRegExp(`${root === "/" ? "" : root}/${glob}`);
+}
+function globMatcher(roots, glob) {
+  const res = roots.map((r) => anchoredGlobAt(r, glob));
+  return (p) => res.some((re) => re.test(p));
+}
 function globToRegExp(glob, caseInsensitive = false) {
   const g = glob.startsWith("/") ? glob : `/${glob}`;
   let re = "";
@@ -338,6 +400,88 @@ function anchoredGlob(fs, glob) {
   const base = cwd === "/" ? "" : cwd;
   return globToRegExp(glob.startsWith("/") ? glob : `${base}/${glob}`);
 }
+function makeGlobTool(opts) {
+  return {
+    name: "Glob",
+    description: 'Find files by glob pattern (e.g. "**/*.ts", "src/**/*.test.ts"). Returns sorted paths, one per line. Space-separated patterns combine; `!`-prefix excludes (e.g. "**/*.ts !**/*.test.ts"). Optional `path` to search a specific directory. Prefer over `bash find` for locating files \u2014 one call, structured output.',
+    parameters: {
+      type: "object",
+      required: ["pattern"],
+      properties: {
+        pattern: { type: "string", description: "glob pattern(s); ** matches across directories; prefix a pattern with ! to exclude" },
+        ...SCAN_PARAMS
+      }
+    },
+    async run({ pattern, path, skipDirs, maxDepth }, ctx) {
+      const roots = scanRoots(ctx.fs, path, opts);
+      const pats = String(pattern ?? "").trim().split(/\s+/).filter(Boolean);
+      const include = pats.filter((p) => !p.startsWith("!")).map((p) => globMatcher(roots, p));
+      const exclude = pats.filter((p) => p.startsWith("!")).map((p) => globMatcher(roots, p.slice(1)));
+      const includes = include.length ? include : [globMatcher(roots, "**")];
+      const { files, note } = await walkRoots(ctx.fs, roots, ctx.signal, opts, callScan({ skipDirs, maxDepth }));
+      const hits = files.filter((p) => includes.some((m) => m(p)) && !exclude.some((m) => m(p)));
+      return (hits.length ? [...new Set(hits)].sort().join("\n") : "(no matches)") + note;
+    }
+  };
+}
+function makeGrepTool(opts) {
+  return {
+    name: "Grep",
+    description: "Search file contents by regex. Returns `path:line: text` hits. Optional `glob` to scope files, `path` to search a specific directory, `context` for surrounding lines, `filesOnly` for matching paths only. Prefer over `bash grep` for file content search \u2014 structured results, no re-parse needed. Use `bash` instead for running commands, tests, or piped workflows.",
+    parameters: {
+      type: "object",
+      required: ["pattern"],
+      properties: {
+        pattern: { type: "string", description: "JS regular expression" },
+        glob: { type: "string", description: "optional file glob to restrict the search" },
+        ...SCAN_PARAMS,
+        context: { type: "number", description: "lines of context before/after each hit" },
+        filesOnly: { type: "boolean", description: "only list matching file paths" }
+      }
+    },
+    async run({ pattern, glob, path, skipDirs, maxDepth, context, filesOnly }, ctx) {
+      let re;
+      try {
+        re = new RegExp(String(pattern ?? ""));
+      } catch (e) {
+        throw new Error(`invalid regex: ${String(e)}`);
+      }
+      const roots = scanRoots(ctx.fs, path, opts);
+      const scope = glob ? globMatcher(roots, String(glob)) : null;
+      const walked = await walkRoots(ctx.fs, roots, ctx.signal, opts, callScan({ skipDirs, maxDepth }));
+      const files = [...new Set(walked.files)].sort().filter((p) => !scope || scope(p));
+      const ctxN = Math.max(0, Number(context ?? 0));
+      const out = [];
+      const matched = [];
+      let skipped = 0;
+      for (const path2 of files) {
+        ckAbort(ctx.signal);
+        let content;
+        try {
+          content = await ctx.fs.readFile(path2);
+        } catch {
+          skipped++;
+          continue;
+        }
+        const lines = content.split("\n");
+        const mask = CONFIG_FILE_RE.test(path2);
+        let fileHit = false;
+        for (let i = 0; i < lines.length; i++) {
+          if (!re.test(lines[i])) continue;
+          fileHit = true;
+          if (filesOnly) break;
+          const lo = Math.max(0, i - ctxN), hi = Math.min(lines.length - 1, i + ctxN);
+          for (let j = lo; j <= hi; j++) out.push(`${path2}:${j + 1}: ${mask ? redactSecrets(lines[j]) : lines[j]}`);
+        }
+        if (fileHit) matched.push(path2);
+      }
+      const note = (skipped ? `
+[skipped ${skipped} unreadable file${skipped === 1 ? "" : "s"}]` : "") + walked.note;
+      if (filesOnly) return (matched.length ? matched.join("\n") : "(no matches)") + note;
+      return (out.length ? out.join("\n") : "(no matches)") + note;
+    }
+  };
+}
 function docOutlineOf(content, cap = 20) {
   const out = [];
   const lines = content.split("\n");
@@ -480,84 +624,21 @@ Reply with a short numbered list of concrete, actionable issues. If the changes
     }
   };
 }
-var fsCwd, globTool, grepTool, SIG_RE, isCode, isDoc, repoMapTool, writeTool, multiEditTool, applyEditsTool;
+var DEFAULT_SKIP_DIRS, DEFAULT_MAX_DEPTH, SCAN_PARAMS, fsCwd, globTool, grepTool, SIG_RE, isCode, isDoc, repoMapTool, writeTool, multiEditTool, applyEditsTool;
 var init_tools_structured = __esm({
   "src/tools.structured.ts"() {
     "use strict";
     init_redact();
-    fsCwd = (fs) => fs.getCwd();
-    globTool = {
-      name: "Glob",
-      description: 'Find files by glob pattern (e.g. "**/*.ts", "src/**/*.test.ts"). Returns sorted paths, one per line. Space-separated patterns combine; `!`-prefix excludes (e.g. "**/*.ts !**/*.test.ts"). Prefer over `bash find` for locating files \u2014 one call, structured output.',
-      parameters: {
-        type: "object",
-        required: ["pattern"],
-        properties: { pattern: { type: "string", description: "glob pattern(s); ** matches across directories; prefix a pattern with ! to exclude" } }
-      },
-      async run({ pattern }, ctx) {
-        const pats = String(pattern ?? "").trim().split(/\s+/).filter(Boolean);
-        const include = pats.filter((p) => !p.startsWith("!")).map((p) => anchoredGlob(ctx.fs, p));
-        const exclude = pats.filter((p) => p.startsWith("!")).map((p) => anchoredGlob(ctx.fs, p.slice(1)));
-        const includes = include.length ? include : [anchoredGlob(ctx.fs, "**")];
-        const hits = (await walkFiles(ctx.fs, fsCwd(ctx.fs), ctx.signal)).filter(
-          (p) => includes.some((re) => re.test(p)) && !exclude.some((re) => re.test(p))
-        );
-        return hits.length ? hits.join("\n") : "(no matches)";
-      }
-    };
-    grepTool = {
-      name: "Grep",
-      description: "Search file contents by regex. Returns `path:line: text` hits. Optional `glob` to scope files, `context` for surrounding lines, `filesOnly` for matching paths only. Prefer over `bash grep` for file content search \u2014 structured results, no re-parse needed. Use `bash` instead for running commands, tests, or piped workflows.",
-      parameters: {
-        type: "object",
-        required: ["pattern"],
-        properties: {
-          pattern: { type: "string", description: "JS regular expression" },
-          glob: { type: "string", description: "optional file glob to restrict the search" },
-          context: { type: "number", description: "lines of context before/after each hit" },
-          filesOnly: { type: "boolean", description: "only list matching file paths" }
-        }
-      },
-      async run({ pattern, glob, context, filesOnly }, ctx) {
-        let re;
-        try {
-          re = new RegExp(String(pattern ?? ""));
-        } catch (e) {
-          throw new Error(`invalid regex: ${String(e)}`);
-        }
-        const scope = glob ? anchoredGlob(ctx.fs, String(glob)) : null;
-        const files = (await walkFiles(ctx.fs, fsCwd(ctx.fs), ctx.signal)).filter((p) => !scope || scope.test(p));
-        const ctxN = Math.max(0, Number(context ?? 0));
-        const out = [];
-        const matched = [];
-        let skipped = 0;
-        for (const path of files) {
-          ckAbort(ctx.signal);
-          let content;
-          try {
-            content = await ctx.fs.readFile(path);
-          } catch {
-            skipped++;
-            continue;
-          }
-          const lines = content.split("\n");
-          const mask = CONFIG_FILE_RE.test(path);
-          let fileHit = false;
-          for (let i = 0; i < lines.length; i++) {
-            if (!re.test(lines[i])) continue;
-            fileHit = true;
-            if (filesOnly) break;
-            const lo = Math.max(0, i - ctxN), hi = Math.min(lines.length - 1, i + ctxN);
-            for (let j = lo; j <= hi; j++) out.push(`${path}:${j + 1}: ${mask ? redactSecrets(lines[j]) : lines[j]}`);
-          }
-          if (fileHit) matched.push(path);
-        }
-        const note = skipped ? `
-[skipped ${skipped} unreadable file${skipped === 1 ? "" : "s"}]` : "";
-        if (filesOnly) return (matched.length ? matched.join("\n") : "(no matches)") + note;
-        return (out.length ? out.join("\n") : "(no matches)") + note;
-      }
+    DEFAULT_SKIP_DIRS = ["node_modules", ".git", "dist", ".tmp"];
+    DEFAULT_MAX_DEPTH = 24;
+    SCAN_PARAMS = {
+      path: { type: "string", description: "optional directory (or list) to search instead of the default roots; absolute VFS path" },
+      skipDirs: { type: "string", description: `comma-separated directory names to prune (default: ${DEFAULT_SKIP_DIRS.join(", ")}); pass an empty string to prune nothing` },
+      maxDepth: { type: "number", description: `max directory depth below each root (default ${DEFAULT_MAX_DEPTH})` }
     };
+    fsCwd = (fs) => fs.getCwd();
+    globTool = makeGlobTool();
+    grepTool = makeGrepTool();
     SIG_RE = /^\s*(export\b|(?:export\s+)?(?:async\s+)?function\s+\*?\w|(?:export\s+)?(?:abstract\s+)?class\s+\w|(?:export\s+)?interface\s+\w|(?:export\s+)?type\s+\w|(?:export\s+)?enum\s+\w)/;
     isCode = (p) => /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(p);
     isDoc = (p) => /\.(md|mdx|txt)$/.test(p);
@@ -1587,7 +1668,7 @@ var NodeDiskFilesystem_exports = {};
 __export(NodeDiskFilesystem_exports, {
   NodeDiskFilesystem: () => NodeDiskFilesystem
 });
-import { promises as fsp } from "fs";
+import { promises as fsp, realpathSync as realpathSync2 } from "fs";
 import * as np from "path";
 import { PathResolver } from "@livx.cc/wcli/core";
 var NodeDiskFilesystem;
@@ -1666,6 +1747,19 @@ var init_NodeDiskFilesystem = __esm({
       realPath(path) {
         return this.real(this.resolvePath(path));
       }
+      /** The CANONICAL on-disk path — symlinks resolved. `realPath` is path arithmetic (baseDir + vpath)
+       *  and therefore reports a symlink and its target as different places, which is no use as an
+       *  identity: a tree walk that dedupes on it still re-enters a loop (`a/b/loop -> a` re-walked 11
+       *  times before a depth cap stopped it). Optional capability, duck-typed by the file-scanning
+       *  tools; falls back to the arithmetic path for anything unresolvable (a broken/racing link). */
+      canonicalPath(path) {
+        const p = this.realPath(path);
+        try {
+          return realpathSync2(p);
+        } catch {
+          return p;
+        }
+      }
       /** Read raw bytes (for binary files like images). Not on the base IFilesystem (which is utf8-only) — an
        *  optional capability the Read tool duck-types to return image blocks. Same symlink/jail guards as readFile. */
       async readFileBytes(path) {