optave-codegraph 3.13.0

package/dist/features/dataflow.js

@@ -0,0 +1,1079 @@
+/**
+ * Dataflow analysis — define/use chains and data movement edges.
+ *
+ * Adds three edge types to track how data moves through functions:
+ *   - flows_to:  parameter/variable flows into another function as an argument
+ *   - returns:   a call's return value is captured and used in the caller
+ *   - mutates:   a parameter-derived value is mutated (e.g. arr.push())
+ *
+ * Opt-in via `build --dataflow`. Supports all languages with DATAFLOW_RULES.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { DATAFLOW_RULES } from '../ast-analysis/rules/index.js';
+import { makeDataflowRules as _makeDataflowRules, buildExtensionSet, buildExtToLangMap, } from '../ast-analysis/shared.js';
+import { walkWithVisitors } from '../ast-analysis/visitor.js';
+import { createDataflowVisitor } from '../ast-analysis/visitors/dataflow-visitor.js';
+import { hasDataflowTable, openReadonlyOrFail, openReadonlyWithNative } from '../db/index.js';
+import { ALL_SYMBOL_KINDS, normalizeSymbol } from '../domain/queries.js';
+import { debug, info } from '../infrastructure/logger.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
+import { paginateResult } from '../shared/paginate.js';
+import { findNodes } from './shared/find-nodes.js';
+// Re-export for backward compatibility
+export { _makeDataflowRules as makeDataflowRules, DATAFLOW_RULES };
+export const DATAFLOW_EXTENSIONS = buildExtensionSet(DATAFLOW_RULES);
+export function extractDataflow(tree, _filePath, _definitions, langId = 'javascript') {
+    const rules = DATAFLOW_RULES.get(langId);
+    if (!rules)
+        return { parameters: [], returns: [], assignments: [], argFlows: [], mutations: [] };
+    const visitor = createDataflowVisitor(rules);
+    const results = walkWithVisitors(tree.rootNode, [visitor], langId, {
+        functionNodeTypes: rules.functionNodes,
+        getFunctionName: () => null, // dataflow visitor handles its own name extraction
+    });
+    return results.dataflow;
+}
+async function initDataflowParsers(fileSymbols) {
+    let needsFallback = false;
+    for (const [relPath, symbols] of fileSymbols) {
+        if (!symbols._tree && !symbols.dataflow) {
+            const ext = path.extname(relPath).toLowerCase();
+            if (DATAFLOW_EXTENSIONS.has(ext)) {
+                needsFallback = true;
+                break;
+            }
+        }
+    }
+    let parsers = null;
+    let getParserFn = null;
+    if (needsFallback) {
+        const { createParsers } = await import('../domain/parser.js');
+        parsers = await createParsers();
+        const mod = await import('../domain/parser.js');
+        getParserFn = mod.getParser;
+    }
+    return { parsers, getParserFn };
+}
+function getDataflowForFile(symbols, relPath, rootDir, extToLang, parsers, getParserFn) {
+    if (symbols.dataflow)
+        return symbols.dataflow;
+    let tree = symbols._tree;
+    let langId = symbols._langId;
+    if (!tree) {
+        if (!getParserFn)
+            return null;
+        const ext = path.extname(relPath).toLowerCase();
+        langId = extToLang.get(ext);
+        if (!langId || !DATAFLOW_RULES.has(langId))
+            return null;
+        const absPath = path.join(rootDir, relPath);
+        let code;
+        try {
+            code = fs.readFileSync(absPath, 'utf-8');
+        }
+        catch (e) {
+            debug(`dataflow: cannot read ${relPath}: ${e.message}`);
+            return null;
+        }
+        const parser = getParserFn(parsers, absPath);
+        if (!parser)
+            return null;
+        try {
+            tree = parser.parse(code);
+        }
+        catch (e) {
+            debug(`dataflow: parse failed for ${relPath}: ${e.message}`);
+            return null;
+        }
+    }
+    if (!langId) {
+        const ext = path.extname(relPath).toLowerCase();
+        langId = extToLang.get(ext);
+        if (!langId)
+            return null;
+    }
+    if (!DATAFLOW_RULES.has(langId))
+        return null;
+    return extractDataflow(tree, relPath, symbols.definitions, langId);
+}
+function insertDataflowEdges(insert, data, resolveNode) {
+    let edgeCount = 0;
+    for (const flow of data.argFlows) {
+        const sourceNode = resolveNode(flow.callerFunc);
+        const targetNode = resolveNode(flow.calleeName);
+        if (sourceNode && targetNode) {
+            insert.run(sourceNode.id, targetNode.id, 'flows_to', flow.argIndex, flow.expression, flow.line, flow.confidence);
+            edgeCount++;
+        }
+    }
+    for (const assignment of data.assignments) {
+        const producerNode = resolveNode(assignment.sourceCallName);
+        const consumerNode = resolveNode(assignment.callerFunc);
+        if (producerNode && consumerNode) {
+            insert.run(producerNode.id, consumerNode.id, 'returns', null, assignment.expression, assignment.line, 1.0);
+            edgeCount++;
+        }
+    }
+    for (const mut of data.mutations) {
+        const mutatorNode = resolveNode(mut.funcName);
+        if (mutatorNode && mut.binding?.type === 'param') {
+            insert.run(mutatorNode.id, mutatorNode.id, 'mutates', null, mut.mutatingExpr, mut.line, 1.0);
+            edgeCount++;
+        }
+    }
+    return edgeCount;
+}
+// ── P1: dataflow_vertices + intra def_use edges ───────────────────────────────
+function prepareVertexStmts(db) {
+    try {
+        return {
+            insertVertex: db.prepare(`INSERT INTO dataflow_vertices (func_id, kind, name, param_index, line, node_id)
+         VALUES (?, ?, ?, ?, ?, ?)`),
+            insertIntraEdge: db.prepare(`INSERT INTO dataflow
+           (source_id, target_id, kind, source_vertex, target_vertex, scope, expression, line, confidence)
+         VALUES (?, ?, 'def_use', ?, ?, 'intra', ?, ?, 1.0)`),
+            available: true,
+        };
+    }
+    catch {
+        return {
+            insertVertex: db.prepare('SELECT 1'),
+            insertIntraEdge: db.prepare('SELECT 1'),
+            available: false,
+        };
+    }
+}
+/**
+ * Build dataflow_vertices, intra def_use edges, and summaries for one file.
+ * Called alongside insertDataflowEdges in the same transaction.
+ *
+ * Returns stitch candidates and return captures for the P2 inter-procedural
+ * post-pass (run after all files are processed).
+ */
+function buildDataflowVerticesAndEdges(db, vstmts, data, resolveNode) {
+    const empty = {
+        candidates: [],
+        captures: [],
+    };
+    if (!vstmts.available)
+        return empty;
+    const params = data.parameters;
+    const returns = data.returns;
+    const assignments = data.assignments;
+    const argFlows = data.argFlows;
+    const mutations = data.mutations;
+    // 1. param vertices
+    const paramVertexIds = new Map(); // "funcName:paramName" → vertex id
+    const paramIndexByFuncAndIndex = new Map(); // "funcId:paramIndex" → vertex id
+    for (const p of params) {
+        const fn = resolveNode(p.funcName);
+        if (!fn)
+            continue;
+        const result = vstmts.insertVertex.run(fn.id, 'param', p.paramName, p.paramIndex, p.line, null);
+        const vid = result.lastInsertRowid;
+        paramVertexIds.set(`${p.funcName}:${p.paramName}`, vid);
+        paramIndexByFuncAndIndex.set(`${fn.id}:${p.paramIndex}`, vid);
+    }
+    // 2. return vertices (one per function that has a return statement)
+    const returnVertexIds = new Map(); // funcName → vertex id
+    const returnFuncsSeen = new Set();
+    for (const r of returns) {
+        if (returnFuncsSeen.has(r.funcName))
+            continue;
+        returnFuncsSeen.add(r.funcName);
+        const fn = resolveNode(r.funcName);
+        if (!fn)
+            continue;
+        const result = vstmts.insertVertex.run(fn.id, 'return', null, null, r.line, null);
+        returnVertexIds.set(r.funcName, result.lastInsertRowid);
+    }
+    // 3. local vertices (from call-return assignments)
+    const localVertexIds = new Map(); // "funcName:varName" → vertex id
+    const localsSeen = new Set();
+    for (const a of assignments) {
+        const key = `${a.callerFunc}:${a.varName}`;
+        if (localsSeen.has(key))
+            continue;
+        localsSeen.add(key);
+        const fn = resolveNode(a.callerFunc);
+        if (!fn)
+            continue;
+        const result = vstmts.insertVertex.run(fn.id, 'local', a.varName, null, a.line, null);
+        localVertexIds.set(key, result.lastInsertRowid);
+    }
+    // 4. intra def_use edges: param/local → return
+    for (const r of returns) {
+        const fn = resolveNode(r.funcName);
+        if (!fn)
+            continue;
+        const returnVid = returnVertexIds.get(r.funcName);
+        if (!returnVid)
+            continue;
+        for (const name of r.referencedNames) {
+            const paramVid = paramVertexIds.get(`${r.funcName}:${name}`);
+            if (paramVid) {
+                vstmts.insertIntraEdge.run(fn.id, fn.id, paramVid, returnVid, r.expression, r.line);
+            }
+            const localVid = localVertexIds.get(`${r.funcName}:${name}`);
+            if (localVid) {
+                vstmts.insertIntraEdge.run(fn.id, fn.id, localVid, returnVid, r.expression, r.line);
+            }
+        }
+    }
+    // 5. summaries: flows_to_return = direct def_use from param to function's return
+    const checkDefUse = db.prepare(`SELECT 1 FROM dataflow WHERE source_vertex = ? AND target_vertex = ? AND kind = 'def_use' LIMIT 1`);
+    const insertSummary = db.prepare(`INSERT OR REPLACE INTO dataflow_summary (func_id, param_index, flows_to_return, is_mutated) VALUES (?, ?, ?, ?)`);
+    for (const p of params) {
+        const fn = resolveNode(p.funcName);
+        if (!fn)
+            continue;
+        const paramVid = paramVertexIds.get(`${p.funcName}:${p.paramName}`);
+        if (!paramVid)
+            continue;
+        const returnVid = returnVertexIds.get(p.funcName);
+        const flowsToReturn = returnVid ? (checkDefUse.get(paramVid, returnVid) ? 1 : 0) : 0;
+        const isMutated = mutations.some((m) => m.funcName === p.funcName &&
+            m.binding?.type === 'param' &&
+            m.binding?.index === p.paramIndex)
+            ? 1
+            : 0;
+        insertSummary.run(fn.id, p.paramIndex, flowsToReturn, isMutated);
+    }
+    // 6. collect stitch candidates for P2 inter-procedural post-pass
+    const candidates = [];
+    for (const af of argFlows) {
+        const callerFn = resolveNode(af.callerFunc);
+        const calleeFn = resolveNode(af.calleeName);
+        if (!callerFn || !calleeFn)
+            continue;
+        candidates.push({
+            callerFuncId: callerFn.id,
+            calleeFuncId: calleeFn.id,
+            argIndex: af.argIndex,
+            bindingType: af.binding.type,
+            bindingIndex: af.binding.index,
+            argName: af.argName,
+            expression: af.expression,
+            line: af.line,
+            confidence: af.confidence,
+        });
+    }
+    // 7. collect return captures (locals that hold a callee's return value)
+    const captures = [];
+    for (const a of assignments) {
+        const callerFn = resolveNode(a.callerFunc);
+        const calleeFn = resolveNode(a.sourceCallName);
+        if (!callerFn || !calleeFn)
+            continue;
+        captures.push({ callerFuncId: callerFn.id, calleeFuncId: calleeFn.id, varName: a.varName });
+    }
+    return { candidates, captures };
+}
+// ── P2: interprocedural stitching ─────────────────────────────────────────────
+/**
+ * Post-pass: connect arg-flow candidates to vertex-level inter-procedural edges.
+ * Runs after all per-file vertices + summaries have been committed.
+ *
+ * For each resolved argFlow (A calls B with arg x → B.param[j]):
+ *  - Emits 'arg_in' inter edge: A's source vertex → B.param[j] vertex
+ *  - If B's summary shows B.param[j] reaches B's return: emits 'return_out'
+ *    inter edge: B.return → A's capture local (if any)
+ */
+function buildInterproceduralStitch(db, candidates, captures) {
+    if (candidates.length === 0)
+        return 0;
+    const getParamVertex = db.prepare(`SELECT id FROM dataflow_vertices WHERE func_id = ? AND kind = 'param' AND param_index = ? LIMIT 1`);
+    const getLocalVertex = db.prepare(`SELECT id FROM dataflow_vertices WHERE func_id = ? AND kind = 'local' AND name = ? LIMIT 1`);
+    const getReturnVertex = db.prepare(`SELECT id FROM dataflow_vertices WHERE func_id = ? AND kind = 'return' LIMIT 1`);
+    const getCallEdge = db.prepare(`SELECT id FROM edges WHERE source_id = ? AND target_id = ? AND kind = 'calls' LIMIT 1`);
+    const getSummary = db.prepare(`SELECT flows_to_return FROM dataflow_summary WHERE func_id = ? AND param_index = ?`);
+    const insertInterEdge = db.prepare(`INSERT INTO dataflow
+       (source_id, target_id, kind, source_vertex, target_vertex, scope, call_edge_id, expression, line, confidence)
+     VALUES (?, ?, ?, ?, ?, 'inter', ?, ?, ?, ?)`);
+    // Build capture map: "callerFuncId:calleeFuncId" → varName (first match wins)
+    const captureMap = new Map();
+    for (const cap of captures) {
+        const key = `${cap.callerFuncId}:${cap.calleeFuncId}`;
+        if (!captureMap.has(key))
+            captureMap.set(key, cap.varName);
+    }
+    let count = 0;
+    const tx = db.transaction(() => {
+        for (const cand of candidates) {
+            // Resolve call edge for this site
+            const callEdge = getCallEdge.get(cand.callerFuncId, cand.calleeFuncId);
+            const callEdgeId = callEdge?.id ?? null;
+            // Find source vertex x in caller
+            let srcVertexId = null;
+            if (cand.bindingType === 'param' && cand.bindingIndex != null) {
+                const v = getParamVertex.get(cand.callerFuncId, cand.bindingIndex);
+                srcVertexId = v?.id ?? null;
+            }
+            else if (cand.bindingType === 'local') {
+                const v = getLocalVertex.get(cand.callerFuncId, cand.argName);
+                srcVertexId = v?.id ?? null;
+            }
+            if (!srcVertexId)
+                continue;
+            // Find callee's param[argIndex] vertex
+            const calleeParam = getParamVertex.get(cand.calleeFuncId, cand.argIndex);
+            if (!calleeParam)
+                continue;
+            // arg_in: A's source → B.param[j]
+            insertInterEdge.run(cand.callerFuncId, cand.calleeFuncId, 'arg_in', srcVertexId, calleeParam.id, callEdgeId, cand.expression, cand.line, cand.confidence);
+            count++;
+            // return_out: if B.param[j] reaches B's return, emit B.return → A's capture
+            const summary = getSummary.get(cand.calleeFuncId, cand.argIndex);
+            if (summary?.flows_to_return) {
+                const calleeReturn = getReturnVertex.get(cand.calleeFuncId);
+                if (calleeReturn) {
+                    const captureVarName = captureMap.get(`${cand.callerFuncId}:${cand.calleeFuncId}`);
+                    const captureVertex = captureVarName
+                        ? getLocalVertex.get(cand.callerFuncId, captureVarName)
+                        : null;
+                    if (captureVertex) {
+                        insertInterEdge.run(cand.calleeFuncId, cand.callerFuncId, 'return_out', calleeReturn.id, captureVertex.id, callEdgeId, cand.expression, cand.line, cand.confidence);
+                        count++;
+                    }
+                }
+            }
+        }
+    });
+    tx();
+    return count;
+}
+// ── buildDataflowEdges ──────────────────────────────────────────────────────
+// ── P4 helpers ───────────────────────────────────────────────────────────────
+/** Return IDs of all function/method nodes in the given relative file paths. */
+export function collectFuncIdsForFiles(db, relPaths) {
+    const stmt = db.prepare(`SELECT id FROM nodes WHERE file = ? AND kind IN ('function', 'method')`);
+    const ids = [];
+    for (const p of relPaths) {
+        for (const row of stmt.all(p))
+            ids.push(row.id);
+    }
+    return ids;
+}
+/**
+ * P4: Re-collect stitch candidates from caller files that were NOT in the
+ * changed set but contain calls to functions that WERE changed.
+ *
+ * During an incremental build the changed files' param vertices are purged
+ * and recreated, but the callers' files are never re-parsed — so their
+ * arg_in edges (pointing to the old param vertices) are deleted and never
+ * replaced. This function reads those caller files from disk and rebuilds
+ * the StitchCandidate list so buildInterproceduralStitch can reconnect them.
+ */
+export async function collectCallerStitchCandidates(db, changedFuncIds, changedRelPaths, rootDir, extToLang, parsers, getParserFn) {
+    if (changedFuncIds.length === 0)
+        return { candidates: [], captures: [] };
+    // Find distinct caller files that have flows_to edges targeting any changed
+    // function and are NOT already in the changed file set (those are handled by
+    // the main per-file loop).
+    //
+    // Chunk the query to avoid exceeding SQLite's SQLITE_MAX_VARIABLE_NUMBER
+    // (999 on older builds, 32766 on SQLite ≥ 3.32).  500 is a safe batch size
+    // that works across all SQLite versions.
+    const CHUNK_SIZE = 500;
+    const callerFileSet = new Set();
+    for (let i = 0; i < changedFuncIds.length; i += CHUNK_SIZE) {
+        const chunk = changedFuncIds.slice(i, i + CHUNK_SIZE);
+        const placeholders = chunk.map(() => '?').join(',');
+        const rows = db
+            .prepare(`SELECT DISTINCT n.file AS caller_file
+         FROM dataflow d
+         JOIN nodes n ON n.id = d.source_id
+         WHERE d.target_id IN (${placeholders})
+           AND d.kind = 'flows_to'`)
+            .all(...chunk);
+        for (const r of rows)
+            callerFileSet.add(r.caller_file);
+    }
+    const callerFileRows = [...callerFileSet].map((f) => ({ caller_file: f }));
+    const callerFiles = callerFileRows
+        .map((r) => r.caller_file)
+        .filter((f) => !changedRelPaths.has(f));
+    if (callerFiles.length === 0)
+        return { candidates: [], captures: [] };
+    // Ensure parsers are available — the main loop may have skipped loading them
+    // if all changed files came through the native bulk-insert path.
+    let activeParsers = parsers;
+    let activeGetParserFn = getParserFn;
+    if (!activeGetParserFn) {
+        const { createParsers, getParser } = await import('../domain/parser.js');
+        activeParsers = await createParsers();
+        activeGetParserFn = getParser;
+    }
+    const changedFuncIdSet = new Set(changedFuncIds);
+    const stmts = prepareNodeResolvers(db);
+    const candidates = [];
+    const captures = [];
+    for (const callerFile of callerFiles) {
+        // Read the caller file from disk without touching its existing DB rows.
+        // definitions: [] is an intentional stub — P4 only needs argFlow/assignment
+        // data from the visitor, not pre-loaded symbol definitions.  extractDataflow
+        // does not currently use _definitions, so this is safe.  If that changes,
+        // the stub must be replaced with the actual symbol list for the caller file.
+        const stub = { definitions: [], _langId: null, _tree: null };
+        const data = getDataflowForFile(stub, callerFile, rootDir, extToLang, activeParsers, activeGetParserFn);
+        if (!data)
+            continue;
+        const resolver = makeNodeResolver(stmts, callerFile);
+        const argFlows = data.argFlows;
+        const assignments = data.assignments;
+        for (const af of argFlows) {
+            const callerFn = resolver(af.callerFunc);
+            const calleeFn = resolver(af.calleeName);
+            if (!callerFn || !calleeFn)
+                continue;
+            if (!changedFuncIdSet.has(calleeFn.id))
+                continue; // only re-stitch calls to changed callees
+            candidates.push({
+                callerFuncId: callerFn.id,
+                calleeFuncId: calleeFn.id,
+                argIndex: af.argIndex,
+                bindingType: af.binding.type,
+                bindingIndex: af.binding.index,
+                argName: af.argName,
+                expression: af.expression,
+                line: af.line,
+                confidence: af.confidence,
+            });
+        }
+        for (const a of assignments) {
+            const callerFn = resolver(a.callerFunc);
+            const calleeFn = resolver(a.sourceCallName);
+            if (!callerFn || !calleeFn)
+                continue;
+            if (!changedFuncIdSet.has(calleeFn.id))
+                continue;
+            captures.push({ callerFuncId: callerFn.id, calleeFuncId: calleeFn.id, varName: a.varName });
+        }
+    }
+    debug(`Dataflow P4: re-stitched ${candidates.length} candidate(s) from ${callerFiles.length} caller file(s)`);
+    return { candidates, captures };
+}
+function prepareNodeResolvers(db) {
+    return {
+        getNodeByNameAndFile: db.prepare(`SELECT id, name, kind, file, line FROM nodes
+       WHERE name = ? AND file = ? AND kind IN ('function', 'method')`),
+        getNodeByName: db.prepare(`SELECT id, name, kind, file, line FROM nodes
+       WHERE name = ? AND kind IN ('function', 'method')
+       ORDER BY file, line LIMIT 10`),
+    };
+}
+function makeNodeResolver(stmts, relPath) {
+    return (funcName) => {
+        const local = stmts.getNodeByNameAndFile.all(funcName, relPath);
+        if (local.length > 0)
+            return local[0];
+        const global = stmts.getNodeByName.all(funcName);
+        return global.length > 0 ? global[0] : null;
+    };
+}
+function collectNativeEdges(data, resolveNode, edges) {
+    for (const flow of data.argFlows) {
+        const sourceNode = resolveNode(flow.callerFunc);
+        const targetNode = resolveNode(flow.calleeName);
+        if (sourceNode && targetNode) {
+            edges.push({
+                sourceId: sourceNode.id,
+                targetId: targetNode.id,
+                kind: 'flows_to',
+                paramIndex: flow.argIndex,
+                expression: flow.expression,
+                line: flow.line,
+                confidence: flow.confidence,
+            });
+        }
+    }
+    for (const assignment of data.assignments) {
+        const producerNode = resolveNode(assignment.sourceCallName);
+        const consumerNode = resolveNode(assignment.callerFunc);
+        if (producerNode && consumerNode) {
+            edges.push({
+                sourceId: producerNode.id,
+                targetId: consumerNode.id,
+                kind: 'returns',
+                paramIndex: undefined,
+                expression: assignment.expression,
+                line: assignment.line,
+                confidence: 1.0,
+            });
+        }
+    }
+    for (const mut of data.mutations) {
+        const mutatorNode = resolveNode(mut.funcName);
+        if (mutatorNode && mut.binding?.type === 'param') {
+            edges.push({
+                sourceId: mutatorNode.id,
+                targetId: mutatorNode.id,
+                kind: 'mutates',
+                paramIndex: undefined,
+                expression: mut.mutatingExpr,
+                line: mut.line,
+                confidence: 1.0,
+            });
+        }
+    }
+}
+/**
+ * P6 vertex-only pass for the native orchestrator path.
+ *
+ * When the Rust orchestrator runs with analysisComplete=true it inserts
+ * flows_to/returns/mutates edges directly into the DB but never writes to
+ * dataflow_vertices or dataflow_summary. This function takes pre-extracted
+ * DataflowResult objects (from native.extractDataflowAnalysis) and builds
+ * the missing vertex rows and inter-procedural edges — without touching the
+ * already-correct function-level edges.
+ */
+export function buildDataflowVerticesFromMap(db, dataflowMap, extraCandidates, extraCaptures) {
+    const vstmts = prepareVertexStmts(db);
+    if (!vstmts.available || dataflowMap.size === 0)
+        return 0;
+    const stmts = prepareNodeResolvers(db);
+    const allCandidates = [];
+    const allCaptures = [];
+    const tx = db.transaction(() => {
+        for (const [relPath, data] of dataflowMap) {
+            const resolver = makeNodeResolver(stmts, relPath);
+            const { candidates, captures } = buildDataflowVerticesAndEdges(db, vstmts, data, resolver);
+            allCandidates.push(...candidates);
+            allCaptures.push(...captures);
+        }
+    });
+    tx();
+    // P4: merge in stitch candidates from unchanged caller files if provided.
+    if (extraCandidates && extraCandidates.length > 0)
+        allCandidates.push(...extraCandidates);
+    if (extraCaptures && extraCaptures.length > 0)
+        allCaptures.push(...extraCaptures);
+    return buildInterproceduralStitch(db, allCandidates, allCaptures);
+}
+/**
+ * P4 re-stitch pass for the native engine path.
+ *
+ * On incremental builds the changed files' param vertices are purged and
+ * recreated by the P6 vertex pass, but unchanged caller files are never
+ * re-parsed — so their arg_in edges (which pointed to the old param vertex
+ * IDs) are deleted and not replaced. This function re-parses those caller
+ * files and rebuilds the arg_in edges for any call that targets a function
+ * in one of the changed callee files.
+ *
+ * Called by the native orchestrator after buildDataflowVerticesFromMap.
+ * Safe to call on full builds — the guard below exits early when
+ * changedFiles covers all distinct files in the DB.
+ */
+export async function buildDataflowP4ForNative(db, changedFiles, rootDir) {
+    if (changedFiles.length === 0)
+        return;
+    // Deduplicate upfront so the full-build guard uses unique-file count, not
+    // raw array length (the orchestrator may emit the same path more than once).
+    const changedRelPaths = new Set(changedFiles);
+    // Skip on full builds — all files were in the changed set, so there are no
+    // unchanged callers to re-stitch.
+    const totalFilesInDb = db.prepare(`SELECT COUNT(DISTINCT file) AS n FROM nodes`).get().n;
+    if (changedRelPaths.size >= totalFilesInDb)
+        return;
+    const extToLang = buildExtToLangMap();
+    const changedFuncIds = collectFuncIdsForFiles(db, changedRelPaths);
+    if (changedFuncIds.length === 0)
+        return;
+    // parsers=null, getParserFn=null → collectCallerStitchCandidates initialises
+    // WASM parsers lazily for the caller files it needs to re-parse.
+    const { candidates, captures } = await collectCallerStitchCandidates(db, changedFuncIds, changedRelPaths, rootDir, extToLang, null, null);
+    if (candidates.length > 0) {
+        // Purge any existing arg_in edges targeting the changed callees from unchanged
+        // caller files. These edges were inserted by a previous P4 pass. Without this
+        // guard, repeated calls to buildDataflowP4ForNative insert duplicates because
+        // the dataflow table has no UNIQUE constraint on (source_vertex, target_vertex).
+        const placeholders = changedFuncIds.map(() => '?').join(',');
+        db.prepare(`DELETE FROM dataflow
+       WHERE kind = 'arg_in'
+         AND target_id IN (${placeholders})
+         AND source_id NOT IN (${placeholders})`).run(...changedFuncIds, ...changedFuncIds);
+        const count = buildInterproceduralStitch(db, candidates, captures);
+        if (count > 0) {
+            info(`Dataflow (native P4): ${count} inter-procedural edges re-stitched`);
+        }
+    }
+}
+export async function buildDataflowEdges(db, fileSymbols, rootDir, engineOpts) {
+    const extToLang = buildExtToLangMap();
+    // ── Native bulk-insert fast path ──────────────────────────────────────
+    const nativeDb = engineOpts?.nativeDb;
+    if (nativeDb?.bulkInsertDataflow) {
+        let needsJsFallback = false;
+        const nativeEdges = [];
+        const stmts = prepareNodeResolvers(db);
+        for (const [relPath, symbols] of fileSymbols) {
+            const ext = path.extname(relPath).toLowerCase();
+            if (!DATAFLOW_EXTENSIONS.has(ext))
+                continue;
+            if (!symbols.dataflow) {
+                needsJsFallback = true;
+                break;
+            }
+            collectNativeEdges(symbols.dataflow, makeNodeResolver(stmts, relPath), nativeEdges);
+        }
+        if (!needsJsFallback) {
+            if (nativeEdges.length > 0) {
+                let inserted;
+                try {
+                    engineOpts?.suspendJsDb?.();
+                    inserted = nativeDb.bulkInsertDataflow(nativeEdges);
+                }
+                finally {
+                    engineOpts?.resumeJsDb?.();
+                }
+                info(`Dataflow (native bulk): ${inserted} edges inserted`);
+            }
+            // P6: vertex extraction on the native path.
+            // Rust DataflowResult already contains parameters/returns — no re-parse needed.
+            const vstmts = prepareVertexStmts(db);
+            if (vstmts.available) {
+                const allCandidates = [];
+                const allCaptures = [];
+                const txVertex = db.transaction(() => {
+                    for (const [relPath, symbols] of fileSymbols) {
+                        if (!symbols.dataflow)
+                            continue;
+                        const ext = path.extname(relPath).toLowerCase();
+                        if (!DATAFLOW_EXTENSIONS.has(ext))
+                            continue;
+                        const resolver = makeNodeResolver(stmts, relPath);
+                        const { candidates, captures } = buildDataflowVerticesAndEdges(db, vstmts, symbols.dataflow, resolver);
+                        allCandidates.push(...candidates);
+                        allCaptures.push(...captures);
+                    }
+                });
+                txVertex();
+                // P4: Incremental re-stitch — unchanged caller files are not in
+                // fileSymbols so their arg_in edges to the old param vertices were
+                // deleted by the purge and never recreated. Re-collect stitch
+                // candidates from those caller files by parsing them from disk.
+                //
+                // Skip on full builds: fileSymbols covers every file in the DB, so
+                // there are no unchanged callers to re-stitch.
+                const totalFilesInDb = db.prepare(`SELECT COUNT(DISTINCT file) AS n FROM nodes`).get().n;
+                let p4CallerCount = 0;
+                if (fileSymbols.size < totalFilesInDb) {
+                    const changedRelPaths = new Set(fileSymbols.keys());
+                    const changedFuncIds = collectFuncIdsForFiles(db, changedRelPaths);
+                    const extra = await collectCallerStitchCandidates(db, changedFuncIds, changedRelPaths, rootDir, extToLang, null, null);
+                    allCandidates.push(...extra.candidates);
+                    allCaptures.push(...extra.captures);
+                    p4CallerCount = extra.candidates.length;
+                }
+                const interCount = buildInterproceduralStitch(db, allCandidates, allCaptures);
+                info(`Dataflow (native): ${interCount} inter-procedural edges inserted${p4CallerCount > 0 ? ` (P4: ${p4CallerCount} re-stitch candidate(s) from unchanged callers)` : ''}`);
+            }
+            return;
+        }
+        debug('Dataflow: some files lack pre-computed data — falling back to JS');
+    }
+    // ── JS fallback path ─────────────────────────────────────────────────
+    const { parsers, getParserFn } = await initDataflowParsers(fileSymbols);
+    const insert = db.prepare(`INSERT INTO dataflow (source_id, target_id, kind, param_index, expression, line, confidence)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`);
+    const stmts = prepareNodeResolvers(db);
+    const vstmts = prepareVertexStmts(db);
+    let totalEdges = 0;
+    const allCandidates = [];
+    const allCaptures = [];
+    const tx = db.transaction(() => {
+        for (const [relPath, symbols] of fileSymbols) {
+            const ext = path.extname(relPath).toLowerCase();
+            if (!DATAFLOW_EXTENSIONS.has(ext))
+                continue;
+            const data = getDataflowForFile(symbols, relPath, rootDir, extToLang, parsers, getParserFn);
+            if (!data)
+                continue;
+            const resolver = makeNodeResolver(stmts, relPath);
+            totalEdges += insertDataflowEdges(insert, data, resolver);
+            const { candidates, captures } = buildDataflowVerticesAndEdges(db, vstmts, data, resolver);
+            allCandidates.push(...candidates);
+            allCaptures.push(...captures);
+        }
+    });
+    tx();
+    // P4: Incremental re-stitch — if only a subset of files changed, callers of
+    // the changed functions were not in fileSymbols, so their arg_in edges were
+    // deleted by the purge but never reconstructed. Re-collect stitch candidates
+    // from those caller files now (read from disk, no DB writes).
+    //
+    // Skip P4 on full builds: when fileSymbols covers every file in the DB there
+    // are no unchanged callers, and collectFuncIdsForFiles would issue one SELECT
+    // per file for nothing.  A single COUNT query is cheaper than N per-file SELECTs.
+    const totalFilesInDb = db.prepare(`SELECT COUNT(DISTINCT file) AS n FROM nodes`).get().n;
+    if (vstmts.available && fileSymbols.size < totalFilesInDb) {
+        const changedRelPaths = new Set(fileSymbols.keys());
+        const changedFuncIds = collectFuncIdsForFiles(db, changedRelPaths);
+        const extra = await collectCallerStitchCandidates(db, changedFuncIds, changedRelPaths, rootDir, extToLang, parsers, getParserFn);
+        allCandidates.push(...extra.candidates);
+        allCaptures.push(...extra.captures);
+    }
+    // P2: inter-procedural stitch — runs after all per-file vertices + summaries committed
+    const interCount = vstmts.available
+        ? buildInterproceduralStitch(db, allCandidates, allCaptures)
+        : 0;
+    info(`Dataflow: ${totalEdges} fn-level edges, ${interCount} inter-procedural edges inserted`);
+}
+function prepareDataflowStmts(db) {
+    return {
+        flowsToOut: db.prepare(`SELECT d.*, n.name AS target_name, n.kind AS target_kind, n.file AS target_file, n.line AS target_line
+     FROM dataflow d JOIN nodes n ON d.target_id = n.id
+     WHERE d.source_id = ? AND d.kind = 'flows_to'`),
+        flowsToIn: db.prepare(`SELECT d.*, n.name AS source_name, n.kind AS source_kind, n.file AS source_file, n.line AS source_line
+     FROM dataflow d JOIN nodes n ON d.source_id = n.id
+     WHERE d.target_id = ? AND d.kind = 'flows_to'`),
+        returnsOut: db.prepare(`SELECT d.*, n.name AS target_name, n.kind AS target_kind, n.file AS target_file, n.line AS target_line
+     FROM dataflow d JOIN nodes n ON d.target_id = n.id
+     WHERE d.source_id = ? AND d.kind = 'returns'`),
+        returnsIn: db.prepare(`SELECT d.*, n.name AS source_name, n.kind AS source_kind, n.file AS source_file, n.line AS source_line
+     FROM dataflow d JOIN nodes n ON d.source_id = n.id
+     WHERE d.target_id = ? AND d.kind = 'returns'`),
+        mutatesOut: db.prepare(`SELECT d.*, n.name AS target_name, n.kind AS target_kind, n.file AS target_file, n.line AS target_line
+     FROM dataflow d JOIN nodes n ON d.target_id = n.id
+     WHERE d.source_id = ? AND d.kind = 'mutates'`),
+        mutatesIn: db.prepare(`SELECT d.*, n.name AS source_name, n.kind AS source_kind, n.file AS source_file, n.line AS source_line
+     FROM dataflow d JOIN nodes n ON d.source_id = n.id
+     WHERE d.target_id = ? AND d.kind = 'mutates'`),
+    };
+}
+/**
+ * Build a unified dataflow result from pre-mapped edge data.
+ * Shared between the SQL and native code paths.
+ */
+function buildDataflowResult(sym, edges, noTests) {
+    if (noTests) {
+        const filter = (arr) => arr.filter((r) => !isTestFile(r.file));
+        return {
+            ...sym,
+            flowsTo: filter(edges.flowsTo),
+            flowsFrom: filter(edges.flowsFrom),
+            returns: edges.returnConsumers.filter((r) => !isTestFile(r.file)),
+            returnedBy: edges.returnedBy.filter((r) => !isTestFile(r.file)),
+            mutates: edges.mutatesTargets,
+            mutatedBy: edges.mutatedBy,
+        };
+    }
+    return {
+        ...sym,
+        flowsTo: edges.flowsTo,
+        flowsFrom: edges.flowsFrom,
+        returns: edges.returnConsumers,
+        returnedBy: edges.returnedBy,
+        mutates: edges.mutatesTargets,
+        mutatedBy: edges.mutatedBy,
+    };
+}
+function buildNodeDataflowResult(node, stmts, db, hc, noTests) {
+    const sym = normalizeSymbol(node, db, hc);
+    const edges = {
+        flowsTo: stmts.flowsToOut.all(node.id).map((r) => ({
+            target: r.target_name,
+            kind: r.target_kind,
+            file: r.target_file,
+            line: r.line,
+            paramIndex: r.param_index,
+            expression: r.expression,
+            confidence: r.confidence,
+        })),
+        flowsFrom: stmts.flowsToIn.all(node.id).map((r) => ({
+            source: r.source_name,
+            kind: r.source_kind,
+            file: r.source_file,
+            line: r.line,
+            paramIndex: r.param_index,
+            expression: r.expression,
+            confidence: r.confidence,
+        })),
+        returnConsumers: stmts.returnsOut.all(node.id).map((r) => ({
+            consumer: r.target_name,
+            kind: r.target_kind,
+            file: r.target_file,
+            line: r.line,
+            expression: r.expression,
+        })),
+        returnedBy: stmts.returnsIn.all(node.id).map((r) => ({
+            producer: r.source_name,
+            kind: r.source_kind,
+            file: r.source_file,
+            line: r.line,
+            expression: r.expression,
+        })),
+        mutatesTargets: stmts.mutatesOut.all(node.id).map((r) => ({
+            target: r.target_name,
+            expression: r.expression,
+            line: r.line,
+        })),
+        mutatedBy: stmts.mutatesIn.all(node.id).map((r) => ({
+            source: r.source_name,
+            expression: r.expression,
+            line: r.line,
+        })),
+    };
+    return buildDataflowResult(sym, edges, noTests);
+}
+function buildNativeDataflowResult(node, nativeDb, db, hc, noTests) {
+    const sym = normalizeSymbol(node, db, hc);
+    const d = nativeDb.getDataflowEdges(node.id);
+    const edges = {
+        flowsTo: d.flowsToOut.map((r) => ({
+            target: r.name,
+            kind: r.kind,
+            file: r.file,
+            line: r.line,
+            paramIndex: r.paramIndex,
+            expression: r.expression,
+            confidence: r.confidence,
+        })),
+        flowsFrom: d.flowsToIn.map((r) => ({
+            source: r.name,
+            kind: r.kind,
+            file: r.file,
+            line: r.line,
+            paramIndex: r.paramIndex,
+            expression: r.expression,
+            confidence: r.confidence,
+        })),
+        returnConsumers: d.returnsOut.map((r) => ({
+            consumer: r.name,
+            kind: r.kind,
+            file: r.file,
+            line: r.line,
+            expression: r.expression,
+        })),
+        returnedBy: d.returnsIn.map((r) => ({
+            producer: r.name,
+            kind: r.kind,
+            file: r.file,
+            line: r.line,
+            expression: r.expression,
+        })),
+        mutatesTargets: d.mutatesOut.map((r) => ({
+            target: r.name,
+            expression: r.expression,
+            line: r.line,
+        })),
+        mutatedBy: d.mutatesIn.map((r) => ({
+            source: r.name,
+            expression: r.expression,
+            line: r.line,
+        })),
+    };
+    return buildDataflowResult(sym, edges, noTests);
+}
+export function dataflowData(name, customDbPath, opts = {}) {
+    const { db, nativeDb, close } = openReadonlyWithNative(customDbPath);
+    try {
+        const noTests = opts.noTests || false;
+        if (!hasDataflowTable(db)) {
+            return {
+                name,
+                results: [],
+                warning: 'No dataflow data found. Rebuild with `codegraph build` (dataflow is now included by default).',
+            };
+        }
+        const nodes = findNodes(db, name, { noTests, file: opts.file, kind: opts.kind }, ALL_SYMBOL_KINDS);
+        if (nodes.length === 0) {
+            return { name, results: [] };
+        }
+        // ── Native fast path: 6 queries per node → 1 napi call per node ──
+        if (nativeDb?.getDataflowEdges) {
+            const hc = new Map();
+            const results = nodes.map((node) => buildNativeDataflowResult(node, nativeDb, db, hc, noTests));
+            const base = { name, results };
+            return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+        }
+        // ── JS fallback ───────────────────────────────────────────────────
+        const stmts = prepareDataflowStmts(db);
+        const hc = new Map();
+        const results = nodes.map((node) => buildNodeDataflowResult(node, stmts, db, hc, noTests));
+        const base = { name, results };
+        return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+    }
+    finally {
+        close();
+    }
+}
+/**
+ * Process a single neighbor in the dataflow BFS. Returns true once the target
+ * has been reached so the caller can stop expanding.
+ */
+function processDataflowNeighbor(n, currentId, targetId, noTests, state) {
+    if (noTests && isTestFile(n.file))
+        return false;
+    const entry = {
+        parentId: currentId,
+        edgeKind: n.edge_kind,
+        expression: n.expression,
+    };
+    if (n.id === targetId) {
+        if (!state.found) {
+            state.found = true;
+            state.parent.set(n.id, entry);
+        }
+        return true;
+    }
+    if (state.visited.has(n.id))
+        return false;
+    state.visited.add(n.id);
+    state.parent.set(n.id, entry);
+    state.nextQueue.push(n.id);
+    return false;
+}
+/** BFS through dataflow edges to find a path from source to target. */
+function bfsDataflowPath(db, sourceId, targetId, maxDepth, noTests) {
+    const neighborStmt = db.prepare(`SELECT n.id, n.name, n.kind, n.file, n.line, d.kind AS edge_kind, d.expression
+     FROM dataflow d JOIN nodes n ON d.target_id = n.id
+     WHERE d.source_id = ? AND d.kind IN ('flows_to', 'returns')`);
+    const state = {
+        visited: new Set([sourceId]),
+        parent: new Map(),
+        nextQueue: [],
+        found: false,
+    };
+    let queue = [sourceId];
+    for (let depth = 1; depth <= maxDepth; depth++) {
+        state.nextQueue = [];
+        for (const currentId of queue) {
+            const neighbors = neighborStmt.all(currentId);
+            for (const n of neighbors) {
+                processDataflowNeighbor(n, currentId, targetId, noTests, state);
+            }
+        }
+        if (state.found)
+            break;
+        queue = state.nextQueue;
+        if (queue.length === 0)
+            break;
+    }
+    return state.found ? state.parent : null;
+}
+/** Reconstruct a path from BFS parent map. */
+function reconstructDataflowPath(db, parent, sourceId, targetId) {
+    const nodeById = db.prepare('SELECT * FROM nodes WHERE id = ?');
+    const hc = new Map();
+    const pathItems = [];
+    let cur = targetId;
+    while (cur !== undefined) {
+        const nodeRow = nodeById.get(cur);
+        const parentInfo = parent.get(cur);
+        pathItems.unshift({
+            ...normalizeSymbol(nodeRow, db, hc),
+            edgeKind: parentInfo?.edgeKind ?? null,
+            expression: parentInfo?.expression ?? null,
+        });
+        cur = parentInfo?.parentId;
+        if (cur === sourceId) {
+            const srcRow = nodeById.get(cur);
+            pathItems.unshift({
+                ...normalizeSymbol(srcRow, db, hc),
+                edgeKind: null,
+                expression: null,
+            });
+            break;
+        }
+    }
+    return pathItems;
+}
+export function dataflowPathData(from, to, customDbPath, opts = {}) {
+    const db = openReadonlyOrFail(customDbPath);
+    try {
+        const noTests = opts.noTests || false;
+        const maxDepth = opts.maxDepth || 10;
+        if (!hasDataflowTable(db)) {
+            return {
+                from,
+                to,
+                found: false,
+                warning: 'No dataflow data found. Rebuild with `codegraph build` (dataflow is now included by default).',
+            };
+        }
+        const fromNodes = findNodes(db, from, { noTests, file: opts.fromFile, kind: opts.kind }, ALL_SYMBOL_KINDS);
+        if (fromNodes.length === 0) {
+            return { from, to, found: false, error: `No symbol matching "${from}"` };
+        }
+        const toNodes = findNodes(db, to, { noTests, file: opts.toFile, kind: opts.kind }, ALL_SYMBOL_KINDS);
+        if (toNodes.length === 0) {
+            return { from, to, found: false, error: `No symbol matching "${to}"` };
+        }
+        const sourceNode = fromNodes[0];
+        const targetNode = toNodes[0];
+        if (sourceNode.id === targetNode.id) {
+            const hc = new Map();
+            const sym = normalizeSymbol(sourceNode, db, hc);
+            return { from, to, found: true, hops: 0, path: [{ ...sym, edgeKind: null }] };
+        }
+        const parent = bfsDataflowPath(db, sourceNode.id, targetNode.id, maxDepth, noTests);
+        if (!parent) {
+            return { from, to, found: false };
+        }
+        const pathItems = reconstructDataflowPath(db, parent, sourceNode.id, targetNode.id);
+        return { from, to, found: true, hops: pathItems.length - 1, path: pathItems };
+    }
+    finally {
+        db.close();
+    }
+}
+/** BFS forward through return-value consumers to build impact levels. */
+function bfsReturnConsumers(node, consumersStmt, db, hc, maxDepth, noTests) {
+    const visited = new Set([node.id]);
+    const levels = {};
+    let frontier = [node.id];
+    for (let d = 1; d <= maxDepth; d++) {
+        const nextFrontier = [];
+        for (const fid of frontier) {
+            const consumers = consumersStmt.all(fid);
+            for (const c of consumers) {
+                if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
+                    visited.add(c.id);
+                    nextFrontier.push(c.id);
+                    if (!levels[d])
+                        levels[d] = [];
+                    levels[d].push(normalizeSymbol(c, db, hc));
+                }
+            }
+        }
+        frontier = nextFrontier;
+        if (frontier.length === 0)
+            break;
+    }
+    return { levels, totalAffected: visited.size - 1 };
+}
+export function dataflowImpactData(name, customDbPath, opts = {}) {
+    const db = openReadonlyOrFail(customDbPath);
+    try {
+        const maxDepth = opts.depth || 5;
+        const noTests = opts.noTests || false;
+        if (!hasDataflowTable(db)) {
+            return {
+                name,
+                results: [],
+                warning: 'No dataflow data found. Rebuild with `codegraph build` (dataflow is now included by default).',
+            };
+        }
+        const nodes = findNodes(db, name, { noTests, file: opts.file, kind: opts.kind }, ALL_SYMBOL_KINDS);
+        if (nodes.length === 0) {
+            return { name, results: [] };
+        }
+        const consumersStmt = db.prepare(`SELECT DISTINCT n.*
+     FROM dataflow d JOIN nodes n ON d.target_id = n.id
+     WHERE d.source_id = ? AND d.kind = 'returns'`);
+        const hc = new Map();
+        const results = nodes.map((node) => {
+            const sym = normalizeSymbol(node, db, hc);
+            const { levels, totalAffected } = bfsReturnConsumers(node, consumersStmt, db, hc, maxDepth, noTests);
+            return { ...sym, levels, totalAffected };
+        });
+        const base = { name, results };
+        return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+    }
+    finally {
+        db.close();
+    }
+}
+//# sourceMappingURL=dataflow.js.map