token-goat 2.9.19 → 2.9.20

package/dist/{token-goat-chunk-BTKDZW7F.mjs → token-goat-chunk-T46UKRFM.mjs}

@@ -12,7 +12,7 @@ import {
 } from "./token-goat-chunk-AH6QILZM.mjs";
 import {
   pushAll
-} from "./token-goat-chunk-ZGQXRYKE.mjs";
+} from "./token-goat-chunk-6LJNM4ZZ.mjs";
 import {
   DocumentRefusedError,
   MAX_DOCUMENT_WORK_MILLIS

package/dist/{token-goat-chunk-JNIFSVWM.mjs → token-goat-chunk-T63VHOL3.mjs}

@@ -15,7 +15,7 @@ import {
   foldCase,
   foldPath,
   sleepSync
-} from "./token-goat-chunk-ZGQXRYKE.mjs";
+} from "./token-goat-chunk-6LJNM4ZZ.mjs";
 import {
   safeJoin
 } from "./token-goat-chunk-NMTKNYGF.mjs";
@@ -1666,6 +1666,10 @@ var LANGUAGE_SPECS = [
   // Oracle PL/SQL sources: package spec and body, standalone procedure/function, trigger, and object type spec and body.
   { id: "sql", extraction: "regex", extensions: [".sql", ".pks", ".pkb", ".pls", ".plsql", ".pck", ".prc", ".fnc", ".trg", ".tps", ".tpb"], label: "SQL", ...DATA, symbolBearing: true, diffable: true, fence: "sql" },
   { id: "ini", extraction: "regex", extensions: [".ini", ".cfg", ".conf"], label: "INI", ...DATA, fence: "ini" },
+  { id: "nginx", extraction: "regex", extensions: [".nginx"], basenames: ["nginx.conf"], label: "Nginx", ...DATA, symbolBearing: true, diffable: true, fence: "nginx" },
+  // `basenames` is matched against a lower-cased basename, so `Caddyfile` is spelled in lower case here; the display spelling is the label's job.
+  { id: "caddy", extraction: "regex", extensions: [".caddy"], basenames: ["caddyfile", "caddy.conf"], label: "Caddyfile", ...DATA, symbolBearing: true, diffable: true, fence: "caddy" },
+  { id: "apache", extraction: "regex", extensions: [".apache", ".apache2"], basenames: ["httpd.conf", "apache2.conf", ".htaccess"], label: "Apache Config", ...DATA, symbolBearing: true, diffable: true, fence: "apache" },
   // `.mk` fragments (config.mk, rules.mk) share a bare Makefile's syntax.
   { id: "makefile", extraction: "regex", extensions: [".mk"], basenames: ["makefile", "gnumakefile", "bsdmakefile"], ...DATA, fence: "makefile", basenameImportsExtension: ".mk" },
   { id: "proto", extraction: "regex", extensions: [".proto"], label: "Protocol Buffers", ...DATA, symbolBearing: true, fence: "protobuf" },

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

@@ -0,0 +1,248 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  WEB_FETCH_KEY_SEP,
+  computeAdaptiveBudget,
+  getContextPressure,
+  getSessionBashOutputs,
+  getSessionBashReruns,
+  getSessionFiles,
+  getSessionWebFetches,
+  isNoisePath,
+  listSiblingSessionStates,
+  loadSessionCache
+} from "./token-goat-chunk-KT75DZK4.mjs";
+import {
+  getBashOutput
+} from "./token-goat-chunk-SL454EN5.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-74ADIZZX.mjs";
+import {
+  foldPath,
+  runGit,
+  toKB
+} from "./token-goat-chunk-6LJNM4ZZ.mjs";
+import {
+  displaySafePath,
+  displaySafeText,
+  neutralizeSpokenMarkers
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/manifest.ts
+init_define_import_meta_env();
+import { spawnSync } from "node:child_process";
+var MEM_EPOCH_TIMEOUT_MS = 800;
+var MAX_ROWS = 40;
+function appendCappedSection(lines, header, rows, cap) {
+  if (rows.length === 0) return;
+  lines.push("");
+  lines.push(header);
+  for (const row of rows.slice(0, cap)) lines.push(row);
+  if (rows.length > cap) lines.push(`- ...and ${rows.length - cap} more`);
+}
+function renderReadRow(entry) {
+  const kb = Math.max(1, toKB(entry.sizeBytes));
+  const plural = entry.readCount === 1 ? "read" : "reads";
+  const edited = entry.wasEdited ? ", edited" : "";
+  return `- ${displaySafePath(entry.path)} (${kb}kb, ${entry.readCount} ${plural}${edited})`;
+}
+function renderSymbolReadRow(entry) {
+  return `- ${displaySafePath(entry.path)} (symbols: ${(entry.symbols_read ?? []).map(displaySafeText).join(", ")})`;
+}
+function mergeManifestFiles(parent, siblingFiles) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const f of parent) byPath.set(foldPath(f.path), f);
+  for (const f of siblingFiles) {
+    const key = foldPath(f.path);
+    const prev = byPath.get(key);
+    if (prev === void 0) {
+      byPath.set(key, f);
+      continue;
+    }
+    const mergedSymbols = [.../* @__PURE__ */ new Set([...prev.symbols_read ?? [], ...f.symbols_read ?? []])];
+    byPath.set(key, {
+      path: prev.path,
+      readCount: Math.max(prev.readCount, f.readCount),
+      lastReadAt: Math.max(prev.lastReadAt, f.lastReadAt),
+      wasEdited: prev.wasEdited || f.wasEdited,
+      sizeBytes: f.lastReadAt >= prev.lastReadAt ? f.sizeBytes : prev.sizeBytes,
+      ...prev.wasTruncated || f.wasTruncated ? { wasTruncated: true } : {},
+      ...mergedSymbols.length > 0 ? { symbols_read: mergedSymbols } : {}
+    });
+  }
+  return Array.from(byPath.values());
+}
+function renderWebFetchRow(key, cacheId) {
+  const [url = key, prompt = ""] = key.split(WEB_FETCH_KEY_SEP);
+  const promptSuffix = prompt ? `, prompt: ${neutralizeSpokenMarkers(JSON.stringify(prompt))}` : "";
+  return `- ${displaySafeText(url)} (cacheId: ${cacheId}${promptSuffix})`;
+}
+function selectManifestFiles(siblings) {
+  const ownFiles = [...getSessionFiles().values()];
+  const siblingFiles = siblings.flatMap((s) => s.files);
+  const files = siblingFiles.length > 0 ? mergeManifestFiles(ownFiles, siblingFiles) : ownFiles;
+  const editedFiles = files.filter((f) => f.wasEdited);
+  const readFiles = files.filter((f) => f.readCount > 0 && !f.wasEdited && !isNoisePath(f.path));
+  const symbolOnlyFiles = files.filter((f) => f.readCount === 0 && !f.wasEdited && (f.symbols_read?.length ?? 0) > 0);
+  return { files, readFiles, editedFiles, symbolOnlyFiles };
+}
+function selectManifestWebFetches(siblings) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const sibling of siblings) for (const [key, cacheId] of sibling.webFetches) merged.set(key, cacheId);
+  for (const [key, cacheId] of getSessionWebFetches()) merged.set(key, cacheId);
+  return [...merged.entries()];
+}
+function manifestPrintedPaths(sessionId, limit, cwd, transcriptPath) {
+  const { printed } = buildManifestParts(sessionId, cwd, transcriptPath);
+  return printed.slice(0, limit);
+}
+function buildManifestParts(sessionId, cwd, transcriptPath) {
+  const siblings = sessionId !== void 0 ? listSiblingSessionStates(sessionId) : [];
+  const { files, readFiles, editedFiles, symbolOnlyFiles } = selectManifestFiles(siblings);
+  const webFetches = selectManifestWebFetches(siblings);
+  const lines = [];
+  lines.push("## Session context");
+  lines.push(`Files read: ${readFiles.length}`);
+  lines.push(`Files edited: ${editedFiles.length}`);
+  const fileRows = [];
+  const appendFileSection = (header, entries, render) => {
+    const rows = entries.map(render);
+    appendCappedSection(lines, header, rows, MAX_ROWS);
+    for (let i = 0; i < Math.min(rows.length, MAX_ROWS); i++) fileRows.push({ path: displaySafePath(entries[i].path), row: rows[i] });
+  };
+  appendFileSection("### Edited files", editedFiles, (entry) => `- ${displaySafePath(entry.path)}`);
+  appendFileSection("### Surgically read files (symbol/section reads, never read whole)", symbolOnlyFiles, renderSymbolReadRow);
+  appendFileSection("### Read files", readFiles, renderReadRow);
+  appendCappedSection(lines, "### Web URLs fetched", webFetches.map(([key, cacheId]) => renderWebFetchRow(key, cacheId)), MAX_ROWS);
+  lines.push(...buildSafeToDiscardSection(files));
+  lines.push(...buildMemEpochSection());
+  const text = capManifestChars(lines.join("\n"), sessionId, cwd, transcriptPath);
+  const seen = /* @__PURE__ */ new Set();
+  const printed = [];
+  for (const { path, row } of fileRows) {
+    if (seen.has(path) || !(text.includes(row + "\n") || text.endsWith(row))) continue;
+    seen.add(path);
+    printed.push(path);
+  }
+  return { text, printed };
+}
+function buildManifest(sessionId, cwd, transcriptPath) {
+  return buildManifestParts(sessionId, cwd, transcriptPath).text;
+}
+function gitDirtySignals(cwd) {
+  const timeoutMs = loadConfig().hints.git_hint_max_ms;
+  let hasPendingDiff = false;
+  try {
+    const diffResult = runGit(["diff", "--no-color", "--stat", "HEAD"], { cwd, timeoutMs });
+    hasPendingDiff = diffResult.exitCode === 0 && diffResult.stdout.trim() !== "";
+  } catch {
+  }
+  let hasUncommittedChanges = false;
+  try {
+    const statusResult = runGit(["status", "--porcelain"], { cwd, timeoutMs });
+    hasUncommittedChanges = statusResult.exitCode === 0 && statusResult.stdout.trim() !== "";
+  } catch {
+  }
+  return { hasPendingDiff, hasUncommittedChanges };
+}
+function adaptiveCharBonus(sessionId, cwd, transcriptPath) {
+  if (!cwd) return 0;
+  const cache = loadSessionCache(sessionId ?? "") ?? {};
+  const ageSecs = cache.created_ts !== void 0 ? Math.max(0, Date.now() / 1e3 - cache.created_ts) : 0;
+  const contextPressure = getContextPressure(cache, transcriptPath);
+  const { hasPendingDiff, hasUncommittedChanges } = gitDirtySignals(cwd);
+  if (!hasPendingDiff && !hasUncommittedChanges) return 0;
+  const baseline = computeAdaptiveBudget(cache, ageSecs, { contextPressure });
+  const withGitSignal = computeAdaptiveBudget(cache, ageSecs, { hasPendingDiff, hasUncommittedChanges, contextPressure });
+  const deltaTokens = Math.max(0, withGitSignal - baseline);
+  return deltaTokens * 3;
+}
+function capManifestChars(manifest, sessionId, cwd, transcriptPath) {
+  const cap = loadConfig().compact_assist.max_manifest_chars;
+  if (cap <= 0) return manifest;
+  if (manifest.length <= cap) return manifest;
+  const effectiveCap = cap + adaptiveCharBonus(sessionId, cwd, transcriptPath);
+  if (manifest.length <= effectiveCap) return manifest;
+  const omitted = manifest.length - effectiveCap;
+  return manifest.slice(0, effectiveCap) + `
+...(manifest truncated at ${effectiveCap} chars; ${omitted} chars omitted)`;
+}
+function buildSafeToDiscardSection(files) {
+  const rerunHashes = getSessionBashReruns();
+  const bashOutputs = getSessionBashOutputs();
+  const rerunHashSet = new Set(rerunHashes);
+  const rerunRows = [];
+  for (const hash of rerunHashes) {
+    const id = bashOutputs.find(([h]) => h === hash)?.[1];
+    if (id === void 0) continue;
+    const entry = getBashOutput(id);
+    if (entry === null) continue;
+    const flatCommand = neutralizeSpokenMarkers(entry.command.replace(/[\t\r\n]+/g, " "));
+    rerunRows.push("- `" + flatCommand + "` \u2014 an older run of this exact command was superseded; recall the surviving copy with `bash-output " + id + " --full`");
+  }
+  const supersededReadRows = [];
+  for (const f of files) {
+    if (f.readCount > 1 || f.wasEdited) {
+      const reason = f.wasEdited ? "edited after being read" : "re-read " + f.readCount + "x";
+      supersededReadRows.push("- " + displaySafePath(f.path) + " (" + reason + " \u2014 only the latest content already in context is current)");
+    }
+  }
+  const cachedOutputRows = [];
+  for (const [hash, id] of bashOutputs) {
+    if (rerunHashSet.has(hash)) continue;
+    const entry = getBashOutput(id);
+    if (entry === null) continue;
+    const flatCommand = neutralizeSpokenMarkers(entry.command.replace(/[\t\r\n]+/g, " "));
+    cachedOutputRows.push("- `" + flatCommand + "` \u2014 recallable via `bash-output " + id + " --full`");
+  }
+  const total = rerunRows.length + supersededReadRows.length + cachedOutputRows.length;
+  if (total === 0) return [];
+  const lines = [];
+  lines.push("");
+  lines.push("### SAFE_TO_DISCARD (" + total + " items \u2014 provably inert; each is recallable, not gone)");
+  appendCappedSection(lines, "Superseded reruns (" + rerunRows.length + "):", rerunRows, MAX_ROWS);
+  appendCappedSection(lines, "Superseded file reads (" + supersededReadRows.length + "):", supersededReadRows, MAX_ROWS);
+  appendCappedSection(lines, "Other cached bash outputs (" + cachedOutputRows.length + "):", cachedOutputRows, MAX_ROWS);
+  return lines;
+}
+function buildMemEpochSection() {
+  let result;
+  try {
+    result = spawnSync("mem", ["epoch"], {
+      encoding: "utf-8",
+      timeout: MEM_EPOCH_TIMEOUT_MS,
+      windowsHide: true
+    });
+  } catch {
+    return [];
+  }
+  if (result.error !== void 0 || result.status !== 0) return [];
+  const stdout = typeof result.stdout === "string" ? result.stdout.trim() : "";
+  if (!/^\d+$/.test(stdout)) return [];
+  return [
+    "",
+    "### mem epoch",
+    `mem epoch: ${stdout} (no live TGMEM block is tracked in this session -- only the epoch counter is folded in; see buildMemEpochSection's doc comment)`
+  ];
+}
+var MANIFEST_PREAMBLE = "When summarizing this session, keep the file paths and symbol names below exactly as written -- they are the handles the next turn needs to resume work. Do not paraphrase them into prose.";
+var MANIFEST_RECOVERY_PREAMBLE = "The conversation was just compacted. Below is what this session touched, recovered from token-goat's own ledger rather than from the summary -- use it to re-establish paths and symbol names the summary may have dropped.";
+var BUDGET_ESCALATION_MARKER = "TG-BUDGET-ESCALATION:";
+function summaryBudgetDirective(budgetChars) {
+  if (budgetChars <= 0) return "";
+  return ` Aim for at most ${budgetChars} characters. Prefer a shorter summary that keeps every path, symbol, command and decision over a longer one that reproduces tool output verbatim: cite the recall id (\`token-goat bash-output <id> --full\`) rather than quoting the output again. If this session genuinely cannot be summarized within that target without losing state the next turn needs, exceed it and open the summary with a single line reading \`${BUDGET_ESCALATION_MARKER} <one-sentence reason>\`.`;
+}
+
+export {
+  renderWebFetchRow,
+  manifestPrintedPaths,
+  buildManifest,
+  MANIFEST_PREAMBLE,
+  MANIFEST_RECOVERY_PREAMBLE,
+  BUDGET_ESCALATION_MARKER,
+  summaryBudgetDirective
+};

package/dist/{token-goat-chunk-EXLLLIC3.mjs → token-goat-chunk-VYXGHGUY.mjs}

@@ -5,11 +5,11 @@ import {
   docxTables,
   docxText,
   formatDocxTables
-} from "./token-goat-chunk-DHIXE6GV.mjs";
-import "./token-goat-chunk-BTKDZW7F.mjs";
+} from "./token-goat-chunk-PTW22MRC.mjs";
+import "./token-goat-chunk-T46UKRFM.mjs";
 import "./token-goat-chunk-XTQAOTSO.mjs";
 import "./token-goat-chunk-AH6QILZM.mjs";
-import "./token-goat-chunk-ZGQXRYKE.mjs";
+import "./token-goat-chunk-6LJNM4ZZ.mjs";
 import "./token-goat-chunk-NMTKNYGF.mjs";
 import "./token-goat-chunk-Y4AFKTHK.mjs";
 import "./token-goat-chunk-GMOUBOX4.mjs";

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

@@ -0,0 +1,128 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  renderWebFetchRow
+} from "./token-goat-chunk-VSJGPEBB.mjs";
+import {
+  SESSIONS_SUBDIR,
+  extractChecklistSection,
+  getSkillFilePath,
+  listSkills
+} from "./token-goat-chunk-KT75DZK4.mjs";
+import {
+  getBashOutput
+} from "./token-goat-chunk-SL454EN5.mjs";
+import {
+  loadBlob
+} from "./token-goat-chunk-K5XPIUVB.mjs";
+import {
+  resolveProjectRoot
+} from "./token-goat-chunk-74ADIZZX.mjs";
+import {
+  runGit,
+  safeSlice
+} from "./token-goat-chunk-6LJNM4ZZ.mjs";
+import {
+  displaySafePath,
+  displaySafeText,
+  neutralizeSpokenMarkers
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/resume.ts
+init_define_import_meta_env();
+import { readFile } from "node:fs/promises";
+var MAX_RESUME_TOKENS = 2e3;
+var MAX_RESUME_CHARS = MAX_RESUME_TOKENS * 4;
+var MAX_RESUME_WEB_FETCHES = 8;
+var SKILL_MAX_COUNT = 3;
+var SKILL_MAX_CHARS_EACH = 400;
+async function buildSkillsSection(sessionId) {
+  const skills = await listSkills(sessionId);
+  if (skills.length === 0) return [];
+  const skillLines = ["## Skills"];
+  for (const skill of skills.slice(0, SKILL_MAX_COUNT)) {
+    let checklist = null;
+    try {
+      const filePath = await getSkillFilePath(skill.name);
+      if (filePath !== null) {
+        const body = await readFile(filePath, "utf-8");
+        checklist = extractChecklistSection(body);
+      }
+    } catch {
+      checklist = null;
+    }
+    if (checklist !== null) {
+      const trimmed = checklist.length > SKILL_MAX_CHARS_EACH ? checklist.slice(0, SKILL_MAX_CHARS_EACH).trimEnd() + "\u2026" : checklist;
+      skillLines.push(`**${displaySafeText(skill.name)}**:`);
+      skillLines.push(neutralizeSpokenMarkers(trimmed));
+    } else {
+      skillLines.push(`**${displaySafeText(skill.name)}** \u2014 \`token-goat skill-body ${displaySafeText(skill.name)} --section DoD\``);
+    }
+  }
+  skillLines.push("");
+  return skillLines;
+}
+async function buildResumePacket(sessionId) {
+  const blob = loadBlob(SESSIONS_SUBDIR, sessionId);
+  if (blob === null || typeof blob !== "object") return null;
+  const raw = blob;
+  const filesArr = Array.isArray(raw["files"]) ? raw["files"] : [];
+  const lines = [`# Resume packet \u2014 session ${displaySafeText(sessionId)}`, ""];
+  try {
+    lines.push(...await buildSkillsSection(sessionId));
+  } catch {
+  }
+  const editedPaths = filesArr.filter((f) => f["wasEdited"] === true).map((f) => typeof f["path"] === "string" ? f["path"] : "").filter(Boolean).slice(0, 10);
+  if (editedPaths.length > 0) {
+    lines.push("## Edited files");
+    for (const p of editedPaths) lines.push(`- ${displaySafePath(p)}`);
+    lines.push("");
+  }
+  const topRead = [...filesArr].filter((f) => f["wasEdited"] !== true).sort((a, b) => (typeof b["readCount"] === "number" ? b["readCount"] : 0) - (typeof a["readCount"] === "number" ? a["readCount"] : 0)).slice(0, 8).map((f) => typeof f["path"] === "string" ? f["path"] : "").filter(Boolean);
+  if (topRead.length > 0) {
+    lines.push("## Top files read");
+    for (const p of topRead) lines.push(`- ${displaySafePath(p)}`);
+    lines.push("");
+  }
+  const bashOutputs = Array.isArray(raw["bashOutputs"]) ? raw["bashOutputs"] : [];
+  const recentBash = bashOutputs.slice(-2);
+  if (recentBash.length > 0) {
+    lines.push("## Recent bash commands");
+    for (const entry of recentBash) {
+      if (Array.isArray(entry) && typeof entry[1] === "string") {
+        const bashEntry = getBashOutput(entry[1]);
+        if (bashEntry !== null) lines.push(`- ${displaySafeText(bashEntry.command)}`);
+      }
+    }
+    lines.push("");
+  }
+  const webFetches = Array.isArray(raw["webFetches"]) ? raw["webFetches"] : [];
+  const webRows = webFetches.slice(-MAX_RESUME_WEB_FETCHES).filter((e) => Array.isArray(e) && typeof e[0] === "string" && typeof e[1] === "string").map(([key, cacheId]) => renderWebFetchRow(key, cacheId));
+  if (webRows.length > 0) {
+    lines.push("## Web pages fetched");
+    lines.push(...webRows);
+    lines.push("");
+  }
+  try {
+    const projectRoot = resolveProjectRoot();
+    const result = runGit(["diff", "--stat"], { cwd: projectRoot });
+    if (result.exitCode === 0 && result.stdout.trim().length > 0) {
+      lines.push("## Uncommitted changes (git diff --stat)");
+      lines.push(result.stdout.trim().split("\n").map(displaySafeText).join("\n"));
+      lines.push("");
+    }
+  } catch {
+  }
+  const text = lines.join("\n");
+  if (text.length <= MAX_RESUME_CHARS) return text;
+  return safeSlice(text, MAX_RESUME_CHARS) + "\n... (truncated to cap)\n";
+}
+
+export {
+  MAX_RESUME_TOKENS,
+  MAX_RESUME_CHARS,
+  buildResumePacket
+};