token-goat 2.9.19 → 2.9.21

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

@@ -0,0 +1,324 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  classifyContent,
+  guardDivisor,
+  stripAnsiEscapes
+} from "./token-goat-chunk-PHDNWISV.mjs";
+import {
+  safeSlice
+} from "./token-goat-chunk-TGBSMHPM.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/claude_config_dir.ts
+init_define_import_meta_env();
+import * as os from "node:os";
+import * as path from "node:path";
+function claudeConfigDir(homeDir = os.homedir()) {
+  const override = process.env["CLAUDE_CONFIG_DIR"];
+  if (override !== void 0 && override !== "") return override;
+  return path.join(homeDir, ".claude");
+}
+
+// src/overflow_guard.ts
+init_define_import_meta_env();
+function estimateTokensFromLength(length, cls = "text") {
+  return Math.max(1, Math.floor(Math.max(0, length) / guardDivisor(cls)) + 1);
+}
+function estimateTokens(text) {
+  const stripped = stripAnsiEscapes(text);
+  return estimateTokensFromLength(stripped.length, classifyContent(stripped));
+}
+function trimToBudget(text, budgetTokens, command) {
+  const markerMarginTokens = 64;
+  const strippedAll = stripAnsiEscapes(text);
+  const contentClass = classifyContent(strippedAll);
+  const totalTokens = estimateTokensFromLength(strippedAll.length, contentClass);
+  if (totalTokens <= budgetTokens) {
+    return text;
+  }
+  const lines = text.split("\n");
+  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+  const totalLines = lines.length;
+  const bodyBudget = Math.max(1, budgetTokens - markerMarginTokens);
+  const charBudget = bodyBudget * guardDivisor(contentClass);
+  const kept = [];
+  let used = 0;
+  for (const ln of lines) {
+    const stripped = stripAnsiEscapes(ln);
+    const cost = ln.length + 1;
+    if (kept.length === 0 && cost > charBudget) {
+      const truncated = safeSlice(stripped, charBudget);
+      kept.push(truncated);
+      break;
+    }
+    if (kept.length > 0 && used + cost > charBudget) {
+      break;
+    }
+    kept.push(ln);
+    used += cost;
+  }
+  const shown = kept.length;
+  const hint = getHintFor(command);
+  const marker = `[token-goat: output capped at ~${budgetTokens} tokens to protect context \u2014 showing ${shown} of ${totalLines} lines. ${hint}]`;
+  return kept.join("\n") + "\n" + marker;
+}
+function capJsonRows(items, budgetTokens) {
+  const totalCount = items.length;
+  const charBudget = Math.max(1, budgetTokens * guardDivisor());
+  const kept = [];
+  let used = 0;
+  for (const item of items) {
+    const cost = JSON.stringify(item).length + 2;
+    if (kept.length > 0 && used + cost > charBudget) break;
+    kept.push(item);
+    used += cost;
+  }
+  return { items: kept, truncated: kept.length < totalCount, totalCount };
+}
+function getHintFor(command) {
+  const cmd = (command || "").toLowerCase().trim();
+  if (cmd === "symbol") {
+    return "Request a specific method (file.py::Class.method) or use --json for structured access.";
+  }
+  if (cmd === "heading" || cmd === "section") {
+    return "Request a narrower sub-heading, e.g. 'doc.md::Section#2'.";
+  }
+  if (cmd === "lines") {
+    return "Request a smaller line range, e.g. 'file.py@100-150'.";
+  }
+  if (cmd === "bash-output" || cmd === "web-output") {
+    return "Use --grep PATTERN, --section HEADING, or --tail N to narrow the cached output.";
+  }
+  if (cmd === "semantic") {
+    return "Narrow your query text or pass --limit to reduce the number of matches returned.";
+  }
+  return "Narrow your query or raise overflow_guard max_tokens in config.";
+}
+
+// src/resident_context.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+var LARGE_TASK_LIST_BYTES = 2e4;
+var LARGE_SKILL_BODY_BYTES = 2e4;
+var SKILL_BODY_REPEAT_THRESHOLD = 2;
+var RESIDENT_TAIL_MAX_BYTES = 1048576;
+function createResidentContextStats() {
+  return {
+    attachmentsByType: /* @__PURE__ */ new Map(),
+    latestTaskList: null,
+    taskReminderCount: 0,
+    taskReminderBytes: 0,
+    skillBodies: /* @__PURE__ */ new Map(),
+    compactionCount: 0
+  };
+}
+function bump(map, key, bytes) {
+  const entry = map.get(key);
+  if (entry === void 0) map.set(key, { count: 1, bytes });
+  else {
+    entry.count += 1;
+    entry.bytes += bytes;
+  }
+}
+function messageText(message) {
+  if (message === null || typeof message !== "object") return "";
+  const content = message["content"];
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let out = "";
+  for (const block of content) {
+    if (block === null || typeof block !== "object") continue;
+    const text = block["text"];
+    if (typeof text === "string") out += text;
+  }
+  return out;
+}
+function skillNameFromBody(text) {
+  const dir = /^Base directory for this skill:\s*(.+?)\s*$/m.exec(text);
+  if (dir?.[1] !== void 0) {
+    const segments = dir[1].split(/[\\/]/).filter((s) => s.length > 0);
+    const last = segments[segments.length - 1];
+    if (last !== void 0 && last.length > 0) return last;
+  }
+  const heading = /^#\s+(.+?)\s*$/m.exec(text);
+  if (heading?.[1] !== void 0 && heading[1].length > 0) return heading[1];
+  return null;
+}
+function readTaskList(attachment, bytes) {
+  const snapshot = {
+    bytes,
+    itemCount: typeof attachment["itemCount"] === "number" ? attachment["itemCount"] : 0,
+    completed: 0,
+    inProgress: 0,
+    pending: 0,
+    descriptionBytes: 0,
+    completedDescriptionBytes: 0
+  };
+  const content = attachment["content"];
+  if (!Array.isArray(content)) return snapshot;
+  if (content.length > snapshot.itemCount) snapshot.itemCount = content.length;
+  for (const item of content) {
+    if (item === null || typeof item !== "object") continue;
+    const record = item;
+    const status = typeof record["status"] === "string" ? record["status"] : "";
+    const description = typeof record["description"] === "string" ? record["description"] : "";
+    snapshot.descriptionBytes += description.length;
+    if (status === "completed") {
+      snapshot.completed += 1;
+      snapshot.completedDescriptionBytes += description.length;
+    } else if (status === "in_progress") snapshot.inProgress += 1;
+    else if (status === "pending") snapshot.pending += 1;
+  }
+  return snapshot;
+}
+function collectInvokedSkills(acc, record) {
+  const skills = record["skills"];
+  if (!Array.isArray(skills)) return;
+  for (const entry of skills) {
+    if (entry === null || typeof entry !== "object") continue;
+    const skill = entry;
+    const content = skill["content"];
+    if (typeof content !== "string" || content.length < LARGE_SKILL_BODY_BYTES) continue;
+    const name = skillName(skill);
+    if (name !== null) bump(acc.skillBodies, name, content.length);
+  }
+}
+function skillName(skill) {
+  const name = skill["name"];
+  if (typeof name === "string" && name.trim() !== "") return name.trim();
+  const path2 = skill["path"];
+  if (typeof path2 !== "string") return null;
+  const segments = path2.split(/[\\/]/).filter((part) => part !== "");
+  const last = segments[segments.length - 1];
+  return last === void 0 || last === "" ? null : last;
+}
+function accumulateResidentLine(acc, parsed, bytes) {
+  try {
+    if (parsed === null || typeof parsed !== "object") return;
+    const line = parsed;
+    if (line["type"] === "system" && line["subtype"] === "compact_boundary") acc.compactionCount += 1;
+    const attachment = line["attachment"];
+    if (attachment !== null && typeof attachment === "object") {
+      const record = attachment;
+      const type = typeof record["type"] === "string" ? record["type"] : "unknown";
+      bump(acc.attachmentsByType, type, bytes);
+      if (type === "task_reminder") {
+        acc.taskReminderCount += 1;
+        acc.taskReminderBytes += bytes;
+        acc.latestTaskList = readTaskList(record, bytes);
+      }
+      if (type === "invoked_skills") collectInvokedSkills(acc, record);
+    }
+    if (line["isMeta"] === true && line["type"] === "user") {
+      const text = messageText(line["message"]);
+      if (text.length >= LARGE_SKILL_BODY_BYTES) {
+        const skill = skillNameFromBody(text);
+        if (skill !== null) bump(acc.skillBodies, skill, text.length);
+      }
+    }
+  } catch {
+  }
+}
+function summarizeResidentContext(acc) {
+  const attachmentClasses = [...acc.attachmentsByType.entries()].map(([type, v]) => ({ type, count: v.count, bytes: v.bytes })).sort((a, b) => b.bytes - a.bytes || a.type.localeCompare(b.type));
+  const repeatedSkillBodies = [...acc.skillBodies.entries()].filter(([, v]) => v.count >= SKILL_BODY_REPEAT_THRESHOLD).map(([skill, v]) => ({ skill, count: v.count, bytes: v.bytes })).sort((a, b) => b.bytes - a.bytes || a.skill.localeCompare(b.skill));
+  return {
+    attachmentClasses,
+    totalAttachmentBytes: attachmentClasses.reduce((n, c) => n + c.bytes, 0),
+    latestTaskList: acc.latestTaskList,
+    taskReminderCount: acc.taskReminderCount,
+    taskReminderBytes: acc.taskReminderBytes,
+    repeatedSkillBodies,
+    compactionCount: acc.compactionCount
+  };
+}
+function formatBytes(bytes) {
+  if (bytes >= 1e6) return `${(bytes / 1048576).toFixed(1)} MB`;
+  if (bytes >= 1e3) return `${Math.round(bytes / 1024)} KB`;
+  return `${bytes} B`;
+}
+function formatTokenEstimate(tokens) {
+  return tokens >= 1e3 ? `${Math.round(tokens / 1e3)}K` : String(tokens);
+}
+function taskListPruneHint(snapshot) {
+  if (snapshot === null) return null;
+  if (snapshot.bytes < LARGE_TASK_LIST_BYTES) return null;
+  if (snapshot.completed === 0) return null;
+  const tokens = formatTokenEstimate(estimateTokensFromLength(snapshot.bytes));
+  const prunable = formatBytes(snapshot.completedDescriptionBytes);
+  return `Your task list is ${formatBytes(snapshot.bytes)} (~${tokens} tok est) and is re-injected in full whenever it changes; ${snapshot.completed} of ${snapshot.itemCount} items are already completed and their descriptions alone are ${prunable}. Prune completed items or shorten their descriptions with TaskUpdate. Check ownership first if other agents share this list.`;
+}
+function repeatedSkillBodyHint(injections) {
+  const worst = injections[0];
+  if (worst === void 0) return null;
+  if (worst.count < SKILL_BODY_REPEAT_THRESHOLD || worst.bytes < LARGE_SKILL_BODY_BYTES) return null;
+  const skill = displaySafeText(worst.skill);
+  const tokens = formatTokenEstimate(estimateTokensFromLength(worst.bytes));
+  return `The \`${skill}\` skill body has been injected ${worst.count} times this session (${formatBytes(worst.bytes)} total, ~${tokens} tok est). Slash expansion and the Skill tool both send the whole body every time, and no hook can intercept either. If it is already loaded, work from it instead of re-invoking; to reread one part, use \`token-goat skill-section ${skill} '<heading>'\`.`;
+}
+function readTranscriptTail(transcriptPath, maxBytes = RESIDENT_TAIL_MAX_BYTES) {
+  let fd = null;
+  try {
+    const stat = fs.statSync(transcriptPath);
+    if (!stat.isFile() || stat.size === 0) return [];
+    const start = Math.max(0, stat.size - maxBytes);
+    const length = stat.size - start;
+    fd = fs.openSync(transcriptPath, "r");
+    const buf = Buffer.allocUnsafe(length);
+    const read = fs.readSync(fd, buf, 0, length, start);
+    const lines = buf.subarray(0, read).toString("utf8").split("\n");
+    if (start > 0) lines.shift();
+    return lines;
+  } catch {
+    return [];
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function lineMayCarryResidentSignal(line) {
+  return line.includes('"task_reminder"') || line.includes('"compact_boundary"') || line.includes('"invoked_skills"') || line.includes('"isMeta"');
+}
+function accumulateResidentLines(lines) {
+  const acc = createResidentContextStats();
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    accumulateResidentLine(acc, parsed, trimmed.length);
+  }
+  return acc;
+}
+
+export {
+  claudeConfigDir,
+  estimateTokensFromLength,
+  estimateTokens,
+  trimToBudget,
+  capJsonRows,
+  createResidentContextStats,
+  accumulateResidentLine,
+  summarizeResidentContext,
+  formatBytes,
+  formatTokenEstimate,
+  taskListPruneHint,
+  repeatedSkillBodyHint,
+  readTranscriptTail,
+  lineMayCarryResidentSignal,
+  accumulateResidentLines
+};