token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-KQBLRPBN.mjs

@@ -0,0 +1,433 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  indexRecallEntry,
+  isBlobStale,
+  isBuildCommand,
+  isDevServerCommand,
+  isTestRunnerCommand,
+  loadBlob,
+  parsePorcelainZ,
+  storeBlob
+} from "./token-goat-chunk-4ZBFWLXF.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  shortFingerprint
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import {
+  runGit
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  normalizePath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/bash_output_cache.ts
+init_define_import_meta_env();
+import { readdirSync, readFileSync, statSync } from "fs";
+import { resolve } from "path";
+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,
+  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 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;
+}
+var STATUS_STAT_CAP = 2e3;
+function statusPathStats(root, porcelainZ) {
+  const out = [];
+  for (const { path: rel } of parsePorcelainZ(porcelainZ).slice(0, STATUS_STAT_CAP)) {
+    const st = statSync(resolve(root, rel), { throwIfNoEntry: false });
+    out.push(st ? `${rel}:${st.mtimeMs}:${st.size}` : `${rel}:-`);
+  }
+  return out.join("\0");
+}
+function gitStateFingerprintSync(cwd) {
+  try {
+    const headResult = runGit(["rev-parse", "--show-toplevel", "HEAD"], { cwd });
+    if (headResult.exitCode !== 0) return null;
+    const [root = "", headSha = ""] = headResult.stdout.trim().split(/\r?\n/);
+    let statusHash = "";
+    const statusResult = runGit(["status", "--porcelain", "-z", "--untracked-files=all"], { cwd });
+    if (statusResult.exitCode === 0) {
+      statusHash = shortFingerprint(`${statusResult.stdout}\0${statusPathStats(root, 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, gitState = () => cwd ? gitStateFingerprintSync(cwd) : null) {
+  const normalized = normalizeCommandForCacheKey(command);
+  let key = cwd ? `${normalizePath(cwd)}\0${normalized}` : normalized;
+  if (cwd && isGitMutableCommand(command)) {
+    const fp = gitState();
+    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 outputIdFromCommandHash(commandHashSync(command, cwd), output);
+}
+function outputIdFromCommandHash(commandKey, output) {
+  return shortFingerprint(`${commandKey}\0${output}`);
+}
+function computeBashFingerprints(command, cwd, gitState = () => cwd ? gitStateFingerprintSync(cwd) : null) {
+  const fingerprints = {};
+  if (cwd && (isGitMutableCommand(command) || isGitPushCommand(command) || isTestRunnerCommand(command) || isLintCommand(command) || isBuildCommand(command) || isDevServerCommand(command) || isNpmRunScriptCommand(command))) {
+    const fp = gitState();
+    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) {
+  let gitState = null;
+  const gitStateOnce = () => (gitState ??= { value: cwd ? gitStateFingerprintSync(cwd) : null }).value;
+  const commandKey = commandHashSync(command, cwd, gitStateOnce);
+  const id = outputIdFromCommandHash(commandKey, output);
+  const fingerprints = computeBashFingerprints(command, cwd, gitStateOnce);
+  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 {
+  BASH_OUTPUT_SUBDIR,
+  isLintCommand,
+  isScopedGitStatusOrDiffStatCommand,
+  normalizeCommandForCacheKey,
+  commandHash,
+  bashOutputIdSync,
+  isBashEntryStale,
+  summarizeOutputDelta,
+  storeBashOutputSync,
+  storeBashOutput,
+  getBashOutput
+};