token-goat 2.9.29 → 2.9.31

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

@@ -0,0 +1,35 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  computeSymbolFingerprints,
+  symbolNamesInFile
+} from "./token-goat-chunk-COPNXRJM.mjs";
+import {
+  resolveIndexPath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  globalDbPath
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/note_anchor.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+function anchorStatus(root, anchor, dbPath = globalDbPath()) {
+  try {
+    const abs = resolveIndexPath(anchor.file, root);
+    if (!fs.existsSync(abs)) return "gone";
+    const now = computeSymbolFingerprints(abs, anchor.symbol, dbPath);
+    if (now.length === 1) return now[0] === anchor.sha ? "current" : "changed";
+    if (now.length > 1) return now.includes(anchor.sha) ? "current" : "unknown";
+    return symbolNamesInFile(abs, dbPath).length > 0 ? "gone" : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+export {
+  anchorStatus
+};

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

@@ -0,0 +1,218 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  buildGuidanceBlock,
+  claudeMdPath,
+  codexAgentsPath,
+  copilotCliInstructionsPath,
+  isCodexInstalled,
+  isCopilotCliInstalled,
+  isInstalled
+} from "./token-goat-chunk-7MAOA6X4.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  recordCreatedBy,
+  upsertDelimitedBlock
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/cli_doctor_guidance.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+var INSTRUCTION_GATE_BEGIN = "<!-- token-goat-begin -->";
+var INSTRUCTION_GATE_END = "<!-- token-goat-end -->";
+var CODEX_GATE_BEGIN = "<!-- token-goat-codex-begin -->";
+var CODEX_GATE_END = "<!-- token-goat-codex-end -->";
+function findInstructionGateCandidates(rootDir = process.cwd()) {
+  const candidates = [];
+  const claudeMdPath2 = path.join(rootDir, "CLAUDE.md");
+  const claudeMdExists = fs.existsSync(claudeMdPath2);
+  let claudeMdHasGate = false;
+  if (claudeMdExists) {
+    try {
+      const content = fs.readFileSync(claudeMdPath2, "utf8");
+      claudeMdHasGate = content.includes(INSTRUCTION_GATE_BEGIN) && content.includes(INSTRUCTION_GATE_END);
+    } catch {
+    }
+  }
+  candidates.push({
+    filename: "CLAUDE.md",
+    relativePath: "CLAUDE.md",
+    fullPath: claudeMdPath2,
+    harnessName: "Claude Code",
+    exists: claudeMdExists,
+    hasGate: claudeMdHasGate,
+    beginMarker: INSTRUCTION_GATE_BEGIN,
+    endMarker: INSTRUCTION_GATE_END,
+    fallbackToolClause: "Claude Code's own Read, Grep, and Glob preference rules"
+  });
+  const agentsMdPath = path.join(rootDir, "AGENTS.md");
+  const agentsMdExists = fs.existsSync(agentsMdPath);
+  let agentsMdHasGate = false;
+  if (agentsMdExists) {
+    try {
+      const content = fs.readFileSync(agentsMdPath, "utf8");
+      agentsMdHasGate = content.includes(CODEX_GATE_BEGIN) && content.includes(CODEX_GATE_END) || content.includes(INSTRUCTION_GATE_BEGIN) && content.includes(INSTRUCTION_GATE_END);
+    } catch {
+    }
+  }
+  candidates.push({
+    filename: "AGENTS.md",
+    relativePath: "AGENTS.md",
+    fullPath: agentsMdPath,
+    harnessName: "Codex / AGENTS.md",
+    exists: agentsMdExists,
+    hasGate: agentsMdHasGate,
+    beginMarker: CODEX_GATE_BEGIN,
+    endMarker: CODEX_GATE_END,
+    fallbackToolClause: "Codex's native `exec`, `apply_patch`, and `view_image` tools (shell commands like `cat`/`type` run inside `exec`)"
+  });
+  const copilotInstructionsPath = path.join(rootDir, ".github", "copilot-instructions.md");
+  const copilotInstructionsExists = fs.existsSync(copilotInstructionsPath);
+  let copilotInstructionsHasGate = false;
+  if (copilotInstructionsExists) {
+    try {
+      const content = fs.readFileSync(copilotInstructionsPath, "utf8");
+      copilotInstructionsHasGate = content.includes(INSTRUCTION_GATE_BEGIN) && content.includes(INSTRUCTION_GATE_END);
+    } catch {
+    }
+  }
+  candidates.push({
+    filename: "copilot-instructions.md",
+    relativePath: path.join(".github", "copilot-instructions.md"),
+    fullPath: copilotInstructionsPath,
+    harnessName: "GitHub Copilot CLI",
+    exists: copilotInstructionsExists,
+    hasGate: copilotInstructionsHasGate,
+    beginMarker: INSTRUCTION_GATE_BEGIN,
+    endMarker: INSTRUCTION_GATE_END,
+    fallbackToolClause: "Copilot CLI's native `view`, `grep`, and `glob` tools (with PowerShell commands `Get-Content`/`Select-String` as search fallbacks)"
+  });
+  return candidates;
+}
+function fileHasGate(fullPath, markers) {
+  let content;
+  try {
+    content = fs.readFileSync(fullPath, "utf8");
+  } catch {
+    return false;
+  }
+  return markers.some(([begin, end]) => content.includes(begin) && content.includes(end));
+}
+function findActiveGlobalGates() {
+  const globals = [
+    { fullPath: claudeMdPath(), markers: [[INSTRUCTION_GATE_BEGIN, INSTRUCTION_GATE_END]] },
+    { fullPath: codexAgentsPath(), markers: [[CODEX_GATE_BEGIN, CODEX_GATE_END], [INSTRUCTION_GATE_BEGIN, INSTRUCTION_GATE_END]] },
+    { fullPath: copilotCliInstructionsPath(), markers: [[INSTRUCTION_GATE_BEGIN, INSTRUCTION_GATE_END]] }
+  ];
+  return globals.filter((g) => fileHasGate(g.fullPath, g.markers)).map((g) => g.fullPath);
+}
+function checkInstructionGates(rootDir = process.cwd()) {
+  const candidates = findInstructionGateCandidates(rootDir);
+  const existingFiles = candidates.filter((c) => c.exists);
+  const gatedFiles = existingFiles.filter((c) => c.hasGate);
+  const activeGlobal = findActiveGlobalGates();
+  if (gatedFiles.length > 0 || activeGlobal.length > 0) {
+    const names = [...activeGlobal, ...gatedFiles.map((c) => c.relativePath)].join(", ");
+    return {
+      name: "Instruction gate",
+      status: "ok",
+      message: `active in ${names}`
+    };
+  }
+  if (existingFiles.length > 0) {
+    const unGated = existingFiles.map((c) => c.relativePath).join(", ");
+    return {
+      name: "Instruction gate",
+      status: "warn",
+      message: `missing in ${unGated} and in the user-level instruction files \`token-goat install\` writes (agents will bypass token-goat and read whole files). Run \`token-goat doctor --fix\` to inject automatically.`
+    };
+  }
+  return {
+    name: "Instruction gate",
+    status: "warn",
+    message: "missing: no user-level instruction file carries it and no project instruction file was found (CLAUDE.md, AGENTS.md, or .github/copilot-instructions.md). Run `token-goat install`, or `token-goat doctor --fix` to create CLAUDE.md with the routing gate."
+  };
+}
+function repairInstructionGates(rootDir = process.cwd()) {
+  const repairs = [];
+  const errors = [];
+  const candidates = findInstructionGateCandidates(rootDir);
+  if (candidates.some((c) => c.hasGate) || findActiveGlobalGates().length > 0) return { repairs, errors };
+  const existingUngated = candidates.filter((c) => c.exists);
+  const fallback = candidates[0];
+  if (!fallback) return { repairs, errors };
+  const targets = existingUngated.length > 0 ? existingUngated : [fallback];
+  const cfg = loadConfig(rootDir);
+  const gdrive = cfg.gdrive?.enabled ?? true;
+  for (const target of targets) {
+    try {
+      const block = buildGuidanceBlock({
+        beginMarker: target.beginMarker,
+        endMarker: target.endMarker,
+        fallbackToolClause: target.fallbackToolClause,
+        gdrive
+      });
+      recordCreatedBy([target.fullPath], () => {
+        fs.mkdirSync(path.dirname(target.fullPath), { recursive: true });
+        upsertDelimitedBlock(target.fullPath, target.beginMarker, target.endMarker, block);
+      });
+      repairs.push(`Injected token-goat routing gate into ${target.relativePath}`);
+    } catch (e) {
+      errors.push(`Failed to inject routing gate into ${target.relativePath}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return { repairs, errors };
+}
+function checkHarnessCacheEfficiency(rootDir = process.cwd()) {
+  const hasVscode = fs.existsSync(path.join(rootDir, ".vscode"));
+  const hasIdea = fs.existsSync(path.join(rootDir, ".idea"));
+  const hasCursor = fs.existsSync(path.join(rootDir, ".cursor")) || fs.existsSync(path.join(rootDir, ".cursorrules"));
+  const hasVs = fs.existsSync(path.join(rootDir, ".vs"));
+  const ideDetected = [
+    hasVscode && "VS Code",
+    hasIdea && "JetBrains",
+    hasCursor && "Cursor",
+    hasVs && "Visual Studio"
+  ].filter(Boolean);
+  const hasClaude = fs.existsSync(path.join(rootDir, ".claude")) || fs.existsSync(path.join(rootDir, "CLAUDE.md"));
+  const hasCopilot = fs.existsSync(path.join(rootDir, ".github", "hooks")) || fs.existsSync(path.join(rootDir, ".github", "copilot-instructions.md"));
+  const hasCodex = fs.existsSync(path.join(rootDir, ".codex")) || fs.existsSync(path.join(rootDir, "AGENTS.md"));
+  const cliDetected = [
+    (hasClaude || isInstalled("user")) && "Claude Code",
+    (hasCopilot || isCopilotCliInstalled()) && "Copilot CLI",
+    (hasCodex || isCodexInstalled()) && "Codex"
+  ].filter(Boolean);
+  if (ideDetected.length > 0 && cliDetected.length === 0) {
+    return {
+      name: "Harness efficiency",
+      status: "warn",
+      message: `${ideDetected.join(", ")} workspace detected without CLI harness config. IDE hooks cannot fold/trim built-in reads. If you also use a CLI agent, run \`token-goat install\` for Claude Code, or \`token-goat install --codex\` or '--copilot' for those.`
+    };
+  }
+  if (cliDetected.length > 0) {
+    return {
+      name: "Harness efficiency",
+      status: "ok",
+      message: `CLI harness configured (${cliDetected.join(", ")})`
+    };
+  }
+  return null;
+}
+
+export {
+  INSTRUCTION_GATE_BEGIN,
+  INSTRUCTION_GATE_END,
+  CODEX_GATE_BEGIN,
+  CODEX_GATE_END,
+  findInstructionGateCandidates,
+  findActiveGlobalGates,
+  checkInstructionGates,
+  repairInstructionGates,
+  checkHarnessCacheEfficiency
+};