@wrongstack/tools 0.310.1 → 0.313.1

package/dist/generic-parser-VUXDIAOZ.js

@@ -0,0 +1,13 @@
+import {
+  GENERIC_MAX_FILE_CHARS,
+  GENERIC_MAX_SYMBOLS_DEFAULT,
+  parseGeneric,
+  parseSymbols
+} from "./chunk-A6BRWIXN.js";
+export {
+  GENERIC_MAX_FILE_CHARS,
+  GENERIC_MAX_SYMBOLS_DEFAULT,
+  parseGeneric,
+  parseSymbols
+};
+//# sourceMappingURL=generic-parser-VUXDIAOZ.js.map

package/dist/git.js

@@ -1,383 +1,7 @@
-// src/git.ts
-import { spawn } from "node:child_process";
-import { statSync } from "node:fs";
-import { dirname, resolve, sep } from "node:path";
-import { assessCommitSafety } from "@wrongstack/core/coordination";
-import { buildChildEnv } from "@wrongstack/core/utils";
-
-// src/_util.ts
-import * as Core from "@wrongstack/core/utils";
-var COMMAND_OUTPUT_MAX_BYTES = 32768;
-var REPEAT_RUN_THRESHOLD = 3;
-function collapseCarriageReturns(text) {
-  const lf = text.replace(/\r\n/g, "\n");
-  if (!lf.includes("\r")) return lf;
-  return lf.split("\n").map((line) => line.includes("\r") ? line.slice(line.lastIndexOf("\r") + 1) : line).join("\n");
-}
-function collapseConsecutiveDuplicates(text, minRun = REPEAT_RUN_THRESHOLD) {
-  const lines = text.split("\n");
-  const out = [];
-  let i = 0;
-  while (i < lines.length) {
-    let j = i + 1;
-    while (j < lines.length && lines[j] === lines[i]) j++;
-    const run = j - i;
-    if (run >= minRun) {
-      out.push(lines[i], `\u2026 \u27E8repeated ${run}\xD7\u27E9`);
-    } else {
-      for (let k = i; k < j; k++) out.push(lines[k]);
-    }
-    i = j;
-  }
-  return out.join("\n");
-}
-function takeHeadBytes(s, maxBytes) {
-  if (maxBytes <= 0) return "";
-  if (Buffer.byteLength(s, "utf8") <= maxBytes) return s;
-  let lo = 0;
-  let hi = s.length;
-  while (lo < hi) {
-    const mid = Math.ceil((lo + hi) / 2);
-    if (Buffer.byteLength(s.slice(0, mid), "utf8") <= maxBytes) lo = mid;
-    else hi = mid - 1;
-  }
-  return s.slice(0, lo);
-}
-function takeTailBytes(s, maxBytes) {
-  if (maxBytes <= 0) return "";
-  if (Buffer.byteLength(s, "utf8") <= maxBytes) return s;
-  let lo = 0;
-  let hi = s.length;
-  while (lo < hi) {
-    const mid = Math.ceil((lo + hi) / 2);
-    if (Buffer.byteLength(s.slice(s.length - mid), "utf8") <= maxBytes) lo = mid;
-    else hi = mid - 1;
-  }
-  return s.slice(s.length - lo);
-}
-function truncateHeadTail(s, maxBytes) {
-  const total = Buffer.byteLength(s, "utf8");
-  if (total <= maxBytes) return s;
-  const MARKER_RESERVE = 64;
-  const avail = Math.max(0, maxBytes - MARKER_RESERVE);
-  const headBudget = Math.floor(avail * 0.45);
-  const head = takeHeadBytes(s, headBudget);
-  const tail = takeTailBytes(s, avail - Buffer.byteLength(head, "utf8"));
-  const kept = Buffer.byteLength(head, "utf8") + Buffer.byteLength(tail, "utf8");
-  return `${head}
-\u2026[truncated ${total - kept} bytes]\u2026
-${tail}`;
-}
-function normalizeCommandOutput(raw, opts = {}) {
-  if (!raw) return raw;
-  let text = Core.stripAnsi(raw);
-  text = collapseCarriageReturns(text);
-  text = text.replace(/[ \t]+$/gm, "");
-  text = collapseConsecutiveDuplicates(text);
-  text = text.replace(/\n{3,}/g, "\n\n");
-  return truncateHeadTail(text, opts.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES);
-}
-
-// src/git.ts
-var TIMEOUT_MS = 3e4;
-var MAX_OUTPUT = 1e5;
-var gitTool = {
-  name: "git",
-  category: "Git",
-  description: "Safe wrapper around common git operations. Supports status, log, diff, commit, branch, checkout, stash, push, pull, fetch, reset, worktree, etc. This is the preferred way to interact with git instead of using the raw `bash` or `exec` tools.",
-  usageHint: "ALWAYS prefer this tool over raw shell git commands.\n\nKey fields:\n- `command`: one of the supported subcommands (status, log, diff, commit, etc.)\n- Use `message` only for commit operations.\n- Use `files` array for operations that take paths (status, diff, add, etc.).\n- Non-mutating commands (status, log, diff, branch, fetch) are still permission:confirm for safety.\n- For `commit` in a possibly-shared working tree, pass an explicit `files` list scoped to what YOU changed. A bare commit (no `files`) includes ALL staged changes and may capture another agent's half-done work. Heed the `warning` field on the result.\nNever pass raw git flags through `args` for dangerous operations \u2014 use the structured fields.",
-  permission: "confirm",
-  icon: "git",
-  // Conservative: any of these may mutate. The non-mutating commands
-  // (status/log/diff/branch/fetch) are still gated on `permission: 'confirm'`
-  // and `MUTATING_SUBCOMMANDS` is consulted at runtime for per-call checks.
-  // WS-046: gives permission decisions something to key on.
-  // The git subcommand (status/commit/push) is what a trust rule needs to
-  // distinguish; `git status` and `git push --force` must not share a subject.
-  subjectKey: "command",
-  // `command` is an enum subcommand, so on its own it rendered the subject
-  // `"push"` — and one "always allow" then covered every push, to any branch,
-  // with or without `--force`. These are the fields that change what the call
-  // actually does, so the stored trust rule is as specific as the invocation
-  // the user approved.
-  subjectFields: ["branch", "force", "worktreeAction", "worktreePath", "newBranch"],
-  mutating: true,
-  capabilities: ["fs.write", "shell.restricted"],
-  timeoutMs: TIMEOUT_MS,
-  inputSchema: {
-    type: "object",
-    properties: {
-      command: {
-        type: "string",
-        enum: [
-          "status",
-          "log",
-          "diff",
-          "commit",
-          "branch",
-          "checkout",
-          "stash",
-          "push",
-          "pull",
-          "fetch",
-          "reset",
-          "worktree"
-        ],
-        description: "Git subcommand"
-      },
-      files: {
-        type: "string",
-        description: 'File(s) for status/diff: single path, comma-separated list, or "**/*.ts" glob'
-      },
-      message: { type: "string", description: "Commit message (required for commit)" },
-      branch: { type: "string", description: "Branch name for checkout/branch" },
-      format: {
-        type: "string",
-        enum: ["short", "oneline", "stat", "graph"],
-        description: "Log format (default: short)"
-      },
-      limit: { type: "integer", description: "Limit for log (default: 20)" },
-      dry_run: { type: "boolean", description: "For commit: show what would be committed" },
-      worktreeAction: {
-        type: "string",
-        enum: ["list", "add", "remove", "prune"],
-        description: "Worktree action: list, add, remove, prune"
-      },
-      worktreePath: {
-        type: "string",
-        description: 'Path for worktree add/remove (e.g. "../wt-feature-xyz")'
-      },
-      newBranch: {
-        type: "boolean",
-        description: "Create new branch when adding worktree"
-      },
-      force: {
-        type: "boolean",
-        description: "Force operation (e.g. worktree remove --force)"
-      }
-    },
-    required: ["command"]
-  },
-  async execute(input, ctx, opts) {
-    if (!input?.command) throw new Error("git: command is required");
-    if (input.command === "commit" && !input.message) {
-      return {
-        command: "commit",
-        stdout: "",
-        stderr: "git commit requires a message (-m flag)",
-        exitCode: 1,
-        truncated: false
-      };
-    }
-    const branchGuard = validateBranchInput(input);
-    if (branchGuard) return branchGuard;
-    if (input.command === "worktree") {
-      const guard = validateWorktreeInput(input, ctx.projectRoot);
-      if (guard) return guard;
-    }
-    const gitDir = findGitDir(ctx.cwd, ctx.projectRoot);
-    if (!gitDir) {
-      return {
-        command: input.command,
-        stdout: "",
-        stderr: "Not in a git repository (within project root)",
-        exitCode: 128,
-        truncated: false
-      };
-    }
-    const args = buildArgs(input);
-    let safetyWarning;
-    if (input.command === "commit") {
-      try {
-        const report = await assessCommitSafety({
-          cwd: ctx.cwd,
-          projectRoot: ctx.projectRoot,
-          sessionId: ctx.session?.id,
-          signal: opts.signal
-        });
-        if (report.warning) {
-          const scopeNote = input.files ? "" : "\nNote: this commit has no explicit `files` list, so it will include ALL staged changes. Pass `files` to scope the commit to only what you changed.";
-          safetyWarning = report.warning + scopeNote;
-        }
-      } catch {
-      }
-    }
-    let stagedDiff;
-    if (input.command === "commit" && !input.dry_run) {
-      try {
-        const diffResult = await runGit(["diff", "--cached"], gitDir, opts.signal);
-        if (diffResult.exitCode === 0) {
-          const MAX_DIFF = 2e4;
-          stagedDiff = diffResult.stdout.length > MAX_DIFF ? diffResult.stdout.slice(0, MAX_DIFF) + "\n\n... (diff truncated)" : diffResult.stdout;
-        }
-      } catch {
-      }
-    }
-    const result = await runGit(args, gitDir, opts.signal);
-    if (stagedDiff !== void 0) result.diff = stagedDiff;
-    if (safetyWarning !== void 0) result.warning = safetyWarning;
-    return result;
-  }
-};
-function validateBranchInput(input) {
-  const branch = input.branch;
-  if (branch === void 0) return null;
-  if (!branch.startsWith("-") && !branch.includes(" --")) return null;
-  return {
-    command: input.command,
-    stdout: "",
-    stderr: `unsafe branch name (parsed as a git option): ${branch}`,
-    exitCode: 1,
-    truncated: false
-  };
-}
-function validateWorktreeInput(input, projectRoot) {
-  const reject = (stderr) => ({
-    command: "worktree",
-    stdout: "",
-    stderr,
-    exitCode: 1,
-    truncated: false
-  });
-  if (input.worktreePath?.startsWith("-")) {
-    return reject(`unsafe worktree path: ${input.worktreePath}`);
-  }
-  if ((input.worktreeAction === "add" || input.worktreeAction === "remove") && input.worktreePath) {
-    const root = resolve(projectRoot);
-    const abs = resolve(root, input.worktreePath);
-    if (abs !== root && !abs.startsWith(root + sep)) {
-      return reject(`unsafe worktree path (escapes project root): ${input.worktreePath}`);
-    }
-  }
-  return null;
-}
-function findGitDir(cwd, projectRoot) {
-  const root = projectRoot;
-  let dir = cwd;
-  for (let i = 0; i < 20; i++) {
-    try {
-      const stat = statSync(`${dir}/.git`);
-      if (stat.isDirectory() || stat.isFile()) return dir;
-    } catch {
-    }
-    if (dir === root) break;
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-function buildArgs(input) {
-  const limit = input.limit ?? 20;
-  const files = input.files ? (Array.isArray(input.files) ? input.files : input.files.split(",")).map((s) => s.trim()).filter(Boolean) : [];
-  switch (input.command) {
-    case "status":
-      return ["status", ...files.length ? ["--", ...files] : []];
-    case "log":
-      return [
-        "log",
-        `--max-count=${limit}`,
-        ...input.format === "oneline" ? ["--oneline"] : [],
-        ...input.format === "stat" ? ["--stat"] : [],
-        ...input.format === "graph" ? ["--oneline", "--graph", "--decorate"] : [],
-        ...input.format === "short" || !input.format ? [] : []
-      ];
-    case "diff":
-      return ["diff", "--no-color", ...files.length ? ["--", ...files] : []];
-    case "commit":
-      return [
-        "commit",
-        ...input.dry_run ? ["--dry-run", "--porcelain"] : [],
-        ...input.message ? ["-m", input.message] : [],
-        ...files.length ? ["--", ...files] : []
-      ];
-    case "branch":
-      return input.branch ? [
-        "branch",
-        ...input.branch.startsWith("-") || input.branch.includes(" --") ? [] : [input.branch]
-      ] : ["branch"];
-    case "checkout":
-      if (files.length) return ["checkout", "--", ...files];
-      return input.branch ? ["checkout", input.branch, "--"] : ["checkout"];
-    case "stash":
-      return input.message ? ["stash", "push", "-m", input.message] : ["stash", "push"];
-    case "push":
-      return ["push"];
-    case "pull":
-      return ["pull"];
-    case "fetch":
-      return ["fetch", ...input.branch ? [input.branch] : ["--all"]];
-    case "reset":
-      return ["reset", ...files.length ? ["--", ...files] : []];
-    case "worktree":
-      switch (input.worktreeAction) {
-        case "list":
-          return ["worktree", "list"];
-        case "add": {
-          if (!input.worktreePath) return ["worktree", "list"];
-          const add = ["worktree", "add"];
-          if (input.newBranch && input.branch) add.push("-b", input.branch);
-          add.push(input.worktreePath);
-          if (!input.newBranch && input.branch) add.push(input.branch);
-          return add;
-        }
-        case "remove":
-          return [
-            "worktree",
-            "remove",
-            ...input.force ? ["--force"] : [],
-            input.worktreePath ?? ""
-          ].filter(Boolean);
-        case "prune":
-          return ["worktree", "prune"];
-        default:
-          return ["worktree", "list"];
-      }
-    default:
-      return [input.command];
-  }
-}
-function runGit(args, cwd, signal) {
-  return new Promise((resolve2) => {
-    let stdout = "";
-    let stderr = "";
-    const child = spawn("git", args, {
-      cwd,
-      signal,
-      env: buildChildEnv(),
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true
-    });
-    child.stdout?.on("data", (chunk) => {
-      if (stdout.length < MAX_OUTPUT) {
-        stdout += chunk.toString();
-      }
-    });
-    child.stderr?.on("data", (chunk) => {
-      if (stderr.length < MAX_OUTPUT) {
-        stderr += chunk.toString();
-      }
-    });
-    child.on("error", (err) => {
-      resolve2({
-        command: args[0],
-        stdout: normalizeCommandOutput(stdout),
-        stderr: err.message,
-        exitCode: 1,
-        truncated: Buffer.byteLength(stdout, "utf8") > COMMAND_OUTPUT_MAX_BYTES
-      });
-    });
-    child.on("close", (code) => {
-      resolve2({
-        command: args[0],
-        stdout: normalizeCommandOutput(stdout),
-        stderr: normalizeCommandOutput(stderr),
-        exitCode: code ?? 1,
-        truncated: Buffer.byteLength(stdout, "utf8") > COMMAND_OUTPUT_MAX_BYTES || Buffer.byteLength(stderr, "utf8") > COMMAND_OUTPUT_MAX_BYTES
-      });
-    });
-  });
-}
+import {
+  gitTool
+} from "./chunk-RXISBFR5.js";
+import "./chunk-D33S4RQG.js";
 export {
   gitTool
 };

package/dist/glob.js

@@ -1,283 +1,9 @@
-// src/glob.ts
-import * as fs2 from "node:fs/promises";
-import * as path3 from "node:path";
-import { compileGlob as compileGlob2, DEFAULT_WALK_IGNORE_DIRS } from "@wrongstack/core/utils";
-import { ToolValidationError } from "@wrongstack/core/types";
-
-// src/_concurrency.ts
-async function mapWithConcurrency(items, limit, fn) {
-  if (items.length === 0) return [];
-  const effectiveLimit = Math.max(1, Math.min(limit | 0, items.length));
-  const results = new Array(items.length);
-  let nextIndex = 0;
-  const worker = async () => {
-    while (true) {
-      const i = nextIndex++;
-      if (i >= items.length) return;
-      results[i] = await fn(items[i]);
-    }
-  };
-  await Promise.all(Array.from({ length: effectiveLimit }, worker));
-  return results;
-}
-
-// src/codebase-index/gitignore.ts
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { compileGlob } from "@wrongstack/core/utils";
-function globBody(glob) {
-  return compileGlob(glob).source.replace(/^\^/, "").replace(/\$$/, "");
-}
-function compileGitignore(lines) {
-  const rules = [];
-  for (const raw of lines) {
-    let line = raw.replace(/\r$/, "");
-    if (!line.trim() || line.trimStart().startsWith("#")) continue;
-    line = line.trim();
-    let negated = false;
-    if (line.startsWith("!")) {
-      negated = true;
-      line = line.slice(1);
-    }
-    let dirOnly = false;
-    if (line.endsWith("/")) {
-      dirOnly = true;
-      line = line.slice(0, -1);
-    }
-    if (!line) continue;
-    const anchored = line.startsWith("/") || line.includes("/");
-    if (line.startsWith("/")) line = line.slice(1);
-    const body = globBody(line);
-    const prefix = anchored ? "^" : "(?:^|.*/)";
-    rules.push({
-      eqOrUnder: new RegExp(`${prefix}${body}(?:/.*)?$`),
-      under: new RegExp(`${prefix}${body}/.*$`),
-      negated,
-      dirOnly
-    });
-  }
-  return (relPath, isDir) => {
-    const p = relPath.replace(/\\/g, "/").replace(/^\/+/, "");
-    let ignored = false;
-    for (const r of rules) {
-      const re = r.dirOnly && !isDir ? r.under : r.eqOrUnder;
-      if (re.test(p)) ignored = !r.negated;
-    }
-    return ignored;
-  };
-}
-async function loadGitignoreMatcher(projectRoot) {
-  let lines = [];
-  try {
-    const raw = await fs.readFile(path.join(projectRoot, ".gitignore"), "utf8");
-    lines = raw.split("\n");
-  } catch {
-  }
-  return compileGitignore(lines);
-}
-
-// src/_util.ts
-import * as fsp from "node:fs/promises";
-import * as path2 from "node:path";
-import * as Core from "@wrongstack/core/utils";
-function resolvePath(input, ctx) {
-  return path2.isAbsolute(input) ? path2.normalize(input) : path2.resolve(ctx.workingDir ?? ctx.cwd, input);
-}
-function allowedRoots(ctx) {
-  return [path2.resolve(ctx.projectRoot), path2.resolve(Core.wstackGlobalRoot())];
-}
-function isInsideAny(target, roots) {
-  return roots.some((root) => {
-    const rel = path2.relative(root, target);
-    return rel === "" || !rel.startsWith("..") && !path2.isAbsolute(rel);
-  });
-}
-function ensureInsideRoot(absPath, ctx) {
-  const target = path2.resolve(absPath);
-  if (ctx.allowOutsideProjectRoot) return target;
-  if (isInsideAny(target, allowedRoots(ctx))) return target;
-  throw new Error(`Path "${absPath}" is outside project root "${path2.resolve(ctx.projectRoot)}"`);
-}
-function safeResolve(input, ctx) {
-  return ensureInsideRoot(resolvePath(input, ctx), ctx);
-}
-async function assertRealInsideRoot(absPath, ctx) {
-  await resolveRealInsideRoot(absPath, ctx);
-}
-async function resolveRealInsideRoot(absPath, ctx) {
-  if (ctx.allowOutsideProjectRoot) return absPath;
-  const realRoots = await Promise.all(
-    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path2.resolve(r)))
-  );
-  let probe = absPath;
-  const pendingTail = [];
-  for (; ; ) {
-    let real;
-    try {
-      real = await fsp.realpath(probe);
-    } catch (err) {
-      if (err.code === "ENOENT") {
-        const parent = path2.dirname(probe);
-        if (parent === probe) return absPath;
-        pendingTail.unshift(path2.basename(probe));
-        probe = parent;
-        continue;
-      }
-      throw err;
-    }
-    const candidate = pendingTail.length > 0 ? path2.join(real, ...pendingTail) : real;
-    if (isInsideAny(candidate, realRoots)) {
-      return candidate;
-    }
-    throw new Error(
-      `Path "${absPath}" resolves through a symlink outside project root "${realRoots[0]}"`
-    );
-  }
-}
-async function safeResolveReal(input, ctx) {
-  const abs = safeResolve(input, ctx);
-  return await resolveRealInsideRoot(abs, ctx);
-}
-
-// src/glob.ts
-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 = compileGlob2(input.pattern);
-    const results = [];
-    let truncated = false;
-    const pushResult = async (full) => {
-      if (truncated || results.length >= limit) {
-        truncated = true;
-        return;
-      }
-      try {
-        const st = await fs2.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 fs2.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 = path3.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 fs2.stat(full);
-            if (st.isDirectory()) {
-              if (isGitIgnored(rel, true)) continue;
-              const real = await fs2.realpath(full);
-              await assertRealInsideRoot(real, ctx);
-              subdirs.push({ full, rel });
-            } else if (st.isFile()) {
-              if (isGitIgnored(rel, false)) continue;
-              const real = await fs2.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 };
-  }
-};
+import {
+  globTool
+} from "./chunk-UNSKG6DC.js";
+import "./chunk-U4D5S3VQ.js";
+import "./chunk-LIJQMYYX.js";
+import "./chunk-D33S4RQG.js";
 export {
   globTool
 };