token-goat 2.9.29 → 2.9.31

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

@@ -0,0 +1,307 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  formatAge
+} from "./token-goat-chunk-SAMFDIS2.mjs";
+import {
+  findProject
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  LOCK_WAIT_MS_HARDENED,
+  atomicWriteText,
+  countNoun,
+  ensureDirSync,
+  withFileLock,
+  withRetryOnLock
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  sleepSync
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  fenceUntrustedFileContent
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  dataDir
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/project_memory.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+var MAX_ENTRIES = 30;
+var MAX_VALUE_LEN = 300;
+var MAX_TOTAL_CHARS = 4e3;
+var KEY_RE = /^[A-Za-z0-9_-]{1,80}$/;
+var SET_AT_RE = /^#\s*set\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)$/;
+var ANCHOR_RE = /^#\s*anchor:\s*(\S.*)::([^:@\s]+)@([0-9a-f]{64})$/;
+function anchorLabel(status) {
+  if (status === "changed") return " (changed since note)";
+  if (status === "gone") return " (anchored symbol gone)";
+  return "";
+}
+function anchorLine(anchor) {
+  const line = `# anchor: ${anchor.file}::${anchor.symbol}@${anchor.sha}`;
+  const back = ANCHOR_RE.exec(line);
+  return back !== null && back[1] === anchor.file && back[2] === anchor.symbol ? line : null;
+}
+function noteMap() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function ordinal(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function memoryPath(projectHash) {
+  return path.join(dataDir(), "projects", `${projectHash}_memory.toml`);
+}
+function validateKey(key) {
+  if (!KEY_RE.test(key)) {
+    throw new Error(
+      `Invalid memory key ${JSON.stringify(key)}: use only letters, digits, hyphens, underscores (max 80 chars)`
+    );
+  }
+}
+function parseTOML(content, unparsed = [], setAt = /* @__PURE__ */ new Map(), anchors = /* @__PURE__ */ new Map()) {
+  const result = noteMap();
+  let pendingSetAt;
+  let pendingAnchor;
+  for (const [i, line] of content.split("\n").entries()) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      const time = SET_AT_RE.exec(trimmed)?.[1];
+      if (time !== void 0 && !Number.isNaN(Date.parse(time))) pendingSetAt = time;
+      const anchor = ANCHOR_RE.exec(trimmed);
+      if (anchor !== null) pendingAnchor = { file: anchor[1], symbol: anchor[2], sha: anchor[3] };
+      continue;
+    }
+    const entrySetAt = pendingSetAt;
+    const entryAnchor = pendingAnchor;
+    pendingSetAt = void 0;
+    pendingAnchor = void 0;
+    const match = trimmed.match(/^([A-Za-z0-9_-]+)\s*=\s*"(.*)"\s*$/s);
+    if (match) {
+      const [, key, value] = match;
+      if (key && value !== void 0) {
+        const unescaped = value.replace(/\\(u202[89]|[\\nrt"])/g, (_, c) => {
+          switch (c) {
+            case "u2028":
+              return "\u2028";
+            case "u2029":
+              return "\u2029";
+            case "\\":
+              return "\\";
+            case "n":
+              return "\n";
+            case "r":
+              return "\r";
+            case '"':
+              return '"';
+            default:
+              return _;
+          }
+        });
+        result[key] = unescaped;
+        if (entrySetAt === void 0) setAt.delete(key);
+        else setAt.set(key, entrySetAt);
+        if (entryAnchor === void 0) anchors.delete(key);
+        else anchors.set(key, entryAnchor);
+      }
+    } else {
+      unparsed.push(i + 1);
+    }
+  }
+  return result;
+}
+function loadRaw(filePath, forUpdate = false, setAt, anchors) {
+  let content = "";
+  try {
+    withRetryOnLock(() => {
+      content = fs.readFileSync(filePath, "utf-8");
+    });
+  } catch (err) {
+    if (err.code === "ENOENT") return noteMap();
+    throw err;
+  }
+  const unparsed = [];
+  const entries = parseTOML(content, unparsed, setAt, anchors);
+  if (forUpdate && unparsed.length > 0) {
+    const one = unparsed.length === 1;
+    throw new Error(`Not updating ${filePath}: ${one ? "line" : "lines"} ${unparsed.join(", ")} ${one ? "is" : "are"} not in the key = "value" form, and saving would drop ${one ? "it" : "them"}. Fix or remove ${one ? "it" : "them"}, then try again.`);
+  }
+  return entries;
+}
+function save(filePath, entries, setAt = /* @__PURE__ */ new Map(), anchors = /* @__PURE__ */ new Map()) {
+  const lines = [];
+  const sorted = Object.entries(entries).sort(([a], [b]) => ordinal(a, b));
+  for (const [k, v] of sorted) {
+    const escaped = v.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+    const time = setAt.get(k);
+    if (time !== void 0) lines.push(`# set ${time}`);
+    const anchor = anchors.get(k);
+    const anchored = anchor === void 0 ? null : anchorLine(anchor);
+    if (anchored !== null) lines.push(anchored);
+    lines.push(`${k} = "${escaped}"`);
+  }
+  const content = lines.length > 0 ? lines.join("\n") + "\n" : "";
+  const dir = path.dirname(filePath);
+  ensureDirSync(dir);
+  atomicWriteText(filePath, content);
+}
+function loadEntries(projectHash) {
+  return loadRaw(memoryPath(projectHash));
+}
+function loadDatedEntries(projectHash) {
+  const setAt = /* @__PURE__ */ new Map();
+  const anchors = /* @__PURE__ */ new Map();
+  const entries = loadRaw(memoryPath(projectHash), false, setAt, anchors);
+  const result = noteMap();
+  for (const [key, value] of Object.entries(entries)) {
+    const note = { value };
+    const time = setAt.get(key);
+    if (time !== void 0) note.setAt = time;
+    const anchor = anchors.get(key);
+    if (anchor !== void 0) note.anchor = anchor;
+    result[key] = note;
+  }
+  return result;
+}
+function noteAgeLabel(note, now = Date.now()) {
+  if (note.setAt === void 0) return "";
+  return ` (set ${formatAge(Math.max(0, now - Date.parse(note.setAt)))} ago)`;
+}
+function oneLineNoteValue(value) {
+  return value.replace(/\r\n|[\r\n\u0085\u2028\u2029]/g, "\\n");
+}
+function byRecency(a, aSetAt, b, bSetAt) {
+  const ta = aSetAt === void 0 ? Number.NEGATIVE_INFINITY : Date.parse(aSetAt);
+  const tb = bSetAt === void 0 ? Number.NEGATIVE_INFINITY : Date.parse(bSetAt);
+  return ta !== tb ? ta > tb ? -1 : 1 : ordinal(a, b);
+}
+function setEntry(projectHash, key, value, anchor) {
+  validateKey(key);
+  const p = memoryPath(projectHash);
+  const dir = path.dirname(p);
+  ensureDirSync(dir);
+  const result = { evicted: [] };
+  const doSet = () => {
+    const setAt = /* @__PURE__ */ new Map();
+    const anchors = /* @__PURE__ */ new Map();
+    const entries = loadRaw(p, true, setAt, anchors);
+    const old = Object.hasOwn(entries, key) ? entries[key] : void 0;
+    if (old !== void 0) result.previous = old;
+    const isNewKey = !Object.hasOwn(entries, key);
+    if (isNewKey && Object.keys(entries).length >= MAX_ENTRIES) {
+      const keysToKeep = MAX_ENTRIES - 1;
+      const allKeys = Object.keys(entries).sort((a, b) => byRecency(a, setAt.get(a), b, setAt.get(b)));
+      for (const k of allKeys.slice(keysToKeep)) {
+        result.evicted.push(k);
+        delete entries[k];
+        setAt.delete(k);
+        anchors.delete(k);
+      }
+    }
+    entries[key] = value;
+    setAt.set(key, (/* @__PURE__ */ new Date()).toISOString());
+    if (anchor === void 0) anchors.delete(key);
+    else anchors.set(key, anchor);
+    save(p, entries, setAt, anchors);
+    return true;
+  };
+  underNotesLock(p, doSet);
+  return result;
+}
+function underNotesLock(p, update) {
+  const lockPath = `${p}.lock`;
+  ensureDirSync(path.dirname(p));
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    if (withFileLock(lockPath, update, { waitMs: LOCK_WAIT_MS_HARDENED }) !== void 0) return;
+    if (fs.existsSync(lockPath)) break;
+    if (attempt < 3) sleepSync(50 * attempt);
+  }
+  throw new Error(`Could not lock ${p} for writing; no note was changed. Another token-goat process may be writing notes: try again.`);
+}
+function unsetEntry(projectHash, key) {
+  validateKey(key);
+  const p = memoryPath(projectHash);
+  let removed = false;
+  const doUnset = () => {
+    const setAt = /* @__PURE__ */ new Map();
+    const anchors = /* @__PURE__ */ new Map();
+    const entries = loadRaw(p, true, setAt, anchors);
+    if (Object.hasOwn(entries, key)) {
+      delete entries[key];
+      save(p, entries, setAt, anchors);
+      removed = true;
+    }
+    return true;
+  };
+  underNotesLock(p, doUnset);
+  return removed;
+}
+function clearAll(projectHash) {
+  const p = memoryPath(projectHash);
+  const doClear = () => {
+    if (fs.existsSync(p)) {
+      save(p, {});
+    }
+    return true;
+  };
+  underNotesLock(p, doClear);
+}
+function buildInjection(projectHash, root, statusOf) {
+  try {
+    const entries = loadDatedEntries(projectHash);
+    if (Object.keys(entries).length === 0) {
+      return null;
+    }
+    const now = Date.now();
+    const header = '### Project notes (`token-goat note set <key> "<finding>"`)';
+    const render = (shown2, skipped) => {
+      const parts = [header];
+      if (shown2.length > 0) parts.push(fenceUntrustedFileContent(shown2.join("\n")));
+      if (skipped > 0) parts.push(`- (+${countNoun(skipped, "more memory entry", "more memory entries")} omitted)`);
+      return parts.join("\n");
+    };
+    const entries_list = Object.entries(entries).sort(([a, na], [b, nb]) => byRecency(a, na.setAt, b, nb.setAt));
+    const shown = [];
+    for (const [key, note] of entries_list.slice(0, MAX_ENTRIES)) {
+      const val = note.value;
+      const display = val.length <= MAX_VALUE_LEN ? val : val.slice(0, MAX_VALUE_LEN) + "\u2026";
+      const flag = root === void 0 || statusOf === void 0 || note.anchor === void 0 ? "" : anchorLabel(statusOf(root, note.anchor));
+      const line = `- **${key}**${noteAgeLabel(note, now)}${flag}: ${oneLineNoteValue(display)}`;
+      if (render([...shown, line], entries_list.length - shown.length - 1).length > MAX_TOTAL_CHARS) break;
+      shown.push(line);
+    }
+    return render(shown, entries_list.length - shown.length);
+  } catch {
+    return null;
+  }
+}
+function projectNotesFor(cwd, statusOf) {
+  if (cwd === void 0) return null;
+  try {
+    const project = findProject(cwd);
+    return project === null ? null : buildInjection(project.hash, project.root, statusOf);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  MAX_ENTRIES,
+  anchorLabel,
+  anchorLine,
+  loadEntries,
+  loadDatedEntries,
+  noteAgeLabel,
+  oneLineNoteValue,
+  setEntry,
+  unsetEntry,
+  clearAll,
+  projectNotesFor
+};

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
+};

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

@@ -0,0 +1,48 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  ensureDirSync
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  dataDir
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/probe_marker.ts
+init_define_import_meta_env();
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+var PROBE_NONCE_ENV = "TOKEN_GOAT_PROBE_NONCE";
+var NONCE_RE = /^[a-f0-9]{16,32}$/;
+var PROBE_EVENT_TAGS = { session_start: "S", user_prompt_submit: "P" };
+function probeDir() {
+  return path.join(dataDir(), "probe");
+}
+function probeMarkerLine(nonce, tag) {
+  return `token-goat probe marker: ${nonce}-${tag}`;
+}
+function applyProbeMarker(eventName, output, env = process.env) {
+  const nonce = env[PROBE_NONCE_ENV];
+  const tag = PROBE_EVENT_TAGS[eventName];
+  if (nonce === void 0 || tag === void 0 || !NONCE_RE.test(nonce)) return output;
+  try {
+    ensureDirSync(probeDir());
+    writeFileSync(path.join(probeDir(), `${nonce}.${tag}`), "");
+  } catch {
+  }
+  const line = probeMarkerLine(nonce, tag);
+  if (output.hookType === "context") return { ...output, context: `${output.context}
+
+${line}` };
+  if (output.hookType === "pass") return output.notice === void 0 ? { hookType: "context", context: line } : { hookType: "context", context: line, notice: output.notice };
+  return output;
+}
+
+export {
+  PROBE_NONCE_ENV,
+  PROBE_EVENT_TAGS,
+  probeDir,
+  applyProbeMarker
+};