token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-4SMRO4TO.mjs

@@ -0,0 +1,366 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  registerHook,
+  sessionStateKey
+} from "./token-goat-chunk-C75NA7PL.mjs";
+import {
+  passOutput
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  HOOK_PROBE_ENV
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import {
+  getDb
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  getHarnessName
+} from "./token-goat-chunk-QYHO5CPH.mjs";
+import {
+  globalDbPath
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/hint_stats.ts
+init_define_import_meta_env();
+var HINT_CATEGORIES = [
+  "bash_redirect",
+  "bash_recall",
+  "read_reread_dedup",
+  "read_structural_nav",
+  "edit_reread_suggest",
+  // call_streak.ts: serial read-only calls that could have gone out in one message, and consecutive searches that found nothing. Both are scored by that module itself (see SELF_SCORED_HINT_CATEGORIES).
+  "read_batch",
+  "search_brake",
+  // The Grep/Glob dedup notes from hooks_common.ts's makeDedupHintHandlers. Logged with no correlator, so they count as spend and emissions but never as a verdict: the note is attached to the re-run it describes, so no later call can show whether it was heeded.
+  "grep_dedup_hint",
+  "glob_dedup_hint",
+  // recovery_pairs.ts: a failed Bash command that an earlier session learned a fix for. Logged with no correlator: the fix may be run in many spellings, so the pair store scores it (helped and hurt) rather than a pointer match.
+  "recovery_pair",
+  // edit_near_miss.ts: a failed Edit whose old_string differs from the file only by whitespace, punctuation or indentation. Logged with no correlator: the corrected edit may be retyped in any spelling, so it counts as spend and emissions but never a verdict.
+  "edit_near_miss",
+  // path_miss.ts: a tool call named a path that does not exist and an existing path is plausibly the one meant. Logged with no correlator: the corrected call may name the path in any spelling, so it counts as spend and emissions but never a verdict.
+  "path_miss"
+];
+function isHintCategory(value) {
+  return HINT_CATEGORIES.includes(value);
+}
+var ACTED_ON_WINDOW = 5;
+var KNOWN_CORRELATOR_PLACEHOLDERS = /* @__PURE__ */ new Set([
+  "Heading",
+  "HeadingName",
+  "SectionHeading",
+  "SectionName",
+  "sectionName",
+  "Symbol",
+  "SymbolName",
+  "table_name",
+  "name"
+]);
+function joinCorrelators(correlators) {
+  const kept = correlators.filter((c) => c !== "" && !c.includes("\n"));
+  return kept.length === 0 ? null : [...new Set(kept)].join("\n");
+}
+function splitCorrelators(correlator) {
+  return correlator.split("\n").filter((c) => c !== "");
+}
+function extractPathCorrelator(text) {
+  const m = /(?:[A-Za-z]:[\\/]|\.{1,2}\/|\/)[^\s"'`]+/.exec(text);
+  if (m === null) return null;
+  const cleaned = m[0].replace(/[`"'.,;:)]+$/, "");
+  const sepIdx = cleaned.indexOf("::");
+  if (sepIdx === -1) return cleaned;
+  const suffix = cleaned.slice(sepIdx + 2);
+  if (/^<[^<>]*>$/.test(suffix) || KNOWN_CORRELATOR_PLACEHOLDERS.has(suffix)) {
+    return cleaned.slice(0, sepIdx);
+  }
+  return cleaned;
+}
+function classifyBashHint(text) {
+  const fileMatch = /token-goat bash-output --file "([^"]+)"/.exec(text);
+  if (fileMatch?.[1] !== void 0) {
+    return { category: "bash_recall", correlator: fileMatch[1] };
+  }
+  const idMatch = /token-goat bash-output ([A-Za-z0-9_.-]+)/.exec(text);
+  if (idMatch?.[1] !== void 0) {
+    return { category: "bash_recall", correlator: idMatch[1] };
+  }
+  return { category: "bash_redirect", correlator: extractPathCorrelator(text) };
+}
+function classifyReadHint(text) {
+  const category = /already read|already been read/i.test(text) ? "read_reread_dedup" : "read_structural_nav";
+  return { category, correlator: extractPathCorrelator(text) };
+}
+function classifyEditHint(text) {
+  return { category: "edit_reread_suggest", correlator: extractPathCorrelator(text) };
+}
+function uncorrelatedHint(category) {
+  return () => ({ category, correlator: null });
+}
+var SELF_SCORED_HINT_CATEGORIES = /* @__PURE__ */ new Set(["read_batch", "search_brake"]);
+function settleSelfScoredHints(category, event, actedOn) {
+  try {
+    getDb(globalDbPath()).prepare(`UPDATE hint_emissions SET acted_on = ?, observable = ?, resolved = 1 WHERE category = ? AND session_id = ? AND correlator IS ? AND resolved = 0`).run(actedOn === true ? 1 : 0, actedOn === null ? 0 : 1, category, event.sessionId, sessionStateKey(event));
+  } catch {
+  }
+}
+function isProbeOccasion(occasion, thresholds) {
+  const sorted = [...new Set(thresholds.filter((t) => t > 0))].sort((a, b) => a - b);
+  if (sorted.length === 0) return false;
+  if (sorted.includes(occasion)) return true;
+  const last = sorted[sorted.length - 1];
+  return occasion > last && occasion % last === 0;
+}
+function bumpSuppressionStreak(category) {
+  try {
+    const db = getDb(globalDbPath());
+    const harness = getHarnessName();
+    db.prepare(
+      `INSERT INTO hint_suppression_probes (category, harness, streak) VALUES (@category, @harness, 1)
+       ON CONFLICT(category, harness) DO UPDATE SET streak = streak + 1`
+    ).run({ category, harness });
+    const row = db.prepare(`SELECT streak FROM hint_suppression_probes WHERE category = ? AND harness = ?`).get(category, harness);
+    return row?.streak ?? 0;
+  } catch {
+    return 0;
+  }
+}
+function resetSuppressionStreak(category) {
+  try {
+    const db = getDb(globalDbPath());
+    db.prepare(`UPDATE hint_suppression_probes SET streak = 0 WHERE category = ? AND harness = ?`).run(category, getHarnessName());
+  } catch {
+  }
+}
+function applyHintTracking(event, output, classify) {
+  if (output.hookType !== "context") return output;
+  if (process.env[HOOK_PROBE_ENV] === "1") return output;
+  const classified = classify(output.context);
+  const { category } = classified;
+  const correlator = output.correlators === void 0 ? classified.correlator : joinCorrelators(output.correlators);
+  const compensateSelfResolve = event.eventName === "pre_tool_use";
+  if (shouldSuppress(category, event.sessionId)) {
+    const occasion = bumpSuppressionStreak(category);
+    const thresholds = loadConfig().hints.backoff_thresholds;
+    if (!isProbeOccasion(occasion, thresholds)) {
+      logSuppressedDetection(category, event.sessionId, correlator);
+      return passOutput();
+    }
+    logHintEmission(category, event.sessionId, correlator, compensateSelfResolve, output.context.length);
+    return output;
+  }
+  resetSuppressionStreak(category);
+  logHintEmission(category, event.sessionId, correlator, compensateSelfResolve, output.context.length);
+  return output;
+}
+function logSuppressedDetection(category, sessionId, correlator) {
+  try {
+    getDb(globalDbPath()).prepare(
+      `INSERT INTO hint_emissions (category, session_id, harness, correlator, emitted_at, resolved, acted_on, calls_remaining, bytes_emitted, observable, displayed)
+         VALUES (@category, @sessionId, @harness, @correlator, @emittedAt, 1, 0, 0, 0, 0, 0)`
+    ).run({ category, sessionId, harness: getHarnessName(), correlator, emittedAt: Date.now() });
+  } catch {
+  }
+}
+function logHintEmission(category, sessionId, correlator, compensateSelfResolve = false, bytesEmitted = null) {
+  try {
+    const db = getDb(globalDbPath());
+    const observable = correlator !== null || SELF_SCORED_HINT_CATEGORIES.has(category);
+    const resolved = observable ? 0 : 1;
+    const window = ACTED_ON_WINDOW + (compensateSelfResolve ? 1 : 0);
+    db.prepare(
+      `INSERT INTO hint_emissions (category, session_id, harness, correlator, emitted_at, resolved, acted_on, calls_remaining, bytes_emitted, observable)
+       VALUES (@category, @sessionId, @harness, @correlator, @emittedAt, @resolved, 0, @callsRemaining, @bytesEmitted, @observable)`
+    ).run({
+      category,
+      sessionId,
+      harness: getHarnessName(),
+      correlator,
+      emittedAt: Date.now(),
+      resolved,
+      callsRemaining: observable ? window : 0,
+      bytesEmitted,
+      observable: observable ? 1 : 0
+    });
+  } catch {
+  }
+}
+var TOKEN_GOAT_INVOCATION_RE = /(?:^|[\s;&|])(?:token-goat|tg)(?=[\s]|$)/;
+function commandMentionsCorrelator(command, correlator) {
+  let idx = command.indexOf(correlator);
+  while (idx !== -1) {
+    const before = idx > 0 ? command[idx - 1] : void 0;
+    const after = command[idx + correlator.length];
+    const beforeOk = before === void 0 || !/[A-Za-z0-9_.-]/.test(before);
+    const afterOk = after === void 0 || !/[A-Za-z0-9_.-]/.test(after);
+    if (beforeOk && afterOk) return true;
+    idx = command.indexOf(correlator, idx + 1);
+  }
+  return false;
+}
+var SUPPRESSION_HINT_CATEGORIES = /* @__PURE__ */ new Set([
+  "read_reread_dedup",
+  "edit_reread_suggest",
+  "read_structural_nav"
+]);
+function isSuppressionCategory(category) {
+  return SUPPRESSION_HINT_CATEGORIES.has(category);
+}
+var EVENT_PATH_KEYS = ["file_path", "filePath", "notebook_path", "path"];
+function eventTargetText(event) {
+  if (event.toolName === "Bash") {
+    const c = event.toolInput["command"];
+    return typeof c === "string" ? c : "";
+  }
+  for (const key of EVENT_PATH_KEYS) {
+    const v = event.toolInput[key];
+    if (typeof v === "string" && v !== "") return v;
+  }
+  return "";
+}
+function isDefiance(correlator, target) {
+  if (target === "") return false;
+  if (TOKEN_GOAT_INVOCATION_RE.test(target)) return false;
+  return splitCorrelators(correlator).some((c) => commandMentionsCorrelator(target, c));
+}
+function isActedOn(category, correlator, command) {
+  if (!TOKEN_GOAT_INVOCATION_RE.test(command)) return false;
+  const anyMatch = splitCorrelators(correlator).some((c) => commandMentionsCorrelator(command, c));
+  if (category === "bash_recall") return command.includes("bash-output") && anyMatch;
+  return anyMatch;
+}
+function resolvePendingHintsForEvent(event) {
+  try {
+    const db = getDb(globalDbPath());
+    const command = event.toolName === "Bash" && typeof event.toolInput["command"] === "string" ? event.toolInput["command"] : "";
+    const target = eventTargetText(event);
+    const pending = db.prepare(`SELECT id, category, correlator, calls_remaining FROM hint_emissions WHERE session_id = ? AND resolved = 0`).all(event.sessionId);
+    for (const row of pending) {
+      if (isHintCategory(row.category) && SELF_SCORED_HINT_CATEGORIES.has(row.category)) continue;
+      if (!isHintCategory(row.category) || row.correlator === null) {
+        db.prepare(`UPDATE hint_emissions SET acted_on = 0, resolved = 1, observable = 0 WHERE id = ?`).run(row.id);
+        continue;
+      }
+      if (isSuppressionCategory(row.category)) {
+        if (isDefiance(row.correlator, target)) {
+          db.prepare(`UPDATE hint_emissions SET acted_on = 0, resolved = 1 WHERE id = ?`).run(row.id);
+          continue;
+        }
+        if (command !== "" && isActedOn(row.category, row.correlator, command)) {
+          db.prepare(`UPDATE hint_emissions SET acted_on = 1, resolved = 1 WHERE id = ?`).run(row.id);
+          continue;
+        }
+        const left = row.calls_remaining - 1;
+        if (left <= 0) {
+          db.prepare(`UPDATE hint_emissions SET acted_on = 1, resolved = 1 WHERE id = ?`).run(row.id);
+        } else {
+          db.prepare(`UPDATE hint_emissions SET calls_remaining = ? WHERE id = ?`).run(left, row.id);
+        }
+        continue;
+      }
+      if (command !== "" && isActedOn(row.category, row.correlator, command)) {
+        db.prepare(`UPDATE hint_emissions SET acted_on = 1, resolved = 1 WHERE id = ?`).run(row.id);
+        continue;
+      }
+      const remaining = row.calls_remaining - 1;
+      if (remaining <= 0) {
+        db.prepare(`UPDATE hint_emissions SET resolved = 1 WHERE id = ?`).run(row.id);
+      } else {
+        db.prepare(`UPDATE hint_emissions SET calls_remaining = ? WHERE id = ?`).run(remaining, row.id);
+      }
+    }
+  } catch {
+  }
+}
+registerHook(
+  "post_tool_use",
+  (event) => {
+    resolvePendingHintsForEvent(event);
+    return passOutput();
+  },
+  { advisory: true, followsMatcher: true }
+);
+function categoryStats(category, sessionId) {
+  const db = getDb(globalDbPath());
+  const scope = sessionId === void 0 ? "harness = ?" : "session_id = ?";
+  const row = db.prepare(
+    `SELECT COALESCE(SUM(CASE WHEN displayed = 1 AND observable = 1 AND resolved = 1 THEN 1 ELSE 0 END), 0) AS emitted,
+              SUM(CASE WHEN displayed = 1 AND observable = 1 AND resolved = 1 THEN acted_on ELSE 0 END) AS actedOn,
+              COALESCE(SUM(CASE WHEN displayed = 1 AND observable = 1 AND resolved = 0 THEN 1 ELSE 0 END), 0) AS pending,
+              COALESCE(SUM(CASE WHEN displayed = 1 AND observable = 0 THEN 1 ELSE 0 END), 0) AS unobservable,
+              COALESCE(SUM(CASE WHEN displayed = 0 THEN 1 ELSE 0 END), 0) AS detected,
+              SUM(bytes_emitted) AS bytesEmitted,
+              SUM(CASE WHEN bytes_emitted IS NULL THEN 1 ELSE 0 END) AS legacyEmissions
+       FROM hint_emissions WHERE category = ? AND ${scope}`
+  ).get(category, sessionId ?? getHarnessName());
+  return row ?? { emitted: 0, actedOn: 0, pending: 0, unobservable: 0, detected: 0, bytesEmitted: null, legacyEmissions: 0 };
+}
+function shouldSuppress(category, _sessionId) {
+  try {
+    const { emitted, actedOn } = categoryStats(category);
+    return suppressesAt(emitted, actedOn ?? 0, loadConfig().hint_stats, isSuppressionCategory(category));
+  } catch {
+    return false;
+  }
+}
+function suppressesAt(emitted, actedOn, cfg, inverted) {
+  if (emitted < cfg.min_sample_size) return false;
+  const barPct = inverted ? 100 - cfg.defiance_threshold_pct : cfg.suppress_threshold_pct;
+  return 100 * wilsonInterval(actedOn, emitted).hi < barPct;
+}
+function wilsonInterval(k, n, z = 1.96) {
+  if (n <= 0) return { lo: 0, hi: 1 };
+  const phat = k / n;
+  const z2 = z * z;
+  const denom = 1 + z2 / n;
+  const centre = phat + z2 / (2 * n);
+  const margin = z * Math.sqrt(phat * (1 - phat) / n + z2 / (4 * n * n));
+  return { lo: k <= 0 ? 0 : Math.max(0, (centre - margin) / denom), hi: k >= n ? 1 : Math.min(1, (centre + margin) / denom) };
+}
+function meetsSavingsFloor(bytesSaved) {
+  return bytesSaved >= loadConfig().hints.min_session_hint_savings_bytes;
+}
+function resetHintStats() {
+  const db = getDb(globalDbPath());
+  db.exec("DELETE FROM hint_emissions");
+  db.exec("DELETE FROM hint_manual_marks");
+  db.exec("DELETE FROM hint_suppression_probes");
+}
+function bumpManualMark(category, column) {
+  const db = getDb(globalDbPath());
+  db.prepare(
+    `INSERT INTO hint_manual_marks (category, effective_count, ineffective_count) VALUES (?, 0, 0)
+     ON CONFLICT(category) DO NOTHING`
+  ).run(category);
+  db.prepare(`UPDATE hint_manual_marks SET ${column} = ${column} + 1 WHERE category = ?`).run(category);
+}
+function markCategoryEffective(category) {
+  bumpManualMark(category, "effective_count");
+}
+function markCategoryIneffective(category) {
+  bumpManualMark(category, "ineffective_count");
+}
+
+export {
+  HINT_CATEGORIES,
+  isHintCategory,
+  classifyBashHint,
+  classifyReadHint,
+  classifyEditHint,
+  uncorrelatedHint,
+  settleSelfScoredHints,
+  applyHintTracking,
+  logSuppressedDetection,
+  isSuppressionCategory,
+  categoryStats,
+  shouldSuppress,
+  meetsSavingsFloor,
+  resetHintStats,
+  markCategoryEffective,
+  markCategoryIneffective
+};