@wrongstack/tools 0.310.1 → 0.313.1

package/dist/chunk-UNSKG6DC.js

@@ -0,0 +1,159 @@
+import {
+  mapWithConcurrency
+} from "./chunk-U4D5S3VQ.js";
+import {
+  loadGitignoreMatcher
+} from "./chunk-LIJQMYYX.js";
+import {
+  assertRealInsideRoot,
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/glob.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { compileGlob, DEFAULT_WALK_IGNORE_DIRS } from "@wrongstack/core/utils";
+import { ToolValidationError } from "@wrongstack/core/types";
+var DEFAULT_IGNORE = new Set(DEFAULT_WALK_IGNORE_DIRS);
+var WALK_CONCURRENCY = 16;
+var globTool = {
+  name: "glob",
+  category: "Filesystem",
+  description: "Find files by path pattern. Results are sorted by modification time, newest first, so when the list is truncated at `limit` it is the oldest files that are dropped (recency-biased). Use index-backed `codebase-search` first for code symbols or concepts when it is live.",
+  usageHint: "PATH DISCOVERY AND SEARCH SCOPING:\n\n- When `codebase-search` is live, use it first for code concepts; use `glob` for filenames, path patterns, and non-indexed files.\n- Combine with `path` and `limit`.\n- Default ignores common build/dependency directories.\nMuch more efficient than shell `find` for most use cases inside the agent.",
+  selection: {
+    doNotUseWhen: "you need to search inside file contents.",
+    useInstead: ["grep"]
+  },
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  icon: "folder",
+  maxOutputBytes: 65536,
+  timeoutMs: 15e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: 'Glob pattern to match (e.g. "**/*.ts", "src/**").'
+      },
+      path: {
+        type: "string",
+        description: "Base directory to search from (defaults to project root)."
+      },
+      limit: {
+        type: "integer",
+        minimum: 1,
+        maximum: 5e3,
+        description: "Maximum number of results to return (default 1000, max 5000). Results are sorted by mtime descending, so truncation keeps the most recently modified files."
+      }
+    },
+    required: ["pattern"]
+  },
+  async execute(input, ctx, opts) {
+    if (!input?.pattern) {
+      throw new ToolValidationError({
+        message: "glob: pattern is required",
+        field: "pattern"
+      });
+    }
+    const signal = opts?.signal;
+    const base = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
+    const limit = Math.max(1, Math.min(input.limit ?? 1e3, 5e3));
+    const isGitIgnored = await loadGitignoreMatcher(base);
+    const re = compileGlob(input.pattern);
+    const results = [];
+    let truncated = false;
+    const pushResult = async (full) => {
+      if (truncated || results.length >= limit) {
+        truncated = true;
+        return;
+      }
+      try {
+        const st = await fs.stat(full);
+        if (truncated || results.length >= limit) {
+          truncated = true;
+          return;
+        }
+        results.push({ rel: full, mtime: st.mtimeMs });
+        if (results.length >= limit) truncated = true;
+      } catch {
+      }
+    };
+    const walk = async (dir, relPrefix) => {
+      if (signal?.aborted) {
+        truncated = true;
+        return;
+      }
+      if (results.length >= limit) {
+        truncated = true;
+        return;
+      }
+      let entries;
+      try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      const subdirs = [];
+      const matchedFiles = [];
+      for (const e of entries) {
+        const name = e.name;
+        if (DEFAULT_IGNORE.has(name)) continue;
+        const rel = relPrefix ? `${relPrefix}/${name}` : name;
+        const full = path.join(dir, name);
+        if (e.isDirectory()) {
+          if (isGitIgnored(rel, true)) continue;
+          subdirs.push({ full, rel });
+        } else if (e.isFile()) {
+          if (isGitIgnored(rel, false)) continue;
+          re.lastIndex = 0;
+          const relMatch = re.test(rel);
+          re.lastIndex = 0;
+          const nameMatch = re.test(name);
+          if (relMatch || nameMatch) {
+            matchedFiles.push(full);
+          }
+        } else if (e.isSymbolicLink()) {
+          try {
+            const st = await fs.stat(full);
+            if (st.isDirectory()) {
+              if (isGitIgnored(rel, true)) continue;
+              const real = await fs.realpath(full);
+              await assertRealInsideRoot(real, ctx);
+              subdirs.push({ full, rel });
+            } else if (st.isFile()) {
+              if (isGitIgnored(rel, false)) continue;
+              const real = await fs.realpath(full);
+              await assertRealInsideRoot(real, ctx);
+              re.lastIndex = 0;
+              const relMatch = re.test(rel);
+              re.lastIndex = 0;
+              const nameMatch = re.test(name);
+              if (relMatch || nameMatch) matchedFiles.push(full);
+            }
+          } catch {
+          }
+        }
+        if (truncated) return;
+      }
+      await mapWithConcurrency(matchedFiles, WALK_CONCURRENCY, pushResult);
+      if (truncated) return;
+      const remainingSubdirs = truncated ? [] : subdirs;
+      await mapWithConcurrency(
+        remainingSubdirs,
+        WALK_CONCURRENCY,
+        ({ full, rel }) => walk(full, rel)
+      );
+    };
+    await walk(base, "");
+    results.sort((a, b) => b.mtime - a.mtime);
+    return { files: results.map((r) => r.rel), truncated };
+  }
+};
+
+export {
+  globTool
+};
+//# sourceMappingURL=chunk-UNSKG6DC.js.map