@titan-design/code-graph 0.1.0

package/dist/index.js

@@ -0,0 +1,2413 @@
+// src/store.ts
+import { openDatabase, runMigrations } from "@titan-design/store-sqlite";
+
+// src/schema.ts
+import { kitMigration } from "@titan-design/store-sqlite";
+var KIT = { snapshot: "snapshot", entitySnap: "node", cacheBlob: "blob_cache" };
+var KIT_EXTENSIONS = `
+  ALTER TABLE node ADD COLUMN language TEXT;
+  ALTER TABLE node ADD COLUMN role TEXT;
+  ALTER TABLE snapshot ADD COLUMN commit_hash TEXT;
+  ALTER TABLE snapshot ADD COLUMN index_version TEXT NOT NULL DEFAULT '';
+`;
+var DOMAIN_DDL = `
+  CREATE TABLE IF NOT EXISTS edge (
+    snapshot_id INTEGER NOT NULL,
+    src_id      TEXT NOT NULL,
+    dst_id      TEXT NOT NULL,
+    kind        TEXT NOT NULL,
+    attrs       TEXT,
+    PRIMARY KEY (snapshot_id, src_id, dst_id, kind)
+  );
+  CREATE INDEX IF NOT EXISTS idx_edge_dst ON edge(snapshot_id, dst_id);
+  CREATE INDEX IF NOT EXISTS idx_edge_kind ON edge(snapshot_id, kind);
+
+  CREATE TABLE IF NOT EXISTS metric (
+    snapshot_id INTEGER NOT NULL,
+    node_id     TEXT NOT NULL,
+    name        TEXT NOT NULL,
+    value       REAL,
+    unit        TEXT,
+    PRIMARY KEY (snapshot_id, node_id, name)
+  );
+  CREATE INDEX IF NOT EXISTS idx_metric_name ON metric(snapshot_id, name);
+
+  CREATE TABLE IF NOT EXISTS id_alias (
+    snapshot_id INTEGER NOT NULL,
+    old_id      TEXT NOT NULL,
+    new_id      TEXT NOT NULL,
+    reason      TEXT NOT NULL,
+    PRIMARY KEY (snapshot_id, old_id, new_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS file_fingerprint (
+    snapshot_id     INTEGER NOT NULL,
+    file_id         TEXT NOT NULL,
+    content_hash    TEXT NOT NULL,
+    structural_hash TEXT,
+    PRIMARY KEY (snapshot_id, file_id)
+  );
+`;
+var MIGRATIONS = [
+  kitMigration(1, { snapshot: KIT.snapshot, entitySnap: KIT.entitySnap, cacheBlob: KIT.cacheBlob }),
+  { version: 2, name: "code graph columns", up: (db) => db.exec(KIT_EXTENSIONS) },
+  { version: 3, name: "code graph tables", up: (db) => db.exec(DOMAIN_DDL) }
+];
+
+// src/rows.ts
+function rowToSnapshot(row) {
+  return {
+    id: row.id,
+    ref: row.ref,
+    commitHash: row.commit_hash,
+    takenAt: row.taken_at,
+    indexVersion: row.index_version,
+    attrs: JSON.parse(row.attrs)
+  };
+}
+function rowToNode(row) {
+  return {
+    id: row.id,
+    kind: row.kind,
+    name: row.name,
+    parentId: row.parent_id ?? void 0,
+    language: row.language ?? void 0,
+    role: row.role ?? void 0,
+    attrs: JSON.parse(row.attrs)
+  };
+}
+function rowToEdge(row) {
+  return {
+    srcId: row.src_id,
+    dstId: row.dst_id,
+    kind: row.kind,
+    attrs: JSON.parse(row.attrs)
+  };
+}
+function rowToMetric(row) {
+  return {
+    nodeId: row.node_id,
+    name: row.name,
+    value: row.value,
+    unit: row.unit ?? void 0
+  };
+}
+function rowToAlias(row) {
+  return {
+    oldId: row.old_id,
+    newId: row.new_id,
+    reason: row.reason
+  };
+}
+function rowToFingerprint(row) {
+  return {
+    fileId: row.file_id,
+    contentHash: row.content_hash,
+    structuralHash: row.structural_hash ?? void 0
+  };
+}
+
+// src/store.ts
+var NODE_COLS = "id, kind, name, parent_id, language, role, attrs";
+var CodeGraphStore = class {
+  constructor(db) {
+    this.db = db;
+    this.statements = prepareStatements(db);
+  }
+  db;
+  statements;
+  createSnapshot(input) {
+    const result = this.statements.insertSnapshot.run({
+      ref: input.ref,
+      commitHash: input.commitHash ?? null,
+      indexVersion: input.indexVersion,
+      attrs: JSON.stringify(input.attrs ?? {})
+    });
+    return Number(result.lastInsertRowid);
+  }
+  insertNodes(snapshotId, nodes) {
+    const stmt = this.statements.insertNode;
+    this.db.transaction(() => {
+      for (const n of nodes) {
+        stmt.run({
+          snapshotId,
+          id: n.id,
+          kind: n.kind,
+          name: n.name,
+          parentId: n.parentId ?? null,
+          language: n.language ?? null,
+          role: n.role ?? null,
+          attrs: JSON.stringify(n.attrs ?? {})
+        });
+      }
+    })();
+  }
+  insertEdges(snapshotId, edges) {
+    const stmt = this.statements.insertEdge;
+    this.db.transaction(() => {
+      for (const e of edges) {
+        stmt.run({
+          snapshotId,
+          srcId: e.srcId,
+          dstId: e.dstId,
+          kind: e.kind,
+          attrs: JSON.stringify(e.attrs ?? {})
+        });
+      }
+    })();
+  }
+  insertMetrics(snapshotId, metrics) {
+    const stmt = this.statements.insertMetric;
+    this.db.transaction(() => {
+      for (const m of metrics) {
+        stmt.run({ snapshotId, nodeId: m.nodeId, name: m.name, value: m.value, unit: m.unit ?? null });
+      }
+    })();
+  }
+  insertAliases(snapshotId, aliases) {
+    const stmt = this.statements.insertAlias;
+    this.db.transaction(() => {
+      for (const a of aliases) {
+        stmt.run({ snapshotId, oldId: a.oldId, newId: a.newId, reason: a.reason });
+      }
+    })();
+  }
+  insertFingerprints(snapshotId, fingerprints) {
+    const stmt = this.statements.insertFingerprint;
+    this.db.transaction(() => {
+      for (const f of fingerprints) {
+        stmt.run({
+          snapshotId,
+          fileId: f.fileId,
+          contentHash: f.contentHash,
+          structuralHash: f.structuralHash ?? null
+        });
+      }
+    })();
+  }
+  getSnapshot(id) {
+    const row = this.statements.getSnapshot.get(id);
+    return row ? rowToSnapshot(row) : null;
+  }
+  listSnapshots(opts = {}) {
+    const limit = opts.limit ?? 50;
+    const rows = opts.ref ? this.statements.listSnapshotsByRef.all(opts.ref, limit) : this.statements.listSnapshots.all(limit);
+    return rows.map(rowToSnapshot);
+  }
+  getLatestSnapshotByRef(ref) {
+    return this.listSnapshots({ ref, limit: 1 })[0] ?? null;
+  }
+  getNode(snapshotId, id) {
+    const row = this.statements.getNode.get(snapshotId, id);
+    return row ? rowToNode(row) : null;
+  }
+  /**
+   * File-level structural graph by default: the per-symbol layer is excluded so
+   * consumers that reason about module structure see the graph they expect. Pass
+   * `includeSymbols` for the symbol layer (the reuse basis needs it).
+   */
+  listNodes(snapshotId, opts) {
+    const nodes = this.statements.listNodes.all(snapshotId).map(rowToNode);
+    return opts?.includeSymbols ? nodes : nodes.filter((n) => n.kind !== "symbol");
+  }
+  /** See {@link listNodes}: `references` edges are the symbol layer, excluded by default. */
+  listEdges(snapshotId, opts) {
+    const edges = this.statements.listEdges.all(snapshotId).map(rowToEdge);
+    return opts?.includeReferences ? edges : edges.filter((e) => e.kind !== "references");
+  }
+  listMetrics(snapshotId) {
+    return this.statements.listMetrics.all(snapshotId).map(rowToMetric);
+  }
+  listAliases(snapshotId) {
+    return this.statements.listAliases.all(snapshotId).map(rowToAlias);
+  }
+  listFingerprints(snapshotId) {
+    return this.statements.listFingerprints.all(snapshotId).map(rowToFingerprint);
+  }
+  close() {
+    this.db.close();
+  }
+};
+function prepareStatements(db) {
+  return {
+    insertSnapshot: db.prepare(
+      `INSERT INTO snapshot (ref, commit_hash, index_version, attrs)
+       VALUES (@ref, @commitHash, @indexVersion, @attrs)`
+    ),
+    insertNode: db.prepare(
+      `INSERT OR REPLACE INTO node (snapshot_id, id, kind, name, parent_id, language, role, attrs)
+       VALUES (@snapshotId, @id, @kind, @name, @parentId, @language, @role, @attrs)`
+    ),
+    insertEdge: db.prepare(
+      `INSERT OR REPLACE INTO edge (snapshot_id, src_id, dst_id, kind, attrs)
+       VALUES (@snapshotId, @srcId, @dstId, @kind, @attrs)`
+    ),
+    insertMetric: db.prepare(
+      `INSERT OR REPLACE INTO metric (snapshot_id, node_id, name, value, unit)
+       VALUES (@snapshotId, @nodeId, @name, @value, @unit)`
+    ),
+    insertAlias: db.prepare(
+      `INSERT OR REPLACE INTO id_alias (snapshot_id, old_id, new_id, reason)
+       VALUES (@snapshotId, @oldId, @newId, @reason)`
+    ),
+    insertFingerprint: db.prepare(
+      `INSERT OR REPLACE INTO file_fingerprint (snapshot_id, file_id, content_hash, structural_hash)
+       VALUES (@snapshotId, @fileId, @contentHash, @structuralHash)`
+    ),
+    getSnapshot: db.prepare("SELECT * FROM snapshot WHERE id = ?"),
+    listSnapshots: db.prepare("SELECT * FROM snapshot ORDER BY taken_at DESC, id DESC LIMIT ?"),
+    listSnapshotsByRef: db.prepare(
+      "SELECT * FROM snapshot WHERE ref = ? ORDER BY taken_at DESC, id DESC LIMIT ?"
+    ),
+    getNode: db.prepare(`SELECT ${NODE_COLS} FROM node WHERE snapshot_id = ? AND id = ?`),
+    listNodes: db.prepare(`SELECT ${NODE_COLS} FROM node WHERE snapshot_id = ?`),
+    listEdges: db.prepare("SELECT src_id, dst_id, kind, attrs FROM edge WHERE snapshot_id = ?"),
+    listMetrics: db.prepare("SELECT node_id, name, value, unit FROM metric WHERE snapshot_id = ?"),
+    listAliases: db.prepare("SELECT old_id, new_id, reason FROM id_alias WHERE snapshot_id = ?"),
+    listFingerprints: db.prepare(
+      "SELECT file_id, content_hash, structural_hash FROM file_fingerprint WHERE snapshot_id = ?"
+    )
+  };
+}
+function openCodeGraph(dbPath) {
+  const db = openDatabase(dbPath);
+  runMigrations(db, MIGRATIONS);
+  return new CodeGraphStore(db);
+}
+
+// src/indexer.ts
+import { realpathSync } from "fs";
+import * as path10 from "path";
+
+// src/parser/parser.ts
+import { Parser, Language } from "web-tree-sitter";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var initialized = false;
+var parsers = /* @__PURE__ */ new Map();
+var languages = /* @__PURE__ */ new Map();
+function resolveWasmPath(language) {
+  switch (language) {
+    case "typescript":
+      return require2.resolve("tree-sitter-typescript/tree-sitter-typescript.wasm");
+    case "tsx":
+      return require2.resolve("tree-sitter-typescript/tree-sitter-tsx.wasm");
+    case "python":
+      return require2.resolve("tree-sitter-python/tree-sitter-python.wasm");
+    default:
+      throw new Error(`Unsupported language: ${language}`);
+  }
+}
+async function ensureInitialized() {
+  if (initialized) return;
+  await Parser.init();
+  initialized = true;
+}
+async function getLanguage(language) {
+  const cached = languages.get(language);
+  if (cached) return cached;
+  const wasmPath = resolveWasmPath(language);
+  const lang = await Language.load(wasmPath);
+  languages.set(language, lang);
+  return lang;
+}
+async function getParser(language) {
+  const cached = parsers.get(language);
+  if (cached) return cached;
+  resolveWasmPath(language);
+  await ensureInitialized();
+  const lang = await getLanguage(language);
+  const parser = new Parser();
+  parser.setLanguage(lang);
+  parsers.set(language, parser);
+  return parser;
+}
+async function parseFile(content, filePath, language) {
+  const parser = await getParser(language);
+  const tree = parser.parse(content);
+  if (!tree) {
+    throw new Error(`Failed to parse ${filePath}`);
+  }
+  return { tree, content, filePath, language };
+}
+function getSupportedLanguages() {
+  return ["typescript", "tsx", "python"];
+}
+
+// src/parser/file-filter.ts
+import * as path from "path";
+var EXCLUDED_DIRS = [
+  "node_modules",
+  "vendor",
+  "dist",
+  "build",
+  ".next",
+  "__generated__",
+  ".git",
+  ".claude",
+  "coverage"
+];
+var EXCLUDED_PATTERNS = [
+  /\.min\.[jt]sx?$/,
+  /\.d\.ts$/,
+  /\.map$/,
+  /lock\.(json|yaml)$/,
+  /pnpm-lock\.yaml$/,
+  /package-lock\.json$/,
+  /yarn\.lock$/
+];
+var LANGUAGE_EXTENSIONS = {
+  typescript: [".ts", ".tsx"],
+  javascript: [".js", ".jsx"],
+  python: [".py"]
+};
+function isExcludedDir(dirName) {
+  return EXCLUDED_DIRS.includes(dirName);
+}
+function shouldIncludeFile(filePath, languages2) {
+  const segments = filePath.split("/");
+  if (segments.some((s) => EXCLUDED_DIRS.includes(s))) {
+    return false;
+  }
+  if (EXCLUDED_PATTERNS.some((p) => p.test(filePath))) {
+    return false;
+  }
+  const ext = path.extname(filePath);
+  const allowedExtensions = languages2.flatMap(
+    (lang) => LANGUAGE_EXTENSIONS[lang] ?? []
+  );
+  return allowedExtensions.includes(ext);
+}
+function getLanguageFromPath(filePath) {
+  const ext = path.extname(filePath);
+  for (const [language, extensions] of Object.entries(LANGUAGE_EXTENSIONS)) {
+    if (extensions.includes(ext)) {
+      return language;
+    }
+  }
+  return null;
+}
+
+// src/extractors/ts-morph-extractor.ts
+import * as path5 from "path";
+import { existsSync } from "fs";
+import {
+  Project,
+  ScriptTarget,
+  ModuleKind,
+  ModuleResolutionKind
+} from "ts-morph";
+
+// src/extractors/file-nodes.ts
+import * as path3 from "path";
+
+// src/extractors/ids.ts
+import * as path2 from "path";
+var MODULE_EXT_RE = /\.(?:tsx|ts|jsx|js|mts|cts|mjs|cjs|py)$/;
+function toPosix(p) {
+  return p.split(path2.sep).join("/");
+}
+function repoRelative(repoRoot, absPath) {
+  const rel = path2.relative(repoRoot, absPath);
+  return toPosix(rel);
+}
+function fileId(repoRoot, absPath) {
+  return repoRelative(repoRoot, absPath);
+}
+function moduleId(repoRoot, absPath) {
+  const rel = repoRelative(repoRoot, absPath);
+  return rel.replace(MODULE_EXT_RE, "");
+}
+function parentModuleId(id) {
+  const idx = id.lastIndexOf("/");
+  if (idx < 0) return null;
+  return id.slice(0, idx);
+}
+function packageId(name) {
+  return name;
+}
+var SYMBOL_ID_SEP = "#";
+function symbolId(fileId2, exportName) {
+  return `${fileId2}${SYMBOL_ID_SEP}${exportName}`;
+}
+function parseSymbolId(id) {
+  const idx = id.indexOf(SYMBOL_ID_SEP);
+  if (idx < 0) return null;
+  return { fileId: id.slice(0, idx), name: id.slice(idx + 1) };
+}
+function externalId(specifier) {
+  if (specifier.startsWith("node:")) {
+    return specifier;
+  }
+  return `npm:${bareName(specifier)}`;
+}
+function bareName(specifier) {
+  if (specifier.startsWith("@")) {
+    const parts = specifier.split("/");
+    return parts.slice(0, 2).join("/");
+  }
+  const slash = specifier.indexOf("/");
+  return slash < 0 ? specifier : specifier.slice(0, slash);
+}
+
+// src/extractors/file-nodes.ts
+function buildFileModuleNodes(repoRoot, absPath) {
+  const fId = fileId(repoRoot, absPath);
+  const mId = moduleId(repoRoot, absPath);
+  const parentId = parentModuleId(mId) ?? void 0;
+  const language = getLanguageFromPath(absPath) ?? "typescript";
+  return [
+    { id: fId, kind: "file", name: path3.basename(fId), parentId: mId, language },
+    { id: mId, kind: "module", name: path3.basename(mId), parentId, language }
+  ];
+}
+
+// src/extractors/reference-weight.ts
+import {
+  Node,
+  SyntaxKind
+} from "ts-morph";
+function addWeightedEdge(agg, srcId, dstId, kind, specifier, weight) {
+  const key = JSON.stringify([kind, dstId]);
+  const existing = agg.get(key);
+  if (existing) {
+    existing.attrs.weight += weight;
+    return;
+  }
+  agg.set(key, { srcId, dstId, kind, attrs: { specifier, weight } });
+}
+function importWeight(decl, usage) {
+  const names = importBindingNames(decl);
+  if (names.length === 0) return 1;
+  const used = names.reduce((sum, n) => sum + (usage.get(n) ?? 0), 0);
+  return Math.max(used, 1);
+}
+function namedImportBindings(decl) {
+  const out = [];
+  const def = decl.getDefaultImport();
+  if (def) out.push({ importedName: "default", localName: def.getText() });
+  for (const spec of decl.getNamedImports()) {
+    out.push({
+      importedName: spec.getNameNode().getText(),
+      localName: (spec.getAliasNode() ?? spec.getNameNode()).getText()
+    });
+  }
+  return out;
+}
+function bindingWeight(binding, usage) {
+  return Math.max(usage.get(binding.localName) ?? 0, 1);
+}
+function importBindingNames(decl) {
+  const names = [];
+  const def = decl.getDefaultImport();
+  if (def) names.push(def.getText());
+  const ns = decl.getNamespaceImport();
+  if (ns) names.push(ns.getText());
+  for (const spec of decl.getNamedImports()) {
+    names.push((spec.getAliasNode() ?? spec.getNameNode()).getText());
+  }
+  return names;
+}
+function reExportWeight(decl) {
+  if (decl.isNamespaceExport()) return 1;
+  return Math.max(decl.getNamedExports().length, 1);
+}
+function buildLocalUsageCounts(sourceFile) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind.Identifier)) {
+    if (id.getFirstAncestorByKind(SyntaxKind.ImportDeclaration)) continue;
+    if (id.getFirstAncestorByKind(SyntaxKind.ExportDeclaration)) continue;
+    if (isPropertyNamePosition(id)) continue;
+    const text = id.getText();
+    counts.set(text, (counts.get(text) ?? 0) + 1);
+  }
+  return counts;
+}
+function isPropertyNamePosition(id) {
+  const parent = id.getParent();
+  if (Node.isPropertyAccessExpression(parent) && parent.getNameNode() === id) {
+    return true;
+  }
+  if (Node.isPropertyAssignment(parent) && parent.getNameNode() === id) {
+    return true;
+  }
+  return false;
+}
+
+// src/declared-names.ts
+var TS_DECL_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "method_definition",
+  "class_declaration"
+]);
+var PY_DECL_TYPES = /* @__PURE__ */ new Set(["function_definition", "class_definition"]);
+function collectDeclaredSpans(file) {
+  const declTypes = file.language === "python" ? PY_DECL_TYPES : TS_DECL_TYPES;
+  const spans = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    const named = declaredNodeAt(node, declTypes);
+    if (named) {
+      spans.set(named.name, {
+        startLine: named.node.startPosition.row + 1,
+        endLine: named.node.endPosition.row + 1
+      });
+    }
+    for (const child of node.children) {
+      if (child) visit(child);
+    }
+  };
+  visit(file.tree.rootNode);
+  return spans;
+}
+function collectDeclaredNames(file) {
+  return new Set(collectDeclaredSpans(file).keys());
+}
+function declaredNodeAt(node, declTypes) {
+  if (declTypes.has(node.type)) {
+    const name = node.childForFieldName("name")?.text;
+    return name ? { name, node } : null;
+  }
+  if ((node.type === "arrow_function" || node.type === "function_expression") && node.parent?.type === "variable_declarator") {
+    const name = node.parent.childForFieldName("name")?.text;
+    return name ? { name, node } : null;
+  }
+  return null;
+}
+
+// src/extractors/symbol-signature.ts
+import {
+  Node as Node2
+} from "ts-morph";
+var MAX_SIGNATURE = 200;
+var MAX_PURPOSE = 240;
+function declarationText(decl) {
+  const out = {};
+  const signature = signatureOf(decl);
+  if (signature) out.signature = signature;
+  const purpose = purposeOf(decl);
+  if (purpose) out.purpose = purpose;
+  return out;
+}
+function lookupDeclaration(sf, name) {
+  return sf.getFunction(name) ?? sf.getClass(name) ?? sf.getInterface(name) ?? sf.getTypeAlias(name) ?? sf.getEnum(name) ?? sf.getVariableDeclaration(name);
+}
+function signatureOf(decl) {
+  if (Node2.isFunctionDeclaration(decl) || Node2.isMethodDeclaration(decl)) {
+    return callableSignature(decl, decl.getName() ?? "");
+  }
+  if (Node2.isVariableDeclaration(decl)) return variableSignature(decl);
+  if (Node2.isClassDeclaration(decl)) return clamp(`class ${decl.getName() ?? ""}`.trim());
+  if (Node2.isInterfaceDeclaration(decl)) return clamp(`interface ${decl.getName()}`);
+  if (Node2.isTypeAliasDeclaration(decl)) {
+    return clamp(`type ${decl.getName()} = ${oneLine(decl.getTypeNode()?.getText() ?? "")}`);
+  }
+  if (Node2.isEnumDeclaration(decl)) return clamp(`enum ${decl.getName()}`);
+  return void 0;
+}
+function variableSignature(decl) {
+  const init = decl.getInitializer();
+  if (init && (Node2.isArrowFunction(init) || Node2.isFunctionExpression(init))) {
+    return callableSignature(init, decl.getName());
+  }
+  const typeNode = decl.getTypeNode();
+  const type = typeNode ? oneLine(typeNode.getText()) : cleanType(() => decl.getType().getText());
+  return type ? clamp(`${decl.getName()}: ${type}`) : void 0;
+}
+function callableSignature(decl, name) {
+  const params = decl.getParameters().map((p) => oneLine(p.getText())).join(", ");
+  const ret = returnType(decl);
+  return clamp(`${name}(${params})${ret ? `: ${ret}` : ""}`);
+}
+function returnType(decl) {
+  const node = decl.getReturnTypeNode();
+  if (node) return oneLine(node.getText());
+  return cleanType(() => decl.getReturnType().getText());
+}
+function cleanType(getText) {
+  let text;
+  try {
+    text = getText();
+  } catch {
+    return void 0;
+  }
+  if (!text || text.includes("import(")) return void 0;
+  return oneLine(text);
+}
+function purposeOf(decl) {
+  const docs = jsDocsFor(decl);
+  if (!docs || docs.length === 0) return void 0;
+  const desc = docs[docs.length - 1].getDescription().trim();
+  return desc ? clamp(oneLine(desc), MAX_PURPOSE) : void 0;
+}
+function jsDocsFor(decl) {
+  if (Node2.isJSDocable(decl)) return decl.getJsDocs();
+  if (Node2.isVariableDeclaration(decl)) return decl.getVariableStatement()?.getJsDocs();
+  return void 0;
+}
+function oneLine(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function clamp(s, max = MAX_SIGNATURE) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+
+// src/extractors/symbol-nodes.ts
+function makeSymbolNode(fileId2, name, exported, span, text) {
+  const attrs = { exported };
+  if (span) {
+    attrs.startLine = span.startLine;
+    attrs.endLine = span.endLine;
+  }
+  if (text.signature) attrs.signature = text.signature;
+  if (text.purpose) attrs.purpose = text.purpose;
+  return {
+    id: symbolId(fileId2, name),
+    kind: "symbol",
+    name,
+    parentId: fileId2,
+    language: "typescript",
+    attrs
+  };
+}
+function buildSymbolNodes(repoRoot, sourceFile, file) {
+  const fId = fileId(repoRoot, sourceFile.getFilePath());
+  const spans = collectDeclaredSpans(file);
+  const out = [];
+  const exported = /* @__PURE__ */ new Set();
+  for (const [name, decls] of sourceFile.getExportedDeclarations()) {
+    const own = decls.find((d) => d.getSourceFile() === sourceFile);
+    if (!own) continue;
+    exported.add(name);
+    out.push(makeSymbolNode(fId, name, true, spans.get(name), declarationText(own)));
+  }
+  for (const [name, span] of spans) {
+    if (exported.has(name)) continue;
+    const decl = lookupDeclaration(sourceFile, name);
+    out.push(makeSymbolNode(fId, name, false, span, decl ? declarationText(decl) : {}));
+  }
+  return out;
+}
+
+// src/extractors/dynamic-imports.ts
+import {
+  Node as Node3,
+  SyntaxKind as SyntaxKind2
+} from "ts-morph";
+function dynamicImportSpecifiers(sourceFile) {
+  const out = [];
+  for (const call of sourceFile.getDescendantsOfKind(SyntaxKind2.CallExpression)) {
+    if (call.getExpression().getKind() !== SyntaxKind2.ImportKeyword) continue;
+    const arg = call.getArguments()[0];
+    if (arg && arg.getKind() === SyntaxKind2.StringLiteral) {
+      out.push(arg.asKindOrThrow(SyntaxKind2.StringLiteral).getLiteralText());
+    }
+  }
+  return out;
+}
+function dynamicImportBindings(sourceFile) {
+  const out = [];
+  for (const call of sourceFile.getDescendantsOfKind(SyntaxKind2.CallExpression)) {
+    if (call.getExpression().getKind() !== SyntaxKind2.ImportKeyword) continue;
+    const arg = call.getArguments()[0];
+    if (!arg || arg.getKind() !== SyntaxKind2.StringLiteral) continue;
+    const pattern = destructuredTargetOf(call);
+    if (!pattern) continue;
+    const specifier = arg.asKindOrThrow(SyntaxKind2.StringLiteral).getLiteralText();
+    for (const importedName of destructuredNames(pattern)) {
+      out.push({ specifier, importedName });
+    }
+  }
+  return out;
+}
+function destructuredTargetOf(call) {
+  const parent = call.getParent();
+  if (!parent) return void 0;
+  const init = Node3.isAwaitExpression(parent) ? parent : call;
+  const decl = init.getParent();
+  if (!decl || !Node3.isVariableDeclaration(decl)) return void 0;
+  if (decl.getInitializer() !== init) return void 0;
+  const nameNode = decl.getNameNode();
+  return Node3.isObjectBindingPattern(nameNode) ? nameNode : void 0;
+}
+function destructuredNames(pattern) {
+  const names = [];
+  for (const el of pattern.getElements()) {
+    if (el.getDotDotDotToken()) continue;
+    const nameNode = el.getPropertyNameNode() ?? el.getNameNode();
+    names.push(nameNode.getText());
+  }
+  return names;
+}
+function recordDynamicSymbolRefEdges(sourceFile, srcFileId, agg, resolveSpecifier) {
+  for (const binding of dynamicImportBindings(sourceFile)) {
+    const targetFileId2 = resolveSpecifier(binding.specifier);
+    if (!targetFileId2) continue;
+    addWeightedEdge(
+      agg,
+      srcFileId,
+      symbolId(targetFileId2, binding.importedName),
+      "references",
+      binding.specifier,
+      1
+    );
+  }
+}
+
+// src/extractors/module-resolution.ts
+import * as path4 from "path";
+var RESOLVABLE_EXTS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+];
+function isRelativeSpecifier(specifier) {
+  return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+}
+function* relativeResolutionCandidates(base) {
+  yield base;
+  for (const ext of RESOLVABLE_EXTS) yield base + ext;
+  const jsExt = /\.(?:jsx?|mjs|cjs)$/.exec(base);
+  if (jsExt) {
+    const stem = base.slice(0, base.length - jsExt[0].length);
+    for (const ext of RESOLVABLE_EXTS) yield stem + ext;
+  }
+  for (const ext of RESOLVABLE_EXTS) yield path4.join(base, "index" + ext);
+}
+function resolveRelativeAbs(fs3, fromAbs, specifier) {
+  if (!isRelativeSpecifier(specifier)) return null;
+  const base = path4.resolve(path4.dirname(fromAbs), specifier);
+  for (const candidate of relativeResolutionCandidates(base)) {
+    if (fs3.fileExistsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function inRepoFileId(repoRoot, abs) {
+  const relative4 = path4.relative(repoRoot, abs);
+  if (relative4.startsWith("..") || path4.isAbsolute(relative4)) return null;
+  if (relative4.split(path4.sep).includes("node_modules")) return null;
+  return fileId(repoRoot, abs);
+}
+
+// src/extractors/reexport-resolve.ts
+function resolveReExportOrigin(ctx, importerAbs, specifier, name) {
+  const fs3 = ctx.project.getFileSystem();
+  const targetAbs = resolveRelativeAbs(fs3, importerAbs, specifier);
+  return targetAbs ? walkReExports(ctx, targetAbs, name, /* @__PURE__ */ new Set()) : null;
+}
+function walkReExports(ctx, fileAbs, name, visited) {
+  if (visited.has(fileAbs)) return null;
+  visited.add(fileAbs);
+  const sf = ctx.project.getSourceFile(fileAbs) ?? ctx.project.addSourceFileAtPathIfExists(fileAbs);
+  if (!sf) return null;
+  if (declaresExportLocally(sf, name)) {
+    const id = inRepoFileId(ctx.repoRoot, fileAbs);
+    return id ? symbolId(id, name) : null;
+  }
+  const fs3 = ctx.project.getFileSystem();
+  for (const ed of sf.getExportDeclarations()) {
+    const spec = ed.getModuleSpecifierValue();
+    if (!spec) continue;
+    const inward = reExportInwardName(ed, name);
+    if (inward === null) continue;
+    const targetAbs = resolveRelativeAbs(fs3, fileAbs, spec);
+    if (!targetAbs) continue;
+    const origin = walkReExports(ctx, targetAbs, inward, visited);
+    if (origin) return origin;
+  }
+  return null;
+}
+function declaresExportLocally(sf, name) {
+  const decls = sf.getExportedDeclarations().get(name);
+  return !!decls && decls.some((d) => d.getSourceFile() === sf);
+}
+function reExportInwardName(ed, name) {
+  const named = ed.getNamedExports();
+  if (named.length > 0) {
+    for (const spec of named) {
+      const outward = spec.getAliasNode()?.getText() ?? spec.getName();
+      if (outward === name) return spec.getName();
+    }
+    return null;
+  }
+  if (ed.getNamespaceExport()) return null;
+  return name;
+}
+
+// src/extractors/ts-morph-extractor.ts
+var TsMorphGraphExtractor = class {
+  name = "ts-morph-graph";
+  repoRoot;
+  tsConfigPath;
+  project;
+  constructor(options) {
+    this.repoRoot = options.repoRoot;
+    this.tsConfigPath = options.tsConfigPath;
+    this.project = options.project;
+  }
+  extract(file) {
+    if (!isTypeScriptFile(file)) return [];
+    const project = this.ensureProject();
+    const sourceFile = this.loadSourceFile(project, file);
+    const nodes = this.buildFileAndModuleNodes(sourceFile);
+    const symbolNodes2 = buildSymbolNodes(this.repoRoot, sourceFile, file);
+    const { edges, externalNodes } = this.collectEdges(sourceFile);
+    return [{ nodes: [...nodes, ...symbolNodes2, ...externalNodes], edges }];
+  }
+  ensureProject() {
+    if (this.project) return this.project;
+    this.project = this.tsConfigPath ? new Project({ tsConfigFilePath: this.tsConfigPath }) : new Project({
+      compilerOptions: {
+        allowJs: true,
+        target: ScriptTarget.ESNext,
+        module: ModuleKind.ESNext,
+        moduleResolution: ModuleResolutionKind.NodeNext
+      }
+    });
+    return this.project;
+  }
+  loadSourceFile(project, file) {
+    const existing = project.getSourceFile(file.filePath);
+    if (existing) {
+      if (existing.getFullText() !== file.content) {
+        existing.replaceWithText(file.content);
+      }
+      return existing;
+    }
+    return project.createSourceFile(file.filePath, file.content, {
+      overwrite: true
+    });
+  }
+  buildFileAndModuleNodes(sourceFile) {
+    return buildFileModuleNodes(this.repoRoot, sourceFile.getFilePath());
+  }
+  collectEdges(sourceFile) {
+    const c = {
+      srcAbs: sourceFile.getFilePath(),
+      srcFileId: fileId(this.repoRoot, sourceFile.getFilePath()),
+      usage: buildLocalUsageCounts(sourceFile),
+      agg: /* @__PURE__ */ new Map(),
+      externalNodes: [],
+      seenExternals: /* @__PURE__ */ new Set()
+    };
+    for (const decl of sourceFile.getImportDeclarations()) {
+      this.recordImportEdge(c, decl);
+    }
+    for (const decl of sourceFile.getExportDeclarations()) {
+      this.recordReExportEdge(c, decl);
+    }
+    for (const specifier of dynamicImportSpecifiers(sourceFile)) {
+      const dstId = this.resolveRelativeInternal(c.srcAbs, specifier);
+      if (dstId) addWeightedEdge(c.agg, c.srcFileId, dstId, "imports", specifier, 1);
+    }
+    recordDynamicSymbolRefEdges(
+      sourceFile,
+      c.srcFileId,
+      c.agg,
+      (s) => this.resolveRelativeInternal(c.srcAbs, s)
+    );
+    return { edges: [...c.agg.values()], externalNodes: c.externalNodes };
+  }
+  recordImportEdge(c, decl) {
+    const specifier = decl.getModuleSpecifierValue();
+    const dstId = this.resolveTarget(c, specifier, decl);
+    if (dstId) {
+      addWeightedEdge(c.agg, c.srcFileId, dstId, "imports", specifier, importWeight(decl, c.usage));
+    }
+    this.recordSymbolReferences(c, decl);
+  }
+  /**
+   * Split an import into per-export `references` edges targeting `symbol` nodes,
+   * so per-symbol utilization (which exports are hot) falls out of the same
+   * inbound-weight sum that powers file utilization (C-53). Extracted *forward*
+   * from the importing file — source-local, exactly like the file-level import
+   * weight — which sidesteps the reuse-breaking reverse `findReferences` query:
+   * an unchanged file's outbound reference edges are carried forward verbatim.
+   */
+  recordSymbolReferences(c, decl) {
+    const specifier = decl.getModuleSpecifierValue();
+    for (const binding of namedImportBindings(decl)) {
+      const dstId = this.resolveSymbolTarget(c, decl, binding.importedName);
+      if (!dstId) continue;
+      addWeightedEdge(
+        c.agg,
+        c.srcFileId,
+        dstId,
+        "references",
+        specifier,
+        bindingWeight(binding, c.usage)
+      );
+    }
+  }
+  /**
+   * Resolve an imported name to the id of the `symbol` node for the export that
+   * actually *declares* it — following re-exports through barrels via ts-morph's
+   * own `getExportedDeclarations`, so `import { x } from "./barrel"` credits the
+   * origin file's `x`, not the barrel. When ts-morph can't resolve the specifier
+   * (e.g. an extensionless relative import), falls back to a filesystem-based
+   * re-export walk that still sees through barrel hops (C-70). Returns null for
+   * external / unresolved targets.
+   * A name that resolves to no local declaration (an aliased re-export the
+   * origin doesn't export under this name) yields a dangling edge, pruned after
+   * assembly (`pruneDanglingReferences`).
+   */
+  resolveSymbolTarget(c, decl, importedName) {
+    const targetSf = decl.getModuleSpecifierSourceFile();
+    if (targetSf) {
+      const decls = targetSf.getExportedDeclarations().get(importedName);
+      const originSf = decls && decls.length > 0 ? decls[0].getSourceFile() : targetSf;
+      const originId = this.inRepoFileId(remapDistToSrc(originSf.getFilePath()));
+      return originId ? symbolId(originId, importedName) : null;
+    }
+    return resolveReExportOrigin(
+      { project: this.ensureProject(), repoRoot: this.repoRoot },
+      c.srcAbs,
+      decl.getModuleSpecifierValue(),
+      importedName
+    );
+  }
+  recordReExportEdge(c, decl) {
+    if (!decl.hasModuleSpecifier()) return;
+    const specifier = decl.getModuleSpecifierValue();
+    if (!specifier) return;
+    const dstId = this.resolveTarget(c, specifier, decl);
+    if (dstId) {
+      addWeightedEdge(c.agg, c.srcFileId, dstId, "re-exports", specifier, reExportWeight(decl));
+    }
+  }
+  /**
+   * Resolve an import/export specifier to a graph node id (an in-repo file id or
+   * an `external` node, creating the external node on first sight), or `null`
+   * when it should not produce an edge.
+   */
+  resolveTarget(c, specifier, decl) {
+    const internal = this.resolveInternal(decl.getModuleSpecifierSourceFile()) ?? this.resolveRelativeInternal(c.srcAbs, specifier);
+    if (internal) return internal;
+    if (isRelativeSpecifier(specifier)) {
+      return null;
+    }
+    const extId = externalId(specifier);
+    if (!c.seenExternals.has(extId)) {
+      c.seenExternals.add(extId);
+      c.externalNodes.push({ id: extId, kind: "external", name: specifier });
+    }
+    return extId;
+  }
+  resolveInternal(target) {
+    if (!target) return null;
+    return this.inRepoFileId(remapDistToSrc(target.getFilePath()));
+  }
+  /**
+   * Resolve a relative specifier ts-morph failed to link by walking the
+   * filesystem from the importing file. ts-morph's NodeNext resolution only
+   * links relative imports that carry an explicit `.js` extension, so
+   * extensionless bundler-style imports (`../types`, common in code outside the
+   * tsconfig project such as `dashboard/`) resolve to nothing and would
+   * otherwise fall through to the `npm:` external bucket (C-44). Resolves
+   * through the ts-morph filesystem host so it honours in-memory test fixtures.
+   */
+  resolveRelativeInternal(srcAbs, specifier) {
+    const abs = resolveRelativeAbs(
+      this.ensureProject().getFileSystem(),
+      srcAbs,
+      specifier
+    );
+    return abs ? inRepoFileId(this.repoRoot, abs) : null;
+  }
+  inRepoFileId(abs) {
+    return inRepoFileId(this.repoRoot, abs);
+  }
+};
+function remapDistToSrc(abs) {
+  const m = /^(.*)[\\/]dist[\\/](.+)\.d\.ts$/.exec(abs);
+  if (!m) return abs;
+  const base = m[1];
+  const sub = m[2];
+  for (const ext of [".ts", ".tsx"]) {
+    const candidate = path5.join(base, "src", sub + ext);
+    if (existsSync(candidate)) return candidate;
+  }
+  return abs;
+}
+function isTypeScriptFile(file) {
+  return file.language === "typescript" || file.language === "tsx";
+}
+
+// src/extractors/python-extractor.ts
+import * as path6 from "path";
+import { existsSync as existsSync2 } from "fs";
+function* candidates(base) {
+  yield `${base}.py`;
+  yield path6.join(base, "__init__.py");
+}
+var PythonGraphExtractor = class {
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+  }
+  repoRoot;
+  name = "python-graph";
+  extract(file) {
+    if (file.language !== "python") return [];
+    const fId = fileId(this.repoRoot, file.filePath);
+    const nodes = buildFileModuleNodes(this.repoRoot, file.filePath);
+    nodes.push(...symbolNodes(fId, file));
+    const { edges, externals } = this.collectImports(fId, file);
+    return [{ nodes: [...nodes, ...externals], edges }];
+  }
+  collectImports(srcId, file) {
+    const edges = /* @__PURE__ */ new Map();
+    const externals = [];
+    for (const specifier of importSpecifiers(file.tree.rootNode)) {
+      const internal = this.resolveDotted(file.filePath, specifier);
+      const dstId = internal ?? externalId(specifier);
+      if (!internal && !edges.has(dstId)) {
+        externals.push({ id: dstId, kind: "external", name: specifier });
+      }
+      edges.set(dstId, { srcId, dstId, kind: "imports", attrs: { specifier, weight: 1 } });
+    }
+    return { edges: [...edges.values()], externals };
+  }
+  /**
+   * Resolve `a.b.c` (or a leading-dot relative import) to an in-repo file id by
+   * walking the dotted path from the importing file's package and then from the
+   * repo root, which covers both intra-package and root-relative layouts.
+   */
+  resolveDotted(fromAbs, specifier) {
+    const leadingDots = /^\.*/.exec(specifier)?.[0].length ?? 0;
+    const parts = specifier.slice(leadingDots).split(".").filter(Boolean);
+    const relativeBase = path6.resolve(path6.dirname(fromAbs), "../".repeat(Math.max(leadingDots - 1, 0)));
+    const roots = leadingDots > 0 ? [relativeBase] : [path6.dirname(fromAbs), this.repoRoot];
+    for (const root of roots) {
+      for (const candidate of candidates(path6.join(root, ...parts))) {
+        const id = inRepoFileId(this.repoRoot, candidate);
+        if (id !== null && existsSync2(candidate)) return id;
+      }
+    }
+    return null;
+  }
+};
+function symbolNodes(fId, file) {
+  return [...collectDeclaredSpans(file)].map(([name, span]) => ({
+    id: symbolId(fId, name),
+    kind: "symbol",
+    name,
+    parentId: fId,
+    language: "python",
+    attrs: { exported: !name.startsWith("_"), startLine: span.startLine, endLine: span.endLine }
+  }));
+}
+function importSpecifiers(root) {
+  const out = [];
+  const visit = (node) => {
+    if (node.type === "import_statement" || node.type === "import_from_statement") {
+      const name = node.childForFieldName("module_name");
+      if (name) out.push(name.text);
+      else for (const child of node.namedChildren) if (child?.type === "dotted_name") out.push(child.text);
+    }
+    for (const child of node.namedChildren) if (child) visit(child);
+  };
+  visit(root);
+  return out;
+}
+
+// src/extractors/dispatch.ts
+var LanguageExtractor = class {
+  name = "language-graph";
+  delegates;
+  constructor(options) {
+    this.delegates = [
+      new TsMorphGraphExtractor({ repoRoot: options.repoRoot, tsConfigPath: options.tsConfigPath }),
+      new PythonGraphExtractor(options.repoRoot)
+    ];
+  }
+  extract(file) {
+    return this.delegates.flatMap((delegate) => delegate.extract(file));
+  }
+};
+
+// src/git-renames.ts
+import { execFileSync } from "child_process";
+import * as path7 from "path";
+function detectGitHead(repoRoot) {
+  return runGit(repoRoot, ["rev-parse", "HEAD"]);
+}
+function isInsideGitRepo(repoRoot) {
+  return runGit(repoRoot, ["rev-parse", "--is-inside-work-tree"]) === "true";
+}
+function detectGitToplevel(cwd) {
+  return runGit(cwd, ["rev-parse", "--show-toplevel"]);
+}
+function detectRenames(options) {
+  const threshold = options.similarityThreshold ?? 80;
+  const args = [
+    "diff",
+    `--find-renames=${threshold}%`,
+    "--name-status",
+    options.fromCommit
+  ];
+  if (options.toCommit) args.push(options.toCommit);
+  const out = runGit(options.repoRoot, args);
+  if (out === null) return [];
+  return parseRenameOutput(out);
+}
+function parseRenameOutput(text) {
+  const out = [];
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trimEnd();
+    if (!line) continue;
+    const parts = line.split("	");
+    const status = parts[0] ?? "";
+    if (!status.startsWith("R") || parts.length < 3) continue;
+    const similarity = parseInt(status.slice(1), 10);
+    out.push({
+      oldPath: parts[1],
+      newPath: parts[2],
+      similarity: Number.isFinite(similarity) ? similarity : 100
+    });
+  }
+  return out;
+}
+function classifyRename(oldPath, newPath) {
+  return path7.posix.dirname(oldPath) === path7.posix.dirname(newPath) ? "rename" : "move";
+}
+function renameToAliases(repoRoot, pair) {
+  const reason = classifyRename(pair.oldPath, pair.newPath);
+  const oldAbs = path7.join(repoRoot, pair.oldPath);
+  const newAbs = path7.join(repoRoot, pair.newPath);
+  return [
+    { oldId: fileId(repoRoot, oldAbs), newId: fileId(repoRoot, newAbs), reason },
+    { oldId: moduleId(repoRoot, oldAbs), newId: moduleId(repoRoot, newAbs), reason }
+  ];
+}
+function buildAliases(repoRoot, pairs) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const pair of pairs) {
+    for (const alias of renameToAliases(repoRoot, pair)) {
+      if (seen.has(alias.oldId)) continue;
+      seen.add(alias.oldId);
+      out.push(alias);
+    }
+  }
+  return out;
+}
+function discoveryEnv() {
+  const env = { ...process.env };
+  delete env.GIT_DIR;
+  delete env.GIT_INDEX_FILE;
+  delete env.GIT_WORK_TREE;
+  return env;
+}
+function runGit(cwd, args) {
+  try {
+    return execFileSync("git", [...args], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      env: discoveryEnv()
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/generated.ts
+import { readFileSync } from "fs";
+import * as path8 from "path";
+var HEURISTIC_FILE_RE = /(?:^|\/)[^/]*\.(?:gen|generated)\.[^/]*$/;
+var HEURISTIC_DIR_RE = /(?:^|\/)generated\//;
+function isGeneratedByHeuristic(id) {
+  return HEURISTIC_FILE_RE.test(id) || HEURISTIC_DIR_RE.test(id);
+}
+function isGeneratedFile(id, patterns) {
+  for (const rx of patterns) if (rx.test(id)) return true;
+  return isGeneratedByHeuristic(id);
+}
+function loadGeneratedPatterns(rootDir) {
+  try {
+    const content = readFileSync(path8.join(rootDir, ".gitattributes"), "utf-8");
+    return parseGeneratedPatterns(content);
+  } catch {
+    return [];
+  }
+}
+function parseGeneratedPatterns(content) {
+  const out = [];
+  for (const raw of content.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const parsed = /^("(?:[^"\\]|\\.)*"|\S+)\s*(.*)$/.exec(line);
+    if (!parsed) continue;
+    const pattern = unquote(parsed[1]);
+    if (generatedAttr(parsed[2].split(/\s+/).filter(Boolean)) === true) {
+      out.push(gitattributesPatternToRegex(pattern));
+    }
+  }
+  return out;
+}
+function generatedAttr(attrs) {
+  let value;
+  for (const a of attrs) {
+    if (a === "linguist-generated" || a === "linguist-generated=true") value = true;
+    else if (a === "-linguist-generated" || a === "linguist-generated=false") value = false;
+  }
+  return value;
+}
+function unquote(token) {
+  return token.startsWith('"') && token.endsWith('"') ? token.slice(1, -1).replace(/\\(.)/g, "$1") : token;
+}
+function gitattributesPatternToRegex(pattern) {
+  let p = pattern;
+  const isDir = p.endsWith("/");
+  if (isDir) p = p.slice(0, -1);
+  let body = "";
+  for (let i = 0; i < p.length; i++) {
+    const c = p[i];
+    if (c === "*" && p[i + 1] === "*") {
+      body += ".*";
+      i++;
+    } else if (c === "*") body += "[^/]*";
+    else if (c === "?") body += "[^/]";
+    else body += c.replace(/[.+(){}|^$\\[\]]/, "\\$&");
+  }
+  const prefix = p.includes("/") ? "^" : "(?:^|/)";
+  return new RegExp(prefix + body + (isDir ? "(?:/|$)" : "$"));
+}
+
+// src/roles.ts
+var TEST_RE = /(?:^|\/)(?:__tests__\/|tests?\/)|\.(?:test|spec)(?:\.[a-z]+)?$/;
+var FIXTURE_RE = /(?:^|\/)fixtures(?:\/|$)/;
+var SCRIPT_RE = /(?:^|\/)(?:scripts|archive)(?:\/|$)/;
+var BARREL_RE = /(?:^|\/)index(?:\.[a-z]+)?$/;
+var TYPES_RE = /(?:^|\/)(?:[a-z][\w-]*\.)?types(?:\.[a-z]+)?$/i;
+var CONFIG_RE = /\.config(?:\.[a-z]+)?$/;
+var ALL_ROLES = [
+  "test",
+  "fixture",
+  "barrel",
+  "types",
+  "config",
+  "script",
+  "entry",
+  "generated",
+  "source"
+];
+function classifyRole(id, hints) {
+  if (hints?.isGenerated) return "generated";
+  if (TEST_RE.test(id)) return "test";
+  if (FIXTURE_RE.test(id)) return "fixture";
+  if (SCRIPT_RE.test(id)) return "script";
+  if (hints?.hasShebang) return "entry";
+  if (BARREL_RE.test(id)) return "barrel";
+  if (TYPES_RE.test(id)) return "types";
+  if (CONFIG_RE.test(id)) return "config";
+  return "source";
+}
+function computeRoleHints(readFiles, idRoot, toId) {
+  const patterns = loadGeneratedPatterns(idRoot);
+  const shebangIds = /* @__PURE__ */ new Set();
+  const generatedIds = /* @__PURE__ */ new Set();
+  for (const rf of readFiles) {
+    const id = toId(idRoot, rf.filePath);
+    if (rf.content.startsWith("#!")) shebangIds.add(id);
+    if (isGeneratedFile(id, patterns)) generatedIds.add(id);
+  }
+  return { shebangIds, generatedIds };
+}
+function annotateRoles(nodes, options) {
+  return nodes.map(
+    (n) => n.kind === "file" || n.kind === "module" ? {
+      ...n,
+      role: n.role ?? classifyRole(n.id, {
+        hasShebang: options?.shebangIds?.has(n.id) ?? false,
+        isGenerated: options?.generatedIds?.has(n.id) ?? false
+      })
+    } : n
+  );
+}
+
+// src/file-walk.ts
+import * as fs from "fs/promises";
+import * as path9 from "path";
+async function walkSourceFiles(rootDirs, languages2) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const rootDir of rootDirs) {
+    await collectFiles(rootDir, rootDir, languages2, seen, out);
+  }
+  return out;
+}
+async function collectFiles(dir, rootDir, languages2, seen, out) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path9.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (isExcludedDir(entry.name)) continue;
+      await collectFiles(full, rootDir, languages2, seen, out);
+    } else if (entry.isFile() && !seen.has(full)) {
+      const relative4 = path9.relative(rootDir, full);
+      if (shouldIncludeFile(relative4, [...languages2])) {
+        seen.add(full);
+        out.push(full);
+      }
+    }
+  }
+}
+
+// src/barrel-resolve.ts
+function edgeWeight(e) {
+  const w = e.attrs?.weight;
+  return typeof w === "number" && w > 0 ? w : 1;
+}
+function pruneDanglingReferences(nodes, edges) {
+  for (const [key, edge] of edges) {
+    if (edge.kind === "references" && !nodes.has(edge.dstId)) edges.delete(key);
+  }
+}
+function resolveBarrelEdges(nodes, edges) {
+  const barrels = /* @__PURE__ */ new Set();
+  for (const n of nodes) if (n.role === "barrel") barrels.add(n.id);
+  if (barrels.size === 0) return [...edges];
+  const forwards = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!barrels.has(e.srcId) || e.kind === "references") continue;
+    const arr = forwards.get(e.srcId) ?? [];
+    arr.push({ dst: e.dstId, weight: edgeWeight(e) });
+    forwards.set(e.srcId, arr);
+  }
+  const cache = /* @__PURE__ */ new Map();
+  function resolve4(id, seen) {
+    if (!barrels.has(id)) return /* @__PURE__ */ new Map([[id, 1]]);
+    const cached = cache.get(id);
+    if (cached) return cached;
+    const targets = forwards.get(id);
+    const total = targets?.reduce((s, t) => s + t.weight, 0) ?? 0;
+    if (!targets || total === 0 || seen.has(id)) return /* @__PURE__ */ new Map([[id, 1]]);
+    const out = /* @__PURE__ */ new Map();
+    const nextSeen = new Set(seen).add(id);
+    for (const t of targets) {
+      const share = t.weight / total;
+      for (const [real, frac] of resolve4(t.dst, nextSeen)) {
+        out.set(real, (out.get(real) ?? 0) + share * frac);
+      }
+    }
+    cache.set(id, out);
+    return out;
+  }
+  const resolved = [];
+  for (const e of edges) {
+    if (barrels.has(e.srcId) && e.kind !== "references") continue;
+    if (!barrels.has(e.dstId)) {
+      resolved.push(e);
+      continue;
+    }
+    const w = edgeWeight(e);
+    for (const [real, frac] of resolve4(e.dstId, /* @__PURE__ */ new Set())) {
+      if (real === e.srcId) continue;
+      resolved.push({
+        ...e,
+        dstId: real,
+        attrs: { ...e.attrs, weight: w * frac }
+      });
+    }
+  }
+  return resolved;
+}
+
+// src/incremental.ts
+import { createHash } from "crypto";
+import * as fs2 from "fs/promises";
+
+// src/cognitive-complexity.ts
+function cognitiveComplexityOf(body, language) {
+  const handler = language === "python" ? PY_HANDLER : TS_HANDLER;
+  return scoreNode(body, 0, handler);
+}
+var TS_STRUCTURAL = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement",
+  "switch_statement",
+  "catch_clause",
+  "ternary_expression"
+]);
+var PY_STRUCTURAL = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "while_statement",
+  "except_clause",
+  "conditional_expression"
+  // elif_clause is intentionally NOT here — it's a flat continuation of an
+  // existing if (counted in flatIncrement). Including it would charge both
+  // a structural and a flat +1.
+]);
+var TS_NESTING = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement",
+  "switch_statement",
+  "catch_clause",
+  "function_declaration",
+  "method_definition",
+  "arrow_function"
+]);
+var PY_NESTING = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "while_statement",
+  "except_clause",
+  "function_definition",
+  "lambda"
+]);
+var TS_HANDLER = {
+  structuralIncrement(node, nesting) {
+    return TS_STRUCTURAL.has(node.type) ? 1 + nesting : 0;
+  },
+  isNesting(node) {
+    return TS_NESTING.has(node.type);
+  },
+  flatIncrement(node) {
+    if (node.type === "else_clause") return 1;
+    if (node.type === "binary_expression" && isLogicalOp(node) && !isInnerOfSameOpChain(node, "binary_expression")) {
+      return 1;
+    }
+    return 0;
+  }
+};
+var PY_HANDLER = {
+  structuralIncrement(node, nesting) {
+    return PY_STRUCTURAL.has(node.type) ? 1 + nesting : 0;
+  },
+  isNesting(node) {
+    return PY_NESTING.has(node.type);
+  },
+  flatIncrement(node) {
+    if (node.type === "elif_clause" || node.type === "else_clause") return 1;
+    if (node.type === "boolean_operator" && !isInnerOfSameOpChain(node, "boolean_operator")) {
+      return 1;
+    }
+    return 0;
+  }
+};
+function isLogicalOp(node) {
+  const op = node.childForFieldName("operator");
+  return !!op && (op.text === "&&" || op.text === "||");
+}
+function isInnerOfSameOpChain(node, parentType) {
+  const parent = node.parent;
+  if (!parent || parent.type !== parentType) return false;
+  const op = node.childForFieldName("operator")?.text;
+  const parentOp = parent.childForFieldName("operator")?.text;
+  return !!op && op === parentOp;
+}
+function isElseIf(node) {
+  if (node.type !== "if_statement" && node.type !== "elif_clause") return false;
+  const parent = node.parent;
+  return !!parent && parent.type === "else_clause";
+}
+function scoreNode(node, nesting, handler) {
+  const elseIf = isElseIf(node);
+  const structural = elseIf ? 0 : handler.structuralIncrement(node, nesting);
+  const flat = handler.flatIncrement(node);
+  const childNesting = !elseIf && handler.isNesting(node) ? nesting + 1 : nesting;
+  let score = structural + flat;
+  for (const child of node.namedChildren) {
+    if (child) score += scoreNode(child, childNesting, handler);
+  }
+  return score;
+}
+
+// src/lcom.ts
+function computeLcomMetrics(file, fileId2) {
+  const classes = collectClasses(file);
+  if (classes.length === 0) return [];
+  const out = [
+    {
+      nodeId: fileId2,
+      name: "class_count",
+      value: classes.length,
+      unit: "count"
+    }
+  ];
+  const scores = classes.map((c) => lcom4OfClass(c, file.language)).filter((s) => s !== null);
+  if (scores.length > 0) {
+    out.push({
+      nodeId: fileId2,
+      name: "lcom4_max",
+      value: Math.max(...scores),
+      unit: "count"
+    });
+  }
+  return out;
+}
+function collectClasses(file) {
+  const isClass = file.language === "python" ? (n) => n.type === "class_definition" : (n) => n.type === "class_declaration" || n.type === "class_expression";
+  const out = [];
+  const visit = (node) => {
+    if (isClass(node)) out.push(node);
+    for (const child of node.namedChildren) {
+      if (child) visit(child);
+    }
+  };
+  visit(file.tree.rootNode);
+  return out;
+}
+function lcom4OfClass(classNode, language) {
+  const methods = collectMethods(classNode, language);
+  if (methods.length === 0) return null;
+  if (methods.length === 1) return 1;
+  return countComponents(methods);
+}
+function collectMethods(classNode, language) {
+  return language === "python" ? collectPythonMethods(classNode) : collectTsMethods(classNode);
+}
+function collectTsMethods(classNode) {
+  const body = classNode.childForFieldName("body");
+  if (!body) return [];
+  const out = [];
+  for (const child of body.namedChildren) {
+    if (!child || child.type !== "method_definition") continue;
+    if (hasStaticModifier(child)) continue;
+    const name = methodName(child);
+    if (!name || name === "constructor") continue;
+    out.push({ name, usedNames: thisRefs(child, "this") });
+  }
+  return out;
+}
+function collectPythonMethods(classNode) {
+  const body = classNode.childForFieldName("body");
+  if (!body) return [];
+  const out = [];
+  for (const child of body.namedChildren) {
+    if (!child || child.type !== "function_definition") continue;
+    const name = child.childForFieldName("name")?.text;
+    if (!name || name === "__init__") continue;
+    if (isPythonStaticOrClassMethod(child)) continue;
+    out.push({ name, usedNames: thisRefs(child, "self") });
+  }
+  return out;
+}
+function methodName(methodNode) {
+  const nameNode = methodNode.childForFieldName("name");
+  return nameNode?.text ?? null;
+}
+function hasStaticModifier(methodNode) {
+  for (const child of methodNode.children) {
+    if (child?.type === "static") return true;
+  }
+  return false;
+}
+function isPythonStaticOrClassMethod(funcNode) {
+  let prev = funcNode.previousNamedSibling;
+  while (prev && prev.type === "decorator") {
+    const text = prev.text;
+    if (text.includes("@staticmethod") || text.includes("@classmethod")) {
+      return true;
+    }
+    prev = prev.previousNamedSibling;
+  }
+  return false;
+}
+function thisRefs(methodNode, selfKeyword) {
+  const out = /* @__PURE__ */ new Set();
+  const visit = (n) => {
+    collectThisRef(n, selfKeyword, out);
+    for (const child of n.namedChildren) {
+      if (child) visit(child);
+    }
+  };
+  visit(methodNode);
+  return out;
+}
+function collectThisRef(n, selfKeyword, out) {
+  if (n.type === "member_expression" || n.type === "attribute") {
+    const obj = n.childForFieldName("object");
+    if (!obj) return;
+    if (matchesSelf(obj, selfKeyword)) {
+      const prop = n.childForFieldName("property") ?? n.childForFieldName("attribute");
+      if (prop) out.add(prop.text);
+    }
+  }
+}
+function matchesSelf(node, selfKeyword) {
+  if (selfKeyword === "this") return node.type === "this";
+  return node.type === "identifier" && node.text === selfKeyword;
+}
+function countComponents(methods) {
+  const n = methods.length;
+  const parent = Array.from({ length: n }, (_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (areLinked(methods[i], methods[j])) union(i, j);
+    }
+  }
+  const roots = /* @__PURE__ */ new Set();
+  for (let i = 0; i < n; i++) roots.add(find(i));
+  return roots.size;
+}
+function areLinked(a, b) {
+  if (a.usedNames.has(b.name)) return true;
+  if (b.usedNames.has(a.name)) return true;
+  for (const name of a.usedNames) {
+    if (b.usedNames.has(name)) return true;
+  }
+  return false;
+}
+
+// src/source-metrics.ts
+var TS_FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "method_definition"
+]);
+var PY_FUNCTION_TYPES = /* @__PURE__ */ new Set(["function_definition"]);
+var TS_NESTING_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement",
+  "switch_statement",
+  "try_statement"
+]);
+var PY_NESTING_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "while_statement",
+  "try_statement"
+]);
+var TS_BRANCH_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement",
+  "switch_case",
+  "catch_clause",
+  "ternary_expression"
+]);
+var PY_BRANCH_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "elif_clause",
+  "for_statement",
+  "while_statement",
+  "except_clause",
+  "conditional_expression"
+]);
+var SOURCE_METRIC_NAMES = /* @__PURE__ */ new Set([
+  "loc",
+  "function_count",
+  "cyclomatic_max",
+  "cyclomatic_sum",
+  "cognitive_max",
+  "cognitive_sum",
+  "max_nesting_depth",
+  "class_count",
+  "lcom4_max",
+  // Per-symbol complexity (C-58; C-64 extends it to non-exported symbols), keyed
+  // to `symbol` node ids. Source-local like the file-level metrics above, so an
+  // unchanged file carries them forward — but their nodeId is `<fileId>#<name>`,
+  // so the reuse basis buckets them under the symbol's parent file (incremental.ts).
+  "symbol_cognitive",
+  "symbol_cyclomatic"
+]);
+var EMPTY_NAMES = /* @__PURE__ */ new Set();
+function computeSourceMetrics(files, fileIdOf, symbolNamesByFile2 = /* @__PURE__ */ new Map()) {
+  const out = [];
+  for (const file of files) {
+    const id = fileIdOf(file.filePath);
+    out.push(...metricsForFile(id, file, symbolNamesByFile2.get(id) ?? EMPTY_NAMES));
+  }
+  return out;
+}
+function metricsForFile(nodeId, file, symbolNames) {
+  const out = [];
+  const loc = countLoc(file.content);
+  out.push({ nodeId, name: "loc", value: loc, unit: "lines" });
+  const stats = analyzeFunctions(file);
+  out.push({
+    nodeId,
+    name: "function_count",
+    value: stats.length,
+    unit: "count"
+  });
+  if (stats.length > 0) {
+    out.push({
+      nodeId,
+      name: "cyclomatic_max",
+      value: Math.max(...stats.map((s) => s.cyclomatic)),
+      unit: "count"
+    });
+    out.push({
+      nodeId,
+      name: "cyclomatic_sum",
+      value: stats.reduce((acc, s) => acc + s.cyclomatic, 0),
+      unit: "count"
+    });
+    out.push({
+      nodeId,
+      name: "cognitive_max",
+      value: Math.max(...stats.map((s) => s.cognitive)),
+      unit: "count"
+    });
+    out.push({
+      nodeId,
+      name: "cognitive_sum",
+      value: stats.reduce((acc, s) => acc + s.cognitive, 0),
+      unit: "count"
+    });
+    out.push({
+      nodeId,
+      name: "max_nesting_depth",
+      value: Math.max(...stats.map((s) => s.nestingDepth)),
+      unit: "count"
+    });
+  }
+  out.push(...symbolComplexityMetrics(nodeId, stats, symbolNames));
+  out.push(...computeLcomMetrics(file, nodeId));
+  return out;
+}
+function symbolComplexityMetrics(fileId2, stats, symbolNames) {
+  if (symbolNames.size === 0) return [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const s of stats) {
+    if (!s.name || !symbolNames.has(s.name)) continue;
+    const prev = byName.get(s.name);
+    if (!prev) byName.set(s.name, { cognitive: s.cognitive, cyclomatic: s.cyclomatic });
+    else {
+      prev.cognitive = Math.max(prev.cognitive, s.cognitive);
+      prev.cyclomatic = Math.max(prev.cyclomatic, s.cyclomatic);
+    }
+  }
+  const out = [];
+  for (const [name, m] of byName) {
+    const sid = symbolId(fileId2, name);
+    out.push({ nodeId: sid, name: "symbol_cognitive", value: m.cognitive, unit: "count" });
+    out.push({ nodeId: sid, name: "symbol_cyclomatic", value: m.cyclomatic, unit: "count" });
+  }
+  return out;
+}
+function countLoc(content) {
+  return content.split("\n").filter((l) => l.trim() !== "").length;
+}
+function analyzeFunctions(file) {
+  const stats = [];
+  const fnTypes = file.language === "python" ? PY_FUNCTION_TYPES : TS_FUNCTION_TYPES;
+  const visit = (node) => {
+    const fn = functionAt(node, fnTypes);
+    if (fn) {
+      stats.push({
+        name: fn.name,
+        cyclomatic: cyclomaticOf(fn.body, file.language),
+        cognitive: cognitiveComplexityOf(fn.body, file.language),
+        nestingDepth: nestingDepthOf(fn.body, file.language, 0)
+      });
+    }
+    for (const child of node.children) {
+      if (child) visit(child);
+    }
+  };
+  visit(file.tree.rootNode);
+  return stats;
+}
+function functionAt(node, fnTypes) {
+  if (fnTypes.has(node.type)) {
+    const body = node.childForFieldName("body");
+    return body ? { name: node.childForFieldName("name")?.text ?? null, body } : null;
+  }
+  if ((node.type === "arrow_function" || node.type === "function_expression") && node.parent?.type === "variable_declarator") {
+    const body = node.childForFieldName("body");
+    if (!body) return null;
+    return { name: node.parent.childForFieldName("name")?.text ?? null, body };
+  }
+  return null;
+}
+function nestingDepthOf(node, language, depth) {
+  const nestingTypes = language === "python" ? PY_NESTING_TYPES : TS_NESTING_TYPES;
+  let maxDepth = depth;
+  for (const child of node.namedChildren) {
+    if (!child) continue;
+    const next = nestingTypes.has(child.type) ? depth + 1 : depth;
+    const childMax = nestingDepthOf(child, language, next);
+    if (childMax > maxDepth) maxDepth = childMax;
+  }
+  return maxDepth;
+}
+function cyclomaticOf(body, language) {
+  const branchTypes = language === "python" ? PY_BRANCH_TYPES : TS_BRANCH_TYPES;
+  let complexity = 1;
+  const visit = (node) => {
+    if (branchTypes.has(node.type)) complexity++;
+    if (node.type === "binary_expression") {
+      const op = node.childForFieldName("operator");
+      if (op && (op.text === "&&" || op.text === "||")) complexity++;
+    }
+    if (language === "python" && node.type === "boolean_operator") {
+      complexity++;
+    }
+    for (const child of node.namedChildren) {
+      if (child) visit(child);
+    }
+  };
+  visit(body);
+  return complexity;
+}
+
+// src/reconstruct.ts
+function reconstructFragment(repoRoot, absPath, fileId2, basis) {
+  const nodes = buildFileModuleNodes(repoRoot, absPath);
+  nodes.push(...basis.symbolsByFile.get(fileId2) ?? []);
+  const edges = basis.edgesBySrc.get(fileId2) ?? [];
+  const seenExternals = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    const dst = basis.nodesById.get(edge.dstId);
+    if (dst?.kind === "external" && !seenExternals.has(dst.id)) {
+      seenExternals.add(dst.id);
+      nodes.push({ id: dst.id, kind: "external", name: dst.name });
+    }
+  }
+  return { nodes, edges };
+}
+function reconstructCosmetic(repoRoot, absPath, fileId2, basis, parsed) {
+  const base = reconstructFragment(repoRoot, absPath, fileId2, basis);
+  const spans = collectDeclaredSpans(parsed);
+  const nodes = base.nodes.map(
+    (n) => n.kind === "symbol" ? withRefreshedSpan(n, spans) : n
+  );
+  return { nodes, edges: base.edges };
+}
+function withRefreshedSpan(node, spans) {
+  const attrs = node.attrs;
+  if (!attrs || attrs.startLine === void 0) return node;
+  const span = spans.get(node.name);
+  if (!span) return node;
+  return {
+    ...node,
+    attrs: { ...attrs, startLine: span.startLine, endLine: span.endLine }
+  };
+}
+
+// src/incremental.ts
+function hashContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function structuralSignature(file) {
+  const parts = [];
+  const visit = (node) => {
+    if (node.type === "comment") return;
+    parts.push(node.type);
+    if (node.childCount === 0) parts.push(node.text);
+    for (const child of node.children) if (child) visit(child);
+  };
+  visit(file.tree.rootNode);
+  return hashContent(parts.join(""));
+}
+function sourceLanguage(filePath) {
+  const language = getLanguageFromPath(filePath);
+  return language === "typescript" || language === "python" ? language : null;
+}
+async function readSourceFiles(filePaths) {
+  const out = [];
+  for (const filePath of filePaths) {
+    const language = sourceLanguage(filePath);
+    if (language === null) continue;
+    const content = await fs2.readFile(filePath, "utf-8");
+    out.push({ filePath, language, content, hash: hashContent(content) });
+  }
+  return out;
+}
+function classifyForReuse(readFiles, idRoot, reuse, affected = /* @__PURE__ */ new Set()) {
+  const toParse = [];
+  const reusedFileIds = [];
+  for (const rf of readFiles) {
+    const id = fileId(idRoot, rf.filePath);
+    if (reuse && reuse.fingerprints.get(id) === rf.hash && !affected.has(id)) {
+      reusedFileIds.push(id);
+    } else {
+      toParse.push(rf);
+    }
+  }
+  return { toParse, reusedFileIds };
+}
+function classifyParsed(parsedByPath, idRoot, reuse, reusedFileIds, affected = /* @__PURE__ */ new Set()) {
+  const cosmeticFileIds = /* @__PURE__ */ new Set();
+  const structuralByFileId = /* @__PURE__ */ new Map();
+  for (const [filePath, parsed] of parsedByPath) {
+    const id = fileId(idRoot, filePath);
+    const sig = structuralSignature(parsed);
+    structuralByFileId.set(id, sig);
+    if (reuse && !affected.has(id) && reuse.structuralHashes.get(id) === sig) {
+      cosmeticFileIds.add(id);
+    }
+  }
+  if (reuse) {
+    for (const id of reusedFileIds) {
+      const sig = reuse.structuralHashes.get(id);
+      if (sig !== void 0) structuralByFileId.set(id, sig);
+    }
+  }
+  return { cosmeticFileIds, structuralByFileId };
+}
+function assembleFragments(input) {
+  const fragments = [];
+  for (const rf of input.readFiles) {
+    const parsed = input.parsedByPath.get(rf.filePath);
+    const id = fileId(input.idRoot, rf.filePath);
+    if (parsed && input.reuse && input.cosmeticFileIds.has(id)) {
+      fragments.push(
+        reconstructCosmetic(input.idRoot, rf.filePath, id, input.reuse, parsed)
+      );
+    } else if (parsed) {
+      fragments.push(...input.extractor.extract(parsed));
+    } else if (input.reuse) {
+      fragments.push(
+        reconstructFragment(input.idRoot, rf.filePath, id, input.reuse)
+      );
+    }
+  }
+  return fragments;
+}
+function buildFingerprints(readFiles, idRoot, structuralByFileId) {
+  return readFiles.map((rf) => {
+    const id = fileId(idRoot, rf.filePath);
+    return {
+      fileId: id,
+      contentHash: rf.hash,
+      structuralHash: structuralByFileId.get(id)
+    };
+  });
+}
+function loadReuseBasis(db, indexVersion) {
+  for (const snap of db.listSnapshots({ limit: 50 })) {
+    if (snap.indexVersion !== indexVersion) continue;
+    const fingerprints = db.listFingerprints(snap.id);
+    if (fingerprints.length === 0) continue;
+    const nodesById = /* @__PURE__ */ new Map();
+    const symbolsByFile = /* @__PURE__ */ new Map();
+    for (const n of db.listNodes(snap.id, { includeSymbols: true })) {
+      nodesById.set(n.id, n);
+      if (n.kind === "symbol" && n.parentId) {
+        const bucket = symbolsByFile.get(n.parentId);
+        if (bucket) bucket.push(n);
+        else symbolsByFile.set(n.parentId, [n]);
+      }
+    }
+    const edgesBySrc = /* @__PURE__ */ new Map();
+    for (const e of db.listEdges(snap.id, { includeReferences: true })) {
+      const bucket = edgesBySrc.get(e.srcId);
+      if (bucket) bucket.push(e);
+      else edgesBySrc.set(e.srcId, [e]);
+    }
+    const sourceMetricsByFile = /* @__PURE__ */ new Map();
+    for (const m of db.listMetrics(snap.id)) {
+      if (!SOURCE_METRIC_NAMES.has(m.name)) continue;
+      const node = nodesById.get(m.nodeId);
+      const fileKey = node?.kind === "symbol" && node.parentId ? node.parentId : m.nodeId;
+      const bucket = sourceMetricsByFile.get(fileKey);
+      if (bucket) bucket.push(m);
+      else sourceMetricsByFile.set(fileKey, [m]);
+    }
+    const structuralHashes = /* @__PURE__ */ new Map();
+    for (const f of fingerprints) {
+      if (f.structuralHash) structuralHashes.set(f.fileId, f.structuralHash);
+    }
+    return {
+      snapshotId: snap.id,
+      fingerprints: new Map(fingerprints.map((f) => [f.fileId, f.contentHash])),
+      structuralHashes,
+      nodesById,
+      edgesBySrc,
+      sourceMetricsByFile,
+      symbolsByFile
+    };
+  }
+  return null;
+}
+
+// src/reuse-delta.ts
+function dirOf(id) {
+  const i = id.lastIndexOf("/");
+  return i < 0 ? "" : id.slice(0, i);
+}
+function normalizePosix(p) {
+  const out = [];
+  for (const seg of p.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") out.pop();
+    else out.push(seg);
+  }
+  return out.join("/");
+}
+var JS_EXT_RE = /\.(?:jsx?|mjs|cjs)$/;
+function* candidateIds(base) {
+  yield base;
+  for (const ext of RESOLVABLE_EXTS) yield base + ext;
+  const jsExt = JS_EXT_RE.exec(base);
+  if (jsExt) {
+    const stem = base.slice(0, base.length - jsExt[0].length);
+    for (const ext of RESOLVABLE_EXTS) yield stem + ext;
+  }
+  for (const ext of RESOLVABLE_EXTS) yield `${base}/index${ext}`;
+}
+function isRelative(specifier) {
+  return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+}
+function resolveRelativeId(srcFileId, specifier, fileIds) {
+  const base = normalizePosix(`${dirOf(srcFileId)}/${specifier}`);
+  for (const candidate of candidateIds(base)) {
+    if (fileIds.has(candidate)) return candidate;
+  }
+  return null;
+}
+function targetFileId(edge) {
+  return parseSymbolId(edge.dstId)?.fileId ?? edge.dstId;
+}
+function computeDeltaAffected(basis, currentFileIds) {
+  const affected = /* @__PURE__ */ new Set();
+  const removed = /* @__PURE__ */ new Set();
+  for (const id of basis.fingerprints.keys()) {
+    if (!currentFileIds.has(id)) removed.add(id);
+  }
+  const added = currentFileIds.size !== basis.fingerprints.size || removed.size > 0;
+  if (!added) return affected;
+  for (const [srcId, edges] of basis.edgesBySrc) {
+    if (!currentFileIds.has(srcId)) continue;
+    for (const edge of edges) {
+      if (isEdgeAffected(edge, srcId, removed, currentFileIds)) {
+        affected.add(srcId);
+        break;
+      }
+    }
+  }
+  return affected;
+}
+function isEdgeAffected(edge, srcId, removed, currentFileIds) {
+  if (removed.has(targetFileId(edge))) return true;
+  const specifier = edge.attrs?.specifier;
+  if (!specifier || !isRelative(specifier)) return false;
+  return resolveRelativeId(srcId, specifier, currentFileIds) !== targetFileId(edge);
+}
+
+// src/metrics.ts
+function isStructuralEdge(e) {
+  return e.kind === "imports" || e.kind === "re-exports";
+}
+function countDegrees(nodes, edges) {
+  const fanIn = /* @__PURE__ */ new Map();
+  const fanOut = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    fanIn.set(n.id, 0);
+    fanOut.set(n.id, 0);
+  }
+  for (const e of edges) {
+    if (!isStructuralEdge(e)) continue;
+    if (fanOut.has(e.srcId)) {
+      fanOut.set(e.srcId, fanOut.get(e.srcId) + 1);
+    }
+    if (fanIn.has(e.dstId)) {
+      fanIn.set(e.dstId, fanIn.get(e.dstId) + 1);
+    }
+  }
+  return { fanIn, fanOut };
+}
+function weightedInbound(nodes, edges) {
+  const util = /* @__PURE__ */ new Map();
+  for (const n of nodes) util.set(n.id, 0);
+  for (const e of resolveBarrelEdges(nodes, edges)) {
+    if (util.has(e.dstId)) util.set(e.dstId, util.get(e.dstId) + edgeWeight(e));
+  }
+  return util;
+}
+function computeMetrics(nodes, edges) {
+  const { fanIn, fanOut } = countDegrees(nodes, edges);
+  const utilization = weightedInbound(nodes, edges);
+  const out = [];
+  for (const n of nodes) {
+    if (n.kind === "symbol") {
+      out.push({ nodeId: n.id, name: "utilization", value: utilization.get(n.id) ?? 0, unit: "count" });
+      continue;
+    }
+    const ci = fanIn.get(n.id) ?? 0;
+    const co = fanOut.get(n.id) ?? 0;
+    out.push({ nodeId: n.id, name: "fan_in", value: ci, unit: "count" });
+    out.push({ nodeId: n.id, name: "fan_out", value: co, unit: "count" });
+    out.push({ nodeId: n.id, name: "utilization", value: utilization.get(n.id) ?? 0, unit: "count" });
+    if (ci + co > 0) {
+      out.push({
+        nodeId: n.id,
+        name: "instability",
+        value: co / (ci + co),
+        unit: "ratio"
+      });
+    }
+  }
+  return out;
+}
+
+// src/index-metrics.ts
+function symbolNamesByFile(nodes) {
+  const out = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.kind !== "symbol" || !n.parentId) continue;
+    const bucket = out.get(n.parentId);
+    if (bucket) bucket.add(n.name);
+    else out.set(n.parentId, /* @__PURE__ */ new Set([n.name]));
+  }
+  return out;
+}
+function buildIndexerMetrics(input) {
+  const nodeList = [...input.nodes.values()];
+  return [
+    ...computeMetrics(nodeList, [...input.edges.values()]),
+    ...computeSourceMetrics(
+      input.parsedFiles,
+      (p) => fileId(input.idRoot, p),
+      symbolNamesByFile(nodeList)
+    ),
+    ...input.reusedSourceMetrics
+  ];
+}
+
+// src/merge.ts
+function edgeKey(edge) {
+  return JSON.stringify([edge.srcId, edge.dstId, edge.kind]);
+}
+function mergeFragments(fragments) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  for (const fragment of fragments) {
+    for (const node of fragment.nodes) if (!nodes.has(node.id)) nodes.set(node.id, node);
+    for (const edge of fragment.edges) {
+      const key = edgeKey(edge);
+      if (!edges.has(key)) edges.set(key, edge);
+    }
+  }
+  return { nodes, edges };
+}
+
+// src/indexer.ts
+var INDEX_VERSION = "0.11.0";
+var LANGUAGES = ["typescript", "python"];
+function canonicalizePath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function normalizePaths(paths) {
+  if (paths.length === 0) throw new Error("indexPaths requires at least one path");
+  return [...new Set(paths.map((p) => path10.resolve(p)))];
+}
+function countByKind(items) {
+  const out = {};
+  for (const item of items) out[item.kind] = (out[item.kind] ?? 0) + 1;
+  return out;
+}
+function persist(store, ref, commitHash, accumulator, aliases, metrics) {
+  const snapshotId = store.createSnapshot({ ref, commitHash, indexVersion: INDEX_VERSION });
+  store.insertNodes(snapshotId, [...accumulator.nodes.values()]);
+  store.insertEdges(snapshotId, [...accumulator.edges.values()]);
+  if (aliases.length > 0) store.insertAliases(snapshotId, aliases);
+  if (metrics.length > 0) store.insertMetrics(snapshotId, metrics);
+  return snapshotId;
+}
+function findPriorCommit(store) {
+  return store.listSnapshots({ limit: 50 }).find((s) => s.commitHash)?.commitHash ?? null;
+}
+function resolveAliases(rootDir, idRoot, options, store) {
+  if (options.detectRenames === false) return [];
+  if (!isInsideGitRepo(rootDir)) return [];
+  const priorCommit = findPriorCommit(store);
+  if (!priorCommit) return [];
+  const target = options.commitHash ?? detectGitHead(rootDir) ?? void 0;
+  if (target === priorCommit) return [];
+  return buildAliases(idRoot, detectRenames({ repoRoot: rootDir, fromCommit: priorCommit, toCommit: target }));
+}
+function resolveRoots(paths) {
+  const raw = normalizePaths(paths);
+  const gitToplevel = detectGitToplevel(raw[0]);
+  const rootDirs = gitToplevel !== null ? raw.map(canonicalizePath) : raw;
+  return { rootDirs, idRoot: gitToplevel ?? rootDirs[0] };
+}
+async function parseAll(toParse) {
+  const parsed = /* @__PURE__ */ new Map();
+  for (const rf of toParse) {
+    parsed.set(rf.filePath, await parseFile(rf.content, rf.filePath, rf.language));
+  }
+  return parsed;
+}
+async function indexPaths(store, options) {
+  const { rootDirs, idRoot } = resolveRoots(options.paths);
+  const readFiles = await readSourceFiles(await walkSourceFiles(rootDirs, LANGUAGES));
+  const reuse = options.incremental !== false ? loadReuseBasis(store, INDEX_VERSION) : null;
+  const currentFileIds = new Set(readFiles.map((rf) => fileId(idRoot, rf.filePath)));
+  const affected = reuse ? computeDeltaAffected(reuse, currentFileIds) : /* @__PURE__ */ new Set();
+  const { toParse, reusedFileIds } = classifyForReuse(readFiles, idRoot, reuse, affected);
+  const parsedByPath = await parseAll(toParse);
+  const classified = classifyParsed(parsedByPath, idRoot, reuse, reusedFileIds, affected);
+  const accumulator = mergeFragments(
+    assembleFragments({
+      readFiles,
+      idRoot,
+      parsedByPath,
+      reuse,
+      cosmeticFileIds: classified.cosmeticFileIds,
+      extractor: new LanguageExtractor({ repoRoot: idRoot, tsConfigPath: options.tsConfig })
+    })
+  );
+  const annotated = annotateRoles([...accumulator.nodes.values()], computeRoleHints(readFiles, idRoot, fileId));
+  accumulator.nodes = new Map(annotated.map((n) => [n.id, n]));
+  pruneDanglingReferences(accumulator.nodes, accumulator.edges);
+  const metrics = options.computeMetrics === false ? [] : buildIndexerMetrics({
+    nodes: accumulator.nodes,
+    edges: accumulator.edges,
+    parsedFiles: [...parsedByPath.values()],
+    reusedSourceMetrics: reuse ? reusedFileIds.flatMap((id) => reuse.sourceMetricsByFile.get(id) ?? []) : [],
+    idRoot
+  });
+  const rootDir = rootDirs[0];
+  const aliases = resolveAliases(rootDir, idRoot, options, store);
+  const commitHash = options.commitHash ?? detectGitHead(rootDir) ?? void 0;
+  const snapshotId = persist(store, options.ref ?? "wd", commitHash, accumulator, aliases, metrics);
+  store.insertFingerprints(snapshotId, buildFingerprints(readFiles, idRoot, classified.structuralByFileId));
+  return {
+    snapshotId,
+    files: readFiles.length,
+    nodes: accumulator.nodes.size,
+    edges: accumulator.edges.size,
+    aliases: aliases.length,
+    metrics: metrics.length,
+    reused: reusedFileIds.length,
+    reparsed: toParse.length,
+    cosmetic: classified.cosmeticFileIds.size,
+    nodesByKind: countByKind(accumulator.nodes.values()),
+    edgesByKind: countByKind(accumulator.edges.values())
+  };
+}
+
+// src/aliases.ts
+var METRIC_ALIASES = /* @__PURE__ */ new Map([
+  ["lines", "loc"],
+  ["lines_of_code", "loc"],
+  ["fan-in", "fan_in"],
+  ["fanin", "fan_in"],
+  ["fan-out", "fan_out"],
+  ["fanout", "fan_out"],
+  ["nesting_depth", "max_nesting_depth"],
+  ["max-nesting-depth", "max_nesting_depth"],
+  ["lcom4", "lcom4_max"]
+]);
+var ROLE_ALIASES = /* @__PURE__ */ new Map([
+  ["tests", "test"],
+  ["spec", "test"],
+  ["specs", "test"],
+  ["fixtures", "fixture"],
+  ["barrels", "barrel"]
+]);
+var EDGE_KIND_ALIASES = /* @__PURE__ */ new Map([
+  ["import", "imports"],
+  ["call", "calls"],
+  ["reference", "references"],
+  ["re_exports", "re-exports"],
+  ["reexports", "re-exports"],
+  ["re-export", "re-exports"],
+  ["depends_on", "depends-on"],
+  ["dependson", "depends-on"]
+]);
+function canonicalMetricName(name) {
+  return METRIC_ALIASES.get(name) ?? name;
+}
+function canonicalRole(name) {
+  return ROLE_ALIASES.get(name) ?? name;
+}
+function canonicalEdgeKind(name) {
+  return EDGE_KIND_ALIASES.get(name) ?? name;
+}
+
+// src/read.ts
+function listNodes(store, snapshotId, opts) {
+  return store.listNodes(snapshotId, opts);
+}
+function listEdges(store, snapshotId, opts) {
+  return store.listEdges(snapshotId, opts);
+}
+function listMetrics(store, snapshotId) {
+  return store.listMetrics(snapshotId);
+}
+export {
+  ALL_ROLES,
+  CodeGraphStore,
+  DOMAIN_DDL,
+  INDEX_VERSION,
+  KIT,
+  LanguageExtractor,
+  MIGRATIONS,
+  PythonGraphExtractor,
+  SOURCE_METRIC_NAMES,
+  SYMBOL_ID_SEP,
+  TsMorphGraphExtractor,
+  annotateRoles,
+  buildAliases,
+  buildFileModuleNodes,
+  buildIndexerMetrics,
+  canonicalEdgeKind,
+  canonicalMetricName,
+  canonicalRole,
+  classifyRole,
+  collectDeclaredNames,
+  collectDeclaredSpans,
+  computeMetrics,
+  computeRoleHints,
+  computeSourceMetrics,
+  detectGitHead,
+  detectGitToplevel,
+  detectRenames,
+  edgeWeight,
+  externalId,
+  fileId,
+  getLanguageFromPath,
+  getSupportedLanguages,
+  hashContent,
+  indexPaths,
+  isGeneratedByHeuristic,
+  isGeneratedFile,
+  isInsideGitRepo,
+  listEdges,
+  listMetrics,
+  listNodes,
+  loadGeneratedPatterns,
+  moduleId,
+  openCodeGraph,
+  packageId,
+  parentModuleId,
+  parseFile,
+  parseSymbolId,
+  pruneDanglingReferences,
+  readSourceFiles,
+  resolveBarrelEdges,
+  shouldIncludeFile,
+  structuralSignature,
+  symbolId,
+  walkSourceFiles
+};
+//# sourceMappingURL=index.js.map