token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-57BIAXJL.mjs

@@ -0,0 +1,286 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  GROK_HOOK_SCRIPT,
+  VSCODE_CLAUDE_HOOKS_TURNED_OFF_TEXT,
+  disableVscodeClaudeHooks,
+  grokConfigPath,
+  grokHookScriptPath,
+  installAntigravity,
+  installGemini,
+  installGrok,
+  installKimi,
+  installOpenclaw,
+  installOpencode,
+  installPi,
+  installQwen,
+  isAntigravityInstalled,
+  isGeminiInstalled,
+  isGrokInstalled,
+  isKimiInstalled,
+  isOpenclawInstalled,
+  isOpencodeInstalled,
+  isPiInstalled,
+  isQwenInstalled,
+  kimiConfigPath,
+  kimiHookScriptPath,
+  vscodeHooksInstalled,
+  vscodeRunsTokenGoatClaudeHooks,
+  wiredGrokHookWords,
+  wiredKimiHookWords
+} from "./token-goat-chunk-AUQYRMMH.mjs";
+import {
+  CLAUDECODE_HOOK_SCRIPT,
+  CODEX_HOOK_SCRIPT,
+  COPILOT_CLI_HOOK_SCRIPT,
+  claudeHookScriptPath,
+  codexConfigPath,
+  codexHookScriptPath,
+  copilotCliConfigPath,
+  copilotCliScriptPath,
+  hookEventGaps,
+  installCodex,
+  installHooks,
+  isCodexInstalled,
+  isCopilotCliInstalled,
+  isInstalled,
+  parseNativeInvocation,
+  repairCopilotCliHooks,
+  wiredCodexHookWords,
+  wiredCopilotHookWords
+} from "./token-goat-chunk-7MAOA6X4.mjs";
+import "./token-goat-chunk-CXHOFN7R.mjs";
+import "./token-goat-chunk-QQTWJY2O.mjs";
+import "./token-goat-chunk-G5PJ7AGM.mjs";
+import "./token-goat-chunk-BPGCUMR7.mjs";
+import "./token-goat-chunk-C75NA7PL.mjs";
+import "./token-goat-chunk-CBIQ7WTD.mjs";
+import "./token-goat-chunk-76FGDLRO.mjs";
+import "./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 "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import "./token-goat-chunk-4GBVPH3D.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import {
+  extractErrorMessage,
+  hasCreatedConfig
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/cli_doctor_hooks.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+function shimIsCurrent(scriptPath, expected) {
+  try {
+    return fs.readFileSync(scriptPath, "utf-8").replace(/\r\n/g, "\n") === expected.replace(/\r\n/g, "\n");
+  } catch {
+    return false;
+  }
+}
+var SHIM_FILE_WORD = /(?:^|[\\/])token-goat-shim\.c?js$/;
+function wiringPointsAtMissingFile(entries) {
+  return entries.some(({ words }) => {
+    const native = parseNativeInvocation(words);
+    if (native !== void 0 && !fs.existsSync(native.bin)) return true;
+    return words.some((word) => SHIM_FILE_WORD.test(word) && !fs.existsSync(word));
+  });
+}
+function hasHookEventGaps(gaps) {
+  return gaps !== null && (gaps.missing.length > 0 || gaps.outdated.length > 0 || gaps.broken.length > 0);
+}
+function repairHarnessHooks(rootDir = process.cwd()) {
+  const repairs = [];
+  const errors = [];
+  const projectRoot = path.resolve(rootDir ?? process.cwd());
+  try {
+    const userShim = claudeHookScriptPath();
+    const userGaps = hookEventGaps("user");
+    const userInstalled = isInstalled("user") || fs.existsSync(userShim) || userGaps !== null;
+    if (userInstalled) {
+      const isStaleShim = fs.existsSync(userShim) && !shimIsCurrent(userShim, CLAUDECODE_HOOK_SCRIPT);
+      if (isStaleShim || hasHookEventGaps(userGaps)) {
+        installHooks("user");
+        repairs.push("Repaired Claude Code (user) hooks and shim");
+      }
+    }
+  } catch (e) {
+    errors.push(`Failed to repair Claude Code (user) hooks: ${extractErrorMessage(e)}`);
+  }
+  try {
+    const projShim = claudeHookScriptPath();
+    const projGaps = hookEventGaps("project");
+    const projInstalled = isInstalled("project") || projGaps !== null;
+    if (projInstalled) {
+      const isStaleShim = fs.existsSync(projShim) && !shimIsCurrent(projShim, CLAUDECODE_HOOK_SCRIPT);
+      if (isStaleShim || hasHookEventGaps(projGaps)) {
+        installHooks("project");
+        repairs.push("Repaired Claude Code (project) hooks and shim");
+      }
+    }
+  } catch (e) {
+    errors.push(`Failed to repair Claude Code (project) hooks: ${extractErrorMessage(e)}`);
+  }
+  try {
+    const userShim = copilotCliScriptPath();
+    const userConfig = copilotCliConfigPath();
+    const userInstalled = isCopilotCliInstalled() || fs.existsSync(userConfig) || fs.existsSync(userShim);
+    if (userInstalled) {
+      const isStaleShim = fs.existsSync(userShim) && !shimIsCurrent(userShim, COPILOT_CLI_HOOK_SCRIPT);
+      const wired = wiredCopilotHookWords();
+      const hasOutdatedEntries = wired.some((e) => e.current === false);
+      if (isStaleShim || hasOutdatedEntries || wiringPointsAtMissingFile(wired)) {
+        repairCopilotCliHooks();
+        repairs.push("Repaired Copilot CLI (user) hooks and shim");
+      }
+    }
+  } catch (e) {
+    errors.push(`Failed to repair Copilot CLI (user) hooks: ${extractErrorMessage(e)}`);
+  }
+  try {
+    const copilotLocalOpts = { local: true, projectRoot };
+    const projShim = copilotCliScriptPath(copilotLocalOpts);
+    const projConfig = copilotCliConfigPath(copilotLocalOpts);
+    const projInstalled = isCopilotCliInstalled(copilotLocalOpts) || fs.existsSync(projConfig) || fs.existsSync(projShim);
+    if (projInstalled) {
+      const isStaleShim = fs.existsSync(projShim) && !shimIsCurrent(projShim, COPILOT_CLI_HOOK_SCRIPT);
+      const wired = wiredCopilotHookWords(copilotLocalOpts);
+      const hasOutdatedEntries = wired.some((e) => e.current === false);
+      const pointsAtMissing = hasCreatedConfig(projConfig) && wiringPointsAtMissingFile(wired);
+      if (isStaleShim || hasOutdatedEntries || pointsAtMissing) {
+        repairCopilotCliHooks(copilotLocalOpts);
+        repairs.push("Repaired Copilot CLI (project) hooks and shim");
+      }
+    }
+  } catch (e) {
+    errors.push(`Failed to repair Copilot CLI (project) hooks: ${extractErrorMessage(e)}`);
+  }
+  try {
+    const codexShim = codexHookScriptPath();
+    const codexCfg = codexConfigPath();
+    const codexInstalled = isCodexInstalled() || fs.existsSync(codexCfg) || fs.existsSync(codexShim);
+    if (codexInstalled) {
+      const isStaleShim = fs.existsSync(codexShim) && !shimIsCurrent(codexShim, CODEX_HOOK_SCRIPT);
+      const wired = wiredCodexHookWords();
+      const hasOutdatedEntries = wired.some((e) => e.current === false);
+      if (isStaleShim || hasOutdatedEntries || wiringPointsAtMissingFile(wired)) {
+        installCodex();
+        repairs.push("Repaired Codex CLI hooks and shim");
+      }
+    }
+  } catch (e) {
+    errors.push(`Failed to repair Codex CLI hooks: ${extractErrorMessage(e)}`);
+  }
+  try {
+    const grokShim = grokHookScriptPath();
+    const grokCfg = grokConfigPath();
+    const grokInstalled = isGrokInstalled() || fs.existsSync(grokCfg) || fs.existsSync(grokShim);
+    if (grokInstalled) {
+      const isStaleShim = fs.existsSync(grokShim) && !shimIsCurrent(grokShim, GROK_HOOK_SCRIPT);
+      const wired = wiredGrokHookWords();
+      const hasOutdatedEntries = wired.some((e) => e.current === false);
+      if (isStaleShim || hasOutdatedEntries || wiringPointsAtMissingFile(wired)) {
+        installGrok();
+        repairs.push("Repaired Grok CLI hooks and shim");
+      }
+    }
+  } catch (e) {
+    errors.push(`Failed to repair Grok CLI hooks: ${extractErrorMessage(e)}`);
+  }
+  try {
+    const kimiShim = kimiHookScriptPath();
+    const kimiCfg = kimiConfigPath();
+    const kimiInstalled = isKimiInstalled() || fs.existsSync(kimiCfg) || fs.existsSync(kimiShim);
+    if (kimiInstalled) {
+      const wired = wiredKimiHookWords();
+      const hasOutdatedEntries = wired.some((e) => e.current === false);
+      if (hasOutdatedEntries || wiringPointsAtMissingFile(wired) || fs.existsSync(kimiShim) && fs.statSync(kimiShim).size === 0) {
+        installKimi();
+        repairs.push("Repaired Kimi Code hooks and shim");
+      }
+    }
+  } catch (e) {
+    errors.push(`Failed to repair Kimi Code hooks: ${extractErrorMessage(e)}`);
+  }
+  try {
+    if (isGeminiInstalled()) {
+      const res = installGemini();
+      if (!res.alreadyInstalled) repairs.push("Repaired Gemini CLI hooks");
+    }
+  } catch (e) {
+    errors.push(`Failed to repair Gemini CLI hooks: ${extractErrorMessage(e)}`);
+  }
+  try {
+    if (isQwenInstalled()) {
+      const res = installQwen();
+      if (!res.alreadyInstalled) repairs.push("Repaired Qwen Code hooks");
+    }
+  } catch (e) {
+    errors.push(`Failed to repair Qwen Code hooks: ${extractErrorMessage(e)}`);
+  }
+  try {
+    if (isOpencodeInstalled()) {
+      const res = installOpencode();
+      if (!res.alreadyInstalled) repairs.push("Repaired opencode plugin");
+    }
+  } catch (e) {
+    errors.push(`Failed to repair opencode plugin: ${extractErrorMessage(e)}`);
+  }
+  try {
+    if (isOpenclawInstalled()) {
+      const res = installOpenclaw();
+      if (!res.alreadyInstalled) repairs.push("Repaired OpenClaw plugin");
+    }
+  } catch (e) {
+    errors.push(`Failed to repair OpenClaw plugin: ${extractErrorMessage(e)}`);
+  }
+  try {
+    if (isPiInstalled()) {
+      const res = installPi();
+      if (!res.alreadyInstalled) repairs.push("Repaired pi extension");
+    } else if (isPiInstalled({ local: true })) {
+      const res = installPi({ local: true });
+      if (!res.alreadyInstalled) repairs.push("Repaired pi (project) extension");
+    }
+  } catch (e) {
+    errors.push(`Failed to repair pi extension: ${extractErrorMessage(e)}`);
+  }
+  try {
+    if (isAntigravityInstalled()) {
+      const res = installAntigravity();
+      if (!res.alreadyInstalled) repairs.push("Repaired Antigravity CLI integration");
+    }
+  } catch (e) {
+    errors.push(`Failed to repair Antigravity CLI integration: ${extractErrorMessage(e)}`);
+  }
+  try {
+    if (vscodeRunsTokenGoatClaudeHooks() && vscodeHooksInstalled()) {
+      if (disableVscodeClaudeHooks()) {
+        repairs.push(VSCODE_CLAUDE_HOOKS_TURNED_OFF_TEXT);
+      }
+    }
+  } catch (e) {
+    errors.push(`Failed to repair VS Code chat.useClaudeHooks: ${extractErrorMessage(e)}`);
+  }
+  return { repairs, errors };
+}
+export {
+  repairHarnessHooks,
+  shimIsCurrent,
+  wiringPointsAtMissingFile
+};

package/dist/token-goat-chunk-5AC66HNP.mjs

@@ -0,0 +1,115 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  sessionSidecarPath
+} from "./token-goat-chunk-WBA5SKT4.mjs";
+import {
+  ensureDirSync
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/read_shape.ts
+init_define_import_meta_env();
+import { readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+var SHAPES = /* @__PURE__ */ new Set(["outline", "skeleton", "fold", "truncated", "partial"]);
+var SHAPE_SUFFIX = ".read-shape";
+var MAX_ENTRIES = 512;
+function load(target) {
+  try {
+    const parsed = JSON.parse(readFileSync(target, "utf8"));
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function recordReadShape(stateKey, file, shape) {
+  const target = sessionSidecarPath(stateKey, SHAPE_SUFFIX);
+  if (target === null) return;
+  try {
+    const shapes = load(target);
+    if (shape === null) {
+      if (!Object.hasOwn(shapes, file)) return;
+      delete shapes[file];
+    } else {
+      delete shapes[file];
+      shapes[file] = shape;
+    }
+    const keys = Object.keys(shapes);
+    if (keys.length === 0) {
+      rmSync(target, { force: true });
+      return;
+    }
+    for (const k of keys.slice(0, Math.max(0, keys.length - MAX_ENTRIES))) delete shapes[k];
+    ensureDirSync(dirname(target));
+    writeFileSync(target, JSON.stringify(shapes), "utf8");
+  } catch {
+  }
+}
+function readShapeOf(stateKey, file) {
+  const target = sessionSidecarPath(stateKey, SHAPE_SUFFIX);
+  if (target === null) return null;
+  const shapes = load(target);
+  const shape = Object.hasOwn(shapes, file) ? shapes[file] : void 0;
+  return shape !== void 0 && SHAPES.has(shape) ? shape : null;
+}
+
+// src/line_diff.ts
+init_define_import_meta_env();
+function splitLines(text) {
+  const lines = text.split(/\r\n|\r|\n/);
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function lcsLength(a, b) {
+  const [shortArr, longArr] = a.length <= b.length ? [a, b] : [b, a];
+  const n = shortArr.length;
+  let prev = new Array(n + 1).fill(0);
+  let curr = new Array(n + 1).fill(0);
+  for (let i = 1; i <= longArr.length; i++) {
+    for (let j = 1; j <= n; j++) {
+      curr[j] = shortArr[j - 1] === longArr[i - 1] ? (prev[j - 1] ?? 0) + 1 : Math.max(prev[j] ?? 0, curr[j - 1] ?? 0);
+    }
+    const swap = prev;
+    prev = curr;
+    curr = swap;
+  }
+  return prev[n] ?? 0;
+}
+
+// src/write_target.ts
+init_define_import_meta_env();
+import { readFileSync as readFileSync2, statSync } from "node:fs";
+var MAX_LINES_FOR_DIFF = 4e3;
+var MAX_OLD_FILE_BYTES_FOR_DIFF = 4 * 1024 * 1024;
+function inspectFile(filePath) {
+  let stat;
+  try {
+    stat = statSync(filePath);
+  } catch {
+    return { state: "absent" };
+  }
+  if (!stat.isFile()) return { state: "unusable" };
+  if (stat.size > MAX_OLD_FILE_BYTES_FOR_DIFF) return { state: "unread" };
+  try {
+    return { state: "text", text: readFileSync2(filePath, "utf-8") };
+  } catch {
+    return { state: "unread" };
+  }
+}
+function readKnownText(filePath) {
+  const onDisk = inspectFile(filePath);
+  return onDisk.state === "text" ? onDisk.text : "";
+}
+
+export {
+  recordReadShape,
+  readShapeOf,
+  splitLines,
+  lcsLength,
+  MAX_LINES_FOR_DIFF,
+  inspectFile,
+  readKnownText
+};

package/dist/token-goat-chunk-5IMLKSOP.mjs

@@ -0,0 +1,145 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  isSecretFileName
+} from "./token-goat-chunk-32ZOY4N5.mjs";
+import {
+  fenceFileText
+} from "./token-goat-chunk-4NAPX7BA.mjs";
+import "./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-XX6O25RN.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import "./token-goat-chunk-4GBVPH3D.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/edit_near_miss.ts
+init_define_import_meta_env();
+var MAX_HITS = 20;
+var MAX_OLD_LINES = 200;
+var MAX_OLD_CHARS = 16384;
+var MIN_LINE_COVERAGE = 0.5;
+var FOLDS = [
+  [/[‘’‚‛′]/g, "'"],
+  [/[“”„‟″]/g, '"'],
+  [/[‐‑‒–—―−]/g, "-"]
+];
+function foldPunctuation(line) {
+  let out = line.normalize("NFKC");
+  for (const [pattern, replacement] of FOLDS) out = out.replace(pattern, replacement);
+  return out;
+}
+function trimEndBlanks(line) {
+  let end = line.length;
+  while (end > 0 && " 	\r\f\v".includes(line[end - 1])) end--;
+  return line.slice(0, end);
+}
+var RUNGS = [
+  { rung: "trailing-whitespace", normalize: trimEndBlanks },
+  { rung: "unicode-punctuation", normalize: (line) => trimEndBlanks(foldPunctuation(line)) },
+  { rung: "indentation", normalize: (line) => foldPunctuation(line).trim() }
+];
+function splitLines(text) {
+  const lines = [];
+  let start = 0;
+  while (start <= text.length) {
+    const nl = text.indexOf("\n", start);
+    const end = nl === -1 ? text.length : nl;
+    lines.push({ text: text.slice(start, end), start, end });
+    if (nl === -1) break;
+    start = nl + 1;
+  }
+  return lines;
+}
+function matchesAt(fileLines, oldLines, at, tailAnchored) {
+  const last = oldLines.length - 1;
+  if (last === 0) {
+    const line = fileLines[at];
+    const old = oldLines[0];
+    return tailAnchored ? line.endsWith(old) : old.length >= line.length * MIN_LINE_COVERAGE && line.includes(old);
+  }
+  if (!fileLines[at].endsWith(oldLines[0])) return false;
+  for (let i = 1; i < last; i++) {
+    if (fileLines[at + i] !== oldLines[i]) return false;
+  }
+  const tail = fileLines[at + last];
+  return tailAnchored ? tail === oldLines[last] : tail.startsWith(oldLines[last]);
+}
+function findNearMiss(fileText, oldString) {
+  if (oldString === "" || fileText.includes(oldString)) return null;
+  const lines = splitLines(fileText);
+  const rawOld = oldString.split("\n");
+  if (rawOld.length > 1 && rawOld[rawOld.length - 1] === "") rawOld.pop();
+  if (rawOld.length > lines.length || rawOld.length > MAX_OLD_LINES || oldString.length > MAX_OLD_CHARS) return null;
+  for (const { rung, normalize } of RUNGS) {
+    const oldLines = rawOld.map(normalize);
+    const tailAnchored = /[ \t\r\f\v]$/.test(rawOld[rawOld.length - 1]);
+    if (oldLines.every((line) => line === "")) return null;
+    const normalized = lines.map((line) => normalize(line.text));
+    const hits = [];
+    let truncated = false;
+    for (let at = 0; at + oldLines.length <= lines.length; at++) {
+      if (!matchesAt(normalized, oldLines, at, tailAnchored)) continue;
+      if (hits.length === MAX_HITS) {
+        truncated = true;
+        break;
+      }
+      const first = lines[at];
+      const final = lines[at + oldLines.length - 1];
+      hits.push({ startLine: at + 1, endLine: at + oldLines.length, start: first.start, end: final.end });
+    }
+    if (hits.length > 0) return { rung, hits, truncated };
+  }
+  return null;
+}
+var NEAR_MISS_RUNG_NOTE = {
+  "trailing-whitespace": "ignoring trailing whitespace",
+  "unicode-punctuation": "ignoring quote, dash and space-character differences",
+  indentation: "ignoring indentation"
+};
+var MAX_SPAN_LINES = 20;
+var MAX_SPAN_BYTES = 1536;
+function isNearMissAdvice(text) {
+  return /^\[token-goat\] Edit failed: string not found in [^\n]*?, but (?:line \d+ matches|lines \d+-\d+ match|\d+\+? places match),/.test(text);
+}
+function describeNearMiss(fileText, display, miss) {
+  const [only, ...rest] = miss.hits;
+  if (only === void 0) return null;
+  const note = NEAR_MISS_RUNG_NOTE[miss.rung];
+  const head = `[token-goat] Edit failed: string not found in ${display}`;
+  if (rest.length > 0) {
+    const where = miss.hits.slice(0, 5).map((hit) => hit.startLine === hit.endLine ? `${hit.startLine}` : `${hit.startLine}-${hit.endLine}`);
+    const count = `${miss.hits.length}${miss.truncated ? "+" : ""}`;
+    return `${head}, but ${count} places match, ${note} (lines ${where.join(", ")}). View one range and add surrounding context to old_string.`;
+  }
+  const range = only.startLine === only.endLine ? `line ${only.startLine} matches` : `lines ${only.startLine}-${only.endLine} match`;
+  const span = redactSecrets(fileText.slice(only.start, only.end)).text;
+  if (isSecretFileName(display) || only.endLine - only.startLine + 1 > MAX_SPAN_LINES || Buffer.byteLength(span, "utf8") > MAX_SPAN_BYTES) {
+    return `${head}, but ${range}, ${note}. View that range to copy the exact text.`;
+  }
+  return `${head}, but ${range}, ${note}. Copy the on-disk text below into old_string exactly:
+${fenceFileText(span)}`;
+}
+export {
+  MAX_SPAN_BYTES,
+  MAX_SPAN_LINES,
+  NEAR_MISS_RUNG_NOTE,
+  describeNearMiss,
+  findNearMiss,
+  isNearMissAdvice
+};