@livx.cc/agentx 0.99.32 → 0.99.34

package/dist/tools.shell.js

@@ -15,6 +15,7 @@ var log2 = forComponent("llm");
 
 // src/redact.ts
 var REDACTED = "\u2039redacted\u203A";
+var CONFIG_FILE_RE = /(^|\/)\.(agent|claude)\/(settings(\.[\w-]+)?\.json|config\.(json|js|mjs|cjs|ts))$/i;
 var SECRET_PAIR = /((?:^|[\s,{[])(?:export\s+)?["']?[\w.\-]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|PRIVATE_KEY|ACCESS_?KEY|AUTH(?:_?TOKEN)?|BEARER)[\w.\-]*["']?\s*[:=]\s*)(["']?)([^\s"',{}\]]+)/gi;
 var SECRET_TOKEN = /\b(sk-ant-[\w-]{12,}|sk-[A-Za-z0-9]{20,}|ghp_[A-Za-z0-9]{20,}|gho_[A-Za-z0-9]{20,}|github_pat_[\w]{20,}|xox[baprs]-[\w-]{10,}|AKIA[0-9A-Z]{12,}|AIza[\w-]{20,}|eyJ[\w-]{8,}\.[\w-]{8,}\.[\w-]{8,})\b/g;
 function redactSecrets(text) {
@@ -22,6 +23,196 @@ function redactSecrets(text) {
   return text.replace(SECRET_PAIR, (_m, head, quote, _val) => `${head}${quote}${REDACTED}`).replace(SECRET_TOKEN, REDACTED);
 }
 
+// src/tools.structured.ts
+function ckAbort(signal) {
+  if (signal?.aborted) throw new Error("aborted");
+}
+var DEFAULT_SKIP_DIRS = ["node_modules", ".git", "dist", ".tmp"];
+var DEFAULT_MAX_DEPTH = 24;
+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);
+  } catch {
+    return 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, 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)
+  };
+}
+var 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})` }
+};
+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 = "";
+  for (let i = 0; i < g.length; i++) {
+    const c = g[i];
+    if (c === "*") {
+      if (g[i + 1] === "*") {
+        re += ".*";
+        i++;
+        if (g[i + 1] === "/") i++;
+      } else re += "[^/]*";
+    } else if (c === "?") re += "[^/]";
+    else re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${re}$`, caseInsensitive ? "i" : "");
+}
+var fsCwd = (fs) => fs.getCwd();
+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;
+    }
+  };
+}
+var globTool = makeGlobTool();
+var grepTool = makeGrepTool();
+
 // src/tools.web.ts
 var log3 = forComponent("web");
 function htmlToText(html) {