@dreamtree-org/graphify 1.0.0

package/dist/chunk-DG5FECXV.js

@@ -0,0 +1,2474 @@
+import {
+  escapeHtml,
+  sanitizeLabel,
+  validateGraphPath
+} from "./chunk-5ANIDX3G.js";
+
+// src/detect.ts
+import * as fs from "fs";
+import * as path from "path";
+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 = fs.readFileSync(filePath);
+  return buf.toString("utf-8");
+}
+function collectFiles(root) {
+  const scanRoot = path.resolve(root);
+  const stat = fs.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 = fs.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 = path.join(dir, entry.name);
+      const relPath = path.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 = path.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
+import * as path4 from "path";
+
+// src/extractors/csharp.ts
+import * as fs2 from "fs/promises";
+
+// src/extractors/common.ts
+import * as path2 from "path";
+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(path2.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 = path2.posix.dirname(toPosix(sourceFile));
+    const joined = specifier.startsWith("/") ? specifier : path2.posix.join(dir, specifier);
+    const normalized = path2.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
+import { createRequire } from "module";
+import { Language, Parser } from "web-tree-sitter";
+var require2 = createRequire(import.meta.url);
+var initPromise = null;
+function ensureInitialized() {
+  if (!initPromise) {
+    initPromise = Parser.init();
+  }
+  return initPromise;
+}
+var languageCache = /* @__PURE__ */ new Map();
+async function loadLanguage(grammarName) {
+  await ensureInitialized();
+  let cached = languageCache.get(grammarName);
+  if (!cached) {
+    const wasmPath = require2.resolve(`tree-sitter-wasms/out/tree-sitter-${grammarName}.wasm`);
+    cached = Language.load(wasmPath);
+    languageCache.set(grammarName, cached);
+  }
+  return cached;
+}
+async function createParser(grammarName) {
+  const language = await loadLanguage(grammarName);
+  const parser = new Parser();
+  parser.setLanguage(language);
+  return parser;
+}
+
+// src/extractors/csharp.ts
+async function extractCSharp(filePath) {
+  const parser = await createParser("c_sharp");
+  const raw = await fs2.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
+import * as fs3 from "fs/promises";
+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 fs3.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
+import * as fs4 from "fs/promises";
+async function extractJava(filePath) {
+  const parser = await createParser("java");
+  const raw = await fs4.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
+import * as fs5 from "fs/promises";
+async function extractPython(filePath) {
+  const parser = await createParser("python");
+  const raw = await fs5.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
+import * as fs6 from "fs/promises";
+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 fs6.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
+import * as fs7 from "fs/promises";
+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 fs7.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 path7 = fn.childForFieldName("path")?.text;
+      const name = fn.childForFieldName("name")?.text;
+      if (path7 && name) {
+        const viaImport = importIndex.get(path7);
+        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
+import * as fs8 from "fs/promises";
+import * as path3 from "path";
+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 = path3.extname(filePath);
+  const grammar = grammarForExtension(ext);
+  const parser = await createParser(grammar);
+  const raw = await fs8.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 = path4.extname(filePath);
+  const extractor = EXTRACTOR_REGISTRY[ext];
+  if (!extractor) {
+    return { nodes: [], edges: [] };
+  }
+  return extractor(filePath);
+}
+
+// src/schema.ts
+import { z } from "zod";
+var ConfidenceSchema = z.enum(["EXTRACTED", "INFERRED", "AMBIGUOUS"]);
+var RelationSchema = z.enum([
+  "calls",
+  "imports",
+  "imports_from",
+  "inherits",
+  "implements",
+  "mixes_in",
+  "embeds",
+  "references",
+  "contains",
+  "method",
+  "re_exports"
+]);
+var GraphNodeSchema = z.object({
+  id: z.string().min(1, "node id must be non-empty"),
+  label: z.string(),
+  sourceFile: z.string(),
+  sourceLocation: z.string()
+});
+var GraphEdgeSchema = z.object({
+  source: z.string().min(1, "edge source must be non-empty"),
+  target: z.string().min(1, "edge target must be non-empty"),
+  relation: RelationSchema,
+  confidence: ConfidenceSchema
+});
+var ExtractionResultSchema = z.object({
+  nodes: z.array(GraphNodeSchema),
+  edges: 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
+import Graph from "graphology";
+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 Graph({ 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/cluster.ts
+import { createHash } from "crypto";
+import Graph2 from "graphology";
+import leiden from "@aflsolutions/graphology-communities-leiden";
+import louvain from "graphology-communities-louvain";
+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 Graph2({ 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 Graph2({ 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);
+    leiden.assign(undirected, { rng, maxIterations: options.maxIterations ?? 0 });
+    undirected.forEachNode((nodeId, attributes) => {
+      working.setNodeAttribute(nodeId, "community", attributes.community);
+    });
+    return;
+  }
+  louvain.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, 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/analyze.ts
+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/report.ts
+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/export.ts
+import { createRequire as createRequire2 } from "module";
+import * as fs9 from "fs/promises";
+import * as path5 from "path";
+var require3 = createRequire2(import.meta.url);
+function resolveVisNetworkAssets() {
+  const packageJsonPath = require3.resolve("vis-network/package.json");
+  const root = path5.dirname(packageJsonPath);
+  return {
+    jsPath: path5.join(root, "standalone", "umd", "vis-network.min.js"),
+    cssPath: path5.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([
+    fs9.readFile(jsPath, "utf-8"),
+    fs9.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 = path5.resolve(options.outDir);
+  await fs9.mkdir(outDir, { recursive: true });
+  const jsonPath = validateGraphPath("graph.json", outDir);
+  await fs9.writeFile(jsonPath, JSON.stringify(graph.toJSON(), null, 2), "utf-8");
+  if (options.html !== false) {
+    const htmlPath = validateGraphPath("graph.html", outDir);
+    await fs9.writeFile(htmlPath, await renderHtml(graph), "utf-8");
+  }
+  if (report !== void 0) {
+    const reportPath = validateGraphPath("GRAPH_REPORT.md", outDir);
+    await fs9.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/pipeline.ts
+import * as path6 from "path";
+async function runPipeline(root, options = {}) {
+  const progress = options.onProgress ?? (() => {
+  });
+  const resolvedRoot = path6.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 = path6.relative(process.cwd(), path6.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 ?? path6.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 };
+}
+
+export {
+  collectFiles,
+  EXTRACTOR_REGISTRY,
+  extract,
+  ExtractionResultSchema,
+  ExtractionValidationError,
+  validateExtraction,
+  buildGraph,
+  cluster,
+  analyze,
+  renderReport,
+  exportGraph,
+  runPipeline
+};
+//# sourceMappingURL=chunk-DG5FECXV.js.map