@optave/codegraph 2.0.0 → 2.1.1-dev.3c12b64

package/README.md

@@ -45,10 +45,10 @@ Most tools in this space can't do that:
 
 | Problem | Who has it | Why it breaks on every commit |
 |---|---|---|
-| **Full re-index on every change** | code-graph-rag, CodeMCP, axon, autodev-codebase | No file-level change tracking. Change one file → re-parse and re-insert the entire codebase. On a 3,000-file project, that's 30+ seconds per commit minimum |
-| **Cloud API calls baked into the pipeline** | code-graph-rag, autodev-codebase, Claude-code-memory, CodeRAG | Embeddings are generated through cloud APIs (OpenAI, Voyage AI, Gemini). Every rebuild = API round-trips for every function. Slow, expensive, and rate-limited. You can't put this in a commit hook |
+| **Full re-index on every change** | code-graph-rag, CodeMCP, axon, joern, cpg, GitNexus | No file-level change tracking. Change one file → re-parse and re-insert the entire codebase. On a 3,000-file project, that's 30+ seconds per commit minimum |
+| **Cloud API calls baked into the pipeline** | code-graph-rag, CodeRAG | Embeddings are generated through cloud APIs (OpenAI, Voyage AI, Gemini). Every rebuild = API round-trips for every function. Slow, expensive, and rate-limited. You can't put this in a commit hook |
 | **Heavy infrastructure that's slow to restart** | code-graph-rag (Memgraph), axon (KuzuDB), badger-graph (Dgraph) | External databases add latency to every write. Bulk-inserting a full graph into Memgraph is not a sub-second operation |
-| **No persistence between runs** | glimpse, pyan, cflow | Re-parse from scratch every time. No database, no delta, no incremental anything |
+| **No persistence between runs** | pyan, cflow | Re-parse from scratch every time. No database, no delta, no incremental anything |
 
 **Codegraph solves this with incremental builds:**
 
@@ -71,20 +71,21 @@ Most code graph tools make you choose: **fast local analysis with no AI, or powe
 
 ### Feature comparison
 
-| Capability | codegraph | [code-graph-rag](https://github.com/vitali87/code-graph-rag) | [glimpse](https://github.com/seatedro/glimpse) | [CodeMCP](https://github.com/SimplyLiz/CodeMCP) | [axon](https://github.com/harshkedia177/axon) | [autodev-codebase](https://github.com/anrgct/autodev-codebase) | [arbor](https://github.com/Anandb71/arbor) | [Claude-code-memory](https://github.com/Durafen/Claude-code-memory) |
+| Capability | codegraph | [joern](https://github.com/joernio/joern) | [narsil-mcp](https://github.com/postrv/narsil-mcp) | [code-graph-rag](https://github.com/vitali87/code-graph-rag) | [cpg](https://github.com/Fraunhofer-AISEC/cpg) | [GitNexus](https://github.com/abhigyanpatwari/GitNexus) | [CodeMCP](https://github.com/SimplyLiz/CodeMCP) | [axon](https://github.com/harshkedia177/axon) |
 |---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| Function-level analysis | **Yes** | **Yes** | **Yes** | **Yes** | **Yes** | **Yes** | **Yes** | — |
-| Multi-language | **11** | Multi | Multi | SCIP langs | Few | **40+** | Multi | — |
-| Semantic search | **Yes** | **Yes** | — | — | — | **Yes** | **Yes** | **Yes** |
-| MCP / AI agent support | **Yes** | **Yes** | — | **Yes** | — | — | **Yes** | **Yes** |
-| Git diff impact | **Yes** | — | — | — | **Yes** | — | — | — |
-| Watch mode | **Yes** | — | — | — | — | — | — | — |
-| CI workflow included | **Yes** | — | — | — | — | — | — | — |
-| Cycle detection | **Yes** | — | — | — | **Yes** | — | — | — |
-| Incremental rebuilds | **Yes** | — | — | — | — | — | — | — |
-| Zero config | **Yes** | — | **Yes** | — | — | — | **Yes** | — |
-| LLM-optional (works without API keys) | **Yes** | — | **Yes** | **Yes** | **Yes** | — | **Yes** | — |
-| Open source | **Yes** | Yes | Yes | Custom | — | — | Yes | — |
+| Function-level analysis | **Yes** | **Yes** | **Yes** | **Yes** | **Yes** | **Yes** | **Yes** | **Yes** |
+| Multi-language | **11** | **14** | **32** | Multi | **~10** | **9** | SCIP langs | Few |
+| Semantic search | **Yes** | — | **Yes** | **Yes** | — | **Yes** | — | — |
+| MCP / AI agent support | **Yes** | — | **Yes** | **Yes** | **Yes** | **Yes** | **Yes** | — |
+| Git diff impact | **Yes** | — | — | — | — | **Yes** | — | **Yes** |
+| Watch mode | **Yes** | — | **Yes** | — | — | — | — | — |
+| Cycle detection | **Yes** | — | **Yes** | — | — | — | — | **Yes** |
+| Incremental rebuilds | **Yes** | — | **Yes** | — | — | — | — | — |
+| Zero config | **Yes** | — | **Yes** | — | — | — | — | — |
+| Embeddable JS library (`npm install`) | **Yes** | — | — | — | — | — | — | — |
+| LLM-optional (works without API keys) | **Yes** | **Yes** | **Yes** | — | **Yes** | **Yes** | **Yes** | **Yes** |
+| Commercial use allowed | **Yes** | **Yes** | **Yes** | **Yes** | **Yes** | — | — | — |
+| Open source | **Yes** | Yes | Yes | Yes | Yes | Yes | Custom | — |
 
 ### What makes codegraph different
 
@@ -104,18 +105,53 @@ The key question is: **can you rebuild your graph on every commit in a large cod
 
 | Tool | What it does well | The tradeoff |
 |---|---|---|
+| [joern](https://github.com/joernio/joern) | Full CPG (AST + CFG + PDG) for vulnerability discovery, Scala query DSL, 14 languages, daily releases | No incremental builds — full re-parse on every change. Requires JDK 21, no built-in MCP, no watch mode |
+| [narsil-mcp](https://github.com/postrv/narsil-mcp) | 90 MCP tools, 32 languages, taint analysis, SBOM, dead code, neural search, Merkle-tree incremental indexing, single ~30MB binary | Primarily MCP-only — no standalone CLI query interface. Neural search requires API key or ONNX source build |
 | [code-graph-rag](https://github.com/vitali87/code-graph-rag) | Graph RAG with Memgraph, multi-provider AI, semantic search, code editing via AST | No incremental rebuilds — full re-index + re-embed through cloud APIs on every change. Requires Docker |
-| [glimpse](https://github.com/seatedro/glimpse) | Clipboard-first LLM context tool, call graphs, LSP resolution, token counting | Context-packing tool, not a dependency graph — no persistence, no MCP, no incremental updates |
+| [cpg](https://github.com/Fraunhofer-AISEC/cpg) | Formal Code Property Graph (AST + CFG + PDG + DFG), ~10 languages, MCP module, LLVM IR support, academic specifications | No incremental builds. Requires JVM + Gradle, no zero config, no watch mode |
+| [GitNexus](https://github.com/abhigyanpatwari/GitNexus) | Knowledge graph with precomputed structural intelligence, 7 MCP tools, hybrid search (BM25 + semantic + RRF), clustering, process tracing | Full 6-phase pipeline re-run on changes. KuzuDB graph DB, browser mode limited to ~5,000 files. **PolyForm NC — no commercial use** |
 | [CodeMCP](https://github.com/SimplyLiz/CodeMCP) | SCIP compiler-grade indexing, compound operations (83% token savings), secret scanning | No incremental builds. Custom license, requires SCIP toolchains per language |
 | [axon](https://github.com/harshkedia177/axon) | 11-phase pipeline, KuzuDB, community detection, dead code, change coupling | Full pipeline re-run on changes. No license, Python-only, no MCP |
-| [autodev-codebase](https://github.com/anrgct/autodev-codebase) | 40+ languages, interactive Cytoscape.js visualization, LLM reranking | Re-embeds through cloud APIs on changes. No license, complex setup |
-| [arbor](https://github.com/Anandb71/arbor) | Native GUI, confidence scoring, architectural role classification, fuzzy search | GUI-focused — no CLI pipeline, no watch mode, no CI integration |
-| [Claude-code-memory](https://github.com/Durafen/Claude-code-memory) | Persistent codebase memory for Claude Code, Memory Guard quality gate | Requires Voyage AI (cloud) + Qdrant (Docker) for core features |
 | [Madge](https://github.com/pahen/madge) | Simple file-level JS/TS dependency graphs | No function-level analysis, no impact tracing, JS/TS only |
 | [dependency-cruiser](https://github.com/sverweij/dependency-cruiser) | Architectural rule validation for JS/TS | Module-level only (function-level explicitly out of scope), requires config |
 | [Nx graph](https://nx.dev/) | Monorepo project-level dependency graph | Requires Nx workspace, project-level only (not file or function) |
 | [pyan](https://github.com/Technologicat/pyan) / [cflow](https://www.gnu.org/software/cflow/) | Function-level call graphs | Single-language each (Python / C only), no persistence, no queries |
 
+### Codegraph vs. Narsil-MCP: How to Decide
+
+If you are looking for local code intelligence over MCP, the closest alternative to `codegraph` is [postrv/narsil-mcp](https://github.com/postrv/narsil-mcp). Both projects aim to give AI agents deep context about your codebase, but they approach the problem with fundamentally different philosophies. 
+
+Here is a cold, analytical breakdown to help you decide which tool fits your workflow.
+
+#### The Core Difference
+
+* **Codegraph is a surgical scalpel.** It does one thing exceptionally well: building an always-fresh, function-level dependency graph in SQLite and exposing it to AI agents with zero fluff.
+* **Narsil-MCP is a Swiss Army knife.** It is a sprawling, "batteries-included" intelligence server that includes everything from taint analysis and SBOM generation to SPARQL knowledge graphs.
+
+#### Feature Comparison
+
+| Aspect | Optave Codegraph | Narsil-MCP |
+| :--- | :--- | :--- |
+| **Philosophy** | Lean, deterministic, AI-optimized | Comprehensive, feature-dense |
+| **AI Tool Count** | 13 focused tools | 90 distinct tools |
+| **Language Support** | 11 languages | 32 languages |
+| **Primary Interface** | CLI-first with MCP integration | MCP-first (CLI is secondary) |
+| **Supply Chain Risk** | Low (minimal dependency tree) | Higher (requires massive dependency graph for embedded ML/scanners) |
+| **Graph Updates** | Sub-second incremental (file-hash) | Parallel re-indexing / Merkle trees |
+
+#### Choose Codegraph if:
+
+* **You want to optimize AI agent reasoning.** Large Language Models degrade in performance and hallucinate when overwhelmed with choices. Codegraph’s tight 13-tool surface area ensures agents quickly understand their capabilities without wasting context window tokens.
+* **You are concerned about supply chain attacks.** To support 90 tools, SBOMs, and neural embeddings, a tool must pull in a massive dependency tree. Codegraph keeps its dependencies minimal, dramatically reducing the risk of malicious code sneaking onto your machine.
+* **You want deterministic blast-radius checks.** Features like `diff-impact` are built specifically to tell you exactly how a changed function cascades through your codebase before you merge a PR.
+* **You value a strong standalone CLI.** You want to query your code graph locally without necessarily spinning up an AI agent.
+
+#### Choose Narsil-MCP if:
+
+* **You want security and code intelligence together.** You dont want a separated MCP for security and prefer an 'all-in-one solution.
+* **You use niche languages.** Your codebase relies heavily on languages outside of Codegraph's core 11 (e.g., Fortran, Erlang, Zig, Swift).
+* **You are willing to manage tool presets.** Because 90 tools will overload an AI's context window, you don't mind manually configuring preset files (like "Minimal" or "Balanced") to restrict what the AI can see depending on your editor.
+
 ---
 
 ## 🚀 Quick Start
@@ -229,10 +265,10 @@ A single trailing semicolon is ignored (falls back to single-query mode). The `-
 
 | Flag | Model | Dimensions | Size | License | Notes |
 |---|---|---|---|---|---|
-| `minilm` (default) | all-MiniLM-L6-v2 | 384 | ~23 MB | Apache-2.0 | Fastest, good for quick iteration |
+| `minilm` | all-MiniLM-L6-v2 | 384 | ~23 MB | Apache-2.0 | Fastest, good for quick iteration |
 | `jina-small` | jina-embeddings-v2-small-en | 512 | ~33 MB | Apache-2.0 | Better quality, still small |
 | `jina-base` | jina-embeddings-v2-base-en | 768 | ~137 MB | Apache-2.0 | High quality, 8192 token context |
-| `jina-code` | jina-embeddings-v2-base-code | 768 | ~137 MB | Apache-2.0 | **Best for code search**, trained on code+text |
+| `jina-code` (default) | jina-embeddings-v2-base-code | 768 | ~137 MB | Apache-2.0 | **Best for code search**, trained on code+text |
 | `nomic` | nomic-embed-text-v1 | 768 | ~137 MB | Apache-2.0 | Good quality, 8192 context |
 | `nomic-v1.5` | nomic-embed-text-v1.5 | 768 | ~137 MB | Apache-2.0 | Improved nomic, Matryoshka dimensions |
 | `bge-large` | bge-large-en-v1.5 | 1024 | ~335 MB | MIT | Best general retrieval, top MTEB scores |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optave/codegraph",
-  "version": "2.0.0",
+  "version": "2.1.1-dev.3c12b64",
   "description": "Local code graph CLI — parse codebases with tree-sitter, build dependency graphs, query them",
   "type": "module",
   "main": "src/index.js",
@@ -29,11 +29,11 @@
     "lint": "biome check src/ tests/",
     "lint:fix": "biome check --write src/ tests/",
     "format": "biome format --write src/ tests/",
-    "prepare": "npm run build:wasm && husky",
+    "prepare": "npm run build:wasm && husky && npm run deps:tree",
+    "deps:tree": "node scripts/gen-deps.cjs",
     "release": "commit-and-tag-version",
     "release:dry-run": "commit-and-tag-version --dry-run",
-    "version": "node scripts/sync-native-versions.js && git add package.json",
-    "prepublishOnly": "npm test"
+    "version": "node scripts/sync-native-versions.js && git add package.json"
   },
   "keywords": [
     "codegraph",
@@ -61,19 +61,19 @@
   "optionalDependencies": {
     "@huggingface/transformers": "^3.8.1",
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@optave/codegraph-darwin-arm64": "2.0.0",
-    "@optave/codegraph-darwin-x64": "2.0.0",
-    "@optave/codegraph-linux-x64-gnu": "2.0.0",
-    "@optave/codegraph-win32-x64-msvc": "2.0.0"
+    "@optave/codegraph-darwin-arm64": "2.1.1-dev.3c12b64",
+    "@optave/codegraph-darwin-x64": "2.1.1-dev.3c12b64",
+    "@optave/codegraph-linux-x64-gnu": "2.1.1-dev.3c12b64",
+    "@optave/codegraph-win32-x64-msvc": "2.1.1-dev.3c12b64"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.4",
     "@commitlint/cli": "^19.8",
     "@commitlint/config-conventional": "^19.8",
-    "commit-and-tag-version": "^12.5",
-    "husky": "^9.1",
     "@tree-sitter-grammars/tree-sitter-hcl": "^1.2.0",
     "@vitest/coverage-v8": "^4.0.18",
+    "commit-and-tag-version": "^12.5",
+    "husky": "^9.1",
     "tree-sitter-c-sharp": "^0.23.1",
     "tree-sitter-cli": "^0.26.5",
     "tree-sitter-go": "^0.23.4",

package/src/builder.js

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { loadConfig } from './config.js';
 import { EXTENSIONS, IGNORE_DIRS, normalizePath } from './constants.js';
@@ -581,10 +582,18 @@ export async function buildGraph(rootDir, opts = {}) {
   console.log(`Stored in ${dbPath}`);
   db.close();
 
-  try {
-    const { registerRepo } = await import('./registry.js');
-    registerRepo(rootDir);
-  } catch (err) {
-    debug(`Auto-registration failed: ${err.message}`);
+  if (!opts.skipRegistry) {
+    const tmpDir = path.resolve(os.tmpdir());
+    const resolvedRoot = path.resolve(rootDir);
+    if (resolvedRoot.startsWith(tmpDir)) {
+      debug(`Skipping auto-registration for temp directory: ${resolvedRoot}`);
+    } else {
+      try {
+        const { registerRepo } = await import('./registry.js');
+        registerRepo(rootDir);
+      } catch (err) {
+        debug(`Auto-registration failed: ${err.message}`);
+      }
+    }
   }
 }

package/src/cli.js

@@ -18,6 +18,7 @@ import {
   impactAnalysis,
   moduleMap,
   queryName,
+  stats,
 } from './queries.js';
 import {
   listRepos,
@@ -28,11 +29,14 @@ import {
 } from './registry.js';
 import { watchProject } from './watcher.js';
 
+const __cliDir = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/i, '$1'));
+const pkg = JSON.parse(fs.readFileSync(path.join(__cliDir, '..', 'package.json'), 'utf-8'));
+
 const program = new Command();
 program
   .name('codegraph')
   .description('Local code dependency graph tool')
-  .version('1.3.0')
+  .version(pkg.version)
   .option('-v, --verbose', 'Enable verbose/debug output')
   .option('--engine <engine>', 'Parser engine: native, wasm, or auto (default: auto)', 'auto')
   .hook('preAction', (thisCommand) => {
@@ -78,6 +82,15 @@ program
     moduleMap(opts.db, parseInt(opts.limit, 10), { json: opts.json });
   });
 
+program
+  .command('stats')
+  .description('Show graph health overview: nodes, edges, languages, cycles, hotspots, embeddings')
+  .option('-d, --db <path>', 'Path to graph.db')
+  .option('-j, --json', 'Output as JSON')
+  .action((opts) => {
+    stats(opts.db, { json: opts.json });
+  });
+
 program
   .command('deps <file>')
   .description('Show what this file imports and what imports it')
@@ -214,6 +227,7 @@ registry
   .description('List all registered repositories')
   .option('-j, --json', 'Output as JSON')
   .action((opts) => {
+    pruneRegistry();
     const repos = listRepos();
     if (opts.json) {
       console.log(JSON.stringify(repos, null, 2));
@@ -257,14 +271,16 @@ registry
 
 registry
   .command('prune')
-  .description('Remove registry entries whose directories no longer exist')
-  .action(() => {
-    const pruned = pruneRegistry();
+  .description('Remove stale registry entries (missing directories or idle beyond TTL)')
+  .option('--ttl <days>', 'Days of inactivity before pruning (default: 30)', '30')
+  .action((opts) => {
+    const pruned = pruneRegistry(undefined, parseInt(opts.ttl, 10));
     if (pruned.length === 0) {
       console.log('No stale entries found.');
     } else {
       for (const entry of pruned) {
-        console.log(`Pruned "${entry.name}" (${entry.path})`);
+        const tag = entry.reason === 'expired' ? 'expired' : 'missing';
+        console.log(`Pruned "${entry.name}" (${entry.path}) [${tag}]`);
       }
       console.log(`\nRemoved ${pruned.length} stale ${pruned.length === 1 ? 'entry' : 'entries'}.`);
     }
@@ -278,7 +294,7 @@ program
   .action(() => {
     console.log('\nAvailable embedding models:\n');
     for (const [key, config] of Object.entries(MODELS)) {
-      const def = key === 'minilm' ? ' (default)' : '';
+      const def = key === 'jina-code' ? ' (default)' : '';
       console.log(`  ${key.padEnd(12)} ${String(config.dim).padStart(4)}d  ${config.desc}${def}`);
     }
     console.log('\nUsage: codegraph embed --model <name>');
@@ -292,8 +308,8 @@ program
   )
   .option(
     '-m, --model <name>',
-    'Embedding model: minilm (default), jina-small, jina-base, jina-code, nomic, nomic-v1.5, bge-large. Run `codegraph models` for details',
-    'minilm',
+    'Embedding model: minilm, jina-small, jina-base, jina-code (default), nomic, nomic-v1.5, bge-large. Run `codegraph models` for details',
+    'jina-code',
   )
   .action(async (dir, opts) => {
     const root = path.resolve(dir || '.');

package/src/config.js

@@ -19,7 +19,7 @@ export const DEFAULTS = {
     defaultDepth: 3,
     defaultLimit: 20,
   },
-  embeddings: { model: 'minilm', llmProvider: null },
+  embeddings: { model: 'jina-code', llmProvider: null },
   llm: { provider: null, model: null, baseUrl: null, apiKey: null, apiKeyCommand: null },
   search: { defaultMinScore: 0.2, rrfK: 60, topK: 15 },
   ci: { failOnCycles: false, impactThreshold: null },

package/src/embedder.js

@@ -55,7 +55,7 @@ export const MODELS = {
   },
 };
 
-export const DEFAULT_MODEL = 'minilm';
+export const DEFAULT_MODEL = 'jina-code';
 const BATCH_SIZE_MAP = {
   minilm: 32,
   'jina-small': 16,
@@ -173,10 +173,10 @@ function initEmbeddingsSchema(db) {
 /**
  * Build embeddings for all functions/methods/classes in the graph.
  */
-export async function buildEmbeddings(rootDir, modelKey) {
+export async function buildEmbeddings(rootDir, modelKey, customDbPath) {
   // path already imported at top
   // fs already imported at top
-  const dbPath = findDbPath(null);
+  const dbPath = customDbPath || findDbPath(null);
 
   const db = new Database(dbPath);
   initEmbeddingsSchema(db);

package/src/extractors/csharp.js

@@ -0,0 +1,243 @@
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from C# files.
+ */
+export function extractCSharpSymbols(tree, _filePath) {
+  const definitions = [];
+  const calls = [];
+  const imports = [];
+  const classes = [];
+  const exports = [];
+
+  function findCSharpParentType(node) {
+    let current = node.parent;
+    while (current) {
+      if (
+        current.type === 'class_declaration' ||
+        current.type === 'struct_declaration' ||
+        current.type === 'interface_declaration' ||
+        current.type === 'enum_declaration' ||
+        current.type === 'record_declaration'
+      ) {
+        const nameNode = current.childForFieldName('name');
+        return nameNode ? nameNode.text : null;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+
+  function walkCSharpNode(node) {
+    switch (node.type) {
+      case 'class_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'class',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+          extractCSharpBaseTypes(node, nameNode.text, classes);
+        }
+        break;
+      }
+
+      case 'struct_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'struct',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+          extractCSharpBaseTypes(node, nameNode.text, classes);
+        }
+        break;
+      }
+
+      case 'record_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'record',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+          extractCSharpBaseTypes(node, nameNode.text, classes);
+        }
+        break;
+      }
+
+      case 'interface_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'interface',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+          const body = node.childForFieldName('body');
+          if (body) {
+            for (let i = 0; i < body.childCount; i++) {
+              const child = body.child(i);
+              if (child && child.type === 'method_declaration') {
+                const methName = child.childForFieldName('name');
+                if (methName) {
+                  definitions.push({
+                    name: `${nameNode.text}.${methName.text}`,
+                    kind: 'method',
+                    line: child.startPosition.row + 1,
+                    endLine: child.endPosition.row + 1,
+                  });
+                }
+              }
+            }
+          }
+        }
+        break;
+      }
+
+      case 'enum_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'enum',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'method_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const parentType = findCSharpParentType(node);
+          const fullName = parentType ? `${parentType}.${nameNode.text}` : nameNode.text;
+          definitions.push({
+            name: fullName,
+            kind: 'method',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'constructor_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const parentType = findCSharpParentType(node);
+          const fullName = parentType ? `${parentType}.${nameNode.text}` : nameNode.text;
+          definitions.push({
+            name: fullName,
+            kind: 'method',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'property_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const parentType = findCSharpParentType(node);
+          const fullName = parentType ? `${parentType}.${nameNode.text}` : nameNode.text;
+          definitions.push({
+            name: fullName,
+            kind: 'method',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'using_directive': {
+        // using System.Collections.Generic;
+        const nameNode =
+          node.childForFieldName('name') ||
+          findChild(node, 'qualified_name') ||
+          findChild(node, 'identifier');
+        if (nameNode) {
+          const fullPath = nameNode.text;
+          const lastName = fullPath.split('.').pop();
+          imports.push({
+            source: fullPath,
+            names: [lastName],
+            line: node.startPosition.row + 1,
+            csharpUsing: true,
+          });
+        }
+        break;
+      }
+
+      case 'invocation_expression': {
+        const fn = node.childForFieldName('function') || node.child(0);
+        if (fn) {
+          if (fn.type === 'identifier') {
+            calls.push({ name: fn.text, line: node.startPosition.row + 1 });
+          } else if (fn.type === 'member_access_expression') {
+            const name = fn.childForFieldName('name');
+            if (name) calls.push({ name: name.text, line: node.startPosition.row + 1 });
+          } else if (fn.type === 'generic_name' || fn.type === 'member_binding_expression') {
+            const name = fn.childForFieldName('name') || fn.child(0);
+            if (name) calls.push({ name: name.text, line: node.startPosition.row + 1 });
+          }
+        }
+        break;
+      }
+
+      case 'object_creation_expression': {
+        const typeNode = node.childForFieldName('type');
+        if (typeNode) {
+          const typeName =
+            typeNode.type === 'generic_name'
+              ? typeNode.childForFieldName('name')?.text || typeNode.child(0)?.text
+              : typeNode.text;
+          if (typeName) calls.push({ name: typeName, line: node.startPosition.row + 1 });
+        }
+        break;
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) walkCSharpNode(node.child(i));
+  }
+
+  walkCSharpNode(tree.rootNode);
+  return { definitions, calls, imports, classes, exports };
+}
+
+function extractCSharpBaseTypes(node, className, classes) {
+  const baseList = node.childForFieldName('bases');
+  if (!baseList) return;
+  for (let i = 0; i < baseList.childCount; i++) {
+    const child = baseList.child(i);
+    if (!child) continue;
+    if (child.type === 'identifier' || child.type === 'qualified_name') {
+      classes.push({ name: className, extends: child.text, line: node.startPosition.row + 1 });
+    } else if (child.type === 'generic_name') {
+      const name = child.childForFieldName('name') || child.child(0);
+      if (name)
+        classes.push({ name: className, extends: name.text, line: node.startPosition.row + 1 });
+    } else if (child.type === 'base_list') {
+      for (let j = 0; j < child.childCount; j++) {
+        const base = child.child(j);
+        if (base && (base.type === 'identifier' || base.type === 'qualified_name')) {
+          classes.push({ name: className, extends: base.text, line: node.startPosition.row + 1 });
+        } else if (base && base.type === 'generic_name') {
+          const name = base.childForFieldName('name') || base.child(0);
+          if (name)
+            classes.push({ name: className, extends: name.text, line: node.startPosition.row + 1 });
+        }
+      }
+    }
+  }
+}