@optave/codegraph 2.6.0 → 3.0.0

package/src/db.js

@@ -144,6 +144,87 @@ export const MIGRATIONS = [
       CREATE INDEX IF NOT EXISTS idx_fc_mi ON function_complexity(maintainability_index ASC);
     `,
   },
+  {
+    version: 10,
+    up: `
+      CREATE TABLE IF NOT EXISTS dataflow (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_id INTEGER NOT NULL,
+        target_id INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        param_index INTEGER,
+        expression TEXT,
+        line INTEGER,
+        confidence REAL DEFAULT 1.0,
+        FOREIGN KEY(source_id) REFERENCES nodes(id),
+        FOREIGN KEY(target_id) REFERENCES nodes(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_dataflow_source ON dataflow(source_id);
+      CREATE INDEX IF NOT EXISTS idx_dataflow_target ON dataflow(target_id);
+      CREATE INDEX IF NOT EXISTS idx_dataflow_kind ON dataflow(kind);
+      CREATE INDEX IF NOT EXISTS idx_dataflow_source_kind ON dataflow(source_id, kind);
+    `,
+  },
+  {
+    version: 11,
+    up: `
+      ALTER TABLE nodes ADD COLUMN parent_id INTEGER REFERENCES nodes(id);
+      CREATE INDEX IF NOT EXISTS idx_nodes_parent ON nodes(parent_id);
+      CREATE INDEX IF NOT EXISTS idx_nodes_kind_parent ON nodes(kind, parent_id);
+    `,
+  },
+  {
+    version: 12,
+    up: `
+      CREATE TABLE IF NOT EXISTS cfg_blocks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        function_node_id INTEGER NOT NULL,
+        block_index INTEGER NOT NULL,
+        block_type TEXT NOT NULL,
+        start_line INTEGER,
+        end_line INTEGER,
+        label TEXT,
+        FOREIGN KEY(function_node_id) REFERENCES nodes(id),
+        UNIQUE(function_node_id, block_index)
+      );
+      CREATE INDEX IF NOT EXISTS idx_cfg_blocks_fn ON cfg_blocks(function_node_id);
+
+      CREATE TABLE IF NOT EXISTS cfg_edges (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        function_node_id INTEGER NOT NULL,
+        source_block_id INTEGER NOT NULL,
+        target_block_id INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        FOREIGN KEY(function_node_id) REFERENCES nodes(id),
+        FOREIGN KEY(source_block_id) REFERENCES cfg_blocks(id),
+        FOREIGN KEY(target_block_id) REFERENCES cfg_blocks(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_cfg_edges_fn ON cfg_edges(function_node_id);
+      CREATE INDEX IF NOT EXISTS idx_cfg_edges_src ON cfg_edges(source_block_id);
+      CREATE INDEX IF NOT EXISTS idx_cfg_edges_tgt ON cfg_edges(target_block_id);
+    `,
+  },
+  {
+    version: 13,
+    up: `
+      CREATE TABLE IF NOT EXISTS ast_nodes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        file TEXT NOT NULL,
+        line INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        name TEXT NOT NULL,
+        text TEXT,
+        receiver TEXT,
+        parent_node_id INTEGER,
+        FOREIGN KEY(parent_node_id) REFERENCES nodes(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_ast_kind ON ast_nodes(kind);
+      CREATE INDEX IF NOT EXISTS idx_ast_name ON ast_nodes(name);
+      CREATE INDEX IF NOT EXISTS idx_ast_file ON ast_nodes(file);
+      CREATE INDEX IF NOT EXISTS idx_ast_parent ON ast_nodes(parent_node_id);
+      CREATE INDEX IF NOT EXISTS idx_ast_kind_name ON ast_nodes(kind, name);
+    `,
+  },
 ];
 
 export function getBuildMeta(db, key) {
@@ -265,6 +346,21 @@ export function initSchema(db) {
   } catch {
     /* already exists */
   }
+  try {
+    db.exec('ALTER TABLE nodes ADD COLUMN parent_id INTEGER REFERENCES nodes(id)');
+  } catch {
+    /* already exists */
+  }
+  try {
+    db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_parent ON nodes(parent_id)');
+  } catch {
+    /* already exists */
+  }
+  try {
+    db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_kind_parent ON nodes(kind, parent_id)');
+  } catch {
+    /* already exists */
+  }
 }
 
 export function findDbPath(customPath) {

package/src/embedder.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { closeDb, findDbPath, openDb, openReadonlyOrFail } from './db.js';
 import { info, warn } from './logger.js';
+import { normalizeSymbol } from './queries.js';
 
 /**
  * Split an identifier into readable words.
@@ -582,7 +583,7 @@ function _prepareSearch(customDbPath, opts = {}) {
   const noTests = opts.noTests || false;
   const TEST_PATTERN = /\.(test|spec)\.|__test__|__tests__|\.stories\./;
   let sql = `
-    SELECT e.node_id, e.vector, e.text_preview, n.name, n.kind, n.file, n.line
+    SELECT e.node_id, e.vector, e.text_preview, n.name, n.kind, n.file, n.line, n.end_line, n.role
     FROM embeddings e
     JOIN nodes n ON e.node_id = n.id
   `;
@@ -638,6 +639,7 @@ export async function searchData(query, customDbPath, opts = {}) {
     return null;
   }
 
+  const hc = new Map();
   const results = [];
   for (const row of rows) {
     const vec = new Float32Array(new Uint8Array(row.vector).buffer);
@@ -645,10 +647,7 @@ export async function searchData(query, customDbPath, opts = {}) {
 
     if (sim >= minScore) {
       results.push({
-        name: row.name,
-        kind: row.kind,
-        file: row.file,
-        line: row.line,
+        ...normalizeSymbol(row, db, hc),
         similarity: sim,
       });
     }
@@ -734,14 +733,12 @@ export async function multiSearchData(queries, customDbPath, opts = {}) {
   }
 
   // Build results sorted by RRF score
+  const hc = new Map();
   const results = [];
   for (const [rowIndex, entry] of fusionMap) {
     const row = rows[rowIndex];
     results.push({
-      name: row.name,
-      kind: row.kind,
-      file: row.file,
-      line: row.line,
+      ...normalizeSymbol(row, db, hc),
       rrf: entry.rrfScore,
       queryScores: entry.queryScores,
     });
@@ -804,7 +801,7 @@ export function ftsSearchData(query, customDbPath, opts = {}) {
 
   let sql = `
     SELECT f.rowid AS node_id, rank AS bm25_score,
-           n.name, n.kind, n.file, n.line
+           n.name, n.kind, n.file, n.line, n.end_line, n.role
     FROM fts_index f
     JOIN nodes n ON f.rowid = n.id
     WHERE fts_index MATCH ?
@@ -841,16 +838,13 @@ export function ftsSearchData(query, customDbPath, opts = {}) {
     rows = rows.filter((row) => !TEST_PATTERN.test(row.file));
   }
 
-  db.close();
-
+  const hc = new Map();
   const results = rows.slice(0, limit).map((row) => ({
-    name: row.name,
-    kind: row.kind,
-    file: row.file,
-    line: row.line,
+    ...normalizeSymbol(row, db, hc),
     bm25Score: -row.bm25_score, // FTS5 rank is negative; negate for display
   }));
 
+  db.close();
   return { results };
 }
 
@@ -924,6 +918,9 @@ export async function hybridSearchData(query, customDbPath, opts = {}) {
           kind: item.kind,
           file: item.file,
           line: item.line,
+          endLine: item.endLine ?? null,
+          role: item.role ?? null,
+          fileHash: item.fileHash ?? null,
           rrfScore: 0,
           bm25Score: null,
           bm25Rank: null,
@@ -955,6 +952,9 @@ export async function hybridSearchData(query, customDbPath, opts = {}) {
       kind: e.kind,
       file: e.file,
       line: e.line,
+      endLine: e.endLine,
+      role: e.role,
+      fileHash: e.fileHash,
       rrf: e.rrfScore,
       bm25Score: e.bm25Score,
       bm25Rank: e.bm25Rank,

package/src/export.js

@@ -4,6 +4,25 @@ import { isTestFile } from './queries.js';
 
 const DEFAULT_MIN_CONFIDENCE = 0.5;
 
+/** Escape special XML characters. */
+function escapeXml(s) {
+  return String(s)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+/** RFC 4180 CSV field escaping — quote fields containing commas, quotes, or newlines. */
+function escapeCsv(s) {
+  const str = String(s);
+  if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r')) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+
 /**
  * Export the dependency graph in DOT (Graphviz) format.
  */
@@ -374,3 +393,289 @@ export function exportJSON(db, opts = {}) {
   const base = { nodes, edges };
   return paginateResult(base, 'edges', { limit: opts.limit, offset: opts.offset });
 }
+
+/**
+ * Export the dependency graph in GraphML (XML) format.
+ */
+export function exportGraphML(db, opts = {}) {
+  const fileLevel = opts.fileLevel !== false;
+  const noTests = opts.noTests || false;
+  const minConf = opts.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
+  const edgeLimit = opts.limit;
+
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<graphml xmlns="http://graphml.graphstruct.net/graphml">',
+  ];
+
+  if (fileLevel) {
+    lines.push('  <key id="d0" for="node" attr.name="name" attr.type="string"/>');
+    lines.push('  <key id="d1" for="node" attr.name="file" attr.type="string"/>');
+    lines.push('  <key id="d2" for="edge" attr.name="kind" attr.type="string"/>');
+    lines.push('  <graph id="codegraph" edgedefault="directed">');
+
+    let edges = db
+      .prepare(`
+      SELECT DISTINCT n1.file AS source, n2.file AS target
+      FROM edges e
+      JOIN nodes n1 ON e.source_id = n1.id
+      JOIN nodes n2 ON e.target_id = n2.id
+      WHERE n1.file != n2.file AND e.kind IN ('imports', 'imports-type', 'calls')
+        AND e.confidence >= ?
+    `)
+      .all(minConf);
+    if (noTests) edges = edges.filter((e) => !isTestFile(e.source) && !isTestFile(e.target));
+    if (edgeLimit && edges.length > edgeLimit) edges = edges.slice(0, edgeLimit);
+
+    const files = new Set();
+    for (const { source, target } of edges) {
+      files.add(source);
+      files.add(target);
+    }
+
+    const fileIds = new Map();
+    let nIdx = 0;
+    for (const f of files) {
+      const id = `n${nIdx++}`;
+      fileIds.set(f, id);
+      lines.push(`    <node id="${id}">`);
+      lines.push(`      <data key="d0">${escapeXml(path.basename(f))}</data>`);
+      lines.push(`      <data key="d1">${escapeXml(f)}</data>`);
+      lines.push('    </node>');
+    }
+
+    let eIdx = 0;
+    for (const { source, target } of edges) {
+      lines.push(
+        `    <edge id="e${eIdx++}" source="${fileIds.get(source)}" target="${fileIds.get(target)}">`,
+      );
+      lines.push('      <data key="d2">imports</data>');
+      lines.push('    </edge>');
+    }
+  } else {
+    lines.push('  <key id="d0" for="node" attr.name="name" attr.type="string"/>');
+    lines.push('  <key id="d1" for="node" attr.name="kind" attr.type="string"/>');
+    lines.push('  <key id="d2" for="node" attr.name="file" attr.type="string"/>');
+    lines.push('  <key id="d3" for="node" attr.name="line" attr.type="int"/>');
+    lines.push('  <key id="d4" for="node" attr.name="role" attr.type="string"/>');
+    lines.push('  <key id="d5" for="edge" attr.name="kind" attr.type="string"/>');
+    lines.push('  <key id="d6" for="edge" attr.name="confidence" attr.type="double"/>');
+    lines.push('  <graph id="codegraph" edgedefault="directed">');
+
+    let edges = db
+      .prepare(`
+      SELECT n1.id AS source_id, n1.name AS source_name, n1.kind AS source_kind,
+             n1.file AS source_file, n1.line AS source_line, n1.role AS source_role,
+             n2.id AS target_id, n2.name AS target_name, n2.kind AS target_kind,
+             n2.file AS target_file, n2.line AS target_line, n2.role AS target_role,
+             e.kind AS edge_kind, e.confidence
+      FROM edges e
+      JOIN nodes n1 ON e.source_id = n1.id
+      JOIN nodes n2 ON e.target_id = n2.id
+      WHERE n1.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
+        AND n2.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
+        AND e.kind = 'calls'
+        AND e.confidence >= ?
+    `)
+      .all(minConf);
+    if (noTests)
+      edges = edges.filter((e) => !isTestFile(e.source_file) && !isTestFile(e.target_file));
+    if (edgeLimit && edges.length > edgeLimit) edges = edges.slice(0, edgeLimit);
+
+    const emittedNodes = new Set();
+    function emitNode(id, name, kind, file, line, role) {
+      if (emittedNodes.has(id)) return;
+      emittedNodes.add(id);
+      lines.push(`    <node id="n${id}">`);
+      lines.push(`      <data key="d0">${escapeXml(name)}</data>`);
+      lines.push(`      <data key="d1">${escapeXml(kind)}</data>`);
+      lines.push(`      <data key="d2">${escapeXml(file)}</data>`);
+      lines.push(`      <data key="d3">${line}</data>`);
+      if (role) lines.push(`      <data key="d4">${escapeXml(role)}</data>`);
+      lines.push('    </node>');
+    }
+
+    let eIdx = 0;
+    for (const e of edges) {
+      emitNode(
+        e.source_id,
+        e.source_name,
+        e.source_kind,
+        e.source_file,
+        e.source_line,
+        e.source_role,
+      );
+      emitNode(
+        e.target_id,
+        e.target_name,
+        e.target_kind,
+        e.target_file,
+        e.target_line,
+        e.target_role,
+      );
+      lines.push(`    <edge id="e${eIdx++}" source="n${e.source_id}" target="n${e.target_id}">`);
+      lines.push(`      <data key="d5">${escapeXml(e.edge_kind)}</data>`);
+      lines.push(`      <data key="d6">${e.confidence}</data>`);
+      lines.push('    </edge>');
+    }
+  }
+
+  lines.push('  </graph>');
+  lines.push('</graphml>');
+  return lines.join('\n');
+}
+
+/**
+ * Export the dependency graph in TinkerPop GraphSON v3 format.
+ */
+export function exportGraphSON(db, opts = {}) {
+  const noTests = opts.noTests || false;
+  const minConf = opts.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
+
+  let nodes = db
+    .prepare(`
+    SELECT id, name, kind, file, line, role FROM nodes
+    WHERE kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'file')
+  `)
+    .all();
+  if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
+
+  let edges = db
+    .prepare(`
+    SELECT e.rowid AS id, n1.id AS outV, n2.id AS inV, e.kind, e.confidence
+    FROM edges e
+    JOIN nodes n1 ON e.source_id = n1.id
+    JOIN nodes n2 ON e.target_id = n2.id
+    WHERE e.confidence >= ?
+  `)
+    .all(minConf);
+  if (noTests) {
+    const nodeIds = new Set(nodes.map((n) => n.id));
+    edges = edges.filter((e) => nodeIds.has(e.outV) && nodeIds.has(e.inV));
+  }
+
+  const vertices = nodes.map((n) => ({
+    id: n.id,
+    label: n.kind,
+    properties: {
+      name: [{ id: 0, value: n.name }],
+      file: [{ id: 0, value: n.file }],
+      ...(n.line != null ? { line: [{ id: 0, value: n.line }] } : {}),
+      ...(n.role ? { role: [{ id: 0, value: n.role }] } : {}),
+    },
+  }));
+
+  const gEdges = edges.map((e) => ({
+    id: e.id,
+    label: e.kind,
+    inV: e.inV,
+    outV: e.outV,
+    properties: {
+      confidence: e.confidence,
+    },
+  }));
+
+  const base = { vertices, edges: gEdges };
+  return paginateResult(base, 'edges', { limit: opts.limit, offset: opts.offset });
+}
+
+/**
+ * Export the dependency graph as Neo4j bulk-import CSV files.
+ * Returns { nodes: string, relationships: string }.
+ */
+export function exportNeo4jCSV(db, opts = {}) {
+  const fileLevel = opts.fileLevel !== false;
+  const noTests = opts.noTests || false;
+  const minConf = opts.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
+  const edgeLimit = opts.limit;
+
+  if (fileLevel) {
+    let edges = db
+      .prepare(`
+      SELECT DISTINCT n1.file AS source, n2.file AS target, e.kind, e.confidence
+      FROM edges e
+      JOIN nodes n1 ON e.source_id = n1.id
+      JOIN nodes n2 ON e.target_id = n2.id
+      WHERE n1.file != n2.file AND e.kind IN ('imports', 'imports-type', 'calls')
+        AND e.confidence >= ?
+    `)
+      .all(minConf);
+    if (noTests) edges = edges.filter((e) => !isTestFile(e.source) && !isTestFile(e.target));
+    if (edgeLimit && edges.length > edgeLimit) edges = edges.slice(0, edgeLimit);
+
+    const files = new Map();
+    let idx = 0;
+    for (const { source, target } of edges) {
+      if (!files.has(source)) files.set(source, idx++);
+      if (!files.has(target)) files.set(target, idx++);
+    }
+
+    const nodeLines = ['nodeId:ID,name,file:string,:LABEL'];
+    for (const [file, id] of files) {
+      nodeLines.push(`${id},${escapeCsv(path.basename(file))},${escapeCsv(file)},File`);
+    }
+
+    const relLines = [':START_ID,:END_ID,:TYPE,confidence:float'];
+    for (const e of edges) {
+      const edgeType = e.kind.toUpperCase().replace(/-/g, '_');
+      relLines.push(`${files.get(e.source)},${files.get(e.target)},${edgeType},${e.confidence}`);
+    }
+
+    return { nodes: nodeLines.join('\n'), relationships: relLines.join('\n') };
+  }
+
+  let edges = db
+    .prepare(`
+    SELECT n1.id AS source_id, n1.name AS source_name, n1.kind AS source_kind,
+           n1.file AS source_file, n1.line AS source_line, n1.role AS source_role,
+           n2.id AS target_id, n2.name AS target_name, n2.kind AS target_kind,
+           n2.file AS target_file, n2.line AS target_line, n2.role AS target_role,
+           e.kind AS edge_kind, e.confidence
+    FROM edges e
+    JOIN nodes n1 ON e.source_id = n1.id
+    JOIN nodes n2 ON e.target_id = n2.id
+    WHERE n1.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
+      AND n2.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
+      AND e.kind = 'calls'
+      AND e.confidence >= ?
+  `)
+    .all(minConf);
+  if (noTests)
+    edges = edges.filter((e) => !isTestFile(e.source_file) && !isTestFile(e.target_file));
+  if (edgeLimit && edges.length > edgeLimit) edges = edges.slice(0, edgeLimit);
+
+  const emitted = new Set();
+  const nodeLines = ['nodeId:ID,name,kind,file:string,line:int,role,:LABEL'];
+  function emitNode(id, name, kind, file, line, role) {
+    if (emitted.has(id)) return;
+    emitted.add(id);
+    const label = kind.charAt(0).toUpperCase() + kind.slice(1);
+    nodeLines.push(
+      `${id},${escapeCsv(name)},${escapeCsv(kind)},${escapeCsv(file)},${line},${escapeCsv(role || '')},${label}`,
+    );
+  }
+
+  const relLines = [':START_ID,:END_ID,:TYPE,confidence:float'];
+  for (const e of edges) {
+    emitNode(
+      e.source_id,
+      e.source_name,
+      e.source_kind,
+      e.source_file,
+      e.source_line,
+      e.source_role,
+    );
+    emitNode(
+      e.target_id,
+      e.target_name,
+      e.target_kind,
+      e.target_file,
+      e.target_line,
+      e.target_role,
+    );
+    const edgeType = e.edge_kind.toUpperCase().replace(/-/g, '_');
+    relLines.push(`${e.source_id},${e.target_id},${edgeType},${e.confidence}`);
+  }
+
+  return { nodes: nodeLines.join('\n'), relationships: relLines.join('\n') };
+}

package/src/extractors/csharp.js

@@ -33,11 +33,13 @@ export function extractCSharpSymbols(tree, _filePath) {
       case 'class_declaration': {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
+          const classChildren = extractCSharpClassFields(node);
           definitions.push({
             name: nameNode.text,
             kind: 'class',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: classChildren.length > 0 ? classChildren : undefined,
           });
           extractCSharpBaseTypes(node, nameNode.text, classes);
         }
@@ -47,11 +49,13 @@ export function extractCSharpSymbols(tree, _filePath) {
       case 'struct_declaration': {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
+          const structChildren = extractCSharpClassFields(node);
           definitions.push({
             name: nameNode.text,
             kind: 'struct',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: structChildren.length > 0 ? structChildren : undefined,
           });
           extractCSharpBaseTypes(node, nameNode.text, classes);
         }
@@ -105,11 +109,13 @@ export function extractCSharpSymbols(tree, _filePath) {
       case 'enum_declaration': {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
+          const enumChildren = extractCSharpEnumMembers(node);
           definitions.push({
             name: nameNode.text,
             kind: 'enum',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: enumChildren.length > 0 ? enumChildren : undefined,
           });
         }
         break;
@@ -120,11 +126,13 @@ export function extractCSharpSymbols(tree, _filePath) {
         if (nameNode) {
           const parentType = findCSharpParentType(node);
           const fullName = parentType ? `${parentType}.${nameNode.text}` : nameNode.text;
+          const params = extractCSharpParameters(node.childForFieldName('parameters'));
           definitions.push({
             name: fullName,
             kind: 'method',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: params.length > 0 ? params : undefined,
           });
         }
         break;
@@ -135,11 +143,13 @@ export function extractCSharpSymbols(tree, _filePath) {
         if (nameNode) {
           const parentType = findCSharpParentType(node);
           const fullName = parentType ? `${parentType}.${nameNode.text}` : nameNode.text;
+          const params = extractCSharpParameters(node.childForFieldName('parameters'));
           definitions.push({
             name: fullName,
             kind: 'method',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: params.length > 0 ? params : undefined,
           });
         }
         break;
@@ -152,7 +162,7 @@ export function extractCSharpSymbols(tree, _filePath) {
           const fullName = parentType ? `${parentType}.${nameNode.text}` : nameNode.text;
           definitions.push({
             name: fullName,
-            kind: 'method',
+            kind: 'property',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
@@ -220,6 +230,59 @@ export function extractCSharpSymbols(tree, _filePath) {
   return { definitions, calls, imports, classes, exports };
 }
 
+// ── Child extraction helpers ────────────────────────────────────────────────
+
+function extractCSharpParameters(paramListNode) {
+  const params = [];
+  if (!paramListNode) return params;
+  for (let i = 0; i < paramListNode.childCount; i++) {
+    const param = paramListNode.child(i);
+    if (!param || param.type !== 'parameter') continue;
+    const nameNode = param.childForFieldName('name');
+    if (nameNode) {
+      params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
+    }
+  }
+  return params;
+}
+
+function extractCSharpClassFields(classNode) {
+  const fields = [];
+  const body = classNode.childForFieldName('body') || findChild(classNode, 'declaration_list');
+  if (!body) return fields;
+  for (let i = 0; i < body.childCount; i++) {
+    const member = body.child(i);
+    if (!member || member.type !== 'field_declaration') continue;
+    const varDecl = findChild(member, 'variable_declaration');
+    if (!varDecl) continue;
+    for (let j = 0; j < varDecl.childCount; j++) {
+      const child = varDecl.child(j);
+      if (!child || child.type !== 'variable_declarator') continue;
+      const nameNode = child.childForFieldName('name');
+      if (nameNode) {
+        fields.push({ name: nameNode.text, kind: 'property', line: member.startPosition.row + 1 });
+      }
+    }
+  }
+  return fields;
+}
+
+function extractCSharpEnumMembers(enumNode) {
+  const constants = [];
+  const body =
+    enumNode.childForFieldName('body') || findChild(enumNode, 'enum_member_declaration_list');
+  if (!body) return constants;
+  for (let i = 0; i < body.childCount; i++) {
+    const member = body.child(i);
+    if (!member || member.type !== 'enum_member_declaration') continue;
+    const nameNode = member.childForFieldName('name');
+    if (nameNode) {
+      constants.push({ name: nameNode.text, kind: 'constant', line: member.startPosition.row + 1 });
+    }
+  }
+  return constants;
+}
+
 function extractCSharpBaseTypes(node, className, classes) {
   const baseList = node.childForFieldName('bases');
   if (!baseList) return;