@livx.cc/agentx 0.99.32 → 0.99.34

package/dist/index.d.ts

@@ -39,6 +39,12 @@ declare class NodeDiskFilesystem implements IFilesystem {
     /** The REAL on-disk path behind a VFS path — an optional capability (not on IFilesystem) the Read
      *  tool duck-types so it can persist an image REFERENCE instead of megabytes of base64. */
     realPath(path: string): string;
+    /** 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: string): string;
     /** 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. */
     readFileBytes(path: string): Promise<Uint8Array>;
@@ -434,9 +440,31 @@ declare function fullAgentOptions(opts?: Partial<AgentOptions> & {
     cwd?: string;
 }): Promise<Partial<AgentOptions>>;
 
+/**
+ * Directory names never worth walking. Pruned by NAME at every level (not by path), because the
+ * cost is where they nest: a real-FS root of a JS deployment is mostly `node_modules`, and on a
+ * measured 412k-file app root a single `Glob` spent 31s almost entirely inside it.
+ */
+declare const DEFAULT_SKIP_DIRS: string[];
+/** Depth below a root at which the walk stops. Deep enough for any real source tree; a bound at all
+ *  is what turns a symlink cycle from a hang into a truncated result. */
+declare const DEFAULT_MAX_DEPTH = 24;
+/** How the file-scanning tools (Glob/Grep) decide WHAT to walk. */
+interface FileScanOptions {
+    /** Roots to walk when a call names no `path`. Default: `[fs.getCwd()]`, i.e. today's behaviour.
+     *  A host with its data outside the cwd passes both, so a search can reach it at all. */
+    roots?: string[];
+    /** Directory names pruned during the walk. Default: {@link DEFAULT_SKIP_DIRS}. */
+    skipDirs?: string[];
+    /** Max depth below each root. Default: {@link DEFAULT_MAX_DEPTH}. */
+    maxDepth?: number;
+}
 /** List paths matching a glob, sorted — the structured alternative to `find`. */
-declare const globTool: AgentTool;
+declare function makeGlobTool(opts?: FileScanOptions): AgentTool;
 /** Search file contents by regex, returning typed `path:line:text` hits with optional context. */
+declare function makeGrepTool(opts?: FileScanOptions): AgentTool;
+/** Default instances — cwd-rooted, standard prunes. Hosts that need other roots build their own. */
+declare const globTool: AgentTool;
 declare const grepTool: AgentTool;
 /**
  * Compact map of a VFS — code signatures and/or doc outlines. Edge-safe (pure IFilesystem walk).
@@ -1285,4 +1313,4 @@ declare function exitWorktree(): {
     reason?: string;
 } | null;
 
-export { Agent, type AgentDef, AgentOptions, AgentTool, type AskOptions, type Attempt, BodDbFilesystem, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, DuplexAgent, DuplexAgentOptions, type DuplexTaskStatus, FakeAIClient, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, type LoadMemoryOpts, MEMORY_PROMPT, MessageContent, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, type ReflectOptions, RunResult, SCRATCH_DIR, type ScheduledJob, type ScheduledJobSnapshot, Scheduler, type SchedulerOptions, Scratch, type ScratchOptions, ScriptedHostBridge, type SiblingResolver, type SkillInfo, type TaskRecord, type TaskToolOptions, ToolCall, type ToolSpec, type Trigger, type TriggerCron, type TriggerInterval, type TriggerOneOff, UserQuestion, VOICE_MEMORY_PROMPT, VOICE_SYSTEM_PROMPT, type WebFetchOptions, type WebSearchOptions, type WorkerTier, type WorktreeInfo, type WorktreeSession, applyEditsTool, askUserQuestionTool, checkpointTool, checkpointTools, cleanupWorktree, compileSynthesizedTool, cronMatches, decodeDdgUrl, diskAgentOptions, enterWorktree, exitWorktree, expandCommand, expandEntry, expandTemplate, findGitRoot, forComponent, fullAgentOptions, getOrCreateWorktree, getWorktreeSession, globTool, grepTool, htmlToText, idfWeights, lessonCapture, loadAgents, loadCommands, loadInstructions, loadMemory, loadSkills, makeAskTool, makeScheduleTools, makeTaskBatchTool, makeTaskTool, makeWebFetchTool, makeWebSearchAnthropicTool, makeWebSearchTool, mkdirp, multiEditTool, nextCronAfter, parseCron, parseDdgHtml, raceAttempts, reflectOnRun, relevanceScore, repoIndex, repoMapTool, rollbackTool, sandboxAgentOptions, scanCommands, scanSkills, slugify, tokenize, toolCall, topByRelevance, validateToolCode, validateWorktreeSlug, webFetchTool, webSearchAnthropicTool, webSearchTool, worktreeBranchName, writeFact, writeTool };
+export { Agent, type AgentDef, AgentOptions, AgentTool, type AskOptions, type Attempt, BodDbFilesystem, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, DEFAULT_MAX_DEPTH, DEFAULT_SKIP_DIRS, DuplexAgent, DuplexAgentOptions, type DuplexTaskStatus, FakeAIClient, type FileScanOptions, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, type LoadMemoryOpts, MEMORY_PROMPT, MessageContent, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, type ReflectOptions, RunResult, SCRATCH_DIR, type ScheduledJob, type ScheduledJobSnapshot, Scheduler, type SchedulerOptions, Scratch, type ScratchOptions, ScriptedHostBridge, type SiblingResolver, type SkillInfo, type TaskRecord, type TaskToolOptions, ToolCall, type ToolSpec, type Trigger, type TriggerCron, type TriggerInterval, type TriggerOneOff, UserQuestion, VOICE_MEMORY_PROMPT, VOICE_SYSTEM_PROMPT, type WebFetchOptions, type WebSearchOptions, type WorkerTier, type WorktreeInfo, type WorktreeSession, applyEditsTool, askUserQuestionTool, checkpointTool, checkpointTools, cleanupWorktree, compileSynthesizedTool, cronMatches, decodeDdgUrl, diskAgentOptions, enterWorktree, exitWorktree, expandCommand, expandEntry, expandTemplate, findGitRoot, forComponent, fullAgentOptions, getOrCreateWorktree, getWorktreeSession, globTool, grepTool, htmlToText, idfWeights, lessonCapture, loadAgents, loadCommands, loadInstructions, loadMemory, loadSkills, makeAskTool, makeGlobTool, makeGrepTool, makeScheduleTools, makeTaskBatchTool, makeTaskTool, makeWebFetchTool, makeWebSearchAnthropicTool, makeWebSearchTool, mkdirp, multiEditTool, nextCronAfter, parseCron, parseDdgHtml, raceAttempts, reflectOnRun, relevanceScore, repoIndex, repoMapTool, rollbackTool, sandboxAgentOptions, scanCommands, scanSkills, slugify, tokenize, toolCall, topByRelevance, validateToolCode, validateWorktreeSlug, webFetchTool, webSearchAnthropicTool, webSearchTool, worktreeBranchName, writeFact, writeTool };

package/dist/index.js

@@ -304,7 +304,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);
@@ -313,12 +330,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 = "";
@@ -340,6 +402,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");
@@ -482,84 +626,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);
@@ -1423,7 +1504,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;
@@ -1502,6 +1583,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) {
@@ -8401,7 +8495,9 @@ export {
   CommandExecutor2 as CommandExecutor,
   ConsoleHostBridge,
   DEFAULT_DENY,
+  DEFAULT_MAX_DEPTH,
   DEFAULT_MUTATING,
+  DEFAULT_SKIP_DIRS,
   DuplexAgent,
   DuplexAgentOptions,
   FakeAIClient,
@@ -8483,6 +8579,8 @@ export {
   log,
   makeAskTool,
   makeContext,
+  makeGlobTool,
+  makeGrepTool,
   makeJobTools,
   makeLazyMcpToolSearch,
   makeMcpToolSearch,