@dreamtree-org/graphify 1.0.0

package/dist/cli/index.cjs

@@ -0,0 +1,3250 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl, importMetaUrl;
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+    importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+  }
+});
+
+// src/security.ts
+function ipv4ToInt(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) return null;
+  let result = 0;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part)) return null;
+    const n = Number(part);
+    if (n > 255) return null;
+    result = result << 8 | n;
+  }
+  return result >>> 0;
+}
+function ipv4InCidr(ipInt, cidr) {
+  const [base, prefixStr] = cidr.split("/");
+  const prefix = Number(prefixStr);
+  const baseInt = ipv4ToInt(base ?? "");
+  if (baseInt === null) return false;
+  const mask = prefix === 0 ? 0 : ~0 << 32 - prefix >>> 0;
+  return (ipInt & mask) >>> 0 === (baseInt & mask) >>> 0;
+}
+function isForbiddenIpv4(ip) {
+  const ipInt = ipv4ToInt(ip);
+  if (ipInt === null) return true;
+  return BLOCKED_IPV4_CIDRS.some((cidr) => ipv4InCidr(ipInt, cidr));
+}
+function expandIpv6(ip) {
+  const withoutZone = ip.split("%")[0] ?? "";
+  const parts = withoutZone.split("::");
+  if (parts.length > 2) return null;
+  const head = parts[0] ? parts[0].split(":").filter((s) => s.length > 0) : [];
+  const tail = parts.length === 2 && parts[1] ? parts[1].split(":").filter((s) => s.length > 0) : [];
+  let missing = 0;
+  if (parts.length === 2) {
+    missing = 8 - head.length - tail.length;
+    if (missing < 0) return null;
+  } else if (head.length + tail.length !== 8) {
+    return null;
+  }
+  const groupsHex = [...head, ...Array(missing).fill("0"), ...tail];
+  if (groupsHex.length !== 8) return null;
+  const groups = [];
+  for (const g of groupsHex) {
+    if (!/^[0-9a-fA-F]{1,4}$/.test(g)) return null;
+    groups.push(parseInt(g, 16));
+  }
+  return groups;
+}
+function isForbiddenIpv6(ip) {
+  const lower = ip.toLowerCase();
+  if (lower === "::1" || lower === "::") return true;
+  const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
+  if (mapped) return isForbiddenIpv4(mapped[1]);
+  const groups = expandIpv6(lower);
+  if (groups === null) return true;
+  const first = groups[0];
+  if ((first & 65472) === 65152) return true;
+  if ((first & 65024) === 64512) return true;
+  if ((first & 65280) === 65280) return true;
+  if (groups.every((g) => g === 0)) return true;
+  return false;
+}
+function isForbiddenIp(ip) {
+  return net.isIPv6(ip) ? isForbiddenIpv6(ip) : isForbiddenIpv4(ip);
+}
+function validateUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
+    throw new Error(
+      `URL scheme not allowed: "${parsed.protocol}" (allowed: ${[...ALLOWED_SCHEMES].join(", ")})`
+    );
+  }
+  const hostname = parsed.hostname.toLowerCase();
+  if (BLOCKED_HOSTNAMES.has(hostname)) {
+    throw new Error(`URL targets a blocked host: ${hostname}`);
+  }
+  const bareHost = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  if (net.isIP(bareHost) && isForbiddenIp(bareHost)) {
+    throw new Error(`URL targets a forbidden IP address: ${bareHost}`);
+  }
+  return parsed.toString();
+}
+function validateGraphPath(path11, base) {
+  const baseDir = base ?? nodePath.join(process.cwd(), "graphify-out");
+  let resolvedBase;
+  try {
+    resolvedBase = fs.realpathSync(baseDir);
+  } catch {
+    throw new Error(`Base directory does not exist: ${baseDir}`);
+  }
+  const candidate = nodePath.isAbsolute(path11) ? path11 : nodePath.join(resolvedBase, path11);
+  const resolvedCandidate = nodePath.resolve(candidate);
+  let realCandidate = resolvedCandidate;
+  try {
+    realCandidate = fs.realpathSync(resolvedCandidate);
+  } catch {
+  }
+  const relative4 = nodePath.relative(resolvedBase, realCandidate);
+  const escapes = relative4 === ".." || relative4.startsWith(`..${nodePath.sep}`) || nodePath.isAbsolute(relative4);
+  if (escapes) {
+    throw new Error(`Path escapes graphify-out/: ${path11}`);
+  }
+  return realCandidate;
+}
+function sanitizeLabel(text) {
+  if (text == null) return "";
+  const stripped = String(text).replace(/[\x00-\x1f\x7f]/g, "");
+  return stripped.slice(0, MAX_LABEL_LEN);
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var import_node_crypto2, dns, http, https, fs, net, nodePath, ALLOWED_SCHEMES, MAX_FETCH_BYTES, MAX_TEXT_BYTES, MAX_LABEL_LEN, BLOCKED_HOSTNAMES, BLOCKED_IPV4_CIDRS;
+var init_security = __esm({
+  "src/security.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_crypto2 = require("crypto");
+    dns = __toESM(require("dns"), 1);
+    http = __toESM(require("http"), 1);
+    https = __toESM(require("https"), 1);
+    fs = __toESM(require("fs"), 1);
+    net = __toESM(require("net"), 1);
+    nodePath = __toESM(require("path"), 1);
+    ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
+    MAX_FETCH_BYTES = 50 * 1024 * 1024;
+    MAX_TEXT_BYTES = 10 * 1024 * 1024;
+    MAX_LABEL_LEN = 256;
+    BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+      "metadata.google.internal",
+      "metadata.internal",
+      "metadata",
+      "metadata.azure.com",
+      "instance-data",
+      "instance-data.ec2.internal"
+    ]);
+    BLOCKED_IPV4_CIDRS = [
+      "0.0.0.0/8",
+      // "this" network
+      "10.0.0.0/8",
+      // private
+      "100.64.0.0/10",
+      // carrier-grade NAT (CGN)
+      "127.0.0.0/8",
+      // loopback
+      "169.254.0.0/16",
+      // link-local (covers 169.254.169.254 cloud metadata)
+      "172.16.0.0/12",
+      // private
+      "192.0.0.0/24",
+      // IETF protocol assignments
+      "192.0.2.0/24",
+      // TEST-NET-1
+      "192.168.0.0/16",
+      // private
+      "198.18.0.0/15",
+      // benchmarking
+      "198.51.100.0/24",
+      // TEST-NET-2
+      "203.0.113.0/24",
+      // TEST-NET-3
+      "224.0.0.0/4",
+      // multicast
+      "240.0.0.0/4",
+      // reserved
+      "255.255.255.255/32"
+      // broadcast
+    ];
+  }
+});
+
+// src/graphStore.ts
+async function loadGraph(outDir = path2.join(process.cwd(), "graphify-out")) {
+  const jsonPath = validateGraphPath("graph.json", outDir);
+  const raw = await fs3.readFile(jsonPath, "utf-8");
+  const data = JSON.parse(raw);
+  return import_graphology2.default.from(data);
+}
+var fs3, path2, import_graphology2;
+var init_graphStore = __esm({
+  "src/graphStore.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs3 = __toESM(require("fs/promises"), 1);
+    path2 = __toESM(require("path"), 1);
+    import_graphology2 = __toESM(require("graphology"), 1);
+    init_security();
+  }
+});
+
+// src/query.ts
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9_.]+/).filter((token) => token.length > 1 && !STOPWORDS.has(token));
+}
+function scoreNodes(graph, query) {
+  const tokens = tokenize(query);
+  const matches = [];
+  graph.forEachNode((id, attributes) => {
+    const label = attributes.label ?? id;
+    const haystack = `${label} ${id}`.toLowerCase();
+    let score = 0;
+    for (const token of tokens) {
+      if (haystack.includes(token)) score += 1;
+    }
+    if (score > 0) matches.push({ id, label, score });
+  });
+  matches.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+  return matches;
+}
+function resolveNode(graph, query) {
+  const matches = scoreNodes(graph, query);
+  return matches[0] ?? null;
+}
+function queryGraph(graph, question, options = {}) {
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const maxSeeds = options.maxSeeds ?? DEFAULT_MAX_SEEDS;
+  const budget = options.budget ?? DEFAULT_BUDGET;
+  const allMatches = scoreNodes(graph, question);
+  const seeds = allMatches.length > 0 ? allMatches.slice(0, maxSeeds) : [];
+  const visited = /* @__PURE__ */ new Map();
+  const frontier = seeds.map((s) => ({ id: s.id, depth: 0 }));
+  for (const seed of seeds) visited.set(seed.id, 0);
+  while (frontier.length > 0 && visited.size < budget) {
+    const current = options.dfs ? frontier.pop() : frontier.shift();
+    if (current.depth >= maxDepth) continue;
+    const neighbors = [...graph.neighbors(current.id)].sort((a, b) => a.localeCompare(b));
+    for (const neighbor of neighbors) {
+      if (visited.has(neighbor) || visited.size >= budget) continue;
+      visited.set(neighbor, current.depth + 1);
+      frontier.push({ id: neighbor, depth: current.depth + 1 });
+    }
+  }
+  const visitedNodes = [...visited.entries()].map(([id, depth]) => {
+    const attrs = graph.getNodeAttributes(id);
+    return {
+      id,
+      label: attrs.label ?? id,
+      sourceFile: attrs.sourceFile ?? "",
+      sourceLocation: attrs.sourceLocation ?? "",
+      depth
+    };
+  }).sort((a, b) => a.depth - b.depth || a.id.localeCompare(b.id));
+  const edges = [];
+  graph.forEachEdge((_edge, attrs, source, target) => {
+    if (visited.has(source) && visited.has(target)) {
+      edges.push({
+        source,
+        target,
+        relation: String(attrs.relation),
+        confidence: String(attrs.confidence)
+      });
+    }
+  });
+  edges.sort(
+    (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target) || a.relation.localeCompare(b.relation)
+  );
+  return { seeds, visited: visitedNodes, edges };
+}
+function shortestPath(graph, fromQuery, toQuery) {
+  const from = resolveNode(graph, fromQuery);
+  const to = resolveNode(graph, toQuery);
+  if (!from || !to) return null;
+  if (from.id === to.id) {
+    return { from, to, found: true, path: [from.id], edges: [] };
+  }
+  const predecessor = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set([from.id]);
+  const queue = [from.id];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === to.id) break;
+    const neighbors = [...graph.neighbors(current)].sort((a, b) => a.localeCompare(b));
+    for (const neighbor of neighbors) {
+      if (visited.has(neighbor)) continue;
+      visited.add(neighbor);
+      predecessor.set(neighbor, current);
+      queue.push(neighbor);
+    }
+  }
+  if (!visited.has(to.id)) {
+    return { from, to, found: false, path: [], edges: [] };
+  }
+  const path11 = [to.id];
+  let cursor = to.id;
+  while (cursor !== from.id) {
+    const prev = predecessor.get(cursor);
+    if (!prev) break;
+    path11.unshift(prev);
+    cursor = prev;
+  }
+  const edges = [];
+  for (let i = 0; i < path11.length - 1; i++) {
+    const a = path11[i];
+    const b = path11[i + 1];
+    const key = graph.edges(a, b)[0] ?? graph.edges(b, a)[0];
+    if (key) {
+      const attrs = graph.getEdgeAttributes(key);
+      edges.push({ source: a, target: b, relation: String(attrs.relation), confidence: String(attrs.confidence) });
+    }
+  }
+  return { from, to, found: true, path: path11, edges };
+}
+function explainNode(graph, query) {
+  const match = resolveNode(graph, query);
+  if (!match) return null;
+  const attrs = graph.getNodeAttributes(match.id);
+  const outgoing = [];
+  const incoming = [];
+  graph.forEachOutEdge(match.id, (_edge, edgeAttrs, source, target) => {
+    outgoing.push({ source, target, relation: String(edgeAttrs.relation), confidence: String(edgeAttrs.confidence) });
+  });
+  graph.forEachInEdge(match.id, (_edge, edgeAttrs, source, target) => {
+    incoming.push({ source, target, relation: String(edgeAttrs.relation), confidence: String(edgeAttrs.confidence) });
+  });
+  outgoing.sort((a, b) => a.target.localeCompare(b.target) || a.relation.localeCompare(b.relation));
+  incoming.sort((a, b) => a.source.localeCompare(b.source) || a.relation.localeCompare(b.relation));
+  return {
+    id: match.id,
+    label: match.label,
+    sourceFile: attrs.sourceFile ?? "",
+    sourceLocation: attrs.sourceLocation ?? "",
+    communityLabel: attrs.communityLabel,
+    outgoing,
+    incoming
+  };
+}
+var STOPWORDS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_SEEDS, DEFAULT_BUDGET;
+var init_query = __esm({
+  "src/query.ts"() {
+    "use strict";
+    init_cjs_shims();
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "a",
+      "an",
+      "the",
+      "is",
+      "are",
+      "was",
+      "were",
+      "do",
+      "does",
+      "did",
+      "how",
+      "what",
+      "where",
+      "when",
+      "why",
+      "who",
+      "which",
+      "to",
+      "of",
+      "in",
+      "on",
+      "for",
+      "and",
+      "or",
+      "this",
+      "that",
+      "it",
+      "does",
+      "that's"
+    ]);
+    DEFAULT_MAX_DEPTH = 2;
+    DEFAULT_MAX_SEEDS = 5;
+    DEFAULT_BUDGET = 40;
+  }
+});
+
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createGraphifyMcpServer: () => createGraphifyMcpServer,
+  main: () => main,
+  startServer: () => startServer
+});
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function createGraphifyMcpServer(outDir) {
+  const server = new import_mcp.McpServer({ name: "graphify", version: "0.1.0" });
+  server.registerTool(
+    "query",
+    {
+      description: "BFS (default) or DFS traversal of the graphify knowledge graph, seeded from nodes whose label matches the question. Returns the matched seeds, the visited node context, and the edges among them \u2014 broad context for answering a structural question.",
+      inputSchema: {
+        question: import_zod2.z.string().describe("Natural-language question or keywords to search the graph for."),
+        dfs: import_zod2.z.boolean().optional().describe("Use depth-first traversal instead of the default breadth-first."),
+        budget: import_zod2.z.number().int().positive().optional().describe("Approximate cap on how many nodes to include.")
+      }
+    },
+    async ({ question, dfs, budget }) => {
+      const graph = await loadGraph(outDir);
+      const result = queryGraph(graph, question, { dfs, budget });
+      return textResult(JSON.stringify(result, null, 2));
+    }
+  );
+  server.registerTool(
+    "path",
+    {
+      description: "Shortest path between two named nodes in the graphify knowledge graph.",
+      inputSchema: {
+        from: import_zod2.z.string().describe("Name/label of the starting node."),
+        to: import_zod2.z.string().describe("Name/label of the destination node.")
+      }
+    },
+    async ({ from, to }) => {
+      const graph = await loadGraph(outDir);
+      const result = shortestPath(graph, from, to);
+      if (!result) {
+        return textResult(`Could not resolve "${from}" and/or "${to}" to a node in the graph.`);
+      }
+      return textResult(JSON.stringify(result, null, 2));
+    }
+  );
+  server.registerTool(
+    "explain",
+    {
+      description: "Plain-language-ready explanation of a single node: its source location, community, and incoming/outgoing edges.",
+      inputSchema: {
+        node: import_zod2.z.string().describe("Name/label (or id) of the node to explain.")
+      }
+    },
+    async ({ node }) => {
+      const graph = await loadGraph(outDir);
+      const result = explainNode(graph, node);
+      if (!result) {
+        return textResult(`No node matched "${node}".`);
+      }
+      return textResult(JSON.stringify(result, null, 2));
+    }
+  );
+  return server;
+}
+async function startServer(graphPath, transport = new import_stdio.StdioServerTransport()) {
+  const outDir = path9.dirname(path9.resolve(graphPath));
+  const fileName = path9.basename(graphPath);
+  validateGraphPath(fileName, outDir);
+  const server = createGraphifyMcpServer(outDir);
+  await server.connect(transport);
+}
+async function main(argv = process.argv) {
+  const graphPath = argv[2] ?? path9.join(process.cwd(), "graphify-out", "graph.json");
+  await startServer(graphPath);
+}
+var path9, import_mcp, import_stdio, import_zod2;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_cjs_shims();
+    path9 = __toESM(require("path"), 1);
+    import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+    import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+    import_zod2 = require("zod");
+    init_graphStore();
+    init_query();
+    init_security();
+  }
+});
+
+// src/cli/index.ts
+init_cjs_shims();
+var import_node_child_process = require("child_process");
+var fs13 = __toESM(require("fs/promises"), 1);
+var os = __toESM(require("os"), 1);
+var path10 = __toESM(require("path"), 1);
+var import_node_util = require("util");
+var import_chokidar = require("chokidar");
+var import_commander = require("commander");
+
+// src/analyze.ts
+init_cjs_shims();
+var ABSOLUTE_DEGREE_FLOOR = 10;
+var MEAN_DEGREE_MULTIPLIER = 3;
+var MAX_LISTED = 10;
+function truncatedList(items) {
+  const shown = items.slice(0, MAX_LISTED).join(", ");
+  return items.length > MAX_LISTED ? `${shown}, ...` : shown;
+}
+function connectedComponents(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  const sortedNodes = [...graph.nodes()].sort((a, b) => a.localeCompare(b));
+  for (const start of sortedNodes) {
+    if (visited.has(start)) continue;
+    const component = [];
+    const queue = [start];
+    visited.add(start);
+    while (queue.length > 0) {
+      const current = queue.shift();
+      component.push(current);
+      const neighbors = [...graph.neighbors(current)].sort((a, b) => a.localeCompare(b));
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          queue.push(neighbor);
+        }
+      }
+    }
+    component.sort((a, b) => a.localeCompare(b));
+    components.push(component);
+  }
+  components.sort((a, b) => b.length - a.length || (a[0] ?? "").localeCompare(b[0] ?? ""));
+  return components;
+}
+function labelOf(graph, id) {
+  return graph.getNodeAttribute(id, "label") ?? id;
+}
+function analyze(graph) {
+  const godNodes = [];
+  const surprises = [];
+  const openQuestions = [];
+  if (graph.order === 0) {
+    openQuestions.push(
+      "The graph is empty \u2014 no nodes were extracted. Check detect()/extract() coverage for this codebase."
+    );
+    return { godNodes, surprises, openQuestions };
+  }
+  const degreeEntries = [...graph.nodes()].map((id) => ({ id, degree: graph.degree(id) })).sort((a, b) => a.id.localeCompare(b.id));
+  const meanDegree = degreeEntries.reduce((sum, e) => sum + e.degree, 0) / degreeEntries.length;
+  const threshold = Math.max(ABSOLUTE_DEGREE_FLOOR, meanDegree * MEAN_DEGREE_MULTIPLIER);
+  for (const { id, degree } of degreeEntries) {
+    if (degree > 0 && degree >= threshold) {
+      godNodes.push(id);
+      surprises.push(
+        `${labelOf(graph, id)} has ${degree} connections (fan-in + fan-out) \u2014 well above the graph average of ${meanDegree.toFixed(1)}. Likely a god node / hotspot worth reviewing for excessive coupling.`
+      );
+    }
+  }
+  graph.forEachEdge((_edge, attributes, source, target) => {
+    if (source === target) {
+      surprises.push(`${labelOf(graph, source)} has a self-referential "${String(attributes.relation)}" edge.`);
+    }
+  });
+  const ambiguousEdges = [];
+  graph.forEachEdge((_edge, attributes, source, target) => {
+    if (attributes.confidence === "AMBIGUOUS") {
+      ambiguousEdges.push(
+        `${labelOf(graph, source)} --${String(attributes.relation)}--> ${labelOf(graph, target)}`
+      );
+    }
+  });
+  if (ambiguousEdges.length > 0) {
+    ambiguousEdges.sort((a, b) => a.localeCompare(b));
+    openQuestions.push(
+      `${ambiguousEdges.length} edge(s) are marked AMBIGUOUS and need human review: ` + truncatedList(ambiguousEdges)
+    );
+  }
+  const isolated = degreeEntries.filter((e) => e.degree === 0).map((e) => e.id);
+  if (isolated.length > 0) {
+    openQuestions.push(
+      `${isolated.length} node(s) have no incoming or outgoing edges (${truncatedList(isolated)}) \u2014 dead code, an entry point, or a gap in extraction?`
+    );
+  }
+  const components = connectedComponents(graph);
+  if (components.length > 1) {
+    const largest = components[0];
+    openQuestions.push(
+      `The graph has ${components.length} disconnected components \u2014 the largest has ${largest.length} node(s). Confirm this reflects real module boundaries rather than missed cross-file edges.`
+    );
+  }
+  return { godNodes, surprises, openQuestions };
+}
+
+// src/cluster.ts
+init_cjs_shims();
+var import_node_crypto = require("crypto");
+var import_graphology = __toESM(require("graphology"), 1);
+var import_graphology_communities_leiden = __toESM(require("@aflsolutions/graphology-communities-leiden"), 1);
+var import_graphology_communities_louvain = __toESM(require("graphology-communities-louvain"), 1);
+var FIXED_SEED = 1592594996;
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function next() {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function sortedWorkingCopy(graph) {
+  const copy = new import_graphology.default({ type: graph.type, multi: graph.multi, allowSelfLoops: graph.allowSelfLoops });
+  const nodeIds = graph.nodes().sort((a, b) => a.localeCompare(b));
+  for (const id of nodeIds) {
+    copy.addNode(id, { ...graph.getNodeAttributes(id) });
+  }
+  const edgeEntries = [];
+  graph.forEachEdge((edge, attributes, source, target) => {
+    edgeEntries.push({ key: edge, source, target, attributes });
+  });
+  edgeEntries.sort(
+    (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target) || String(a.attributes.relation).localeCompare(String(b.attributes.relation))
+  );
+  for (const entry of edgeEntries) {
+    copy.addEdgeWithKey(entry.key, entry.source, entry.target, { ...entry.attributes });
+  }
+  return copy;
+}
+function toUndirectedCopy(graph) {
+  const copy = new import_graphology.default({ type: "undirected", multi: true, allowSelfLoops: graph.allowSelfLoops });
+  graph.forEachNode((nodeId, attributes) => copy.addNode(nodeId, { ...attributes }));
+  graph.forEachEdge((edgeKey, attributes, source, target) => {
+    copy.addEdgeWithKey(edgeKey, source, target, { ...attributes });
+  });
+  return copy;
+}
+function runAlgorithm(working, options) {
+  const rng = mulberry32(FIXED_SEED);
+  if (options.algorithm === "leiden") {
+    const undirected = toUndirectedCopy(working);
+    import_graphology_communities_leiden.default.assign(undirected, { rng, maxIterations: options.maxIterations ?? 0 });
+    undirected.forEachNode((nodeId, attributes) => {
+      working.setNodeAttribute(nodeId, "community", attributes.community);
+    });
+    return;
+  }
+  import_graphology_communities_louvain.default.assign(working, { rng });
+}
+function cluster(graph, options = {}) {
+  if (graph.order === 0) return graph;
+  const working = sortedWorkingCopy(graph);
+  runAlgorithm(working, options);
+  const hubs = /* @__PURE__ */ new Map();
+  working.forEachNode((nodeId) => {
+    const community = working.getNodeAttribute(nodeId, "community");
+    const degree = working.degree(nodeId);
+    const current = hubs.get(community);
+    if (!current || degree > current.degree) {
+      hubs.set(community, { id: nodeId, degree });
+    }
+  });
+  const membersByCommunity = /* @__PURE__ */ new Map();
+  working.forEachNode((nodeId) => {
+    const community = working.getNodeAttribute(nodeId, "community");
+    const list = membersByCommunity.get(community);
+    if (list) list.push(nodeId);
+    else membersByCommunity.set(community, [nodeId]);
+  });
+  const labelByCommunity = /* @__PURE__ */ new Map();
+  const hashByCommunity = /* @__PURE__ */ new Map();
+  for (const [community, members] of membersByCommunity) {
+    members.sort((a, b) => a.localeCompare(b));
+    hashByCommunity.set(community, (0, import_node_crypto.createHash)("sha256").update(members.join("\n")).digest("hex"));
+    const hub = hubs.get(community);
+    const hubLabel = hub ? working.getNodeAttribute(hub.id, "label") : void 0;
+    labelByCommunity.set(community, hubLabel && hubLabel.length > 0 ? hubLabel : `community-${community}`);
+  }
+  working.forEachNode((nodeId) => {
+    const community = working.getNodeAttribute(nodeId, "community");
+    graph.mergeNodeAttributes(nodeId, {
+      community,
+      communityLabel: labelByCommunity.get(community),
+      communityHash: hashByCommunity.get(community)
+    });
+  });
+  return graph;
+}
+
+// src/export.ts
+init_cjs_shims();
+var import_node_module = require("module");
+var fs2 = __toESM(require("fs/promises"), 1);
+var path = __toESM(require("path"), 1);
+init_security();
+var require2 = (0, import_node_module.createRequire)(importMetaUrl);
+function resolveVisNetworkAssets() {
+  const packageJsonPath = require2.resolve("vis-network/package.json");
+  const root = path.dirname(packageJsonPath);
+  return {
+    jsPath: path.join(root, "standalone", "umd", "vis-network.min.js"),
+    cssPath: path.join(root, "styles", "vis-network.min.css")
+  };
+}
+var COMMUNITY_PALETTE = [
+  "#4e79a7",
+  "#f28e2b",
+  "#e15759",
+  "#76b7b2",
+  "#59a14f",
+  "#edc948",
+  "#b07aa1",
+  "#ff9da7",
+  "#9c755f",
+  "#bab0ac"
+];
+function colorForCommunity(community) {
+  if (community === void 0) return "#8ab4f8";
+  const index = (community % COMMUNITY_PALETTE.length + COMMUNITY_PALETTE.length) % COMMUNITY_PALETTE.length;
+  return COMMUNITY_PALETTE[index];
+}
+function safeInlineJson(value) {
+  return JSON.stringify(value, null, 2).replace(/<\/(script)/gi, "<\\/$1");
+}
+function buildVisNodesAndEdges(graph) {
+  const nodes = graph.nodes().map((id) => {
+    const attributes = graph.getNodeAttributes(id);
+    const rawLabel = attributes.label ?? id;
+    const label = escapeHtml(sanitizeLabel(rawLabel));
+    const sourceFile = escapeHtml(sanitizeLabel(attributes.sourceFile ?? ""));
+    const sourceLocation = escapeHtml(sanitizeLabel(attributes.sourceLocation ?? ""));
+    const communityLabel = escapeHtml(sanitizeLabel(attributes.communityLabel ?? ""));
+    return {
+      id,
+      label,
+      title: `${label}
+${sourceFile}${sourceLocation ? `:${sourceLocation}` : ""}${communityLabel ? `
+community: ${communityLabel}` : ""}`,
+      color: colorForCommunity(attributes.community)
+    };
+  });
+  const edges = [];
+  graph.forEachEdge((edgeKey, attributes, source, target) => {
+    const relation = escapeHtml(sanitizeLabel(String(attributes.relation ?? "")));
+    const confidence = escapeHtml(sanitizeLabel(String(attributes.confidence ?? "")));
+    edges.push({
+      id: edgeKey,
+      from: source,
+      to: target,
+      label: relation,
+      title: `${relation} (${confidence})`,
+      dashes: confidence === "INFERRED" || confidence === "AMBIGUOUS",
+      arrows: "to"
+    });
+  });
+  return { nodes, edges };
+}
+async function renderHtml(graph) {
+  const { jsPath, cssPath } = resolveVisNetworkAssets();
+  const [visJs, visCss] = await Promise.all([
+    fs2.readFile(jsPath, "utf-8"),
+    fs2.readFile(cssPath, "utf-8")
+  ]);
+  const { nodes, edges } = buildVisNodesAndEdges(graph);
+  const dataJson = safeInlineJson({ nodes, edges });
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>graphify \u2014 graph.html</title>
+<style>
+  html, body { margin: 0; padding: 0; height: 100%; font-family: system-ui, sans-serif; }
+  #graph { width: 100%; height: 100vh; }
+  ${visCss}
+</style>
+</head>
+<body>
+<div id="graph"></div>
+<script>
+${visJs}
+</script>
+<script>
+(function () {
+  var data = ${dataJson};
+  var nodes = new vis.DataSet(data.nodes);
+  var edges = new vis.DataSet(data.edges);
+  var container = document.getElementById('graph');
+  var network = new vis.Network(container, { nodes: nodes, edges: edges }, {
+    nodes: { shape: 'dot', size: 12, font: { size: 14 } },
+    edges: { smooth: { type: 'continuous' }, font: { size: 10, align: 'middle' } },
+    physics: { stabilization: true },
+    interaction: { hover: true, tooltipDelay: 150 },
+  });
+  window.__graphifyNetwork = network;
+})();
+</script>
+</body>
+</html>
+`;
+}
+async function exportGraph(graph, options, report) {
+  const outDir = path.resolve(options.outDir);
+  await fs2.mkdir(outDir, { recursive: true });
+  const jsonPath = validateGraphPath("graph.json", outDir);
+  await fs2.writeFile(jsonPath, JSON.stringify(graph.toJSON(), null, 2), "utf-8");
+  if (options.html !== false) {
+    const htmlPath = validateGraphPath("graph.html", outDir);
+    await fs2.writeFile(htmlPath, await renderHtml(graph), "utf-8");
+  }
+  if (report !== void 0) {
+    const reportPath = validateGraphPath("GRAPH_REPORT.md", outDir);
+    await fs2.writeFile(reportPath, report, "utf-8");
+  }
+  const notImplemented = [];
+  if (options.svg) notImplemented.push("--svg");
+  if (options.graphml) notImplemented.push("--graphml");
+  if (options.neo4j) notImplemented.push("--neo4j");
+  if (options.obsidian) notImplemented.push("--obsidian");
+  for (const flag of notImplemented) {
+    console.warn(`graphify: ${flag} export is not implemented yet in v1 \u2014 skipping.`);
+  }
+}
+
+// src/cli/index.ts
+init_graphStore();
+
+// src/pipeline.ts
+init_cjs_shims();
+var path7 = __toESM(require("path"), 1);
+
+// src/build.ts
+init_cjs_shims();
+var import_graphology3 = __toESM(require("graphology"), 1);
+
+// src/schema.ts
+init_cjs_shims();
+var import_zod = require("zod");
+var ConfidenceSchema = import_zod.z.enum(["EXTRACTED", "INFERRED", "AMBIGUOUS"]);
+var RelationSchema = import_zod.z.enum([
+  "calls",
+  "imports",
+  "imports_from",
+  "inherits",
+  "implements",
+  "mixes_in",
+  "embeds",
+  "references",
+  "contains",
+  "method",
+  "re_exports"
+]);
+var GraphNodeSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1, "node id must be non-empty"),
+  label: import_zod.z.string(),
+  sourceFile: import_zod.z.string(),
+  sourceLocation: import_zod.z.string()
+});
+var GraphEdgeSchema = import_zod.z.object({
+  source: import_zod.z.string().min(1, "edge source must be non-empty"),
+  target: import_zod.z.string().min(1, "edge target must be non-empty"),
+  relation: RelationSchema,
+  confidence: ConfidenceSchema
+});
+var ExtractionResultSchema = import_zod.z.object({
+  nodes: import_zod.z.array(GraphNodeSchema),
+  edges: import_zod.z.array(GraphEdgeSchema)
+});
+var ExtractionValidationError = class extends Error {
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.name = "ExtractionValidationError";
+    this.issues = issues;
+  }
+};
+function validateExtraction(value, context) {
+  const result = ExtractionResultSchema.safeParse(value);
+  if (!result.success) {
+    const label = context ? ` (${context})` : "";
+    const issues = result.error.issues.map((issue) => ({
+      path: issue.path,
+      message: issue.message
+    }));
+    const details = issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
+    throw new ExtractionValidationError(`Invalid ExtractionResult${label}: ${details}`, issues);
+  }
+  return result.data;
+}
+
+// src/build.ts
+var CONFIDENCE_RANK = { EXTRACTED: 3, INFERRED: 2, AMBIGUOUS: 1 };
+function strongerConfidence(a, b) {
+  return CONFIDENCE_RANK[a] >= CONFIDENCE_RANK[b] ? a : b;
+}
+function ensureNode(graph, id) {
+  if (graph.hasNode(id)) return;
+  graph.addNode(id, { label: id, sourceFile: "<unknown>", sourceLocation: "L0" });
+}
+function buildGraph(extractions) {
+  const graph = new import_graphology3.default({ type: "directed", multi: true, allowSelfLoops: true });
+  const validated = extractions.map(
+    (extraction, index) => validateExtraction(extraction, `extraction #${index}`)
+  );
+  const allNodes = validated.flatMap((extraction) => extraction.nodes);
+  const allEdges = validated.flatMap((extraction) => extraction.edges);
+  const sortedNodes = [...allNodes].sort((a, b) => a.id.localeCompare(b.id));
+  for (const node of sortedNodes) {
+    if (graph.hasNode(node.id)) continue;
+    graph.addNode(node.id, {
+      label: node.label,
+      sourceFile: node.sourceFile,
+      sourceLocation: node.sourceLocation
+    });
+  }
+  const sortedEdges = [...allEdges].sort(
+    (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target) || a.relation.localeCompare(b.relation)
+  );
+  for (const edge of sortedEdges) {
+    ensureNode(graph, edge.source);
+    ensureNode(graph, edge.target);
+    const key = `${edge.source}|${edge.relation}|${edge.target}`;
+    if (graph.hasEdge(key)) {
+      const existing = graph.getEdgeAttribute(key, "confidence");
+      graph.setEdgeAttribute(key, "confidence", strongerConfidence(existing, edge.confidence));
+      continue;
+    }
+    graph.addEdgeWithKey(key, edge.source, edge.target, {
+      relation: edge.relation,
+      confidence: edge.confidence
+    });
+  }
+  return graph;
+}
+
+// src/detect.ts
+init_cjs_shims();
+var fs4 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  "graphify-out",
+  ".next",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".cache",
+  "coverage",
+  ".turbo"
+]);
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".cs",
+  ".rb",
+  ".c",
+  ".h",
+  ".cpp",
+  ".hpp",
+  ".cc",
+  ".php",
+  ".kt",
+  ".swift",
+  ".scala",
+  ".lua",
+  ".sh",
+  ".sql"
+]);
+var DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".txt", ".rst", ".adoc", ".org", ".json", ".yaml", ".yml", ".toml"]);
+var PAPER_EXTENSIONS = /* @__PURE__ */ new Set([".pdf", ".tex", ".bib"]);
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".bmp", ".ico"]);
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm"]);
+var SENSITIVE_NAME_PATTERNS = [
+  /^\.env(\..*)?$/i,
+  /^\.npmrc$/i,
+  /^\.pypirc$/i,
+  /credentials/i,
+  /secret/i,
+  /^id_rsa$/i,
+  /^id_ed25519$/i,
+  /\.pem$/i,
+  /\.key$/i,
+  /\.pfx$/i,
+  /\.p12$/i,
+  /^\.aws\//i,
+  /service[-_]?account.*\.json$/i
+];
+function isSensitiveName(name) {
+  return SENSITIVE_NAME_PATTERNS.some((pattern) => pattern.test(name));
+}
+function categorize(ext) {
+  const lower = ext.toLowerCase();
+  if (CODE_EXTENSIONS.has(lower)) return "code";
+  if (DOCUMENT_EXTENSIONS.has(lower)) return "document";
+  if (PAPER_EXTENSIONS.has(lower)) return "paper";
+  if (IMAGE_EXTENSIONS.has(lower)) return "image";
+  if (VIDEO_EXTENSIONS.has(lower)) return "video";
+  return null;
+}
+function countWords(content) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return 0;
+  return trimmed.split(/\s+/).length;
+}
+function readTextSafely(filePath) {
+  const buf = fs4.readFileSync(filePath);
+  return buf.toString("utf-8");
+}
+function collectFiles(root) {
+  const scanRoot = path3.resolve(root);
+  const stat = fs4.statSync(scanRoot);
+  if (!stat.isDirectory()) {
+    throw new Error(`collectFiles: not a directory: ${scanRoot}`);
+  }
+  const files = {
+    code: [],
+    document: [],
+    paper: [],
+    image: [],
+    video: []
+  };
+  const skippedSensitive = [];
+  let totalWords = 0;
+  const stack = [scanRoot];
+  const textCategories = /* @__PURE__ */ new Set(["code", "document", "paper"]);
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue;
+      const fullPath = path3.join(dir, entry.name);
+      const relPath = path3.relative(scanRoot, fullPath);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+        stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (isSensitiveName(entry.name)) {
+        skippedSensitive.push(relPath);
+        continue;
+      }
+      const ext = path3.extname(entry.name);
+      const category = categorize(ext);
+      if (category === null) continue;
+      files[category].push(relPath);
+      if (textCategories.has(category)) {
+        try {
+          const content = readTextSafely(fullPath);
+          totalWords += countWords(content);
+        } catch {
+        }
+      }
+    }
+  }
+  for (const category of Object.keys(files)) {
+    files[category].sort();
+  }
+  skippedSensitive.sort();
+  const totalFiles = Object.values(files).reduce((sum, list) => sum + list.length, 0);
+  return {
+    scanRoot,
+    files,
+    totalFiles,
+    totalWords,
+    skippedSensitive
+  };
+}
+
+// src/extract.ts
+init_cjs_shims();
+var path6 = __toESM(require("path"), 1);
+
+// src/extractors/csharp.ts
+init_cjs_shims();
+var fs5 = __toESM(require("fs/promises"), 1);
+
+// src/extractors/common.ts
+init_cjs_shims();
+var path4 = __toESM(require("path"), 1);
+function namedChildren(node) {
+  return node.namedChildren.filter((c) => c !== null);
+}
+function descendantsOfType(node, types) {
+  return node.descendantsOfType(types).filter((c) => c !== null);
+}
+function toPosix(p) {
+  return p.split(path4.sep).join("/");
+}
+function lineOf(node) {
+  return `L${node.startPosition.row + 1}`;
+}
+function entityId(sourceFile, qualifiedName) {
+  return `${toPosix(sourceFile)}::${qualifiedName}`;
+}
+function externalId(name) {
+  return `external:${name}`;
+}
+function resolveModuleRef(sourceFile, specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/")) {
+    const dir = path4.posix.dirname(toPosix(sourceFile));
+    const joined = specifier.startsWith("/") ? specifier : path4.posix.join(dir, specifier);
+    const normalized = path4.posix.normalize(joined);
+    return { id: normalized, label: specifier, external: false };
+  }
+  return { id: `module:${specifier}`, label: specifier, external: true };
+}
+var ExtractionBuilder = class {
+  nodeIds = /* @__PURE__ */ new Set();
+  nodes = [];
+  edges = [];
+  addNode(node) {
+    if (this.nodeIds.has(node.id)) return;
+    this.nodeIds.add(node.id);
+    this.nodes.push(node);
+  }
+  hasNode(id) {
+    return this.nodeIds.has(id);
+  }
+  addEdge(edge) {
+    this.edges.push(edge);
+  }
+  build() {
+    return { nodes: this.nodes, edges: this.edges };
+  }
+};
+
+// src/extractors/wasmLoader.ts
+init_cjs_shims();
+var import_node_module2 = require("module");
+var import_web_tree_sitter = require("web-tree-sitter");
+var require3 = (0, import_node_module2.createRequire)(importMetaUrl);
+var initPromise = null;
+function ensureInitialized() {
+  if (!initPromise) {
+    initPromise = import_web_tree_sitter.Parser.init();
+  }
+  return initPromise;
+}
+var languageCache = /* @__PURE__ */ new Map();
+async function loadLanguage(grammarName) {
+  await ensureInitialized();
+  let cached = languageCache.get(grammarName);
+  if (!cached) {
+    const wasmPath = require3.resolve(`tree-sitter-wasms/out/tree-sitter-${grammarName}.wasm`);
+    cached = import_web_tree_sitter.Language.load(wasmPath);
+    languageCache.set(grammarName, cached);
+  }
+  return cached;
+}
+async function createParser(grammarName) {
+  const language = await loadLanguage(grammarName);
+  const parser = new import_web_tree_sitter.Parser();
+  parser.setLanguage(language);
+  return parser;
+}
+
+// src/extractors/csharp.ts
+async function extractCSharp(filePath) {
+  const parser = await createParser("c_sharp");
+  const raw = await fs5.readFile(filePath);
+  const content = raw.toString("utf-8");
+  const tree = parser.parse(content);
+  if (!tree) {
+    throw new Error(`extractCSharp: parser produced no tree for ${filePath}`);
+  }
+  const root = tree.rootNode;
+  const sourceFile = toPosix(filePath);
+  const builder = new ExtractionBuilder();
+  const fileId = sourceFile;
+  builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
+  const nameIndex = /* @__PURE__ */ new Map();
+  const functionNodeMap = /* @__PURE__ */ new Map();
+  const classMethods = /* @__PURE__ */ new Map();
+  const enclosingClassOf = /* @__PURE__ */ new Map();
+  const importIndex = /* @__PURE__ */ new Map();
+  function addModuleNode(ref) {
+    if (builder.hasNode(ref.id)) return;
+    builder.addNode({
+      id: ref.id,
+      label: ref.label,
+      sourceFile: ref.external ? "<external>" : ref.id,
+      sourceLocation: "L1"
+    });
+  }
+  function resolveHeritageTarget(name) {
+    const resolved = nameIndex.get(name);
+    if (resolved) return resolved;
+    const extId = externalId(name);
+    if (!builder.hasNode(extId)) {
+      builder.addNode({ id: extId, label: name, sourceFile: "<external>", sourceLocation: "L0" });
+    }
+    return extId;
+  }
+  function handleUsingDirective(node) {
+    const children = namedChildren(node);
+    const first = children[0];
+    if (!first) return;
+    let aliasName;
+    let targetNode;
+    if (first.type === "name_equals") {
+      aliasName = namedChildren(first)[0]?.text;
+      targetNode = children[1];
+    } else {
+      targetNode = first;
+    }
+    if (!targetNode) return;
+    const ref = resolveModuleRef(sourceFile, targetNode.text);
+    addModuleNode(ref);
+    if (aliasName) importIndex.set(aliasName, ref);
+    builder.addEdge({ source: fileId, target: ref.id, relation: "imports", confidence: "EXTRACTED" });
+  }
+  function handleMethodDeclaration(typeNode, typeId, typeName, member) {
+    const methodName = member.childForFieldName("name")?.text ?? "(anonymous)";
+    const methodId = entityId(sourceFile, `${typeName}.${methodName}`);
+    builder.addNode({
+      id: methodId,
+      label: `method ${typeName}.${methodName}`,
+      sourceFile,
+      sourceLocation: lineOf(member)
+    });
+    builder.addEdge({ source: typeId, target: methodId, relation: "method", confidence: "EXTRACTED" });
+    let methods = classMethods.get(typeNode.id);
+    if (!methods) {
+      methods = /* @__PURE__ */ new Map();
+      classMethods.set(typeNode.id, methods);
+    }
+    methods.set(methodName, methodId);
+    functionNodeMap.set(member.id, methodId);
+    enclosingClassOf.set(member.id, typeNode.id);
+  }
+  function handleBaseList(typeId, node) {
+    const baseList = node.childForFieldName("bases");
+    if (!baseList) return;
+    const entries = namedChildren(baseList);
+    entries.forEach((entry, index) => {
+      builder.addEdge({
+        source: typeId,
+        target: resolveHeritageTarget(entry.text),
+        relation: index === 0 ? "inherits" : "implements",
+        confidence: "EXTRACTED"
+      });
+    });
+  }
+  function handleClassDeclaration(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const classId = entityId(sourceFile, name);
+    builder.addNode({ id: classId, label: `class ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: classId, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, classId);
+    functionNodeMap.set(node.id, classId);
+    classMethods.set(node.id, /* @__PURE__ */ new Map());
+    handleBaseList(classId, node);
+    const body = node.childForFieldName("body");
+    if (body) {
+      for (const member of namedChildren(body)) {
+        if (member.type !== "method_declaration") continue;
+        handleMethodDeclaration(node, classId, name, member);
+      }
+    }
+  }
+  function handleInterfaceDeclaration(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const id = entityId(sourceFile, name);
+    builder.addNode({ id, label: `interface ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, id);
+    handleBaseList(id, node);
+  }
+  function walkTopLevel(node) {
+    for (const child of namedChildren(node)) {
+      switch (child.type) {
+        case "using_directive":
+          handleUsingDirective(child);
+          break;
+        case "class_declaration":
+          handleClassDeclaration(child);
+          break;
+        case "interface_declaration":
+          handleInterfaceDeclaration(child);
+          break;
+        case "namespace_declaration": {
+          const nsBody = child.childForFieldName("body");
+          if (nsBody) walkTopLevel(nsBody);
+          break;
+        }
+        case "file_scoped_namespace_declaration":
+          walkTopLevel(child);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  walkTopLevel(root);
+  function closestTrackedCaller(node) {
+    let current = node.parent;
+    while (current) {
+      const tracked = functionNodeMap.get(current.id);
+      if (tracked) return tracked;
+      current = current.parent;
+    }
+    return fileId;
+  }
+  function closestEnclosingClassMethods(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "method_declaration") {
+        const typeNodeId = enclosingClassOf.get(current.id);
+        if (typeNodeId !== void 0) return classMethods.get(typeNodeId);
+      }
+      current = current.parent;
+    }
+    return void 0;
+  }
+  for (const call of descendantsOfType(root, ["invocation_expression"])) {
+    const fn = call.childForFieldName("function");
+    if (!fn) continue;
+    let targetId = null;
+    let confidence = "EXTRACTED";
+    if (fn.type === "identifier") {
+      const name = fn.text;
+      const methodId = closestEnclosingClassMethods(call)?.get(name);
+      if (methodId) {
+        targetId = methodId;
+      } else {
+        const viaImport = importIndex.get(name);
+        if (viaImport) {
+          targetId = viaImport.id;
+          confidence = "INFERRED";
+        }
+      }
+    } else if (fn.type === "member_access_expression") {
+      const expression = fn.childForFieldName("expression");
+      const name = fn.childForFieldName("name")?.text;
+      if (expression && name) {
+        if (expression.type === "this_expression") {
+          const methodId = closestEnclosingClassMethods(call)?.get(name);
+          if (methodId) targetId = methodId;
+        } else if (expression.type === "identifier") {
+          const viaImport = importIndex.get(expression.text);
+          if (viaImport) {
+            targetId = viaImport.id;
+            confidence = "INFERRED";
+          }
+        }
+      }
+    }
+    if (!targetId) continue;
+    const callerId = closestTrackedCaller(call);
+    builder.addEdge({ source: callerId, target: targetId, relation: "calls", confidence });
+  }
+  return builder.build();
+}
+
+// src/extractors/go.ts
+init_cjs_shims();
+var fs6 = __toESM(require("fs/promises"), 1);
+function stripQuotes(text) {
+  if (text.length >= 2) {
+    const first = text[0];
+    const last = text[text.length - 1];
+    if ((first === '"' || first === "`") && first === last) {
+      return text.slice(1, -1);
+    }
+  }
+  return text;
+}
+function defaultPackageQualifier(importPath) {
+  const segments = importPath.split("/");
+  return segments[segments.length - 1] ?? importPath;
+}
+async function extractGo(filePath) {
+  const parser = await createParser("go");
+  const raw = await fs6.readFile(filePath);
+  const content = raw.toString("utf-8");
+  const tree = parser.parse(content);
+  if (!tree) {
+    throw new Error(`extractGo: parser produced no tree for ${filePath}`);
+  }
+  const root = tree.rootNode;
+  const sourceFile = toPosix(filePath);
+  const builder = new ExtractionBuilder();
+  const fileId = sourceFile;
+  builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
+  const nameIndex = /* @__PURE__ */ new Map();
+  const functionNodeMap = /* @__PURE__ */ new Map();
+  const typeMethods = /* @__PURE__ */ new Map();
+  const receiverInfo = /* @__PURE__ */ new Map();
+  const importIndex = /* @__PURE__ */ new Map();
+  function addModuleNode(ref) {
+    if (builder.hasNode(ref.id)) return;
+    builder.addNode({
+      id: ref.id,
+      label: ref.label,
+      sourceFile: ref.external ? "<external>" : ref.id,
+      sourceLocation: "L1"
+    });
+  }
+  function resolveTypeTarget(name) {
+    const resolved = nameIndex.get(name);
+    if (resolved) return resolved;
+    const extId = externalId(name);
+    if (!builder.hasNode(extId)) {
+      builder.addNode({ id: extId, label: name, sourceFile: "<external>", sourceLocation: "L0" });
+    }
+    return extId;
+  }
+  function handleImportSpec(spec) {
+    const pathNode = spec.childForFieldName("path");
+    if (!pathNode) return;
+    const specifier = stripQuotes(pathNode.text);
+    const ref = resolveModuleRef(sourceFile, specifier);
+    addModuleNode(ref);
+    builder.addEdge({ source: fileId, target: ref.id, relation: "imports", confidence: "EXTRACTED" });
+    const aliasNode = spec.childForFieldName("name");
+    const alias = aliasNode?.text;
+    if (alias && alias !== "_" && alias !== ".") {
+      importIndex.set(alias, ref);
+    } else if (!alias) {
+      importIndex.set(defaultPackageQualifier(specifier), ref);
+    }
+  }
+  function handleImportDeclaration(node) {
+    for (const child of namedChildren(node)) {
+      if (child.type === "import_spec") {
+        handleImportSpec(child);
+      } else if (child.type === "import_spec_list") {
+        for (const spec of namedChildren(child)) {
+          if (spec.type === "import_spec") handleImportSpec(spec);
+        }
+      }
+    }
+  }
+  function handleFunctionDeclaration(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const id = entityId(sourceFile, name);
+    builder.addNode({ id, label: `function ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, id);
+    functionNodeMap.set(node.id, id);
+  }
+  function handleTypeDeclaration(node) {
+    for (const spec of namedChildren(node)) {
+      if (spec.type !== "type_spec") continue;
+      const name = spec.childForFieldName("name")?.text;
+      if (!name) continue;
+      const underlying = spec.childForFieldName("type");
+      const kind = underlying?.type === "struct_type" ? "struct" : underlying?.type === "interface_type" ? "interface" : "type";
+      const id = entityId(sourceFile, name);
+      builder.addNode({ id, label: `${kind} ${name}`, sourceFile, sourceLocation: lineOf(spec) });
+      builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+      nameIndex.set(name, id);
+      typeMethods.set(id, /* @__PURE__ */ new Map());
+      if (underlying?.type === "struct_type") {
+        const fieldList = namedChildren(underlying).find((c) => c.type === "field_declaration_list");
+        if (fieldList) {
+          for (const field of namedChildren(fieldList)) {
+            if (field.type !== "field_declaration") continue;
+            if (field.childForFieldName("name")) continue;
+            const embeddedType = namedChildren(field)[0];
+            if (!embeddedType) continue;
+            const base = embeddedType.type === "pointer_type" ? namedChildren(embeddedType)[0] : embeddedType;
+            if (!base) continue;
+            builder.addEdge({
+              source: id,
+              target: resolveTypeTarget(base.text),
+              relation: "embeds",
+              confidence: "EXTRACTED"
+            });
+          }
+        }
+      }
+    }
+  }
+  function receiverTypeName(receiver) {
+    const paramDecl = namedChildren(receiver)[0];
+    if (!paramDecl) return null;
+    let typeNode = paramDecl.childForFieldName("type");
+    if (typeNode?.type === "pointer_type") {
+      typeNode = namedChildren(typeNode)[0] ?? null;
+    }
+    return typeNode?.type === "type_identifier" ? typeNode.text : null;
+  }
+  function receiverVarName(receiver) {
+    const paramDecl = namedChildren(receiver)[0];
+    return paramDecl?.childForFieldName("name")?.text ?? null;
+  }
+  function handleMethodDeclaration(node) {
+    const receiver = node.childForFieldName("receiver");
+    const methodName = node.childForFieldName("name")?.text ?? "(anonymous)";
+    if (!receiver) return;
+    const typeName = receiverTypeName(receiver);
+    if (!typeName) return;
+    const typeId = resolveTypeTarget(typeName);
+    const methodId = entityId(sourceFile, `${typeName}.${methodName}`);
+    builder.addNode({ id: methodId, label: `method ${typeName}.${methodName}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: typeId, target: methodId, relation: "method", confidence: "EXTRACTED" });
+    let methods = typeMethods.get(typeId);
+    if (!methods) {
+      methods = /* @__PURE__ */ new Map();
+      typeMethods.set(typeId, methods);
+    }
+    methods.set(methodName, methodId);
+    functionNodeMap.set(node.id, methodId);
+    const varName = receiverVarName(receiver);
+    if (varName) receiverInfo.set(node.id, { varName, typeId });
+  }
+  for (const child of namedChildren(root)) {
+    switch (child.type) {
+      case "import_declaration":
+        handleImportDeclaration(child);
+        break;
+      case "type_declaration":
+        handleTypeDeclaration(child);
+        break;
+      case "function_declaration":
+        handleFunctionDeclaration(child);
+        break;
+      case "method_declaration":
+        handleMethodDeclaration(child);
+        break;
+      default:
+        break;
+    }
+  }
+  function closestTrackedCaller(node) {
+    let current = node.parent;
+    while (current) {
+      const tracked = functionNodeMap.get(current.id);
+      if (tracked) return tracked;
+      current = current.parent;
+    }
+    return fileId;
+  }
+  function closestEnclosingReceiver(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "method_declaration") {
+        return receiverInfo.get(current.id);
+      }
+      current = current.parent;
+    }
+    return void 0;
+  }
+  for (const call of descendantsOfType(root, ["call_expression"])) {
+    const fn = call.childForFieldName("function");
+    if (!fn) continue;
+    let targetId = null;
+    let confidence = "EXTRACTED";
+    if (fn.type === "identifier") {
+      const sameFile = nameIndex.get(fn.text);
+      if (sameFile) targetId = sameFile;
+    } else if (fn.type === "selector_expression") {
+      const operand = fn.childForFieldName("operand");
+      const property = fn.childForFieldName("field")?.text;
+      if (operand && property && operand.type === "identifier") {
+        const receiver = closestEnclosingReceiver(call);
+        if (receiver && receiver.varName === operand.text) {
+          const methodId = typeMethods.get(receiver.typeId)?.get(property);
+          if (methodId) targetId = methodId;
+        } else {
+          const viaImport = importIndex.get(operand.text);
+          if (viaImport) {
+            targetId = viaImport.id;
+            confidence = "INFERRED";
+          }
+        }
+      }
+    }
+    if (!targetId) continue;
+    const callerId = closestTrackedCaller(call);
+    builder.addEdge({ source: callerId, target: targetId, relation: "calls", confidence });
+  }
+  return builder.build();
+}
+
+// src/extractors/java.ts
+init_cjs_shims();
+var fs7 = __toESM(require("fs/promises"), 1);
+async function extractJava(filePath) {
+  const parser = await createParser("java");
+  const raw = await fs7.readFile(filePath);
+  const content = raw.toString("utf-8");
+  const tree = parser.parse(content);
+  if (!tree) {
+    throw new Error(`extractJava: parser produced no tree for ${filePath}`);
+  }
+  const root = tree.rootNode;
+  const sourceFile = toPosix(filePath);
+  const builder = new ExtractionBuilder();
+  const fileId = sourceFile;
+  builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
+  const nameIndex = /* @__PURE__ */ new Map();
+  const functionNodeMap = /* @__PURE__ */ new Map();
+  const classMethods = /* @__PURE__ */ new Map();
+  const enclosingClassOf = /* @__PURE__ */ new Map();
+  const importIndex = /* @__PURE__ */ new Map();
+  function addModuleNode(ref) {
+    if (builder.hasNode(ref.id)) return;
+    builder.addNode({
+      id: ref.id,
+      label: ref.label,
+      sourceFile: ref.external ? "<external>" : ref.id,
+      sourceLocation: "L1"
+    });
+  }
+  function resolveHeritageTarget(name) {
+    const resolved = nameIndex.get(name);
+    if (resolved) return resolved;
+    const extId = externalId(name);
+    if (!builder.hasNode(extId)) {
+      builder.addNode({ id: extId, label: name, sourceFile: "<external>", sourceLocation: "L0" });
+    }
+    return extId;
+  }
+  function handleImportDeclaration(node) {
+    const hasWildcard = namedChildren(node).some((c) => c.type === "asterisk");
+    const scoped = namedChildren(node).find((c) => c.type === "scoped_identifier" || c.type === "identifier");
+    if (!scoped) return;
+    const fullPath = scoped.text;
+    const ref = resolveModuleRef(sourceFile, fullPath);
+    addModuleNode(ref);
+    if (hasWildcard) {
+      builder.addEdge({ source: fileId, target: ref.id, relation: "imports", confidence: "EXTRACTED" });
+      return;
+    }
+    const segments = fullPath.split(".");
+    const localName = segments[segments.length - 1];
+    if (localName) importIndex.set(localName, ref);
+    builder.addEdge({ source: fileId, target: ref.id, relation: "imports_from", confidence: "EXTRACTED" });
+  }
+  function handleMethodDeclaration(classNode, classId, className, member) {
+    const methodName = member.childForFieldName("name")?.text ?? "(anonymous)";
+    const methodId = entityId(sourceFile, `${className}.${methodName}`);
+    builder.addNode({
+      id: methodId,
+      label: `method ${className}.${methodName}`,
+      sourceFile,
+      sourceLocation: lineOf(member)
+    });
+    builder.addEdge({ source: classId, target: methodId, relation: "method", confidence: "EXTRACTED" });
+    let methods = classMethods.get(classNode.id);
+    if (!methods) {
+      methods = /* @__PURE__ */ new Map();
+      classMethods.set(classNode.id, methods);
+    }
+    methods.set(methodName, methodId);
+    functionNodeMap.set(member.id, methodId);
+    enclosingClassOf.set(member.id, classNode.id);
+  }
+  function handleClassDeclaration(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const classId = entityId(sourceFile, name);
+    builder.addNode({ id: classId, label: `class ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: classId, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, classId);
+    functionNodeMap.set(node.id, classId);
+    classMethods.set(node.id, /* @__PURE__ */ new Map());
+    const superclass = node.childForFieldName("superclass");
+    if (superclass) {
+      const base = namedChildren(superclass)[0];
+      if (base) {
+        builder.addEdge({
+          source: classId,
+          target: resolveHeritageTarget(base.text),
+          relation: "inherits",
+          confidence: "EXTRACTED"
+        });
+      }
+    }
+    const interfaces = node.childForFieldName("interfaces");
+    if (interfaces) {
+      const typeList = namedChildren(interfaces).find((c) => c.type === "type_list");
+      for (const iface of typeList ? namedChildren(typeList) : []) {
+        builder.addEdge({
+          source: classId,
+          target: resolveHeritageTarget(iface.text),
+          relation: "implements",
+          confidence: "EXTRACTED"
+        });
+      }
+    }
+    const body = node.childForFieldName("body");
+    if (body) {
+      for (const member of namedChildren(body)) {
+        if (member.type !== "method_declaration") continue;
+        handleMethodDeclaration(node, classId, name, member);
+      }
+    }
+  }
+  function handleInterfaceDeclaration(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const id = entityId(sourceFile, name);
+    builder.addNode({ id, label: `interface ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, id);
+    const extendsInterfaces = namedChildren(node).find((c) => c.type === "extends_interfaces");
+    if (extendsInterfaces) {
+      const typeList = namedChildren(extendsInterfaces).find((c) => c.type === "type_list");
+      for (const parent of typeList ? namedChildren(typeList) : []) {
+        builder.addEdge({
+          source: id,
+          target: resolveHeritageTarget(parent.text),
+          relation: "inherits",
+          confidence: "EXTRACTED"
+        });
+      }
+    }
+  }
+  for (const child of namedChildren(root)) {
+    switch (child.type) {
+      case "import_declaration":
+        handleImportDeclaration(child);
+        break;
+      case "class_declaration":
+        handleClassDeclaration(child);
+        break;
+      case "interface_declaration":
+        handleInterfaceDeclaration(child);
+        break;
+      default:
+        break;
+    }
+  }
+  function closestTrackedCaller(node) {
+    let current = node.parent;
+    while (current) {
+      const tracked = functionNodeMap.get(current.id);
+      if (tracked) return tracked;
+      current = current.parent;
+    }
+    return fileId;
+  }
+  function closestEnclosingClassMethods(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "method_declaration") {
+        const classNodeId = enclosingClassOf.get(current.id);
+        if (classNodeId !== void 0) return classMethods.get(classNodeId);
+      }
+      current = current.parent;
+    }
+    return void 0;
+  }
+  for (const call of descendantsOfType(root, ["method_invocation"])) {
+    const name = call.childForFieldName("name")?.text;
+    if (!name) continue;
+    const object = call.childForFieldName("object");
+    let targetId = null;
+    let confidence = "EXTRACTED";
+    if (!object) {
+      const methodId = closestEnclosingClassMethods(call)?.get(name);
+      if (methodId) {
+        targetId = methodId;
+      } else {
+        const viaImport = importIndex.get(name);
+        if (viaImport) {
+          targetId = viaImport.id;
+          confidence = "INFERRED";
+        }
+      }
+    } else if (object.type === "this") {
+      const methodId = closestEnclosingClassMethods(call)?.get(name);
+      if (methodId) targetId = methodId;
+    } else if (object.type === "identifier") {
+      const viaImport = importIndex.get(object.text);
+      if (viaImport) {
+        targetId = viaImport.id;
+        confidence = "INFERRED";
+      }
+    }
+    if (!targetId) continue;
+    const callerId = closestTrackedCaller(call);
+    builder.addEdge({ source: callerId, target: targetId, relation: "calls", confidence });
+  }
+  return builder.build();
+}
+
+// src/extractors/python.ts
+init_cjs_shims();
+var fs8 = __toESM(require("fs/promises"), 1);
+async function extractPython(filePath) {
+  const parser = await createParser("python");
+  const raw = await fs8.readFile(filePath);
+  const content = raw.toString("utf-8");
+  const tree = parser.parse(content);
+  if (!tree) {
+    throw new Error(`extractPython: parser produced no tree for ${filePath}`);
+  }
+  const root = tree.rootNode;
+  const sourceFile = toPosix(filePath);
+  const builder = new ExtractionBuilder();
+  const fileId = sourceFile;
+  builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
+  const nameIndex = /* @__PURE__ */ new Map();
+  const functionNodeMap = /* @__PURE__ */ new Map();
+  const classMethods = /* @__PURE__ */ new Map();
+  const enclosingClassOf = /* @__PURE__ */ new Map();
+  const importIndex = /* @__PURE__ */ new Map();
+  function addModuleNode(ref) {
+    if (builder.hasNode(ref.id)) return;
+    builder.addNode({
+      id: ref.id,
+      label: ref.label,
+      sourceFile: ref.external ? "<external>" : ref.id,
+      sourceLocation: "L1"
+    });
+  }
+  function resolveHeritageTarget(name) {
+    const resolved = nameIndex.get(name);
+    if (resolved) return resolved;
+    const extId = externalId(name);
+    if (!builder.hasNode(extId)) {
+      builder.addNode({ id: extId, label: name, sourceFile: "<external>", sourceLocation: "L0" });
+    }
+    return extId;
+  }
+  function unwrapDecorated(node) {
+    if (node.type !== "decorated_definition") return node;
+    return namedChildren(node).find((c) => c.type === "function_definition" || c.type === "class_definition") ?? null;
+  }
+  function relativeSpecifier(relImport) {
+    let dots = 0;
+    for (const ch of relImport.text) {
+      if (ch !== ".") break;
+      dots++;
+    }
+    const dotted = namedChildren(relImport).find((c) => c.type === "dotted_name");
+    const up = dots - 1;
+    let base = up === 0 ? "." : Array.from({ length: up }, () => "..").join("/");
+    if (dotted) {
+      base = `${base}/${dotted.text.split(".").join("/")}`;
+    }
+    return base;
+  }
+  function moduleSpecifierOf(node) {
+    if (node.type === "relative_import") return relativeSpecifier(node);
+    return node.text;
+  }
+  function handleFunctionDefinition(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const id = entityId(sourceFile, name);
+    builder.addNode({ id, label: `function ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, id);
+    functionNodeMap.set(node.id, id);
+  }
+  function handleClassDefinition(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const classId = entityId(sourceFile, name);
+    builder.addNode({ id: classId, label: `class ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: classId, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, classId);
+    functionNodeMap.set(node.id, classId);
+    const superclasses = node.childForFieldName("superclasses");
+    if (superclasses) {
+      for (const base of namedChildren(superclasses)) {
+        if (base.type !== "identifier" && base.type !== "attribute") continue;
+        builder.addEdge({
+          source: classId,
+          target: resolveHeritageTarget(base.text),
+          relation: "inherits",
+          confidence: "EXTRACTED"
+        });
+      }
+    }
+    const methods = /* @__PURE__ */ new Map();
+    classMethods.set(node.id, methods);
+    const body = node.childForFieldName("body");
+    if (body) {
+      for (const rawMember of namedChildren(body)) {
+        const member = unwrapDecorated(rawMember);
+        if (!member || member.type !== "function_definition") continue;
+        const methodName = member.childForFieldName("name")?.text ?? "(anonymous)";
+        const methodId = entityId(sourceFile, `${name}.${methodName}`);
+        builder.addNode({
+          id: methodId,
+          label: `method ${name}.${methodName}`,
+          sourceFile,
+          sourceLocation: lineOf(member)
+        });
+        builder.addEdge({ source: classId, target: methodId, relation: "method", confidence: "EXTRACTED" });
+        methods.set(methodName, methodId);
+        functionNodeMap.set(member.id, methodId);
+        enclosingClassOf.set(member.id, node.id);
+      }
+    }
+  }
+  function handleImportStatement(node) {
+    for (const item of namedChildren(node)) {
+      if (item.type === "dotted_name") {
+        const ref = resolveModuleRef(sourceFile, item.text);
+        addModuleNode(ref);
+        const bindingName = namedChildren(item)[0]?.text ?? item.text;
+        importIndex.set(bindingName, ref);
+        builder.addEdge({ source: fileId, target: ref.id, relation: "imports", confidence: "EXTRACTED" });
+      } else if (item.type === "aliased_import") {
+        const dotted = item.childForFieldName("name");
+        const alias = item.childForFieldName("alias")?.text;
+        if (!dotted || !alias) continue;
+        const ref = resolveModuleRef(sourceFile, dotted.text);
+        addModuleNode(ref);
+        importIndex.set(alias, ref);
+        builder.addEdge({ source: fileId, target: ref.id, relation: "imports", confidence: "EXTRACTED" });
+      }
+    }
+  }
+  function handleImportFromStatement(node) {
+    const moduleNode = node.childForFieldName("module_name");
+    if (!moduleNode) return;
+    const ref = resolveModuleRef(sourceFile, moduleSpecifierOf(moduleNode));
+    addModuleNode(ref);
+    let sawItem = false;
+    for (const child of namedChildren(node)) {
+      if (child.id === moduleNode.id) continue;
+      if (child.type === "dotted_name") {
+        sawItem = true;
+        importIndex.set(child.text, ref);
+      } else if (child.type === "aliased_import") {
+        sawItem = true;
+        const alias = child.childForFieldName("alias")?.text;
+        const name = child.childForFieldName("name")?.text;
+        if (alias) importIndex.set(alias, ref);
+        else if (name) importIndex.set(name, ref);
+      } else if (child.type === "wildcard_import") {
+        sawItem = true;
+      }
+    }
+    if (sawItem) {
+      builder.addEdge({ source: fileId, target: ref.id, relation: "imports_from", confidence: "EXTRACTED" });
+    }
+  }
+  for (const rawChild of namedChildren(root)) {
+    if (rawChild.type === "import_statement") {
+      handleImportStatement(rawChild);
+      continue;
+    }
+    if (rawChild.type === "import_from_statement") {
+      handleImportFromStatement(rawChild);
+      continue;
+    }
+    const effective = unwrapDecorated(rawChild);
+    if (!effective) continue;
+    switch (effective.type) {
+      case "function_definition":
+        handleFunctionDefinition(effective);
+        break;
+      case "class_definition":
+        handleClassDefinition(effective);
+        break;
+      default:
+        break;
+    }
+  }
+  function closestTrackedCaller(node) {
+    let current = node.parent;
+    while (current) {
+      const tracked = functionNodeMap.get(current.id);
+      if (tracked) return tracked;
+      current = current.parent;
+    }
+    return fileId;
+  }
+  function closestEnclosingClassMethods(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "function_definition") {
+        const classNodeId = enclosingClassOf.get(current.id);
+        if (classNodeId !== void 0) return classMethods.get(classNodeId);
+      }
+      current = current.parent;
+    }
+    return void 0;
+  }
+  for (const call of descendantsOfType(root, ["call"])) {
+    const fn = call.childForFieldName("function");
+    if (!fn) continue;
+    let targetId = null;
+    let confidence = "EXTRACTED";
+    if (fn.type === "identifier") {
+      const name = fn.text;
+      const sameFile = nameIndex.get(name);
+      if (sameFile) {
+        targetId = sameFile;
+      } else {
+        const viaImport = importIndex.get(name);
+        if (viaImport) {
+          targetId = viaImport.id;
+          confidence = "INFERRED";
+        }
+      }
+    } else if (fn.type === "attribute") {
+      const object = fn.childForFieldName("object");
+      const property = fn.childForFieldName("attribute")?.text;
+      if (object && property) {
+        if (object.type === "identifier" && object.text === "self") {
+          const methodId = closestEnclosingClassMethods(call)?.get(property);
+          if (methodId) targetId = methodId;
+        } else if (object.type === "identifier") {
+          const viaImport = importIndex.get(object.text);
+          if (viaImport) {
+            targetId = viaImport.id;
+            confidence = "INFERRED";
+          }
+        }
+      }
+    }
+    if (!targetId) continue;
+    const callerId = closestTrackedCaller(call);
+    builder.addEdge({ source: callerId, target: targetId, relation: "calls", confidence });
+  }
+  return builder.build();
+}
+
+// src/extractors/ruby.ts
+init_cjs_shims();
+var fs9 = __toESM(require("fs/promises"), 1);
+function conventionalConstantName(specifier) {
+  const lastSegment = specifier.split("/").filter(Boolean).pop() ?? specifier;
+  return lastSegment.split("_").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function stringLiteralContent(node) {
+  if (node.type !== "string") return null;
+  const content = namedChildren(node).find((c) => c.type === "string_content");
+  return content ? content.text : "";
+}
+async function extractRuby(filePath) {
+  const parser = await createParser("ruby");
+  const raw = await fs9.readFile(filePath);
+  const content = raw.toString("utf-8");
+  const tree = parser.parse(content);
+  if (!tree) {
+    throw new Error(`extractRuby: parser produced no tree for ${filePath}`);
+  }
+  const root = tree.rootNode;
+  const sourceFile = toPosix(filePath);
+  const builder = new ExtractionBuilder();
+  const fileId = sourceFile;
+  builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
+  const nameIndex = /* @__PURE__ */ new Map();
+  const functionNodeMap = /* @__PURE__ */ new Map();
+  const typeMethods = /* @__PURE__ */ new Map();
+  const enclosingTypeOf = /* @__PURE__ */ new Map();
+  const importIndex = /* @__PURE__ */ new Map();
+  function addModuleNode(ref) {
+    if (builder.hasNode(ref.id)) return;
+    builder.addNode({
+      id: ref.id,
+      label: ref.label,
+      sourceFile: ref.external ? "<external>" : ref.id,
+      sourceLocation: "L1"
+    });
+  }
+  function resolveHeritageTarget(name) {
+    const resolved = nameIndex.get(name);
+    if (resolved) return resolved;
+    const extId = externalId(name);
+    if (!builder.hasNode(extId)) {
+      builder.addNode({ id: extId, label: name, sourceFile: "<external>", sourceLocation: "L0" });
+    }
+    return extId;
+  }
+  function handleTopLevelMethod(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const id = entityId(sourceFile, name);
+    builder.addNode({ id, label: `function ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, id);
+    functionNodeMap.set(node.id, id);
+  }
+  function handleClassOrModule(node, kind) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const id = entityId(sourceFile, name);
+    builder.addNode({ id, label: `${kind} ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, id);
+    typeMethods.set(id, /* @__PURE__ */ new Map());
+    if (kind === "class") {
+      const superclass = node.childForFieldName("superclass");
+      const base = superclass ? namedChildren(superclass)[0] : void 0;
+      if (base) {
+        builder.addEdge({
+          source: id,
+          target: resolveHeritageTarget(base.text),
+          relation: "inherits",
+          confidence: "EXTRACTED"
+        });
+      }
+    }
+    const body = node.childForFieldName("body");
+    if (!body) return;
+    const methods = typeMethods.get(id);
+    for (const member of namedChildren(body)) {
+      if (member.type === "method") {
+        const methodName = member.childForFieldName("name")?.text ?? "(anonymous)";
+        const methodId = entityId(sourceFile, `${name}.${methodName}`);
+        builder.addNode({
+          id: methodId,
+          label: `method ${name}.${methodName}`,
+          sourceFile,
+          sourceLocation: lineOf(member)
+        });
+        builder.addEdge({ source: id, target: methodId, relation: "method", confidence: "EXTRACTED" });
+        methods?.set(methodName, methodId);
+        functionNodeMap.set(member.id, methodId);
+        enclosingTypeOf.set(member.id, id);
+      } else if (member.type === "call") {
+        const methodField = member.childForFieldName("method")?.text;
+        if (methodField !== "include" && methodField !== "extend" && methodField !== "prepend") continue;
+        const args = member.childForFieldName("arguments");
+        for (const arg of args ? namedChildren(args) : []) {
+          if (arg.type !== "constant" && arg.type !== "scoped_constant") continue;
+          builder.addEdge({
+            source: id,
+            target: resolveHeritageTarget(arg.text),
+            relation: "mixes_in",
+            confidence: "EXTRACTED"
+          });
+        }
+      }
+    }
+  }
+  for (const child of namedChildren(root)) {
+    switch (child.type) {
+      case "method":
+        handleTopLevelMethod(child);
+        break;
+      case "class":
+        handleClassOrModule(child, "class");
+        break;
+      case "module":
+        handleClassOrModule(child, "module");
+        break;
+      default:
+        break;
+    }
+  }
+  function closestTrackedCaller(node) {
+    let current = node.parent;
+    while (current) {
+      const tracked = functionNodeMap.get(current.id);
+      if (tracked) return tracked;
+      current = current.parent;
+    }
+    return fileId;
+  }
+  function closestEnclosingTypeMethods(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "method") {
+        const typeId = enclosingTypeOf.get(current.id);
+        if (typeId !== void 0) return typeMethods.get(typeId);
+      }
+      current = current.parent;
+    }
+    return void 0;
+  }
+  const allCalls = descendantsOfType(root, ["call"]);
+  const requireCallIds = /* @__PURE__ */ new Set();
+  for (const call of allCalls) {
+    const methodName = call.childForFieldName("method")?.text;
+    if (methodName !== "require" && methodName !== "require_relative") continue;
+    const args = call.childForFieldName("arguments");
+    const soleArg = args ? namedChildren(args) : [];
+    if (soleArg.length !== 1) continue;
+    const literal = stringLiteralContent(soleArg[0]);
+    if (literal === null) continue;
+    requireCallIds.add(call.id);
+    const ref = resolveModuleRef(sourceFile, literal);
+    addModuleNode(ref);
+    builder.addEdge({ source: fileId, target: ref.id, relation: "imports", confidence: "EXTRACTED" });
+    importIndex.set(conventionalConstantName(literal), ref);
+  }
+  for (const call of allCalls) {
+    if (requireCallIds.has(call.id)) continue;
+    const methodName = call.childForFieldName("method")?.text;
+    if (!methodName) continue;
+    const receiver = call.childForFieldName("receiver");
+    let targetId = null;
+    let confidence = "EXTRACTED";
+    if (!receiver) {
+      const viaEnclosingType = closestEnclosingTypeMethods(call)?.get(methodName);
+      if (viaEnclosingType) {
+        targetId = viaEnclosingType;
+      } else {
+        const sameFile = nameIndex.get(methodName);
+        if (sameFile) targetId = sameFile;
+      }
+    } else if (receiver.type === "self") {
+      const methodId = closestEnclosingTypeMethods(call)?.get(methodName);
+      if (methodId) targetId = methodId;
+    } else if (receiver.type === "constant" || receiver.type === "scoped_constant") {
+      const sameFileTypeId = nameIndex.get(receiver.text);
+      const methodId = sameFileTypeId ? typeMethods.get(sameFileTypeId)?.get(methodName) : void 0;
+      if (methodId) {
+        targetId = methodId;
+      } else {
+        const viaImport = importIndex.get(receiver.text);
+        if (viaImport) {
+          targetId = viaImport.id;
+          confidence = "INFERRED";
+        }
+      }
+    }
+    if (!targetId) continue;
+    const callerId = closestTrackedCaller(call);
+    builder.addEdge({ source: callerId, target: targetId, relation: "calls", confidence });
+  }
+  return builder.build();
+}
+
+// src/extractors/rust.ts
+init_cjs_shims();
+var fs10 = __toESM(require("fs/promises"), 1);
+function convertUsePath(segments) {
+  const first = segments[0];
+  if (first === "crate" || first === "self") {
+    const rest = segments.slice(1);
+    return rest.length ? `./${rest.join("/")}` : ".";
+  }
+  if (first === "super") {
+    let i = 0;
+    while (segments[i] === "super") i++;
+    const ups = Array.from({ length: i }, () => "..").join("/");
+    const rest = segments.slice(i);
+    return rest.length ? `${ups}/${rest.join("/")}` : ups;
+  }
+  return segments.join("::");
+}
+async function extractRust(filePath) {
+  const parser = await createParser("rust");
+  const raw = await fs10.readFile(filePath);
+  const content = raw.toString("utf-8");
+  const tree = parser.parse(content);
+  if (!tree) {
+    throw new Error(`extractRust: parser produced no tree for ${filePath}`);
+  }
+  const root = tree.rootNode;
+  const sourceFile = toPosix(filePath);
+  const builder = new ExtractionBuilder();
+  const fileId = sourceFile;
+  builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
+  const nameIndex = /* @__PURE__ */ new Map();
+  const functionNodeMap = /* @__PURE__ */ new Map();
+  const typeMethods = /* @__PURE__ */ new Map();
+  const enclosingTypeOf = /* @__PURE__ */ new Map();
+  const importIndex = /* @__PURE__ */ new Map();
+  function addModuleNode(ref) {
+    if (builder.hasNode(ref.id)) return;
+    builder.addNode({
+      id: ref.id,
+      label: ref.label,
+      sourceFile: ref.external ? "<external>" : ref.id,
+      sourceLocation: "L1"
+    });
+  }
+  function resolveTypeTarget(name) {
+    const resolved = nameIndex.get(name);
+    if (resolved) return resolved;
+    const extId = externalId(name);
+    if (!builder.hasNode(extId)) {
+      builder.addNode({ id: extId, label: name, sourceFile: "<external>", sourceLocation: "L0" });
+    }
+    return extId;
+  }
+  function processUseArgument(node) {
+    switch (node.type) {
+      case "identifier": {
+        const ref = resolveModuleRef(sourceFile, convertUsePath([node.text]));
+        addModuleNode(ref);
+        importIndex.set(node.text, ref);
+        builder.addEdge({ source: fileId, target: ref.id, relation: "imports", confidence: "EXTRACTED" });
+        break;
+      }
+      case "scoped_identifier": {
+        const pathNode = node.childForFieldName("path");
+        const nameNode = node.childForFieldName("name");
+        if (!pathNode || !nameNode) break;
+        const ref = resolveModuleRef(sourceFile, convertUsePath(pathNode.text.split("::")));
+        addModuleNode(ref);
+        importIndex.set(nameNode.text, ref);
+        builder.addEdge({ source: fileId, target: ref.id, relation: "imports_from", confidence: "EXTRACTED" });
+        break;
+      }
+      case "use_as_clause": {
+        const pathNode = node.childForFieldName("path");
+        const aliasNode = node.childForFieldName("alias");
+        if (!pathNode || !aliasNode) break;
+        const ref = resolveModuleRef(sourceFile, convertUsePath(pathNode.text.split("::")));
+        addModuleNode(ref);
+        importIndex.set(aliasNode.text, ref);
+        builder.addEdge({ source: fileId, target: ref.id, relation: "imports", confidence: "EXTRACTED" });
+        break;
+      }
+      case "scoped_use_list": {
+        const pathNode = node.childForFieldName("path");
+        const listNode = node.childForFieldName("list");
+        if (!listNode) break;
+        const prefixSegments = pathNode ? pathNode.text.split("::") : [];
+        const ref = resolveModuleRef(sourceFile, convertUsePath(prefixSegments));
+        addModuleNode(ref);
+        let sawItem = false;
+        for (const item of namedChildren(listNode)) {
+          sawItem = true;
+          if (item.type === "identifier") {
+            importIndex.set(item.text, ref);
+          } else if (item.type === "use_as_clause") {
+            const alias = item.childForFieldName("alias")?.text;
+            if (alias) importIndex.set(alias, ref);
+          }
+        }
+        if (sawItem) {
+          builder.addEdge({ source: fileId, target: ref.id, relation: "imports_from", confidence: "EXTRACTED" });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  function handleStructItem(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const id = entityId(sourceFile, name);
+    builder.addNode({ id, label: `struct ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, id);
+    typeMethods.set(id, /* @__PURE__ */ new Map());
+  }
+  function handleTraitItem(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const id = entityId(sourceFile, name);
+    builder.addNode({ id, label: `trait ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, id);
+  }
+  function handleFunctionItem(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const id = entityId(sourceFile, name);
+    builder.addNode({ id, label: `function ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, id);
+    functionNodeMap.set(node.id, id);
+  }
+  function handleImplItem(node) {
+    const typeName = node.childForFieldName("type")?.text;
+    if (!typeName) return;
+    const typeId = resolveTypeTarget(typeName);
+    const traitName = node.childForFieldName("trait")?.text;
+    if (traitName) {
+      builder.addEdge({
+        source: typeId,
+        target: resolveTypeTarget(traitName),
+        relation: "implements",
+        confidence: "EXTRACTED"
+      });
+    }
+    let methods = typeMethods.get(typeId);
+    if (!methods) {
+      methods = /* @__PURE__ */ new Map();
+      typeMethods.set(typeId, methods);
+    }
+    const body = node.childForFieldName("body");
+    if (!body) return;
+    for (const member of namedChildren(body)) {
+      if (member.type !== "function_item") continue;
+      const methodName = member.childForFieldName("name")?.text ?? "(anonymous)";
+      const methodId = entityId(sourceFile, `${typeName}.${methodName}`);
+      builder.addNode({
+        id: methodId,
+        label: `method ${typeName}.${methodName}`,
+        sourceFile,
+        sourceLocation: lineOf(member)
+      });
+      builder.addEdge({ source: typeId, target: methodId, relation: "method", confidence: "EXTRACTED" });
+      methods.set(methodName, methodId);
+      functionNodeMap.set(member.id, methodId);
+      enclosingTypeOf.set(member.id, typeId);
+    }
+  }
+  const implNodes = [];
+  for (const child of namedChildren(root)) {
+    switch (child.type) {
+      case "use_declaration": {
+        const arg = child.childForFieldName("argument");
+        if (arg) processUseArgument(arg);
+        break;
+      }
+      case "struct_item":
+        handleStructItem(child);
+        break;
+      case "trait_item":
+        handleTraitItem(child);
+        break;
+      case "function_item":
+        handleFunctionItem(child);
+        break;
+      case "impl_item":
+        implNodes.push(child);
+        break;
+      default:
+        break;
+    }
+  }
+  for (const impl of implNodes) handleImplItem(impl);
+  function closestTrackedCaller(node) {
+    let current = node.parent;
+    while (current) {
+      const tracked = functionNodeMap.get(current.id);
+      if (tracked) return tracked;
+      current = current.parent;
+    }
+    return fileId;
+  }
+  function closestEnclosingTypeMethods(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "function_item") {
+        const typeId = enclosingTypeOf.get(current.id);
+        if (typeId !== void 0) return typeMethods.get(typeId);
+      }
+      current = current.parent;
+    }
+    return void 0;
+  }
+  for (const call of descendantsOfType(root, ["call_expression"])) {
+    const fn = call.childForFieldName("function");
+    if (!fn) continue;
+    let targetId = null;
+    let confidence = "EXTRACTED";
+    if (fn.type === "identifier") {
+      const name = fn.text;
+      const sameFile = nameIndex.get(name);
+      if (sameFile) {
+        targetId = sameFile;
+      } else {
+        const viaImport = importIndex.get(name);
+        if (viaImport) {
+          targetId = viaImport.id;
+          confidence = "INFERRED";
+        }
+      }
+    } else if (fn.type === "field_expression") {
+      const value = fn.childForFieldName("value");
+      const field = fn.childForFieldName("field")?.text;
+      if (value && field) {
+        if (value.type === "self") {
+          const methodId = closestEnclosingTypeMethods(call)?.get(field);
+          if (methodId) targetId = methodId;
+        }
+      }
+    } else if (fn.type === "scoped_identifier") {
+      const path11 = fn.childForFieldName("path")?.text;
+      const name = fn.childForFieldName("name")?.text;
+      if (path11 && name) {
+        const viaImport = importIndex.get(path11);
+        if (viaImport) {
+          targetId = viaImport.id;
+          confidence = "INFERRED";
+        }
+      }
+    }
+    if (!targetId) continue;
+    const callerId = closestTrackedCaller(call);
+    builder.addEdge({ source: callerId, target: targetId, relation: "calls", confidence });
+  }
+  return builder.build();
+}
+
+// src/extractors/typescript.ts
+init_cjs_shims();
+var fs11 = __toESM(require("fs/promises"), 1);
+var path5 = __toESM(require("path"), 1);
+function grammarForExtension(ext) {
+  const lower = ext.toLowerCase();
+  if (lower === ".tsx") return "tsx";
+  if (lower === ".jsx") return "javascript";
+  if (lower === ".ts" || lower === ".mts" || lower === ".cts") return "typescript";
+  return "javascript";
+}
+function stripQuotes2(text) {
+  if (text.length >= 2) {
+    const first = text[0];
+    const last = text[text.length - 1];
+    if ((first === '"' || first === "'" || first === "`") && first === last) {
+      return text.slice(1, -1);
+    }
+  }
+  return text;
+}
+function firstStringArgument(call) {
+  const args = call.childForFieldName("arguments");
+  if (!args) return null;
+  const first = namedChildren(args)[0];
+  if (!first || first.type !== "string") return null;
+  return stripQuotes2(first.text);
+}
+async function extractTypeScript(filePath) {
+  const ext = path5.extname(filePath);
+  const grammar = grammarForExtension(ext);
+  const parser = await createParser(grammar);
+  const raw = await fs11.readFile(filePath);
+  const content = raw.toString("utf-8");
+  const tree = parser.parse(content);
+  if (!tree) {
+    throw new Error(`extractTypeScript: parser produced no tree for ${filePath}`);
+  }
+  const root = tree.rootNode;
+  const sourceFile = toPosix(filePath);
+  const builder = new ExtractionBuilder();
+  const fileId = sourceFile;
+  builder.addNode({ id: fileId, label: sourceFile, sourceFile, sourceLocation: "L1" });
+  const nameIndex = /* @__PURE__ */ new Map();
+  const functionNodeMap = /* @__PURE__ */ new Map();
+  const classMethods = /* @__PURE__ */ new Map();
+  const enclosingClassOf = /* @__PURE__ */ new Map();
+  const importIndex = /* @__PURE__ */ new Map();
+  function addModuleNode(ref) {
+    if (builder.hasNode(ref.id)) return;
+    builder.addNode({
+      id: ref.id,
+      label: ref.label,
+      sourceFile: ref.external ? "<external>" : ref.id,
+      sourceLocation: "L1"
+    });
+  }
+  function importTargetId(binding, property) {
+    if (!binding.ref.external) {
+      if (binding.kind === "named" && binding.importedName) {
+        return entityId(binding.ref.id, binding.importedName);
+      }
+      if (binding.kind === "namespace" && property) {
+        return entityId(binding.ref.id, property);
+      }
+    }
+    return binding.ref.id;
+  }
+  function resolveHeritageTarget(name) {
+    const resolved = nameIndex.get(name);
+    if (resolved) return resolved;
+    const extId = externalId(name);
+    if (!builder.hasNode(extId)) {
+      builder.addNode({ id: extId, label: name, sourceFile: "<external>", sourceLocation: "L0" });
+    }
+    return extId;
+  }
+  function handleFunctionDeclaration(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const id = entityId(sourceFile, name);
+    builder.addNode({ id, label: `function ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, id);
+    functionNodeMap.set(node.id, id);
+  }
+  function registerRequireBinding(nameNode, ref) {
+    if (nameNode.type === "identifier") {
+      importIndex.set(nameNode.text, { ref, kind: "namespace" });
+      return;
+    }
+    if (nameNode.type === "object_pattern") {
+      for (const prop of namedChildren(nameNode)) {
+        if (prop.type === "shorthand_property_identifier_pattern") {
+          importIndex.set(prop.text, { ref, importedName: prop.text, kind: "named" });
+        } else if (prop.type === "pair_pattern") {
+          const key = prop.childForFieldName("key")?.text;
+          const value = prop.childForFieldName("value")?.text;
+          if (key && value) importIndex.set(value, { ref, importedName: key, kind: "named" });
+        }
+      }
+    }
+  }
+  function handleTopLevelVariableFunctions(node) {
+    for (const declarator of namedChildren(node)) {
+      if (declarator.type !== "variable_declarator") continue;
+      const value = declarator.childForFieldName("value");
+      if (!value) continue;
+      if (value.type === "arrow_function" || value.type === "function_expression") {
+        const name = declarator.childForFieldName("name")?.text;
+        if (!name) continue;
+        const id = entityId(sourceFile, name);
+        builder.addNode({ id, label: `function ${name}`, sourceFile, sourceLocation: lineOf(declarator) });
+        builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+        nameIndex.set(name, id);
+        functionNodeMap.set(value.id, id);
+        continue;
+      }
+      if (value.type === "call_expression") {
+        const callee = value.childForFieldName("function");
+        const specifier = callee?.type === "identifier" && callee.text === "require" ? firstStringArgument(value) : null;
+        if (specifier) {
+          const nameNode = declarator.childForFieldName("name");
+          if (nameNode) {
+            const ref = resolveModuleRef(sourceFile, specifier);
+            addModuleNode(ref);
+            registerRequireBinding(nameNode, ref);
+          }
+        }
+      }
+    }
+  }
+  function handleInterfaceDeclaration(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const id = entityId(sourceFile, name);
+    builder.addNode({ id, label: `interface ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, id);
+  }
+  function handleClassDeclaration(node) {
+    const name = node.childForFieldName("name")?.text ?? "(anonymous)";
+    const classId = entityId(sourceFile, name);
+    builder.addNode({ id: classId, label: `class ${name}`, sourceFile, sourceLocation: lineOf(node) });
+    builder.addEdge({ source: fileId, target: classId, relation: "contains", confidence: "EXTRACTED" });
+    nameIndex.set(name, classId);
+    functionNodeMap.set(node.id, classId);
+    const heritage = namedChildren(node).find((c) => c.type === "class_heritage");
+    if (heritage) {
+      for (const clause of namedChildren(heritage)) {
+        if (clause.type === "extends_clause") {
+          const base = clause.childForFieldName("value")?.text;
+          if (base) {
+            builder.addEdge({
+              source: classId,
+              target: resolveHeritageTarget(base),
+              relation: "inherits",
+              confidence: "EXTRACTED"
+            });
+          }
+        } else if (clause.type === "implements_clause") {
+          for (const iface of namedChildren(clause)) {
+            builder.addEdge({
+              source: classId,
+              target: resolveHeritageTarget(iface.text),
+              relation: "implements",
+              confidence: "EXTRACTED"
+            });
+          }
+        }
+      }
+    }
+    const methods = /* @__PURE__ */ new Map();
+    classMethods.set(node.id, methods);
+    const body = node.childForFieldName("body");
+    if (body) {
+      for (const member of namedChildren(body)) {
+        if (member.type !== "method_definition") continue;
+        const methodName = member.childForFieldName("name")?.text ?? "(anonymous)";
+        const methodId = entityId(sourceFile, `${name}.${methodName}`);
+        builder.addNode({
+          id: methodId,
+          label: `method ${name}.${methodName}`,
+          sourceFile,
+          sourceLocation: lineOf(member)
+        });
+        builder.addEdge({ source: classId, target: methodId, relation: "method", confidence: "EXTRACTED" });
+        methods.set(methodName, methodId);
+        functionNodeMap.set(member.id, methodId);
+        enclosingClassOf.set(member.id, node.id);
+      }
+    }
+  }
+  function handleImport(node) {
+    const sourceNode = node.childForFieldName("source");
+    if (!sourceNode) return;
+    const ref = resolveModuleRef(sourceFile, stripQuotes2(sourceNode.text));
+    addModuleNode(ref);
+    const clause = namedChildren(node).find((c) => c.type === "import_clause");
+    if (!clause) return;
+    let sawNamed = false;
+    let sawWhole = false;
+    for (const child of namedChildren(clause)) {
+      if (child.type === "named_imports") {
+        sawNamed = true;
+        for (const specifierNode of namedChildren(child)) {
+          const importedName = specifierNode.childForFieldName("name")?.text;
+          const localName = specifierNode.childForFieldName("alias")?.text ?? importedName;
+          if (localName) importIndex.set(localName, { ref, importedName, kind: "named" });
+        }
+      } else if (child.type === "namespace_import") {
+        sawWhole = true;
+        const localName = namedChildren(child)[0]?.text;
+        if (localName) importIndex.set(localName, { ref, kind: "namespace" });
+      } else if (child.type === "identifier") {
+        sawWhole = true;
+        importIndex.set(child.text, { ref, kind: "default" });
+      }
+    }
+    if (sawNamed) {
+      builder.addEdge({ source: fileId, target: ref.id, relation: "imports_from", confidence: "EXTRACTED" });
+    }
+    if (sawWhole) {
+      builder.addEdge({ source: fileId, target: ref.id, relation: "imports", confidence: "EXTRACTED" });
+    }
+  }
+  function handleReExport(node) {
+    const sourceNode = node.childForFieldName("source");
+    if (!sourceNode) return;
+    const ref = resolveModuleRef(sourceFile, stripQuotes2(sourceNode.text));
+    addModuleNode(ref);
+    builder.addEdge({ source: fileId, target: ref.id, relation: "re_exports", confidence: "EXTRACTED" });
+  }
+  function unwrapExport(node) {
+    if (node.type !== "export_statement") return node;
+    return node.childForFieldName("declaration");
+  }
+  for (const child of namedChildren(root)) {
+    if (child.type === "import_statement") {
+      handleImport(child);
+      continue;
+    }
+    if (child.type === "export_statement" && child.childForFieldName("source")) {
+      handleReExport(child);
+      continue;
+    }
+    const effective = unwrapExport(child);
+    if (!effective) continue;
+    switch (effective.type) {
+      case "function_declaration":
+      case "generator_function_declaration":
+        handleFunctionDeclaration(effective);
+        break;
+      case "class_declaration":
+        handleClassDeclaration(effective);
+        break;
+      case "interface_declaration":
+        handleInterfaceDeclaration(effective);
+        break;
+      case "lexical_declaration":
+      case "variable_declaration":
+        handleTopLevelVariableFunctions(effective);
+        break;
+      default:
+        break;
+    }
+  }
+  function closestTrackedCaller(node) {
+    let current = node.parent;
+    while (current) {
+      const tracked = functionNodeMap.get(current.id);
+      if (tracked) return tracked;
+      current = current.parent;
+    }
+    return fileId;
+  }
+  function closestEnclosingClassMethods(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "method_definition") {
+        const classNodeId = enclosingClassOf.get(current.id);
+        if (classNodeId !== void 0) return classMethods.get(classNodeId);
+      }
+      current = current.parent;
+    }
+    return void 0;
+  }
+  for (const call of descendantsOfType(root, ["call_expression"])) {
+    const fn = call.childForFieldName("function");
+    if (!fn) continue;
+    if (fn.type === "identifier" && fn.text === "require" || fn.type === "import") {
+      const specifier = firstStringArgument(call);
+      if (specifier) {
+        const ref = resolveModuleRef(sourceFile, specifier);
+        addModuleNode(ref);
+        builder.addEdge({
+          source: closestTrackedCaller(call),
+          target: ref.id,
+          relation: "imports",
+          confidence: "EXTRACTED"
+        });
+        continue;
+      }
+    }
+    let targetId = null;
+    let confidence = "EXTRACTED";
+    if (fn.type === "identifier") {
+      const name = fn.text;
+      const sameFile = nameIndex.get(name);
+      if (sameFile) {
+        targetId = sameFile;
+      } else {
+        const binding = importIndex.get(name);
+        if (binding) {
+          targetId = importTargetId(binding);
+          confidence = "INFERRED";
+        }
+      }
+    } else if (fn.type === "member_expression") {
+      const object = fn.childForFieldName("object");
+      const property = fn.childForFieldName("property")?.text;
+      if (object && property) {
+        if (object.type === "this") {
+          const methodId = closestEnclosingClassMethods(call)?.get(property);
+          if (methodId) targetId = methodId;
+        } else if (object.type === "identifier") {
+          const binding = importIndex.get(object.text);
+          if (binding) {
+            targetId = importTargetId(binding, property);
+            confidence = "INFERRED";
+          }
+        }
+      }
+    }
+    if (!targetId) continue;
+    const callerId = closestTrackedCaller(call);
+    builder.addEdge({ source: callerId, target: targetId, relation: "calls", confidence });
+  }
+  return builder.build();
+}
+
+// src/extract.ts
+var EXTRACTOR_REGISTRY = {
+  ".ts": extractTypeScript,
+  ".tsx": extractTypeScript,
+  ".js": extractTypeScript,
+  ".jsx": extractTypeScript,
+  ".mjs": extractTypeScript,
+  ".cjs": extractTypeScript,
+  ".mts": extractTypeScript,
+  ".cts": extractTypeScript,
+  ".py": extractPython,
+  ".go": extractGo,
+  ".rs": extractRust,
+  ".java": extractJava,
+  ".cs": extractCSharp,
+  ".rb": extractRuby
+};
+async function extract(filePath) {
+  const ext = path6.extname(filePath);
+  const extractor = EXTRACTOR_REGISTRY[ext];
+  if (!extractor) {
+    return { nodes: [], edges: [] };
+  }
+  return extractor(filePath);
+}
+
+// src/report.ts
+init_cjs_shims();
+function labelOf2(graph, id) {
+  return graph.getNodeAttribute(id, "label") ?? id;
+}
+function bulletList(items) {
+  if (items.length === 0) return "_None found._";
+  return items.map((item) => `- ${item}`).join("\n");
+}
+function summarizeCommunities(graph) {
+  const byCommunity = /* @__PURE__ */ new Map();
+  graph.forEachNode((nodeId, attributes) => {
+    const community = attributes.community;
+    if (community === void 0) return;
+    const label = attributes.communityLabel ?? `community-${community}`;
+    const existing = byCommunity.get(community);
+    if (existing) {
+      existing.members.push(nodeId);
+    } else {
+      byCommunity.set(community, { label, members: [nodeId] });
+    }
+  });
+  const summaries = [...byCommunity.values()];
+  for (const summary of summaries) {
+    summary.members.sort((a, b) => a.localeCompare(b));
+  }
+  summaries.sort((a, b) => b.members.length - a.members.length || a.label.localeCompare(b.label));
+  return summaries;
+}
+function renderReport(graph, analysis, now = /* @__PURE__ */ new Date()) {
+  const generatedAt = now.toISOString();
+  const communities = summarizeCommunities(graph);
+  const lines = [];
+  lines.push("# Graph Report");
+  lines.push("");
+  lines.push(`Generated: ${generatedAt}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`- **Nodes:** ${graph.order}`);
+  lines.push(`- **Edges:** ${graph.size}`);
+  lines.push(`- **Communities:** ${communities.length}`);
+  lines.push(`- **God nodes:** ${analysis.godNodes.length}`);
+  lines.push("");
+  lines.push("## Communities");
+  lines.push("");
+  if (communities.length === 0) {
+    lines.push("_No communities detected (graph may be empty, or cluster() has not run yet)._");
+  } else {
+    for (const community of communities) {
+      lines.push(`### ${community.label} (${community.members.length} member(s))`);
+      lines.push("");
+      const shown = community.members.slice(0, 25).map((id) => labelOf2(graph, id));
+      lines.push(bulletList(shown));
+      if (community.members.length > 25) {
+        lines.push(`- ...and ${community.members.length - 25} more`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("## God Nodes");
+  lines.push("");
+  lines.push(
+    "Nodes with unusually high fan-in + fan-out relative to the rest of this graph \u2014 often a sign of a shared utility, a bottleneck, or a module that has taken on too many responsibilities."
+  );
+  lines.push("");
+  lines.push(bulletList(analysis.godNodes.map((id) => labelOf2(graph, id))));
+  lines.push("");
+  lines.push("## Structural Surprises");
+  lines.push("");
+  lines.push(bulletList(analysis.surprises));
+  lines.push("");
+  lines.push("## Open Questions");
+  lines.push("");
+  lines.push(bulletList(analysis.openQuestions));
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/pipeline.ts
+async function runPipeline(root, options = {}) {
+  const progress = options.onProgress ?? (() => {
+  });
+  const resolvedRoot = path7.resolve(root);
+  progress(`Scanning ${resolvedRoot} ...`);
+  const manifest = collectFiles(resolvedRoot);
+  progress(
+    `Found ${manifest.totalFiles} file(s) (${manifest.files.code.length} code, ${manifest.skippedSensitive.length} skipped as sensitive).`
+  );
+  progress("Extracting...");
+  const extractions = [];
+  for (const relFile of manifest.files.code.sort((a, b) => a.localeCompare(b))) {
+    const filePath = path7.relative(process.cwd(), path7.join(resolvedRoot, relFile)) || relFile;
+    try {
+      const extraction = await extract(filePath);
+      extractions.push(extraction);
+    } catch (error) {
+      progress(`  extraction failed for ${relFile}: ${error.message}`);
+      throw error;
+    }
+  }
+  progress("Building graph...");
+  const graph = buildGraph(extractions);
+  progress(`Clustering (${options.algorithm ?? "louvain"})...`);
+  cluster(graph, { algorithm: options.algorithm, maxIterations: options.maxIterations });
+  progress("Analyzing...");
+  const analysis = analyze(graph);
+  progress("Rendering report...");
+  const report = renderReport(graph, analysis);
+  const outDir = options.outDir ?? path7.join(resolvedRoot, "graphify-out");
+  progress(`Exporting to ${outDir} ...`);
+  await exportGraph(
+    graph,
+    {
+      outDir,
+      html: options.html,
+      svg: options.svg,
+      graphml: options.graphml,
+      neo4j: options.neo4j,
+      obsidian: options.obsidian
+    },
+    report
+  );
+  progress("Done.");
+  return { manifest, graph, analysis, report };
+}
+
+// src/cli/index.ts
+init_security();
+
+// src/cli/commands/explain.ts
+init_cjs_shims();
+init_graphStore();
+init_query();
+async function runExplain(nodeName) {
+  const graph = await loadGraph();
+  const result = explainNode(graph, nodeName);
+  if (!result) {
+    console.log(`No node matched "${nodeName}".`);
+    return;
+  }
+  const location = result.sourceLocation ? `:${result.sourceLocation}` : "";
+  console.log(result.label);
+  console.log(`  location: ${result.sourceFile}${location}`);
+  if (result.communityLabel) {
+    console.log(`  community: ${result.communityLabel}`);
+  }
+  console.log("");
+  console.log(`Calls / references out (${result.outgoing.length}):`);
+  if (result.outgoing.length === 0) {
+    console.log("  (none)");
+  } else {
+    for (const edge of result.outgoing) {
+      console.log(`  --${edge.relation}--> ${edge.target} (${edge.confidence})`);
+    }
+  }
+  console.log("");
+  console.log(`Referenced by (${result.incoming.length}):`);
+  if (result.incoming.length === 0) {
+    console.log("  (none)");
+  } else {
+    for (const edge of result.incoming) {
+      console.log(`  ${edge.source} --${edge.relation}--> (${edge.confidence})`);
+    }
+  }
+}
+
+// src/cli/commands/install.ts
+init_cjs_shims();
+var import_node_module3 = require("module");
+var fs12 = __toESM(require("fs/promises"), 1);
+var path8 = __toESM(require("path"), 1);
+var require4 = (0, import_node_module3.createRequire)(importMetaUrl);
+function packageRoot() {
+  const packageJsonPath = require4.resolve("@dreamtree-org/graphify/package.json");
+  return path8.dirname(packageJsonPath);
+}
+async function runInstall(cwd = process.cwd()) {
+  const sourcePath = path8.join(packageRoot(), "src", "skill", "SKILL.md");
+  const content = await fs12.readFile(sourcePath, "utf-8");
+  const results = [];
+  const claudeCodeDir = path8.join(cwd, ".claude", "skills", "graphify");
+  await fs12.mkdir(claudeCodeDir, { recursive: true });
+  const claudeCodePath = path8.join(claudeCodeDir, "SKILL.md");
+  await fs12.writeFile(claudeCodePath, content, "utf-8");
+  results.push({ host: "Claude Code", path: claudeCodePath });
+  for (const result of results) {
+    console.log(`Installed graphify skill for ${result.host} -> ${result.path}`);
+  }
+  console.log("");
+  console.log(
+    "Other hosts (Cursor, etc.) are not implemented yet by `graphify install` \u2014 see ARCHITECTURE.md."
+  );
+  return results;
+}
+
+// src/cli/commands/path.ts
+init_cjs_shims();
+init_graphStore();
+init_query();
+async function runPath(fromNode, toNode) {
+  const graph = await loadGraph();
+  const result = shortestPath(graph, fromNode, toNode);
+  if (!result) {
+    console.log(`Could not resolve "${fromNode}" and/or "${toNode}" to a node in the graph.`);
+    return;
+  }
+  if (!result.found) {
+    console.log(
+      `No path found between "${result.from.label}" and "${result.to.label}" \u2014 they may be in disconnected parts of the graph (see GRAPH_REPORT.md \xA7 Open Questions).`
+    );
+    return;
+  }
+  console.log(`${result.from.label} -> ${result.to.label} (${result.path.length} node(s)):`);
+  console.log(`  ${result.path.join(" -> ")}`);
+  if (result.edges.length > 0) {
+    console.log("");
+    console.log("Edges along the path:");
+    for (const edge of result.edges) {
+      console.log(`  ${edge.source} --${edge.relation}--> ${edge.target} (${edge.confidence})`);
+    }
+  }
+}
+
+// src/cli/commands/query.ts
+init_cjs_shims();
+init_graphStore();
+init_query();
+async function runQuery(question, options = {}) {
+  const graph = await loadGraph();
+  const result = queryGraph(graph, question, { dfs: options.dfs, budget: options.budget });
+  if (result.seeds.length === 0) {
+    console.log(
+      `No nodes matched "${question}". Try different keywords, or run \`graphify explain <node>\` if you already know the name.`
+    );
+    return;
+  }
+  console.log(`Matched ${result.seeds.length} seed node(s):`);
+  for (const seed of result.seeds) {
+    console.log(`  - ${seed.label} (${seed.id})`);
+  }
+  console.log("");
+  console.log(`Context \u2014 ${result.visited.length} node(s), ${options.dfs ? "DFS" : "BFS"} traversal:`);
+  for (const node of result.visited) {
+    const location = node.sourceLocation ? `:${node.sourceLocation}` : "";
+    console.log(`  [depth ${node.depth}] ${node.label} \u2014 ${node.sourceFile}${location}`);
+  }
+  console.log("");
+  console.log(`Edges within this context (${result.edges.length}):`);
+  for (const edge of result.edges) {
+    console.log(`  ${edge.source} --${edge.relation}--> ${edge.target} (${edge.confidence})`);
+  }
+}
+
+// src/cli/index.ts
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+function looksLikeGitUrl(value) {
+  if (!/^https?:\/\//i.test(value)) return false;
+  return /github\.com|gitlab\.com|bitbucket\.org/i.test(value) || value.endsWith(".git");
+}
+async function cloneRepo(url) {
+  const validated = validateUrl(url);
+  const dest = await fs13.mkdtemp(path10.join(os.tmpdir(), "graphify-clone-"));
+  await execFileAsync("git", ["clone", "--depth", "1", validated, dest]);
+  return dest;
+}
+function exportOptionsFrom(options) {
+  return { html: options.viz, svg: options.svg, graphml: options.graphml, neo4j: options.neo4j };
+}
+function clusterOptionsFrom(options) {
+  return {
+    algorithm: options.leiden ? "leiden" : "louvain",
+    maxIterations: options.maxIterations
+  };
+}
+async function runClusterOnly(root, options) {
+  const outDir = path10.join(root, "graphify-out");
+  const graph = await loadGraph(outDir);
+  cluster(graph, clusterOptionsFrom(options));
+  const analysis = analyze(graph);
+  const report = renderReport(graph, analysis);
+  await exportGraph(graph, { outDir, ...exportOptionsFrom(options) }, report);
+  console.error(`Re-clustered the existing graph (${clusterOptionsFrom(options).algorithm}).`);
+}
+async function watchAndRebuild(root, runOnce) {
+  const watcher = (0, import_chokidar.watch)(root, {
+    ignored: (filePath) => /(^|[/\\])(node_modules|\.git|graphify-out)([/\\]|$)/.test(filePath),
+    ignoreInitial: true
+  });
+  let timer = null;
+  let running = false;
+  const schedule = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      if (running) return;
+      running = true;
+      console.error("Change detected, rebuilding...");
+      runOnce().catch((error) => console.error(`graphify --watch: rebuild failed: ${error.message}`)).finally(() => {
+        running = false;
+      });
+    }, 300);
+  };
+  watcher.on("add", schedule).on("change", schedule).on("unlink", schedule);
+  await new Promise(() => {
+  });
+}
+var program = new import_commander.Command();
+program.name("graphify").description("Turn a folder of code/docs/papers into a queryable knowledge graph.").argument("[path]", "path to scan, or a GitHub URL", ".").option("--mode <mode>", "extraction mode (deep for richer INFERRED edges \u2014 reserved, no-op in v1)").option("--update", "incremental re-extract of changed files only (not implemented in v1 \u2014 runs full pipeline)").option("--watch", "rebuild on file change").option("--cluster-only", "rerun clustering on an existing graph").option("--leiden", "use Leiden instead of Louvain for community detection (v2 \u2014 better community quality)").option("--max-iterations <n>", "Leiden only: cap on outer iterations for very large graphs", Number).option("--no-viz", "skip graph.html").option("--svg", "also export graph.svg (not implemented in v1)").option("--graphml", "also export graph.graphml (not implemented in v1)").option("--neo4j", "generate graphify-out/cypher.txt for Neo4j (not implemented in v1)").option("--mcp", "start MCP stdio server instead of running the pipeline").action(async (targetArg, options) => {
+  try {
+    if (options.mcp) {
+      const outDir = path10.resolve(targetArg === "." ? process.cwd() : targetArg, "graphify-out");
+      const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+      await startServer2(path10.join(outDir, "graph.json"));
+      return;
+    }
+    let root = targetArg;
+    if (looksLikeGitUrl(targetArg)) {
+      console.error(`Cloning ${targetArg} ...`);
+      root = await cloneRepo(targetArg);
+    }
+    root = path10.resolve(root);
+    if (options.update) {
+      console.error(
+        "--update (incremental re-extract) is not implemented yet in v1 \u2014 running the full pipeline instead."
+      );
+    }
+    if (options.mode) {
+      console.error(`--mode ${options.mode} is reserved for a future richer-INFERRED-edges pass \u2014 currently a no-op.`);
+    }
+    if (options.clusterOnly) {
+      await runClusterOnly(root, options);
+      return;
+    }
+    const runOnce = () => runPipeline(root, {
+      ...exportOptionsFrom(options),
+      ...clusterOptionsFrom(options),
+      onProgress: (m) => console.error(m)
+    });
+    await runOnce();
+    if (options.watch) {
+      console.error(`Watching ${root} for changes (Ctrl+C to stop) ...`);
+      await watchAndRebuild(root, runOnce);
+    }
+  } catch (error) {
+    console.error(`graphify: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("query <question>").description("BFS (default) or DFS traversal answering a question against the existing graph").option("--dfs", "depth-first traversal (trace a specific path)").option("--budget <tokens>", "cap answer at N tokens", Number).action(async (question, options) => {
+  try {
+    await runQuery(question, options);
+  } catch (error) {
+    console.error(`graphify query: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("path <from> <to>").description("shortest path between two named nodes").action(async (from, to) => {
+  try {
+    await runPath(from, to);
+  } catch (error) {
+    console.error(`graphify path: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("explain <node>").description("plain-language explanation of a node").action(async (node) => {
+  try {
+    await runExplain(node);
+  } catch (error) {
+    console.error(`graphify explain: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("install").description("install the skill files into the local agent(s)").action(async () => {
+  try {
+    await runInstall();
+  } catch (error) {
+    console.error(`graphify install: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.parseAsync(process.argv);
+//# sourceMappingURL=index.cjs.map