token-goat 2.9.30 → 2.9.31

package/dist/token-goat-chunk-646E6U44.mjs

@@ -0,0 +1,398 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  MAX_LINES_FOR_DIFF,
+  lcsLength,
+  readKnownText,
+  readShapeOf,
+  splitLines
+} from "./token-goat-chunk-5AC66HNP.mjs";
+import "./token-goat-chunk-WBA5SKT4.mjs";
+import {
+  sessionStateKey
+} from "./token-goat-chunk-C75NA7PL.mjs";
+import {
+  preToolPathDeclined
+} from "./token-goat-chunk-P6VGNTQT.mjs";
+import {
+  contextOutput,
+  denyOutput,
+  getCwd,
+  getFilePath,
+  getToolInput,
+  getToolName,
+  passOutput,
+  resolveEventPath
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  dropFileLineRangesIfChanged,
+  getFileLineRanges,
+  markHintShown,
+  wasFileFullyReadThisSession,
+  wasHintShown
+} from "./token-goat-chunk-GL3ETKSC.mjs";
+import {
+  recordStat
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import "./token-goat-chunk-GVB2MUST.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
+import "./token-goat-chunk-OUKDTVNU.mjs";
+import "./token-goat-chunk-BFCWY73P.mjs";
+import "./token-goat-chunk-KGEFFSHD.mjs";
+import "./token-goat-chunk-XX6O25RN.mjs";
+import "./token-goat-chunk-HAVAOB3S.mjs";
+import "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import {
+  fingerprintContent,
+  resolveProjectRoot
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import {
+  isWithinQuietHours
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  canQuoteArg,
+  echoedValue,
+  fencedCommand,
+  fileSubject,
+  quotedArg
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import {
+  canonicalize
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  displaySafePath,
+  normalizePath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/write_guard_hooks.ts
+init_define_import_meta_env();
+
+// src/sibling_copy.ts
+init_define_import_meta_env();
+import { basename, dirname, extname, join } from "node:path";
+var BACKUP_EXTENSIONS = /* @__PURE__ */ new Set([".bak", ".orig", ".new"]);
+var VERSIONED_STEM = /^(.*\D)[_.-]?v\d+$/i;
+var COPY_SUFFIX_STEM = /^(.+?)(?:[_.-](?:new|fixed|copy|old|orig|backup|bak)| copy| - copy| \(\d+\))$/i;
+var SERIES_DIRECTORIES = /* @__PURE__ */ new Set(["migrations", "versions", "fixtures", "__snapshots__"]);
+var VERSION_DIRECTORY = /^v\d+$/i;
+function siblingCandidates(filePath) {
+  const dir = dirname(filePath);
+  const base = basename(filePath);
+  const ext = extname(base);
+  const stem = ext === "" ? base : base.slice(0, -ext.length);
+  const names = [];
+  if (BACKUP_EXTENSIONS.has(ext.toLowerCase()) && extname(stem) !== "") names.push(stem);
+  const versioned = VERSIONED_STEM.exec(stem);
+  if (versioned !== null) names.push(versioned[1].replace(/[_.-]+$/, "") + ext);
+  const copied = COPY_SUFFIX_STEM.exec(stem);
+  if (copied !== null) names.push(copied[1] + ext);
+  return names.filter((name, i) => name !== "" && name !== ext && name !== base && names.indexOf(name) === i).map((name) => join(dir, name));
+}
+function globToRegExp(glob) {
+  let source = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*" && glob[i + 1] === "*") {
+      source += ".*";
+      i++;
+    } else if (c === "*") {
+      source += "[^/]*";
+    } else if (c === "?") {
+      source += "[^/]";
+    } else {
+      source += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp("(?:^|/)" + source + "$", "i");
+}
+function directorySegments(normalized, projectRoot) {
+  const root = projectRoot === null ? "" : projectRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (root !== "" && normalized.toLowerCase().startsWith(root.toLowerCase() + "/")) return normalized.slice(root.length + 1).split("/").slice(0, -1).map((s) => s.toLowerCase());
+  if (root === "") return normalized.split("/").slice(0, -1).map((s) => s.toLowerCase());
+  return normalized.split("/").slice(-2, -1).map((s) => s.toLowerCase());
+}
+function siblingCopyExcluded(filePath, allow, projectRoot) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const segments = directorySegments(normalized, projectRoot);
+  if (segments.some((s) => SERIES_DIRECTORIES.has(s) || VERSION_DIRECTORY.test(s))) return true;
+  return allow.some((glob) => glob !== "" && globToRegExp(glob.replace(/\\/g, "/")).test(normalized));
+}
+function siblingCopyMessage(original, unchangedPct) {
+  const shown = displaySafePath(original);
+  const outline = canQuoteArg(shown) ? `, or run ${fencedCommand("token-goat outline " + quotedArg(shown))} to find the part to change` : "";
+  return `This new file repeats about ${Math.round(unchangedPct)}% of an existing file in the same directory. Edit the original with \`Edit\` or \`token-goat replace\` instead of writing a second copy of it${outline}. If a separate copy is intended, carry on.`;
+}
+
+// src/write_guards.ts
+init_define_import_meta_env();
+var ELLIPSIS = String.raw`(?:\.{3}|…)`;
+var COMMENT_LEAD = String.raw`(?:/{2,}|#+|/\*+|\*+|<!--|--|;+|%+|"""|''')`;
+var COMMENT_CLOSE = String.raw`(?:\*+/|-->|"""|''')`;
+var KEYWORD = String.raw`(?:rest|remainder|remaining|existing|unchanged|omitted|truncated|previous|same as|other)`;
+var SUBJECT = String.raw`(?:rest of (?:the )?(?:file|code|content|function|class|module|implementation|method)|existing (?:code|content|implementation)|remaining (?:code|content|lines|implementation)|previous (?:code|content))`;
+var REST_SUBJECT = String.raw`(?:rest of (?:the )?(?:file|code|content|function|class|module|implementation|method)|remaining (?:code|content|lines|implementation))`;
+var TRAILER = String.raw`(?:(?:is |remains |stays |goes )?(?:unchanged|here|omitted|as[- ]is|the same|same as before|as before|above|below))`;
+var MAX_ELISION_LINE_CHARS = 120;
+var LEADING_COMMENT = new RegExp(`^${COMMENT_LEAD}`);
+var TRAILING_COMMENT = new RegExp(`${COMMENT_CLOSE}$`);
+var ANY_ELLIPSIS = new RegExp(ELLIPSIS, "g");
+var HAS_ELLIPSIS = new RegExp(ELLIPSIS);
+var STARTS_WITH_ELLIPSIS = new RegExp(`^${ELLIPSIS}`);
+var ENDS_WITH_ELLIPSIS = new RegExp(`${ELLIPSIS}$`);
+var LEAD_THEN_TRAILER = new RegExp(`^(?:keep )?(?:the )?${KEYWORD}(?: \\S+){0,4}? (?:unchanged|here|omitted|truncated|as[- ]is|the same|as before|above|below)$`, "i");
+var WRAPPED_MARKER = new RegExp(`^(?:the )?${KEYWORD}(?: \\S+){0,3}$`, "i");
+var SUBJECT_ONLY = new RegExp(`^${SUBJECT}(?: ${TRAILER})?$`, "i");
+var SUBJECT_QUALIFIED = new RegExp(`^${SUBJECT} (?:(?:is |are |remains? |stays? )?(?:unchanged|omitted|truncated|not shown|as[- ]is|as before|same as before)|(?:remains?|stays?|is|are) (?:the )?same)$`, "i");
+var REST_PLACED = new RegExp(`^(?:${REST_SUBJECT} (?:(?:goes |is |comes )?(?:here|above|below)|follows)|rest of (?:the )?implementation)$`, "i");
+var ELLIPSIS_QUALIFIER = new RegExp(`^(?:(?:the )?(?:same as before|as before|unchanged|omitted|truncated|not shown)|\\d+ (?:more )?\\S+ (?:omitted|truncated|not shown|unchanged|hidden|elided))$`, "i");
+var BRACKET_NOTE = new RegExp(`^(?:truncated|omitted|content (?:truncated|omitted)|(?:remaining|rest of)[^\\]]{0,60}(?:omitted|truncated|unchanged)|\\d+ (?:more )?lines? (?:omitted|truncated|folded))$`, "i");
+var FOLD_MARKER = new RegExp(`^${ELLIPSIS}\\s*\\d+\\s+(?:more\\s+)?lines?\\b.*\\bfolded\\b`, "i");
+var TOKEN_GOAT_NOTICE = /^\[token-goat[: ].{0,200}\]$/;
+function spaced(text) {
+  return text.replace(ANY_ELLIPSIS, " ").replace(/\s+/g, " ").trim();
+}
+function isElisionLine(trimmed) {
+  if (trimmed === "" || trimmed.length > MAX_ELISION_LINE_CHARS) return false;
+  if (TOKEN_GOAT_NOTICE.test(trimmed) || FOLD_MARKER.test(trimmed)) return true;
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) return BRACKET_NOTE.test(spaced(trimmed.slice(1, -1)));
+  const led = LEADING_COMMENT.test(trimmed);
+  if (!led && !STARTS_WITH_ELLIPSIS.test(trimmed)) return false;
+  const body = led ? trimmed.replace(LEADING_COMMENT, "").replace(TRAILING_COMMENT, "").trim() : trimmed;
+  const payload = spaced(body).replace(/^[([](.*)[)\]]$/, "$1").trim();
+  const hasEllipsis = HAS_ELLIPSIS.test(body);
+  if (!hasEllipsis) return SUBJECT_QUALIFIED.test(payload) || REST_PLACED.test(payload);
+  if (SUBJECT_ONLY.test(payload) || ELLIPSIS_QUALIFIER.test(payload)) return true;
+  return LEAD_THEN_TRAILER.test(payload) || STARTS_WITH_ELLIPSIS.test(body) && ENDS_WITH_ELLIPSIS.test(body) && WRAPPED_MARKER.test(payload);
+}
+function findNewElisionLine(newText, knownText) {
+  let known;
+  for (const raw of splitLines(newText)) {
+    const trimmed = raw.trim();
+    if (!isElisionLine(trimmed)) continue;
+    known ??= new Set(splitLines(typeof knownText === "function" ? knownText() : knownText).map((l) => l.trim()));
+    if (!known.has(trimmed)) return trimmed;
+  }
+  return null;
+}
+function patchAddedLines(patch) {
+  const files = [];
+  let current;
+  for (const line of patch.split(/\r\n|\r|\n/)) {
+    const header = /^\*\*\* (?:Add|Update) File: (.+)$/.exec(line);
+    const moved = /^\*\*\* Move to: (.+)$/.exec(line);
+    if (header !== null) {
+      current = { path: header[1].trim(), added: [] };
+      files.push(current);
+    } else if (moved !== null && current !== void 0) {
+      current.path = moved[1].trim();
+    } else if (line.startsWith("*** ")) {
+      current = void 0;
+    } else if (current !== void 0 && line.startsWith("+")) {
+      current.added.push(line.slice(1));
+    }
+  }
+  return files;
+}
+var MAX_DIFF_SPAN = 2e3;
+function removedLineIndexes(oldLines, newLines) {
+  let head = 0;
+  while (head < oldLines.length && head < newLines.length && oldLines[head] === newLines[head]) head++;
+  let tail = 0;
+  while (tail < oldLines.length - head && tail < newLines.length - head && oldLines[oldLines.length - 1 - tail] === newLines[newLines.length - 1 - tail]) tail++;
+  const n = oldLines.length - head - tail;
+  const m = newLines.length - head - tail;
+  const removed = [];
+  if (m === 0 || n > MAX_DIFF_SPAN || m > MAX_DIFF_SPAN) {
+    for (let i2 = 0; i2 < n; i2++) removed.push(head + i2);
+    return removed;
+  }
+  const width = m + 1;
+  const goesLeft = new Uint8Array(Math.ceil((n + 1) * width / 8));
+  let above = new Uint16Array(width);
+  let row = new Uint16Array(width);
+  for (let i2 = 1; i2 <= n; i2++) {
+    for (let j2 = 1; j2 <= m; j2++) {
+      if (oldLines[head + i2 - 1] === newLines[head + j2 - 1]) {
+        row[j2] = (above[j2 - 1] ?? 0) + 1;
+      } else {
+        const left = row[j2 - 1] ?? 0;
+        const up = above[j2] ?? 0;
+        row[j2] = Math.max(left, up);
+        if (left >= up) goesLeft[i2 * width + j2 >> 3] |= 1 << (i2 * width + j2 & 7);
+      }
+    }
+    ;
+    [above, row] = [row, above];
+  }
+  let i = n;
+  let j = m;
+  while (i > 0) {
+    if (j > 0 && oldLines[head + i - 1] === newLines[head + j - 1]) {
+      i--;
+      j--;
+    } else if (j > 0 && ((goesLeft[i * width + j >> 3] ?? 0) & 1 << (i * width + j & 7)) !== 0) {
+      j--;
+    } else {
+      removed.push(head + i - 1);
+      i--;
+    }
+  }
+  return removed.reverse();
+}
+function unseenRemovedRuns(oldLines, newLines, served) {
+  const unseen = removedLineIndexes(oldLines, newLines).map((i) => i + 1).filter((line) => !served.some(([s, e]) => line >= s && line <= e));
+  const runs = [];
+  for (const line of unseen) {
+    const last = runs[runs.length - 1];
+    if (last !== void 0 && last[1] === line - 1) last[1] = line;
+    else runs.push([line, line]);
+  }
+  return runs;
+}
+var BLIND_DROP_MIN_LINES = 5;
+function countRunLines(runs) {
+  return runs.reduce((sum, [s, e]) => sum + (e - s + 1), 0);
+}
+var ELISION_ADVICE = "Write the real content, or change only the part you mean to with `Edit` or `token-goat replace`. If this exact text is intended, repeat the identical call and it goes through.";
+function placeholderMessage(line) {
+  const shown = echoedValue(line.length > 100 ? line.slice(0, 100) + "..." : line);
+  return `This call writes a placeholder line (${shown}) that is not in the file now. Written as it stands, that line replaces whatever it stands for. ${ELISION_ADVICE}`;
+}
+var MAX_QUOTED_PLACEHOLDERS = 3;
+function placeholdersMessage(found) {
+  if (found.length === 1) return placeholderMessage(found[0]);
+  const quoted = found.slice(0, MAX_QUOTED_PLACEHOLDERS).map((line) => echoedValue(line.length > 100 ? line.slice(0, 100) + "..." : line));
+  const more = found.length > quoted.length ? ` and ${found.length - quoted.length} more` : "";
+  return `This call writes ${found.length} placeholder lines (${quoted.join(", ")}${more}) that are not in the files now. Written as they stand, each replaces whatever it stands for. ${ELISION_ADVICE}`;
+}
+function blindDropMessage(filePath, runs) {
+  const total = countRunLines(runs);
+  const named = [...runs].sort((a, b) => b[1] - b[0] - (a[1] - a[0])).slice(0, 3).sort((a, b) => a[0] - b[0]);
+  const shownPath = displaySafePath(filePath);
+  const commands = named.map(([s, e]) => fencedCommand("token-goat read " + quotedArg(`${shownPath}@${s}-${e}`)));
+  return `This Write would delete ${total} lines of ${fileSubject(commands.join(" "), shownPath, filePath)} that this session never read in full (lines ${named.map(([s, e]) => s === e ? String(s) : `${s}-${e}`).join(", ")}). Read them first with ${commands.join(" or ")}, or change only what you mean to with \`Edit\` or \`token-goat replace\`. If dropping them is intended, repeat the identical call and it goes through.`;
+}
+
+// src/write_guard_hooks.ts
+function guardVerdict(key, message, detail) {
+  const hints = loadConfig().hints;
+  const policy = hints.write_blind_drop;
+  if (policy === "off" || wasHintShown(key)) return passOutput();
+  if (policy === "warn" && isWithinQuietHours(hints.quiet_hours)) return passOutput();
+  markHintShown(key);
+  recordStat("write_blind_drop", 0, 0, void 0, detail);
+  return policy === "deny" ? denyOutput(message) : contextOutput(message);
+}
+function guardKey(kind, file, text) {
+  return "write_blind_drop:" + kind + ":" + fingerprintContent(file + "\0" + text);
+}
+function placeholderGuard(event, filePath, newText, knownText) {
+  if (loadConfig().hints.write_blind_drop === "off") return passOutput();
+  const line = findNewElisionLine(newText, knownText);
+  if (line === null) return passOutput();
+  return guardVerdict(guardKey("placeholder", filePath, newText), placeholderMessage(line), "kind=placeholder tool=" + (getToolName(event) ?? "unknown"));
+}
+function blindDropGuard(event, filePath, newContent, oldLines, newLines) {
+  if (loadConfig().hints.write_blind_drop === "off") return passOutput();
+  const normalized = normalizePath(filePath);
+  const shape = readShapeOf(sessionStateKey(event), normalized);
+  if (shape === null || shape === "fold" || shape === "truncated") return passOutput();
+  if (wasFileFullyReadThisSession(normalized)) return passOutput();
+  dropFileLineRangesIfChanged(normalized);
+  const served = getFileLineRanges(normalized);
+  if (shape === "partial" && served.length === 0) return passOutput();
+  const runs = unseenRemovedRuns(oldLines, newLines, served);
+  if (countRunLines(runs) < BLIND_DROP_MIN_LINES) return passOutput();
+  return guardVerdict(guardKey("blind", filePath, newContent), blindDropMessage(filePath, runs), "kind=blind_drop last_read=" + shape + " lines=" + countRunLines(runs));
+}
+function siblingCopyGuard(event, filePath, newContent) {
+  const cfg = loadConfig().hints;
+  if (!cfg.write_sibling_copy) return passOutput();
+  const candidates = siblingCandidates(filePath);
+  if (candidates.length === 0) return passOutput();
+  const cwd = getCwd(event);
+  if (siblingCopyExcluded(canonicalize(filePath, cwd), cfg.write_sibling_copy_allow, cwd === void 0 ? null : resolveProjectRoot({ project: cwd }))) return passOutput();
+  const newLines = splitLines(newContent);
+  if (newLines.length > MAX_LINES_FOR_DIFF) return passOutput();
+  for (const original of candidates) {
+    const oldLines = splitLines(readKnownText(original));
+    if (oldLines.length < cfg.write_rewrite_min_lines || oldLines.length > MAX_LINES_FOR_DIFF) continue;
+    const unchangedPct = lcsLength(oldLines, newLines) / oldLines.length * 100;
+    if (unchangedPct < cfg.write_rewrite_unchanged_pct) continue;
+    const key = "write_sibling_copy:" + fingerprintContent(original);
+    if (wasHintShown(key)) return passOutput();
+    markHintShown(key);
+    const shownPct = Math.round(unchangedPct);
+    recordStat("write_sibling_copy", 0, 0, void 0, "unchanged_pct=" + shownPct);
+    return contextOutput(siblingCopyMessage(original, unchangedPct));
+  }
+  return passOutput();
+}
+var MAX_EDIT_FILES_CHECKED = 20;
+function preEditPlaceholderGuard(event) {
+  if (loadConfig().hints.write_blind_drop === "off") return passOutput();
+  const input = getToolInput(event);
+  const patch = typeof input["command"] === "string" ? input["command"] : input["input"];
+  if (typeof patch === "string" && input["new_string"] === void 0 && input["edits"] === void 0 && input["replacements"] === void 0) {
+    for (const file of patchAddedLines(patch)) {
+      const target = resolveEventPath(event, file.path);
+      if (preToolPathDeclined(event, target)) continue;
+      const verdict2 = placeholderGuard(event, target, file.added.join("\n"), () => readKnownText(target));
+      if (verdict2.hookType !== "pass") return verdict2;
+    }
+    return passOutput();
+  }
+  const known = /* @__PURE__ */ new Map();
+  const fileText = (path) => {
+    let text = known.get(path);
+    if (text === void 0) known.set(path, text = readKnownText(path));
+    return text;
+  };
+  const edits = [];
+  if (Array.isArray(input["replacements"])) {
+    for (const raw of input["replacements"]) {
+      const named = raw !== null && typeof raw === "object" ? raw["filePath"] : void 0;
+      edits.push({ path: typeof named === "string" && named !== "" ? resolveEventPath(event, named) : void 0, raw });
+    }
+  } else {
+    const filePath = getFilePath(event);
+    for (const raw of Array.isArray(input["edits"]) ? input["edits"] : [input]) edits.push({ path: filePath, raw });
+  }
+  const flagged = [];
+  const examined = /* @__PURE__ */ new Set();
+  for (const { path, raw } of edits) {
+    if (path === void 0 || raw === null || typeof raw !== "object" || preToolPathDeclined(event, path)) continue;
+    const edit = raw;
+    const newString = edit["new_string"] ?? edit["newString"];
+    if (typeof newString !== "string") continue;
+    if (!examined.has(path)) {
+      if (examined.size >= MAX_EDIT_FILES_CHECKED) continue;
+      examined.add(path);
+    }
+    const oldString = edit["old_string"] ?? edit["oldString"];
+    const replaced = typeof oldString === "string" ? oldString : "";
+    const line = findNewElisionLine(newString, () => fileText(path) + "\n" + replaced);
+    const key = guardKey("placeholder", path, newString);
+    if (line !== null && !wasHintShown(key)) flagged.push({ line, key });
+  }
+  if (flagged.length === 0) return passOutput();
+  const verdict = guardVerdict(flagged[0].key, placeholdersMessage(flagged.map((f) => f.line)), "kind=placeholder tool=" + (getToolName(event) ?? "unknown") + " entries=" + flagged.length);
+  if (verdict.hookType !== "pass") for (const { key } of flagged) markHintShown(key);
+  return verdict;
+}
+export {
+  blindDropGuard,
+  placeholderGuard,
+  preEditPlaceholderGuard,
+  siblingCopyGuard
+};

package/dist/token-goat-chunk-65N4RHP4.mjs

@@ -0,0 +1,33 @@
+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/windows_powershell.ts
+init_define_import_meta_env();
+
+// src/windows_system32.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+var DEFAULT_WINDOWS_DIR = "C:\\Windows";
+function windowsSystem32Exe(...rel) {
+  const missing = path.join(DEFAULT_WINDOWS_DIR, "System32", ...rel);
+  for (const root of [process.env["SystemRoot"], process.env["windir"], DEFAULT_WINDOWS_DIR]) {
+    if (root === void 0 || !path.win32.isAbsolute(root)) continue;
+    const exe = path.join(root, "System32", ...rel);
+    if (fs.existsSync(exe)) return exe;
+  }
+  return missing;
+}
+
+// src/windows_powershell.ts
+function windowsPowerShellPath() {
+  return windowsSystem32Exe("WindowsPowerShell", "v1.0", "powershell.exe");
+}
+
+export {
+  windowsSystem32Exe,
+  windowsPowerShellPath
+};

package/dist/{token-goat-chunk-JN4XMLSD.mjs → token-goat-chunk-6DG6HWP3.mjs}

@@ -3,6 +3,12 @@ const require = __cjsRequire(import.meta.url);
 import {
   external_exports
 } from "./token-goat-chunk-3U6ZYVX5.mjs";
+import {
+  answeringMcpToolCall
+} from "./token-goat-chunk-KGEFFSHD.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-FNFBKLRD.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -113,7 +119,7 @@ var McpServer = class {
           await this.send({ jsonrpc: "2.0", id, result: await this.callTool(params) });
           return;
         default:
-          await this.sendError(id, JSONRPC_METHOD_NOT_FOUND, `Method not found: ${method}`);
+          await this.sendError(id, JSONRPC_METHOD_NOT_FOUND, `Method not found: ${displaySafeText(method)}`);
           return;
       }
     } catch (err) {
@@ -157,7 +163,7 @@ var McpServer = class {
       );
     }
     try {
-      return await handler(parsed.data);
+      return await answeringMcpToolCall(() => handler(parsed.data), new Set(this.tools.keys()));
     } catch (err) {
       return errorText(err instanceof Error ? err.message : String(err));
     }