codeorbit 0.1.0

package/dist/server.js

@@ -0,0 +1,3408 @@
+// src/adapters/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/adapters/mcp/tools.ts
+import fs7 from "fs";
+import path10 from "path";
+
+// 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, fileHash = "") {
+    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,
+      fileHash,
+      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, fileHash = "") {
+    const txn = this.db.transaction(() => {
+      this.removeFileData(filePath);
+      for (const node of nodes) {
+        this.upsertNode(node, fileHash);
+      }
+      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
+    };
+  }
+};
+function sanitizeName(s, maxLen = 256) {
+  let cleaned = "";
+  for (const ch of s) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (ch === "	" || ch === "\n" || code >= 32) {
+      cleaned += ch;
+    }
+  }
+  return cleaned.slice(0, maxLen);
+}
+function nodeToDict(n) {
+  return {
+    id: n.id,
+    kind: n.kind,
+    name: sanitizeName(n.name),
+    qualified_name: sanitizeName(n.qualifiedName),
+    file_path: n.filePath,
+    line_start: n.lineStart,
+    line_end: n.lineEnd,
+    language: n.language,
+    parent_name: n.parentName ? sanitizeName(n.parentName) : n.parentName,
+    is_test: n.isTest
+  };
+}
+function edgeToDict(e) {
+  return {
+    id: e.id,
+    kind: e.kind,
+    source: sanitizeName(e.sourceQualified),
+    target: sanitizeName(e.targetQualified),
+    file_path: e.filePath,
+    line: e.line
+  };
+}
+
+// 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;
+}
+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/infrastructure/SqliteEmbeddingStore.ts
+import crypto2 from "crypto";
+import Database2 from "better-sqlite3";
+
+// src/infrastructure/LocalEmbeddingProvider.ts
+var NOMIC_MODEL = "Xenova/nomic-embed-text-v1.5";
+var MINILM_MODEL = "Xenova/all-MiniLM-L6-v2";
+var LocalEmbeddingProvider = class {
+  _pipelinePromise = null;
+  _model;
+  _dim;
+  constructor() {
+    const hasToken = !!(process.env["HF_TOKEN"] ?? process.env["CODEORBIT_HF_TOKEN"]);
+    this._model = hasToken ? NOMIC_MODEL : MINILM_MODEL;
+    this._dim = hasToken ? 768 : 384;
+  }
+  _getPipeline() {
+    if (!this._pipelinePromise) {
+      const model = this._model;
+      this._pipelinePromise = import("@huggingface/transformers").then((mod) => {
+        const { pipeline, env } = mod;
+        const hfToken = process.env["HF_TOKEN"] ?? process.env["CODEORBIT_HF_TOKEN"];
+        if (hfToken) env["token"] = hfToken;
+        return pipeline("feature-extraction", model);
+      });
+    }
+    return this._pipelinePromise;
+  }
+  async embed(texts) {
+    const pipe = await this._getPipeline();
+    const inputs = this._model === NOMIC_MODEL ? texts.map((t) => `search_document: ${t}`) : texts;
+    const output = await pipe(inputs, { pooling: "mean", normalize: true });
+    const dim = this._dim;
+    return Array.from(
+      { length: texts.length },
+      (_, i) => Array.from(output.data.subarray(i * dim, (i + 1) * dim))
+    );
+  }
+  async embedQuery(text) {
+    const pipe = await this._getPipeline();
+    const input = this._model === NOMIC_MODEL ? `search_query: ${text}` : text;
+    const output = await pipe([input], { pooling: "mean", normalize: true });
+    return Array.from(output.data);
+  }
+  get dimension() {
+    return this._dim;
+  }
+  get name() {
+    return `local:${this._model.split("/")[1]}`;
+  }
+};
+
+// src/infrastructure/GoogleEmbeddingProvider.ts
+import { createRequire as createRequire2 } from "module";
+var _require2 = createRequire2(import.meta.url);
+var GoogleEmbeddingProvider = class {
+  _model;
+  _dimension = null;
+  modelName;
+  constructor(apiKey, model = "gemini-embedding-001") {
+    this.modelName = model;
+    const { GoogleGenerativeAI } = _require2("@google/generative-ai");
+    const genAI = new GoogleGenerativeAI(apiKey);
+    this._model = genAI.getGenerativeModel({ model });
+  }
+  async _withRetry(fn, maxRetries = 3) {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (e) {
+        const msg = String(e);
+        const retryable = msg.includes("429") || msg.includes("500") || msg.includes("503");
+        if (!retryable || attempt === maxRetries - 1) throw e;
+        await new Promise((r) => setTimeout(r, 2 ** attempt * 1e3));
+      }
+    }
+    throw new Error("unreachable");
+  }
+  async embed(texts) {
+    const batchSize = 100;
+    const results = [];
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const batch = texts.slice(i, i + batchSize);
+      const response = await this._withRetry(
+        () => this._model.batchEmbedContents({
+          requests: batch.map((t) => ({
+            content: { parts: [{ text: t }], role: "user" },
+            taskType: "RETRIEVAL_DOCUMENT"
+          }))
+        })
+      );
+      results.push(...response.embeddings.map((e) => e.values));
+    }
+    if (this._dimension === null && results.length > 0) {
+      this._dimension = results[0].length;
+    }
+    return results;
+  }
+  async embedQuery(text) {
+    const response = await this._withRetry(
+      () => this._model.embedContent({
+        content: { parts: [{ text }], role: "user" },
+        taskType: "RETRIEVAL_QUERY"
+      })
+    );
+    const vec = response.embedding.values;
+    if (this._dimension === null) this._dimension = vec.length;
+    return vec;
+  }
+  get dimension() {
+    return this._dimension ?? 768;
+  }
+  get name() {
+    return `google:${this.modelName}`;
+  }
+};
+
+// src/infrastructure/SqliteEmbeddingStore.ts
+var EMBEDDINGS_SCHEMA = `
+CREATE TABLE IF NOT EXISTS embeddings (
+  qualified_name TEXT PRIMARY KEY,
+  vector BLOB NOT NULL,
+  text_hash TEXT NOT NULL,
+  provider TEXT NOT NULL DEFAULT 'unknown'
+);
+`;
+function encodeVector(vec) {
+  const buf = Buffer.allocUnsafe(vec.length * 4);
+  for (let i = 0; i < vec.length; i++) buf.writeFloatLE(vec[i], i * 4);
+  return buf;
+}
+function decodeVector(blob) {
+  const n = blob.length / 4;
+  const result = new Array(n);
+  for (let i = 0; i < n; i++) result[i] = blob.readFloatLE(i * 4);
+  return result;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function nodeToText(node) {
+  const parts = [node.name];
+  if (node.kind !== "File") parts.push(node.kind.toLowerCase());
+  if (node.parentName) parts.push(`in ${node.parentName}`);
+  if (node.params) parts.push(node.params);
+  if (node.returnType) parts.push(`returns ${node.returnType}`);
+  if (node.language) parts.push(node.language);
+  return parts.join(" ");
+}
+function getProvider(provider) {
+  if (provider === "google") {
+    const apiKey = process.env["GOOGLE_API_KEY"];
+    if (!apiKey) return null;
+    try {
+      return new GoogleEmbeddingProvider(apiKey);
+    } catch {
+      return null;
+    }
+  }
+  return new LocalEmbeddingProvider();
+}
+var SqliteEmbeddingStore = class {
+  _db;
+  available;
+  _provider;
+  constructor(dbPath, provider) {
+    this._db = new Database2(dbPath);
+    this._db.exec(EMBEDDINGS_SCHEMA);
+    try {
+      this._db.prepare("SELECT provider FROM embeddings LIMIT 1").get();
+    } catch {
+      this._db.exec(
+        "ALTER TABLE embeddings ADD COLUMN provider TEXT NOT NULL DEFAULT 'unknown'"
+      );
+    }
+    this._provider = getProvider(provider);
+    this.available = this._provider !== null;
+  }
+  count() {
+    const row = this._db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get();
+    return row.cnt;
+  }
+  async embedNodes(nodes, batchSize = 64) {
+    if (!this._provider) return 0;
+    const providerName = this._provider.name;
+    const toEmbed = [];
+    for (const node of nodes) {
+      if (node.kind === "File") continue;
+      const text = nodeToText(node);
+      const textHash = crypto2.createHash("sha256").update(text).digest("hex");
+      const existing = this._db.prepare("SELECT text_hash, provider FROM embeddings WHERE qualified_name = ?").get(node.qualifiedName);
+      if (existing && existing.text_hash === textHash && existing.provider === providerName) {
+        continue;
+      }
+      toEmbed.push({ node, text, textHash });
+    }
+    if (toEmbed.length === 0) return 0;
+    const insert = this._db.prepare(
+      "INSERT OR REPLACE INTO embeddings (qualified_name, vector, text_hash, provider) VALUES (?, ?, ?, ?)"
+    );
+    for (let i = 0; i < toEmbed.length; i += batchSize) {
+      const batch = toEmbed.slice(i, i + batchSize);
+      const vectors = await this._provider.embed(batch.map((b) => b.text));
+      this._db.transaction(() => {
+        for (let j = 0; j < batch.length; j++) {
+          const { node, textHash } = batch[j];
+          insert.run(node.qualifiedName, encodeVector(vectors[j]), textHash, providerName);
+        }
+      })();
+    }
+    return toEmbed.length;
+  }
+  async search(query, limit = 20) {
+    if (!this._provider) return [];
+    const providerName = this._provider.name;
+    const queryVec = await this._provider.embedQuery(query);
+    const rows = this._db.prepare("SELECT qualified_name, vector FROM embeddings WHERE provider = ?").all(providerName);
+    const scored = rows.map((row) => ({
+      qualifiedName: row.qualified_name,
+      score: cosineSimilarity(queryVec, decodeVector(row.vector))
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit);
+  }
+  removeNode(qualifiedName) {
+    this._db.prepare("DELETE FROM embeddings WHERE qualified_name = ?").run(qualifiedName);
+  }
+  close() {
+    this._db.close();
+  }
+};
+
+// 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 getStagedAndUnstaged(repoRoot) {
+  const output = gitRun(["status", "--porcelain"], repoRoot);
+  const files = [];
+  for (const line of output.split("\n")) {
+    if (line.length > 3) {
+      let entry = line.slice(3).trim();
+      if (entry.includes(" -> ")) {
+        entry = entry.split(" -> ")[1];
+      }
+      files.push(entry);
+    }
+  }
+  return files;
+}
+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 findProjectRoot(start) {
+  return findRepoRoot(start) ?? start ?? process.cwd();
+}
+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
+import crypto3 from "crypto";
+import fs4 from "fs";
+import path4 from "path";
+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 = crypto3.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 = crypto3.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];
+}
+
+// src/usecases/getImpactRadius.ts
+function computeImpactRadius(changedFiles, repo, maxDepth = 2, maxNodes = 500) {
+  const adj = repo.getAdjacency();
+  const seeds = /* @__PURE__ */ new Set();
+  for (const f of changedFiles) {
+    for (const node of repo.getNodesByFile(f)) {
+      seeds.add(node.qualifiedName);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  let frontier = new Set(seeds);
+  const impacted = /* @__PURE__ */ new Set();
+  let depth = 0;
+  while (frontier.size > 0 && depth < maxDepth) {
+    const nextFrontier = /* @__PURE__ */ new Set();
+    for (const qn of frontier) {
+      visited.add(qn);
+      const outNeighbors = adj.outgoing.get(qn);
+      if (outNeighbors) {
+        for (const nb of outNeighbors) {
+          if (!visited.has(nb)) {
+            nextFrontier.add(nb);
+            impacted.add(nb);
+          }
+        }
+      }
+      const inNeighbors = adj.incoming.get(qn);
+      if (inNeighbors) {
+        for (const nb of inNeighbors) {
+          if (!visited.has(nb)) {
+            nextFrontier.add(nb);
+            impacted.add(nb);
+          }
+        }
+      }
+    }
+    if (visited.size + nextFrontier.size > maxNodes) {
+      break;
+    }
+    frontier = nextFrontier;
+    depth++;
+  }
+  const changedNodes = [];
+  for (const qn of seeds) {
+    const n = repo.getNode(qn);
+    if (n) {
+      changedNodes.push(n);
+    }
+  }
+  let impactedNodes = [];
+  for (const qn of impacted) {
+    if (seeds.has(qn)) {
+      continue;
+    }
+    const n = repo.getNode(qn);
+    if (n) {
+      impactedNodes.push(n);
+    }
+  }
+  const totalImpacted = impactedNodes.length;
+  const truncated = totalImpacted > maxNodes;
+  if (truncated) {
+    impactedNodes = impactedNodes.slice(0, maxNodes);
+  }
+  const impactedFiles = [...new Set(impactedNodes.map((n) => n.filePath))];
+  const allQns = /* @__PURE__ */ new Set([...seeds, ...impactedNodes.map((n) => n.qualifiedName)]);
+  const edges = allQns.size > 0 ? repo.getEdgesAmong(allQns) : [];
+  return { changedNodes, impactedNodes, impactedFiles, edges, truncated, totalImpacted };
+}
+
+// src/usecases/queryGraph.ts
+import path5 from "path";
+var BUILTIN_CALL_NAMES = /* @__PURE__ */ new Set([
+  "map",
+  "filter",
+  "reduce",
+  "reduceRight",
+  "forEach",
+  "find",
+  "findIndex",
+  "some",
+  "every",
+  "includes",
+  "indexOf",
+  "lastIndexOf",
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "slice",
+  "concat",
+  "join",
+  "flat",
+  "flatMap",
+  "sort",
+  "reverse",
+  "fill",
+  "keys",
+  "values",
+  "entries",
+  "from",
+  "isArray",
+  "of",
+  "at",
+  "trim",
+  "trimStart",
+  "trimEnd",
+  "split",
+  "replace",
+  "replaceAll",
+  "match",
+  "matchAll",
+  "search",
+  "substring",
+  "substr",
+  "toLowerCase",
+  "toUpperCase",
+  "startsWith",
+  "endsWith",
+  "padStart",
+  "padEnd",
+  "repeat",
+  "charAt",
+  "charCodeAt",
+  "assign",
+  "freeze",
+  "defineProperty",
+  "getOwnPropertyNames",
+  "hasOwnProperty",
+  "create",
+  "is",
+  "fromEntries",
+  "log",
+  "warn",
+  "error",
+  "info",
+  "debug",
+  "trace",
+  "dir",
+  "table",
+  "time",
+  "timeEnd",
+  "assert",
+  "clear",
+  "count",
+  "then",
+  "catch",
+  "finally",
+  "resolve",
+  "reject",
+  "all",
+  "allSettled",
+  "race",
+  "any",
+  "parse",
+  "stringify",
+  "floor",
+  "ceil",
+  "round",
+  "random",
+  "max",
+  "min",
+  "abs",
+  "pow",
+  "sqrt",
+  "addEventListener",
+  "removeEventListener",
+  "querySelector",
+  "querySelectorAll",
+  "getElementById",
+  "createElement",
+  "appendChild",
+  "removeChild",
+  "setAttribute",
+  "getAttribute",
+  "preventDefault",
+  "stopPropagation",
+  "setTimeout",
+  "clearTimeout",
+  "setInterval",
+  "clearInterval",
+  "toString",
+  "valueOf",
+  "toJSON",
+  "toISOString",
+  "getTime",
+  "getFullYear",
+  "now",
+  "isNaN",
+  "parseInt",
+  "parseFloat",
+  "toFixed",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "call",
+  "apply",
+  "bind",
+  "next",
+  "emit",
+  "on",
+  "off",
+  "once",
+  "pipe",
+  "write",
+  "read",
+  "end",
+  "close",
+  "destroy",
+  "send",
+  "status",
+  "json",
+  "redirect",
+  "set",
+  "get",
+  "delete",
+  "has",
+  "findUnique",
+  "findFirst",
+  "findMany",
+  "createMany",
+  "update",
+  "updateMany",
+  "deleteMany",
+  "upsert",
+  "aggregate",
+  "groupBy",
+  "transaction",
+  "describe",
+  "it",
+  "test",
+  "expect",
+  "beforeEach",
+  "afterEach",
+  "beforeAll",
+  "afterAll",
+  "mock",
+  "spyOn",
+  "require",
+  "fetch"
+]);
+var QUERY_PATTERNS = {
+  callers_of: "Find all functions that call a given function",
+  callees_of: "Find all functions called by a given function",
+  imports_of: "Find all imports of a given file or module",
+  importers_of: "Find all files that import a given file or module",
+  children_of: "Find all nodes contained in a file or class",
+  tests_for: "Find all tests for a given function or class",
+  inheritors_of: "Find all classes that inherit from a given class",
+  file_summary: "Get a summary of all nodes in a file"
+};
+function queryGraph(args) {
+  const { pattern, target, repo, repoRoot } = args;
+  if (!QUERY_PATTERNS[pattern]) {
+    return {
+      status: "error",
+      error: `Unknown pattern '${pattern}'. Available: ${Object.keys(QUERY_PATTERNS).join(", ")}`
+    };
+  }
+  const results = [];
+  const edgesOut = [];
+  if (pattern === "callers_of" && BUILTIN_CALL_NAMES.has(target) && !target.includes("::")) {
+    return {
+      status: "ok",
+      pattern,
+      target,
+      description: QUERY_PATTERNS[pattern],
+      summary: `'${target}' is a common builtin \u2014 callers_of skipped to avoid noise.`,
+      results: [],
+      edges: []
+    };
+  }
+  let node = repo.getNode(target);
+  let resolvedTarget = target;
+  if (!node) {
+    const absTarget = path5.join(repoRoot, target);
+    node = repo.getNode(absTarget);
+    if (node) {
+      resolvedTarget = absTarget;
+    }
+  }
+  if (!node) {
+    const candidates = repo.searchNodes(target, 5);
+    if (candidates.length === 1) {
+      node = candidates[0];
+      resolvedTarget = node.qualifiedName;
+    } else if (candidates.length > 1) {
+      return {
+        status: "ambiguous",
+        summary: `Multiple matches for '${target}'. Please use a qualified name.`,
+        candidates: candidates.map(nodeToDict)
+      };
+    }
+  }
+  if (!node && pattern !== "file_summary") {
+    return { status: "not_found", summary: `No node found matching '${target}'.` };
+  }
+  const qn = node?.qualifiedName ?? resolvedTarget;
+  if (pattern === "callers_of") {
+    for (const e of repo.getEdgesByTarget(qn)) {
+      if (e.kind === "CALLS") {
+        const caller = repo.getNode(e.sourceQualified);
+        if (caller) {
+          results.push(nodeToDict(caller));
+        }
+        edgesOut.push(edgeToDict(e));
+      }
+    }
+    if (results.length === 0 && node) {
+      for (const e of repo.searchEdgesByTargetName(node.name)) {
+        const caller = repo.getNode(e.sourceQualified);
+        if (caller) {
+          results.push(nodeToDict(caller));
+        }
+        edgesOut.push(edgeToDict(e));
+      }
+    }
+  } else if (pattern === "callees_of") {
+    for (const e of repo.getEdgesBySource(qn)) {
+      if (e.kind === "CALLS") {
+        const callee = repo.getNode(e.targetQualified);
+        if (callee) {
+          results.push(nodeToDict(callee));
+        }
+        edgesOut.push(edgeToDict(e));
+      }
+    }
+  } else if (pattern === "imports_of") {
+    for (const e of repo.getEdgesBySource(qn)) {
+      if (e.kind === "IMPORTS_FROM") {
+        results.push({ import_target: e.targetQualified });
+        edgesOut.push(edgeToDict(e));
+      }
+    }
+  } else if (pattern === "importers_of") {
+    const absTarget = node ? node.filePath : path5.join(repoRoot, target);
+    for (const e of repo.getEdgesByTarget(absTarget)) {
+      if (e.kind === "IMPORTS_FROM") {
+        results.push({ importer: e.sourceQualified, file: e.filePath });
+        edgesOut.push(edgeToDict(e));
+      }
+    }
+  } else if (pattern === "children_of") {
+    for (const e of repo.getEdgesBySource(qn)) {
+      if (e.kind === "CONTAINS") {
+        const child = repo.getNode(e.targetQualified);
+        if (child) {
+          results.push(nodeToDict(child));
+        }
+      }
+    }
+  } else if (pattern === "tests_for") {
+    for (const e of repo.getEdgesByTarget(qn)) {
+      if (e.kind === "TESTED_BY") {
+        const testNode = repo.getNode(e.sourceQualified);
+        if (testNode) {
+          results.push(nodeToDict(testNode));
+        }
+      }
+    }
+    const name = node?.name ?? target;
+    const seenQns = new Set(results.map((r) => r["qualified_name"]));
+    for (const t of [
+      ...repo.searchNodes(`test_${name}`, 10),
+      ...repo.searchNodes(`Test${name}`, 10)
+    ]) {
+      if (!seenQns.has(t.qualifiedName) && t.isTest) {
+        results.push(nodeToDict(t));
+      }
+    }
+  } else if (pattern === "inheritors_of") {
+    for (const e of repo.getEdgesByTarget(qn)) {
+      if (e.kind === "INHERITS" || e.kind === "IMPLEMENTS") {
+        const child = repo.getNode(e.sourceQualified);
+        if (child) {
+          results.push(nodeToDict(child));
+        }
+        edgesOut.push(edgeToDict(e));
+      }
+    }
+  } else if (pattern === "file_summary") {
+    const absPath = path5.join(repoRoot, target);
+    for (const n of repo.getNodesByFile(absPath)) {
+      results.push(nodeToDict(n));
+    }
+  }
+  return {
+    status: "ok",
+    pattern,
+    target: resolvedTarget,
+    description: QUERY_PATTERNS[pattern],
+    summary: `Found ${results.length} result(s) for ${pattern}('${resolvedTarget}')`,
+    results,
+    edges: edgesOut
+  };
+}
+
+// src/usecases/getReviewContext.ts
+import fs5 from "fs";
+import path6 from "path";
+function getReviewContext(args) {
+  const {
+    changedFiles,
+    repo,
+    repoRoot,
+    maxDepth = 2,
+    includeSource = true,
+    maxLinesPerFile = 200
+  } = args;
+  if (changedFiles.length === 0) {
+    return { status: "ok", summary: "No changes detected. Nothing to review.", context: {} };
+  }
+  const absFiles = changedFiles.map((f) => path6.join(repoRoot, f));
+  const impact = computeImpactRadius(absFiles, repo, maxDepth);
+  const context = {
+    changed_files: changedFiles,
+    impacted_files: impact.impactedFiles,
+    graph: {
+      changed_nodes: impact.changedNodes.map(nodeToDict),
+      impacted_nodes: impact.impactedNodes.map(nodeToDict),
+      edges: impact.edges.map(edgeToDict)
+    }
+  };
+  if (includeSource) {
+    const snippets = {};
+    for (const relPath of changedFiles) {
+      const fullPath = path6.join(repoRoot, relPath);
+      if (fs5.existsSync(fullPath) && fs5.statSync(fullPath).isFile()) {
+        try {
+          const content = fs5.readFileSync(fullPath, "utf-8");
+          const lines = content.split("\n");
+          if (lines.length > maxLinesPerFile) {
+            snippets[relPath] = extractRelevantLines(lines, impact.changedNodes, fullPath);
+          } else {
+            snippets[relPath] = lines.map((l, i) => `${i + 1}: ${l}`).join("\n");
+          }
+        } catch {
+          snippets[relPath] = "(could not read file)";
+        }
+      }
+    }
+    context["source_snippets"] = snippets;
+  }
+  const guidance = generateReviewGuidance(impact, changedFiles);
+  context["review_guidance"] = guidance;
+  const summaryParts = [
+    `Review context for ${changedFiles.length} changed file(s):`,
+    `  - ${impact.changedNodes.length} directly changed nodes`,
+    `  - ${impact.impactedNodes.length} impacted nodes in ${impact.impactedFiles.length} files`,
+    "",
+    "Review guidance:",
+    guidance
+  ];
+  return { status: "ok", summary: summaryParts.join("\n"), context };
+}
+function extractRelevantLines(lines, nodes, filePath) {
+  const ranges = [];
+  for (const n of nodes) {
+    if (n.filePath === filePath) {
+      const start = Math.max(0, (n.lineStart ?? 1) - 3);
+      const end = Math.min(lines.length, (n.lineEnd ?? lines.length) + 2);
+      ranges.push([start, end]);
+    }
+  }
+  if (ranges.length === 0) {
+    return lines.slice(0, 50).map((l, i) => `${i + 1}: ${l}`).join("\n");
+  }
+  ranges.sort((a, b) => a[0] - b[0]);
+  const merged = [ranges[0]];
+  for (const [start, end] of ranges.slice(1)) {
+    const last = merged[merged.length - 1];
+    if (start <= last[1] + 1) {
+      merged[merged.length - 1] = [last[0], Math.max(last[1], end)];
+    } else {
+      merged.push([start, end]);
+    }
+  }
+  const parts = [];
+  for (const [start, end] of merged) {
+    if (parts.length > 0) {
+      parts.push("...");
+    }
+    for (let i = start; i < end; i++) {
+      parts.push(`${i + 1}: ${lines[i] ?? ""}`);
+    }
+  }
+  return parts.join("\n");
+}
+function generateReviewGuidance(impact, _changedFiles) {
+  const guidanceParts = [];
+  const changedFuncs = impact.changedNodes.filter((n) => n.kind === "Function");
+  const testedFuncQns = new Set(
+    impact.edges.filter((e) => e.kind === "TESTED_BY").map((e) => e.sourceQualified)
+  );
+  const untested = changedFuncs.filter(
+    (f) => !testedFuncQns.has(f.qualifiedName) && !f.isTest
+  );
+  if (untested.length > 0) {
+    guidanceParts.push(
+      `- ${untested.length} changed function(s) lack test coverage: ` + untested.slice(0, 5).map((n) => n.name).join(", ")
+    );
+  }
+  if (impact.impactedNodes.length > 20) {
+    guidanceParts.push(
+      `- Wide blast radius: ${impact.impactedNodes.length} nodes impacted. Review callers and dependents carefully.`
+    );
+  }
+  const inheritanceEdges = impact.edges.filter(
+    (e) => e.kind === "INHERITS" || e.kind === "IMPLEMENTS"
+  );
+  if (inheritanceEdges.length > 0) {
+    guidanceParts.push(
+      `- ${inheritanceEdges.length} inheritance/implementation relationship(s) affected. Check for Liskov substitution violations.`
+    );
+  }
+  if (impact.impactedFiles.length > 3) {
+    guidanceParts.push(
+      `- Changes impact ${impact.impactedFiles.length} other files. Consider splitting into smaller PRs.`
+    );
+  }
+  if (guidanceParts.length === 0) {
+    guidanceParts.push("- Changes appear well-contained with minimal blast radius.");
+  }
+  return guidanceParts.join("\n");
+}
+
+// src/usecases/semanticSearch.ts
+async function semanticSearchNodes(args) {
+  const { query, kind = null, limit = 20, repo, embStore } = args;
+  let searchMode = "keyword";
+  try {
+    if (embStore.available && embStore.count() > 0) {
+      searchMode = "semantic";
+      let raw = await semanticSearch(query, repo, embStore, limit * 2);
+      if (kind) {
+        raw = raw.filter((r) => r["kind"] === kind);
+      }
+      raw = raw.slice(0, limit);
+      return {
+        status: "ok",
+        query,
+        search_mode: searchMode,
+        summary: `Found ${raw.length} node(s) matching '${query}' via semantic search` + (kind ? ` (kind=${kind})` : ""),
+        results: raw
+      };
+    }
+  } catch {
+    searchMode = "keyword";
+  }
+  let results = repo.searchNodes(query, limit * 2);
+  if (kind) {
+    results = results.filter((r) => r.kind === kind);
+  }
+  const qLower = query.toLowerCase();
+  results.sort((a, b) => {
+    const aLower = a.name.toLowerCase();
+    const bLower = b.name.toLowerCase();
+    const aScore = aLower === qLower ? 0 : aLower.startsWith(qLower) ? 1 : 2;
+    const bScore = bLower === qLower ? 0 : bLower.startsWith(qLower) ? 1 : 2;
+    return aScore - bScore;
+  });
+  results = results.slice(0, limit);
+  return {
+    status: "ok",
+    query,
+    search_mode: searchMode,
+    summary: `Found ${results.length} node(s) matching '${query}'` + (kind ? ` (kind=${kind})` : ""),
+    results: results.map(nodeToDict)
+  };
+}
+async function semanticSearch(query, repo, embStore, limit = 20) {
+  if (embStore.available && embStore.count() > 0) {
+    const results = await embStore.search(query, limit);
+    const output = [];
+    for (const { qualifiedName, score } of results) {
+      const node = repo.getNode(qualifiedName);
+      if (node) {
+        const d = nodeToDict(node);
+        d["similarity_score"] = Math.round(score * 1e4) / 1e4;
+        output.push(d);
+      }
+    }
+    return output;
+  }
+  return repo.searchNodes(query, limit).map((n) => nodeToDict(n));
+}
+
+// src/usecases/listStats.ts
+import path7 from "path";
+function listStats(args) {
+  const { repo, embStore, repoRoot } = args;
+  const stats = repo.getStats();
+  const rootName = path7.basename(repoRoot);
+  const summaryParts = [
+    `Graph statistics for ${rootName}:`,
+    `  Files: ${stats.filesCount}`,
+    `  Total nodes: ${stats.totalNodes}`,
+    `  Total edges: ${stats.totalEdges}`,
+    `  Languages: ${stats.languages.length > 0 ? stats.languages.join(", ") : "none"}`,
+    `  Last updated: ${stats.lastUpdated ?? "never"}`,
+    "",
+    "Nodes by kind:",
+    ...Object.entries(stats.nodesByKind).sort().map(([k, c]) => `  ${k}: ${c}`),
+    "",
+    "Edges by kind:",
+    ...Object.entries(stats.edgesByKind).sort().map(([k, c]) => `  ${k}: ${c}`)
+  ];
+  let embCount = 0;
+  try {
+    embCount = embStore.count();
+    summaryParts.push("", `Embeddings: ${embCount} nodes embedded`);
+    if (!embStore.available) {
+      summaryParts.push("  (install @huggingface/transformers for semantic search)");
+    }
+  } catch {
+  }
+  return {
+    status: "ok",
+    summary: summaryParts.join("\n"),
+    total_nodes: stats.totalNodes,
+    total_edges: stats.totalEdges,
+    nodes_by_kind: stats.nodesByKind,
+    edges_by_kind: stats.edgesByKind,
+    languages: stats.languages,
+    files_count: stats.filesCount,
+    last_updated: stats.lastUpdated,
+    embeddings_count: embCount
+  };
+}
+
+// src/usecases/embedGraph.ts
+async function embedAllNodes(repo, embStore) {
+  if (!embStore.available) return 0;
+  const allNodes = [];
+  for (const f of repo.getAllFiles()) {
+    allNodes.push(...repo.getNodesByFile(f));
+  }
+  return embStore.embedNodes(allNodes);
+}
+async function embedGraph(args) {
+  const { repo, embStore } = args;
+  if (!embStore.available) {
+    return {
+      status: "error",
+      error: "@huggingface/transformers is not installed. Install with: npm install codeorbit (with optional deps)"
+    };
+  }
+  const newlyEmbedded = await embedAllNodes(repo, embStore);
+  const total = embStore.count();
+  return {
+    status: "ok",
+    summary: `Embedded ${newlyEmbedded} new node(s). Total embeddings: ${total}. Semantic search is now active.`,
+    newly_embedded: newlyEmbedded,
+    total_embeddings: total
+  };
+}
+
+// src/usecases/getDocsSection.ts
+import fs6 from "fs";
+import path8 from "path";
+var AVAILABLE_SECTIONS = [
+  "usage",
+  "review-delta",
+  "review-pr",
+  "commands",
+  "legal",
+  "watch",
+  "embeddings",
+  "languages",
+  "troubleshooting"
+];
+function getDocsSection(args) {
+  const { sectionName, searchRoots } = args;
+  for (const searchRoot of searchRoots) {
+    const candidate = path8.join(searchRoot, "docs", "LLM-OPTIMIZED-REFERENCE.md");
+    if (fs6.existsSync(candidate)) {
+      const content = fs6.readFileSync(candidate, "utf-8");
+      const escapedName = sectionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const match = new RegExp(
+        `<section name="${escapedName}">(.*?)</section>`,
+        "si"
+      ).exec(content);
+      if (match) {
+        return { status: "ok", section: sectionName, content: match[1].trim() };
+      }
+    }
+  }
+  return {
+    status: "not_found",
+    error: `Section '${sectionName}' not found. Available: ${AVAILABLE_SECTIONS.join(", ")}`
+  };
+}
+
+// src/usecases/findLargeFunctions.ts
+import path9 from "path";
+function findLargeFunctions(args) {
+  const { minLines = 50, kind = null, filePathPattern = null, limit = 50, repo, repoRoot } = args;
+  const nodes = repo.getNodesBySize(
+    minLines,
+    void 0,
+    kind ?? void 0,
+    filePathPattern ?? void 0,
+    limit
+  );
+  const results = nodes.map((n) => {
+    const d = nodeToDict(n);
+    d["line_count"] = n.lineStart != null && n.lineEnd != null ? n.lineEnd - n.lineStart + 1 : 0;
+    try {
+      d["relative_path"] = path9.relative(repoRoot, n.filePath);
+    } catch {
+      d["relative_path"] = n.filePath;
+    }
+    return d;
+  });
+  const summaryParts = [
+    `Found ${results.length} node(s) with >= ${minLines} lines` + (kind ? ` (kind=${kind})` : "") + (filePathPattern ? ` matching '${filePathPattern}'` : "") + ":"
+  ];
+  for (const r of results.slice(0, 10)) {
+    summaryParts.push(
+      `  ${String(r["line_count"]).padStart(4)} lines | ${String(r["kind"]).padStart(8)} | ${r["name"]} (${r["relative_path"]}:${r["line_start"]})`
+    );
+  }
+  if (results.length > 10) {
+    summaryParts.push(`  ... and ${results.length - 10} more`);
+  }
+  return {
+    status: "ok",
+    summary: summaryParts.join("\n"),
+    total_found: results.length,
+    min_lines: minLines,
+    results
+  };
+}
+
+// src/adapters/mcp/tools.ts
+function validateRepoRoot(repoRoot) {
+  const resolved = path10.resolve(repoRoot);
+  if (!fs7.existsSync(resolved) || !fs7.statSync(resolved).isDirectory()) {
+    throw new Error(`repo_root is not an existing directory: ${resolved}`);
+  }
+  if (!fs7.existsSync(path10.join(resolved, ".git")) && !fs7.existsSync(path10.join(resolved, ".codeorbit"))) {
+    throw new Error(
+      `repo_root does not look like a project root (no .git or .codeorbit): ${resolved}`
+    );
+  }
+  return resolved;
+}
+function resolveRoot(repoRoot) {
+  return repoRoot ? validateRepoRoot(repoRoot) : findProjectRoot();
+}
+function buildOrUpdateGraph(args) {
+  const { fullRebuild = false, repoRoot = null, base = "HEAD~1" } = args;
+  const root = resolveRoot(repoRoot);
+  const repo = new SqliteGraphRepository(getDbPath(root));
+  const parser = new CodeParser();
+  try {
+    if (fullRebuild) {
+      const result = fullBuild(root, repo, parser);
+      return {
+        status: "ok",
+        build_type: "full",
+        summary: `Full build complete: parsed ${result.filesUpdated} files, created ${result.totalNodes} nodes and ${result.totalEdges} edges.`,
+        files_updated: result.filesUpdated,
+        total_nodes: result.totalNodes,
+        total_edges: result.totalEdges,
+        errors: result.errors
+      };
+    } else {
+      const result = incrementalUpdate(root, repo, parser, base);
+      if (result.filesUpdated === 0) {
+        return {
+          status: "ok",
+          build_type: "incremental",
+          summary: "No changes detected. Graph is up to date.",
+          files_updated: 0,
+          total_nodes: 0,
+          total_edges: 0,
+          changed_files: [],
+          dependent_files: [],
+          errors: []
+        };
+      }
+      return {
+        status: "ok",
+        build_type: "incremental",
+        summary: `Incremental update: ${result.filesUpdated} files re-parsed, ${result.totalNodes} nodes and ${result.totalEdges} edges updated. Changed: ${JSON.stringify(result.changedFiles)}. Dependents also updated: ${JSON.stringify(result.dependentFiles)}.`,
+        files_updated: result.filesUpdated,
+        total_nodes: result.totalNodes,
+        total_edges: result.totalEdges,
+        changed_files: result.changedFiles,
+        dependent_files: result.dependentFiles,
+        errors: result.errors
+      };
+    }
+  } finally {
+    repo.close();
+  }
+}
+function getImpactRadius(args) {
+  const {
+    changedFiles = null,
+    maxDepth = 2,
+    maxResults = 500,
+    repoRoot = null,
+    base = "HEAD~1"
+  } = args;
+  const root = resolveRoot(repoRoot);
+  const repo = new SqliteGraphRepository(getDbPath(root));
+  try {
+    let changed = changedFiles;
+    if (!changed) {
+      changed = getChangedFiles(root, base);
+      if (changed.length === 0) {
+        changed = getStagedAndUnstaged(root);
+      }
+    }
+    if (changed.length === 0) {
+      return {
+        status: "ok",
+        summary: "No changed files detected.",
+        changed_nodes: [],
+        impacted_nodes: [],
+        impacted_files: [],
+        truncated: false,
+        total_impacted: 0
+      };
+    }
+    const absFiles = changed.map((f) => path10.join(root, f));
+    const result = computeImpactRadius(absFiles, repo, maxDepth, maxResults);
+    const summaryParts = [
+      `Blast radius for ${changed.length} changed file(s):`,
+      `  - ${result.changedNodes.length} nodes directly changed`,
+      `  - ${result.impactedNodes.length} nodes impacted (within ${maxDepth} hops)`,
+      `  - ${result.impactedFiles.length} additional files affected`
+    ];
+    if (result.truncated) {
+      summaryParts.push(
+        `  - Results truncated: showing ${result.impactedNodes.length} of ${result.totalImpacted} impacted nodes`
+      );
+    }
+    return {
+      status: "ok",
+      summary: summaryParts.join("\n"),
+      changed_files: changed,
+      changed_nodes: result.changedNodes.map(nodeToDict),
+      impacted_nodes: result.impactedNodes.map(nodeToDict),
+      impacted_files: result.impactedFiles,
+      edges: result.edges.map(edgeToDict),
+      truncated: result.truncated,
+      total_impacted: result.totalImpacted
+    };
+  } finally {
+    repo.close();
+  }
+}
+function queryGraph2(args) {
+  const { pattern, target, repoRoot = null } = args;
+  const root = resolveRoot(repoRoot);
+  const repo = new SqliteGraphRepository(getDbPath(root));
+  try {
+    return queryGraph({ pattern, target, repo, repoRoot: root });
+  } finally {
+    repo.close();
+  }
+}
+function getReviewContext2(args) {
+  const {
+    changedFiles = null,
+    maxDepth = 2,
+    includeSource = true,
+    maxLinesPerFile = 200,
+    repoRoot = null,
+    base = "HEAD~1"
+  } = args;
+  const root = resolveRoot(repoRoot);
+  const repo = new SqliteGraphRepository(getDbPath(root));
+  try {
+    let changed = changedFiles;
+    if (!changed) {
+      changed = getChangedFiles(root, base);
+      if (changed.length === 0) {
+        changed = getStagedAndUnstaged(root);
+      }
+    }
+    if (changed.length === 0) {
+      return {
+        status: "ok",
+        summary: "No changes detected. Nothing to review.",
+        context: {}
+      };
+    }
+    return getReviewContext({
+      changedFiles: changed,
+      repo,
+      repoRoot: root,
+      maxDepth,
+      includeSource,
+      maxLinesPerFile
+    });
+  } finally {
+    repo.close();
+  }
+}
+async function semanticSearchNodes2(args) {
+  const { query, kind = null, limit = 20, repoRoot = null } = args;
+  const root = resolveRoot(repoRoot);
+  const dbPath = getDbPath(root);
+  const repo = new SqliteGraphRepository(dbPath);
+  const embStore = new SqliteEmbeddingStore(dbPath);
+  try {
+    return await semanticSearchNodes({ query, kind, limit, repo, embStore });
+  } finally {
+    embStore.close();
+    repo.close();
+  }
+}
+function listGraphStats(args) {
+  const { repoRoot = null } = args;
+  const root = resolveRoot(repoRoot);
+  const dbPath = getDbPath(root);
+  const repo = new SqliteGraphRepository(dbPath);
+  const embStore = new SqliteEmbeddingStore(dbPath);
+  try {
+    return listStats({ repo, embStore, repoRoot: root });
+  } finally {
+    embStore.close();
+    repo.close();
+  }
+}
+async function embedGraph2(args) {
+  const { repoRoot = null } = args;
+  const root = resolveRoot(repoRoot);
+  const dbPath = getDbPath(root);
+  const repo = new SqliteGraphRepository(dbPath);
+  const embStore = new SqliteEmbeddingStore(dbPath);
+  try {
+    return await embedGraph({ repo, embStore });
+  } finally {
+    embStore.close();
+    repo.close();
+  }
+}
+function getDocsSection2(args) {
+  const { sectionName, repoRoot = null } = args;
+  const searchRoots = [];
+  if (repoRoot) {
+    searchRoots.push(path10.resolve(repoRoot));
+  }
+  try {
+    const root = resolveRoot(repoRoot);
+    if (!searchRoots.includes(root)) {
+      searchRoots.push(root);
+    }
+  } catch {
+  }
+  return getDocsSection({ sectionName, searchRoots });
+}
+function findLargeFunctions2(args) {
+  const {
+    minLines = 50,
+    kind = null,
+    filePathPattern = null,
+    limit = 50,
+    repoRoot = null
+  } = args;
+  const root = resolveRoot(repoRoot);
+  const repo = new SqliteGraphRepository(getDbPath(root));
+  try {
+    return findLargeFunctions({ minLines, kind, filePathPattern, limit, repo, repoRoot: root });
+  } finally {
+    repo.close();
+  }
+}
+
+// src/adapters/mcp/server.ts
+var server = new McpServer(
+  { name: "codeorbit", version: "0.1.0" },
+  {
+    instructions: "Persistent incremental knowledge graph for token-efficient, context-aware code reviews. Parses your codebase with Tree-sitter, builds a structural graph, and provides smart impact analysis."
+  }
+);
+server.tool(
+  "build_or_update_graph_tool",
+  "Build or incrementally update the code knowledge graph.\n\nCall this first to initialize the graph, or after making changes.\nBy default performs an incremental update (only changed files).\nSet full_rebuild=True to re-parse every file.\n\nArgs:\n    full_rebuild: If True, re-parse all files. Default: False (incremental).\n    repo_root: Repository root path. Auto-detected from current directory if omitted.\n    base: Git ref to diff against for incremental updates. Default: HEAD~1.",
+  {
+    full_rebuild: z.boolean().default(false),
+    repo_root: z.string().nullable().default(null),
+    base: z.string().default("HEAD~1")
+  },
+  async (args) => ({
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          buildOrUpdateGraph({
+            fullRebuild: args.full_rebuild,
+            repoRoot: args.repo_root,
+            base: args.base
+          })
+        )
+      }
+    ]
+  })
+);
+server.tool(
+  "get_impact_radius_tool",
+  "Analyze the blast radius of changed files in the codebase.\n\nShows which functions, classes, and files are impacted by changes.\nAuto-detects changed files from git if not specified.\n\nArgs:\n    changed_files: List of changed file paths (relative to repo root). Auto-detected if omitted.\n    max_depth: Number of hops to traverse in the dependency graph. Default: 2.\n    repo_root: Repository root path. Auto-detected if omitted.\n    base: Git ref for auto-detecting changes. Default: HEAD~1.",
+  {
+    changed_files: z.array(z.string()).nullable().default(null),
+    max_depth: z.number().int().default(2),
+    repo_root: z.string().nullable().default(null),
+    base: z.string().default("HEAD~1")
+  },
+  async (args) => ({
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          getImpactRadius({
+            changedFiles: args.changed_files,
+            maxDepth: args.max_depth,
+            repoRoot: args.repo_root,
+            base: args.base
+          })
+        )
+      }
+    ]
+  })
+);
+server.tool(
+  "query_graph_tool",
+  "Run a predefined graph query to explore code relationships.\n\nAvailable patterns:\n- callers_of: Find functions that call the target\n- callees_of: Find functions called by the target\n- imports_of: Find what the target imports\n- importers_of: Find files that import the target\n- children_of: Find nodes contained in a file or class\n- tests_for: Find tests for the target\n- inheritors_of: Find classes inheriting from the target\n- file_summary: Get all nodes in a file\n\nArgs:\n    pattern: Query pattern name (see above).\n    target: Node name, qualified name, or file path to query.\n    repo_root: Repository root path. Auto-detected if omitted.",
+  {
+    pattern: z.string(),
+    target: z.string(),
+    repo_root: z.string().nullable().default(null)
+  },
+  async (args) => ({
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          queryGraph2({
+            pattern: args.pattern,
+            target: args.target,
+            repoRoot: args.repo_root
+          })
+        )
+      }
+    ]
+  })
+);
+server.tool(
+  "get_review_context_tool",
+  "Generate a focused, token-efficient review context for code changes.\n\nCombines impact analysis with source snippets and review guidance.\nUse this for comprehensive code reviews.\n\nArgs:\n    changed_files: Files to review. Auto-detected from git diff if omitted.\n    max_depth: Impact radius depth. Default: 2.\n    include_source: Include source code snippets. Default: True.\n    max_lines_per_file: Max source lines per file. Default: 200.\n    repo_root: Repository root path. Auto-detected if omitted.\n    base: Git ref for change detection. Default: HEAD~1.",
+  {
+    changed_files: z.array(z.string()).nullable().default(null),
+    max_depth: z.number().int().default(2),
+    include_source: z.boolean().default(true),
+    max_lines_per_file: z.number().int().default(200),
+    repo_root: z.string().nullable().default(null),
+    base: z.string().default("HEAD~1")
+  },
+  async (args) => ({
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          getReviewContext2({
+            changedFiles: args.changed_files,
+            maxDepth: args.max_depth,
+            includeSource: args.include_source,
+            maxLinesPerFile: args.max_lines_per_file,
+            repoRoot: args.repo_root,
+            base: args.base
+          })
+        )
+      }
+    ]
+  })
+);
+server.tool(
+  "semantic_search_nodes_tool",
+  "Search for code entities by name, keyword, or semantic similarity.\n\nUses vector embeddings for semantic search when available (run embed_graph_tool\nfirst, requires @huggingface/transformers). Falls back to keyword matching otherwise.\n\nArgs:\n    query: Search string to match against node names.\n    kind: Optional filter: File, Class, Function, Type, or Test.\n    limit: Maximum results. Default: 20.\n    repo_root: Repository root path. Auto-detected if omitted.",
+  {
+    query: z.string(),
+    kind: z.string().nullable().default(null),
+    limit: z.number().int().default(20),
+    repo_root: z.string().nullable().default(null)
+  },
+  async (args) => ({
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          await semanticSearchNodes2({
+            query: args.query,
+            kind: args.kind,
+            limit: args.limit,
+            repoRoot: args.repo_root
+          })
+        )
+      }
+    ]
+  })
+);
+server.tool(
+  "embed_graph_tool",
+  "Compute vector embeddings for all graph nodes to enable semantic search.\n\nRequires: npm install @huggingface/transformers\nOnly computes embeddings for nodes that do not already have them.\n\nArgs:\n    repo_root: Repository root path. Auto-detected if omitted.",
+  {
+    repo_root: z.string().nullable().default(null)
+  },
+  async (args) => ({
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(await embedGraph2({ repoRoot: args.repo_root }))
+      }
+    ]
+  })
+);
+server.tool(
+  "list_graph_stats_tool",
+  "Get aggregate statistics about the code knowledge graph.\n\nShows total nodes, edges, languages, files, and last update time.\nUseful for checking if the graph is built and up to date.\n\nArgs:\n    repo_root: Repository root path. Auto-detected if omitted.",
+  {
+    repo_root: z.string().nullable().default(null)
+  },
+  async (args) => ({
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(listGraphStats({ repoRoot: args.repo_root }))
+      }
+    ]
+  })
+);
+server.tool(
+  "get_docs_section_tool",
+  'Get a specific section from the LLM-optimized documentation reference.\n\nReturns only the requested section content for minimal token usage.\n\nAvailable sections: usage, review-delta, review-pr, commands, legal,\nwatch, embeddings, languages, troubleshooting.\n\nArgs:\n    section_name: The section to retrieve (e.g. "review-delta", "usage").',
+  {
+    section_name: z.string(),
+    repo_root: z.string().nullable().default(null)
+  },
+  async (args) => ({
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          getDocsSection2({
+            sectionName: args.section_name,
+            repoRoot: args.repo_root
+          })
+        )
+      }
+    ]
+  })
+);
+server.tool(
+  "find_large_functions_tool",
+  'Find functions, classes, or files exceeding a line-count threshold.\n\nUseful for decomposition audits, code quality checks, and enforcing\nsize limits during code review. Results are ordered by line count.\n\nArgs:\n    min_lines: Minimum line count to flag. Default: 50.\n    kind: Optional filter: Function, Class, File, or Test.\n    file_path_pattern: Filter by file path substring (e.g. "components/").\n    limit: Maximum results. Default: 50.\n    repo_root: Repository root path. Auto-detected if omitted.',
+  {
+    min_lines: z.number().int().default(50),
+    kind: z.string().nullable().default(null),
+    file_path_pattern: z.string().nullable().default(null),
+    limit: z.number().int().default(50),
+    repo_root: z.string().nullable().default(null)
+  },
+  async (args) => ({
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          findLargeFunctions2({
+            minLines: args.min_lines,
+            kind: args.kind,
+            filePathPattern: args.file_path_pattern,
+            limit: args.limit,
+            repoRoot: args.repo_root
+          })
+        )
+      }
+    ]
+  })
+);
+async function runMcpServer() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  runMcpServer
+};
+//# sourceMappingURL=server.js.map