@optave/codegraph 3.1.2 → 3.1.4

package/src/native.js

@@ -8,9 +8,11 @@
 
 import { createRequire } from 'node:module';
 import os from 'node:os';
+import { EngineError } from './errors.js';
 
 let _cached; // undefined = not yet tried, null = failed, object = module
 let _loadError = null;
+const _require = createRequire(import.meta.url);
 
 /**
  * Detect whether the current Linux environment uses glibc or musl.
@@ -18,7 +20,7 @@ let _loadError = null;
  */
 function detectLibc() {
   try {
-    const { readdirSync } = require('node:fs');
+    const { readdirSync } = _require('node:fs');
     const files = readdirSync('/lib');
     if (files.some((f) => f.startsWith('ld-musl-') && f.endsWith('.so.1'))) {
       return 'musl';
@@ -38,6 +40,17 @@ const PLATFORM_PACKAGES = {
   'win32-x64': '@optave/codegraph-win32-x64-msvc',
 };
 
+/**
+ * Resolve the platform-specific npm package name for the native addon.
+ * Returns null if the current platform is not supported.
+ */
+function resolvePlatformPackage() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const key = platform === 'linux' ? `${platform}-${arch}-${detectLibc()}` : `${platform}-${arch}`;
+  return PLATFORM_PACKAGES[key] || null;
+}
+
 /**
  * Try to load the native napi addon.
  * Returns the module on success, null on failure.
@@ -45,21 +58,16 @@ const PLATFORM_PACKAGES = {
 export function loadNative() {
   if (_cached !== undefined) return _cached;
 
-  const require = createRequire(import.meta.url);
-
-  const platform = os.platform();
-  const arch = os.arch();
-  const key = platform === 'linux' ? `${platform}-${arch}-${detectLibc()}` : `${platform}-${arch}`;
-  const pkg = PLATFORM_PACKAGES[key];
+  const pkg = resolvePlatformPackage();
   if (pkg) {
     try {
-      _cached = require(pkg);
+      _cached = _require(pkg);
       return _cached;
     } catch (err) {
       _loadError = err;
     }
   } else {
-    _loadError = new Error(`Unsupported platform: ${key}`);
+    _loadError = new Error(`Unsupported platform: ${os.platform()}-${os.arch()}`);
   }
 
   _cached = null;
@@ -73,15 +81,31 @@ export function isNativeAvailable() {
   return loadNative() !== null;
 }
 
+/**
+ * Read the version from the platform-specific npm package.json.
+ * Returns null if the package is not installed or has no version.
+ */
+export function getNativePackageVersion() {
+  const pkg = resolvePlatformPackage();
+  if (!pkg) return null;
+  try {
+    const pkgJson = _require(`${pkg}/package.json`);
+    return pkgJson.version || null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Return the native module or throw if not available.
  */
 export function getNative() {
   const mod = loadNative();
   if (!mod) {
-    throw new Error(
+    throw new EngineError(
       `Native codegraph-core not available: ${_loadError?.message || 'unknown error'}. ` +
         'Install the platform package or use --engine wasm.',
+      { cause: _loadError },
     );
   }
   return mod;

package/src/parser.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Language, Parser, Query } from 'web-tree-sitter';
 import { warn } from './logger.js';
-import { getNative, loadNative } from './native.js';
+import { getNative, getNativePackageVersion, loadNative } from './native.js';
 
 // Re-export all extractors for backward compatibility
 export {
@@ -41,6 +41,9 @@ let _initialized = false;
 // Memoized parsers — avoids reloading WASM grammars on every createParsers() call
 let _cachedParsers = null;
 
+// Cached Language objects — WASM-backed, must be .delete()'d explicitly
+let _cachedLanguages = null;
+
 // Query cache for JS/TS/TSX extractors (populated during createParsers)
 const _queryCache = new Map();
 
@@ -77,12 +80,14 @@ export async function createParsers() {
   }
 
   const parsers = new Map();
+  const languages = new Map();
   for (const entry of LANGUAGE_REGISTRY) {
     try {
       const lang = await Language.load(grammarPath(entry.grammarFile));
       const parser = new Parser();
       parser.setLanguage(lang);
       parsers.set(entry.id, parser);
+      languages.set(entry.id, lang);
       // Compile and cache tree-sitter Query for JS/TS/TSX extractors
       if (entry.extractor === extractSymbols && !_queryCache.has(entry.id)) {
         const isTS = entry.id === 'typescript' || entry.id === 'tsx';
@@ -100,9 +105,47 @@ export async function createParsers() {
     }
   }
   _cachedParsers = parsers;
+  _cachedLanguages = languages;
   return parsers;
 }
 
+/**
+ * Dispose all cached WASM parsers and queries to free WASM linear memory.
+ * Call this between repeated builds in the same process (e.g. benchmarks)
+ * to prevent memory accumulation that can cause segfaults.
+ */
+export function disposeParsers() {
+  if (_cachedParsers) {
+    for (const [, parser] of _cachedParsers) {
+      if (parser && typeof parser.delete === 'function') {
+        try {
+          parser.delete();
+        } catch {}
+      }
+    }
+    _cachedParsers = null;
+  }
+  for (const [, query] of _queryCache) {
+    if (query && typeof query.delete === 'function') {
+      try {
+        query.delete();
+      } catch {}
+    }
+  }
+  _queryCache.clear();
+  if (_cachedLanguages) {
+    for (const [, lang] of _cachedLanguages) {
+      if (lang && typeof lang.delete === 'function') {
+        try {
+          lang.delete();
+        } catch {}
+      }
+    }
+    _cachedLanguages = null;
+  }
+  _initialized = false;
+}
+
 export function getParser(parsers, filePath) {
   const ext = path.extname(filePath);
   const entry = _extToLang.get(ext);
@@ -214,6 +257,7 @@ function patchNativeResult(r) {
       if (i.csharpUsing === undefined) i.csharpUsing = i.csharp_using;
       if (i.rubyRequire === undefined) i.rubyRequire = i.ruby_require;
       if (i.phpUse === undefined) i.phpUse = i.php_use;
+      if (i.dynamicImport === undefined) i.dynamicImport = i.dynamic_import;
     }
   }
 
@@ -429,11 +473,18 @@ export async function parseFilesAuto(filePaths, rootDir, opts = {}) {
  */
 export function getActiveEngine(opts = {}) {
   const { name, native } = resolveEngine(opts);
-  const version = native
+  let version = native
     ? typeof native.engineVersion === 'function'
       ? native.engineVersion()
       : null
     : null;
+  // Prefer platform package.json version over binary-embedded version
+  // to handle stale binaries that weren't recompiled during a release
+  if (native) {
+    try {
+      version = getNativePackageVersion() ?? version;
+    } catch {}
+  }
   return { name, version };
 }
 

package/src/presentation/colors.js

@@ -0,0 +1,44 @@
+/**
+ * Shared color constants for the graph viewer.
+ *
+ * These live in a standalone module so both the domain layer (src/viewer.js)
+ * and the presentation layer (src/presentation/viewer.js) can import them
+ * without creating a cross-layer dependency.
+ */
+
+export const DEFAULT_NODE_COLORS = {
+  function: '#4CAF50',
+  method: '#66BB6A',
+  class: '#2196F3',
+  interface: '#42A5F5',
+  type: '#7E57C2',
+  struct: '#FF7043',
+  enum: '#FFA726',
+  trait: '#26A69A',
+  record: '#EC407A',
+  module: '#78909C',
+  file: '#90A4AE',
+};
+
+export const DEFAULT_ROLE_COLORS = {
+  entry: '#e8f5e9',
+  core: '#e3f2fd',
+  utility: '#f5f5f5',
+  dead: '#ffebee',
+  leaf: '#fffde7',
+};
+
+export const COMMUNITY_COLORS = [
+  '#4CAF50',
+  '#2196F3',
+  '#FF9800',
+  '#9C27B0',
+  '#F44336',
+  '#00BCD4',
+  '#CDDC39',
+  '#E91E63',
+  '#3F51B5',
+  '#FF5722',
+  '#009688',
+  '#795548',
+];

package/src/presentation/export.js

@@ -0,0 +1,444 @@
+/**
+ * Graph export serializers — pure data → formatted string transforms.
+ *
+ * Each function receives pre-loaded graph data and returns a formatted string
+ * (or structured object for CSV). No DB access — all data must be pre-loaded.
+ */
+
+import path from 'node:path';
+
+// ─── Escape Helpers ──────────────────────────────────────────────────
+
+/** Escape special XML characters. */
+export 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. */
+export function escapeCsv(s) {
+  const str = String(s);
+  if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r')) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+
+/** Escape double quotes for Mermaid labels. */
+export function escapeLabel(label) {
+  return label.replace(/"/g, '#quot;');
+}
+
+/** Map node kind to Mermaid shape wrapper. */
+export function mermaidShape(kind, label) {
+  const escaped = escapeLabel(label);
+  switch (kind) {
+    case 'function':
+    case 'method':
+      return `(["${escaped}"])`;
+    case 'class':
+    case 'interface':
+    case 'type':
+    case 'struct':
+    case 'enum':
+    case 'trait':
+    case 'record':
+      return `{{"${escaped}"}}`;
+    case 'module':
+      return `[["${escaped}"]]`;
+    default:
+      return `["${escaped}"]`;
+  }
+}
+
+/** Map node role to Mermaid style colors. */
+export const ROLE_STYLES = {
+  entry: 'fill:#e8f5e9,stroke:#4caf50',
+  core: 'fill:#e3f2fd,stroke:#2196f3',
+  utility: 'fill:#f5f5f5,stroke:#9e9e9e',
+  dead: 'fill:#ffebee,stroke:#f44336',
+  leaf: 'fill:#fffde7,stroke:#fdd835',
+};
+
+// ─── DOT Serializer ──────────────────────────────────────────────────
+
+/**
+ * Render file-level graph data as DOT (Graphviz) format.
+ *
+ * @param {{ dirs: Array<{ name: string, files: Array<{ path: string, basename: string }>, cohesion: number|null }>, edges: Array<{ source: string, target: string }>, totalEdges: number, limit?: number }} data
+ * @returns {string}
+ */
+export function renderFileLevelDOT(data) {
+  const lines = [
+    'digraph codegraph {',
+    '  rankdir=LR;',
+    '  node [shape=box, fontname="monospace", fontsize=10];',
+    '  edge [color="#666666"];',
+    '',
+  ];
+
+  let clusterIdx = 0;
+  for (const dir of data.dirs) {
+    lines.push(`  subgraph cluster_${clusterIdx++} {`);
+    const cohLabel = dir.cohesion !== null ? ` (cohesion: ${dir.cohesion.toFixed(2)})` : '';
+    lines.push(`    label="${dir.name}${cohLabel}";`);
+    lines.push(`    style=dashed;`);
+    lines.push(`    color="#999999";`);
+    for (const f of dir.files) {
+      lines.push(`    "${f.path}" [label="${f.basename}"];`);
+    }
+    lines.push(`  }`);
+    lines.push('');
+  }
+
+  for (const { source, target } of data.edges) {
+    lines.push(`  "${source}" -> "${target}";`);
+  }
+  if (data.limit && data.totalEdges > data.limit) {
+    lines.push(`  // Truncated: showing ${data.edges.length} of ${data.totalEdges} edges`);
+  }
+
+  lines.push('}');
+  return lines.join('\n');
+}
+
+/**
+ * Render function-level graph data as DOT (Graphviz) format.
+ *
+ * @param {{ edges: Array<{ source_name: string, source_file: string, target_name: string, target_file: string }>, totalEdges: number, limit?: number }} data
+ * @returns {string}
+ */
+export function renderFunctionLevelDOT(data) {
+  const lines = [
+    'digraph codegraph {',
+    '  rankdir=LR;',
+    '  node [shape=box, fontname="monospace", fontsize=10];',
+    '  edge [color="#666666"];',
+    '',
+  ];
+
+  const emittedNodes = new Set();
+  for (const e of data.edges) {
+    const sId = `${e.source_file}:${e.source_name}`.replace(/[^a-zA-Z0-9_]/g, '_');
+    const tId = `${e.target_file}:${e.target_name}`.replace(/[^a-zA-Z0-9_]/g, '_');
+    if (!emittedNodes.has(sId)) {
+      lines.push(`  ${sId} [label="${e.source_name}\\n${path.basename(e.source_file)}"];`);
+      emittedNodes.add(sId);
+    }
+    if (!emittedNodes.has(tId)) {
+      lines.push(`  ${tId} [label="${e.target_name}\\n${path.basename(e.target_file)}"];`);
+      emittedNodes.add(tId);
+    }
+    lines.push(`  ${sId} -> ${tId};`);
+  }
+  if (data.limit && data.totalEdges > data.limit) {
+    lines.push(`  // Truncated: showing ${data.edges.length} of ${data.totalEdges} edges`);
+  }
+
+  lines.push('}');
+  return lines.join('\n');
+}
+
+// ─── Mermaid Serializer ──────────────────────────────────────────────
+
+/**
+ * Render file-level graph data as Mermaid flowchart format.
+ *
+ * @param {{ direction: string, dirs: Array<{ name: string, files: string[] }>, edges: Array<{ source: string, target: string, edge_kind: string }>, totalEdges: number, limit?: number }} data
+ * @returns {string}
+ */
+export function renderFileLevelMermaid(data) {
+  const lines = [`flowchart ${data.direction || 'LR'}`];
+
+  let nodeCounter = 0;
+  const nodeIdMap = new Map();
+  function nodeId(key) {
+    if (!nodeIdMap.has(key)) nodeIdMap.set(key, `n${nodeCounter++}`);
+    return nodeIdMap.get(key);
+  }
+
+  // Emit subgraphs
+  for (const dir of data.dirs) {
+    const sgId = dir.name.replace(/[^a-zA-Z0-9]/g, '_');
+    lines.push(`  subgraph ${sgId}["${escapeLabel(dir.name)}"]`);
+    for (const f of dir.files) {
+      const nId = nodeId(f);
+      lines.push(`    ${nId}["${escapeLabel(path.basename(f))}"]`);
+    }
+    lines.push('  end');
+  }
+
+  // Deduplicate edges per source-target pair, collecting all distinct kinds
+  const edgeMap = new Map();
+  for (const { source, target, edge_kind } of data.edges) {
+    const key = `${source}|${target}`;
+    const label = edge_kind === 'imports-type' ? 'imports' : edge_kind;
+    if (!edgeMap.has(key)) edgeMap.set(key, { source, target, labels: new Set() });
+    edgeMap.get(key).labels.add(label);
+  }
+
+  for (const { source, target, labels } of edgeMap.values()) {
+    lines.push(`  ${nodeId(source)} -->|${[...labels].join(', ')}| ${nodeId(target)}`);
+  }
+  if (data.limit && data.totalEdges > data.limit) {
+    lines.push(`  %% Truncated: showing ${data.edges.length} of ${data.totalEdges} edges`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Render function-level graph data as Mermaid flowchart format.
+ *
+ * @param {{ direction: string, edges: Array, roles: Map<string, string>, totalEdges: number, limit?: number }} data
+ * @returns {string}
+ */
+export function renderFunctionLevelMermaid(data) {
+  const lines = [`flowchart ${data.direction || 'LR'}`];
+
+  let nodeCounter = 0;
+  const nodeIdMap = new Map();
+  function nodeId(key) {
+    if (!nodeIdMap.has(key)) nodeIdMap.set(key, `n${nodeCounter++}`);
+    return nodeIdMap.get(key);
+  }
+
+  // Group nodes by file for subgraphs
+  const fileNodes = new Map();
+  const nodeKinds = new Map();
+  for (const e of data.edges) {
+    const sKey = `${e.source_file}::${e.source_name}`;
+    const tKey = `${e.target_file}::${e.target_name}`;
+    nodeId(sKey);
+    nodeId(tKey);
+    nodeKinds.set(sKey, e.source_kind);
+    nodeKinds.set(tKey, e.target_kind);
+
+    if (!fileNodes.has(e.source_file)) fileNodes.set(e.source_file, new Map());
+    fileNodes.get(e.source_file).set(sKey, e.source_name);
+
+    if (!fileNodes.has(e.target_file)) fileNodes.set(e.target_file, new Map());
+    fileNodes.get(e.target_file).set(tKey, e.target_name);
+  }
+
+  // Emit subgraphs grouped by file
+  for (const [file, nodes] of [...fileNodes].sort((a, b) => a[0].localeCompare(b[0]))) {
+    const sgId = file.replace(/[^a-zA-Z0-9]/g, '_');
+    lines.push(`  subgraph ${sgId}["${escapeLabel(file)}"]`);
+    for (const [key, name] of nodes) {
+      const kind = nodeKinds.get(key);
+      lines.push(`    ${nodeId(key)}${mermaidShape(kind, name)}`);
+    }
+    lines.push('  end');
+  }
+
+  // Emit edges with labels
+  for (const e of data.edges) {
+    const sId = nodeId(`${e.source_file}::${e.source_name}`);
+    const tId = nodeId(`${e.target_file}::${e.target_name}`);
+    lines.push(`  ${sId} -->|${e.edge_kind}| ${tId}`);
+  }
+  if (data.limit && data.totalEdges > data.limit) {
+    lines.push(`  %% Truncated: showing ${data.edges.length} of ${data.totalEdges} edges`);
+  }
+
+  // Role styling
+  const roleStyles = [];
+  for (const [key, nid] of nodeIdMap) {
+    const role = data.roles?.get(key);
+    if (role && ROLE_STYLES[role]) {
+      roleStyles.push(`  style ${nid} ${ROLE_STYLES[role]}`);
+    }
+  }
+  lines.push(...roleStyles);
+
+  return lines.join('\n');
+}
+
+// ─── GraphML Serializer ──────────────────────────────────────────────
+
+/**
+ * Render file-level graph data as GraphML (XML) format.
+ *
+ * @param {{ edges: Array<{ source: string, target: string }> }} data
+ * @returns {string}
+ */
+export function renderFileLevelGraphML(data) {
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<graphml xmlns="http://graphml.graphstruct.net/graphml">',
+    '  <key id="d0" for="node" attr.name="name" attr.type="string"/>',
+    '  <key id="d1" for="node" attr.name="file" attr.type="string"/>',
+    '  <key id="d2" for="edge" attr.name="kind" attr.type="string"/>',
+    '  <graph id="codegraph" edgedefault="directed">',
+  ];
+
+  const files = new Set();
+  for (const { source, target } of data.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 data.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>');
+  }
+
+  lines.push('  </graph>');
+  lines.push('</graphml>');
+  return lines.join('\n');
+}
+
+/**
+ * Render function-level graph data as GraphML (XML) format.
+ *
+ * @param {{ edges: Array }} data
+ * @returns {string}
+ */
+export function renderFunctionLevelGraphML(data) {
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<graphml xmlns="http://graphml.graphstruct.net/graphml">',
+    '  <key id="d0" for="node" attr.name="name" attr.type="string"/>',
+    '  <key id="d1" for="node" attr.name="kind" attr.type="string"/>',
+    '  <key id="d2" for="node" attr.name="file" attr.type="string"/>',
+    '  <key id="d3" for="node" attr.name="line" attr.type="int"/>',
+    '  <key id="d4" for="node" attr.name="role" attr.type="string"/>',
+    '  <key id="d5" for="edge" attr.name="kind" attr.type="string"/>',
+    '  <key id="d6" for="edge" attr.name="confidence" attr.type="double"/>',
+    '  <graph id="codegraph" edgedefault="directed">',
+  ];
+
+  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 data.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');
+}
+
+// ─── Neo4j CSV Serializer ────────────────────────────────────────────
+
+/**
+ * Render file-level graph data as Neo4j bulk-import CSV.
+ *
+ * @param {{ edges: Array<{ source: string, target: string, edge_kind: string, confidence: number }> }} data
+ * @returns {{ nodes: string, relationships: string }}
+ */
+export function renderFileLevelNeo4jCSV(data) {
+  const files = new Map();
+  let idx = 0;
+  for (const { source, target } of data.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 data.edges) {
+    const edgeType = e.edge_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') };
+}
+
+/**
+ * Render function-level graph data as Neo4j bulk-import CSV.
+ *
+ * @param {{ edges: Array }} data
+ * @returns {{ nodes: string, relationships: string }}
+ */
+export function renderFunctionLevelNeo4jCSV(data) {
+  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 data.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') };
+}