codeorbit 0.1.0

package/dist/index.js

@@ -0,0 +1,1932 @@
+// src/infrastructure/SqliteGraphRepository.ts
+import fs from "fs";
+import path from "path";
+import Database from "better-sqlite3";
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS nodes (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    kind TEXT NOT NULL,
+    name TEXT NOT NULL,
+    qualified_name TEXT NOT NULL UNIQUE,
+    file_path TEXT NOT NULL,
+    line_start INTEGER,
+    line_end INTEGER,
+    language TEXT,
+    parent_name TEXT,
+    params TEXT,
+    return_type TEXT,
+    modifiers TEXT,
+    is_test INTEGER DEFAULT 0,
+    file_hash TEXT,
+    extra TEXT DEFAULT '{}',
+    updated_at REAL NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    kind TEXT NOT NULL,
+    source_qualified TEXT NOT NULL,
+    target_qualified TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    line INTEGER DEFAULT 0,
+    extra TEXT DEFAULT '{}',
+    updated_at REAL NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_nodes_file ON nodes(file_path);
+CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind);
+CREATE INDEX IF NOT EXISTS idx_nodes_qualified ON nodes(qualified_name);
+CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_qualified);
+CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_qualified);
+CREATE INDEX IF NOT EXISTS idx_edges_kind ON edges(kind);
+CREATE INDEX IF NOT EXISTS idx_edges_file ON edges(file_path);
+`;
+var SqliteGraphRepository = class {
+  db;
+  adjCache = null;
+  dbPath;
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    const dir = path.dirname(dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 5000");
+    try {
+      this.db.pragma("wal_checkpoint(TRUNCATE)");
+    } catch {
+    }
+    this._initSchema();
+  }
+  close() {
+    try {
+      this.db.pragma("wal_checkpoint(TRUNCATE)");
+    } catch {
+    }
+    this.db.close();
+    for (const suffix of ["-wal", "-shm"]) {
+      const side = this.dbPath + suffix;
+      try {
+        if (fs.existsSync(side)) {
+          fs.unlinkSync(side);
+        }
+      } catch {
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Write operations
+  // ---------------------------------------------------------------------------
+  upsertNode(node, fileHash2 = "") {
+    const now = Date.now() / 1e3;
+    const qualified = this._makeQualified(node);
+    const extra = node.extra ? JSON.stringify(node.extra) : "{}";
+    this.db.prepare(`
+      INSERT INTO nodes
+        (kind, name, qualified_name, file_path, line_start, line_end,
+         language, parent_name, params, return_type, modifiers, is_test,
+         file_hash, extra, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(qualified_name) DO UPDATE SET
+        kind=excluded.kind, name=excluded.name,
+        file_path=excluded.file_path, line_start=excluded.line_start,
+        line_end=excluded.line_end, language=excluded.language,
+        parent_name=excluded.parent_name, params=excluded.params,
+        return_type=excluded.return_type, modifiers=excluded.modifiers,
+        is_test=excluded.is_test, file_hash=excluded.file_hash,
+        extra=excluded.extra, updated_at=excluded.updated_at
+    `).run(
+      node.kind,
+      node.name,
+      qualified,
+      node.filePath,
+      node.lineStart,
+      node.lineEnd,
+      node.language ?? null,
+      node.parentName ?? null,
+      node.params ?? null,
+      node.returnType ?? null,
+      node.modifiers ?? null,
+      node.isTest ? 1 : 0,
+      fileHash2,
+      extra,
+      now
+    );
+    const row = this.db.prepare(
+      "SELECT id FROM nodes WHERE qualified_name = ?"
+    ).get(qualified);
+    return row.id;
+  }
+  upsertEdge(edge) {
+    const now = Date.now() / 1e3;
+    const extra = edge.extra ? JSON.stringify(edge.extra) : "{}";
+    const line = edge.line ?? 0;
+    const existing = this.db.prepare(`
+      SELECT id FROM edges
+      WHERE kind=? AND source_qualified=? AND target_qualified=?
+            AND file_path=? AND line=?
+    `).get(edge.kind, edge.source, edge.target, edge.filePath, line);
+    if (existing) {
+      this.db.prepare(
+        "UPDATE edges SET line=?, extra=?, updated_at=? WHERE id=?"
+      ).run(line, extra, now, existing.id);
+      return existing.id;
+    }
+    const result = this.db.prepare(`
+      INSERT INTO edges
+        (kind, source_qualified, target_qualified, file_path, line, extra, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(edge.kind, edge.source, edge.target, edge.filePath, line, extra, now);
+    return Number(result.lastInsertRowid);
+  }
+  removeFileData(filePath) {
+    this.db.prepare("DELETE FROM nodes WHERE file_path = ?").run(filePath);
+    this.db.prepare("DELETE FROM edges WHERE file_path = ?").run(filePath);
+    this._invalidateCache();
+  }
+  storeFileNodesEdges(filePath, nodes, edges, fileHash2 = "") {
+    const txn = this.db.transaction(() => {
+      this.removeFileData(filePath);
+      for (const node of nodes) {
+        this.upsertNode(node, fileHash2);
+      }
+      for (const edge of edges) {
+        this.upsertEdge(edge);
+      }
+    });
+    txn();
+    this._invalidateCache();
+  }
+  setMetadata(key, value) {
+    this.db.prepare(
+      "INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)"
+    ).run(key, value);
+  }
+  getMetadata(key) {
+    const row = this.db.prepare(
+      "SELECT value FROM metadata WHERE key = ?"
+    ).get(key);
+    return row?.value;
+  }
+  // ---------------------------------------------------------------------------
+  // Read operations
+  // ---------------------------------------------------------------------------
+  getNode(qualifiedName) {
+    const row = this.db.prepare(
+      "SELECT * FROM nodes WHERE qualified_name = ?"
+    ).get(qualifiedName);
+    return row ? this._rowToNode(row) : void 0;
+  }
+  getNodesByFile(filePath) {
+    const rows = this.db.prepare(
+      "SELECT * FROM nodes WHERE file_path = ? ORDER BY line_start"
+    ).all(filePath);
+    return rows.map((r) => this._rowToNode(r));
+  }
+  getEdgesBySource(qualifiedName) {
+    const rows = this.db.prepare(
+      "SELECT * FROM edges WHERE source_qualified = ?"
+    ).all(qualifiedName);
+    return rows.map((r) => this._rowToEdge(r));
+  }
+  getEdgesByTarget(qualifiedName) {
+    const rows = this.db.prepare(
+      "SELECT * FROM edges WHERE target_qualified = ?"
+    ).all(qualifiedName);
+    return rows.map((r) => this._rowToEdge(r));
+  }
+  searchEdgesByTargetName(name, kind = "CALLS") {
+    const rows = this.db.prepare(
+      "SELECT * FROM edges WHERE target_qualified = ? AND kind = ?"
+    ).all(name, kind);
+    return rows.map((r) => this._rowToEdge(r));
+  }
+  getAllFiles() {
+    const rows = this.db.prepare(
+      "SELECT DISTINCT file_path FROM nodes WHERE kind = 'File' ORDER BY file_path"
+    ).all();
+    return rows.map((r) => r.file_path);
+  }
+  searchNodes(query, limit = 20) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (words.length === 0) {
+      return [];
+    }
+    const conditions = words.map(
+      () => "(LOWER(name) LIKE ? OR LOWER(qualified_name) LIKE ?)"
+    );
+    const params = [];
+    for (const word of words) {
+      params.push(`%${word}%`, `%${word}%`);
+    }
+    params.push(limit);
+    const where = conditions.join(" AND ");
+    const rows = this.db.prepare(
+      `SELECT * FROM nodes WHERE ${where} LIMIT ?`
+    ).all(...params);
+    return rows.map((r) => this._rowToNode(r));
+  }
+  getSubgraph(qualifiedNames) {
+    const nodes = [];
+    for (const qn of qualifiedNames) {
+      const n = this.getNode(qn);
+      if (n) {
+        nodes.push(n);
+      }
+    }
+    const qnSet = new Set(qualifiedNames);
+    const edges = [];
+    for (const qn of qualifiedNames) {
+      for (const e of this.getEdgesBySource(qn)) {
+        if (qnSet.has(e.targetQualified)) {
+          edges.push(e);
+        }
+      }
+    }
+    return { nodes, edges };
+  }
+  getStats() {
+    const totalNodes = this.db.prepare("SELECT COUNT(*) AS cnt FROM nodes").get().cnt;
+    const totalEdges = this.db.prepare("SELECT COUNT(*) AS cnt FROM edges").get().cnt;
+    const nodesByKind = {};
+    for (const r of this.db.prepare(
+      "SELECT kind, COUNT(*) AS cnt FROM nodes GROUP BY kind"
+    ).all()) {
+      nodesByKind[r.kind] = r.cnt;
+    }
+    const edgesByKind = {};
+    for (const r of this.db.prepare(
+      "SELECT kind, COUNT(*) AS cnt FROM edges GROUP BY kind"
+    ).all()) {
+      edgesByKind[r.kind] = r.cnt;
+    }
+    const languages = this.db.prepare(
+      "SELECT DISTINCT language FROM nodes WHERE language IS NOT NULL AND language != ''"
+    ).all().map((r) => r.language);
+    const filesCount = this.db.prepare(
+      "SELECT COUNT(*) AS cnt FROM nodes WHERE kind = 'File'"
+    ).get().cnt;
+    const lastUpdated = this.getMetadata("last_updated") ?? null;
+    let embeddingsCount = 0;
+    try {
+      embeddingsCount = this.db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get().cnt;
+    } catch {
+    }
+    return {
+      totalNodes,
+      totalEdges,
+      nodesByKind,
+      edgesByKind,
+      languages,
+      filesCount,
+      lastUpdated,
+      embeddingsCount
+    };
+  }
+  getNodesBySize(minLines = 50, maxLines, kind, filePathPattern, limit = 50) {
+    const conditions = [
+      "line_start IS NOT NULL",
+      "line_end IS NOT NULL",
+      "(line_end - line_start + 1) >= ?"
+    ];
+    const params = [minLines];
+    if (maxLines !== void 0) {
+      conditions.push("(line_end - line_start + 1) <= ?");
+      params.push(maxLines);
+    }
+    if (kind) {
+      conditions.push("kind = ?");
+      params.push(kind);
+    }
+    if (filePathPattern) {
+      conditions.push("file_path LIKE ?");
+      params.push(`%${filePathPattern}%`);
+    }
+    params.push(limit);
+    const where = conditions.join(" AND ");
+    const rows = this.db.prepare(
+      `SELECT * FROM nodes WHERE ${where} ORDER BY (line_end - line_start + 1) DESC LIMIT ?`
+    ).all(...params);
+    return rows.map((r) => ({
+      ...this._rowToNode(r),
+      lineCount: r.line_start != null && r.line_end != null ? r.line_end - r.line_start + 1 : 0
+    }));
+  }
+  getAllEdges() {
+    const rows = this.db.prepare("SELECT * FROM edges").all();
+    return rows.map((r) => this._rowToEdge(r));
+  }
+  getEdgesAmong(qualifiedNames) {
+    if (qualifiedNames.size === 0) {
+      return [];
+    }
+    const qns = [...qualifiedNames];
+    const results = [];
+    const batchSize = 450;
+    for (let i = 0; i < qns.length; i += batchSize) {
+      const batch = qns.slice(i, i + batchSize);
+      const placeholders = batch.map(() => "?").join(",");
+      const rows = this.db.prepare(
+        `SELECT * FROM edges WHERE source_qualified IN (${placeholders})`
+      ).all(...batch);
+      for (const r of rows) {
+        const edge = this._rowToEdge(r);
+        if (qualifiedNames.has(edge.targetQualified)) {
+          results.push(edge);
+        }
+      }
+    }
+    return results;
+  }
+  // ---------------------------------------------------------------------------
+  // Adjacency (BFS support for use cases)
+  // ---------------------------------------------------------------------------
+  getAdjacency() {
+    const cache = this._buildAdjacency();
+    return { outgoing: cache.out, incoming: cache.in };
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  _initSchema() {
+    this.db.exec(SCHEMA_SQL);
+    this.setMetadata("schema_version", "1");
+  }
+  _invalidateCache() {
+    this.adjCache = null;
+  }
+  _buildAdjacency() {
+    if (this.adjCache) {
+      return this.adjCache;
+    }
+    const out = /* @__PURE__ */ new Map();
+    const inMap = /* @__PURE__ */ new Map();
+    const rows = this.db.prepare("SELECT source_qualified, target_qualified FROM edges").all();
+    for (const r of rows) {
+      if (!out.has(r.source_qualified)) {
+        out.set(r.source_qualified, /* @__PURE__ */ new Set());
+      }
+      out.get(r.source_qualified).add(r.target_qualified);
+      if (!inMap.has(r.target_qualified)) {
+        inMap.set(r.target_qualified, /* @__PURE__ */ new Set());
+      }
+      inMap.get(r.target_qualified).add(r.source_qualified);
+    }
+    this.adjCache = { out, in: inMap };
+    return this.adjCache;
+  }
+  _makeQualified(node) {
+    if (node.kind === "File") {
+      return node.filePath;
+    }
+    if (node.parentName) {
+      return `${node.filePath}::${node.parentName}.${node.name}`;
+    }
+    return `${node.filePath}::${node.name}`;
+  }
+  _rowToNode(row) {
+    return {
+      id: row.id,
+      kind: row.kind,
+      name: row.name,
+      qualifiedName: row.qualified_name,
+      filePath: row.file_path,
+      lineStart: row.line_start,
+      lineEnd: row.line_end,
+      language: row.language ?? null,
+      parentName: row.parent_name ?? null,
+      params: row.params ?? null,
+      returnType: row.return_type ?? null,
+      modifiers: row.modifiers ?? null,
+      isTest: row.is_test === 1,
+      fileHash: row.file_hash ?? null
+    };
+  }
+  _rowToEdge(row) {
+    return {
+      id: row.id,
+      kind: row.kind,
+      sourceQualified: row.source_qualified,
+      targetQualified: row.target_qualified,
+      filePath: row.file_path,
+      line: row.line ?? 0
+    };
+  }
+};
+
+// src/infrastructure/TreeSitterParser.ts
+import crypto from "crypto";
+import fs2 from "fs";
+import { createRequire } from "module";
+import path2 from "path";
+import Parser from "tree-sitter";
+var _require = createRequire(import.meta.url);
+function loadLanguage(pkg) {
+  try {
+    const mod = _require(pkg);
+    return mod.default ?? mod;
+  } catch {
+    return null;
+  }
+}
+var _languageCache = /* @__PURE__ */ new Map();
+function getLanguage(name) {
+  if (_languageCache.has(name)) {
+    return _languageCache.get(name) ?? null;
+  }
+  const pkgMap = {
+    python: "tree-sitter-python",
+    javascript: "tree-sitter-javascript",
+    typescript: "tree-sitter-typescript/bindings/node/typescript",
+    tsx: "tree-sitter-typescript/bindings/node/tsx",
+    go: "tree-sitter-go",
+    rust: "tree-sitter-rust",
+    java: "tree-sitter-java",
+    c: "tree-sitter-c",
+    cpp: "tree-sitter-cpp",
+    csharp: "tree-sitter-c-sharp",
+    ruby: "tree-sitter-ruby",
+    kotlin: "tree-sitter-kotlin",
+    swift: "tree-sitter-swift",
+    php: "tree-sitter-php/php",
+    solidity: "tree-sitter-solidity",
+    vue: "tree-sitter-vue"
+  };
+  const pkg = pkgMap[name];
+  const lang = pkg ? loadLanguage(pkg) : null;
+  _languageCache.set(name, lang);
+  return lang;
+}
+var EXTENSION_TO_LANGUAGE = {
+  ".py": "python",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".ts": "typescript",
+  ".tsx": "tsx",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".cs": "csharp",
+  ".rb": "ruby",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".c": "c",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".kt": "kotlin",
+  ".swift": "swift",
+  ".php": "php",
+  ".sol": "solidity",
+  ".vue": "vue"
+};
+var CLASS_TYPES = {
+  python: ["class_definition"],
+  javascript: ["class_declaration", "class"],
+  typescript: ["class_declaration", "class"],
+  tsx: ["class_declaration", "class"],
+  go: ["type_declaration"],
+  rust: ["struct_item", "enum_item", "impl_item"],
+  java: ["class_declaration", "interface_declaration", "enum_declaration"],
+  c: ["struct_specifier", "type_definition"],
+  cpp: ["class_specifier", "struct_specifier"],
+  csharp: ["class_declaration", "interface_declaration", "enum_declaration", "struct_declaration"],
+  ruby: ["class", "module"],
+  kotlin: ["class_declaration", "object_declaration"],
+  swift: ["class_declaration", "struct_declaration", "protocol_declaration"],
+  php: ["class_declaration", "interface_declaration"],
+  solidity: [
+    "contract_declaration",
+    "interface_declaration",
+    "library_declaration",
+    "struct_declaration",
+    "enum_declaration",
+    "error_declaration",
+    "user_defined_type_definition"
+  ]
+};
+var FUNCTION_TYPES = {
+  python: ["function_definition"],
+  javascript: ["function_declaration", "method_definition", "arrow_function"],
+  typescript: ["function_declaration", "method_definition", "arrow_function"],
+  tsx: ["function_declaration", "method_definition", "arrow_function"],
+  go: ["function_declaration", "method_declaration"],
+  rust: ["function_item"],
+  java: ["method_declaration", "constructor_declaration"],
+  c: ["function_definition"],
+  cpp: ["function_definition"],
+  csharp: ["method_declaration", "constructor_declaration"],
+  ruby: ["method", "singleton_method"],
+  kotlin: ["function_declaration"],
+  swift: ["function_declaration"],
+  php: ["function_definition", "method_declaration"],
+  solidity: [
+    "function_definition",
+    "constructor_definition",
+    "modifier_definition",
+    "event_definition",
+    "fallback_receive_definition"
+  ]
+};
+var IMPORT_TYPES = {
+  python: ["import_statement", "import_from_statement"],
+  javascript: ["import_statement"],
+  typescript: ["import_statement"],
+  tsx: ["import_statement"],
+  go: ["import_declaration"],
+  rust: ["use_declaration"],
+  java: ["import_declaration"],
+  c: ["preproc_include"],
+  cpp: ["preproc_include"],
+  csharp: ["using_directive"],
+  ruby: ["call"],
+  // require / require_relative
+  kotlin: ["import_header"],
+  swift: ["import_declaration"],
+  php: ["namespace_use_declaration"],
+  solidity: ["import_directive"]
+};
+var CALL_TYPES = {
+  python: ["call"],
+  javascript: ["call_expression", "new_expression"],
+  typescript: ["call_expression", "new_expression"],
+  tsx: ["call_expression", "new_expression"],
+  go: ["call_expression"],
+  rust: ["call_expression", "macro_invocation"],
+  java: ["method_invocation", "object_creation_expression"],
+  c: ["call_expression"],
+  cpp: ["call_expression"],
+  csharp: ["invocation_expression", "object_creation_expression"],
+  ruby: ["call", "method_call"],
+  kotlin: ["call_expression"],
+  swift: ["call_expression"],
+  php: ["function_call_expression", "member_call_expression"],
+  solidity: ["call_expression"]
+};
+var TEST_PATTERNS = [
+  /^test_/,
+  /^Test/,
+  /_test$/,
+  /\.test\./,
+  /\.spec\./,
+  /_spec$/
+];
+var TEST_FILE_PATTERNS = [
+  /test_.*\.py$/,
+  /.*_test\.py$/,
+  /.*\.test\.[jt]sx?$/,
+  /.*\.spec\.[jt]sx?$/,
+  /.*_test\.go$/,
+  /tests?\//
+];
+function isTestFile(filePath) {
+  return TEST_FILE_PATTERNS.some((p) => p.test(filePath));
+}
+var TEST_RUNNER_NAMES = /* @__PURE__ */ new Set([
+  "describe",
+  "it",
+  "test",
+  "beforeEach",
+  "afterEach",
+  "beforeAll",
+  "afterAll"
+]);
+function isTestFunction(name, filePath) {
+  if (TEST_PATTERNS.some((p) => p.test(name))) {
+    return true;
+  }
+  if (isTestFile(filePath) && TEST_RUNNER_NAMES.has(name)) {
+    return true;
+  }
+  return false;
+}
+function fileHash(filePath) {
+  const buf = fs2.readFileSync(filePath);
+  return crypto.createHash("sha256").update(buf).digest("hex");
+}
+var MAX_AST_DEPTH = 180;
+var MODULE_CACHE_MAX = 15e3;
+var CodeParser = class {
+  parsers = /* @__PURE__ */ new Map();
+  moduleFileCache = /* @__PURE__ */ new Map();
+  getParser(language) {
+    if (this.parsers.has(language)) {
+      return this.parsers.get(language) ?? null;
+    }
+    try {
+      const lang = getLanguage(language);
+      if (!lang) {
+        return null;
+      }
+      const p = new Parser();
+      p.setLanguage(lang);
+      this.parsers.set(language, p);
+      return p;
+    } catch {
+      return null;
+    }
+  }
+  detectLanguage(filePath) {
+    const ext = path2.extname(filePath).toLowerCase();
+    return EXTENSION_TO_LANGUAGE[ext] ?? null;
+  }
+  parseFile(filePath) {
+    let source;
+    try {
+      source = fs2.readFileSync(filePath);
+    } catch {
+      return [[], []];
+    }
+    return this.parseBytes(filePath, source);
+  }
+  parseBytes(filePath, source) {
+    const language = this.detectLanguage(filePath);
+    if (!language) {
+      return [[], []];
+    }
+    if (language === "vue") {
+      return this._parseVue(filePath, source);
+    }
+    const parser = this.getParser(language);
+    if (!parser) {
+      return [[], []];
+    }
+    const tree = parser.parse(source.toString("utf-8"));
+    const nodes = [];
+    const edges = [];
+    const testFile = isTestFile(filePath);
+    const lineCount = source.toString("utf-8").split("\n").length;
+    nodes.push({
+      kind: "File",
+      name: filePath,
+      filePath,
+      lineStart: 1,
+      lineEnd: lineCount,
+      language,
+      isTest: testFile
+    });
+    const [importMap, definedNames] = this._collectFileScope(
+      tree.rootNode,
+      language,
+      source
+    );
+    this._extractFromTree(
+      tree.rootNode,
+      source,
+      language,
+      filePath,
+      nodes,
+      edges,
+      void 0,
+      void 0,
+      importMap,
+      definedNames
+    );
+    const resolvedEdges = this._resolveCallTargets(nodes, edges, filePath);
+    if (testFile) {
+      const testQNames = /* @__PURE__ */ new Set();
+      for (const n of nodes) {
+        if (n.isTest) {
+          testQNames.add(this._qualify(n.name, filePath, n.parentName ?? null));
+        }
+      }
+      const testedBy = [];
+      for (const edge of resolvedEdges) {
+        if (edge.kind === "CALLS" && testQNames.has(edge.source)) {
+          testedBy.push({
+            kind: "TESTED_BY",
+            source: edge.target,
+            target: edge.source,
+            filePath: edge.filePath,
+            line: edge.line
+          });
+        }
+      }
+      resolvedEdges.push(...testedBy);
+    }
+    return [nodes, resolvedEdges];
+  }
+  _parseVue(filePath, source) {
+    const vueParser = this.getParser("vue");
+    if (!vueParser) {
+      return [[], []];
+    }
+    const tree = vueParser.parse(source.toString("utf-8"));
+    const testFile = isTestFile(filePath);
+    const lineCount = source.toString("utf-8").split("\n").length;
+    const allNodes = [{
+      kind: "File",
+      name: filePath,
+      filePath,
+      lineStart: 1,
+      lineEnd: lineCount,
+      language: "vue",
+      isTest: testFile
+    }];
+    const allEdges = [];
+    for (const child of tree.rootNode.children) {
+      if (child.type !== "script_element") {
+        continue;
+      }
+      let scriptLang = "javascript";
+      let startTag = null;
+      let rawTextNode = null;
+      for (const sub of child.children) {
+        if (sub.type === "start_tag") {
+          startTag = sub;
+        } else if (sub.type === "raw_text") {
+          rawTextNode = sub;
+        }
+      }
+      if (startTag) {
+        for (const attr of startTag.children) {
+          if (attr.type === "attribute") {
+            let attrName = null;
+            let attrValue = null;
+            for (const a of attr.children) {
+              if (a.type === "attribute_name") {
+                attrName = a.text;
+              } else if (a.type === "quoted_attribute_value") {
+                for (const v of a.children) {
+                  if (v.type === "attribute_value") {
+                    attrValue = v.text;
+                  }
+                }
+              }
+            }
+            if (attrName === "lang" && (attrValue === "ts" || attrValue === "typescript")) {
+              scriptLang = "typescript";
+            }
+          }
+        }
+      }
+      if (!rawTextNode) {
+        continue;
+      }
+      const scriptSource = Buffer.from(rawTextNode.text, "utf-8");
+      const lineOffset = rawTextNode.startPosition.row;
+      const scriptParser = this.getParser(scriptLang);
+      if (!scriptParser) {
+        continue;
+      }
+      const scriptTree = scriptParser.parse(scriptSource.toString("utf-8"));
+      const [importMap, definedNames] = this._collectFileScope(
+        scriptTree.rootNode,
+        scriptLang,
+        scriptSource
+      );
+      const nodes = [];
+      const edges = [];
+      this._extractFromTree(
+        scriptTree.rootNode,
+        scriptSource,
+        scriptLang,
+        filePath,
+        nodes,
+        edges,
+        void 0,
+        void 0,
+        importMap,
+        definedNames
+      );
+      for (const n of nodes) {
+        n.lineStart += lineOffset;
+        n.lineEnd += lineOffset;
+        n.language = "vue";
+      }
+      for (const e of edges) {
+        e.line = (e.line ?? 0) + lineOffset;
+      }
+      allNodes.push(...nodes);
+      allEdges.push(...edges);
+    }
+    if (testFile) {
+      const testQNames = /* @__PURE__ */ new Set();
+      for (const n of allNodes) {
+        if (n.isTest) {
+          testQNames.add(this._qualify(n.name, filePath, n.parentName ?? null));
+        }
+      }
+      const testedBy = [];
+      for (const edge of allEdges) {
+        if (edge.kind === "CALLS" && testQNames.has(edge.source)) {
+          testedBy.push({
+            kind: "TESTED_BY",
+            source: edge.target,
+            target: edge.source,
+            filePath: edge.filePath,
+            line: edge.line
+          });
+        }
+      }
+      allEdges.push(...testedBy);
+    }
+    return [allNodes, allEdges];
+  }
+  _resolveCallTargets(nodes, edges, filePath) {
+    const symbols = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      if (["Function", "Class", "Type", "Test"].includes(node.kind)) {
+        const bare = node.name;
+        if (!symbols.has(bare)) {
+          symbols.set(bare, this._qualify(bare, filePath, node.parentName ?? null));
+        }
+      }
+    }
+    return edges.map((edge) => {
+      if (edge.kind === "CALLS" && !edge.target.includes("::")) {
+        const qualified = symbols.get(edge.target);
+        if (qualified) {
+          return { ...edge, target: qualified };
+        }
+      }
+      return edge;
+    });
+  }
+  _extractFromTree(root, source, language, filePath, nodes, edges, enclosingClass, enclosingFunc, importMap, definedNames, depth = 0) {
+    if (depth > MAX_AST_DEPTH) {
+      return;
+    }
+    const classTypes = new Set(CLASS_TYPES[language] ?? []);
+    const funcTypes = new Set(FUNCTION_TYPES[language] ?? []);
+    const importTypes = new Set(IMPORT_TYPES[language] ?? []);
+    const callTypes = new Set(CALL_TYPES[language] ?? []);
+    for (const child of root.children) {
+      const nodeType = child.type;
+      if (classTypes.has(nodeType)) {
+        const name = this._getName(child, language, "class");
+        if (name) {
+          nodes.push({
+            kind: "Class",
+            name,
+            filePath,
+            lineStart: child.startPosition.row + 1,
+            lineEnd: child.endPosition.row + 1,
+            language,
+            parentName: enclosingClass ?? null
+          });
+          edges.push({
+            kind: "CONTAINS",
+            source: filePath,
+            target: this._qualify(name, filePath, enclosingClass ?? null),
+            filePath,
+            line: child.startPosition.row + 1
+          });
+          const bases = this._getBases(child, language);
+          for (const base of bases) {
+            edges.push({
+              kind: "INHERITS",
+              source: this._qualify(name, filePath, enclosingClass ?? null),
+              target: base,
+              filePath,
+              line: child.startPosition.row + 1
+            });
+          }
+          this._extractFromTree(
+            child,
+            source,
+            language,
+            filePath,
+            nodes,
+            edges,
+            name,
+            null,
+            importMap,
+            definedNames,
+            depth + 1
+          );
+          continue;
+        }
+      }
+      if (funcTypes.has(nodeType)) {
+        const name = this._getName(child, language, "function");
+        if (name) {
+          const isTest = isTestFunction(name, filePath);
+          const kind = isTest ? "Test" : "Function";
+          const qualified = this._qualify(name, filePath, enclosingClass ?? null);
+          const params = this._getParams(child, language);
+          const retType = this._getReturnType(child, language);
+          nodes.push({
+            kind,
+            name,
+            filePath,
+            lineStart: child.startPosition.row + 1,
+            lineEnd: child.endPosition.row + 1,
+            language,
+            parentName: enclosingClass ?? null,
+            params,
+            returnType: retType,
+            isTest
+          });
+          const container = enclosingClass ? this._qualify(enclosingClass, filePath, null) : filePath;
+          edges.push({
+            kind: "CONTAINS",
+            source: container,
+            target: qualified,
+            filePath,
+            line: child.startPosition.row + 1
+          });
+          if (language === "solidity") {
+            for (const sub of child.children) {
+              if (sub.type === "modifier_invocation") {
+                for (const ident of sub.children) {
+                  if (ident.type === "identifier") {
+                    edges.push({
+                      kind: "CALLS",
+                      source: qualified,
+                      target: ident.text,
+                      filePath,
+                      line: sub.startPosition.row + 1
+                    });
+                    break;
+                  }
+                }
+              }
+            }
+          }
+          this._extractFromTree(
+            child,
+            source,
+            language,
+            filePath,
+            nodes,
+            edges,
+            enclosingClass,
+            name,
+            importMap,
+            definedNames,
+            depth + 1
+          );
+          continue;
+        }
+      }
+      if (importTypes.has(nodeType)) {
+        const imports = this._extractImport(child, language);
+        for (const impTarget of imports) {
+          edges.push({
+            kind: "IMPORTS_FROM",
+            source: filePath,
+            target: impTarget,
+            filePath,
+            line: child.startPosition.row + 1
+          });
+        }
+        continue;
+      }
+      if (callTypes.has(nodeType)) {
+        const callName = this._getCallName(child, language);
+        if (callName && enclosingFunc) {
+          const caller = this._qualify(enclosingFunc, filePath, enclosingClass ?? null);
+          const target = this._resolveCallTarget(
+            callName,
+            filePath,
+            language,
+            importMap ?? /* @__PURE__ */ new Map(),
+            definedNames ?? /* @__PURE__ */ new Set()
+          );
+          edges.push({
+            kind: "CALLS",
+            source: caller,
+            target,
+            filePath,
+            line: child.startPosition.row + 1
+          });
+        }
+      }
+      if (language === "solidity") {
+        if (nodeType === "emit_statement" && enclosingFunc) {
+          for (const sub of child.children) {
+            if (sub.type === "expression") {
+              for (const ident of sub.children) {
+                if (ident.type === "identifier") {
+                  const caller = this._qualify(
+                    enclosingFunc,
+                    filePath,
+                    enclosingClass ?? null
+                  );
+                  edges.push({
+                    kind: "CALLS",
+                    source: caller,
+                    target: ident.text,
+                    filePath,
+                    line: child.startPosition.row + 1
+                  });
+                }
+              }
+            }
+          }
+        }
+        if (nodeType === "state_variable_declaration" && enclosingClass) {
+          let varName = null;
+          let varVisibility = null;
+          let varType = null;
+          let varMutability = null;
+          for (const sub of child.children) {
+            if (sub.type === "identifier") {
+              varName = sub.text;
+            } else if (sub.type === "visibility") {
+              varVisibility = sub.text;
+            } else if (sub.type === "type_name") {
+              varType = sub.text;
+            } else if (sub.type === "constant" || sub.type === "immutable") {
+              varMutability = sub.type;
+            }
+          }
+          if (varName) {
+            const qualified = this._qualify(varName, filePath, enclosingClass);
+            nodes.push({
+              kind: "Function",
+              name: varName,
+              filePath,
+              lineStart: child.startPosition.row + 1,
+              lineEnd: child.endPosition.row + 1,
+              language,
+              parentName: enclosingClass,
+              returnType: varType,
+              modifiers: varVisibility,
+              extra: { solidity_kind: "state_variable", mutability: varMutability }
+            });
+            edges.push({
+              kind: "CONTAINS",
+              source: this._qualify(enclosingClass, filePath, null),
+              target: qualified,
+              filePath,
+              line: child.startPosition.row + 1
+            });
+            continue;
+          }
+        }
+        if (nodeType === "constant_variable_declaration") {
+          let varName = null;
+          let varType = null;
+          for (const sub of child.children) {
+            if (sub.type === "identifier") {
+              varName = sub.text;
+            } else if (sub.type === "type_name") {
+              varType = sub.text;
+            }
+          }
+          if (varName) {
+            const qualified = this._qualify(varName, filePath, enclosingClass ?? null);
+            nodes.push({
+              kind: "Function",
+              name: varName,
+              filePath,
+              lineStart: child.startPosition.row + 1,
+              lineEnd: child.endPosition.row + 1,
+              language,
+              parentName: enclosingClass ?? null,
+              returnType: varType,
+              extra: { solidity_kind: "constant" }
+            });
+            const container = enclosingClass ? this._qualify(enclosingClass, filePath, null) : filePath;
+            edges.push({
+              kind: "CONTAINS",
+              source: container,
+              target: qualified,
+              filePath,
+              line: child.startPosition.row + 1
+            });
+            continue;
+          }
+        }
+        if (nodeType === "using_directive") {
+          let libName = null;
+          for (const sub of child.children) {
+            if (sub.type === "type_alias") {
+              for (const ident of sub.children) {
+                if (ident.type === "identifier") {
+                  libName = ident.text;
+                  break;
+                }
+              }
+            }
+          }
+          if (libName) {
+            const sourceName = enclosingClass ? this._qualify(enclosingClass, filePath, null) : filePath;
+            edges.push({
+              kind: "DEPENDS_ON",
+              source: sourceName,
+              target: libName,
+              filePath,
+              line: child.startPosition.row + 1
+            });
+          }
+          continue;
+        }
+      }
+      this._extractFromTree(
+        child,
+        source,
+        language,
+        filePath,
+        nodes,
+        edges,
+        enclosingClass,
+        enclosingFunc,
+        importMap,
+        definedNames,
+        depth + 1
+      );
+    }
+  }
+  _collectFileScope(root, language, source) {
+    const importMap = /* @__PURE__ */ new Map();
+    const definedNames = /* @__PURE__ */ new Set();
+    const classTypes = new Set(CLASS_TYPES[language] ?? []);
+    const funcTypes = new Set(FUNCTION_TYPES[language] ?? []);
+    const importTypes = new Set(IMPORT_TYPES[language] ?? []);
+    const decoratorWrappers = /* @__PURE__ */ new Set(["decorated_definition", "decorator"]);
+    for (const child of root.children) {
+      const nodeType = child.type;
+      let target = child;
+      if (decoratorWrappers.has(nodeType)) {
+        for (const inner of child.children) {
+          if (funcTypes.has(inner.type) || classTypes.has(inner.type)) {
+            target = inner;
+            break;
+          }
+        }
+      }
+      const targetType = target.type;
+      if (funcTypes.has(targetType) || classTypes.has(targetType)) {
+        const name = this._getName(
+          target,
+          language,
+          classTypes.has(targetType) ? "class" : "function"
+        );
+        if (name) {
+          definedNames.add(name);
+        }
+      }
+      if (importTypes.has(nodeType)) {
+        this._collectImportNames(child, language, source, importMap);
+      }
+    }
+    return [importMap, definedNames];
+  }
+  _collectImportNames(node, language, _source, importMap) {
+    if (language === "python") {
+      if (node.type === "import_from_statement") {
+        let module = null;
+        let seenImport = false;
+        for (const child of node.children) {
+          if (child.type === "dotted_name" && !seenImport) {
+            module = child.text;
+          } else if (child.type === "import") {
+            seenImport = true;
+          } else if (seenImport && module) {
+            if (child.type === "identifier" || child.type === "dotted_name") {
+              importMap.set(child.text, module);
+            } else if (child.type === "aliased_import") {
+              const names = child.children.filter(
+                (c) => c.type === "identifier" || c.type === "dotted_name"
+              ).map((c) => c.text);
+              if (names.length > 0) {
+                importMap.set(names[names.length - 1], module);
+              }
+            }
+          }
+        }
+      }
+    } else if (language === "javascript" || language === "typescript" || language === "tsx") {
+      let module = null;
+      for (const child of node.children) {
+        if (child.type === "string") {
+          module = child.text.replace(/^['"]|['"]$/g, "");
+        }
+      }
+      if (module) {
+        for (const child of node.children) {
+          if (child.type === "import_clause") {
+            this._collectJsImportNames(child, module, importMap);
+          }
+        }
+      }
+    }
+  }
+  _collectJsImportNames(clauseNode, module, importMap) {
+    for (const child of clauseNode.children) {
+      if (child.type === "identifier") {
+        importMap.set(child.text, module);
+      } else if (child.type === "named_imports") {
+        for (const spec of child.children) {
+          if (spec.type === "import_specifier") {
+            const names = spec.children.filter(
+              (s) => s.type === "identifier" || s.type === "property_identifier"
+            ).map((s) => s.text);
+            if (names.length > 0) {
+              importMap.set(names[names.length - 1], module);
+            }
+          }
+        }
+      }
+    }
+  }
+  _resolveModuleToFile(module, filePath, language) {
+    const callerDir = path2.dirname(filePath);
+    const cacheKey = `${language}:${callerDir}:${module}`;
+    if (this.moduleFileCache.has(cacheKey)) {
+      return this.moduleFileCache.get(cacheKey) ?? null;
+    }
+    const resolved = this._doResolveModule(module, filePath, language);
+    if (this.moduleFileCache.size >= MODULE_CACHE_MAX) {
+      this.moduleFileCache.clear();
+    }
+    this.moduleFileCache.set(cacheKey, resolved);
+    return resolved;
+  }
+  _doResolveModule(module, filePath, language) {
+    const callerDir = path2.dirname(filePath);
+    if (language === "python") {
+      const relPath = module.replace(/\./g, "/");
+      const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
+      let current = callerDir;
+      while (true) {
+        for (const candidate of candidates) {
+          const target = path2.join(current, candidate);
+          if (fs2.existsSync(target)) {
+            return path2.resolve(target);
+          }
+        }
+        const parent = path2.dirname(current);
+        if (parent === current) {
+          break;
+        }
+        current = parent;
+      }
+    } else if (language === "javascript" || language === "typescript" || language === "tsx" || language === "vue") {
+      if (module.startsWith(".")) {
+        const base = path2.join(callerDir, module);
+        const extensions = [".ts", ".tsx", ".js", ".jsx", ".vue"];
+        if (fs2.existsSync(base) && fs2.statSync(base).isFile()) {
+          return path2.resolve(base);
+        }
+        for (const ext of extensions) {
+          const target = base + ext;
+          if (fs2.existsSync(target)) {
+            return path2.resolve(target);
+          }
+        }
+        if (fs2.existsSync(base) && fs2.statSync(base).isDirectory()) {
+          for (const ext of extensions) {
+            const target = path2.join(base, `index${ext}`);
+            if (fs2.existsSync(target)) {
+              return path2.resolve(target);
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  _resolveCallTarget(callName, filePath, language, importMap, definedNames) {
+    if (definedNames.has(callName)) {
+      return this._qualify(callName, filePath, null);
+    }
+    const importedFrom = importMap.get(callName);
+    if (importedFrom) {
+      const resolved = this._resolveModuleToFile(importedFrom, filePath, language);
+      if (resolved) {
+        return this._qualify(callName, resolved, null);
+      }
+    }
+    return callName;
+  }
+  _qualify(name, filePath, enclosingClass) {
+    if (enclosingClass) {
+      return `${filePath}::${enclosingClass}.${name}`;
+    }
+    return `${filePath}::${name}`;
+  }
+  _getName(node, language, kind) {
+    if (language === "solidity") {
+      if (node.type === "constructor_definition") {
+        return "constructor";
+      }
+      if (node.type === "fallback_receive_definition") {
+        for (const child of node.children) {
+          if (child.type === "receive" || child.type === "fallback") {
+            return child.text;
+          }
+        }
+      }
+    }
+    if ((language === "c" || language === "cpp") && kind === "function") {
+      for (const child of node.children) {
+        if (child.type === "function_declarator" || child.type === "pointer_declarator") {
+          const result = this._getName(child, language, kind);
+          if (result) {
+            return result;
+          }
+        }
+      }
+    }
+    for (const child of node.children) {
+      if ([
+        "identifier",
+        "name",
+        "type_identifier",
+        "property_identifier",
+        "simple_identifier",
+        "constant"
+      ].includes(child.type)) {
+        return child.text;
+      }
+    }
+    if (language === "go" && node.type === "type_declaration") {
+      for (const child of node.children) {
+        if (child.type === "type_spec") {
+          return this._getName(child, language, kind);
+        }
+      }
+    }
+    return null;
+  }
+  _getParams(node, language) {
+    for (const child of node.children) {
+      if (["parameters", "formal_parameters", "parameter_list"].includes(child.type)) {
+        return child.text;
+      }
+    }
+    if (language === "solidity") {
+      const params = node.children.filter((c) => c.type === "parameter").map((c) => c.text);
+      if (params.length > 0) {
+        return `(${params.join(", ")})`;
+      }
+    }
+    return null;
+  }
+  _getReturnType(node, language) {
+    for (const child of node.children) {
+      if ([
+        "type",
+        "return_type",
+        "type_annotation",
+        "return_type_definition"
+      ].includes(child.type)) {
+        return child.text;
+      }
+    }
+    if (language === "python") {
+      for (let i = 0; i < node.children.length - 1; i++) {
+        if (node.children[i].type === "->") {
+          return node.children[i + 1].text;
+        }
+      }
+    }
+    return null;
+  }
+  _getBases(node, language) {
+    const bases = [];
+    if (language === "python") {
+      for (const child of node.children) {
+        if (child.type === "argument_list") {
+          for (const arg of child.children) {
+            if (arg.type === "identifier" || arg.type === "attribute") {
+              bases.push(arg.text);
+            }
+          }
+        }
+      }
+    } else if (language === "java" || language === "csharp" || language === "kotlin") {
+      for (const child of node.children) {
+        if ([
+          "superclass",
+          "super_interfaces",
+          "extends_type",
+          "implements_type",
+          "type_identifier",
+          "supertype",
+          "delegation_specifier"
+        ].includes(child.type)) {
+          bases.push(child.text);
+        }
+      }
+    } else if (language === "cpp") {
+      for (const child of node.children) {
+        if (child.type === "base_class_clause") {
+          for (const sub of child.children) {
+            if (sub.type === "type_identifier") {
+              bases.push(sub.text);
+            }
+          }
+        }
+      }
+    } else if (language === "typescript" || language === "javascript" || language === "tsx") {
+      for (const child of node.children) {
+        if (child.type === "extends_clause" || child.type === "implements_clause") {
+          for (const sub of child.children) {
+            if ([
+              "identifier",
+              "type_identifier",
+              "nested_identifier"
+            ].includes(sub.type)) {
+              bases.push(sub.text);
+            }
+          }
+        }
+      }
+    } else if (language === "solidity") {
+      for (const child of node.children) {
+        if (child.type === "inheritance_specifier") {
+          for (const sub of child.children) {
+            if (sub.type === "user_defined_type") {
+              for (const ident of sub.children) {
+                if (ident.type === "identifier") {
+                  bases.push(ident.text);
+                }
+              }
+            }
+          }
+        }
+      }
+    } else if (language === "go") {
+      for (const child of node.children) {
+        if (child.type === "type_spec") {
+          for (const sub of child.children) {
+            if (sub.type === "struct_type" || sub.type === "interface_type") {
+              for (const fieldNode of sub.children) {
+                if (fieldNode.type === "field_declaration_list") {
+                  for (const f of fieldNode.children) {
+                    if (f.type === "type_identifier") {
+                      bases.push(f.text);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return bases;
+  }
+  _extractImport(node, language) {
+    const imports = [];
+    const text = node.text.trim();
+    if (language === "python") {
+      if (node.type === "import_from_statement") {
+        for (const child of node.children) {
+          if (child.type === "dotted_name") {
+            imports.push(child.text);
+            break;
+          }
+        }
+      } else {
+        for (const child of node.children) {
+          if (child.type === "dotted_name") {
+            imports.push(child.text);
+          }
+        }
+      }
+    } else if (language === "javascript" || language === "typescript" || language === "tsx") {
+      for (const child of node.children) {
+        if (child.type === "string") {
+          imports.push(child.text.replace(/^['"]|['"]$/g, ""));
+        }
+      }
+    } else if (language === "go") {
+      for (const child of node.children) {
+        if (child.type === "import_spec_list") {
+          for (const spec of child.children) {
+            if (spec.type === "import_spec") {
+              for (const s of spec.children) {
+                if (s.type === "interpreted_string_literal") {
+                  imports.push(s.text.replace(/^"|"$/g, ""));
+                }
+              }
+            }
+          }
+        } else if (child.type === "import_spec") {
+          for (const s of child.children) {
+            if (s.type === "interpreted_string_literal") {
+              imports.push(s.text.replace(/^"|"$/g, ""));
+            }
+          }
+        }
+      }
+    } else if (language === "rust") {
+      imports.push(text.replace(/^use\s+/, "").replace(/;$/, "").trim());
+    } else if (language === "c" || language === "cpp") {
+      for (const child of node.children) {
+        if (child.type === "system_lib_string" || child.type === "string_literal") {
+          imports.push(child.text.replace(/^[<""]|[>""]$/g, ""));
+        }
+      }
+    } else if (language === "java" || language === "csharp") {
+      const parts = text.split(/\s+/);
+      if (parts.length >= 2) {
+        imports.push(parts[parts.length - 1].replace(/;$/, ""));
+      }
+    } else if (language === "solidity") {
+      for (const child of node.children) {
+        if (child.type === "string") {
+          const val = child.text.replace(/^"|"$/g, "");
+          if (val) {
+            imports.push(val);
+          }
+        }
+      }
+    } else if (language === "ruby") {
+      if (text.includes("require")) {
+        const match = /['"]([^'"]+)['"]/u.exec(text);
+        if (match) {
+          imports.push(match[1]);
+        }
+      }
+    } else {
+      imports.push(text);
+    }
+    return imports;
+  }
+  _getCallName(node, language) {
+    if (!node.children || node.children.length === 0) {
+      return null;
+    }
+    let first = node.children[0];
+    if (language === "solidity" && first.type === "expression" && first.children.length > 0) {
+      first = first.children[0];
+    }
+    if (first.type === "identifier") {
+      return first.text;
+    }
+    const memberTypes = [
+      "attribute",
+      "member_expression",
+      "field_expression",
+      "selector_expression"
+    ];
+    if (memberTypes.includes(first.type)) {
+      for (let i = first.children.length - 1; i >= 0; i--) {
+        const child = first.children[i];
+        if ([
+          "identifier",
+          "property_identifier",
+          "field_identifier",
+          "field_name"
+        ].includes(child.type)) {
+          return child.text;
+        }
+      }
+      return first.text;
+    }
+    if (first.type === "scoped_identifier" || first.type === "qualified_name") {
+      return first.text;
+    }
+    return null;
+  }
+};
+
+// src/usecases/buildGraph.ts
+import crypto2 from "crypto";
+import fs4 from "fs";
+import path4 from "path";
+
+// src/infrastructure/FileSystemHelper.ts
+import fs3 from "fs";
+import path3 from "path";
+import micromatch from "micromatch";
+
+// src/infrastructure/GitRunner.ts
+import { spawnSync } from "child_process";
+var GIT_TIMEOUT_MS = Number(process.env["CRG_GIT_TIMEOUT"] ?? 30) * 1e3;
+function gitRun(args, cwd) {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    timeout: GIT_TIMEOUT_MS,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.error || result.status !== 0) {
+    return "";
+  }
+  return result.stdout ?? "";
+}
+function getChangedFiles(repoRoot, base = "HEAD~1") {
+  let output = gitRun(["diff", "--name-only", base], repoRoot);
+  if (!output.trim()) {
+    output = gitRun(["diff", "--name-only", "--cached"], repoRoot);
+  }
+  return output.split("\n").map((f) => f.trim()).filter(Boolean);
+}
+function getAllTrackedFiles(repoRoot) {
+  const output = gitRun(["ls-files"], repoRoot);
+  return output.split("\n").map((f) => f.trim()).filter(Boolean);
+}
+
+// src/infrastructure/FileSystemHelper.ts
+var DEFAULT_IGNORE_PATTERNS = [
+  ".codeorbit/**",
+  "node_modules/**",
+  ".git/**",
+  "__pycache__/**",
+  "*.pyc",
+  ".venv/**",
+  "venv/**",
+  "dist/**",
+  "build/**",
+  ".next/**",
+  "target/**",
+  "*.min.js",
+  "*.min.css",
+  "*.map",
+  "*.lock",
+  "package-lock.json",
+  "yarn.lock",
+  "*.db",
+  "*.sqlite",
+  "*.db-journal",
+  "*.db-wal"
+];
+var PRUNE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "__pycache__",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  "dist",
+  "build",
+  ".venv",
+  "venv",
+  "env",
+  "target",
+  ".mypy_cache",
+  ".pytest_cache",
+  "coverage",
+  ".tox",
+  ".cache",
+  ".tmp",
+  "tmp",
+  "temp",
+  "vendor",
+  "Pods",
+  "DerivedData",
+  ".gradle",
+  ".idea",
+  ".vs"
+]);
+function findRepoRoot(start) {
+  let current = start ?? process.cwd();
+  while (true) {
+    if (fs3.existsSync(path3.join(current, ".git"))) {
+      return current;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return void 0;
+}
+function getDbPath(repoRoot) {
+  const crgDir = path3.join(repoRoot, ".codeorbit");
+  const newDb = path3.join(crgDir, "graph.db");
+  if (!fs3.existsSync(crgDir)) {
+    fs3.mkdirSync(crgDir, { recursive: true });
+  }
+  const innerGitignore = path3.join(crgDir, ".gitignore");
+  if (!fs3.existsSync(innerGitignore)) {
+    fs3.writeFileSync(
+      innerGitignore,
+      "# Auto-generated by codeorbit \u2014 do not commit database files.\n# The graph.db contains absolute paths and code structure metadata.\n*\n"
+    );
+  }
+  const legacyDb = path3.join(repoRoot, ".codeorbit.db");
+  if (fs3.existsSync(legacyDb) && !fs3.existsSync(newDb)) {
+    fs3.renameSync(legacyDb, newDb);
+  }
+  for (const suffix of ["-wal", "-shm", "-journal"]) {
+    const side = legacyDb + suffix;
+    if (fs3.existsSync(side)) {
+      try {
+        fs3.unlinkSync(side);
+      } catch {
+      }
+    }
+  }
+  return newDb;
+}
+function loadIgnorePatterns(repoRoot) {
+  const patterns = [...DEFAULT_IGNORE_PATTERNS];
+  const ignoreFile = path3.join(repoRoot, ".codeorbitignore");
+  if (fs3.existsSync(ignoreFile)) {
+    for (const line of fs3.readFileSync(ignoreFile, "utf-8").split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        patterns.push(trimmed);
+      }
+    }
+  }
+  return patterns;
+}
+function shouldIgnore(filePath, patterns) {
+  return micromatch.isMatch(filePath, patterns);
+}
+function isBinary(filePath) {
+  try {
+    const chunk = Buffer.alloc(8192);
+    const fd = fs3.openSync(filePath, "r");
+    const bytesRead = fs3.readSync(fd, chunk, 0, 8192, 0);
+    fs3.closeSync(fd);
+    return chunk.slice(0, bytesRead).includes(0);
+  } catch {
+    return true;
+  }
+}
+function walkDir(dir, repoRoot) {
+  const files = [];
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (PRUNE_DIRS.has(entry.name)) {
+        continue;
+      }
+      files.push(...walkDir(path3.join(dir, entry.name), repoRoot));
+    } else if (entry.isFile()) {
+      const rel = path3.relative(repoRoot, path3.join(dir, entry.name));
+      files.push(rel);
+    }
+  }
+  return files;
+}
+function collectAllFiles(repoRoot) {
+  const ignorePatterns = loadIgnorePatterns(repoRoot);
+  const parser = new CodeParser();
+  const files = [];
+  const tracked = getAllTrackedFiles(repoRoot);
+  const candidates = tracked.length > 0 ? tracked : walkDir(repoRoot, repoRoot);
+  for (const relPath of candidates) {
+    if (shouldIgnore(relPath, ignorePatterns)) {
+      continue;
+    }
+    const fullPath = path3.join(repoRoot, relPath);
+    let stat;
+    try {
+      stat = fs3.lstatSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+      continue;
+    }
+    if (!parser.detectLanguage(fullPath)) {
+      continue;
+    }
+    if (isBinary(fullPath)) {
+      continue;
+    }
+    files.push(relPath);
+  }
+  return files;
+}
+
+// src/usecases/buildGraph.ts
+function fullBuild(repoRoot, repo, parser) {
+  const files = collectAllFiles(repoRoot);
+  const existingFiles = new Set(repo.getAllFiles());
+  const currentAbs = new Set(files.map((f) => path4.join(repoRoot, f)));
+  for (const stale of existingFiles) {
+    if (!currentAbs.has(stale)) {
+      repo.removeFileData(stale);
+    }
+  }
+  let totalNodes = 0;
+  let totalEdges = 0;
+  const errors = [];
+  for (let i = 0; i < files.length; i++) {
+    const relPath = files[i];
+    const fullPath = path4.join(repoRoot, relPath);
+    try {
+      const source = fs4.readFileSync(fullPath);
+      const fhash = crypto2.createHash("sha256").update(source).digest("hex");
+      const [nodes, edges] = parser.parseBytes(fullPath, source);
+      repo.storeFileNodesEdges(fullPath, nodes, edges, fhash);
+      totalNodes += nodes.length;
+      totalEdges += edges.length;
+    } catch (err) {
+      errors.push(`${relPath}: ${String(err)}`);
+    }
+    if ((i + 1) % 50 === 0 || i + 1 === files.length) {
+      process.stderr.write(`Progress: ${i + 1}/${files.length} files parsed
+`);
+    }
+  }
+  repo.setMetadata("last_updated", (/* @__PURE__ */ new Date()).toISOString().replace(/\..+$/, ""));
+  repo.setMetadata("last_build_type", "full");
+  return {
+    buildType: "full",
+    filesUpdated: files.length,
+    totalNodes,
+    totalEdges,
+    changedFiles: files,
+    dependentFiles: [],
+    errors
+  };
+}
+function incrementalUpdate(repoRoot, repo, parser, base = "HEAD~1", changedFiles) {
+  const ignorePatterns = loadIgnorePatterns(repoRoot);
+  const changed = changedFiles ?? getChangedFiles(repoRoot, base);
+  if (changed.length === 0) {
+    return {
+      buildType: "incremental",
+      filesUpdated: 0,
+      totalNodes: 0,
+      totalEdges: 0,
+      changedFiles: [],
+      dependentFiles: [],
+      errors: []
+    };
+  }
+  const dependentFiles = /* @__PURE__ */ new Set();
+  for (const relPath of changed) {
+    const fullPath = path4.join(repoRoot, relPath);
+    const deps = findDependents(repo, fullPath);
+    for (const d of deps) {
+      try {
+        dependentFiles.add(path4.relative(repoRoot, d));
+      } catch {
+        dependentFiles.add(d);
+      }
+    }
+  }
+  const allFiles = /* @__PURE__ */ new Set([...changed, ...dependentFiles]);
+  let totalNodes = 0;
+  let totalEdges = 0;
+  const errors = [];
+  for (const relPath of allFiles) {
+    if (shouldIgnore(relPath, ignorePatterns)) {
+      continue;
+    }
+    const absPath = path4.join(repoRoot, relPath);
+    if (!fs4.existsSync(absPath)) {
+      repo.removeFileData(absPath);
+      continue;
+    }
+    if (!parser.detectLanguage(absPath)) {
+      continue;
+    }
+    try {
+      const source = fs4.readFileSync(absPath);
+      const fhash = crypto2.createHash("sha256").update(source).digest("hex");
+      const existingNodes = repo.getNodesByFile(absPath);
+      if (existingNodes.length > 0 && existingNodes[0].fileHash === fhash) {
+        continue;
+      }
+      const [nodes, edges] = parser.parseBytes(absPath, source);
+      repo.storeFileNodesEdges(absPath, nodes, edges, fhash);
+      totalNodes += nodes.length;
+      totalEdges += edges.length;
+    } catch (err) {
+      errors.push(`${relPath}: ${String(err)}`);
+    }
+  }
+  repo.setMetadata("last_updated", (/* @__PURE__ */ new Date()).toISOString().replace(/\..+$/, ""));
+  repo.setMetadata("last_build_type", "incremental");
+  return {
+    buildType: "incremental",
+    filesUpdated: allFiles.size,
+    totalNodes,
+    totalEdges,
+    changedFiles: changed,
+    dependentFiles: [...dependentFiles],
+    errors
+  };
+}
+function findDependents(repo, filePath) {
+  const dependents = /* @__PURE__ */ new Set();
+  for (const e of repo.getEdgesByTarget(filePath)) {
+    if (e.kind === "IMPORTS_FROM") {
+      dependents.add(e.filePath);
+    }
+  }
+  for (const node of repo.getNodesByFile(filePath)) {
+    for (const e of repo.getEdgesByTarget(node.qualifiedName)) {
+      if (["CALLS", "IMPORTS_FROM", "INHERITS", "IMPLEMENTS"].includes(e.kind)) {
+        dependents.add(e.filePath);
+      }
+    }
+  }
+  dependents.delete(filePath);
+  return [...dependents];
+}
+export {
+  CodeParser,
+  SqliteGraphRepository as GraphStore,
+  collectAllFiles,
+  fileHash,
+  findRepoRoot,
+  fullBuild,
+  getDbPath,
+  incrementalUpdate
+};
+//# sourceMappingURL=index.js.map