@wrongstack/tools 0.313.0 → 0.316.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

package/dist/chunk-V43EQ6VR.js

@@ -0,0 +1,68 @@
+// src/_win32-resolve.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+function resolveWin32Command(cmd) {
+  if (process.platform !== "win32") return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || path.extname(cmd.replace(/\//g, "\\"))) {
+    return cmd;
+  }
+  const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
+  const pathDirs = (process.env["PATH"] ?? "").split(path.delimiter);
+  for (const dir of pathDirs) {
+    const base = path.join(dir, cmd);
+    for (const ext of pathext) {
+      const full = `${base}${ext}`;
+      try {
+        fs.accessSync(full, fs.constants.X_OK);
+        return full;
+      } catch {
+      }
+    }
+  }
+  return cmd;
+}
+function resolvePowerShell(cmd) {
+  if (process.platform !== "win32") return cmd;
+  const lower = cmd.toLowerCase();
+  if (lower !== "pwsh" && lower !== "powershell" && lower !== "pwsh.exe" && lower !== "powershell.exe") {
+    return resolveWin32Command(cmd);
+  }
+  const primary = lower.startsWith("pwsh") ? "pwsh" : "powershell";
+  const fallback = lower.startsWith("pwsh") ? "powershell" : "pwsh";
+  const resolved = resolveWin32Command(primary);
+  if (resolved === primary) {
+    const fb = resolveWin32Command(fallback);
+    return fb === fallback ? cmd : fb;
+  }
+  return resolved;
+}
+var WIN32_SHELL_META = /[&|<>"%\r\n\0]/;
+function assertSafeWin32ShellArgs(args) {
+  for (const arg of args) {
+    if (typeof arg === "string" && WIN32_SHELL_META.test(arg)) {
+      throw new Error(
+        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > " %, or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
+      );
+    }
+  }
+}
+function buildWin32CmdShimInvocation(command, args = []) {
+  assertSafeWin32ShellArgs([command, ...args]);
+  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
+  return {
+    command: process.env["COMSPEC"] ?? "cmd.exe",
+    args: ["/d", "/c", line],
+    windowsVerbatimArguments: true
+  };
+}
+function quoteWin32CmdArg(arg) {
+  return `"${arg}"`;
+}
+
+export {
+  resolveWin32Command,
+  resolvePowerShell,
+  assertSafeWin32ShellArgs,
+  buildWin32CmdShimInvocation
+};
+//# sourceMappingURL=chunk-V43EQ6VR.js.map