@zuvia-software-solutions/code-mapper 1.4.0 → 2.0.1

package/dist/core/db/adapter.js

@@ -0,0 +1,402 @@
+// code-mapper/src/core/db/adapter.ts
+/**
+ * @file Unified SQLite database adapter for code-mapper.
+ *
+ * Single module for both CLI and MCP database access.
+ * WAL mode: concurrent readers + single writer, zero lock conflicts.
+ * Synchronous better-sqlite3 API: no connection pools needed.
+ *
+ * All public functions are typed with branded IDs and schema types
+ * from schema.ts — the compiler prevents passing wrong ID types
+ * or invalid labels/edge types.
+ */
+import Database from 'better-sqlite3';
+import path from 'path';
+import fs from 'fs';
+import { SCHEMA_SQL, toNodeId, } from './schema.js';
+// ---------------------------------------------------------------------------
+// Singleton instances keyed by resolved dbPath
+// ---------------------------------------------------------------------------
+const instances = new Map();
+// ---------------------------------------------------------------------------
+// Lifecycle
+// ---------------------------------------------------------------------------
+/** Open (or reuse) a SQLite database. Creates schema if new. */
+export function openDb(dbPath) {
+    const resolved = path.resolve(dbPath);
+    const existing = instances.get(resolved);
+    if (existing)
+        return existing;
+    const dir = path.dirname(resolved);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const db = new Database(resolved);
+    // Performance pragmas
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.pragma('cache_size = -64000'); // 64MB
+    db.pragma('mmap_size = 268435456'); // 256MB
+    db.pragma('foreign_keys = OFF');
+    // Create schema (IF NOT EXISTS — idempotent)
+    db.exec(SCHEMA_SQL);
+    instances.set(resolved, db);
+    return db;
+}
+/** Close one or all databases. */
+export function closeDb(dbPath) {
+    if (dbPath) {
+        const resolved = path.resolve(dbPath);
+        const db = instances.get(resolved);
+        if (db) {
+            db.close();
+            instances.delete(resolved);
+        }
+        return;
+    }
+    for (const [key, db] of instances) {
+        db.close();
+        instances.delete(key);
+    }
+}
+/** Delete and recreate a database (full re-analyze). */
+export function resetDb(dbPath) {
+    closeDb(dbPath);
+    const resolved = path.resolve(dbPath);
+    for (const suffix of ['', '-wal', '-shm']) {
+        try {
+            fs.unlinkSync(resolved + suffix);
+        }
+        catch { }
+    }
+    return openDb(dbPath);
+}
+/** Check if a database is open. */
+export function isDbOpen(dbPath) {
+    return instances.has(path.resolve(dbPath));
+}
+// ---------------------------------------------------------------------------
+// Node operations
+// ---------------------------------------------------------------------------
+/**
+ * Expand an identifier into natural language words for FTS matching.
+ * camelCase, PascalCase, snake_case, UPPER_CASE → space-separated words.
+ *
+ * Examples:
+ *   buildTestGraph → "build test graph"
+ *   processCallsFromExtracted → "process calls from extracted"
+ *   MAX_CHAIN_DEPTH → "max chain depth"
+ *   deleteNodesByFile → "delete nodes by file"
+ */
+export function expandIdentifier(name) {
+    if (!name)
+        return '';
+    return name
+        // Insert space before uppercase runs: "processHTTPRequest" → "process HTTP Request"
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        // Insert space between uppercase run and lowercase: "HTTPRequest" → "HTTP Request"
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        // Replace underscores/hyphens with spaces
+        .replace(/[_\-]+/g, ' ')
+        // Collapse multiple spaces
+        .replace(/\s+/g, ' ')
+        .toLowerCase()
+        .trim();
+}
+const INSERT_NODE_SQL = `
+  INSERT OR REPLACE INTO nodes (
+    id, label, name, filePath, startLine, endLine, isExported, content, description,
+    heuristicLabel, cohesion, symbolCount, keywords, enrichedBy,
+    processType, stepCount, communities, entryPointId, terminalId,
+    parameterCount, returnType, nameExpanded
+  ) VALUES (
+    @id, @label, @name, @filePath, @startLine, @endLine, @isExported, @content, @description,
+    @heuristicLabel, @cohesion, @symbolCount, @keywords, @enrichedBy,
+    @processType, @stepCount, @communities, @entryPointId, @terminalId,
+    @parameterCount, @returnType, @nameExpanded
+  )
+`;
+/** Insert or replace a node. Automatically expands name for FTS natural language matching. */
+export function insertNode(db, node) {
+    db.prepare(INSERT_NODE_SQL).run({
+        id: node.id,
+        label: node.label,
+        name: node.name ?? '',
+        filePath: node.filePath ?? '',
+        startLine: node.startLine ?? null,
+        endLine: node.endLine ?? null,
+        isExported: node.isExported ?? null,
+        content: node.content ?? '',
+        description: node.description ?? '',
+        heuristicLabel: node.heuristicLabel ?? null,
+        cohesion: node.cohesion ?? null,
+        symbolCount: node.symbolCount ?? null,
+        keywords: node.keywords ?? null,
+        enrichedBy: node.enrichedBy ?? null,
+        processType: node.processType ?? null,
+        stepCount: node.stepCount ?? null,
+        communities: node.communities ?? null,
+        entryPointId: node.entryPointId ?? null,
+        terminalId: node.terminalId ?? null,
+        parameterCount: node.parameterCount ?? null,
+        returnType: node.returnType ?? null,
+        nameExpanded: node.nameExpanded ?? expandIdentifier(node.name ?? ''),
+    });
+}
+/** Get a node by ID. Returns undefined if not found. */
+export function getNode(db, id) {
+    return db.prepare('SELECT * FROM nodes WHERE id = ?').get(id);
+}
+/** Find nodes by name (optionally filtered by label). */
+export function findNodesByName(db, name, label, limit = 10) {
+    if (label) {
+        return db.prepare('SELECT * FROM nodes WHERE name = ? AND label = ? LIMIT ?').all(name, label, limit);
+    }
+    return db.prepare('SELECT * FROM nodes WHERE name = ? LIMIT ?').all(name, limit);
+}
+/** Find nodes by file path. */
+export function findNodesByFile(db, filePath) {
+    return db.prepare('SELECT * FROM nodes WHERE filePath = ?').all(filePath);
+}
+/** Find the node containing a given line in a file (best match). */
+export function findNodeAtLine(db, filePath, line, excludeLabel) {
+    const sql = excludeLabel
+        ? 'SELECT * FROM nodes WHERE filePath = ? AND startLine <= ? AND endLine >= ? AND label != ? ORDER BY (endLine - startLine) LIMIT 1'
+        : 'SELECT * FROM nodes WHERE filePath = ? AND startLine <= ? AND endLine >= ? ORDER BY (endLine - startLine) LIMIT 1';
+    return excludeLabel
+        ? db.prepare(sql).get(filePath, line, line, excludeLabel)
+        : db.prepare(sql).get(filePath, line, line);
+}
+/** Count nodes, optionally by label. */
+export function countNodes(db, label) {
+    if (label) {
+        return db.prepare('SELECT COUNT(*) AS cnt FROM nodes WHERE label = ?').get(label).cnt;
+    }
+    return db.prepare('SELECT COUNT(*) AS cnt FROM nodes').get().cnt;
+}
+/** Delete all nodes (and related edges/embeddings) for a file path. Returns count deleted. */
+export function deleteNodesByFile(db, filePath) {
+    const nodeIds = db.prepare('SELECT id FROM nodes WHERE filePath = ?').all(filePath);
+    if (nodeIds.length === 0)
+        return 0;
+    const ids = nodeIds.map(n => n.id);
+    const ph = ids.map(() => '?').join(',');
+    // Delete edges FROM this file's nodes (outgoing). Incoming edges from other
+    // files are preserved — the node IDs are deterministic (label:filePath:name),
+    // so re-inserted nodes get the same ID and the edges remain valid.
+    db.prepare(`DELETE FROM edges WHERE sourceId IN (${ph})`).run(...ids);
+    db.prepare(`DELETE FROM embeddings WHERE nodeId IN (${ph})`).run(...ids);
+    return db.prepare('DELETE FROM nodes WHERE filePath = ?').run(filePath).changes;
+}
+// ---------------------------------------------------------------------------
+// Edge operations
+// ---------------------------------------------------------------------------
+const INSERT_EDGE_SQL = `
+  INSERT OR IGNORE INTO edges (id, sourceId, targetId, type, confidence, reason, step, callLine)
+  VALUES (@id, @sourceId, @targetId, @type, @confidence, @reason, @step, @callLine)
+`;
+/** Insert an edge (ignores duplicates). */
+export function insertEdge(db, edge) {
+    db.prepare(INSERT_EDGE_SQL).run({
+        id: edge.id,
+        sourceId: edge.sourceId,
+        targetId: edge.targetId,
+        type: edge.type,
+        confidence: edge.confidence ?? 1.0,
+        reason: edge.reason ?? '',
+        step: edge.step ?? 0,
+        callLine: edge.callLine ?? null,
+    });
+}
+/** Find edges from a source node, optionally filtered by type. */
+export function findEdgesFrom(db, sourceId, type, minConfidence = 0) {
+    if (type) {
+        return db.prepare('SELECT * FROM edges WHERE sourceId = ? AND type = ? AND confidence >= ?').all(sourceId, type, minConfidence);
+    }
+    return db.prepare('SELECT * FROM edges WHERE sourceId = ? AND confidence >= ?').all(sourceId, minConfidence);
+}
+/** Find edges to a target node, optionally filtered by type. */
+export function findEdgesTo(db, targetId, type, minConfidence = 0) {
+    if (type) {
+        return db.prepare('SELECT * FROM edges WHERE targetId = ? AND type = ? AND confidence >= ?').all(targetId, type, minConfidence);
+    }
+    return db.prepare('SELECT * FROM edges WHERE targetId = ? AND confidence >= ?').all(targetId, minConfidence);
+}
+/** Count edges. */
+export function countEdges(db) {
+    return db.prepare('SELECT COUNT(*) AS cnt FROM edges').get().cnt;
+}
+// ---------------------------------------------------------------------------
+// Embedding operations
+// ---------------------------------------------------------------------------
+/** Insert or replace an embedding (stores as binary Float32Array). */
+export function insertEmbedding(db, nodeId, embedding) {
+    const buf = Buffer.from(new Float32Array(embedding).buffer);
+    db.prepare('INSERT OR REPLACE INTO embeddings (nodeId, embedding) VALUES (?, ?)').run(nodeId, buf);
+}
+/** Delete embeddings for nodes in a given file. */
+export function deleteEmbeddingsByFile(db, filePath) {
+    const nodeIds = db.prepare('SELECT id FROM nodes WHERE filePath = ?').all(filePath);
+    if (nodeIds.length === 0)
+        return;
+    const ph = nodeIds.map(() => '?').join(',');
+    db.prepare(`DELETE FROM embeddings WHERE nodeId IN (${ph})`).run(...nodeIds.map(n => n.id));
+}
+/** Count embeddings. */
+export function countEmbeddings(db) {
+    return db.prepare('SELECT COUNT(*) AS cnt FROM embeddings').get().cnt;
+}
+/** Cosine similarity between two vectors. */
+function cosineSimilarity(a, b) {
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        const ai = a[i] ?? 0;
+        const bi = b[i] ?? 0;
+        dot += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dot / denom;
+}
+/** Vector similarity search (brute-force cosine). Fast enough for <200K vectors at 256 dims. */
+export function searchVector(db, queryVec, limit = 10, maxDistance = 0.5) {
+    const rows = db.prepare('SELECT nodeId, embedding FROM embeddings').all();
+    const results = [];
+    for (const row of rows) {
+        const vec = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4);
+        const distance = 1 - cosineSimilarity(queryVec, vec);
+        if (distance < maxDistance) {
+            results.push({ nodeId: toNodeId(row.nodeId), distance });
+        }
+    }
+    results.sort((a, b) => a.distance - b.distance);
+    return results.slice(0, limit);
+}
+// ---------------------------------------------------------------------------
+// FTS search
+// ---------------------------------------------------------------------------
+/** Full-text search across nodes. FTS5 auto-maintains the index. */
+export function searchFTS(db, query, limit = 20) {
+    // Sanitize query for FTS5 — escape double quotes, handle special chars
+    let safeQuery = query.replace(/"/g, '""').replace(/[*(){}[\]^~\\:]/g, ' ').trim();
+    if (!safeQuery)
+        return [];
+    // Multi-word queries: use OR so natural language works ("find nodes by name in database")
+    // FTS5 default is AND — every word must match. OR is more forgiving for NL queries.
+    const words = safeQuery.split(/\s+/).filter(w => w.length > 1);
+    if (words.length > 1) {
+        safeQuery = words.join(' OR ');
+    }
+    try {
+        return db.prepare(`
+      SELECT n.id, n.name, n.label, n.filePath, -fts.rank AS score
+      FROM nodes_fts fts
+      JOIN nodes n ON n.rowid = fts.rowid
+      WHERE nodes_fts MATCH ?
+      ORDER BY fts.rank
+      LIMIT ?
+    `).all(safeQuery, limit);
+    }
+    catch {
+        // FTS query syntax error — fall back to LIKE
+        return db.prepare(`
+      SELECT id, name, label, filePath, 1.0 AS score
+      FROM nodes
+      WHERE name LIKE ? OR content LIKE ?
+      LIMIT ?
+    `).all(`%${safeQuery}%`, `%${safeQuery}%`, limit);
+    }
+}
+// ---------------------------------------------------------------------------
+// Stats
+// ---------------------------------------------------------------------------
+/** Get node count, edge count, and embedding count. */
+export function getStats(db) {
+    return {
+        nodes: countNodes(db),
+        edges: countEdges(db),
+        embeddings: countEmbeddings(db),
+    };
+}
+// ---------------------------------------------------------------------------
+// Batch operations (transactional)
+// ---------------------------------------------------------------------------
+/** Batch insert nodes in a single transaction. */
+export function insertNodesBatch(db, nodes) {
+    const stmt = db.prepare(INSERT_NODE_SQL);
+    const txn = db.transaction((items) => {
+        for (const node of items) {
+            stmt.run({
+                id: node.id, label: node.label, name: node.name ?? '', filePath: node.filePath ?? '',
+                startLine: node.startLine ?? null, endLine: node.endLine ?? null, isExported: node.isExported ?? null,
+                content: node.content ?? '', description: node.description ?? '',
+                heuristicLabel: node.heuristicLabel ?? null, cohesion: node.cohesion ?? null,
+                symbolCount: node.symbolCount ?? null, keywords: node.keywords ?? null, enrichedBy: node.enrichedBy ?? null,
+                processType: node.processType ?? null, stepCount: node.stepCount ?? null,
+                communities: node.communities ?? null, entryPointId: node.entryPointId ?? null,
+                terminalId: node.terminalId ?? null, parameterCount: node.parameterCount ?? null,
+                returnType: node.returnType ?? null,
+                nameExpanded: node.nameExpanded ?? expandIdentifier(node.name ?? ''),
+            });
+        }
+    });
+    txn(nodes);
+}
+/** Batch insert edges in a single transaction. */
+export function insertEdgesBatch(db, edges) {
+    const stmt = db.prepare(INSERT_EDGE_SQL);
+    const txn = db.transaction((items) => {
+        for (const edge of items) {
+            stmt.run({
+                id: edge.id, sourceId: edge.sourceId, targetId: edge.targetId, type: edge.type,
+                confidence: edge.confidence ?? 1.0, reason: edge.reason ?? '', step: edge.step ?? 0,
+                callLine: edge.callLine ?? null,
+            });
+        }
+    });
+    txn(edges);
+}
+/** Batch insert embeddings in a single transaction. */
+export function insertEmbeddingsBatch(db, items) {
+    const stmt = db.prepare('INSERT OR REPLACE INTO embeddings (nodeId, embedding, textHash) VALUES (?, ?, ?)');
+    const txn = db.transaction((batch) => {
+        for (const item of batch) {
+            const buf = Buffer.from(new Float32Array(item.embedding).buffer);
+            stmt.run(item.nodeId, buf, item.textHash ?? null);
+        }
+    });
+    txn(items);
+}
+/** Get all textHashes from the embeddings table for hash-based skip on re-index */
+export function getEmbeddingHashes(db) {
+    const rows = db.prepare('SELECT nodeId, textHash FROM embeddings WHERE textHash IS NOT NULL').all();
+    const map = new Map();
+    for (const row of rows) {
+        map.set(row.nodeId, row.textHash);
+    }
+    return map;
+}
+// ---------------------------------------------------------------------------
+// Raw SQL escape (for dynamic queries in local-backend.ts)
+// ---------------------------------------------------------------------------
+/** Escape a string for use in SQL single-quoted literals. */
+export function escapeSql(value) {
+    return value.replace(/'/g, "''");
+}
+// ---------------------------------------------------------------------------
+// Raw query execution (for migration compatibility)
+// ---------------------------------------------------------------------------
+/** Execute a raw SQL query and return rows. */
+export function rawQuery(db, sql, params) {
+    const stmt = db.prepare(sql);
+    if (params)
+        return stmt.all(...params);
+    return stmt.all();
+}
+/** Execute a raw SQL statement (no return). */
+export function rawRun(db, sql, params) {
+    const stmt = db.prepare(sql);
+    if (params)
+        return stmt.run(...params);
+    return stmt.run();
+}

package/dist/core/db/graph-loader.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @file Loads a KnowledgeGraph into SQLite.
+ *
+ * Replaces the old CSV-generator + graph DB COPY pipeline (~800 lines)
+ * with direct batch INSERTs in transactions. SQLite handles this in <2s
+ * for typical codebases (1-5K nodes) because:
+ *   - Prepared statements are reused across the batch
+ *   - WAL mode doesn't block readers during the write
+ *   - No CSV serialization/deserialization overhead
+ */
+import type Database from 'better-sqlite3';
+import { type KnowledgeGraph } from '../graph/types.js';
+/** Progress callback */
+export type LoadProgressCallback = (message: string) => void;
+/** Result of loading a graph */
+export interface LoadResult {
+    readonly nodesInserted: number;
+    readonly edgesInserted: number;
+    readonly warnings: readonly string[];
+}
+/**
+ * Load an in-memory KnowledgeGraph into a SQLite database.
+ *
+ * This is the full-pipeline path used by `code-mapper analyze`.
+ * For incremental updates, use the adapter functions directly.
+ */
+export declare function loadGraphToDb(db: Database.Database, graph: KnowledgeGraph, repoPath: string, onProgress?: LoadProgressCallback): LoadResult;

package/dist/core/db/graph-loader.js

@@ -0,0 +1,148 @@
+// code-mapper/src/core/db/graph-loader.ts
+/**
+ * @file Loads a KnowledgeGraph into SQLite.
+ *
+ * Replaces the old CSV-generator + graph DB COPY pipeline (~800 lines)
+ * with direct batch INSERTs in transactions. SQLite handles this in <2s
+ * for typical codebases (1-5K nodes) because:
+ *   - Prepared statements are reused across the batch
+ *   - WAL mode doesn't block readers during the write
+ *   - No CSV serialization/deserialization overhead
+ */
+import fs from 'fs';
+import path from 'path';
+import {} from '../graph/types.js';
+import { NODE_LABELS, toNodeId, toEdgeId, } from './schema.js';
+import {} from './schema.js';
+import { insertNodesBatch, insertEdgesBatch } from './adapter.js';
+/** Maximum characters of source content to store per File node */
+const MAX_FILE_CONTENT = 100_000;
+/** Maximum characters of source snippet to store per symbol node */
+const MAX_SNIPPET = 50_000;
+/**
+ * Check if content is likely binary (contains null bytes or high ratio of non-printable chars)
+ */
+function isBinaryContent(content) {
+    if (content.length === 0)
+        return false;
+    let nonPrintable = 0;
+    const sampleSize = Math.min(content.length, 1024);
+    for (let i = 0; i < sampleSize; i++) {
+        const code = content.charCodeAt(i);
+        if (code === 0)
+            return true;
+        if (code < 32 && code !== 9 && code !== 10 && code !== 13)
+            nonPrintable++;
+    }
+    return nonPrintable / sampleSize > 0.1;
+}
+/**
+ * Read and truncate file content for a node
+ */
+function getNodeContent(repoPath, node) {
+    const filePath = node.filePath;
+    if (!filePath)
+        return '';
+    if (node.label === 'Folder')
+        return '';
+    const absPath = path.join(repoPath, filePath);
+    let content;
+    try {
+        content = fs.readFileSync(absPath, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+    if (isBinaryContent(content))
+        return '[Binary file]';
+    if (node.label === 'File') {
+        return content.length > MAX_FILE_CONTENT
+            ? content.slice(0, MAX_FILE_CONTENT) + '\n... [truncated]'
+            : content;
+    }
+    const startLine = node.startLine;
+    const endLine = node.endLine;
+    if (startLine === undefined || endLine === undefined)
+        return '';
+    const lines = content.split('\n');
+    const start = Math.max(0, startLine - 2);
+    const end = Math.min(lines.length - 1, endLine + 2);
+    const snippet = lines.slice(start, end + 1).join('\n');
+    return snippet.length > MAX_SNIPPET
+        ? snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]'
+        : snippet;
+}
+/**
+ * Load an in-memory KnowledgeGraph into a SQLite database.
+ *
+ * This is the full-pipeline path used by `code-mapper analyze`.
+ * For incremental updates, use the adapter functions directly.
+ */
+export function loadGraphToDb(db, graph, repoPath, onProgress) {
+    const log = onProgress ?? (() => { });
+    const warnings = [];
+    const validLabels = new Set(NODE_LABELS);
+    // ── Collect nodes ────────────────────────────────────────────────────
+    log('Preparing nodes...');
+    const nodeInserts = [];
+    for (const node of graph.iterNodes()) {
+        if (!validLabels.has(node.label)) {
+            warnings.push(`Skipped node with unknown label: ${node.label}`);
+            continue;
+        }
+        const content = getNodeContent(repoPath, {
+            label: node.label,
+            filePath: node.properties.filePath,
+            ...(node.properties.startLine !== undefined ? { startLine: node.properties.startLine } : {}),
+            ...(node.properties.endLine !== undefined ? { endLine: node.properties.endLine } : {}),
+        });
+        nodeInserts.push({
+            id: toNodeId(node.id),
+            label: node.label,
+            name: node.properties.name ?? '',
+            filePath: node.properties.filePath ?? '',
+            startLine: node.properties.startLine ?? null,
+            endLine: node.properties.endLine ?? null,
+            isExported: node.properties.isExported ? 1 : null,
+            content,
+            description: node.properties.description ?? '',
+            heuristicLabel: node.properties.heuristicLabel ?? null,
+            cohesion: node.properties.cohesion ?? null,
+            symbolCount: node.properties.symbolCount ?? null,
+            keywords: node.properties.keywords ? JSON.stringify(node.properties.keywords) : null,
+            enrichedBy: node.properties.enrichedBy ?? null,
+            processType: node.properties.processType ?? null,
+            stepCount: node.properties.stepCount ?? null,
+            communities: node.properties.communities ? JSON.stringify(node.properties.communities) : null,
+            entryPointId: node.properties.entryPointId ?? null,
+            terminalId: node.properties.terminalId ?? null,
+            parameterCount: node.properties.parameterCount ?? null,
+            returnType: node.properties.returnType ?? null,
+        });
+    }
+    log(`Inserting ${nodeInserts.length} nodes...`);
+    insertNodesBatch(db, nodeInserts);
+    // ── Collect edges ────────────────────────────────────────────────────
+    log('Preparing edges...');
+    const edgeInserts = [];
+    for (const rel of graph.iterRelationships()) {
+        edgeInserts.push({
+            id: toEdgeId(rel.id),
+            sourceId: toNodeId(rel.sourceId),
+            targetId: toNodeId(rel.targetId),
+            type: rel.type,
+            confidence: rel.confidence,
+            reason: rel.reason ?? '',
+            step: rel.step ?? 0,
+            callLine: rel.callLine ?? null,
+        });
+    }
+    log(`Inserting ${edgeInserts.length} edges...`);
+    insertEdgesBatch(db, edgeInserts);
+    log(`Loaded ${nodeInserts.length} nodes, ${edgeInserts.length} edges`);
+    return {
+        nodesInserted: nodeInserts.length,
+        edgesInserted: edgeInserts.length,
+        warnings,
+    };
+}