@optave/codegraph 2.5.1 → 3.0.0

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;

package/src/extractors/go.js

@@ -1,4 +1,4 @@
-import { nodeEndLine } from './helpers.js';
+import { findChild, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from Go files.
@@ -15,11 +15,13 @@ export function extractGoSymbols(tree, _filePath) {
       case 'function_declaration': {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
+          const params = extractGoParameters(node.childForFieldName('parameters'));
           definitions.push({
             name: nameNode.text,
             kind: 'function',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: params.length > 0 ? params : undefined,
           });
         }
         break;
@@ -46,11 +48,13 @@ export function extractGoSymbols(tree, _filePath) {
             }
           }
           const fullName = receiverType ? `${receiverType}.${nameNode.text}` : nameNode.text;
+          const params = extractGoParameters(node.childForFieldName('parameters'));
           definitions.push({
             name: fullName,
             kind: 'method',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: params.length > 0 ? params : undefined,
           });
         }
         break;
@@ -64,11 +68,13 @@ export function extractGoSymbols(tree, _filePath) {
           const typeNode = spec.childForFieldName('type');
           if (nameNode && typeNode) {
             if (typeNode.type === 'struct_type') {
+              const fields = extractStructFields(typeNode);
               definitions.push({
                 name: nameNode.text,
                 kind: 'struct',
                 line: node.startPosition.row + 1,
                 endLine: nodeEndLine(node),
+                children: fields.length > 0 ? fields : undefined,
               });
             } else if (typeNode.type === 'interface_type') {
               definitions.push({
@@ -145,6 +151,23 @@ export function extractGoSymbols(tree, _filePath) {
         break;
       }
 
+      case 'const_declaration': {
+        for (let i = 0; i < node.childCount; i++) {
+          const spec = node.child(i);
+          if (!spec || spec.type !== 'const_spec') continue;
+          const constName = spec.childForFieldName('name');
+          if (constName) {
+            definitions.push({
+              name: constName.text,
+              kind: 'constant',
+              line: spec.startPosition.row + 1,
+              endLine: spec.endPosition.row + 1,
+            });
+          }
+        }
+        break;
+      }
+
       case 'call_expression': {
         const fn = node.childForFieldName('function');
         if (fn) {
@@ -170,3 +193,45 @@ export function extractGoSymbols(tree, _filePath) {
   walkGoNode(tree.rootNode);
   return { definitions, calls, imports, classes, exports };
 }
+
+// ── Child extraction helpers ────────────────────────────────────────────────
+
+function extractGoParameters(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_declaration') continue;
+    // A parameter_declaration may have multiple identifiers (e.g., `a, b int`)
+    for (let j = 0; j < param.childCount; j++) {
+      const child = param.child(j);
+      if (child && child.type === 'identifier') {
+        params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
+      }
+    }
+  }
+  return params;
+}
+
+function extractStructFields(structTypeNode) {
+  const fields = [];
+  const fieldList = findChild(structTypeNode, 'field_declaration_list');
+  if (!fieldList) return fields;
+  for (let i = 0; i < fieldList.childCount; i++) {
+    const field = fieldList.child(i);
+    if (!field || field.type !== 'field_declaration') continue;
+    const nameNode = field.childForFieldName('name');
+    if (nameNode) {
+      fields.push({ name: nameNode.text, kind: 'property', line: field.startPosition.row + 1 });
+    } else {
+      // Struct fields may have multiple names or use first identifier child
+      for (let j = 0; j < field.childCount; j++) {
+        const child = field.child(j);
+        if (child && child.type === 'field_identifier') {
+          fields.push({ name: child.text, kind: 'property', line: field.startPosition.row + 1 });
+        }
+      }
+    }
+  }
+  return fields;
+}

package/src/extractors/hcl.js

@@ -36,11 +36,33 @@ export function extractHCLSymbols(tree, _filePath) {
         }
 
         if (name) {
+          // Extract attributes as property children for variable/output blocks
+          let blockChildren;
+          if (blockType === 'variable' || blockType === 'output') {
+            blockChildren = [];
+            const body = children.find((c) => c.type === 'body');
+            if (body) {
+              for (let j = 0; j < body.childCount; j++) {
+                const attr = body.child(j);
+                if (attr && attr.type === 'attribute') {
+                  const key = attr.childForFieldName('key') || attr.child(0);
+                  if (key) {
+                    blockChildren.push({
+                      name: key.text,
+                      kind: 'property',
+                      line: attr.startPosition.row + 1,
+                    });
+                  }
+                }
+              }
+            }
+          }
           definitions.push({
             name,
             kind: blockType,
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: blockChildren?.length > 0 ? blockChildren : undefined,
           });
         }