token-goat 2.9.30 → 2.9.31

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

@@ -0,0 +1,938 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  buildLineDiff,
+  formatSymbolLocation
+} from "./token-goat-chunk-QH7YVYOY.mjs";
+import {
+  claudeConfigDir
+} from "./token-goat-chunk-BPGCUMR7.mjs";
+import {
+  embedTexts,
+  hasSkipSegmentBelowRoot,
+  isAvailable,
+  isEmbeddableDocument
+} from "./token-goat-chunk-NISNMD7T.mjs";
+import {
+  detectLanguageOfFile,
+  getDb,
+  getReadDb,
+  projectScopeClause
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import {
+  estimateTokens
+} from "./token-goat-chunk-BFCWY73P.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  findProject,
+  resolveProjectRoot
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  atomicWriteText,
+  countNoun,
+  isTestFile
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  echoedValue,
+  fencedCommand,
+  quotedArg
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import {
+  foldPath,
+  isCaseInsensitiveFs
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  displaySafeJson,
+  displaySafePath,
+  displaySafeText,
+  normalizePath,
+  toDisplayPath
+} 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/index_health.ts
+init_define_import_meta_env();
+import * as fs2 from "fs";
+
+// src/walk_mode.ts
+init_define_import_meta_env();
+import * as fs from "fs";
+import * as path from "path";
+function detectWalkMode(cwd) {
+  const project = findProject(cwd);
+  if (project?.marker === ".git") return "git";
+  let cur = cwd;
+  while (true) {
+    if (fs.existsSync(path.join(cur, ".git"))) return "git";
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return "non-git";
+}
+
+// src/index_health.ts
+function getProjectIndexCounts(dbPath, rootDir) {
+  const db = getReadDb(dbPath);
+  const countScoped = (table, column) => {
+    if (rootDir === void 0) {
+      return db.prepare(`SELECT COUNT(*) as c FROM ${table}`).get().c;
+    }
+    const scope = projectScopeClause(column);
+    return db.prepare(`SELECT COUNT(*) as c FROM ${table} WHERE ${scope.clause}`).get(...scope.params(rootDir)).c;
+  };
+  return { fileCount: countScoped("files", "path"), symbolCount: countScoped("symbols", "file_path") };
+}
+function getEmbeddingCoverage(dbPath, rootDir) {
+  const db = getReadDb(dbPath);
+  const countScoped = (sql, column) => {
+    if (rootDir === void 0) {
+      return db.prepare(sql).get().c;
+    }
+    const scope = projectScopeClause(column);
+    return db.prepare(`${sql} WHERE ${scope.clause}`).get(...scope.params(rootDir)).c;
+  };
+  return {
+    indexedFiles: countScoped("SELECT COUNT(*) as c FROM files", "path"),
+    // DISTINCT file_path, not COUNT(*): the question is how many files are reachable by vector search at all, and one file contributes anywhere from 1 to 404 chunks (measured), so a raw chunk count would read as healthy coverage whenever a handful of large files chunked well.
+    embeddedFiles: countScoped("SELECT COUNT(DISTINCT file_path) as c FROM chunks", "file_path")
+  };
+}
+function getParserFreshness(dbPath, expectedFor, rootDir) {
+  const db = getReadDb(dbPath);
+  const scope = rootDir === void 0 ? void 0 : projectScopeClause("path");
+  const rows = db.prepare(`SELECT language, parser_sha, COUNT(*) as c FROM files${scope === void 0 ? "" : ` WHERE ${scope.clause}`} GROUP BY language, parser_sha`).all(...scope === void 0 || rootDir === void 0 ? [] : scope.params(rootDir));
+  let indexedFiles = 0;
+  let currentFiles = 0;
+  for (const row of rows) {
+    indexedFiles += row.c;
+    if (row.parser_sha !== null && row.parser_sha === expectedFor(row.language ?? "unknown")) currentFiles += row.c;
+  }
+  return { indexedFiles, currentFiles };
+}
+function isIndexEmptyForProject(dbPath, rootDir) {
+  if (!fs2.existsSync(dbPath)) return true;
+  try {
+    const { fileCount, symbolCount } = getProjectIndexCounts(dbPath, rootDir);
+    return fileCount === 0 && symbolCount === 0;
+  } catch {
+    return false;
+  }
+}
+function suggestedIndexCommand(rootDir) {
+  return detectWalkMode(rootDir) === "git" ? "token-goat index ." : "token-goat index . --walk";
+}
+function emptyIndexMessage(rootDir, projectRootWasOmitted = false) {
+  const omittedNote = projectRootWasOmitted ? ` (projectRoot was omitted and defaulted to server process cwd ${echoedValue(rootDir)}; pass projectRoot: "<workspace-path>" to target your workspace)` : "";
+  return `no files indexed for this project \u2014 every read command will return empty, which looks like a genuine "not found" rather than a missing index; run ${fencedCommand(suggestedIndexCommand(rootDir))} here${omittedNote}`;
+}
+
+// src/baseline.ts
+init_define_import_meta_env();
+import * as fs5 from "node:fs";
+import * as path4 from "node:path";
+
+// src/cli_context_stats.ts
+init_define_import_meta_env();
+import * as fs4 from "node:fs";
+import * as os from "node:os";
+import * as path3 from "node:path";
+
+// src/confirm_apply.ts
+init_define_import_meta_env();
+import * as readline from "node:readline";
+async function defaultConfirm(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise((resolve3) => rl.question(question, resolve3));
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function confirmAndApply(changes, opts = {}) {
+  const write = opts.write ?? ((text) => {
+    process.stdout.write(text);
+  });
+  const isTTY = opts.isTTY ?? process.stdin.isTTY === true;
+  const confirmFn = opts.confirm ?? defaultConfirm;
+  const dryRun = opts.yes !== true && !isTTY;
+  const applied = [];
+  const skipped = [];
+  for (const change of changes) {
+    const label = change.label ?? change.path;
+    const diff = buildLineDiff(change.before, change.after, label);
+    write(`
+${diff}
+`);
+    if (opts.yes === true) {
+      atomicWriteText(change.path, change.after);
+      applied.push(change);
+      continue;
+    }
+    if (!isTTY) {
+      skipped.push(change);
+      continue;
+    }
+    const ok = await confirmFn(`Apply this change to ${label}? [y/N] `);
+    if (ok) {
+      atomicWriteText(change.path, change.after);
+      applied.push(change);
+    } else {
+      skipped.push(change);
+    }
+  }
+  if (dryRun) {
+    write(
+      "\nDry run: no files were written (stdin is not a TTY and --yes was not passed).\nRe-run with --yes to apply these changes non-interactively.\n"
+    );
+  }
+  return { applied, skipped, dryRun };
+}
+
+// src/memory_prune.ts
+init_define_import_meta_env();
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
+var ENTRY_RE = /^\s*-\s*\[(?<title>[^\]]+)\]\((?<target>[^)]+?\.md)\)/;
+var URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+function parseIndex(text) {
+  const passthrough = [];
+  const entries = [];
+  if (!text) return [passthrough, entries];
+  const lines = [];
+  let current = "";
+  for (const char of text) {
+    current += char;
+    if (char === "\n") {
+      lines.push(current);
+      current = "";
+    }
+  }
+  if (current) lines.push(current);
+  for (let lineno = 0; lineno < lines.length; lineno++) {
+    const rawLine = lines[lineno];
+    const m = ENTRY_RE.exec(rawLine);
+    if (m?.groups) {
+      const title = m.groups["title"];
+      const target = m.groups["target"];
+      if (title && target) {
+        entries.push({
+          raw: rawLine,
+          title,
+          target,
+          lineno
+        });
+        continue;
+      }
+    }
+    passthrough.push([lineno, rawLine]);
+  }
+  return [passthrough, entries];
+}
+function pruneIndex(memoryDir, opts) {
+  const result = {
+    removedDead: [],
+    removedDup: [],
+    kept: 0,
+    changed: false,
+    tokensSaved: 0
+  };
+  const memoryMd = path2.join(memoryDir, "MEMORY.md");
+  let text;
+  try {
+    text = fs3.readFileSync(memoryMd, "utf-8");
+  } catch {
+    return result;
+  }
+  const [passthrough, entries] = parseIndex(text);
+  const seenTargets = /* @__PURE__ */ new Set();
+  const keep = [];
+  const dead = [];
+  const dups = [];
+  for (const entry of entries) {
+    const isUrl = URL_SCHEME_RE.test(entry.target);
+    const targetExists = isUrl ? true : path2.isAbsolute(entry.target) ? fs3.existsSync(entry.target) : fs3.existsSync(path2.join(memoryDir, entry.target));
+    const foldedTarget = foldPath(entry.target);
+    if (!targetExists) {
+      dead.push(entry);
+    } else if (seenTargets.has(foldedTarget)) {
+      dups.push(entry);
+    } else {
+      seenTargets.add(foldedTarget);
+      keep.push(entry);
+    }
+  }
+  result.removedDead = dead;
+  result.removedDup = dups;
+  result.kept = keep.length;
+  result.changed = dead.length > 0 || dups.length > 0;
+  result.tokensSaved = dead.reduce((sum, e) => sum + estimateTokens(e.raw), 0) + dups.reduce((sum, e) => sum + estimateTokens(e.raw), 0);
+  if (!result.changed) {
+    return result;
+  }
+  const lineMap = /* @__PURE__ */ new Map();
+  for (const [lineno, rawLine] of passthrough) {
+    lineMap.set(lineno, rawLine);
+  }
+  for (const entry of keep) {
+    lineMap.set(entry.lineno, entry.raw);
+  }
+  const sortedKeys = Array.from(lineMap.keys()).sort((a, b) => a - b);
+  let reconstructed = sortedKeys.map((k) => lineMap.get(k) ?? "").join("");
+  if (reconstructed && !reconstructed.endsWith("\n")) {
+    reconstructed += "\n";
+  }
+  result.after = reconstructed;
+  if (opts?.dryRun) {
+    return result;
+  }
+  try {
+    atomicWriteText(memoryMd, reconstructed);
+  } catch {
+    result.changed = false;
+  }
+  return result;
+}
+function jaccard(a, b) {
+  const ta = new Set(a.toLowerCase().split(/\s+/));
+  const tb = new Set(b.toLowerCase().split(/\s+/));
+  if (ta.size === 0 && tb.size === 0) return 1;
+  if (ta.size === 0 || tb.size === 0) return 0;
+  const intersection = new Set([...ta].filter((x) => tb.has(x)));
+  const union = /* @__PURE__ */ new Set([...ta, ...tb]);
+  return intersection.size / union.size;
+}
+function siblingSnippet(filePath) {
+  let text;
+  try {
+    text = fs3.readFileSync(filePath, { encoding: "utf-8" });
+  } catch {
+    return "";
+  }
+  if (text.startsWith("---")) {
+    const closeRe = /\n---(?:\n|$)/g;
+    closeRe.lastIndex = 3;
+    const closeMatch = closeRe.exec(text);
+    const end = closeMatch ? closeMatch.index : -1;
+    const closeLen = closeMatch ? closeMatch[0].length : 0;
+    if (end !== -1) {
+      const body = text.slice(end + closeLen).trimStart();
+      const fm = text.slice(3, end);
+      let desc = "";
+      for (const line of fm.split("\n")) {
+        if (line.startsWith("description:")) {
+          desc = line.slice(12).trim().replace(/^["']|["']$/g, "");
+          break;
+        }
+      }
+      return `${desc} ${body.slice(0, 500)}`.trim();
+    }
+    return text.slice(0, 500);
+  }
+  return text.slice(0, 500);
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+function greedyCluster(siblings, snippets, matches, simFor, method) {
+  const clusters = [];
+  const used = /* @__PURE__ */ new Set();
+  for (let i = 0; i < siblings.length; i++) {
+    if (used.has(i)) continue;
+    const group = [i];
+    for (let j = i + 1; j < siblings.length; j++) {
+      if (used.has(j)) continue;
+      if (matches(i, j, group)) {
+        group.push(j);
+      }
+    }
+    if (group.length > 1) {
+      const members = group.map((k) => siblings[k]);
+      const tok2 = group.reduce((sum, k) => sum + estimateTokens(snippets[k]), 0);
+      let maxSim = 0;
+      for (let a = 0; a < group.length; a++) {
+        for (let b = a + 1; b < group.length; b++) {
+          maxSim = Math.max(maxSim, simFor(group[a], group[b]));
+        }
+      }
+      clusters.push({
+        members,
+        similarity: Math.round(maxSim * 1e3) / 1e3,
+        method,
+        tokens: tok2
+      });
+      for (const idx of group) used.add(idx);
+    }
+  }
+  return clusters;
+}
+async function tryEmbeddingClusters(siblings, snippets, threshold) {
+  if (!(loadConfig().indexing?.embeddings_enabled ?? true) || !isAvailable()) {
+    return null;
+  }
+  let vecs;
+  try {
+    vecs = await embedTexts(snippets);
+  } catch {
+    return null;
+  }
+  return greedyCluster(
+    siblings,
+    snippets,
+    (i, j) => cosineSimilarity(vecs[i], vecs[j]) >= threshold,
+    (a, b) => cosineSimilarity(vecs[a], vecs[b]),
+    "embedding"
+  );
+}
+async function findContentDuplicates(memoryDir, _opts) {
+  const threshold = _opts?.threshold ?? 0.92;
+  const siblings = fs3.readdirSync(memoryDir).filter((name) => name.toLowerCase().endsWith(".md") && name.toLowerCase() !== "memory.md").map((name) => path2.join(memoryDir, name)).sort();
+  if (siblings.length < 2) {
+    return [];
+  }
+  const snippets = siblings.map((p) => siblingSnippet(p));
+  const embeddingClusters = await tryEmbeddingClusters(siblings, snippets, threshold);
+  if (embeddingClusters !== null) {
+    return embeddingClusters;
+  }
+  const JACCARD_THRESHOLD = 0.6;
+  return greedyCluster(
+    siblings,
+    snippets,
+    (_seed, j, group) => group.some((gi) => jaccard(snippets[gi], snippets[j]) >= JACCARD_THRESHOLD),
+    (a, b) => jaccard(snippets[a], snippets[b]),
+    "jaccard"
+  );
+}
+function auditClaudeMd(files) {
+  const reports = [];
+  const allLines = [];
+  for (const filePath of files) {
+    let text;
+    try {
+      text = fs3.readFileSync(filePath, { encoding: "utf-8" });
+    } catch {
+      continue;
+    }
+    const lines = text.split("\n");
+    const tokens = estimateTokens(text);
+    const exactDups = [];
+    const dupSections = [];
+    const seenLines = /* @__PURE__ */ new Map();
+    for (let i = 0; i < lines.length; i++) {
+      const stripped = lines[i].trim();
+      if (!stripped) continue;
+      if (seenLines.has(stripped)) {
+        const firstLine = seenLines.get(stripped);
+        exactDups.push([firstLine, i, stripped]);
+      } else {
+        seenLines.set(stripped, i);
+      }
+    }
+    const seenHeadings = /* @__PURE__ */ new Map();
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.startsWith("##")) {
+        const heading = line.trim();
+        if (!seenHeadings.has(heading)) {
+          seenHeadings.set(heading, []);
+        }
+        seenHeadings.get(heading).push(i);
+      }
+    }
+    for (const [heading, lnos] of seenHeadings) {
+      if (lnos.length > 1) {
+        dupSections.push([heading, lnos]);
+      }
+    }
+    reports.push({
+      path: filePath,
+      tokens,
+      exactDupLines: exactDups,
+      dupSections,
+      crossFileOverlaps: []
+    });
+    for (let i = 0; i < lines.length; i++) {
+      const stripped = lines[i].trim();
+      if (stripped) {
+        allLines.push([filePath, i, stripped]);
+      }
+    }
+  }
+  const lineToFiles = /* @__PURE__ */ new Map();
+  for (const [filePath, _i, stripped] of allLines) {
+    if (!lineToFiles.has(stripped)) {
+      lineToFiles.set(stripped, /* @__PURE__ */ new Set());
+    }
+    lineToFiles.get(stripped).add(filePath);
+  }
+  for (const report of reports) {
+    const overlaps = [];
+    for (const [stripped, filesSet] of lineToFiles) {
+      if (filesSet.has(report.path) && filesSet.size > 1) {
+        const others = Array.from(filesSet).filter((p) => p !== report.path).map((p) => path2.basename(p));
+        if (others.length > 0) {
+          if (stripped.length > 60) {
+            overlaps.push(
+              `${JSON.stringify(stripped.slice(0, 60))}\u2026 also in ${others.join(", ")}`
+            );
+          } else {
+            overlaps.push(`${JSON.stringify(stripped)} also in ${others.join(", ")}`);
+          }
+        }
+      }
+    }
+    report.crossFileOverlaps = overlaps.slice(0, 10);
+  }
+  return reports;
+}
+
+// src/cli_context_stats.ts
+function tok(filePath) {
+  try {
+    const size = fs4.statSync(filePath).size;
+    return Math.floor(size / 4);
+  } catch {
+    return 0;
+  }
+}
+function findClaudeMdFiles(projectRoot, homeDir = os.homedir()) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = path3.resolve(projectRoot);
+  while (true) {
+    const candidate = path3.join(current, "CLAUDE.md");
+    if (!seen.has(candidate) && fs4.existsSync(candidate)) {
+      found.push(candidate);
+      seen.add(candidate);
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  const globalMd = path3.join(claudeConfigDir(homeDir), "CLAUDE.md");
+  if (!seen.has(globalMd) && fs4.existsSync(globalMd)) {
+    found.push(globalMd);
+  }
+  return found;
+}
+function findMemoryMd(projectRoot, homeDir = os.homedir(), alternateRoots = []) {
+  try {
+    const projectsDir = path3.join(claudeConfigDir(homeDir), "projects");
+    if (!fs4.existsSync(projectsDir)) return null;
+    const rootStr = path3.resolve(projectRoot);
+    const candidateRoots = [rootStr];
+    try {
+      const realRoot = fs4.realpathSync.native(rootStr);
+      if (realRoot !== rootStr) candidateRoots.push(realRoot);
+    } catch {
+    }
+    for (const alternate of alternateRoots) {
+      const resolved = path3.resolve(alternate);
+      if (!candidateRoots.includes(resolved)) candidateRoots.push(resolved);
+    }
+    for (const root of candidateRoots) {
+      const expectedSlug = root.replace(/[^A-Za-z0-9]/g, "-");
+      const candidate = path3.join(projectsDir, expectedSlug, "memory", "MEMORY.md");
+      if (fs4.existsSync(candidate)) return candidate;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function buildStats(projectRoot, homeDir = os.homedir(), alternateRoots = []) {
+  const claudeMds = findClaudeMdFiles(projectRoot, homeDir);
+  const claudeMdRows = [];
+  let claudeMdTotal = 0;
+  for (const p of claudeMds) {
+    const t = tok(p);
+    claudeMdTotal += t;
+    const parentDir = path3.basename(path3.dirname(p));
+    const label = parentDir === ".claude" ? "~/.claude/CLAUDE.md" : (() => {
+      try {
+        return path3.relative(projectRoot, p);
+      } catch {
+        return p;
+      }
+    })();
+    claudeMdRows.push({ label, tokens: t, path: p });
+  }
+  const memPath = findMemoryMd(projectRoot, homeDir, alternateRoots);
+  const memTok = memPath !== null ? tok(memPath) : 0;
+  const total = claudeMdTotal + memTok;
+  return {
+    claude_md_rows: claudeMdRows,
+    claude_md_total: claudeMdTotal,
+    memory_md_path: memPath,
+    memory_md_tokens: memTok,
+    total_tokens: total
+  };
+}
+async function runContextStats(opts = {}) {
+  const projectRoot = resolveProjectRoot(opts.project !== void 0 ? { project: opts.project } : {});
+  const result = buildStats(projectRoot);
+  if (opts.json === true) {
+    process.stdout.write(displaySafeJson(result) + "\n");
+    return;
+  }
+  process.stdout.write(`
+# token-goat context-stats
+`);
+  process.stdout.write(`Project: ${projectRoot}
+
+`);
+  if (result.claude_md_rows.length === 0) {
+    process.stdout.write("No CLAUDE.md files found.\n");
+  } else {
+    process.stdout.write("## CLAUDE.md files\n");
+    for (const row of result.claude_md_rows) {
+      process.stdout.write(`  ${row.tokens.toString().padStart(6)} tok  ${displaySafeText(row.label)}
+`);
+    }
+    process.stdout.write(
+      `  ${"\u2500".repeat(6)}     total
+  ${result.claude_md_total.toString().padStart(6)} tok
+
+`
+    );
+  }
+  if (result.memory_md_path !== null) {
+    process.stdout.write("## MEMORY.md\n");
+    process.stdout.write(`  ${result.memory_md_tokens.toString().padStart(6)} tok  ${displaySafeText(result.memory_md_path)}
+
+`);
+  } else {
+    process.stdout.write("## MEMORY.md\n  (not found)\n\n");
+  }
+  process.stdout.write(`## Total estimated context overhead
+`);
+  process.stdout.write(`  ${result.total_tokens.toString().padStart(6)} tok
+
+`);
+  if (opts.fix === true) {
+    if (result.memory_md_path === null) {
+      process.stdout.write("[--fix] No MEMORY.md found; nothing to prune.\n");
+    } else {
+      const memPath = result.memory_md_path;
+      const pruneResult = pruneIndex(path3.dirname(memPath), { dryRun: true });
+      if (!pruneResult.changed || pruneResult.after === void 0) {
+        process.stdout.write("[--fix] MEMORY.md already clean; nothing to prune.\n");
+      } else {
+        const before = fs4.readFileSync(memPath, "utf-8");
+        const applyResult = await confirmAndApply(
+          [{ path: memPath, before, after: pruneResult.after, label: "MEMORY.md" }],
+          opts.yes === true ? { yes: true } : {}
+        );
+        if (applyResult.applied.length > 0) {
+          process.stdout.write("[--fix] Pruned MEMORY.md\n");
+          process.stdout.write(`  removed ${countNoun(pruneResult.removedDead.length, "dead-link entry", "dead-link entries")}
+`);
+          process.stdout.write(`  removed ${countNoun(pruneResult.removedDup.length, "duplicate entry", "duplicate entries")}
+`);
+          process.stdout.write(`  kept ${countNoun(pruneResult.kept, "entry", "entries")}
+`);
+          process.stdout.write(`  ${pruneResult.tokensSaved} tok saved
+`);
+        } else {
+          process.stdout.write(
+            `[--fix] ${applyResult.dryRun ? "Dry run" : "Skipped"} -- MEMORY.md not written. Re-run with --yes to apply without prompting.
+`
+          );
+        }
+      }
+    }
+  }
+}
+
+// src/baseline.ts
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".venv",
+  "venv",
+  // Installed Python packages live under <any-venv>/Lib/site-packages or lib/pythonX.Y/site-packages. Skip by this exact name so a non-standard venv directory name (e.g. tmptg-py313-venv) cannot smuggle dependency code into the symbol index — the enclosing venv dir name varies, but site-packages does not.
+  "site-packages",
+  "__pycache__",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".ruff_cache",
+  "target",
+  ".idea",
+  ".vscode"
+]);
+function isIgnoredIndexPath(p, projectRoot) {
+  return hasSkipSegmentBelowRoot(p, projectRoot, (s) => SKIP_DIRS.has(foldPath(s)));
+}
+var MAX_FILES_SCANNED = 2e4;
+function walkProject(rootDir, opts = {}) {
+  const files = [];
+  const languages = {};
+  const stack = [rootDir];
+  const excludeTests = opts.excludeTests === true;
+  const includeEmbeddableDocuments = opts.includeEmbeddableDocuments === true;
+  const extraSkipDirs = loadConfig().indexing.skip_dirs;
+  const maxFiles = opts.maxFiles ?? MAX_FILES_SCANNED;
+  while (stack.length > 0 && files.length < maxFiles) {
+    const dir = stack.pop();
+    if (dir === void 0) break;
+    let entries;
+    try {
+      entries = fs5.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name) || extraSkipDirs.includes(entry.name)) continue;
+        if (entry.name.startsWith(".") && entry.name !== ".") {
+          continue;
+        }
+        stack.push(full);
+      } else if (entry.isFile()) {
+        const lang = detectLanguageOfFile(full);
+        if (lang === "unknown" && !(includeEmbeddableDocuments && isEmbeddableDocument(full))) continue;
+        if (excludeTests && isTestFile(full)) continue;
+        files.push(full);
+        languages[lang] = (languages[lang] ?? 0) + 1;
+        if (files.length >= maxFiles) break;
+      }
+    }
+  }
+  return { files, languages, truncated: files.length >= maxFiles };
+}
+function buildTopSymbolsSql() {
+  const { clause } = projectScopeClause("s.file_path");
+  const refScope = projectScopeClause("r.file_path");
+  const symbolsPathIndex = isCaseInsensitiveFs() ? "idx_symbols_file_folded" : "idx_symbols_file";
+  const family = (col) => `CASE WHEN ${col} IN ('typescript', 'javascript') THEN 'js' ELSE COALESCE(${col}, '') END`;
+  return `SELECT s.file_path, s.name, s.kind, s.line_start, s.line_end, s.body, s.docstring, s.parent
+         FROM (
+           SELECT rid, kind, score, body_len
+           FROM (
+             SELECT t.rid, t.name, t.kind, t.body_len, t.file_path,
+                    t.ref_count * 1.0 / COUNT(*) OVER (PARTITION BY t.name) AS score,
+                    ROW_NUMBER() OVER (
+                      PARTITION BY t.name
+                      ORDER BY t.body_len DESC, t.file_path
+                    ) AS rn
+             FROM (
+               SELECT d.rid, d.file_path, d.name, d.kind, d.body_len, COUNT(DISTINCT rr.file_path) AS ref_count
+               FROM (
+                 SELECT s.rowid AS rid, s.file_path, s.name, s.kind, LENGTH(COALESCE(s.body, '')) AS body_len,
+                        ${family("(SELECT f.language FROM files f WHERE f.path = s.file_path)")} AS fam
+                 FROM symbols s INDEXED BY ${symbolsPathIndex}
+                 WHERE s.kind IN ('class', 'function', 'interface') AND ${clause}
+                   AND LENGTH(s.name) >= 4
+                   AND s.file_path NOT LIKE '%/tests/%' ESCAPE '\\'
+                   AND s.file_path NOT LIKE '%/test/%' ESCAPE '\\'
+                   AND s.file_path NOT LIKE '%/__tests__/%' ESCAPE '\\'
+                   AND s.file_path NOT LIKE '%/spec/%' ESCAPE '\\'
+                   AND s.file_path NOT LIKE '%.test.%'
+                   AND s.file_path NOT LIKE '%.spec.%'
+               ) d
+               LEFT JOIN (
+                 SELECT DISTINCT r.name AS name, r.file_path AS file_path, ${family("(SELECT rf.language FROM files rf WHERE rf.path = r.file_path)")} AS fam
+                 FROM refs r
+                 WHERE ${refScope.clause}
+               ) rr ON rr.name = d.name AND rr.fam = d.fam AND rr.file_path <> d.file_path
+               GROUP BY d.rid
+             ) t
+           )
+           WHERE rn = 1
+           ORDER BY score DESC,
+                    CASE kind WHEN 'class' THEN 0 WHEN 'interface' THEN 1 ELSE 2 END,
+                    body_len DESC
+           LIMIT ?
+         ) top
+         JOIN symbols s ON s.rowid = top.rid
+         ORDER BY top.score DESC,
+                  CASE top.kind WHEN 'class' THEN 0 WHEN 'interface' THEN 1 ELSE 2 END,
+                  top.body_len DESC`;
+}
+function fetchTopSymbols(limit, dbPath, rootDir) {
+  try {
+    const db = getDb(dbPath);
+    const bounds = projectScopeClause("file_path").params(rootDir);
+    const rows = db.prepare(buildTopSymbolsSql()).all(...bounds, ...bounds, limit);
+    return rows.map((r) => ({
+      filePath: r.file_path,
+      name: r.name,
+      kind: r.kind,
+      lineStart: r.line_start,
+      lineEnd: r.line_end,
+      body: r.body ?? "",
+      docstring: r.docstring ?? "",
+      parent: r.parent ?? ""
+    }));
+  } catch {
+    return [];
+  }
+}
+function buildProjectMap(rootDir = process.cwd(), opts = {}) {
+  const root = path4.resolve(rootDir);
+  const config = loadConfig();
+  const { files, languages, truncated } = walkProject(root, { excludeTests: config.repomap.exclude_tests });
+  const compact = opts.compact === true || files.length > config.repomap.compact_file_threshold;
+  const symbolLimit = compact ? 10 : 30;
+  const topSymbols = fetchTopSymbols(symbolLimit, globalDbPath(), root);
+  const recentFiles = compact && opts.emitsJson !== true ? [] : files.map((f) => {
+    let mtime;
+    try {
+      mtime = fs5.statSync(f).mtimeMs;
+    } catch {
+      mtime = 0;
+    }
+    return { f, mtime };
+  }).sort((a, b) => b.mtime - a.mtime).slice(0, compact ? 5 : 15).map((x) => path4.relative(root, x.f).split(path4.sep).join("/"));
+  return {
+    rootDir: root,
+    fileCount: files.length,
+    fileCountTruncated: truncated,
+    languages,
+    topSymbols,
+    recentFiles,
+    compact
+  };
+}
+function formatProjectMap(map, compact = false) {
+  const lines = [];
+  const rel = displaySafeText(path4.basename(map.rootDir));
+  lines.push(`# Project map: ${rel}`);
+  lines.push(map.fileCountTruncated === true ? `Files: at least ${map.fileCount} (walk stopped at the ${MAX_FILES_SCANNED}-file cap)` : `Files: ${map.fileCount}`);
+  const langPairs = Object.entries(map.languages).sort((a, b) => b[1] - a[1]);
+  const langSummary = langPairs.map(([lang, n]) => `${lang} ${n}`).join(", ");
+  const langSuffix = map.fileCountTruncated === true ? " (counted over a truncated walk; each count is a lower bound)" : "";
+  lines.push(`Languages: ${langSummary || "(none)"}${langSuffix}`);
+  if (map.topSymbols.length > 0) {
+    lines.push("");
+    lines.push("## Top symbols");
+    for (const s of map.topSymbols) {
+      const loc = formatSymbolLocation(displaySafeText(toDisplayPath(map.rootDir, s.filePath)), s.lineStart, s.lineEnd);
+      lines.push(`- ${displaySafeText(s.name)} (${displaySafeText(s.kind)}) \u2014 ${loc}`);
+    }
+  } else {
+    lines.push("");
+    lines.push(`## Top symbols: none \u2014 no files indexed for this project; run ${fencedCommand(suggestedIndexCommand(map.rootDir))}`);
+  }
+  if (!compact && map.recentFiles.length > 0) {
+    lines.push("");
+    lines.push("## Recent files");
+    for (const f of map.recentFiles) {
+      lines.push(`- ${displaySafeText(f)}`);
+    }
+  }
+  return lines.join(String.fromCharCode(10));
+}
+function mapLookupBytesSaved(map, emittedText) {
+  const referencedFiles = /* @__PURE__ */ new Set([
+    ...map.recentFiles.map((f) => normalizePath(path4.resolve(map.rootDir, f))),
+    ...map.topSymbols.map((s) => normalizePath(s.filePath))
+  ]);
+  const listingText = Array.from(referencedFiles).sort().join("\n");
+  const fullSourceBytes = Buffer.byteLength(listingText, "utf8");
+  const emittedBytes = Buffer.byteLength(emittedText, "utf8");
+  return Math.max(1, fullSourceBytes - emittedBytes);
+}
+var BULLET_LINE_RE = /^[-*]\s+\S.*$/;
+var STRUCTURAL_HEADING_RE = /\b(architecture|file structure|directory structure|repository structure|project structure|folder structure)\b/i;
+var CRITICAL_HEADING_RE = /\b(MANDATORY|REQUIRED|CRITICAL|NEVER|ALWAYS)\b/;
+function findMemSuggestionCandidates(projectRoot) {
+  const claudeMdFiles = findClaudeMdFiles(projectRoot);
+  const candidateFiles = new Set(claudeMdFiles);
+  for (const claudeMd of claudeMdFiles) {
+    const agentsMd = path4.join(path4.dirname(claudeMd), "AGENTS.md");
+    if (fs5.existsSync(agentsMd)) candidateFiles.add(agentsMd);
+  }
+  const suggestions = [];
+  for (const filePath of candidateFiles) {
+    let text;
+    try {
+      text = fs5.readFileSync(filePath, { encoding: "utf-8" });
+    } catch {
+      continue;
+    }
+    let count = 0;
+    let skipSection = false;
+    let skipLevel = 0;
+    for (const rawLine of text.split(String.fromCharCode(10))) {
+      const line = rawLine.trim();
+      if (line.startsWith("#")) {
+        const level = /^#+/.exec(line)?.[0].length ?? 0;
+        if (skipSection && level > skipLevel) continue;
+        const heading = line.replace(/^#+\s*/, "");
+        skipSection = STRUCTURAL_HEADING_RE.test(heading) || CRITICAL_HEADING_RE.test(heading);
+        skipLevel = level;
+        continue;
+      }
+      if (skipSection) continue;
+      if (BULLET_LINE_RE.test(line)) count++;
+    }
+    if (count > 0) suggestions.push({ path: filePath, count });
+  }
+  return suggestions;
+}
+function formatMemSuggestions(projectRoot) {
+  const suggestions = findMemSuggestionCandidates(projectRoot);
+  if (suggestions.length === 0) return "";
+  const lines = ["", "## mem suggestions"];
+  for (const s of suggestions) {
+    const basename4 = path4.basename(s.path);
+    lines.push(
+      "Consider: mem import --from-md " + quotedArg(displaySafePath(s.path)) + "  # migrates " + s.count + " preference-shaped lines from " + basename4 + " as pending facts for review"
+    );
+  }
+  return lines.join(String.fromCharCode(10));
+}
+
+export {
+  detectWalkMode,
+  getProjectIndexCounts,
+  getEmbeddingCoverage,
+  getParserFreshness,
+  isIndexEmptyForProject,
+  suggestedIndexCommand,
+  emptyIndexMessage,
+  confirmAndApply,
+  findContentDuplicates,
+  auditClaudeMd,
+  findClaudeMdFiles,
+  findMemoryMd,
+  buildStats,
+  runContextStats,
+  SKIP_DIRS,
+  isIgnoredIndexPath,
+  MAX_FILES_SCANNED,
+  walkProject,
+  buildProjectMap,
+  formatProjectMap,
+  mapLookupBytesSaved,
+  findMemSuggestionCandidates,
+  formatMemSuggestions
+};