token-goat 2.9.30 → 2.9.31

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-KWPNJBDH.mjs → token-goat-chunk-4GILLLWY.mjs}

@@ -3,6 +3,9 @@ const require = __cjsRequire(import.meta.url);
 import {
   stripAnsiEscapes
 } 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";
@@ -343,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"
   );
 }
@@ -365,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}`;
 }
@@ -382,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) {

package/dist/{token-goat-chunk-67TQJ76B.mjs → token-goat-chunk-4NAPX7BA.mjs}

@@ -2,11 +2,16 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   recordStat
-} from "./token-goat-chunk-3Z5S4KGM.mjs";
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
 import {
   loadConfig
-} from "./token-goat-chunk-7IN2MKDS.mjs";
+} from "./token-goat-chunk-7EZTZOMC.mjs";
 import {
+  UNTRUSTED_FILE_TAG,
+  displaySafeText,
   fenceUntrustedContent,
   scanForInjectionPatterns
 } from "./token-goat-chunk-FNFBKLRD.mjs";
@@ -47,11 +52,39 @@ function scanAndRecord(text) {
   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
+  scanAndRecord,
+  fenceFileText,
+  fenceIfScanMatched,
+  fenceFieldIfMatched,
+  fenceFileFieldIfMatched,
+  fenceJsonStrings
 };