token-goat 2.9.29 → 2.9.31

package/dist/{token-goat-chunk-O6I2XU4P.mjs → token-goat-chunk-4ZBFWLXF.mjs}

@@ -1,47 +1,253 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
-  DEFAULT_MAX_AGE_MS,
-  blobPath,
-  isBlobStale,
-  loadBlob,
-  storeBlob
-} from "./token-goat-chunk-D4ETHJD6.mjs";
-import {
-  hasUnquotedOperator
-} from "./token-goat-chunk-2WOUYWLM.mjs";
+  sanitizeFtsQuery
+} from "./token-goat-chunk-IK2DRMFX.mjs";
 import {
-  redactSecrets
-} from "./token-goat-chunk-CIQ2FTY3.mjs";
+  recordStat
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
 import {
-  sanitizeFtsQuery
-} from "./token-goat-chunk-435UQTKD.mjs";
+  getDb,
+  getReadDb
+} from "./token-goat-chunk-GVB2MUST.mjs";
 import {
-  getDb
-} from "./token-goat-chunk-7CPMDFGB.mjs";
+  hasUnquotedOperator
+} from "./token-goat-chunk-4GILLLWY.mjs";
 import {
-  shortFingerprint
-} from "./token-goat-chunk-TGOXNAHW.mjs";
+  stripAnsiEscapes
+} from "./token-goat-chunk-HAVAOB3S.mjs";
 import {
-  registerReset
-} from "./token-goat-chunk-YZAAZU2S.mjs";
+  redactSerializedJson
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
 import {
-  runGit
-} from "./token-goat-chunk-XYWPOSCN.mjs";
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
 import {
-  normalizePath
-} from "./token-goat-chunk-NMTKNYGF.mjs";
+  atomicWriteText,
+  ensureDirSync,
+  sanitizeIdForFilename
+} from "./token-goat-chunk-HU4TORC5.mjs";
 import {
-  globalDbPath
-} from "./token-goat-chunk-MELOKFDJ.mjs";
+  globalDbPath,
+  tokenGoatHome
+} from "./token-goat-chunk-CO3UYX6G.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
 
-// src/bash_output_cache.ts
+// src/disk_cache.ts
 init_define_import_meta_env();
-import { readdirSync, readFileSync, statSync } from "fs";
-import { resolve } from "path";
+import * as fs from "node:fs";
+import * as path from "node:path";
+var DEFAULT_MAX_COUNT = 200;
+var DEFAULT_MAX_AGE_MS = 24 * 3600 * 1e3;
+function sanitizeId(id) {
+  return sanitizeIdForFilename(id, 64);
+}
+function blobDir(subdir) {
+  return path.join(tokenGoatHome(), subdir);
+}
+function blobPath(subdir, id) {
+  const safe = sanitizeId(id);
+  if (!safe) return null;
+  const dir = blobDir(subdir);
+  const candidate = path.join(dir, `${safe}.json`);
+  try {
+    const rel = path.relative(dir, candidate);
+    if (rel.startsWith("..")) return null;
+  } catch {
+    return null;
+  }
+  return candidate;
+}
+function isBlobStale(subdir, id) {
+  const p = blobPath(subdir, id);
+  if (p === null) return false;
+  try {
+    const stat = fs.statSync(p);
+    return Date.now() - stat.mtimeMs > DEFAULT_MAX_AGE_MS;
+  } catch {
+    return false;
+  }
+}
+function subdirCacheDefaults(subdir) {
+  try {
+    if (subdir === "bash_outputs") {
+      const bc = loadConfig().bash_compress;
+      return { maxCount: bc.cache_max_file_count, maxBytes: bc.cache_max_bytes, maxBytesPerItem: bc.cache_max_bytes_per_output };
+    }
+    if (subdir === "web_outputs") {
+      const wf = loadConfig().webfetch;
+      return { maxCount: wf.max_file_count, maxBytes: wf.max_bytes, maxBytesPerItem: Number.POSITIVE_INFINITY };
+    }
+  } catch {
+  }
+  return { maxCount: DEFAULT_MAX_COUNT, maxBytes: Number.POSITIVE_INFINITY, maxBytesPerItem: Number.POSITIVE_INFINITY };
+}
+function storeBlob(subdir, id, value, opts = {}) {
+  const p = blobPath(subdir, id);
+  if (!p) return false;
+  const defaults = subdirCacheDefaults(subdir);
+  const maxBytesPerItem = opts.maxBytesPerItem ?? defaults.maxBytesPerItem;
+  let rawJson;
+  try {
+    rawJson = JSON.stringify(value);
+  } catch {
+    return false;
+  }
+  let json;
+  try {
+    const result = redactSerializedJson(rawJson);
+    json = result.text;
+    if (result.count > 0) recordStat("secret_redacted", 0, result.count, void 0, subdir);
+  } catch {
+    return false;
+  }
+  if (Number.isFinite(maxBytesPerItem) && Buffer.byteLength(json, "utf-8") > maxBytesPerItem) return false;
+  try {
+    const dir = path.dirname(p);
+    if (!fs.existsSync(dir)) ensureDirSync(dir);
+    atomicWriteText(p, json);
+  } catch {
+    return false;
+  }
+  pruneBlobs(
+    subdir,
+    opts.maxCount ?? defaults.maxCount,
+    opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS,
+    opts.maxBytes ?? defaults.maxBytes,
+    p
+  );
+  return true;
+}
+function loadBlob(subdir, id) {
+  const p = blobPath(subdir, id);
+  if (!p) return null;
+  try {
+    if (!fs.existsSync(p)) return null;
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function listBlobs(subdir) {
+  const dir = blobDir(subdir);
+  const out = [];
+  try {
+    if (!fs.existsSync(dir)) return out;
+    for (const file of fs.readdirSync(dir)) {
+      if (!file.endsWith(".json")) continue;
+      const id = file.slice(0, -5);
+      let mtime = 0;
+      try {
+        mtime = fs.statSync(path.join(dir, file)).mtimeMs;
+      } catch {
+      }
+      const value = loadBlob(subdir, id);
+      if (value !== null) out.push({ id, mtime, value });
+    }
+  } catch {
+    return out;
+  }
+  return out;
+}
+function pruneBlobs(subdir, maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_AGE_MS, maxBytes = Number.POSITIVE_INFINITY, protectedPath) {
+  return pruneBlobDir(blobDir(subdir), maxCount, maxAgeMs, maxBytes, protectedPath);
+}
+function pruneBlobDir(dir, maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_AGE_MS, maxBytes = Number.POSITIVE_INFINITY, protectedPath) {
+  let removed = 0;
+  try {
+    if (!fs.existsSync(dir)) return 0;
+    const cutoff = Date.now() - maxAgeMs;
+    let kept = [];
+    let protectedEntry;
+    for (const file of fs.readdirSync(dir)) {
+      const full = path.join(dir, file);
+      let stat;
+      try {
+        stat = fs.statSync(full);
+      } catch {
+        continue;
+      }
+      if (!stat.isFile()) continue;
+      if (protectedPath !== void 0 && full === protectedPath) {
+        protectedEntry = [full, stat.mtimeMs, stat.size];
+        continue;
+      }
+      if (stat.mtimeMs < cutoff) {
+        try {
+          fs.unlinkSync(full);
+          removed++;
+        } catch {
+          continue;
+        }
+      } else if (file.endsWith(".json")) {
+        kept.push([full, stat.mtimeMs, stat.size]);
+      }
+    }
+    const countBudget = protectedEntry ? Math.max(0, maxCount - 1) : maxCount;
+    if (kept.length > countBudget) {
+      kept.sort((a, b) => a[1] - b[1]);
+      const excess = kept.slice(0, kept.length - countBudget);
+      kept = kept.slice(kept.length - countBudget);
+      for (const [full] of excess) {
+        try {
+          fs.unlinkSync(full);
+          removed++;
+        } catch {
+          continue;
+        }
+      }
+    }
+    if (Number.isFinite(maxBytes)) {
+      kept.sort((a, b) => a[1] - b[1]);
+      let total = kept.reduce((sum, [, , size]) => sum + size, 0) + (protectedEntry ? protectedEntry[2] : 0);
+      while (total > maxBytes && kept.length > 0) {
+        const oldest = kept.shift();
+        if (!oldest) break;
+        const [full, , size] = oldest;
+        try {
+          fs.unlinkSync(full);
+          removed++;
+          total -= size;
+        } catch {
+          break;
+        }
+      }
+    }
+  } catch {
+    return removed;
+  }
+  return removed;
+}
+var SWEEPABLE_CACHE_SUBDIRS = [
+  { subdir: "bash_outputs", countCapped: true },
+  { subdir: "web_outputs", countCapped: true },
+  { subdir: "mcp_outputs", countCapped: true },
+  { subdir: "sessions", countCapped: false }
+];
+function sweepCacheRoots(extraRoots = []) {
+  let removed = 0;
+  const roots = [tokenGoatHome(), ...extraRoots];
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    if (!root || seen.has(root)) continue;
+    seen.add(root);
+    for (const { subdir, countCapped } of SWEEPABLE_CACHE_SUBDIRS) {
+      try {
+        const defaults = subdirCacheDefaults(subdir);
+        removed += pruneBlobDir(
+          path.join(root, subdir),
+          countCapped ? defaults.maxCount : Number.POSITIVE_INFINITY,
+          DEFAULT_MAX_AGE_MS,
+          countCapped ? defaults.maxBytes : Number.POSITIVE_INFINITY
+        );
+      } catch {
+      }
+    }
+  }
+  return removed;
+}
 
 // src/hints/lang_patterns.ts
 init_define_import_meta_env();
@@ -140,7 +346,7 @@ var BUILD_COMMAND_PATTERNS = [
   /^\s*(?:gradle|\.\/gradlew|gradlew)\b/i,
   // Python / pip
   /^\s*pip\s+(install|freeze)\b/i,
-  // npm audit / npm outdated — read-only reporting commands with no side effects, safe to cache/recall. Each resolves a `lockfile`-scoped fingerprint via bash_output_cache.ts's isNpmAuditCommand/isNpmOutdatedCommand, but that fingerprinting never actually ran outside their own unit tests until this entry, since neither subcommand was recognized by isBuildCommand (the generic cache-reachability gate in hooks_bash.ts). `npm install`/`npm ci`/`npm list`/`npm ls` are deliberately left out — see the negative-case test in lang_patterns.test.ts.
+  // npm audit / npm outdated — read-only reporting commands with no side effects, safe to cache/recall. Each resolves a `lockfile`-scoped fingerprint via bash_output_cache.ts's isNpmAuditCommand/isNpmOutdatedCommand, but that fingerprinting never actually ran outside their own unit tests until this entry, since neither subcommand was recognized by isBuildCommand (the generic cache-reachability gate in hooks_bash.ts and hooks_bash_post.ts). `npm install`/`npm ci`/`npm list`/`npm ls` are deliberately left out — see the negative-case test in lang_patterns.test.ts.
   /^\s*npm\s+(audit|outdated)\b/i,
   // Poetry
   /^\s*poetry\s+(install|update)\b/i,
@@ -225,6 +431,8 @@ var TEST_RUNNER_COMMAND_PATTERNS = [
   /^go test(?:\s|$)/i,
   // Rust / Cargo
   /^cargo test(?:\s|$)/i,
+  // dotnet test
+  /^\s*dotnet\s+test(?:\s|$)/i,
   // npm test / npm run test
   /^npm (?:test|run test)(?:\s|$)/i,
   // yarn test / yarn run test / pnpm test / pnpm run test
@@ -233,6 +441,20 @@ var TEST_RUNNER_COMMAND_PATTERNS = [
 function isTestRunnerCommand(cmd) {
   return TEST_RUNNER_COMMAND_PATTERNS.some((re) => re.test(cmd));
 }
+var DEV_SERVER_COMMAND_PATTERNS = [
+  { pattern: /^(?:npx\s+)?next dev/, recallHint: '--tail 30 --grep "error|warn|ready|compiled"' },
+  { pattern: /^(?:npx\s+)?next build/, recallHint: '--grep "error|warn|Failed|\u2713"' },
+  // vite ends at whitespace or the end of the command, not at a word boundary, which a hyphen satisfies: vite-node is another tool, so it is neither recalled nor fingerprinted as a dev server.
+  { pattern: /^(?:npx\s+)?vite(?:\s|$)/, recallHint: '--tail 20 --grep "error|warn|ready"' },
+  // nuxt dev ends the same way: `nuxt devtools enable` is another nuxt command.
+  { pattern: /^(?:npx\s+)?nuxt dev(?:\s|$)/, recallHint: '--tail 30 --grep "error|warn|ready"' },
+  { pattern: /^(?:npx\s+)?remix dev/, recallHint: '--tail 20 --grep "error|warn|ready"' },
+  { pattern: /^(?:npx\s+)?astro dev/, recallHint: '--tail 20 --grep "error|warn|ready"' }
+];
+function isDevServerCommand(cmd) {
+  const trimmed = cmd.trim();
+  return DEV_SERVER_COMMAND_PATTERNS.some(({ pattern }) => pattern.test(trimmed));
+}
 var MONITORING_COMMAND_PATTERNS = [
   // GitHub CI
   { pattern: /^gh run (?:watch|view|list)/, recallHint: '--grep "fail|error|pass|\u2713|\u2717|conclusion"' },
@@ -242,16 +464,10 @@ var MONITORING_COMMAND_PATTERNS = [
   { pattern: /^gh pr list/, recallHint: '--grep "OPEN|DRAFT|MERGED|#"' },
   { pattern: /^gh issue view/, recallHint: '--grep "state|title|label|OPEN|CLOSED"' },
   { pattern: /^gh workflow (?:run|list|view)/, recallHint: '--grep "completed|failed|in_progress"' },
-  // Dev servers (Next, Vite, Nuxt, Remix, Astro)
-  { pattern: /^(?:npx\s+)?next dev/, recallHint: '--tail 30 --grep "error|warn|ready|compiled"' },
-  { pattern: /^(?:npx\s+)?next build/, recallHint: '--grep "error|warn|Failed|\u2713"' },
-  { pattern: /^(?:npx\s+)?vite\b(?:\s+dev|\s+build|\s+preview)?/, recallHint: '--tail 20 --grep "error|warn|ready"' },
-  { pattern: /^(?:npx\s+)?nuxt dev/, recallHint: '--tail 30 --grep "error|warn|ready"' },
-  { pattern: /^(?:npx\s+)?remix dev/, recallHint: '--tail 20 --grep "error|warn|ready"' },
-  { pattern: /^(?:npx\s+)?astro dev/, recallHint: '--tail 20 --grep "error|warn|ready"' },
-  // Test watchers
-  { pattern: /^(?:npx\s+)?vitest(?:\s+run|\s+watch)?/, recallHint: '--grep "FAIL|PASS|Error|\u2713|\u2717"' },
-  { pattern: /^(?:npx\s+)?jest(?:\s+--watch)?/, recallHint: '--grep "FAIL|PASS|Error|Tests:"' },
+  ...DEV_SERVER_COMMAND_PATTERNS,
+  // Test watchers. jest and vitest must be followed by whitespace or the end of the command, as in TEST_RUNNER_COMMAND_PATTERNS, not merely by a word boundary: a cached run goes stale only through the git fingerprint isTestRunnerCommand grants, and a longer name (jest-codemods, vitest-preview) is another tool that predicate rejects.
+  { pattern: /^(?:npx\s+)?vitest(?:\s|$)/, recallHint: '--grep "FAIL|PASS|Error|\u2713|\u2717"' },
+  { pattern: /^(?:npx\s+)?jest(?:\s|$)/, recallHint: '--grep "FAIL|PASS|Error|Tests:"' },
   { pattern: /^pytest(?:\s|$)/, recallHint: '--grep "FAILED|PASSED|ERROR|passed|failed"' },
   { pattern: /^(?:cargo\s+test|cargo\s+watch)/, recallHint: '--grep "FAILED|ok|error\\["' },
   { pattern: /^go test/, recallHint: '--grep "FAIL|ok|---"' },
@@ -268,7 +484,8 @@ var MONITORING_COMMAND_PATTERNS = [
   { pattern: /^(?:npx\s+)?prettier(?:\s|$)/, recallHint: '--grep "unchanged|reformatted|error"' },
   { pattern: /^npx\s+tsc(?:\s|$)/, recallHint: '--grep "error TS|Cannot find|Type "' },
   { pattern: /^ruff(?:\s|$)/, recallHint: '--grep "error|warning|Found"' },
-  { pattern: /^(?:cargo\s+)?clippy/, recallHint: '--grep "error\\[|warning\\["' },
+  // Ends the same way: clippy-driver is clippy's rustc wrapper, run without cargo, so isBuildCommand gives it no fingerprint to go stale by.
+  { pattern: /^(?:cargo\s+)?clippy(?:\s|$)/, recallHint: '--grep "error\\[|warning\\["' },
   // git diff (full diff output — can be very large; excludes --stat which is small)
   { pattern: /^git diff(?!\s+--stat)(?:\s+HEAD)?(?:\s|$)/, recallHint: '--grep "@@|\\+\\+\\+|---|diff --git"' },
   { pattern: /^git diff\s+--cached(?!\s+--stat)/, recallHint: '--grep "@@|\\+\\+\\+|---|diff --git"' },
@@ -318,16 +535,46 @@ function getMonitoringRecallHint(cmd) {
   return null;
 }
 
+// src/git_porcelain.ts
+init_define_import_meta_env();
+function parsePorcelainZ(stdout) {
+  const fields = stdout.split("\0");
+  const out = [];
+  for (let i = 0; i < fields.length; i++) {
+    const field = fields[i] ?? "";
+    if (field.length < 4) continue;
+    const entry = { path: field.slice(3) };
+    if (field.startsWith("??")) entry.untracked = true;
+    if (/[RC]/.test(field.slice(0, 2))) {
+      i++;
+      const orig = fields[i];
+      if (orig !== void 0 && orig !== "") entry.origPath = orig;
+    }
+    out.push(entry);
+  }
+  return out;
+}
+
 // src/recall_index.ts
 init_define_import_meta_env();
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
+
+// src/snippet_window.ts
+init_define_import_meta_env();
+function snippetAround(text, idx, maxLen) {
+  const start = Math.max(0, idx - Math.floor(maxLen / 3));
+  const end = Math.min(text.length, start + maxLen);
+  return (start > 0 ? "..." : "") + text.slice(start, end) + (end < text.length ? "..." : "");
+}
+
+// src/recall_index.ts
 function subdirForCacheType(cacheType) {
   return cacheType === "web" ? "web_outputs" : "bash_outputs";
 }
 function blobStillExists(cacheType, id) {
   try {
     const p = blobPath(subdirForCacheType(cacheType), id);
-    return p !== null && fs.existsSync(p);
+    return p !== null && fs2.existsSync(p);
   } catch {
     return false;
   }
@@ -347,7 +594,8 @@ function indexRecallEntry(cacheType, id, label, content, storedAt) {
          label = excluded.label,
          content = excluded.content,
          stored_at = excluded.stored_at`
-    ).run({ cacheType, id, label, content, storedAt });
+      // Stripped so a query spanning a colour boundary matches the text a reader sees; the cached blob itself stays raw.
+    ).run({ cacheType, id, label: stripAnsiEscapes(label), content: stripAnsiEscapes(content), storedAt });
   } catch {
   }
   pruneCacheRecallRows();
@@ -364,7 +612,7 @@ var _ftsAvailable = null;
 function hasFtsTable() {
   if (_ftsAvailable !== null) return _ftsAvailable;
   try {
-    const db = getDb(globalDbPath());
+    const db = getReadDb(globalDbPath());
     const row = db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cache_recall_fts'`).get();
     _ftsAvailable = row !== void 0;
   } catch {
@@ -373,7 +621,7 @@ function hasFtsTable() {
   return _ftsAvailable;
 }
 function buildSnippet(content, query, maxLen = 160) {
-  const flat = content.replace(/\s+/g, " ").trim();
+  const flat = stripAnsiEscapes(content).replace(/\s+/g, " ").trim();
   const tokens = query.split(/\s+/).filter(Boolean);
   let idx = -1;
   const lowerFlat = flat.toLowerCase();
@@ -384,14 +632,7 @@ function buildSnippet(content, query, maxLen = 160) {
       break;
     }
   }
-  if (idx === -1) {
-    return flat.length > maxLen ? flat.slice(0, maxLen) + "..." : flat;
-  }
-  const start = Math.max(0, idx - Math.floor(maxLen / 3));
-  const end = Math.min(flat.length, start + maxLen);
-  const prefix = start > 0 ? "..." : "";
-  const suffix = end < flat.length ? "..." : "";
-  return prefix + flat.slice(start, end) + suffix;
+  return snippetAround(flat, Math.max(0, idx), maxLen);
 }
 function toFtsMatchExpr(query) {
   if (query.trim().length === 0) return null;
@@ -410,7 +651,7 @@ function mapRowsToHits(rows, snippetQuery) {
 function ftsSearch(query, type, limit) {
   const matchExpr = toFtsMatchExpr(query);
   if (matchExpr === null) return [];
-  const db = getDb(globalDbPath());
+  const db = getReadDb(globalDbPath());
   const rows = type !== void 0 ? db.prepare(
     `SELECT c.entry_id AS id, c.cache_type AS cacheType, c.label AS label, c.content AS content, c.stored_at AS storedAt
              FROM cache_recall_fts
@@ -431,7 +672,7 @@ function ftsSearch(query, type, limit) {
 function likeSearch(query, type, limit) {
   const trimmed = query.trim();
   if (!trimmed) return [];
-  const db = getDb(globalDbPath());
+  const db = getReadDb(globalDbPath());
   const needle = `%${trimmed.replace(/\\/g, "\\\\").replace(/[%_]/g, (c) => `\\${c}`)}%`;
   const rows = type !== void 0 ? db.prepare(
     `SELECT entry_id AS id, cache_type AS cacheType, label, content, stored_at AS storedAt
@@ -452,7 +693,7 @@ function listRecentRecall(opts = {}) {
   const limit = opts.limit ?? RECALL_DEFAULT_LIMIT;
   const columns = `SELECT entry_id AS id, cache_type AS cacheType, label, content, stored_at AS storedAt FROM cache_recall`;
   try {
-    const db = getDb(globalDbPath());
+    const db = getReadDb(globalDbPath());
     const rows = opts.type !== void 0 ? db.prepare(`${columns} WHERE cache_type = ? ORDER BY stored_at DESC LIMIT ?`).all(opts.type, limit) : db.prepare(`${columns} ORDER BY stored_at DESC LIMIT ?`).all(limit);
     return mapRowsToHits(rows, "");
   } catch {
@@ -476,401 +717,29 @@ function searchRecall(query, opts = {}) {
   }
 }
 
-// src/bash_output_cache.ts
-var BASH_OUTPUT_SUBDIR = "bash_outputs";
-var _byId = /* @__PURE__ */ new Map();
-var COMMAND_PATTERNS = {
-  gitMutable: /^\s*git\s+(diff|status)\b/i,
-  gitImmutable: /^\s*git\s+show\s+[0-9a-f]{40}\b/i,
-  gitDiffScoped: /\s--\s+\S/,
-  dirListing: /^\s*(?:ls|eza|exa|dir|Get-ChildItem|gci)\b/i,
-  depList: /^\s*(?:npm\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:ls|list)\b|pip\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:list|freeze)\b|uv\s+pip\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:list|freeze)\b|pnpm\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:list|ls)\b|yarn\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:list)\b|cargo\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*tree\b|bundle\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:list|show)\b|composer\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*show\b)/i,
-  npmInstall: /^\s*npm\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:install|ci)\b/i,
-  npmAudit: /^\s*npm\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*audit\b(?!.*(?:--fix|fix)\b)/i,
-  npmOutdated: /^\s*npm\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*outdated\b/i,
-  envProbe: /^\s*(?:node\s+(?:-v|--version)|npm\s+(?:-v|--version)|python3?\s+(?:(?:-V)\b|--?version)|git\s+--version|uv\s+--version|go\s+version|rustc\s+--version|cargo\s+--version|java\s+--version|ruby\s+--version|gem\s+--version|php\s+--version|which\b|where\b)/i,
-  npx: /^(?!.*\b(?:install|add|remove|uninstall|i|rm|update|upgrade|set|get|publish|link|ci|audit|shrinkwrap|dedupe|prune|rebuild)\b)\s*npx\s+(?:--?yes\s+)?/i,
-  gitPush: /^\s*git\s+push\b/i,
-  testRunner: /^\s*(?:npx\s+)?(?:pytest|vitest|jest|go\s+test)\b/i,
-  lintCommand: /^\s*(?:(?:npx\s+)?eslint|(?:uv\s+run\s+)?ruff)\b/i,
-  npmRunScript: /^\s*npm\s+run(?:-script)?\b/i,
-  catCommand: /^\s*cat\b/i
-};
-var DEP_LOCKFILES = {
-  npm: ["package-lock.json", "yarn.lock"],
-  pip: ["requirements.txt"],
-  uv: ["uv.lock", "requirements.txt"],
-  pnpm: ["pnpm-lock.yaml"],
-  yarn: ["yarn.lock"],
-  cargo: ["Cargo.lock"],
-  bundle: ["Gemfile.lock"],
-  composer: ["composer.lock"]
-};
-function isCommandOfType(cmd, type) {
-  const pattern = COMMAND_PATTERNS[type];
-  return pattern?.test(cmd) ?? false;
-}
-var isGitMutableCommand = (cmd) => isCommandOfType(cmd, "gitMutable");
-var isDirListingCommand = (cmd) => isCommandOfType(cmd, "dirListing");
-var isDepListCommand = (cmd) => isCommandOfType(cmd, "depList");
-var isNpmInstallCommand = (cmd) => isCommandOfType(cmd, "npmInstall");
-var isNpmAuditCommand = (cmd) => isCommandOfType(cmd, "npmAudit");
-var isNpmOutdatedCommand = (cmd) => isCommandOfType(cmd, "npmOutdated");
-var isGitPushCommand = (cmd) => isCommandOfType(cmd, "gitPush");
-var isTestRunnerCommand2 = (cmd) => isCommandOfType(cmd, "testRunner");
-var isLintCommand = (cmd) => isCommandOfType(cmd, "lintCommand");
-var isNpmRunScriptCommand = (cmd) => isCommandOfType(cmd, "npmRunScript");
-var isCatCommand = (cmd) => isCommandOfType(cmd, "catCommand");
-function isScopedGitStatusOrDiffStatCommand(cmd) {
-  if (!isCommandOfType(cmd, "gitMutable")) return false;
-  if (!isCommandOfType(cmd, "gitDiffScoped")) return false;
-  if (/^\s*git\s+diff\b/i.test(cmd) && !/--stat\b/.test(cmd)) return false;
-  return true;
-}
-function gitStateFingerprintSync(cwd) {
-  try {
-    const headResult = runGit(["rev-parse", "HEAD"], { cwd });
-    if (headResult.exitCode !== 0) return null;
-    const headSha = headResult.stdout.trim();
-    let statusHash = "";
-    const statusResult = runGit(["status", "--porcelain"], { cwd });
-    if (statusResult.exitCode === 0) {
-      statusHash = shortFingerprint(statusResult.stdout);
-    }
-    const key = `${headSha}\0${statusHash}`;
-    return shortFingerprint(key);
-  } catch {
-    return null;
-  }
-}
-var DIR_FINGERPRINT_LISTING_CAP_ENTRIES = 1e4;
-function dirStateFingerprintSync(path) {
-  try {
-    const stat = statSync(path);
-    if (!stat.isDirectory()) return null;
-    const entries = readdirSync(path);
-    if (entries.length <= DIR_FINGERPRINT_LISTING_CAP_ENTRIES) {
-      return shortFingerprint(entries.slice().sort().join("\0"));
-    }
-    return shortFingerprint(stat.mtimeMs.toString());
-  } catch {
-    return null;
-  }
-}
-var FILE_FINGERPRINT_CONTENT_CAP_BYTES = 2 * 1024 * 1024;
-function fileStateFingerprintSync(path) {
-  try {
-    const stat = statSync(path);
-    if (!stat.isFile()) return null;
-    if (stat.size <= FILE_FINGERPRINT_CONTENT_CAP_BYTES) {
-      return shortFingerprint(readFileSync(path));
-    }
-    return shortFingerprint(`${stat.mtimeMs}\0${stat.size}`);
-  } catch {
-    return null;
-  }
-}
-function depLockfileFingerprintSync(cmd, cwd) {
-  if (!cwd) return null;
-  const stripped = cmd.trim();
-  const firstToken = stripped.split(/\s+/)[0]?.toLowerCase() || "";
-  if (!firstToken) return null;
-  const candidates = firstToken === "uv" ? DEP_LOCKFILES["uv"] : DEP_LOCKFILES[firstToken];
-  if (!candidates) return null;
-  for (const lockfile of candidates) {
-    try {
-      const content = readFileSync(resolve(cwd, lockfile));
-      return shortFingerprint(content);
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-function normalizeCommandForCacheKey(cmd) {
-  const trimmed = cmd.trim();
-  const tokens = [];
-  let current = "";
-  let quoteChar = null;
-  const flush = () => {
-    if (current.length > 0) {
-      tokens.push(current);
-      current = "";
-    }
-  };
-  for (let i = 0; i < trimmed.length; i++) {
-    const ch = trimmed[i];
-    if (quoteChar !== null) {
-      current += ch;
-      if (ch === quoteChar) quoteChar = null;
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      quoteChar = ch;
-      current += ch;
-      continue;
-    }
-    if (/\s/.test(ch)) {
-      flush();
-      continue;
-    }
-    current += ch === "\\" ? "/" : ch;
-  }
-  flush();
-  const normalized_tokens = tokens.map((token) => {
-    if (token.startsWith("-") || ["&&", "||", "|", ">", ">>", ";", "&"].includes(token)) {
-      return token;
-    }
-    if (token.startsWith("./") && !token.startsWith("../")) {
-      token = token.slice(2);
-    }
-    if (token.endsWith("/") && token !== "/") {
-      token = token.slice(0, -1);
-    }
-    return token || ".";
-  });
-  return normalized_tokens.join(" ");
-}
-function commandHashSync(command, cwd = null) {
-  const normalized = normalizeCommandForCacheKey(command);
-  let key = cwd ? `${normalizePath(cwd)}\0${normalized}` : normalized;
-  if (cwd && isGitMutableCommand(command)) {
-    const fp = gitStateFingerprintSync(cwd);
-    if (fp) key = `${key}\0git:${fp}`;
-  }
-  if (cwd && isDirListingCommand(command)) {
-    const target = extractFirstPathArg(command, cwd, cwd);
-    if (target) {
-      const fp = dirStateFingerprintSync(target);
-      if (fp) key = `${key}\0dir:${fp}`;
-    }
-  }
-  if (isDepListCommand(command)) {
-    const fp = depLockfileFingerprintSync(command, cwd);
-    if (fp) key = `${key}\0lockfile:${fp}`;
-  }
-  if (cwd && (isNpmInstallCommand(command) || isNpmAuditCommand(command) || isNpmOutdatedCommand(command))) {
-    const fp = depLockfileFingerprintSync(command, cwd);
-    if (fp) key = `${key}\0npm-install:${fp}`;
-  }
-  return shortFingerprint(key);
-}
-function commandHash(command, cwd = null) {
-  return Promise.resolve(commandHashSync(command, cwd));
-}
-function bashOutputIdSync(command, output, cwd = null) {
-  return shortFingerprint(`${commandHashSync(command, cwd)}\0${output}`);
-}
-function computeBashFingerprints(command, cwd) {
-  const fingerprints = {};
-  if (cwd && (isGitMutableCommand(command) || isGitPushCommand(command) || isTestRunnerCommand2(command) || isLintCommand(command) || isBuildCommand(command) || isNpmRunScriptCommand(command))) {
-    const fp = gitStateFingerprintSync(cwd);
-    if (fp) fingerprints.git = fp;
-  }
-  if (cwd && isDirListingCommand(command)) {
-    const target = extractFirstPathArg(command, cwd, cwd);
-    if (target) {
-      const fp = dirStateFingerprintSync(target);
-      if (fp) fingerprints.dir = fp;
-    }
-  }
-  if (isDepListCommand(command) || cwd && (isNpmInstallCommand(command) || isNpmAuditCommand(command) || isNpmOutdatedCommand(command))) {
-    const fp = depLockfileFingerprintSync(command, cwd);
-    if (fp) fingerprints.lockfile = fp;
-  }
-  if (cwd && isCatCommand(command)) {
-    const target = extractFirstPathArg(command, cwd, null);
-    if (target) {
-      const fp = fileStateFingerprintSync(target);
-      if (fp) fingerprints.file = fp;
-    }
-  }
-  return Object.keys(fingerprints).length > 0 ? fingerprints : void 0;
-}
-function isBashEntryStale(entry, command, cwd) {
-  const stored = entry.fingerprints;
-  if (!stored) return false;
-  const current = computeBashFingerprints(command, cwd);
-  if (stored.git !== void 0 && stored.git !== current?.git) return true;
-  if (stored.dir !== void 0 && stored.dir !== current?.dir) return true;
-  if (stored.lockfile !== void 0 && stored.lockfile !== current?.lockfile) return true;
-  if (stored.file !== void 0 && stored.file !== current?.file) return true;
-  return false;
-}
-function tokenizeShellArgs(cmd) {
-  const trimmed = cmd.trim();
-  const tokens = [];
-  let current = "";
-  let quoteChar = null;
-  let hasToken = false;
-  for (let i = 0; i < trimmed.length; i++) {
-    const ch = trimmed[i];
-    if (quoteChar !== null) {
-      if (ch === quoteChar) {
-        quoteChar = null;
-      } else {
-        current += ch;
-      }
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      quoteChar = ch;
-      hasToken = true;
-      continue;
-    }
-    if (/\s/.test(ch)) {
-      if (hasToken) {
-        tokens.push(current);
-        current = "";
-        hasToken = false;
-      }
-      continue;
-    }
-    current += ch;
-    hasToken = true;
-  }
-  if (hasToken) tokens.push(current);
-  return tokens;
-}
-function extractFirstPathArg(cmd, cwd, fallback) {
-  const tokens = tokenizeShellArgs(cmd);
-  for (let i = 1; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (!token.startsWith("-")) {
-      if (!token.startsWith("/")) {
-        return resolve(cwd, token);
-      }
-      return token;
-    }
-  }
-  return fallback;
-}
-var ISSUE_LINE_PATTERN = /\b(?:error|fail(?:ed|ure)?|warning)\b/i;
-function summarizeOutputDelta(oldOutput, newOutput) {
-  if (oldOutput === newOutput) return null;
-  const oldLines = oldOutput.split("\n");
-  const newLines = newOutput.split("\n");
-  const oldIssueLines = oldLines.filter((l) => ISSUE_LINE_PATTERN.test(l));
-  if (oldIssueLines.length > 0) {
-    const newIssueLines = newLines.filter((l) => ISSUE_LINE_PATTERN.test(l));
-    const priorTotal = oldIssueLines.length;
-    const availableCounts = /* @__PURE__ */ new Map();
-    for (const l of newIssueLines) availableCounts.set(l, (availableCounts.get(l) ?? 0) + 1);
-    let resolved = 0;
-    for (const l of oldIssueLines) {
-      const avail = availableCounts.get(l) ?? 0;
-      if (avail > 0) {
-        availableCounts.set(l, avail - 1);
-      } else {
-        resolved++;
-      }
-    }
-    const remaining = newIssueLines.length;
-    return `[token-goat: delta] ${resolved} of ${priorTotal} prior issues resolved; remaining: ${remaining}`;
-  }
-  return `[token-goat: delta] output changed: ${oldLines.length} -> ${newLines.length} lines`;
-}
-function storeBashOutputSync(command, output, exitCode, cwd = null) {
-  const id = bashOutputIdSync(command, output, cwd);
-  const commandKey = commandHashSync(command, cwd);
-  const fingerprints = computeBashFingerprints(command, cwd);
-  const redactedOutput = redactSecrets(output).text;
-  const redactedCommand = redactSecrets(command).text;
-  const entry = {
-    id,
-    command: redactedCommand,
-    output: redactedOutput,
-    exitCode,
-    storedAt: Date.now(),
-    sizeBytes: Buffer.byteLength(redactedOutput, "utf-8"),
-    ...fingerprints ? { fingerprints } : {}
-  };
-  _byId.set(id, entry);
-  _byId.set(commandKey, entry);
-  storeBlob(BASH_OUTPUT_SUBDIR, id, entry);
-  if (commandKey !== id) storeBlob(BASH_OUTPUT_SUBDIR, commandKey, { latestId: id });
-  indexRecallEntry("bash", id, redactedCommand, `${redactedCommand}
-${redactedOutput}`, entry.storedAt);
-  return id;
-}
-function coerceBashRedirect(raw) {
-  if (raw === null || typeof raw !== "object") return null;
-  const latest = raw["latestId"];
-  return typeof latest === "string" && latest.length > 0 ? latest : null;
-}
-function storeBashOutput(command, output, exitCode, cwd = null) {
-  return Promise.resolve(storeBashOutputSync(command, output, exitCode, cwd));
-}
-function coerceBashEntry(raw) {
-  if (raw === null || typeof raw !== "object") return null;
-  const o = raw;
-  if (typeof o["id"] !== "string" || typeof o["command"] !== "string" || typeof o["output"] !== "string" || typeof o["exitCode"] !== "number" || typeof o["storedAt"] !== "number" || typeof o["sizeBytes"] !== "number") {
-    return null;
-  }
-  const entry = {
-    id: o["id"],
-    command: o["command"],
-    output: o["output"],
-    exitCode: o["exitCode"],
-    storedAt: o["storedAt"],
-    sizeBytes: o["sizeBytes"]
-  };
-  const rawFingerprints = o["fingerprints"];
-  if (rawFingerprints !== null && typeof rawFingerprints === "object") {
-    const f = rawFingerprints;
-    const fingerprints = {};
-    if (typeof f["git"] === "string") fingerprints.git = f["git"];
-    if (typeof f["dir"] === "string") fingerprints.dir = f["dir"];
-    if (typeof f["lockfile"] === "string") fingerprints.lockfile = f["lockfile"];
-    if (typeof f["file"] === "string") fingerprints.file = f["file"];
-    if (Object.keys(fingerprints).length > 0) return { ...entry, fingerprints };
-  }
-  return entry;
-}
-function getBashOutput(id) {
-  const hit = _byId.get(id);
-  if (hit !== void 0) return hit;
-  if (isBlobStale(BASH_OUTPUT_SUBDIR, id)) return null;
-  const raw = loadBlob(BASH_OUTPUT_SUBDIR, id);
-  const target = coerceBashRedirect(raw);
-  if (target !== null) {
-    if (isBlobStale(BASH_OUTPUT_SUBDIR, target)) return null;
-    const latest = coerceBashEntry(loadBlob(BASH_OUTPUT_SUBDIR, target));
-    if (latest === null) return null;
-    _byId.set(target, latest);
-    _byId.set(id, latest);
-    return latest;
-  }
-  const entry = coerceBashEntry(raw);
-  if (entry === null) return null;
-  _byId.set(id, entry);
-  return entry;
-}
-registerReset(() => {
-  _byId = /* @__PURE__ */ new Map();
-}, { perRequest: true });
-
 export {
+  parsePorcelainZ,
+  DEFAULT_MAX_COUNT,
+  DEFAULT_MAX_AGE_MS,
+  blobPath,
+  isBlobStale,
+  storeBlob,
+  loadBlob,
+  listBlobs,
+  pruneBlobs,
+  sweepCacheRoots,
   isLockFile,
   isManifestFile,
   isInBuildDir,
   isGeneratedFile,
   isBuildCommand,
   isTestRunnerCommand,
+  isDevServerCommand,
   getMonitoringRecallHint,
+  snippetAround,
   RECALL_DEFAULT_LIMIT,
   isRecallCacheType,
   indexRecallEntry,
   listRecentRecall,
-  searchRecall,
-  BASH_OUTPUT_SUBDIR,
-  isScopedGitStatusOrDiffStatCommand,
-  normalizeCommandForCacheKey,
-  commandHash,
-  bashOutputIdSync,
-  isBashEntryStale,
-  summarizeOutputDelta,
-  storeBashOutputSync,
-  storeBashOutput,
-  getBashOutput
+  searchRecall
 };