@optave/codegraph 3.1.5 → 3.2.0

package/src/features/dataflow.js

@@ -21,9 +21,10 @@ import { walkWithVisitors } from '../ast-analysis/visitor.js';
 import { createDataflowVisitor } from '../ast-analysis/visitors/dataflow-visitor.js';
 import { hasDataflowTable, openReadonlyOrFail } from '../db/index.js';
 import { ALL_SYMBOL_KINDS, normalizeSymbol } from '../domain/queries.js';
-import { info } from '../infrastructure/logger.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 };
@@ -57,26 +58,11 @@ export function extractDataflow(tree, _filePath, _definitions, langId = 'javascr
   return results.dataflow;
 }
 
-// ── buildDataflowEdges ──────────────────────────────────────────────────────
+// ── Build-Time Helpers ──────────────────────────────────────────────────────
 
-/**
- * Build dataflow edges and insert them into the database.
- * Called during graph build when --dataflow is enabled.
- *
- * @param {object} db - better-sqlite3 database instance
- * @param {Map<string, object>} fileSymbols - map of relPath → symbols
- * @param {string} rootDir - absolute root directory
- * @param {object} engineOpts - engine options
- */
-export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts) {
-  // Lazily init WASM parsers if needed
-  let parsers = null;
+async function initDataflowParsers(fileSymbols) {
   let needsFallback = false;
 
-  // Always build ext→langId map so native-only builds (where _langId is unset)
-  // can still derive the language from the file extension.
-  const extToLang = buildExtToLangMap();
-
   for (const [relPath, symbols] of fileSymbols) {
     if (!symbols._tree && !symbols.dataflow) {
       const ext = path.extname(relPath).toLowerCase();
@@ -87,25 +73,130 @@ export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts)
     }
   }
 
+  let parsers = null;
+  let getParserFn = null;
+
   if (needsFallback) {
     const { createParsers } = await import('../domain/parser.js');
     parsers = await createParsers();
-  }
-
-  let getParserFn = null;
-  if (parsers) {
     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;
+}
+
+// ── buildDataflowEdges ──────────────────────────────────────────────────────
+
+/**
+ * Build dataflow edges and insert them into the database.
+ * Called during graph build when --dataflow is enabled.
+ *
+ * @param {object} db - better-sqlite3 database instance
+ * @param {Map<string, object>} fileSymbols - map of relPath → symbols
+ * @param {string} rootDir - absolute root directory
+ * @param {object} engineOpts - engine options
+ */
+export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts) {
+  const extToLang = buildExtToLangMap();
+  const { parsers, getParserFn } = await initDataflowParsers(fileSymbols);
+
   const insert = db.prepare(
     `INSERT INTO dataflow (source_id, target_id, kind, param_index, expression, line, confidence)
      VALUES (?, ?, ?, ?, ?, ?, ?)`,
   );
 
-  // MVP scope: only resolve function/method nodes for dataflow edges.
-  // Future expansion: add 'parameter', 'property', 'constant' kinds to track
-  // data flow through property accessors or constant references.
   const getNodeByNameAndFile = db.prepare(
     `SELECT id, name, kind, file, line FROM nodes
      WHERE name = ? AND file = ? AND kind IN ('function', 'method')`,
@@ -124,107 +215,17 @@ export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts)
       const ext = path.extname(relPath).toLowerCase();
       if (!DATAFLOW_EXTENSIONS.has(ext)) continue;
 
-      // Use native dataflow data if available — skip WASM extraction
-      let data = symbols.dataflow;
-      if (!data) {
-        let tree = symbols._tree;
-        let langId = symbols._langId;
-
-        // WASM fallback if no cached tree
-        if (!tree) {
-          if (!getParserFn) continue;
-          langId = extToLang.get(ext);
-          if (!langId || !DATAFLOW_RULES.has(langId)) continue;
-
-          const absPath = path.join(rootDir, relPath);
-          let code;
-          try {
-            code = fs.readFileSync(absPath, 'utf-8');
-          } catch {
-            continue;
-          }
-
-          const parser = getParserFn(parsers, absPath);
-          if (!parser) continue;
-
-          try {
-            tree = parser.parse(code);
-          } catch {
-            continue;
-          }
-        }
-
-        if (!langId) {
-          langId = extToLang.get(ext);
-          if (!langId) continue;
-        }
-
-        if (!DATAFLOW_RULES.has(langId)) continue;
+      const data = getDataflowForFile(symbols, relPath, rootDir, extToLang, parsers, getParserFn);
+      if (!data) continue;
 
-        data = extractDataflow(tree, relPath, symbols.definitions, langId);
-      }
-
-      // Resolve function names to node IDs in this file first, then globally
-      function resolveNode(funcName) {
+      const resolveNode = (funcName) => {
         const local = getNodeByNameAndFile.all(funcName, relPath);
         if (local.length > 0) return local[0];
         const global = getNodeByName.all(funcName);
         return global.length > 0 ? global[0] : null;
-      }
-
-      // flows_to: parameter/variable passed as argument to another function
-      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,
-          );
-          totalEdges++;
-        }
-      }
-
-      // returns: call return value captured in caller
-      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,
-          );
-          totalEdges++;
-        }
-      }
+      };
 
-      // mutates: parameter-derived value is mutated
-      for (const mut of data.mutations) {
-        const mutatorNode = resolveNode(mut.funcName);
-        if (mutatorNode && mut.binding?.type === 'param') {
-          // The mutation in this function affects the parameter source
-          insert.run(
-            mutatorNode.id,
-            mutatorNode.id,
-            'mutates',
-            null,
-            mut.mutatingExpr,
-            mut.line,
-            1.0,
-          );
-          totalEdges++;
-        }
-      }
+      totalEdges += insertDataflowEdges(insert, data, resolveNode);
     }
   });
 
@@ -234,31 +235,7 @@ export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts)
 
 // ── Query functions ─────────────────────────────────────────────────────────
 
-/**
- * Look up node(s) by name with optional file/kind/noTests filtering.
- * Similar to findMatchingNodes in queries.js but operates on the dataflow table.
- */
-function findNodes(db, name, opts = {}) {
-  const kinds = opts.kind ? [opts.kind] : ALL_SYMBOL_KINDS;
-  const placeholders = kinds.map(() => '?').join(', ');
-  const params = [`%${name}%`, ...kinds];
-
-  let fileCondition = '';
-  if (opts.file) {
-    fileCondition = ' AND file LIKE ?';
-    params.push(`%${opts.file}%`);
-  }
-
-  const rows = db
-    .prepare(
-      `SELECT * FROM nodes
-       WHERE name LIKE ? AND kind IN (${placeholders})${fileCondition}
-       ORDER BY file, line`,
-    )
-    .all(...params);
-
-  return opts.noTests ? rows.filter((n) => !isTestFile(n.file)) : rows;
-}
+// findNodes imported from ./shared/find-nodes.js
 
 /**
  * Return all dataflow edges for a symbol.
@@ -282,7 +259,12 @@ export function dataflowData(name, customDbPath, opts = {}) {
       };
     }
 
-    const nodes = findNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+    const nodes = findNodes(
+      db,
+      name,
+      { noTests, file: opts.file, kind: opts.kind },
+      ALL_SYMBOL_KINDS,
+    );
     if (nodes.length === 0) {
       return { name, results: [] };
     }
@@ -426,12 +408,22 @@ export function dataflowPathData(from, to, customDbPath, opts = {}) {
       };
     }
 
-    const fromNodes = findNodes(db, from, { noTests, file: opts.fromFile, kind: opts.kind });
+    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 });
+    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}"` };
     }
@@ -554,7 +546,12 @@ export function dataflowImpactData(name, customDbPath, opts = {}) {
       };
     }
 
-    const nodes = findNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+    const nodes = findNodes(
+      db,
+      name,
+      { noTests, file: opts.file, kind: opts.kind },
+      ALL_SYMBOL_KINDS,
+    );
     if (nodes.length === 0) {
       return { name, results: [] };
     }

package/src/features/export.js

@@ -67,8 +67,8 @@ function loadFunctionLevelEdges(db, { noTests, minConfidence, limit }) {
       FROM edges e
       JOIN nodes n1 ON e.source_id = n1.id
       JOIN nodes n2 ON e.target_id = n2.id
-      WHERE n1.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
-        AND n2.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
+      WHERE n1.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant')
+        AND n2.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant')
         AND e.kind = 'calls'
         AND e.confidence >= ?
     `,
@@ -308,7 +308,7 @@ export function exportGraphSON(db, opts = {}) {
   let nodes = db
     .prepare(`
     SELECT id, name, kind, file, line, role FROM nodes
-    WHERE kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'file')
+    WHERE kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant', 'file')
   `)
     .all();
   if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));

package/src/features/graph-enrichment.js

@@ -42,8 +42,8 @@ function prepareFunctionLevelData(db, noTests, minConf, cfg) {
       FROM edges e
       JOIN nodes n1 ON e.source_id = n1.id
       JOIN nodes n2 ON e.target_id = n2.id
-      WHERE n1.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
-        AND n2.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module')
+      WHERE n1.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant')
+        AND n2.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant')
         AND e.kind = 'calls'
         AND e.confidence >= ?
     `,

package/src/features/manifesto.js

@@ -1,4 +1,5 @@
 import { openReadonlyOrFail } from '../db/index.js';
+import { buildFileConditionSQL } from '../db/query-builder.js';
 import { findCycles } from '../domain/graph/cycles.js';
 import { loadConfig } from '../infrastructure/config.js';
 import { debug } from '../infrastructure/logger.js';
@@ -144,9 +145,10 @@ function evaluateFunctionRules(db, rules, opts, violations, ruleResults) {
   let where = "WHERE n.kind IN ('function','method')";
   const params = [];
   if (opts.noTests) where += NO_TEST_SQL;
-  if (opts.file) {
-    where += ' AND n.file LIKE ?';
-    params.push(`%${opts.file}%`);
+  {
+    const fc = buildFileConditionSQL(opts.file, 'n.file');
+    where += fc.sql;
+    params.push(...fc.params);
   }
   if (opts.kind) {
     where += ' AND n.kind = ?';
@@ -221,9 +223,10 @@ function evaluateFileRules(db, rules, opts, violations, ruleResults) {
   let where = "WHERE n.kind = 'file'";
   const params = [];
   if (opts.noTests) where += NO_TEST_SQL;
-  if (opts.file) {
-    where += ' AND n.file LIKE ?';
-    params.push(`%${opts.file}%`);
+  {
+    const fc = buildFileConditionSQL(opts.file, 'n.file');
+    where += fc.sql;
+    params.push(...fc.params);
   }
 
   let rows;

package/src/features/owners.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { findDbPath, openReadonlyOrFail } from '../db/index.js';
+import { normalizeFileFilter } from '../db/query-builder.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
 
 // ─── CODEOWNERS Parsing ──────────────────────────────────────────────
@@ -192,9 +193,9 @@ export function ownersData(customDbPath, opts = {}) {
       .map((r) => r.file);
 
     if (opts.noTests) allFiles = allFiles.filter((f) => !isTestFile(f));
-    if (opts.file) {
-      const filter = opts.file;
-      allFiles = allFiles.filter((f) => f.includes(filter));
+    const fileFilters = normalizeFileFilter(opts.file);
+    if (fileFilters.length > 0) {
+      allFiles = allFiles.filter((f) => fileFilters.some((filter) => f.includes(filter)));
     }
 
     // Map files to owners