token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-4ADZHI7J.mjs

@@ -0,0 +1,63 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  INSTALL_INDEX_ENV,
+  formatInstallIndexResult,
+  queueInstallIndex
+} from "./token-goat-chunk-UZOROKIS.mjs";
+import "./token-goat-chunk-M3LFJDPU.mjs";
+import "./token-goat-chunk-ZNMNUPAZ.mjs";
+import "./token-goat-chunk-PFWIMH2E.mjs";
+import "./token-goat-chunk-OBOFIHKN.mjs";
+import "./token-goat-chunk-QH7YVYOY.mjs";
+import "./token-goat-chunk-NOSS5VWY.mjs";
+import "./token-goat-chunk-NMD42SFQ.mjs";
+import "./token-goat-chunk-SAMFDIS2.mjs";
+import "./token-goat-chunk-4SMRO4TO.mjs";
+import "./token-goat-chunk-WBA5SKT4.mjs";
+import "./token-goat-chunk-MNWKPRAL.mjs";
+import "./token-goat-chunk-CIMQ2BB3.mjs";
+import "./token-goat-chunk-WDH44VAU.mjs";
+import "./token-goat-chunk-BPGCUMR7.mjs";
+import "./token-goat-chunk-KQBLRPBN.mjs";
+import "./token-goat-chunk-4ZBFWLXF.mjs";
+import "./token-goat-chunk-C75NA7PL.mjs";
+import "./token-goat-chunk-P6VGNTQT.mjs";
+import "./token-goat-chunk-76FGDLRO.mjs";
+import "./token-goat-chunk-GL3ETKSC.mjs";
+import "./token-goat-chunk-OXFMP75N.mjs";
+import "./token-goat-chunk-NISNMD7T.mjs";
+import "./token-goat-chunk-EVMZJ27Z.mjs";
+import "./token-goat-chunk-IK2DRMFX.mjs";
+import "./token-goat-chunk-5Y6ZYL6U.mjs";
+import "./token-goat-chunk-U4WHMG6Y.mjs";
+import "./token-goat-chunk-GVB2MUST.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
+import "./token-goat-chunk-OUKDTVNU.mjs";
+import "./token-goat-chunk-3BTK54F3.mjs";
+import "./token-goat-chunk-4GILLLWY.mjs";
+import "./token-goat-chunk-BFCWY73P.mjs";
+import "./token-goat-chunk-KGEFFSHD.mjs";
+import "./token-goat-chunk-XX6O25RN.mjs";
+import "./token-goat-chunk-HAVAOB3S.mjs";
+import "./token-goat-chunk-F6PAUIEK.mjs";
+import "./token-goat-chunk-65N4RHP4.mjs";
+import "./token-goat-chunk-X2SUP3EI.mjs";
+import "./token-goat-chunk-T5P5ACNQ.mjs";
+import "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import "./token-goat-chunk-4GBVPH3D.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  INSTALL_INDEX_ENV,
+  formatInstallIndexResult,
+  queueInstallIndex
+};

package/dist/token-goat-chunk-4GBVPH3D.mjs

@@ -0,0 +1,242 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  registerReset
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import {
+  extractErrorMessage,
+  runGit
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  canonicalize,
+  foldPath
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  normalizeDarwinSystemAlias
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/fingerprint.ts
+init_define_import_meta_env();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+function fingerprintContent(content) {
+  const hash = createHash("sha256");
+  hash.update(typeof content === "string" ? Buffer.from(content, "utf-8") : content);
+  return hash.digest("hex");
+}
+function shortFingerprint(content) {
+  return fingerprintContent(content).slice(0, 16);
+}
+function indexedFileIsGone(filePath) {
+  return statIndexedFile(filePath) === "gone";
+}
+function statIndexedFile(filePath) {
+  try {
+    const st = fs.statSync(filePath);
+    return st.isFile() ? st : "gone";
+  } catch (err) {
+    const code = err?.code;
+    return code === "ENOENT" || code === "ENOTDIR" ? "gone" : null;
+  }
+}
+function fingerprintFile(filePath) {
+  let data;
+  try {
+    data = fs.readFileSync(filePath);
+  } catch {
+    return null;
+  }
+  return fingerprintContent(data);
+}
+function fileIsAbsent(filePath) {
+  try {
+    return fs.statSync(filePath, { throwIfNoEntry: false }) === void 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/project.ts
+init_define_import_meta_env();
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "shopify.app.toml",
+  "_config.yml",
+  "deno.json",
+  "deno.jsonc"
+];
+var REPO_CONTAINER_THRESHOLD = 3;
+function projectHash(canonicalRoot) {
+  return shortFingerprint(foldPath(canonicalRoot));
+}
+function makeProjectAt(root) {
+  let canonical;
+  try {
+    canonical = canonicalize(root);
+  } catch (exc) {
+    throw new Error(
+      `makeProjectAt: could not resolve path: ${extractErrorMessage(exc)}`,
+      { cause: exc }
+    );
+  }
+  try {
+    const stat = fs2.statSync(canonical);
+    if (!stat.isDirectory()) {
+      throw new Error(`makeProjectAt: path is not a directory: ${canonical}`);
+    }
+  } catch (exc) {
+    if (exc instanceof Error && exc.message.includes("ENOENT")) {
+      throw new Error(`makeProjectAt: path does not exist: ${canonical}`, { cause: exc });
+    }
+    throw exc;
+  }
+  const hash = projectHash(canonical);
+  return { root: canonical, hash, marker: "manual" };
+}
+function isRepoContainer(pathStr) {
+  let nestedRepos = 0;
+  try {
+    const entries = fs2.readdirSync(pathStr, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const gitPath = path.join(pathStr, entry.name, ".git");
+        if (fs2.existsSync(gitPath)) {
+          let isGitDir = false;
+          try {
+            isGitDir = fs2.statSync(gitPath).isDirectory();
+          } catch {
+          }
+          if (isGitDir) {
+            nestedRepos++;
+            if (nestedRepos >= REPO_CONTAINER_THRESHOLD) {
+              return true;
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+function markerExists(current, marker) {
+  const markerPath = path.join(current, marker);
+  try {
+    if (!fs2.existsSync(markerPath)) {
+      return false;
+    }
+    const stat = fs2.lstatSync(markerPath);
+    if (!stat.isSymbolicLink()) {
+      return true;
+    }
+    const resolved = fs2.realpathSync(markerPath);
+    const rel = path.relative(path.resolve(current), path.resolve(resolved));
+    return !rel.startsWith("..") && !path.isAbsolute(rel);
+  } catch {
+    return false;
+  }
+}
+function findProject(cwd) {
+  let p;
+  try {
+    p = canonicalize(cwd);
+  } catch {
+    return null;
+  }
+  let sysTemp = null;
+  try {
+    sysTemp = canonicalize(os.tmpdir());
+  } catch {
+  }
+  let current = p;
+  while (true) {
+    if (sysTemp && normalizeDarwinSystemAlias(foldPath(current)) === normalizeDarwinSystemAlias(foldPath(sysTemp))) {
+      break;
+    }
+    for (const marker of PROJECT_MARKERS) {
+      if (markerExists(current, marker)) {
+        if (!isRepoContainer(current)) {
+          return {
+            root: current,
+            hash: projectHash(current),
+            marker
+          };
+        }
+        break;
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+var _displayRootCache = null;
+function getDisplayRoot(explicitRoot) {
+  if (explicitRoot !== void 0) return explicitRoot;
+  const cwd = process.cwd();
+  if (_displayRootCache !== null && _displayRootCache.cwd === cwd) return _displayRootCache.root;
+  const project = findProject(cwd);
+  const root = project !== null ? project.root : void 0;
+  _displayRootCache = { cwd, root };
+  return root;
+}
+registerReset(() => {
+  _displayRootCache = null;
+}, { perRequest: true });
+function isUnderSystemTemp(filePath) {
+  let sysTemp;
+  try {
+    sysTemp = canonicalize(os.tmpdir());
+  } catch {
+    return false;
+  }
+  let target;
+  try {
+    target = canonicalize(filePath);
+  } catch {
+    return false;
+  }
+  const foldedTemp = normalizeDarwinSystemAlias(foldPath(sysTemp));
+  const foldedTarget = normalizeDarwinSystemAlias(foldPath(target));
+  return foldedTarget === foldedTemp || foldedTarget.startsWith(`${foldedTemp}/`);
+}
+function resolveProjectRoot(opts) {
+  const base = opts?.project !== void 0 ? path.resolve(opts.project) : process.cwd();
+  const toplevel = runGit(["rev-parse", "--show-toplevel"], { cwd: base });
+  if (toplevel.exitCode === 0) {
+    const trimmed = toplevel.stdout.trim();
+    if (trimmed.length > 0) return canonicalize(trimmed);
+  }
+  const project = findProject(base);
+  if (project !== null) return project.root;
+  return canonicalize(base);
+}
+
+export {
+  fingerprintContent,
+  shortFingerprint,
+  indexedFileIsGone,
+  statIndexedFile,
+  fingerprintFile,
+  fileIsAbsent,
+  projectHash,
+  makeProjectAt,
+  findProject,
+  getDisplayRoot,
+  isUnderSystemTemp,
+  resolveProjectRoot
+};

package/dist/{token-goat-chunk-2WOUYWLM.mjs → token-goat-chunk-4GILLLWY.mjs}

@@ -2,7 +2,10 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   stripAnsiEscapes
-} from "./token-goat-chunk-CIQ2FTY3.mjs";
+} from "./token-goat-chunk-HAVAOB3S.mjs";
+import {
+  countNoun
+} from "./token-goat-chunk-HU4TORC5.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -36,12 +39,24 @@ function clipWideLines(text, maxChars = INPUT_MAX_LINE_CHARS) {
   let clipped = 0;
   const out = text.split("\n").map((line) => {
     if (line.length <= maxChars) return line;
+    const marker = CLIPPED_MARKER_RE.exec(line);
+    if (marker && line.length - marker[0].length <= maxChars) return line;
     clipped += 1;
     const keep = Math.floor(maxChars / 2);
     return line.slice(0, keep) + ` ... [${line.length - maxChars} chars clipped] ... ` + line.slice(line.length - (maxChars - keep));
   });
   return clipped === 0 ? text : out.join("\n");
 }
+function isWholeJsonDocument(text) {
+  const t = text.trim();
+  if (t[0] !== "{" && t[0] !== "[") return false;
+  try {
+    JSON.parse(t);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function clampKeepingEnds(text, maxBytes) {
   const buf = Buffer.from(text, "utf8");
   if (buf.length <= maxBytes) return null;
@@ -195,7 +210,7 @@ function dedupeConsecutive(lines, opts = {}) {
   let count = 0;
   const flush = () => {
     if (prev === null) return;
-    if (count >= minRun) out.push(fmt(prev, count));
+    if (count >= minRun) out.push(prev.trim() === "" ? "" : fmt(prev, count));
     else for (let i = 0; i < count; i++) out.push(prev);
   };
   for (const line of lines) {
@@ -206,7 +221,7 @@ function dedupeConsecutive(lines, opts = {}) {
       out.push(line);
       continue;
     }
-    if (line === prev) {
+    if (line === prev || prev !== null && prev.trim() === "" && line.trim() === "") {
       count += 1;
       continue;
     }
@@ -331,11 +346,11 @@ function capTokens(text, maxTokens) {
   }
   return truncated;
 }
-function headTailCompress(lines, head, tail, label = "items") {
+function headTailCompress(lines, head, tail, noun = "item", plural = `${noun}s`) {
   const total = lines.length;
   if (total <= head + tail) return lines.join("\n");
   const elided = total - head - tail;
-  return [...lines.slice(0, head), `... [${elided} more ${label} elided by token-goat]`, ...lines.slice(total - tail)].join(
+  return [...lines.slice(0, head), `... [${countNoun(elided, `more ${noun}`, `more ${plural}`)} elided by token-goat]`, ...lines.slice(total - tail)].join(
     "\n"
   );
 }
@@ -353,7 +368,7 @@ function truncateTableRows(text, maxRows, hint) {
   for (let i = 0; i < rows.length && wanted.size < maxRows; i++) wanted.add(i);
   const kept = [...wanted].sort((a, b) => a - b);
   const elided = rows.length - kept.length;
-  const note = anomalies ? `[token-goat: ${elided} more rows; ${anomalies} row(s) kept for a not-ready status, the rest from the top; ${hint}]` : `[token-goat: ${elided} more rows; ${hint}]`;
+  const note = anomalies ? `[token-goat: ${countNoun(elided, "more row")}; ${countNoun(anomalies, "row")} kept for a not-ready status, the rest from the top; ${hint}]` : `[token-goat: ${countNoun(elided, "more row")}; ${hint}]`;
   return `${[header, ...kept.map((i) => rows[i])].join("\n")}
 ${note}`;
 }
@@ -370,7 +385,7 @@ function trimRepeatedPrefix(lines, pattern, keep) {
       out.push(line);
     }
   }
-  if (dropped) out.push(`[token-goat: +${dropped} more lines matching ${pattern.source}]`);
+  if (dropped) out.push(`[token-goat: +${countNoun(dropped, "more line")} matching ${pattern.source}]`);
   return out;
 }
 function stripTimestamps(lines) {
@@ -723,6 +738,7 @@ function shlexSplit(cmd) {
   if (has) tokens.push(cur);
   return tokens;
 }
+var CLIP_MIN_OVERFLOW = 64;
 function capLongLines(lines, maxChars = FALLBACK_MAX_LINE_CHARS) {
   return lines.map((line) => {
     if (line.length <= maxChars) return line;
@@ -732,6 +748,7 @@ function capLongLines(lines, maxChars = FALLBACK_MAX_LINE_CHARS) {
     const high = line.charCodeAt(cut - 1);
     const low = line.charCodeAt(cut);
     if (high >= 55296 && high <= 56319 && low >= 56320 && low <= 57343) cut -= 1;
+    if (line.length - cut <= CLIP_MIN_OVERFLOW) return line;
     const carried = priorClip !== null && priorClip.index >= cut ? Number(priorClip[1]) - priorClip[0].length : 0;
     return `${line.slice(0, cut)}  \u2026 [${line.length - cut + carried} chars elided]`;
   });
@@ -907,14 +924,18 @@ export {
   DEFAULT_MAX_LINES,
   DEFAULT_MAX_BYTES,
   MAX_INSPECT_BYTES,
+  DEFAULT_MAX_INPUT_BYTES,
+  FALLBACK_MAX_LINE_CHARS,
   LONG_LINE_MAX_CHARS,
   getMaxInputBytes,
   INPUT_MAX_LINE_CHARS,
   clipWideLines,
+  isWholeJsonDocument,
   clampKeepingEnds,
   compressionMarker,
   combineStreams,
   ERROR_SIGNAL_RE,
+  TABLE_ROW_ANOMALY_RE,
   TIMESTAMP_PREFIX_RE,
   REDIRECT_TOKEN_RE,
   maskQuotedSpans,
@@ -924,9 +945,13 @@ export {
   hasUnquotedOperator,
   splitOwnTrailingNotices,
   safeDecode,
+  sanitizeControlChars,
+  stripProgress,
   normalise,
   hasHighEntropyToken,
   dedupeConsecutive,
+  dedupeNumericRuns,
+  truncateMiddle,
   truncateMiddleSmart,
   capBytes,
   capTokens,
@@ -945,6 +970,8 @@ export {
   resolvePackageManagerScript,
   shlexSplit,
   capLongLines,
+  GREP_MAX_LINE_CHARS,
+  grepLiteralPattern,
   clipLongMatchLine,
   clipGrepLines,
   fallbackTruncate,

package/dist/token-goat-chunk-4NAPX7BA.mjs

@@ -0,0 +1,90 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  recordStat
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  UNTRUSTED_FILE_TAG,
+  displaySafeText,
+  fenceUntrustedContent,
+  scanForInjectionPatterns
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/untrusted_fence.ts
+init_define_import_meta_env();
+function injectionFencingEnabled() {
+  try {
+    return loadConfig().injection.enabled;
+  } catch {
+    return true;
+  }
+}
+function fenceUntrusted(text, tag) {
+  if (!injectionFencingEnabled()) return text;
+  return fenceUntrustedContent(text, scanAndRecord(text), tag);
+}
+function fenceUntrustedSpans(spans, tag) {
+  const joined = spans.map((s) => s.text).join("");
+  if (!injectionFencingEnabled()) return joined;
+  return fenceUntrustedContent(spans, scanAndRecord(spans.filter((s) => s.own !== true).map((s) => s.text).join("")), tag);
+}
+function fenceWithMatches(text, matches, tag) {
+  if (!injectionFencingEnabled()) return text;
+  return tag === void 0 ? fenceUntrustedContent(text, matches) : fenceUntrustedContent(text, matches, tag);
+}
+function scanAndRecord(text) {
+  if (!injectionFencingEnabled()) return [];
+  let matches;
+  try {
+    matches = scanForInjectionPatterns(text);
+  } catch {
+    matches = [];
+  }
+  if (matches.length > 0) recordStat("injection_detected", 0, 0, void 0, matches.join(","));
+  return matches;
+}
+function fenceFileText(text) {
+  return fenceUntrusted(redactSecrets(text).text, UNTRUSTED_FILE_TAG);
+}
+function fenceIfScanMatched(text, tag) {
+  const matches = scanAndRecord(text);
+  if (matches.length === 0) return text;
+  return fenceUntrustedContent(text, matches, tag);
+}
+function fenceFieldIfMatched(text, tag) {
+  const redacted = redactSecrets(text).text;
+  const fenced = fenceIfScanMatched(redacted, tag);
+  return fenced === redacted ? displaySafeText(redacted) : fenced;
+}
+function fenceFileFieldIfMatched(text) {
+  return fenceFieldIfMatched(text, UNTRUSTED_FILE_TAG);
+}
+function fenceJsonStrings(value, field) {
+  if (typeof value === "string") return field(value);
+  if (Array.isArray(value)) return value.map((v) => fenceJsonStrings(v, field));
+  if (value === null || typeof value !== "object") return value;
+  if (typeof value.toJSON === "function") return value;
+  return Object.fromEntries(Object.entries(value).map(([k, v]) => [field(k), fenceJsonStrings(v, field)]));
+}
+
+export {
+  injectionFencingEnabled,
+  fenceUntrusted,
+  fenceUntrustedSpans,
+  fenceWithMatches,
+  scanAndRecord,
+  fenceFileText,
+  fenceIfScanMatched,
+  fenceFieldIfMatched,
+  fenceFileFieldIfMatched,
+  fenceJsonStrings
+};