@wrongstack/tools 0.295.0 → 0.295.1

package/dist/glob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../src/glob.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAInD,UAAU,SAAS;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAED,UAAU,UAAU;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;CACpB;AAKD,eAAO,MAAM,QAAQ,EAAE,IAAI,CAAC,SAAS,EAAE,UAAU,CAyJhD,CAAC"}
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../src/glob.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAKnD,UAAU,SAAS;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAED,UAAU,UAAU;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;CACpB;AAKD,eAAO,MAAM,QAAQ,EAAE,IAAI,CAAC,SAAS,EAAE,UAAU,CA+JhD,CAAC"}

package/dist/glob.js

@@ -1,7 +1,7 @@
 // src/glob.ts
-import * as fs from "node:fs/promises";
-import * as path2 from "node:path";
-import { compileGlob } from "@wrongstack/core/utils";
+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";
 
 // src/_concurrency.ts
 async function mapWithConcurrency(items, limit, fn) {
@@ -20,27 +20,82 @@ async function mapWithConcurrency(items, limit, fn) {
   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 path from "node:path";
+import * as path2 from "node:path";
 import * as Core from "@wrongstack/core/utils";
 function resolvePath(input, ctx) {
-  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);
+  return path2.isAbsolute(input) ? path2.normalize(input) : path2.resolve(ctx.workingDir ?? ctx.cwd, input);
 }
 function allowedRoots(ctx) {
-  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];
+  return [path2.resolve(ctx.projectRoot), path2.resolve(Core.wstackGlobalRoot())];
 }
 function isInsideAny(target, roots) {
   return roots.some((root) => {
-    const rel = path.relative(root, target);
-    return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+    const rel = path2.relative(root, target);
+    return rel === "" || !rel.startsWith("..") && !path2.isAbsolute(rel);
   });
 }
 function ensureInsideRoot(absPath, ctx) {
-  const target = path.resolve(absPath);
+  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 "${path.resolve(ctx.projectRoot)}"`);
+  throw new Error(`Path "${absPath}" is outside project root "${path2.resolve(ctx.projectRoot)}"`);
 }
 function safeResolve(input, ctx) {
   return ensureInsideRoot(resolvePath(input, ctx), ctx);
@@ -48,7 +103,7 @@ function safeResolve(input, ctx) {
 async function assertRealInsideRoot(absPath, ctx) {
   if (ctx.allowOutsideProjectRoot) return;
   const realRoots = await Promise.all(
-    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r)))
+    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path2.resolve(r)))
   );
   let probe = absPath;
   for (; ; ) {
@@ -57,7 +112,7 @@ async function assertRealInsideRoot(absPath, ctx) {
       real = await fsp.realpath(probe);
     } catch (err) {
       if (err.code === "ENOENT") {
-        const parent = path.dirname(probe);
+        const parent = path2.dirname(probe);
         if (parent === probe) return;
         probe = parent;
         continue;
@@ -77,7 +132,7 @@ async function safeResolveReal(input, ctx) {
 }
 
 // src/glob.ts
-var DEFAULT_IGNORE = ["node_modules", ".git", "dist", "build", ".next", "coverage", ".turbo"];
+var DEFAULT_IGNORE = DEFAULT_WALK_IGNORE_DIRS;
 var WALK_CONCURRENCY = 16;
 var globTool = {
   name: "glob",
@@ -117,8 +172,8 @@ var globTool = {
     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 ignored = await readGitignore(base);
-    const re = compileGlob(input.pattern);
+    const isGitIgnored = await loadGitignoreMatcher(base);
+    const re = compileGlob2(input.pattern);
     const results = [];
     let truncated = false;
     const pushResult = async (full) => {
@@ -127,7 +182,7 @@ var globTool = {
         return;
       }
       try {
-        const st = await fs.stat(full);
+        const st = await fs2.stat(full);
         if (truncated || results.length >= limit) {
           truncated = true;
           return;
@@ -148,7 +203,7 @@ var globTool = {
       }
       let entries;
       try {
-        entries = await fs.readdir(dir, { withFileTypes: true });
+        entries = await fs2.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -157,12 +212,13 @@ var globTool = {
       for (const e of entries) {
         const name = e.name;
         if (DEFAULT_IGNORE.includes(name)) continue;
-        if (ignored.includes(name)) continue;
         const rel = relPrefix ? `${relPrefix}/${name}` : name;
-        const full = path2.join(dir, 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;
@@ -172,13 +228,15 @@ var globTool = {
           }
         } else if (e.isSymbolicLink()) {
           try {
-            const st = await fs.stat(full);
+            const st = await fs2.stat(full);
             if (st.isDirectory()) {
-              const real = await fs.realpath(full);
+              if (isGitIgnored(rel, true)) continue;
+              const real = await fs2.realpath(full);
               await assertRealInsideRoot(real, ctx);
               subdirs.push({ full, rel });
             } else if (st.isFile()) {
-              const real = await fs.realpath(full);
+              if (isGitIgnored(rel, false)) continue;
+              const real = await fs2.realpath(full);
               await assertRealInsideRoot(real, ctx);
               re.lastIndex = 0;
               const relMatch = re.test(rel);
@@ -201,14 +259,6 @@ var globTool = {
     return { files: results.map((r) => r.rel), truncated };
   }
 };
-async function readGitignore(dir) {
-  try {
-    const raw = await fs.readFile(path2.join(dir, ".gitignore"), "utf8");
-    return raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
-  } catch {
-    return [];
-  }
-}
 export {
   globTool
 };

package/dist/glob.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../src/glob.ts", "../src/_concurrency.ts", "../src/_util.ts"],
-  "sourcesContent": ["import * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport { compileGlob } from '@wrongstack/core/utils';\nimport type { Tool } from '@wrongstack/core/types';\nimport { mapWithConcurrency } from './_concurrency.js';\nimport { assertRealInsideRoot, safeResolveReal } from './_util.js';\n\ninterface GlobInput {\n  pattern: string;\n  path?: string | undefined;\n  limit?: number | undefined;\n}\n\ninterface GlobOutput {\n  files: string[];\n  truncated: boolean;\n}\n\nconst DEFAULT_IGNORE = ['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.turbo'];\nconst WALK_CONCURRENCY = 16;\n\nexport const globTool: Tool<GlobInput, GlobOutput> = {\n  name: 'glob',\n  category: 'Filesystem',\n  description:\n    'Find files by path pattern. Use index-backed `codebase-search` first for code symbols or concepts when it is live.',\n  usageHint:\n    'PATH DISCOVERY AND SEARCH SCOPING:\\n\\n' +\n    '- When `codebase-search` is live, use it first for code concepts; use `glob` for filenames, path patterns, and non-indexed files.\\n' +\n    '- Combine with `path` and `limit`.\\n' +\n    '- Default ignores common build/dependency directories.\\n' +\n    'Much more efficient than shell `find` for most use cases inside the agent.',\n  selection: {\n    doNotUseWhen: 'you need to search inside file contents.',\n    useInstead: ['grep'],\n  },\n  permission: 'auto',\n  mutating: false,\n  capabilities: ['fs.read'],\n  icon: 'folder',\n  maxOutputBytes: 65_536,\n  timeoutMs: 5_000,\n  inputSchema: {\n    type: 'object',\n    properties: {\n      pattern: {\n        type: 'string',\n        description: 'Glob pattern to match (e.g. \"**/*.ts\", \"src/**\").',\n      },\n      path: {\n        type: 'string',\n        description: 'Base directory to search from (defaults to project root).',\n      },\n      limit: {\n        type: 'integer',\n        description: 'Maximum number of results to return (default 1000, max 5000).',\n      },\n    },\n    required: ['pattern'],\n  },\n  async execute(input, ctx, opts) {\n    if (!input?.pattern) throw new Error('glob: pattern is required');\n    const signal = opts?.signal;\n    // `safeResolveReal` validates that the input base \u2014 even if symlinked \u2014\n    // resolves to a real path inside the project root (or `~/.wrongstack`).\n    // Throws on escape, matching how single-file tools (`read`, `edit`,\n    // `write`) reject out-of-root paths: the caller named the base explicitly.\n    const base = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;\n    const limit = Math.max(1, Math.min(input.limit ?? 1000, 5000));\n\n    const ignored = await readGitignore(base);\n    const re = compileGlob(input.pattern);\n\n    const results: { rel: string; mtime: number }[] = [];\n    let truncated = false;\n    const pushResult = async (full: string): Promise<void> => {\n      // Bail before stat if a concurrent worker has already filled the budget \u2014\n      // the limit is a global cap across all parallel walkers, not per-worker.\n      if (truncated || results.length >= limit) {\n        truncated = true;\n        return;\n      }\n      try {\n        const st = await fs.stat(full);\n        // Re-check after the await: another worker may have filled the budget\n        // while we were waiting on fs.stat.\n        if (truncated || results.length >= limit) {\n          truncated = true;\n          return;\n        }\n        results.push({ rel: full, mtime: st.mtimeMs });\n        if (results.length >= limit) truncated = true;\n      } catch {\n        // skip stat error\n      }\n    };\n    const walk = async (dir: string, relPrefix: string): Promise<void> => {\n      // Abort check per directory: a huge tree walk must stop promptly on\n      // Ctrl+C instead of running to completion with a discarded result.\n      if (signal?.aborted) {\n        truncated = true;\n        return;\n      }\n      /* v8 ignore start -- the inner limit guards (file push + post-recursion return) always stop first; this re-entry guard is defensive. */\n      if (results.length >= limit) {\n        truncated = true;\n        return;\n      }\n      /* v8 ignore stop */\n      let entries: import('node:fs').Dirent[];\n      try {\n        entries = await fs.readdir(dir, { withFileTypes: true });\n      } catch {\n        return;\n      }\n      const subdirs: Array<{ full: string; rel: string }> = [];\n      const matchedFiles: string[] = [];\n      for (const e of entries) {\n        const name = e.name;\n        if (DEFAULT_IGNORE.includes(name)) continue;\n        if (ignored.includes(name)) continue;\n        const rel = relPrefix ? `${relPrefix}/${name}` : name;\n        const full = path.join(dir, name);\n        if (e.isDirectory()) {\n          subdirs.push({ full, rel });\n        } else if (e.isFile()) {\n          re.lastIndex = 0;\n          const relMatch = re.test(rel);\n          re.lastIndex = 0;\n          const nameMatch = re.test(name);\n          if (relMatch || nameMatch) {\n            matchedFiles.push(full);\n          }\n        } else if (e.isSymbolicLink()) {\n          try {\n            const st = await fs.stat(full);\n            if (st.isDirectory()) {\n              // CWE-59 containment: a symlink inside the workspace can point\n              // outside it. Before recursing into it (or including the\n              // resolved file in results), realpath the symlink and verify\n              // its target is still inside the project root. Skip silently\n              // on escape so a single bad symlink doesn't poison the whole\n              // walk.\n              const real = await fs.realpath(full);\n              await assertRealInsideRoot(real, ctx);\n              subdirs.push({ full, rel });\n            } else if (st.isFile()) {\n              const real = await fs.realpath(full);\n              await assertRealInsideRoot(real, ctx);\n              re.lastIndex = 0;\n              const relMatch = re.test(rel);\n              re.lastIndex = 0;\n              const nameMatch = re.test(name);\n              if (relMatch || nameMatch) matchedFiles.push(full);\n            }\n          } catch {\n            // Skip broken symlink, stat error, OR out-of-root target. All\n            // three should fail the walk without aborting the whole search.\n          }\n        }\n        if (truncated) return;\n      }\n      await mapWithConcurrency(matchedFiles, WALK_CONCURRENCY, pushResult);\n      if (truncated) return;\n      // Subdir walks: each one re-checks the limit at entry (re-entry guard),\n      // but we also stop dispatching new walks once truncated, so siblings of\n      // a hit-limit subdir don't keep adding results.\n      const remainingSubdirs = truncated ? [] : subdirs;\n      await mapWithConcurrency(remainingSubdirs, WALK_CONCURRENCY, ({ full, rel }) => walk(full, rel));\n    };\n    await walk(base, '');\n    results.sort((a, b) => b.mtime - a.mtime);\n    return { files: results.map((r) => r.rel), truncated };\n  },\n};\n\nasync function readGitignore(dir: string): Promise<string[]> {\n  try {\n    const raw = await fs.readFile(path.join(dir, '.gitignore'), 'utf8');\n    return raw\n      .split('\\n')\n      .map((l) => l.trim())\n      .filter((l) => l && !l.startsWith('#'));\n  } catch {\n    return [];\n  }\n}\n", "/**\n * Bounded-concurrency async map.\n *\n * Runs `fn` over `items` with at most `limit` in-flight promises. Order of\n * results matches input order. Errors reject the returned promise on the first\n * failure \u2014 the remaining in-flight work is not awaited; this matches\n * `Promise.all` semantics for callers that want fail-fast behavior.\n *\n * Lives here (rather than imported from `@wrongstack/bench`) because:\n *   1. tools sits below bench in the dependency graph \u2014 bench is a consumer of\n *      tools, never the other way around.\n *   2. The semantics used by grep/glob are deliberately simple (fail-fast,\n *      no cancellation, no progress) and don't need bench's richer options.\n */\nexport async function mapWithConcurrency<T, R>(\n  items: readonly T[],\n  limit: number,\n  fn: (item: T) => Promise<R>,\n): Promise<R[]> {\n  if (items.length === 0) return [];\n  const effectiveLimit = Math.max(1, Math.min(limit | 0, items.length));\n  const results: R[] = new Array(items.length);\n  let nextIndex = 0;\n\n  const worker = async (): Promise<void> => {\n    while (true) {\n      const i = nextIndex++;\n      if (i >= items.length) return;\n      results[i] = await fn(items[i] as T);\n    }\n  };\n\n  await Promise.all(Array.from({ length: effectiveLimit }, worker));\n  return results;\n}\n", "import { createHash } from 'node:crypto';\nimport * as fsp from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as Core from '@wrongstack/core/utils';\nimport type { Context } from '@wrongstack/core/agent';\n\n/**\n * sha-256 hex of a UTF-8 string. Used by the file tools to record a content\n * hash alongside the mtime in `ctx.recordRead` \u2014 the hash is the authoritative\n * staleness arbiter for `edit` (mtime has a 2 s tolerance window on Windows).\n */\nexport function sha256hex(content: string): string {\n  return createHash('sha256').update(content, 'utf8').digest('hex');\n}\n/** Detected package manager for a project directory. */\nexport type PackageManager = 'pnpm' | 'yarn' | 'npm';\n\n/**\n * Detect the project's package manager by inspecting lockfiles in `cwd`.\n * Order: pnpm \u2192 yarn \u2192 npm (default). Missing or unreadable directories fall\n * back to `npm` rather than throwing, so a `safeResolve`-checked cwd that\n * happens to be empty never aborts the tool.\n */\nexport async function detectPackageManager(cwd: string): Promise<PackageManager> {\n  const { stat } = await import('node:fs/promises');\n  try {\n    await stat(`${cwd}/pnpm-lock.yaml`);\n    return 'pnpm';\n  } catch {\n    /* not pnpm */\n  }\n  try {\n    await stat(`${cwd}/yarn.lock`);\n    return 'yarn';\n  } catch {\n    /* not yarn */\n  }\n  return 'npm';\n}\n\nexport function resolvePath(input: string, ctx: Context): string {\n  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);\n}\n\n/**\n * Roots every file tool may always reach, even in restricted mode: the\n * project root and the user-global `~/.wrongstack` directory (config, memory,\n * sessions, skills). `~/.wrongstack` honors the `WRONGSTACK_HOME` override.\n */\nfunction allowedRoots(ctx: Context): string[] {\n  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];\n}\n\n/** True if `target` is `root` itself or nested inside any of `roots`. */\nfunction isInsideAny(target: string, roots: string[]): boolean {\n  return roots.some((root) => {\n    const rel = path.relative(root, target);\n    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));\n  });\n}\n\nexport function ensureInsideRoot(absPath: string, ctx: Context): string {\n  const target = path.resolve(absPath);\n  // Unrestricted filesystem access: skip the project-root containment check.\n  if (ctx.allowOutsideProjectRoot) return target;\n  if (isInsideAny(target, allowedRoots(ctx))) return target;\n  throw new Error(`Path \"${absPath}\" is outside project root \"${path.resolve(ctx.projectRoot)}\"`);\n}\n\nexport function safeResolve(input: string, ctx: Context): string {\n  return ensureInsideRoot(resolvePath(input, ctx), ctx);\n}\n\n/**\n * Defense against in-root\u2192out-of-root symlink escape (CWE-59). `safeResolve`\n * only does a syntactic `../` check, so a symlink that lives *inside* the\n * project root but points outside still passes it. This resolves the path\n * through `fs.realpath` and re-verifies containment against the realpath of\n * the project root (comparing like-for-like, since the root itself may be a\n * symlink \u2014 macOS `/var`\u2192`/private/var`, Windows 8.3 short names). For a path\n * that does not exist yet (e.g. a `write` to a new file) the nearest existing\n * ancestor directory is checked instead. Throws if the real target escapes.\n *\n * Mirrors the per-file guard already used in `replace.ts`/`grep.ts`; applied\n * to single-file `read`/`edit`/`write` it throws (rather than skips) because\n * the caller named exactly one file.\n */\nexport async function assertRealInsideRoot(absPath: string, ctx: Context): Promise<void> {\n  // Unrestricted filesystem access: no symlink-escape check to perform.\n  if (ctx.allowOutsideProjectRoot) return;\n  // Compare like-for-like against the realpath of each always-allowed root\n  // (project root + ~/.wrongstack), since a root may itself be a symlink.\n  const realRoots = await Promise.all(\n    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r))),\n  );\n  let probe = absPath;\n  for (;;) {\n    let real: string;\n    try {\n      real = await fsp.realpath(probe);\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {\n        const parent = path.dirname(probe);\n        if (parent === probe) return; // reached fs root without escaping\n        probe = parent;\n        continue;\n      }\n      throw err;\n    }\n    if (isInsideAny(real, realRoots)) return;\n    throw new Error(\n      `Path \"${absPath}\" resolves through a symlink outside project root \"${realRoots[0]}\"`,\n    );\n  }\n}\n\n/** `safeResolve` + symlink realpath containment check. Async. */\nexport async function safeResolveReal(input: string, ctx: Context): Promise<string> {\n  const abs = safeResolve(input, ctx);\n  await assertRealInsideRoot(abs, ctx);\n  return abs;\n}\n\nexport function truncateMiddle(s: string, max: number): string {\n  if (Buffer.byteLength(s, 'utf8') <= max) return s;\n  const half = Math.floor(max / 2);\n  return (\n    s.slice(0, half) +\n    `\\n\u2026[truncated ${Buffer.byteLength(s, 'utf8') - max} bytes from middle]\u2026\\n` +\n    s.slice(-half)\n  );\n}\n\nexport function isBinaryBuffer(buf: Buffer): boolean {\n  const len = Math.min(buf.length, 8192);\n  for (let i = 0; i < len; i++) {\n    if (buf[i] === 0) return true;\n  }\n  return false;\n}\n\n// \u2500\u2500\u2500 Command-output normalization (token-saving) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Raw process output is full of tokens the model gains nothing from: ANSI\n// escapes, carriage-return progress spam, runs of identical warning lines, and\n// huge tails of build noise. These helpers strip that noise before the output\n// reaches the LLM. They are scoped to COMMAND tools (bash/git/exec and the\n// _spawn-stream consumers) \u2014 never applied to structured/code outputs.\n\n/** Unified byte cap for all command tool output fed to the model. */\nexport const COMMAND_OUTPUT_MAX_BYTES = 32_768;\n\n/** Runs of >= this many identical consecutive lines are collapsed. */\nconst REPEAT_RUN_THRESHOLD = 3;\n\n/**\n * Collapse carriage-return overwrites the way a terminal would: `\\r\\n` becomes\n * `\\n`, and a bare `\\r` (progress redraw) keeps only the text after the LAST\n * `\\r` on its physical line. Without this, a single progress bar that redraws\n * 200 times explodes into 200 lines.\n */\nexport function collapseCarriageReturns(text: string): string {\n  const lf = text.replace(/\\r\\n/g, '\\n');\n  if (!lf.includes('\\r')) return lf;\n  return lf\n    .split('\\n')\n    .map((line) => (line.includes('\\r') ? line.slice(line.lastIndexOf('\\r') + 1) : line))\n    .join('\\n');\n}\n\n/**\n * Collapse a run of `minRun`+ identical consecutive lines into the line once\n * plus a marker. Consecutive-only \u2014 it never reorders or dedups non-adjacent\n * lines, so diffs/source stay intact.\n */\nexport function collapseConsecutiveDuplicates(text: string, minRun = REPEAT_RUN_THRESHOLD): string {\n  const lines = text.split('\\n');\n  const out: string[] = [];\n  let i = 0;\n  while (i < lines.length) {\n    let j = i + 1;\n    while (j < lines.length && lines[j] === lines[i]) j++;\n    const run = j - i;\n    if (run >= minRun) {\n      out.push(lines[i]!, `\u2026 \u27E8repeated ${run}\u00D7\u27E9`);\n    } else {\n      for (let k = i; k < j; k++) out.push(lines[k]!);\n    }\n    i = j;\n  }\n  return out.join('\\n');\n}\n\n/** Largest prefix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeHeadBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(0, mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(0, lo);\n}\n\n/** Largest suffix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeTailBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(s.length - mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(s.length - lo);\n}\n\n/**\n * Truncate to `maxBytes` keeping BOTH ends \u2014 the head (what ran / early context)\n * and the tail (errors and summaries usually land last), biased ~45/55 toward\n * the tail. The result never exceeds `maxBytes`.\n */\nexport function truncateHeadTail(s: string, maxBytes: number): string {\n  const total = Buffer.byteLength(s, 'utf8');\n  if (total <= maxBytes) return s;\n  // Reserve a fixed allowance for the marker so the final string can't exceed\n  // the cap even though the dropped-byte count's digit width varies.\n  const MARKER_RESERVE = 64;\n  const avail = Math.max(0, maxBytes - MARKER_RESERVE);\n  const headBudget = Math.floor(avail * 0.45);\n  const head = takeHeadBytes(s, headBudget);\n  const tail = takeTailBytes(s, avail - Buffer.byteLength(head, 'utf8'));\n  const kept = Buffer.byteLength(head, 'utf8') + Buffer.byteLength(tail, 'utf8');\n  return `${head}\\n\u2026[truncated ${total - kept} bytes]\u2026\\n${tail}`;\n}\n\n/**\n * Full token-saving pipeline for command tool output: strip ANSI \u2192 collapse\n * carriage-return progress \u2192 trim trailing whitespace \u2192 collapse identical\n * consecutive lines \u2192 squeeze blank-line runs \u2192 head+tail truncate to the cap.\n */\nexport function normalizeCommandOutput(\n  raw: string,\n  opts: { maxBytes?: number | undefined } = {},\n): string {\n  if (!raw) return raw;\n  let text = Core.stripAnsi(raw);\n  text = collapseCarriageReturns(text);\n  text = text.replace(/[ \\t]+$/gm, ''); // trailing whitespace per line\n  text = collapseConsecutiveDuplicates(text);\n  text = text.replace(/\\n{3,}/g, '\\n\\n'); // >=2 blank lines \u2192 1\n  return truncateHeadTail(text, opts.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES);\n}\n"],
-  "mappings": "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",
-  "names": ["path"]
+  "sources": ["../src/glob.ts", "../src/_concurrency.ts", "../src/codebase-index/gitignore.ts", "../src/_util.ts"],
+  "sourcesContent": ["import * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport { compileGlob, DEFAULT_WALK_IGNORE_DIRS } from '@wrongstack/core/utils';\nimport type { Tool } from '@wrongstack/core/types';\nimport { mapWithConcurrency } from './_concurrency.js';\nimport { loadGitignoreMatcher } from './codebase-index/gitignore.js';\nimport { assertRealInsideRoot, safeResolveReal } from './_util.js';\n\ninterface GlobInput {\n  pattern: string;\n  path?: string | undefined;\n  limit?: number | undefined;\n}\n\ninterface GlobOutput {\n  files: string[];\n  truncated: boolean;\n}\n\nconst DEFAULT_IGNORE = DEFAULT_WALK_IGNORE_DIRS;\nconst WALK_CONCURRENCY = 16;\n\nexport const globTool: Tool<GlobInput, GlobOutput> = {\n  name: 'glob',\n  category: 'Filesystem',\n  description:\n    'Find files by path pattern. Use index-backed `codebase-search` first for code symbols or concepts when it is live.',\n  usageHint:\n    'PATH DISCOVERY AND SEARCH SCOPING:\\n\\n' +\n    '- When `codebase-search` is live, use it first for code concepts; use `glob` for filenames, path patterns, and non-indexed files.\\n' +\n    '- Combine with `path` and `limit`.\\n' +\n    '- Default ignores common build/dependency directories.\\n' +\n    'Much more efficient than shell `find` for most use cases inside the agent.',\n  selection: {\n    doNotUseWhen: 'you need to search inside file contents.',\n    useInstead: ['grep'],\n  },\n  permission: 'auto',\n  mutating: false,\n  capabilities: ['fs.read'],\n  icon: 'folder',\n  maxOutputBytes: 65_536,\n  timeoutMs: 5_000,\n  inputSchema: {\n    type: 'object',\n    properties: {\n      pattern: {\n        type: 'string',\n        description: 'Glob pattern to match (e.g. \"**/*.ts\", \"src/**\").',\n      },\n      path: {\n        type: 'string',\n        description: 'Base directory to search from (defaults to project root).',\n      },\n      limit: {\n        type: 'integer',\n        description: 'Maximum number of results to return (default 1000, max 5000).',\n      },\n    },\n    required: ['pattern'],\n  },\n  async execute(input, ctx, opts) {\n    if (!input?.pattern) throw new Error('glob: pattern is required');\n    const signal = opts?.signal;\n    // `safeResolveReal` validates that the input base \u2014 even if symlinked \u2014\n    // resolves to a real path inside the project root (or `~/.wrongstack`).\n    // Throws on escape, matching how single-file tools (`read`, `edit`,\n    // `write`) reject out-of-root paths: the caller named the base explicitly.\n    const base = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;\n    const limit = Math.max(1, Math.min(input.limit ?? 1000, 5000));\n\n    // Full gitignore semantics (globs, anchors, negation, dir-only rules)\n    // rooted at the walk base \u2014 a project whose build output isn't in the\n    // static DEFAULT_IGNORE list would otherwise be walked in full.\n    const isGitIgnored = await loadGitignoreMatcher(base);\n    const re = compileGlob(input.pattern);\n\n    const results: { rel: string; mtime: number }[] = [];\n    let truncated = false;\n    const pushResult = async (full: string): Promise<void> => {\n      // Bail before stat if a concurrent worker has already filled the budget \u2014\n      // the limit is a global cap across all parallel walkers, not per-worker.\n      if (truncated || results.length >= limit) {\n        truncated = true;\n        return;\n      }\n      try {\n        const st = await fs.stat(full);\n        // Re-check after the await: another worker may have filled the budget\n        // while we were waiting on fs.stat.\n        if (truncated || results.length >= limit) {\n          truncated = true;\n          return;\n        }\n        results.push({ rel: full, mtime: st.mtimeMs });\n        if (results.length >= limit) truncated = true;\n      } catch {\n        // skip stat error\n      }\n    };\n    const walk = async (dir: string, relPrefix: string): Promise<void> => {\n      // Abort check per directory: a huge tree walk must stop promptly on\n      // Ctrl+C instead of running to completion with a discarded result.\n      if (signal?.aborted) {\n        truncated = true;\n        return;\n      }\n      /* v8 ignore start -- the inner limit guards (file push + post-recursion return) always stop first; this re-entry guard is defensive. */\n      if (results.length >= limit) {\n        truncated = true;\n        return;\n      }\n      /* v8 ignore stop */\n      let entries: import('node:fs').Dirent[];\n      try {\n        entries = await fs.readdir(dir, { withFileTypes: true });\n      } catch {\n        return;\n      }\n      const subdirs: Array<{ full: string; rel: string }> = [];\n      const matchedFiles: string[] = [];\n      for (const e of entries) {\n        const name = e.name;\n        if (DEFAULT_IGNORE.includes(name)) continue;\n        const rel = relPrefix ? `${relPrefix}/${name}` : name;\n        const full = path.join(dir, name);\n        if (e.isDirectory()) {\n          if (isGitIgnored(rel, true)) continue;\n          subdirs.push({ full, rel });\n        } else if (e.isFile()) {\n          if (isGitIgnored(rel, false)) continue;\n          re.lastIndex = 0;\n          const relMatch = re.test(rel);\n          re.lastIndex = 0;\n          const nameMatch = re.test(name);\n          if (relMatch || nameMatch) {\n            matchedFiles.push(full);\n          }\n        } else if (e.isSymbolicLink()) {\n          try {\n            const st = await fs.stat(full);\n            if (st.isDirectory()) {\n              if (isGitIgnored(rel, true)) continue;\n              // CWE-59 containment: a symlink inside the workspace can point\n              // outside it. Before recursing into it (or including the\n              // resolved file in results), realpath the symlink and verify\n              // its target is still inside the project root. Skip silently\n              // on escape so a single bad symlink doesn't poison the whole\n              // walk.\n              const real = await fs.realpath(full);\n              await assertRealInsideRoot(real, ctx);\n              subdirs.push({ full, rel });\n            } else if (st.isFile()) {\n              if (isGitIgnored(rel, false)) continue;\n              const real = await fs.realpath(full);\n              await assertRealInsideRoot(real, ctx);\n              re.lastIndex = 0;\n              const relMatch = re.test(rel);\n              re.lastIndex = 0;\n              const nameMatch = re.test(name);\n              if (relMatch || nameMatch) matchedFiles.push(full);\n            }\n          } catch {\n            // Skip broken symlink, stat error, OR out-of-root target. All\n            // three should fail the walk without aborting the whole search.\n          }\n        }\n        if (truncated) return;\n      }\n      await mapWithConcurrency(matchedFiles, WALK_CONCURRENCY, pushResult);\n      if (truncated) return;\n      // Subdir walks: each one re-checks the limit at entry (re-entry guard),\n      // but we also stop dispatching new walks once truncated, so siblings of\n      // a hit-limit subdir don't keep adding results.\n      const remainingSubdirs = truncated ? [] : subdirs;\n      await mapWithConcurrency(remainingSubdirs, WALK_CONCURRENCY, ({ full, rel }) => walk(full, rel));\n    };\n    await walk(base, '');\n    results.sort((a, b) => b.mtime - a.mtime);\n    return { files: results.map((r) => r.rel), truncated };\n  },\n};\n", "/**\n * Bounded-concurrency async map.\n *\n * Runs `fn` over `items` with at most `limit` in-flight promises. Order of\n * results matches input order. Errors reject the returned promise on the first\n * failure \u2014 the remaining in-flight work is not awaited; this matches\n * `Promise.all` semantics for callers that want fail-fast behavior.\n *\n * Lives here (rather than imported from `@wrongstack/bench`) because:\n *   1. tools sits below bench in the dependency graph \u2014 bench is a consumer of\n *      tools, never the other way around.\n *   2. The semantics used by grep/glob are deliberately simple (fail-fast,\n *      no cancellation, no progress) and don't need bench's richer options.\n */\nexport async function mapWithConcurrency<T, R>(\n  items: readonly T[],\n  limit: number,\n  fn: (item: T) => Promise<R>,\n): Promise<R[]> {\n  if (items.length === 0) return [];\n  const effectiveLimit = Math.max(1, Math.min(limit | 0, items.length));\n  const results: R[] = new Array(items.length);\n  let nextIndex = 0;\n\n  const worker = async (): Promise<void> => {\n    while (true) {\n      const i = nextIndex++;\n      if (i >= items.length) return;\n      results[i] = await fn(items[i] as T);\n    }\n  };\n\n  await Promise.all(Array.from({ length: effectiveLimit }, worker));\n  return results;\n}\n", "/**\n * Minimal but faithful `.gitignore` matcher for the indexer.\n *\n * Supports the parts of the gitignore spec that matter for skipping source\n * files: comments / blanks, `!` negation (last match wins), trailing-slash\n * directory-only rules, leading-slash / embedded-slash anchoring, and the\n * `*` / `**` / `?` / `[...]` globs (via core's {@link compileGlob}).\n *\n * Only the project-root `.gitignore` is read. Nested `.gitignore` files are not\n * walked \u2014 the common build/dependency dirs that would live deeper are already\n * covered by the indexer's always-on `DEFAULT_IGNORE`.\n *\n * Known limitation: a `!negated` file inside an ignored directory will not be\n * re-included, because the indexer prunes ignored directories before descending\n * (a large performance win). This matches most lightweight implementations.\n */\n\nimport * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport { compileGlob } from '@wrongstack/core/utils';\n\nexport type IgnoreMatcher = (relPath: string, isDir: boolean) => boolean;\n\ninterface Rule {\n  /** Matches the entry itself or anything under it (for dirs / plain names). */\n  eqOrUnder: RegExp;\n  /** Matches only entries strictly under it (for dir-only rules on files). */\n  under: RegExp;\n  negated: boolean;\n  dirOnly: boolean;\n}\n\n/** Strip the `^`/`$` anchors compileGlob adds so we can re-anchor ourselves. */\nfunction globBody(glob: string): string {\n  return compileGlob(glob).source.replace(/^\\^/, '').replace(/\\$$/, '');\n}\n\n/** Compile a list of raw `.gitignore` lines into a matcher. */\nexport function compileGitignore(lines: string[]): IgnoreMatcher {\n  const rules: Rule[] = [];\n\n  for (const raw of lines) {\n    let line = raw.replace(/\\r$/, '');\n    if (!line.trim() || line.trimStart().startsWith('#')) continue;\n    line = line.trim();\n\n    let negated = false;\n    if (line.startsWith('!')) {\n      negated = true;\n      line = line.slice(1);\n    }\n\n    let dirOnly = false;\n    if (line.endsWith('/')) {\n      dirOnly = true;\n      line = line.slice(0, -1);\n    }\n    if (!line) continue;\n\n    // A slash anywhere (after the trailing slash is stripped) anchors the\n    // pattern to the gitignore's directory (the project root here). A bare name\n    // matches at any depth.\n    const anchored = line.startsWith('/') || line.includes('/');\n    if (line.startsWith('/')) line = line.slice(1);\n\n    const body = globBody(line);\n    const prefix = anchored ? '^' : '(?:^|.*/)';\n    rules.push({\n      eqOrUnder: new RegExp(`${prefix}${body}(?:/.*)?$`),\n      under: new RegExp(`${prefix}${body}/.*$`),\n      negated,\n      dirOnly,\n    });\n  }\n\n  return (relPath: string, isDir: boolean): boolean => {\n    const p = relPath.replace(/\\\\/g, '/').replace(/^\\/+/, '');\n    let ignored = false;\n    for (const r of rules) {\n      // A directory-only rule never matches a file by its own name; it only\n      // matches files that live strictly beneath the named directory.\n      const re = r.dirOnly && !isDir ? r.under : r.eqOrUnder;\n      if (re.test(p)) ignored = !r.negated;\n    }\n    return ignored;\n  };\n}\n\n/** Read `<projectRoot>/.gitignore` and compile it. Missing file \u2192 matches nothing. */\nexport async function loadGitignoreMatcher(projectRoot: string): Promise<IgnoreMatcher> {\n  let lines: string[] = [];\n  try {\n    const raw = await fs.readFile(path.join(projectRoot, '.gitignore'), 'utf8');\n    lines = raw.split('\\n');\n  } catch {\n    // No .gitignore \u2014 nothing extra to ignore beyond the indexer defaults.\n  }\n  return compileGitignore(lines);\n}\n", "import { createHash } from 'node:crypto';\nimport * as fsp from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as Core from '@wrongstack/core/utils';\nimport type { Context } from '@wrongstack/core/agent';\n\n/**\n * sha-256 hex of a UTF-8 string. Used by the file tools to record a content\n * hash alongside the mtime in `ctx.recordRead` \u2014 the hash is the authoritative\n * staleness arbiter for `edit` (mtime has a 2 s tolerance window on Windows).\n */\nexport function sha256hex(content: string): string {\n  return createHash('sha256').update(content, 'utf8').digest('hex');\n}\n/** Detected package manager for a project directory. */\nexport type PackageManager = 'pnpm' | 'yarn' | 'npm';\n\n/**\n * Detect the project's package manager by inspecting lockfiles in `cwd`.\n * Order: pnpm \u2192 yarn \u2192 npm (default). Missing or unreadable directories fall\n * back to `npm` rather than throwing, so a `safeResolve`-checked cwd that\n * happens to be empty never aborts the tool.\n */\nexport async function detectPackageManager(cwd: string): Promise<PackageManager> {\n  const { stat } = await import('node:fs/promises');\n  try {\n    await stat(`${cwd}/pnpm-lock.yaml`);\n    return 'pnpm';\n  } catch {\n    /* not pnpm */\n  }\n  try {\n    await stat(`${cwd}/yarn.lock`);\n    return 'yarn';\n  } catch {\n    /* not yarn */\n  }\n  return 'npm';\n}\n\nexport function resolvePath(input: string, ctx: Context): string {\n  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);\n}\n\n/**\n * Roots every file tool may always reach, even in restricted mode: the\n * project root and the user-global `~/.wrongstack` directory (config, memory,\n * sessions, skills). `~/.wrongstack` honors the `WRONGSTACK_HOME` override.\n */\nfunction allowedRoots(ctx: Context): string[] {\n  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];\n}\n\n/** True if `target` is `root` itself or nested inside any of `roots`. */\nfunction isInsideAny(target: string, roots: string[]): boolean {\n  return roots.some((root) => {\n    const rel = path.relative(root, target);\n    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));\n  });\n}\n\nexport function ensureInsideRoot(absPath: string, ctx: Context): string {\n  const target = path.resolve(absPath);\n  // Unrestricted filesystem access: skip the project-root containment check.\n  if (ctx.allowOutsideProjectRoot) return target;\n  if (isInsideAny(target, allowedRoots(ctx))) return target;\n  throw new Error(`Path \"${absPath}\" is outside project root \"${path.resolve(ctx.projectRoot)}\"`);\n}\n\nexport function safeResolve(input: string, ctx: Context): string {\n  return ensureInsideRoot(resolvePath(input, ctx), ctx);\n}\n\n/**\n * Defense against in-root\u2192out-of-root symlink escape (CWE-59). `safeResolve`\n * only does a syntactic `../` check, so a symlink that lives *inside* the\n * project root but points outside still passes it. This resolves the path\n * through `fs.realpath` and re-verifies containment against the realpath of\n * the project root (comparing like-for-like, since the root itself may be a\n * symlink \u2014 macOS `/var`\u2192`/private/var`, Windows 8.3 short names). For a path\n * that does not exist yet (e.g. a `write` to a new file) the nearest existing\n * ancestor directory is checked instead. Throws if the real target escapes.\n *\n * Mirrors the per-file guard already used in `replace.ts`/`grep.ts`; applied\n * to single-file `read`/`edit`/`write` it throws (rather than skips) because\n * the caller named exactly one file.\n */\nexport async function assertRealInsideRoot(absPath: string, ctx: Context): Promise<void> {\n  // Unrestricted filesystem access: no symlink-escape check to perform.\n  if (ctx.allowOutsideProjectRoot) return;\n  // Compare like-for-like against the realpath of each always-allowed root\n  // (project root + ~/.wrongstack), since a root may itself be a symlink.\n  const realRoots = await Promise.all(\n    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r))),\n  );\n  let probe = absPath;\n  for (;;) {\n    let real: string;\n    try {\n      real = await fsp.realpath(probe);\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {\n        const parent = path.dirname(probe);\n        if (parent === probe) return; // reached fs root without escaping\n        probe = parent;\n        continue;\n      }\n      throw err;\n    }\n    if (isInsideAny(real, realRoots)) return;\n    throw new Error(\n      `Path \"${absPath}\" resolves through a symlink outside project root \"${realRoots[0]}\"`,\n    );\n  }\n}\n\n/** `safeResolve` + symlink realpath containment check. Async. */\nexport async function safeResolveReal(input: string, ctx: Context): Promise<string> {\n  const abs = safeResolve(input, ctx);\n  await assertRealInsideRoot(abs, ctx);\n  return abs;\n}\n\nexport function truncateMiddle(s: string, max: number): string {\n  if (Buffer.byteLength(s, 'utf8') <= max) return s;\n  const half = Math.floor(max / 2);\n  return (\n    s.slice(0, half) +\n    `\\n\u2026[truncated ${Buffer.byteLength(s, 'utf8') - max} bytes from middle]\u2026\\n` +\n    s.slice(-half)\n  );\n}\n\nexport function isBinaryBuffer(buf: Buffer): boolean {\n  const len = Math.min(buf.length, 8192);\n  for (let i = 0; i < len; i++) {\n    if (buf[i] === 0) return true;\n  }\n  return false;\n}\n\n// \u2500\u2500\u2500 Command-output normalization (token-saving) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Raw process output is full of tokens the model gains nothing from: ANSI\n// escapes, carriage-return progress spam, runs of identical warning lines, and\n// huge tails of build noise. These helpers strip that noise before the output\n// reaches the LLM. They are scoped to COMMAND tools (bash/git/exec and the\n// _spawn-stream consumers) \u2014 never applied to structured/code outputs.\n\n/** Unified byte cap for all command tool output fed to the model. */\nexport const COMMAND_OUTPUT_MAX_BYTES = 32_768;\n\n/** Runs of >= this many identical consecutive lines are collapsed. */\nconst REPEAT_RUN_THRESHOLD = 3;\n\n/**\n * Collapse carriage-return overwrites the way a terminal would: `\\r\\n` becomes\n * `\\n`, and a bare `\\r` (progress redraw) keeps only the text after the LAST\n * `\\r` on its physical line. Without this, a single progress bar that redraws\n * 200 times explodes into 200 lines.\n */\nexport function collapseCarriageReturns(text: string): string {\n  const lf = text.replace(/\\r\\n/g, '\\n');\n  if (!lf.includes('\\r')) return lf;\n  return lf\n    .split('\\n')\n    .map((line) => (line.includes('\\r') ? line.slice(line.lastIndexOf('\\r') + 1) : line))\n    .join('\\n');\n}\n\n/**\n * Collapse a run of `minRun`+ identical consecutive lines into the line once\n * plus a marker. Consecutive-only \u2014 it never reorders or dedups non-adjacent\n * lines, so diffs/source stay intact.\n */\nexport function collapseConsecutiveDuplicates(text: string, minRun = REPEAT_RUN_THRESHOLD): string {\n  const lines = text.split('\\n');\n  const out: string[] = [];\n  let i = 0;\n  while (i < lines.length) {\n    let j = i + 1;\n    while (j < lines.length && lines[j] === lines[i]) j++;\n    const run = j - i;\n    if (run >= minRun) {\n      out.push(lines[i]!, `\u2026 \u27E8repeated ${run}\u00D7\u27E9`);\n    } else {\n      for (let k = i; k < j; k++) out.push(lines[k]!);\n    }\n    i = j;\n  }\n  return out.join('\\n');\n}\n\n/** Largest prefix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeHeadBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(0, mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(0, lo);\n}\n\n/** Largest suffix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeTailBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(s.length - mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(s.length - lo);\n}\n\n/**\n * Truncate to `maxBytes` keeping BOTH ends \u2014 the head (what ran / early context)\n * and the tail (errors and summaries usually land last), biased ~45/55 toward\n * the tail. The result never exceeds `maxBytes`.\n */\nexport function truncateHeadTail(s: string, maxBytes: number): string {\n  const total = Buffer.byteLength(s, 'utf8');\n  if (total <= maxBytes) return s;\n  // Reserve a fixed allowance for the marker so the final string can't exceed\n  // the cap even though the dropped-byte count's digit width varies.\n  const MARKER_RESERVE = 64;\n  const avail = Math.max(0, maxBytes - MARKER_RESERVE);\n  const headBudget = Math.floor(avail * 0.45);\n  const head = takeHeadBytes(s, headBudget);\n  const tail = takeTailBytes(s, avail - Buffer.byteLength(head, 'utf8'));\n  const kept = Buffer.byteLength(head, 'utf8') + Buffer.byteLength(tail, 'utf8');\n  return `${head}\\n\u2026[truncated ${total - kept} bytes]\u2026\\n${tail}`;\n}\n\n/**\n * Full token-saving pipeline for command tool output: strip ANSI \u2192 collapse\n * carriage-return progress \u2192 trim trailing whitespace \u2192 collapse identical\n * consecutive lines \u2192 squeeze blank-line runs \u2192 head+tail truncate to the cap.\n */\nexport function normalizeCommandOutput(\n  raw: string,\n  opts: { maxBytes?: number | undefined } = {},\n): string {\n  if (!raw) return raw;\n  let text = Core.stripAnsi(raw);\n  text = collapseCarriageReturns(text);\n  text = text.replace(/[ \\t]+$/gm, ''); // trailing whitespace per line\n  text = collapseConsecutiveDuplicates(text);\n  text = text.replace(/\\n{3,}/g, '\\n\\n'); // >=2 blank lines \u2192 1\n  return truncateHeadTail(text, opts.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES);\n}\n"],
+  "mappings": "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",
+  "names": ["fs", "path", "compileGlob", "path", "compileGlob"]
 }

package/dist/grep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../src/grep.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAmB,MAAM,wBAAwB,CAAC;AAMpE,UAAU,SAAS;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,WAAW,CAAC,EAAE,SAAS,GAAG,oBAAoB,GAAG,OAAO,GAAG,SAAS,CAAC;IACrE,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAED,UAAU,UAAU;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,IAAI,GAAG,QAAQ,CAAC;CACvB;AAOD,eAAO,MAAM,QAAQ,EAAE,IAAI,CAAC,SAAS,EAAE,UAAU,CAqGhD,CAAC"}
+{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../src/grep.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAmB,MAAM,wBAAwB,CAAC;AAOpE,UAAU,SAAS;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,WAAW,CAAC,EAAE,SAAS,GAAG,oBAAoB,GAAG,OAAO,GAAG,SAAS,CAAC;IACrE,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAED,UAAU,UAAU;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,IAAI,GAAG,QAAQ,CAAC;CACvB;AAOD,eAAO,MAAM,QAAQ,EAAE,IAAI,CAAC,SAAS,EAAE,UAAU,CAqGhD,CAAC"}

package/dist/grep.js

@@ -1,10 +1,10 @@
 // src/grep.ts
 import { expectDefined } from "@wrongstack/core/utils";
 import { spawn } from "node:child_process";
-import * as fs from "node:fs/promises";
-import * as path2 from "node:path";
+import * as fs2 from "node:fs/promises";
+import * as path3 from "node:path";
 import { ToolValidationError } from "@wrongstack/core/types";
-import { buildChildEnv, compileGlob } from "@wrongstack/core/utils";
+import { buildChildEnv, compileGlob as compileGlob2, DEFAULT_WALK_IGNORE_DIRS } from "@wrongstack/core/utils";
 
 // src/_concurrency.ts
 async function mapWithConcurrency(items, limit, fn) {
@@ -68,26 +68,81 @@ function capSubject(line) {
   return line.length > MAX_SUBJECT_LEN ? line.slice(0, MAX_SUBJECT_LEN) : line;
 }
 
-// src/_util.ts
+// 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 path2 from "node:path";
 import * as Core from "@wrongstack/core/utils";
 function resolvePath(input, ctx) {
-  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);
+  return path2.isAbsolute(input) ? path2.normalize(input) : path2.resolve(ctx.workingDir ?? ctx.cwd, input);
 }
 function allowedRoots(ctx) {
-  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];
+  return [path2.resolve(ctx.projectRoot), path2.resolve(Core.wstackGlobalRoot())];
 }
 function isInsideAny(target, roots) {
   return roots.some((root) => {
-    const rel = path.relative(root, target);
-    return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+    const rel = path2.relative(root, target);
+    return rel === "" || !rel.startsWith("..") && !path2.isAbsolute(rel);
   });
 }
 function ensureInsideRoot(absPath, ctx) {
-  const target = path.resolve(absPath);
+  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 "${path.resolve(ctx.projectRoot)}"`);
+  throw new Error(`Path "${absPath}" is outside project root "${path2.resolve(ctx.projectRoot)}"`);
 }
 function safeResolve(input, ctx) {
   return ensureInsideRoot(resolvePath(input, ctx), ctx);
@@ -101,7 +156,7 @@ function isBinaryBuffer(buf) {
 }
 
 // src/grep.ts
-var DEFAULT_IGNORE = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
+var DEFAULT_IGNORE = DEFAULT_WALK_IGNORE_DIRS;
 var NATIVE_SCAN_CONCURRENCY = 32;
 var NATIVE_READ_CHUNK_BYTES = 64 * 1024;
 var NATIVE_MAX_FILE_BYTES = 1e6;
@@ -218,6 +273,10 @@ async function* runRgStream(input, base, mode, limit, signal) {
   for (const ignored of DEFAULT_IGNORE) {
     args.push("--glob", `!${ignored}/**`, "--glob", `!**/${ignored}/**`);
   }
+  const gitignorePath = path3.join(base, ".gitignore");
+  if (await fs2.access(gitignorePath).then(() => true, () => false)) {
+    args.push("--ignore-file", gitignorePath);
+  }
   if (input.glob) args.push("--glob", input.glob);
   args.push("--", input.pattern, base);
   const matches = [];
@@ -342,7 +401,8 @@ async function runNative(input, base, mode, limit, signal) {
     });
   }
   const re = compiled.regex;
-  const globRe = input.glob ? compileGlob(input.glob) : null;
+  const globRe = input.glob ? compileGlob2(input.glob) : null;
+  const isGitIgnored = await loadGitignoreMatcher(base);
   const matches = [];
   const countOnlyFirstHit = mode === "count" && limit === 1;
   const maxBytes = mode === "content" ? NATIVE_MAX_FILE_BYTES : Math.min(NATIVE_MAX_FILE_BYTES, 256 * 1024);
@@ -353,9 +413,9 @@ async function runNative(input, base, mode, limit, signal) {
     if (globRe && !globRe.test(name) && !globRe.test(full)) return;
     if (globRe) globRe.lastIndex = 0;
     try {
-      const stat2 = await fs.stat(full);
+      const stat2 = await fs2.stat(full);
       if (!stat2.isFile() || stat2.size > maxBytes || stopped || signal.aborted) return;
-      const file = await fs.open(full, "r");
+      const file = await fs2.open(full, "r");
       try {
         let bytesReadTotal = 0;
         let lineNumber = 0;
@@ -430,11 +490,11 @@ async function runNative(input, base, mode, limit, signal) {
     } catch {
     }
   };
-  const walk = async (dir) => {
+  const walk = async (dir, relPrefix) => {
     if (stopped || signal.aborted) return;
     let entries;
     try {
-      entries = await fs.readdir(dir, { withFileTypes: true });
+      entries = await fs2.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -444,17 +504,24 @@ async function runNative(input, base, mode, limit, signal) {
       if (stopped) return;
       if (DEFAULT_IGNORE.includes(e.name)) continue;
       if (e.isSymbolicLink()) continue;
-      const full = path2.join(dir, e.name);
+      const rel = relPrefix ? `${relPrefix}/${e.name}` : e.name;
+      const full = path3.join(dir, e.name);
       if (e.isDirectory()) {
-        subdirs.push(full);
+        if (isGitIgnored(rel, true)) continue;
+        subdirs.push({ full, rel });
       } else if (e.isFile()) {
+        if (isGitIgnored(rel, false)) continue;
         files.push({ full, name: e.name });
       }
     }
     await mapWithConcurrency(files, NATIVE_SCAN_CONCURRENCY, ({ full, name }) => scanFile(full, name));
-    await mapWithConcurrency(subdirs, Math.min(16, NATIVE_SCAN_CONCURRENCY), walk);
+    await mapWithConcurrency(
+      subdirs,
+      Math.min(16, NATIVE_SCAN_CONCURRENCY),
+      ({ full, rel }) => walk(full, rel)
+    );
   };
-  await walk(base);
+  await walk(base, "");
   return {
     matches,
     count: total,