codebase-wiki 0.1.0

package/dist/chunks/build.mjs

@@ -0,0 +1,1976 @@
+import path__default from 'node:path';
+import { promises } from 'node:fs';
+import { c as repoRel, a as log, t as toPosix, l as loadConfig, d as child, f as configSummary, w as writeJson, b as atomicWriteText, e as exists } from './config.mjs';
+import ignore from 'ignore';
+import { globby } from 'globby';
+import { createHash } from 'node:crypto';
+import { encode } from 'gpt-tokenizer/encoding/cl100k_base';
+import { Language, Parser, Query } from 'web-tree-sitter';
+
+const EXT_TO_LANG = {
+  ".ts": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".tsx": "tsx",
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "jsx",
+  ".py": "python",
+  ".pyi": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".hpp": "cpp",
+  ".hh": "cpp",
+  ".rb": "ruby"
+};
+function detectLanguage(filePath) {
+  const ext = path__default.extname(filePath).toLowerCase();
+  return EXT_TO_LANG[ext] ?? "unknown";
+}
+async function walkFiles(opts) {
+  const { root, ignoreGlobs, includeExtensions = [], maxFiles = 0 } = opts;
+  const allIgnores = [".git", ".codewiki", ".codewiki.new", ...ignoreGlobs];
+  const ig = ignore({ allowRelativePaths: true }).add(allIgnores);
+  const gitignore = path__default.join(root, ".gitignore");
+  try {
+    const content = await promises.readFile(gitignore, "utf8");
+    ig.add(content);
+  } catch {
+  }
+  const paths = await globby("**", {
+    cwd: root,
+    absolute: true,
+    onlyFiles: true,
+    dot: false,
+    gitignore: false,
+    // we apply gitignore ourselves for portability
+    ignore: allIgnores
+  });
+  const results = [];
+  for (const abs of paths) {
+    if (maxFiles > 0 && results.length >= maxFiles) break;
+    const rel = path__default.relative(root, abs).replace(/\\/g, "/");
+    if (ig.ignores(rel)) continue;
+    let stat;
+    try {
+      stat = await promises.stat(abs);
+    } catch {
+      continue;
+    }
+    if (!stat.isFile()) continue;
+    results.push({
+      absPath: abs,
+      repoPath: repoRel(abs, root),
+      size: stat.size,
+      mtimeMs: stat.mtimeMs,
+      language: detectLanguage(abs)
+    });
+  }
+  results.sort((a, b) => a.repoPath < b.repoPath ? -1 : 1);
+  return results;
+}
+
+const walker = {
+  __proto__: null,
+  detectLanguage: detectLanguage,
+  walkFiles: walkFiles
+};
+
+const TEST_PATTERNS = [
+  /(^|\/)__tests__\//,
+  /\.test\.[a-z]+$/,
+  /\.spec\.[a-z]+$/,
+  /(^|\/)test_(.+)\.[a-z]+$/,
+  /(^|\/)(.+)_test\.[a-z]+$/,
+  /(^|\/)spec\//
+];
+function isTestFile(repoPath) {
+  return TEST_PATTERNS.some((re) => re.test(repoPath));
+}
+function moduleForFile(repoPath, cfg) {
+  if (isTestFile(repoPath)) return "_tests";
+  for (const [from, to] of Object.entries(cfg.modules.alias)) {
+    if (repoPath === from || repoPath.startsWith(`${from}/`)) {
+      const remainder = repoPath.slice(from.length).replace(/^\//, "");
+      const top2 = remainder.split("/")[0] || "_root";
+      const candidate = `${to}/${remainder === "" ? "" : top2}`.replace(/\/$/, "");
+      return candidate.split("/")[0] || "_root";
+    }
+  }
+  const top = repoPath.split("/")[0];
+  return top || "_root";
+}
+function groupModules(files, cfg) {
+  const map = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    if (f.repoPath.startsWith(".codewiki/")) continue;
+    const id = moduleForFile(f.repoPath, cfg);
+    let entry = map.get(id);
+    if (!entry) {
+      entry = {
+        id,
+        title: id,
+        files: [],
+        publicSurface: []
+      };
+      map.set(id, entry);
+    }
+    entry.files.push(f.repoPath);
+    for (const s of f.publicSymbols) {
+      entry.publicSurface.push(`${s.kind === "method" ? "method" : s.kind} ${s.name}`);
+    }
+  }
+  for (const id of [...map.keys()]) {
+    if (cfg.modules.ignore.includes(id)) {
+      map.delete(id);
+    }
+  }
+  return map;
+}
+
+function sha256Hex(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+
+function countTokens(input) {
+  if (!input) return 0;
+  return encode(input).length;
+}
+function truncateToTokens(text, budget, ellipsis = "\u2026") {
+  const current = countTokens(text);
+  if (current <= budget) return text;
+  let lo = 0;
+  let hi = text.length;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (countTokens(text.slice(0, mid)) <= budget - 1) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return text.slice(0, lo).trimEnd() + (lo > 0 ? " " + ellipsis : "");
+}
+
+const GENERATOR = `code-wiki`;
+const VERSION = "0.1.0";
+function frontmatter(page) {
+  const srcBlock = page.source ? `
+  source:
+    repoPath: ${yamlStr(page.source.repoPath)}
+    language: ${yamlStr(page.source.language ?? "null")}
+    module: ${yamlStr(page.source.module ?? "null")}${page.source.lineRange ? `
+    lineRange: [${page.source.lineRange[0]}, ${page.source.lineRange[1]}]` : ""}${page.source.symbol ? `
+    symbol: ${yamlStr(page.source.symbol)}` : ""}${page.source.symbolKind ? `
+    symbolKind: ${yamlStr(page.source.symbolKind)}` : ""}${page.source.signature ? `
+    signature: ${yamlStr(page.source.signature)}` : ""}` : "";
+  return [
+    "---",
+    `kind: ${page.kind}`,
+    `id: ${yamlStr(page.id)}`,
+    `title: ${yamlStr(page.title)}`,
+    `path: ${yamlStr(page.path)}`,
+    `tokens: ${page.tokens}`,
+    `stale: ${page.stale}`,
+    `generatedAt: ${yamlStr(page.generatedAt)}`,
+    `generator: ${yamlStr(page.generator)}` + srcBlock,
+    "---",
+    ""
+  ].join("\n");
+}
+function yamlStr(s) {
+  if (s == null) return "null";
+  const escaped = s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+  return `"${escaped}"`;
+}
+function pageStats(body) {
+  return countTokens(body);
+}
+function makePage(kind, id, title, relPath, data, source = void 0, stale = false) {
+  return {
+    kind,
+    id,
+    title,
+    path: relPath,
+    source,
+    tokens: 0,
+    // filled in after rendering
+    stale,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    generator: `${GENERATOR}/${VERSION}`,
+    data
+  };
+}
+
+function buildArchitecturePage(meta, files, cfg, importEdges = [], dependents = {}) {
+  const modules = groupModules(files, cfg);
+  const lines = [];
+  lines.push("# Architecture");
+  lines.push("");
+  lines.push(
+    `> ${meta.fileCount} files, ${meta.moduleCount} modules, ${meta.symbolCount} symbols.`
+  );
+  lines.push("");
+  const visible = [...modules.entries()].filter(([id]) => !cfg.modules.ignore.includes(id)).sort(([a], [b]) => a < b ? -1 : 1);
+  if (visible.length > 0) {
+    const moduleEdges = /* @__PURE__ */ new Map();
+    for (const e of importEdges) {
+      const fromMod = moduleForFile(e.from, cfg);
+      const toMod = moduleForFile(e.to, cfg);
+      if (fromMod === toMod) continue;
+      if (!visible.find(([id]) => id === fromMod)) continue;
+      if (!visible.find(([id]) => id === toMod)) continue;
+      const key = `${fromMod}|${toMod}`;
+      moduleEdges.set(key, (moduleEdges.get(key) ?? 0) + 1);
+    }
+    lines.push("## Module map");
+    lines.push("");
+    lines.push("```mermaid");
+    lines.push("graph LR");
+    const cap = cfg.budgets.mermaidNodes;
+    const displayedNodes = visible.slice(0, cap);
+    for (const [id, m] of displayedNodes) {
+      lines.push(`  ${diagramId(id)}["${m.title}"]`);
+    }
+    if (visible.length > cap) {
+      lines.push(`  more["...(${visible.length - cap} more)"]`);
+    }
+    const edgesArr = [...moduleEdges.entries()].filter(
+      ([k]) => displayedNodes.find(([id]) => id === k.split("|")[0]) && displayedNodes.find(([id]) => id === k.split("|")[1])
+    );
+    for (const [key, count] of edgesArr.slice(0, cap)) {
+      const [from, to] = key.split("|");
+      lines.push(`  ${diagramId(from)} -->|${count} edge${count === 1 ? "" : "es"}| ${diagramId(to)}`);
+    }
+    lines.push("```");
+    lines.push("");
+  }
+  lines.push("## Modules");
+  lines.push("");
+  lines.push(
+    "| Module | Files | Public surface | Imports | Imported by |"
+  );
+  lines.push("| --- | --- | --- | --- | --- |");
+  for (const [id, m] of visible) {
+    const purpose = m.publicSurface.length > 0 ? `\`${m.publicSurface.slice(0, 3).join("`, `")}\`...` : "_Internal-only_";
+    const outCount = countOutgoing(importEdges, files, cfg, id);
+    const inCount = countIncoming(dependents, files, cfg, id);
+    lines.push(
+      `| [${m.title}](./modules/${id}.md) | ${m.files.length} | ${purpose} | ${outCount} | ${inCount} |`
+    );
+  }
+  lines.push("");
+  const body = lines.join("\n");
+  const tokens = pageStats(body);
+  const data = {
+    meta,
+    modules: visible.map(([id, m]) => ({
+      id,
+      title: m.title,
+      fileCount: m.files.length,
+      purpose: m.publicSurface.length > 0 ? `Public: ${m.publicSurface.slice(0, 3).join(", ")}...` : "Internal-only",
+      pagePath: `modules/${id}.md`,
+      importsCount: countOutgoing(importEdges, files, cfg, id),
+      dependentsCount: countIncoming(dependents, files, cfg, id)
+    }))
+  };
+  const page = makePage(
+    "architecture",
+    "architecture",
+    "Architecture",
+    "architecture.md",
+    data,
+    void 0,
+    false
+  );
+  page.tokens = tokens;
+  return { page, body, tokens };
+}
+function renderArchitecture(page, body) {
+  return frontmatter(page) + body;
+}
+function diagramId(s) {
+  return s.replace(/[^A-Za-z0-9]/g, "_").replace(/^(\d)/, "_$1");
+}
+function countOutgoing(edges, _files, cfg, moduleId) {
+  let n = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    const fromMod = moduleForFile(e.from, cfg);
+    if (fromMod !== moduleId) continue;
+    const toMod = moduleForFile(e.to, cfg);
+    const key = `${fromMod}|${toMod}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      n++;
+    }
+  }
+  return n;
+}
+function countIncoming(dependents, _files, cfg, moduleId) {
+  const counts = /* @__PURE__ */ new Set();
+  for (const t of Object.keys(dependents)) {
+    const tgt = moduleForFile(t, cfg);
+    if (tgt === moduleId) {
+      for (const d of dependents[t] ?? []) counts.add(moduleForFile(d, cfg));
+    }
+  }
+  return counts.size;
+}
+
+function buildIndexPage(meta, modules, modulePagePaths, moduleTokens, recent, cfg) {
+  const modList = [...modules.entries()].filter(([id]) => !cfg.modules.ignore.includes(id)).map(([id, m]) => ({
+    ...m,
+    pagePath: modulePagePaths.get(id) ?? `modules/${id}.md`,
+    tokens: moduleTokens.get(id) ?? 0
+  })).sort((a, b) => a.id < b.id ? -1 : 1);
+  const data = {
+    meta,
+    modules: modList,
+    recentlyChanged: recent
+  };
+  const lines = [];
+  lines.push("# Code Index");
+  lines.push("");
+  lines.push(
+    `> ${meta.fileCount} files across ${meta.moduleCount} modules. Generated ${meta.updatedAt}.`
+  );
+  lines.push("");
+  lines.push("## Modules");
+  lines.push("");
+  for (const m of modList) {
+    lines.push(`- [${m.title}](./${m.pagePath}) \u2014 ${m.files.length} files, ~${m.tokens} tokens`);
+  }
+  if (recent.length > 0) {
+    lines.push("");
+    lines.push("## Recently changed");
+    lines.push("");
+    for (const p of recent) lines.push(`- \`${p}\``);
+  }
+  lines.push("");
+  lines.push("## Search hints");
+  lines.push("");
+  lines.push("- Use `/wiki-search <query>` or the `wiki_search` MCP tool.");
+  lines.push("- Use `/wiki-symbol <path>:<name>` to drill into one symbol.");
+  lines.push("- Use `/wiki-architecture` for the system view (and a Mermaid diagram).");
+  lines.push("");
+  const body = lines.join("\n");
+  const tokens = pageStats(body);
+  const page = makePage(
+    "index",
+    "index",
+    "Code Index",
+    "INDEX.md",
+    data,
+    void 0,
+    false
+  );
+  page.tokens = tokens;
+  return { page, body, tokens };
+}
+function renderIndex(page, body) {
+  return frontmatter(page) + body;
+}
+
+function buildModulePage(module, files, filePagePaths, cfg, importEdges = [], dependents = {}) {
+  const lines = [];
+  lines.push(`# Module: ${module.title}`);
+  lines.push("");
+  lines.push(
+    `> ${module.files.length} files, ${module.publicSurface.length} public symbols.`
+  );
+  lines.push("");
+  const outgoing = /* @__PURE__ */ new Set();
+  for (const e of importEdges) {
+    const fromMod = moduleForFile(e.from, cfg);
+    if (fromMod === module.id) {
+      outgoing.add(moduleForFile(e.to, cfg));
+    }
+  }
+  const incoming = /* @__PURE__ */ new Set();
+  for (const t of Object.keys(dependents)) {
+    const tgtMod = moduleForFile(t, cfg);
+    if (tgtMod === module.id) {
+      for (const d of dependents[t] ?? []) incoming.add(moduleForFile(d, cfg));
+    }
+  }
+  if (outgoing.size > 0 || incoming.size > 0) {
+    lines.push("## Dependencies");
+    lines.push("");
+    lines.push("```mermaid");
+    lines.push("graph LR");
+    const selfId = "this";
+    lines.push(`  ${selfId}["${module.title}"]`);
+    let i = 0;
+    for (const m of outgoing) {
+      if (m === module.id) continue;
+      lines.push(`  out${i}["${m}"]`);
+      lines.push(`  ${selfId} --> out${i}`);
+      i++;
+    }
+    let j = 0;
+    for (const m of incoming) {
+      if (m === module.id) continue;
+      lines.push(`  in${j}["${m}"]`);
+      lines.push(`  in${j} --> ${selfId}`);
+      j++;
+    }
+    lines.push("```");
+    lines.push("");
+  }
+  if (module.publicSurface.length > 0) {
+    lines.push("## Public surface");
+    lines.push("");
+    for (const s of module.publicSurface.slice(0, 20)) {
+      lines.push(`- \`${s}\``);
+    }
+    if (module.publicSurface.length > 20) {
+      lines.push(`- _(${module.publicSurface.length - 20} more \u2014 see \`/wiki-search <id>\` for the rest)_`);
+    }
+    lines.push("");
+  }
+  lines.push("## Files");
+  lines.push("");
+  lines.push("| File | Summary | Symbols |");
+  lines.push("| --- | --- | --- |");
+  for (const fp of module.files) {
+    const f = files.find((x) => x.repoPath === fp);
+    if (!f) continue;
+    const pagePath2 = filePagePaths.get(fp) ?? `files/${fp}.md`;
+    const summary = (f.oneLineSummary || "").replace(/\|/g, "\\|").slice(0, 120);
+    lines.push(`| [${fp}](./${pagePath2}) | ${summary} | ${f.symbols.length} |`);
+  }
+  lines.push("");
+  const body = lines.join("\n");
+  const tokens = pageStats(body);
+  const data = {
+    module,
+    files: module.files.map((fp) => {
+      const f = files.find((x) => x.repoPath === fp);
+      if (!f) return null;
+      return {
+        repoPath: fp,
+        oneLineSummary: f.oneLineSummary,
+        pagePath: filePagePaths.get(fp) ?? `files/${fp}.md`,
+        symbols: f.symbols.length
+      };
+    }).filter((x) => x !== null),
+    importsCount: outgoing.size,
+    dependentsCount: incoming.size
+  };
+  const pagePath = `modules/${module.id}.md`;
+  const page = makePage(
+    "module",
+    module.id,
+    module.title,
+    pagePath,
+    data,
+    {
+      repoPath: "",
+      language: null,
+      module: module.id
+    },
+    false
+  );
+  page.tokens = tokens;
+  return { page, body, tokens };
+}
+function renderModule(page, body) {
+  return frontmatter(page) + body;
+}
+
+function buildFilePage(file) {
+  const lines = [];
+  lines.push(`# File: ${file.repoPath}`);
+  lines.push("");
+  if (file.oneLineSummary) lines.push(`> ${file.oneLineSummary}`);
+  lines.push("");
+  lines.push(`- **Language**: ${file.language ?? "unknown"}`);
+  lines.push(`- **Size**: ${file.size} bytes`);
+  lines.push(`- **Symbols**: ${file.symbols.length}`);
+  lines.push("");
+  if (file.symbols.length > 0) {
+    lines.push("## Symbols");
+    lines.push("");
+    lines.push("| Name | Kind | Lines | Signature |");
+    lines.push("| --- | --- | --- | --- |");
+    for (const s of file.symbols) {
+      const sig = (s.signature || "").replace(/\|/g, "\\|").replace(/\n/g, " ");
+      lines.push(
+        `| ${s.name} | ${s.kind} | ${s.lineRange[0]}-${s.lineRange[1]} | \`${sig.slice(0, 200)}\` |`
+      );
+    }
+    lines.push("");
+  } else {
+    lines.push("_No symbols extracted (language not yet supported or file is empty)._");
+    lines.push("");
+  }
+  lines.push("## Notes");
+  lines.push("");
+  lines.push(
+    "This is the static summary. Run `/wiki-enrich` (with `ANTHROPIC_API_KEY` set) for richer prose."
+  );
+  lines.push("");
+  const body = lines.join("\n");
+  const tokens = pageStats(body);
+  const pagePath = `files/${file.repoPath}.md`;
+  const data = { file };
+  const page = makePage(
+    "file",
+    file.repoPath,
+    file.repoPath,
+    pagePath,
+    data,
+    {
+      repoPath: file.repoPath,
+      language: file.language,
+      module: null
+    },
+    false
+  );
+  page.tokens = tokens;
+  return { page, body, tokens };
+}
+function renderFile(page, body) {
+  return frontmatter(page) + body;
+}
+
+const SCHEMA_VERSION = 1;
+
+const GRAMMAR_PATHS = {
+  typescript: {
+    basename: "tree-sitter-typescript.wasm",
+    candidateNames: [
+      "dist/grammars/typescript.wasm",
+      "node_modules/tree-sitter-typescript/tree-sitter-typescript.wasm",
+      // Bundled plugin: chunks live at dist/chunks/*.mjs; grammars live at
+      // dist/grammars/*.wasm. We compute the chunk's dirname lazily.
+      `__import_meta_dirname__/../grammars/typescript.wasm`
+    ]
+  },
+  tsx: {
+    basename: "tree-sitter-tsx.wasm",
+    candidateNames: [
+      "dist/grammars/tsx.wasm",
+      "node_modules/tree-sitter-typescript/tree-sitter-tsx.wasm",
+      `__import_meta_dirname__/../grammars/tsx.wasm`
+    ]
+  },
+  javascript: {
+    basename: "tree-sitter-javascript.wasm",
+    candidateNames: [
+      "dist/grammars/javascript.wasm",
+      "node_modules/tree-sitter-javascript/tree-sitter-javascript.wasm",
+      `__import_meta_dirname__/../grammars/javascript.wasm`
+    ]
+  },
+  python: {
+    basename: "tree-sitter-python.wasm",
+    candidateNames: [
+      "dist/grammars/python.wasm",
+      "node_modules/tree-sitter-python/tree-sitter-python.wasm",
+      `__import_meta_dirname__/../grammars/python.wasm`
+    ]
+  },
+  go: {
+    basename: "tree-sitter-go.wasm",
+    candidateNames: [
+      "dist/grammars/go.wasm",
+      "node_modules/tree-sitter-go/tree-sitter-go.wasm",
+      `__import_meta_dirname__/../grammars/go.wasm`
+    ]
+  },
+  rust: {
+    basename: "tree-sitter-rust.wasm",
+    candidateNames: [
+      "dist/grammars/rust.wasm",
+      "node_modules/tree-sitter-rust/tree-sitter-rust.wasm",
+      `__import_meta_dirname__/../grammars/rust.wasm`
+    ]
+  },
+  java: {
+    basename: "tree-sitter-java.wasm",
+    candidateNames: [
+      "dist/grammars/java.wasm",
+      "node_modules/tree-sitter-java/tree-sitter-java.wasm",
+      `__import_meta_dirname__/../grammars/java.wasm`
+    ]
+  },
+  c: {
+    basename: "tree-sitter-c.wasm",
+    candidateNames: [
+      "dist/grammars/c.wasm",
+      "node_modules/tree-sitter-c/tree-sitter-c.wasm",
+      `__import_meta_dirname__/../grammars/c.wasm`
+    ]
+  },
+  cpp: {
+    basename: "tree-sitter-cpp.wasm",
+    candidateNames: [
+      "dist/grammars/cpp.wasm",
+      "node_modules/tree-sitter-cpp/tree-sitter-cpp.wasm",
+      `__import_meta_dirname__/../grammars/cpp.wasm`
+    ]
+  },
+  ruby: {
+    basename: "tree-sitter-ruby.wasm",
+    candidateNames: [
+      "dist/grammars/ruby.wasm",
+      "node_modules/tree-sitter-ruby/tree-sitter-ruby.wasm",
+      `__import_meta_dirname__/../grammars/ruby.wasm`
+    ]
+  }
+};
+function expandImportMetaDirname(candidates) {
+  if (typeof import.meta.dirname !== "string") return candidates;
+  return candidates.map(
+    (c) => c.includes("__import_meta_dirname__") ? c.replace(/__import_meta_dirname__/g, import.meta.dirname) : c
+  );
+}
+let initPromise = null;
+const languageCache = /* @__PURE__ */ new Map();
+async function ensureParserInit() {
+  if (!initPromise) {
+    initPromise = Parser.init().then(() => {
+      log.debug("web-tree-sitter Parser initialised");
+    });
+  }
+  return initPromise;
+}
+async function findWasm(candidates) {
+  const expanded = expandImportMetaDirname(candidates);
+  for (const rel of expanded) {
+    if (path__default.isAbsolute(rel)) {
+      try {
+        await promises.access(rel);
+        return rel;
+      } catch {
+      }
+    }
+  }
+  let cwd = process.cwd();
+  for (let i = 0; i < 8; i++) {
+    for (const rel of expanded) {
+      if (path__default.isAbsolute(rel)) continue;
+      const abs = path__default.join(cwd, rel);
+      try {
+        await promises.access(abs);
+        return abs;
+      } catch {
+      }
+    }
+    const parent = path__default.dirname(cwd);
+    if (parent === cwd) break;
+    cwd = parent;
+  }
+  return null;
+}
+async function getLanguage(lang) {
+  const cached = languageCache.get(lang);
+  if (cached) return cached;
+  const spec = GRAMMAR_PATHS[lang];
+  if (!spec) return null;
+  await ensureParserInit();
+  const wasmPath = await findWasm(spec.candidateNames);
+  if (!wasmPath) {
+    log.warn({ lang }, "tree-sitter grammar wasm not found; check dist/grammars/");
+    return null;
+  }
+  try {
+    const bytes = await promises.readFile(wasmPath);
+    const language = await Language.load(bytes);
+    languageCache.set(lang, language);
+    return language;
+  } catch (err) {
+    log.warn({ lang, err: String(err) }, "failed to load grammar");
+    return null;
+  }
+}
+
+const TYPESCRIPT_QUERY = `
+; top-level function declarations
+(function_declaration
+  name: (identifier) @def.function.name) @def.function
+
+; exported function declarations
+(export_statement
+  (function_declaration
+    name: (identifier) @def.function.name) @def.function)
+
+; variable-declared functions / arrows
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @def.function.name
+    value: [(function_expression) (arrow_function)]) @def.function)
+
+; class declarations
+(class_declaration
+  name: (type_identifier) @def.class.name) @def.class
+(export_statement
+  (class_declaration
+    name: (type_identifier) @def.class.name) @def.class)
+
+; class members (methods)
+(method_definition
+  name: (property_identifier) @def.method.name) @def.method
+
+; interfaces
+(interface_declaration
+  name: (type_identifier) @def.interface.name) @def.interface
+(export_statement
+  (interface_declaration
+    name: (type_identifier) @def.interface.name) @def.interface)
+
+; type aliases
+(type_alias_declaration
+  name: (type_identifier) @def.type.name) @def.type
+(export_statement
+  (type_alias_declaration
+    name: (type_identifier) @def.type.name) @def.type)
+
+; enums
+(enum_declaration
+  name: (identifier) @def.enum.name) @def.enum
+(export_statement
+  (enum_declaration
+    name: (identifier) @def.enum.name) @def.enum)
+`;
+const NAME_CAPTURE_RE = /^def\.(\w+)\.name$/;
+const FULL_CAPTURE_RE = /^def\.(\w+)$/;
+async function extractTypeScript(opts) {
+  const { source, language, repoPath } = opts;
+  const parser = new Parser();
+  parser.setLanguage(language);
+  const tree = parser.parse(source);
+  if (!tree) return { symbols: [] };
+  const query = new Query(language, TYPESCRIPT_QUERY);
+  const matches = query.matches(tree.rootNode);
+  const nameByNodeId = /* @__PURE__ */ new Map();
+  const kindByNodeId = /* @__PURE__ */ new Map();
+  const nodeById = /* @__PURE__ */ new Map();
+  for (const m of matches) {
+    let nameText = null;
+    let kindName = null;
+    let fullNode = null;
+    for (const cap of m.captures) {
+      nodeById.set(cap.node.id, cap.node);
+      if (NAME_CAPTURE_RE.test(cap.name)) {
+        nameText = source.slice(cap.node.startIndex, cap.node.endIndex);
+        const k = cap.name.replace("def.", "").replace(".name", "");
+        kindName = k;
+      } else if (FULL_CAPTURE_RE.test(cap.name)) {
+        fullNode = cap.node;
+      }
+    }
+    if (fullNode && nameText && kindName) {
+      nameByNodeId.set(fullNode.id, nameText);
+      kindByNodeId.set(fullNode.id, kindName);
+    }
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of matches) {
+    let fullNode = null;
+    for (const cap of m.captures) {
+      nodeById.set(cap.node.id, cap.node);
+      if (FULL_CAPTURE_RE.test(cap.name)) {
+        fullNode = cap.node;
+      }
+    }
+    if (!fullNode) continue;
+    if (seen.has(fullNode.id)) continue;
+    seen.add(fullNode.id);
+    const name = nameByNodeId.get(fullNode.id);
+    const kind = kindByNodeId.get(fullNode.id);
+    if (!name || !kind) continue;
+    const sig = source.slice(fullNode.startIndex, Math.min(fullNode.endIndex, fullNode.startIndex + 400)).split("\n").slice(0, 2).join(" ").trim();
+    const docstring = extractDocstring(source, fullNode);
+    const vis = isExported(fullNode) ? "public" : "internal";
+    const cx = approxComplexity$1(fullNode);
+    let parentId = null;
+    if (kind === "method") {
+      let p = fullNode.parent;
+      while (p) {
+        if (p.type === "class_declaration" || p.type === "class") {
+          const pName = nameByNodeId.get(p.id);
+          const pKind = kindByNodeId.get(p.id);
+          if (pName && pKind === "class") {
+            parentId = buildId(repoPath, "class", pName);
+          }
+          break;
+        }
+        p = p.parent;
+      }
+    }
+    out.push({
+      id: buildId(repoPath, kind, name),
+      name,
+      kind,
+      signature: sig,
+      lineRange: [
+        fullNode.startPosition.row + 1,
+        fullNode.endPosition.row + 1
+      ],
+      docstring,
+      parentId,
+      visibility: vis,
+      complexity: cx
+    });
+  }
+  return { symbols: out };
+}
+function buildId(repoPath, kind, name) {
+  return `${repoPath}::${kind}.${name}`;
+}
+function extractDocstring(source, node) {
+  let top = node;
+  while (top && top.parent && top.parent.type !== "program") {
+    top = top.parent;
+  }
+  if (!top) return null;
+  const programRoot = top.parent;
+  if (!programRoot) return null;
+  let windowStart = 0;
+  const maxWindow = 4096;
+  let cursor = top.previousNamedSibling;
+  let safety = 16;
+  while (cursor && safety-- > 0) {
+    if (cursor.startIndex > 0) windowStart = cursor.startIndex;
+    const dist = top.startIndex - windowStart;
+    if (dist > maxWindow) break;
+    cursor = cursor.previousNamedSibling;
+  }
+  const window = source.slice(windowStart, top.startIndex);
+  const jsdocMatch = /\/\*\*([\s\S]*?)\*\//.exec(window);
+  if (jsdocMatch) {
+    const cleaned = jsdocMatch[1].replace(/^\s*\* ?/gm, "").trim();
+    if (cleaned) return firstParagraph$1(cleaned, 400);
+  }
+  const lines = window.split("\n").slice(-8);
+  const commentLines = [];
+  for (const ln of lines.reverse()) {
+    const m = /^\s*\/\/\s?(.*)$/.exec(ln);
+    if (!m) {
+      if (commentLines.length > 0) break;
+      continue;
+    }
+    commentLines.unshift(m[1] ?? "");
+  }
+  if (commentLines.length === 0) return null;
+  return firstParagraph$1(commentLines.join(" "), 400);
+}
+function firstParagraph$1(text, max) {
+  const idx = text.indexOf("\n\n");
+  const first = idx >= 0 ? text.slice(0, idx) : text;
+  return first.length > max ? `${first.slice(0, max)}\u2026` : first;
+}
+function isExported(node) {
+  let p = node.parent;
+  while (p) {
+    if (p.type === "export_statement") return true;
+    p = p.parent;
+  }
+  return false;
+}
+function approxComplexity$1(node) {
+  let count = 1;
+  walk$2(node, (n) => {
+    if (n.type === "if_statement" || n.type === "for_statement" || n.type === "for_in_statement" || n.type === "while_statement" || n.type === "do_statement" || n.type === "case_statement" || n.type === "catch_clause" || n.type === "switch_case") {
+      count++;
+    }
+  });
+  return count;
+}
+function walk$2(node, fn) {
+  fn(node);
+  for (let i = 0; i < node.childCount; i++) {
+    const c = node.child(i);
+    if (c) walk$2(c, fn);
+  }
+}
+async function extractWithGrammar(source, lang, repoPath) {
+  const language = await getLanguage(lang);
+  if (!language) return [];
+  const { symbols } = await extractTypeScript({ source, language, repoPath });
+  return symbols;
+}
+
+const NAME_RE = /^def\.([\w]+)\.name$/;
+const FULL_RE = /^def\.([\w]+)$/;
+async function runGenericExtract(opts) {
+  const { source, language, query, builder, repoPath } = opts;
+  const parser = new Parser();
+  parser.setLanguage(language);
+  const tree = parser.parse(source);
+  if (!tree) return [];
+  const q = new Query(language, query);
+  const matches = q.matches(tree.rootNode);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const m of matches) {
+    let fullNode = null;
+    let nameNode = null;
+    let kindName = null;
+    for (const cap of m.captures) {
+      if (FULL_RE.test(cap.name)) {
+        fullNode = cap.node;
+        kindName = cap.name.slice(4);
+      } else if (NAME_RE.test(cap.name)) {
+        nameNode = cap.node;
+      }
+    }
+    if (!fullNode || !kindName) continue;
+    if (seen.has(fullNode.id)) continue;
+    seen.add(fullNode.id);
+    const symbolKind = builder.kindOf(kindName);
+    if (!symbolKind) continue;
+    const raw = {
+      fullNode,
+      nameNode: nameNode ?? fullNode,
+      kindName,
+      source,
+      repoPath
+    };
+    const sym = builder.build(raw);
+    if (sym) out.push(sym);
+  }
+  return out;
+}
+function makeSignature(source, node, max = 400) {
+  const slice = source.slice(node.startIndex, Math.min(node.endIndex, node.startIndex + max));
+  return slice.split("\n").slice(0, 2).join(" ").replace(/\s+/g, " ").trim();
+}
+function findDocstringAbove(source, node) {
+  const above = findDocstringAboveOnly(source, node);
+  if (above) return above;
+  const inside = findDocstringInside(source, node);
+  return inside;
+}
+function findDocstringAboveOnly(source, node) {
+  let top = node;
+  while (top && top.parent && top.parent.type !== "program" && top.parent.type !== "translation_unit" && top.parent.type !== "source_file" && top.parent.type !== "module") {
+    top = top.parent;
+  }
+  if (!top) return null;
+  let windowStart = 0;
+  let cursor = top.previousNamedSibling;
+  let safety = 16;
+  while (cursor && safety-- > 0) {
+    if (cursor.startIndex > 0) windowStart = cursor.startIndex;
+    const dist = top.startIndex - windowStart;
+    if (dist > 4096) break;
+    cursor = cursor.previousNamedSibling;
+  }
+  const text = source.slice(windowStart, top.startIndex);
+  const lines = text.split("\n").slice(-12);
+  const jsdoc = /\/\*\*([\s\S]*?)\*\//.exec(text);
+  if (jsdoc) {
+    const cleaned = jsdoc[1].replace(/^\s*\* ?/gm, "").trim();
+    if (cleaned) return firstParagraph(cleaned, 400);
+  }
+  const comment = /\/\*([\s\S]*?)\*\//.exec(text);
+  if (comment) {
+    const cleaned = comment[1].replace(/^\s*\* ?/gm, "").trim();
+    if (cleaned) return firstParagraph(cleaned, 400);
+  }
+  const hashLines = [];
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const ln = lines[i] ?? "";
+    const m = /^\s*#\s?(.*)$/.exec(ln);
+    if (!m) {
+      if (hashLines.length > 0) break;
+      continue;
+    }
+    hashLines.unshift(m[1] ?? "");
+  }
+  if (hashLines.length > 0) return firstParagraph(hashLines.join(" "), 400);
+  const slashLines = [];
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const ln = lines[i] ?? "";
+    const m = /^\s*\/\/\s?(.*)$/.exec(ln);
+    if (!m) {
+      if (slashLines.length > 0) break;
+      continue;
+    }
+    slashLines.unshift(m[1] ?? "");
+  }
+  if (slashLines.length > 0) return firstParagraph(slashLines.join(" "), 400);
+  return null;
+}
+function findDocstringInside(source, node) {
+  function visit(n, depth) {
+    if (n.type === "string") {
+      const text = source.slice(n.startIndex, n.endIndex).trim();
+      const cleaned = text.replace(/^(['"]{3}|['"])|(['"]{3}|['"])$/g, "").trim();
+      if (cleaned) return firstParagraph(cleaned, 400);
+      return null;
+    }
+    if (depth >= 6) return null;
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const c = n.namedChild(i);
+      if (c) {
+        const found = visit(c, depth + 1);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  return visit(node, 0);
+}
+function isRubyPrivate(source, node) {
+  let top = node;
+  while (top && top.parent) {
+    const pt = top.parent.type;
+    if (pt === "class" || pt === "module" || pt === "program" || pt === "source_file") break;
+    top = top.parent;
+  }
+  if (!top || !top.parent) return false;
+  const clsStart = top.parent.startIndex;
+  const clsEnd = top.parent.endIndex;
+  const classBody = source.slice(clsStart, clsEnd);
+  const methodStart = node.startIndex - clsStart;
+  if (methodStart < 0) return false;
+  const head = classBody.slice(0, methodStart);
+  const lines = head.split("\n").slice(-30);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const ln = (lines[i] ?? "").trim();
+    if (ln === "" || ln === "end") continue;
+    if (ln.startsWith("def ") || ln.startsWith("class ") || ln.startsWith("module ")) return false;
+    if (ln === "private" || ln === "protected" || ln.startsWith("private ") || ln.startsWith("protected ")) {
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+function firstParagraph(text, max) {
+  const idx = text.indexOf("\n\n");
+  const first = idx >= 0 ? text.slice(0, idx) : text;
+  return first.length > max ? `${first.slice(0, max)}\u2026` : first;
+}
+function approxComplexity(node) {
+  let count = 1;
+  walk$1(node, (n) => {
+    switch (n.type) {
+      case "if_statement":
+      case "elif_clause":
+      case "else_clause":
+      case "for_statement":
+      case "for_in_statement":
+      case "while_statement":
+      case "do_statement":
+      case "case_clause":
+      case "switch_case":
+      case "catch_clause":
+        count++;
+        break;
+    }
+  });
+  return count;
+}
+function walk$1(node, fn) {
+  fn(node);
+  for (let i = 0; i < node.childCount; i++) {
+    const c = node.child(i);
+    if (c) walk$1(c, fn);
+  }
+}
+function makeSymbolId(repoPath, kind, name) {
+  return `${repoPath}::${kind}.${name}`;
+}
+
+const PYTHON_QUERY = `
+(function_definition
+  name: (identifier) @def.function.name) @def.function
+
+(class_definition
+  name: (identifier) @def.class.name) @def.class
+`;
+const pythonBuilder = {
+  kindOf: (k) => k === "function" || k === "class" ? k : null,
+  build: (raw) => buildPublicPython(raw)
+};
+function buildPublicPython(raw) {
+  const name = textOfNode(raw.nameNode, raw.source);
+  if (!name) return null;
+  const kind = raw.kindName === "class" ? "class" : "function";
+  const vis = name.startsWith("_") ? "internal" : "public";
+  return makeSymbol(raw, kind, name, vis);
+}
+const GO_QUERY = `
+(function_declaration
+  name: (identifier) @def.function.name) @def.function
+
+(method_declaration
+  name: (field_identifier) @def.method.name) @def.method
+
+(type_declaration) @def.type
+`;
+const goBuilder = {
+  kindOf: (k) => {
+    if (k === "function" || k === "method") return k;
+    if (k === "type") return "class";
+    return null;
+  },
+  build: (raw) => {
+    const text = textOf(raw.fullNode, raw.source) ?? "";
+    const nameMatch = /(?:^|\n)\s*type\s+([A-Za-z_]\w*)/.exec(text);
+    const name = nameMatch ? nameMatch[1] : textOfNode(raw.nameNode, raw.source);
+    if (!name) return null;
+    const vis = /^[A-Z]/.test(name) ? "public" : "internal";
+    let kind = "type";
+    if (raw.kindName === "function" || raw.kindName === "method") {
+      kind = raw.kindName;
+    } else if (/^\s*type\s+\w+\s+struct\b/.test(" " + text)) {
+      kind = "class";
+    } else if (/^\s*type\s+\w+\s+interface\b/.test(" " + text)) {
+      kind = "interface";
+    } else {
+      return null;
+    }
+    return makeSymbol(raw, kind, name, vis);
+  }
+};
+const RUST_QUERY = `
+(function_item
+  name: (identifier) @def.function.name) @def.function
+
+(struct_item
+  name: (type_identifier) @def.class.name) @def.class
+
+(enum_item
+  name: (type_identifier) @def.enum.name) @def.enum
+
+(trait_item
+  name: (type_identifier) @def.interface.name) @def.interface
+
+(impl_item
+  trait: (type_identifier) @def.interface.name) @def.interface
+`;
+const rustBuilder = {
+  kindOf: (k) => {
+    const m = {
+      function: "function",
+      class: "class",
+      interface: "interface",
+      enum: "enum"
+    };
+    return m[k] ?? null;
+  },
+  build: (raw) => {
+    const text = textOf(raw.fullNode, raw.source) ?? "";
+    const isPublic = /\bpub\s/.test(text);
+    const vis = isPublic ? "public" : "internal";
+    const name = textOf(raw.nameNode, raw.source);
+    if (!name) return null;
+    const map = {
+      function: "function",
+      class: "class",
+      interface: "interface",
+      enum: "enum"
+    };
+    return makeSymbol(raw, map[raw.kindName], name, vis);
+  }
+};
+const JAVA_QUERY = `
+(method_declaration
+  name: (identifier) @def.method.name) @def.method
+
+(class_declaration
+  name: (identifier) @def.class.name) @def.class
+
+(interface_declaration
+  name: (identifier) @def.interface.name) @def.interface
+
+(enum_declaration
+  name: (identifier) @def.enum.name) @def.enum
+`;
+const javaBuilder = {
+  kindOf: (k) => {
+    const m = {
+      method: "method",
+      class: "class",
+      interface: "interface",
+      enum: "enum"
+    };
+    return m[k] ?? null;
+  },
+  build: (raw) => {
+    const text = textOf(raw.fullNode, raw.source) ?? "";
+    const isPublic = /\bpublic\s/.test(text);
+    const vis = isPublic ? "public" : "internal";
+    const name = textOf(raw.nameNode, raw.source);
+    if (!name) return null;
+    const map = {
+      method: "method",
+      class: "class",
+      interface: "interface",
+      enum: "enum"
+    };
+    return makeSymbol(raw, map[raw.kindName], name, vis);
+  }
+};
+const C_QUERY = `
+(function_definition
+  declarator: (function_declarator
+    declarator: (identifier) @def.function.name)) @def.function
+`;
+const cBuilder = {
+  kindOf: (k) => k === "function" ? "function" : null,
+  build: (raw) => {
+    const text = textOf(raw.fullNode, raw.source) ?? "";
+    const isStatic = /^static\s/m.test(text);
+    const vis = isStatic ? "internal" : "public";
+    const name = textOf(raw.nameNode, raw.source);
+    if (!name) return null;
+    return makeSymbol(raw, "function", name, vis);
+  }
+};
+const CPP_QUERY = `
+(function_definition
+  declarator: (function_declarator
+    declarator: (identifier) @def.function.name)) @def.function
+
+(function_definition
+  declarator: (function_declarator
+    declarator: (field_identifier) @def.method.name)) @def.method
+
+(class_specifier
+  name: (type_identifier) @def.class.name) @def.class
+
+(struct_specifier
+  name: (type_identifier) @def.class.name) @def.class
+
+(class_specifier
+  name: (primitive_type) @def.class.name) @def.class
+`;
+const cppBuilder = {
+  kindOf: (k) => {
+    const m = {
+      function: "function",
+      method: "method",
+      class: "class"
+    };
+    return m[k] ?? null;
+  },
+  build: (raw) => {
+    textOf(raw.fullNode, raw.source) ?? "";
+    const isPrivate = /private\s*:/.test(textOfSlice(raw, 250));
+    const vis = isPrivate ? "internal" : "public";
+    const name = textOf(raw.nameNode, raw.source);
+    if (!name) return null;
+    const map = {
+      function: "function",
+      method: "method",
+      class: "class"
+    };
+    return makeSymbol(raw, map[raw.kindName], name, vis);
+  }
+};
+const RUBY_QUERY = `
+(method
+  name: (identifier) @def.method.name) @def.method
+
+(singleton_method
+  name: (identifier) @def.method.name) @def.method
+
+(class
+  name: (constant) @def.class.name) @def.class
+
+(module
+  name: (constant) @def.module.name) @def.module
+`;
+const rubyBuilder = {
+  kindOf: (k) => {
+    const m = {
+      method: "method",
+      class: "class",
+      module: "module"
+    };
+    return m[k] ?? null;
+  },
+  build: (raw) => {
+    const isPrivate = isRubyPrivate(raw.source, raw.fullNode);
+    const vis = isPrivate ? "internal" : "public";
+    const name = textOfNode(raw.nameNode, raw.source);
+    if (!name) return null;
+    const map = {
+      method: "method",
+      class: "class",
+      module: "module"
+    };
+    return makeSymbol(raw, map[raw.kindName], name, vis);
+  }
+};
+async function extractOtherLanguage(source, lang, repoPath) {
+  const language = await getLanguage(lang);
+  if (!language) return [];
+  const spec = {
+    python: { query: PYTHON_QUERY, builder: pythonBuilder },
+    go: { query: GO_QUERY, builder: goBuilder },
+    rust: { query: RUST_QUERY, builder: rustBuilder },
+    java: { query: JAVA_QUERY, builder: javaBuilder },
+    c: { query: C_QUERY, builder: cBuilder },
+    cpp: { query: CPP_QUERY, builder: cppBuilder },
+    ruby: { query: RUBY_QUERY, builder: rubyBuilder }
+  };
+  const s = spec[lang];
+  return runGenericExtract({ source, language, query: s.query, builder: s.builder, repoPath });
+}
+function textOf(node, source, kind) {
+  return source.slice(node.startIndex, node.endIndex).trim();
+}
+function textOfNode(node, source) {
+  return source.slice(node.startIndex, node.endIndex).trim();
+}
+function textOfSlice(raw, before) {
+  const start = Math.max(0, raw.fullNode.startIndex - before);
+  return raw.source.slice(start, raw.fullNode.endIndex);
+}
+function makeSymbol(raw, kind, name, visibility) {
+  const sig = makeSignature(raw.source, raw.fullNode);
+  const docstring = findDocstringAbove(raw.source, raw.fullNode);
+  const cx = approxComplexity(raw.fullNode);
+  let finalKind = kind;
+  let parentId = null;
+  let p = raw.fullNode.parent;
+  while (p) {
+    if (p.type === "class_definition" || p.type === "class_declaration" || p.type === "class_specifier" || p.type === "impl_item") {
+      const classNameNode = findFirstIdentifierNode(p);
+      if (classNameNode) {
+        const className = raw.source.slice(classNameNode.startIndex, classNameNode.endIndex).trim();
+        if (className) {
+          parentId = makeSymbolId(raw.repoPath, "class", className);
+          if (kind === "function") finalKind = "method";
+          break;
+        }
+      }
+      break;
+    }
+    p = p.parent;
+  }
+  return {
+    id: makeSymbolId(raw.repoPath, finalKind, name),
+    name,
+    kind: finalKind,
+    signature: sig,
+    lineRange: [
+      raw.fullNode.startPosition.row + 1,
+      raw.fullNode.endPosition.row + 1
+    ],
+    docstring,
+    parentId,
+    visibility,
+    complexity: cx
+  };
+}
+function findFirstIdentifierNode(node) {
+  function visit(n, depth) {
+    if (n.type === "identifier" || n.type === "type_identifier" || n.type === "constant") {
+      return n;
+    }
+    if (depth >= 2) return null;
+    for (let i = 0; i < n.childCount; i++) {
+      const c = n.child(i);
+      if (c) {
+        const found = visit(c, depth + 1);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  return visit(node, 0);
+}
+
+async function extractSymbols(input) {
+  const { source, repoPath, language } = input;
+  if (!source) return [];
+  switch (language) {
+    case "typescript":
+    case "tsx":
+    case "javascript":
+    case "jsx":
+      return extractWithGrammar(source, language, repoPath);
+    case "python":
+    case "go":
+    case "rust":
+    case "java":
+    case "c":
+    case "cpp":
+    case "ruby":
+      return extractOtherLanguage(source, language, repoPath);
+    default:
+      return [];
+  }
+}
+function isExtractable(language) {
+  return language === "typescript" || language === "tsx" || language === "javascript" || language === "jsx" || language === "python" || language === "go" || language === "rust" || language === "java" || language === "c" || language === "cpp" || language === "ruby";
+}
+
+function buildSymbolPage(symbol, fileRepoPath) {
+  const lines = [];
+  lines.push(`# ${symbol.kind}: \`${symbol.name}\``);
+  lines.push("");
+  lines.push(
+    `> Defined in \`${fileRepoPath}\`, lines ${symbol.lineRange[0]}-${symbol.lineRange[1]}.`
+  );
+  lines.push("");
+  lines.push("## Signature");
+  lines.push("");
+  lines.push("```" + inferLang(fileRepoPath));
+  lines.push(symbol.signature || symbol.name);
+  lines.push("```");
+  lines.push("");
+  if (symbol.docstring) {
+    lines.push("## Description");
+    lines.push("");
+    lines.push(symbol.docstring);
+    lines.push("");
+  }
+  lines.push("## Metadata");
+  lines.push("");
+  lines.push(`- **Visibility**: ${symbol.visibility}`);
+  lines.push(`- **Complexity**: ${symbol.complexity}`);
+  lines.push("");
+  const body = lines.join("\n");
+  const tokens = pageStats(body);
+  const pagePath = `symbols/${fileRepoPath}/${symbol.kind}.${symbol.name}.md`;
+  const data = { symbol, fileRepoPath };
+  const page = makePage(
+    "symbol",
+    symbol.id,
+    symbol.name,
+    pagePath,
+    data,
+    {
+      repoPath: fileRepoPath,
+      language: null,
+      module: null,
+      lineRange: symbol.lineRange,
+      symbol: symbol.name,
+      symbolKind: symbol.kind,
+      signature: symbol.signature
+    },
+    false
+  );
+  page.tokens = tokens;
+  return { page, body, tokens };
+}
+function renderSymbol(page, body) {
+  return frontmatter(page) + body;
+}
+function inferLang(path) {
+  const ext = path.split(".").pop() ?? "";
+  if (ext === "ts" || ext === "tsx") return "typescript";
+  if (ext === "js" || ext === "jsx") return "javascript";
+  if (ext === "py") return "python";
+  if (ext === "go") return "go";
+  if (ext === "rs") return "rust";
+  if (ext === "java") return "java";
+  if (ext === "rb") return "ruby";
+  if (ext === "cpp" || ext === "cc" || ext === "cxx") return "cpp";
+  if (ext === "c" || ext === "h") return "c";
+  if (ext === "hpp" || ext === "hh") return "cpp";
+  return "";
+}
+
+const WALKERS = {
+  typescript: tsLike,
+  tsx: tsLike,
+  javascript: tsLike,
+  jsx: tsLike,
+  python: pyWalker,
+  go: goWalker,
+  rust: rustWalker,
+  java: javaWalker,
+  c: cppLike,
+  cpp: cppLike,
+  ruby: rubyWalker
+};
+const TS_IMPORT_TYPES = /* @__PURE__ */ new Set(["import_statement", "export_statement"]);
+function tsLike(root, source) {
+  const out = [];
+  walk(root, (n) => {
+    if (!TS_IMPORT_TYPES.has(n.type)) return;
+    let srcText = "";
+    const specs = [];
+    const visit = (m, depth) => {
+      if (!m) return;
+      if (depth > 4) return;
+      if (m.type === "string") {
+        if (srcText === "" && depth <= 2) {
+          srcText = source.slice(m.startIndex, m.endIndex).trim();
+        }
+      }
+      if (m.type === "import_specifier" || m.type === "export_specifier") {
+        const name = findFirstNamedChildText(m, ["identifier", "type_identifier"], source);
+        if (name) specs.push(name);
+      }
+      for (let i = 0; i < m.childCount; i++) {
+        visit(m.child(i), depth + 1);
+      }
+    };
+    visit(n, 0);
+    if (!srcText) return;
+    out.push({ source: srcText, specifiers: specs, row: n.startPosition.row });
+  });
+  return out;
+}
+function pyWalker(root, source) {
+  const out = [];
+  walk(root, (n) => {
+    if (n.type === "import_statement") {
+      const srcText = findFirstNamedChildText(n, ["dotted_name"], source);
+      if (srcText) out.push({ source: srcText, specifiers: [], row: n.startPosition.row });
+    } else if (n.type === "import_from_statement") {
+      let srcText = "";
+      const specs = [];
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (!c) continue;
+        if (c.type === "dotted_name" && !srcText) {
+          srcText = source.slice(c.startIndex, c.endIndex).trim();
+        } else if (c.type === "relative_import") {
+          srcText = source.slice(c.startIndex, c.endIndex).trim();
+        } else if (c.type === "dotted_name" && srcText) {
+          specs.push(source.slice(c.startIndex, c.endIndex).trim());
+        } else if (c.type === "aliased_import") {
+          const name = findFirstNamedChildText(c, ["dotted_name"], source);
+          if (name) specs.push(name);
+        }
+      }
+      if (!srcText) {
+        const text = source.slice(n.startIndex, n.endIndex);
+        const m = /^from\s+(\S+)/.exec(text);
+        if (m) srcText = m[1] ?? "";
+      }
+      if (!srcText) return;
+      out.push({ source: srcText, specifiers: specs, row: n.startPosition.row });
+    }
+  });
+  return out;
+}
+function goWalker(root, source) {
+  const out = [];
+  walk(root, (n) => {
+    if (n.type !== "import_spec") return;
+    let srcText = "";
+    const specs = [];
+    for (let i = 0; i < n.childCount; i++) {
+      const c = n.child(i);
+      if (!c) continue;
+      if (c.type === "interpreted_string_literal") {
+        srcText = source.slice(c.startIndex, c.endIndex).trim();
+      } else if (c.type === "identifier" || c.type === "dot") {
+        specs.push(source.slice(c.startIndex, c.endIndex).trim());
+      }
+    }
+    if (!srcText) return;
+    out.push({ source: srcText, specifiers: specs, row: n.startPosition.row });
+  });
+  return out;
+}
+function rustWalker(root, source) {
+  const out = [];
+  walk(root, (n) => {
+    if (n.type !== "use_declaration") return;
+    const text = source.slice(n.startIndex, n.endIndex);
+    const m = /^use\s+([^;{]+?)\s*(::\s*\{([^}]+)\})?\s*;/.exec(text);
+    if (!m) return;
+    const head = m[1]?.trim() ?? "";
+    const group = m[3]?.trim();
+    if (group) {
+      const parts = group.split(",").map((s) => s.trim()).filter(Boolean);
+      out.push({ source: head, specifiers: parts, row: n.startPosition.row });
+    } else {
+      out.push({ source: head, specifiers: [], row: n.startPosition.row });
+    }
+  });
+  return out;
+}
+function javaWalker(root, source) {
+  const out = [];
+  walk(root, (n) => {
+    if (n.type !== "import_declaration") return;
+    const text = source.slice(n.startIndex, n.endIndex);
+    const m = /^import\s+(?:static\s+)?([\w.]+)/.exec(text);
+    if (!m) return;
+    const lastDot = m[1].lastIndexOf(".");
+    const head = lastDot >= 0 ? m[1].slice(0, lastDot) : "";
+    const tail = lastDot >= 0 ? m[1].slice(lastDot + 1) : m[1];
+    const srcText = head ? `${head}.${tail}` : m[1] ?? "";
+    out.push({
+      source: srcText,
+      specifiers: tail ? [tail] : [],
+      row: n.startPosition.row
+    });
+  });
+  return out;
+}
+function cppLike(root, source) {
+  const out = [];
+  walk(root, (n) => {
+    if (n.type !== "preproc_include") return;
+    const text = source.slice(n.startIndex, n.endIndex);
+    const m = /#\s*include\s+([<"])([^>"]+)[>"]/.exec(text);
+    if (!m) return;
+    const delim = m[1];
+    if (delim === "<") return;
+    const srcText = m[2] ?? "";
+    out.push({ source: srcText, specifiers: [], row: n.startPosition.row });
+  });
+  return out;
+}
+function rubyWalker(root, source) {
+  const out = [];
+  const IMPORT_METHODS = /* @__PURE__ */ new Set(["require", "require_relative", "load"]);
+  walk(root, (n) => {
+    if (n.type !== "call") return;
+    let methodName = "";
+    let strText = "";
+    const visit = (m) => {
+      if (m.type === "identifier" && !methodName) {
+        methodName = source.slice(m.startIndex, m.endIndex);
+      } else if (m.type === "string") {
+        strText = source.slice(m.startIndex, m.endIndex).trim();
+      }
+      for (let i = 0; i < m.childCount; i++) {
+        const c = m.child(i);
+        if (c) visit(c);
+      }
+    };
+    visit(n);
+    if (!IMPORT_METHODS.has(methodName)) return;
+    if (!strText) return;
+    out.push({ source: strText, specifiers: [], row: n.startPosition.row });
+  });
+  return out;
+}
+function walk(node, fn) {
+  fn(node);
+  for (let i = 0; i < node.childCount; i++) {
+    const c = node.child(i);
+    if (c) walk(c, fn);
+  }
+}
+function findFirstNamedChildText(node, want, source) {
+  for (let i = 0; i < node.childCount; i++) {
+    const c = node.child(i);
+    if (c && want.includes(c.type)) {
+      return source.slice(c.startIndex, c.endIndex).trim();
+    }
+  }
+  return null;
+}
+async function extractImports(source, repoPath, lang) {
+  const languageObj = await getLanguage(lang);
+  if (!languageObj) return [];
+  const walker = WALKERS[lang];
+  if (!walker) return [];
+  const parser = new Parser();
+  parser.setLanguage(languageObj);
+  const tree = parser.parse(source);
+  if (!tree) return [];
+  const hits = walker(tree.rootNode, source);
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const hit of hits) {
+    const rawSource = stripQuotes(hit.source.trim());
+    const target = resolveImport(repoPath, rawSource, lang);
+    if (!target) continue;
+    const key = `${repoPath}->${target}|${hit.specifiers.join(",")}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    edges.push({ from: repoPath, to: target, specifiers: hit.specifiers });
+  }
+  return edges;
+}
+function stripQuotes(s) {
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function resolveImport(importerRepoPath, rawSource, lang) {
+  if (!rawSource) return null;
+  if (lang === "python") {
+    if (rawSource.startsWith(".")) return resolveRelative(importerRepoPath, rawSource);
+    return rawSource.replace(/\./g, "/");
+  }
+  if (lang === "c" || lang === "cpp") {
+    if (rawSource.startsWith('"')) return resolveRelative(importerRepoPath, rawSource.slice(1, -1));
+    return null;
+  }
+  if (lang === "java") {
+    return rawSource.replace(/\./g, "/") + ".java";
+  }
+  if (lang === "ruby" && rawSource.startsWith(".")) {
+    return resolveRelative(importerRepoPath, rawSource);
+  }
+  if (rawSource.startsWith(".") || rawSource.startsWith("/")) {
+    return resolveRelative(importerRepoPath, rawSource);
+  }
+  return rawSource;
+}
+function resolveRelative(importerRepoPath, rel) {
+  let normalizedRel = rel;
+  if (/^\.+$/.test(rel) || /^\.+[\w]/.test(rel)) {
+    const dots = (rel.match(/^\.+/)?.[0] ?? "").length;
+    const base = rel.slice(dots);
+    const importerDir2 = path__default.posix.dirname(importerRepoPath);
+    let dir = importerDir2;
+    for (let i = 1; i < dots; i++) {
+      const parent = path__default.posix.dirname(dir);
+      if (parent === dir) return null;
+      dir = parent;
+    }
+    if (!base) return toPosix(dir);
+    normalizedRel = `${dir}/${base}`.replace(/^\.?\//, "");
+    return toPosix(normalizedRel);
+  }
+  const importerDir = path__default.posix.dirname(importerRepoPath);
+  const normalized = path__default.posix.normalize(path__default.posix.join(importerDir, rel));
+  if (normalized.startsWith("..") || normalized === "") return null;
+  return toPosix(normalized);
+}
+function computeDependents(edges) {
+  const map = {};
+  for (const e of edges) {
+    const list = map[e.to] ?? [];
+    if (!list.includes(e.from)) list.push(e.from);
+    map[e.to] = list;
+  }
+  return map;
+}
+
+async function buildWiki(opts) {
+  const t0 = Date.now();
+  const cfg = opts.config ?? await loadConfig(opts.cwd, opts.configPath);
+  const root = opts.cwd;
+  const outRel = cfg.outDir;
+  const outAbs = path__default.resolve(root, outRel);
+  const outNew = `${outAbs}.new`;
+  const log_ = child({ phase: "build", root, out: outRel });
+  log_.info({ cfg: configSummary(cfg) }, "starting build");
+  const walked = await walkFiles({
+    root,
+    ignoreGlobs: cfg.ignore,
+    includeExtensions: cfg.includeExtensions
+  });
+  log_.info({ count: walked.length }, "walked files");
+  const files = [];
+  const languages = /* @__PURE__ */ new Set();
+  for (const w of walked) {
+    if (w.repoPath.startsWith(".codewiki/") || w.repoPath.startsWith(".git/")) continue;
+    if (!w.language) continue;
+    languages.add(w.language);
+    let content = "";
+    try {
+      content = await promises.readFile(w.absPath, "utf8");
+    } catch (err) {
+      log_.debug({ path: w.repoPath, err: String(err) }, "failed to read");
+      continue;
+    }
+    const hash = sha256Hex(content);
+    let symbols = [];
+    if (isExtractable(w.language)) {
+      try {
+        symbols = await extractSymbols({
+          source: content,
+          repoPath: w.repoPath,
+          language: w.language
+        });
+      } catch (err) {
+        log_.debug({ path: w.repoPath, err: String(err) }, "extractor failed");
+        symbols = [];
+      }
+    }
+    const publicSymbols = symbols.filter((s) => s.visibility === "public");
+    const summary = makeStaticFileSummary(content, w.repoPath, symbols, publicSymbols);
+    files.push({
+      repoPath: w.repoPath,
+      absPath: w.absPath,
+      language: w.language,
+      size: w.size,
+      mtimeMs: w.mtimeMs,
+      contentHash: hash,
+      symbols,
+      publicSymbols,
+      oneLineSummary: summary
+    });
+  }
+  const modules = groupModules(files, cfg);
+  const visibleModuleCount = [...modules.keys()].filter(
+    (id) => !cfg.modules.ignore.includes(id)
+  ).length;
+  const filePagePaths = /* @__PURE__ */ new Map();
+  const moduleTokens = /* @__PURE__ */ new Map();
+  const symbolCount = files.reduce((a, f) => a + f.symbols.length, 0);
+  const meta = {
+    schemaVersion: SCHEMA_VERSION,
+    generator: "code-wiki",
+    generatorVersion: "0.1.0",
+    git: { head: "uncommitted", branch: null, dirty: true, remote: null },
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    durationMs: 0,
+    languages: [...languages],
+    fileCount: files.length,
+    moduleCount: visibleModuleCount,
+    symbolCount,
+    models: {
+      staticSummaryVersion: "static-v1",
+      llmSummaryModel: null,
+      llmSummaryModelModule: null
+    },
+    options: {
+      enrichment: cfg.enrichment.enabled,
+      concurrency: cfg.enrichment.concurrency
+    }
+  };
+  const importEdges = [];
+  for (const f of files) {
+    if (!f.language) continue;
+    let content = "";
+    try {
+      content = await promises.readFile(f.absPath, "utf8");
+    } catch {
+      continue;
+    }
+    const edges = await extractImports(content, f.repoPath, f.language);
+    importEdges.push(...edges);
+  }
+  const dependents = computeDependents(importEdges);
+  const arch = buildArchitecturePage(meta, files, cfg, importEdges, dependents);
+  await writeText(outNew, "architecture.md", renderArchitecture(arch.page, arch.body));
+  for (const f of files) {
+    const fp = buildFilePage(f);
+    filePagePaths.set(f.repoPath, fp.page.path);
+    const safePath = path__default.join(outNew, fp.page.path);
+    await promises.mkdir(path__default.dirname(safePath), { recursive: true });
+    await promises.writeFile(safePath, renderFile(fp.page, fp.body), "utf8");
+    for (const s of f.symbols) {
+      const sp = buildSymbolPage(s, f.repoPath);
+      const symPath = path__default.join(outNew, sp.page.path);
+      await promises.mkdir(path__default.dirname(symPath), { recursive: true });
+      await promises.writeFile(symPath, renderSymbol(sp.page, sp.body), "utf8");
+    }
+  }
+  for (const [id, m] of modules) {
+    const mp = buildModulePage(m, files, filePagePaths, cfg, importEdges, dependents);
+    moduleTokens.set(id, mp.tokens);
+    const safePath = path__default.join(outNew, "modules", `${id}.md`);
+    await promises.mkdir(path__default.dirname(safePath), { recursive: true });
+    await promises.writeFile(safePath, renderModule(mp.page, mp.body), "utf8");
+  }
+  const index = buildIndexPage(meta, modules, pagePathMap(modules, files, filePagePaths), moduleTokens, [], cfg);
+  await writeText(outNew, "INDEX.md", renderIndex(index.page, index.body));
+  meta.durationMs = Date.now() - t0;
+  meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeJson(path__default.join(outNew, ".meta.json"), meta);
+  const tree = buildIndexTree(files, modules, filePagePaths, moduleTokens);
+  await writeJson(path__default.join(outNew, ".index.json"), tree);
+  await writeJson(path__default.join(outNew, ".graph.json"), {
+    schemaVersion: SCHEMA_VERSION,
+    imports: importEdges,
+    calls: [],
+    dependents
+  });
+  await replaceDir(outAbs, outNew);
+  log_.info(
+    { files: files.length, modules: visibleModuleCount, durationMs: meta.durationMs },
+    "build complete"
+  );
+  return {
+    meta,
+    root,
+    outDir: outRel,
+    durationMs: meta.durationMs,
+    fileCount: files.length,
+    moduleCount: visibleModuleCount,
+    symbolCount
+  };
+}
+function pagePathMap(modules, files, filePagePaths) {
+  return filePagePaths;
+}
+function buildIndexTree(files, modules, filePagePaths, moduleTokens) {
+  const tree = {
+    schemaVersion: SCHEMA_VERSION,
+    modules: [...modules.entries()].filter(([id]) => id !== "_tests").map(([id, m]) => ({
+      id,
+      title: m.title,
+      path: `modules/${id}.md`,
+      files: m.files,
+      tokens: moduleTokens.get(id) ?? 0
+    })),
+    files: files.map((f) => ({
+      path: f.repoPath,
+      module: idForRepoPath(f.repoPath, modules),
+      kind: "source",
+      language: f.language,
+      tokens: estimateFileTokens(f),
+      symbols: f.symbols.length,
+      stale: false,
+      pagePath: filePagePaths.get(f.repoPath) ?? `files/${f.repoPath}.md`
+    })),
+    symbols: files.flatMap(
+      (f) => f.symbols.map((s) => ({
+        id: s.id,
+        name: s.name,
+        kind: s.kind,
+        file: f.repoPath,
+        lineRange: s.lineRange,
+        pagePath: `symbols/${f.repoPath}/${s.kind}.${s.name}.md`,
+        tokens: 150
+      }))
+    )
+  };
+  return tree;
+}
+function idForRepoPath(repoPath, modules) {
+  for (const [id, m] of modules) {
+    if (m.files.includes(repoPath)) return id;
+  }
+  return "_root";
+}
+function estimateFileTokens(f) {
+  return Math.max(50, Math.round(f.size / 4));
+}
+function makeStaticFileSummary(content, repoPath, symbols = [], publicSymbols = []) {
+  const fname = repoPath.split("/").pop() ?? repoPath;
+  const lines = content.split(/\r?\n/);
+  let firstNonBlank = "";
+  for (const ln of lines) {
+    const t = ln.trim();
+    if (t && !t.startsWith("//") && !t.startsWith("#") && !t.startsWith("/*") && !t.startsWith("*")) {
+      firstNonBlank = t;
+      break;
+    }
+  }
+  const lc = lines.length;
+  const parts = [`${lc} lines`];
+  if (symbols.length > 0) {
+    parts.push(`${symbols.length} symbols (${publicSymbols.length} public)`);
+  }
+  if (firstNonBlank) parts.push(`starts: \`${firstNonBlank.slice(0, 80)}\``);
+  return `${fname}: ${parts.join(", ")}.`;
+}
+async function writeText(outDir, relPath, content) {
+  await atomicWriteText(path__default.join(outDir, relPath), content);
+}
+async function replaceDir(target, replacement) {
+  if (await exists(target)) {
+    await promises.rm(target, { recursive: true, force: true });
+  }
+  await promises.rename(replacement, target);
+}
+
+export { walker as a, buildWiki as b, countTokens as c, detectLanguage as d, groupModules as g, moduleForFile as m, truncateToTokens as t, walkFiles as w };