token-goat 2.9.29 → 2.9.30

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

@@ -0,0 +1,24 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  copyFromSharedCache,
+  downloadPinned,
+  setPinnedRetryDelayForTesting,
+  sha256Of
+} from "./token-goat-chunk-PD5VKH46.mjs";
+import "./token-goat-chunk-SMVRN2HU.mjs";
+import "./token-goat-chunk-7IN2MKDS.mjs";
+import "./token-goat-chunk-U4N3BN2W.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-GOLEOXZP.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-VES7EL7O.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  copyFromSharedCache,
+  downloadPinned,
+  setPinnedRetryDelayForTesting,
+  sha256Of
+};

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

@@ -0,0 +1,188 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  registerHook
+} from "./token-goat-chunk-P4QMM4WK.mjs";
+import {
+  ensureWorkerAlive
+} from "./token-goat-chunk-5KDMCMF2.mjs";
+import {
+  passOutput
+} from "./token-goat-chunk-VPBBTSJR.mjs";
+import {
+  isUnderSystemTemp
+} from "./token-goat-chunk-7IN2MKDS.mjs";
+import {
+  atomicWriteBytes,
+  ensureDirSync
+} from "./token-goat-chunk-GOLEOXZP.mjs";
+import {
+  foldPath
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  normalizePath,
+  resolveIndexPath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  dataDir
+} from "./token-goat-chunk-VES7EL7O.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/dirty_queue.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+function dirtyQueuePathFor(dir) {
+  return path.join(dir, "queue", "dirty.txt");
+}
+var ENCODED_LINE_MARKER = "!";
+function encodeDirtyQueueLine(absPath) {
+  const needsEncoding = /[\r\n]/.test(absPath) || absPath !== absPath.trim();
+  return needsEncoding ? ENCODED_LINE_MARKER + JSON.stringify(absPath) : absPath;
+}
+function decodeDirtyQueueLine(line) {
+  if (!line.startsWith(ENCODED_LINE_MARKER)) return line;
+  try {
+    const decoded = JSON.parse(line.slice(ENCODED_LINE_MARKER.length));
+    return typeof decoded === "string" ? decoded : line;
+  } catch {
+    return line;
+  }
+}
+function parseDirtyQueueLines(raw) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = decodeDirtyQueueLine(line.trim());
+    if (trimmed === "") continue;
+    const normalized = normalizePath(trimmed);
+    const dedupeKey = foldPath(normalized);
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    out.push(trimmed);
+  }
+  return out;
+}
+function getDirtyPathsFor(dir) {
+  let raw;
+  try {
+    raw = fs.readFileSync(dirtyQueuePathFor(dir), "utf8");
+  } catch {
+    return [];
+  }
+  return parseDirtyQueueLines(raw);
+}
+function dirtyQueueLeadingNewline(queuePath) {
+  let fd;
+  try {
+    const size = fs.statSync(queuePath).size;
+    if (size === 0) return "";
+    fd = fs.openSync(queuePath, "r");
+    const tail = Buffer.allocUnsafe(1);
+    fs.readSync(fd, tail, 0, 1, size - 1);
+    return tail[0] === 10 ? "" : "\n";
+  } catch {
+    return "";
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function appendToLiveQueue(queuePath, data) {
+  const fd = fs.openSync(queuePath, "a");
+  try {
+    fs.writeFileSync(fd, data);
+    return fs.statSync(queuePath, { bigint: true, throwIfNoEntry: false })?.ino === fs.fstatSync(fd, { bigint: true }).ino;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function renderDirtyQueueLines(absPaths) {
+  return absPaths.map((p) => `${encodeDirtyQueueLine(p)}
+`).join("");
+}
+function appendDirtyQueueFile(filePath, absPaths) {
+  if (absPaths.length === 0) return;
+  fs.appendFileSync(filePath, `${dirtyQueueLeadingNewline(filePath)}${renderDirtyQueueLines(absPaths)}`);
+}
+function appendDirtyQueuePaths(dir, absPaths) {
+  if (absPaths.length === 0) return true;
+  const queuePath = dirtyQueuePathFor(dir);
+  const queueDir = path.dirname(queuePath);
+  try {
+    ensureDirSync(queueDir);
+  } catch (e) {
+    if (e.code !== "EEXIST" || !fs.existsSync(queueDir)) throw e;
+  }
+  const body = renderDirtyQueueLines(absPaths);
+  for (let attempt = 0; attempt < 3; attempt++) {
+    if (appendToLiveQueue(queuePath, `${dirtyQueueLeadingNewline(queuePath)}${body}`)) return true;
+  }
+  return false;
+}
+
+// src/hooks_index.ts
+init_define_import_meta_env();
+import * as path2 from "node:path";
+function appendDirtyPaths(normalizedPaths) {
+  appendDirtyQueuePaths(dataDir(), normalizedPaths);
+}
+function appendDirtyPath(normalizedPath) {
+  appendDirtyPaths([normalizedPath]);
+}
+function enqueueDirtyPathSafe(filePath, opts) {
+  enqueueDirtyPathsSafe([filePath], opts);
+}
+function enqueueDirtyPathsSafe(filePaths, opts) {
+  const resolved = [];
+  try {
+    for (const filePath of filePaths) {
+      const r = opts?.alreadyResolved === true ? filePath : resolveIndexPath(filePath);
+      if (isUnderSystemTemp(r)) continue;
+      resolved.push(r);
+    }
+    if (resolved.length === 0) return 0;
+    appendDirtyPaths(resolved);
+  } catch {
+    return 0;
+  }
+  try {
+    ensureWorkerAlive();
+  } catch {
+  }
+  return resolved.length;
+}
+function getDirtyPaths() {
+  return getDirtyPathsFor(dataDir());
+}
+function preCompactIndexHandler(_event) {
+  const paths = getDirtyPaths();
+  if (paths.length > 0) {
+    const sidecar = path2.join(dataDir(), "queue", "pending.txt");
+    try {
+      ensureDirSync(path2.dirname(sidecar));
+      atomicWriteBytes(sidecar, Buffer.from(`${paths.join("\n")}
+`, "utf8"));
+    } catch {
+    }
+  }
+  return passOutput();
+}
+registerHook("pre_compact", preCompactIndexHandler, { advisory: true });
+
+export {
+  dirtyQueuePathFor,
+  parseDirtyQueueLines,
+  getDirtyPathsFor,
+  appendDirtyQueueFile,
+  appendDirtyQueuePaths,
+  appendDirtyPath,
+  enqueueDirtyPathSafe,
+  enqueueDirtyPathsSafe
+};

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

@@ -0,0 +1,87 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/render/ansi.ts
+init_define_import_meta_env();
+function _colorStream(isatty) {
+  if (process.env["NO_COLOR"]) return false;
+  return isatty;
+}
+function colorStdout() {
+  return _colorStream(process.stdout.isTTY === true);
+}
+var _E = "\x1B";
+var RESET = `${_E}[0m`;
+var _ANSI_ESCAPE_RE = /\x1B\[[0-?]*[ -/]*[@-~]|\x1B\].*?(?:\x07|\x1B\\|$)|\x1B[PX^_].*?\x1B\\|\x1B[@-_]/gs;
+var _PUA_RE = /[\u{E000}-\u{F8FF}\u{F0000}-\u{FFFFD}]/gu;
+function stripAnsiEscapes(s) {
+  if (!s.includes("\x1B")) {
+    return s;
+  }
+  return s.replace(_ANSI_ESCAPE_RE, "");
+}
+function fmtBytes(n) {
+  let value = n;
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  for (const unit of units) {
+    if (Math.abs(value) < 1024) {
+      return unit === "B" ? `${Math.trunc(value)}${unit}` : `${value.toFixed(1)}${unit}`;
+    }
+    value = value / 1024;
+  }
+  return `${value.toFixed(1)}PB`;
+}
+function fg(r, g, b) {
+  return `${_E}[38;2;${r};${g};${b}m`;
+}
+function vlen(s) {
+  return stripAnsiEscapes(s).replace(_PUA_RE, "").length;
+}
+function padR(s, w) {
+  return s + " ".repeat(Math.max(0, w - vlen(s)));
+}
+function padL(s, w) {
+  return " ".repeat(Math.max(0, w - vlen(s))) + s;
+}
+function lerpRgb(a, b, t) {
+  return [
+    Math.round(a[0] + (b[0] - a[0]) * t),
+    Math.round(a[1] + (b[1] - a[1]) * t),
+    Math.round(a[2] + (b[2] - a[2]) * t)
+  ];
+}
+var C = {
+  TEXT_PRIMARY: [201, 209, 217],
+  TEXT_BRIGHT: [240, 246, 252],
+  TEXT_MUTED: [125, 133, 144],
+  TEXT_DIM: [72, 79, 88],
+  BG_TILE: [22, 27, 34],
+  TRACK: [28, 35, 41],
+  GREEN1: [31, 77, 44],
+  GREEN2: [46, 160, 67],
+  GREEN3: [63, 185, 80],
+  GREEN4: [86, 211, 100],
+  GREEN5: [126, 231, 135],
+  BLUE: [88, 166, 255],
+  PURPLE: [188, 140, 255],
+  TEAL: [138, 212, 255],
+  ORANGE: [235, 165, 80],
+  YELLOW: [240, 215, 80],
+  RED: [200, 60, 60]
+};
+
+export {
+  colorStdout,
+  RESET,
+  stripAnsiEscapes,
+  fmtBytes,
+  fg,
+  vlen,
+  padR,
+  padL,
+  lerpRgb,
+  C
+};