@optave/codegraph 3.1.1 → 3.1.2

package/src/db/repository/nodes.js

@@ -0,0 +1,236 @@
+import { EVERY_SYMBOL_KIND, VALID_ROLES } from '../../kinds.js';
+import { NodeQuery } from '../query-builder.js';
+
+// ─── Query-builder based lookups (moved from src/db/repository.js) ─────
+
+/**
+ * Find nodes matching a name pattern, with fan-in count.
+ * @param {object} db
+ * @param {string} namePattern - LIKE pattern (already wrapped with %)
+ * @param {object} [opts]
+ * @param {string[]} [opts.kinds]
+ * @param {string} [opts.file]
+ * @returns {object[]}
+ */
+export function findNodesWithFanIn(db, namePattern, opts = {}) {
+  const q = new NodeQuery()
+    .select('n.*, COALESCE(fi.cnt, 0) AS fan_in')
+    .withFanIn()
+    .where('n.name LIKE ?', namePattern);
+
+  if (opts.kinds) {
+    q.kinds(opts.kinds);
+  }
+  if (opts.file) {
+    q.fileFilter(opts.file);
+  }
+
+  return q.all(db);
+}
+
+/**
+ * Fetch nodes for triage scoring: fan-in + complexity + churn.
+ * @param {object} db
+ * @param {object} [opts]
+ * @returns {object[]}
+ */
+export function findNodesForTriage(db, opts = {}) {
+  if (opts.kind && !EVERY_SYMBOL_KIND.includes(opts.kind)) {
+    throw new Error(`Invalid kind: ${opts.kind} (expected one of ${EVERY_SYMBOL_KIND.join(', ')})`);
+  }
+  if (opts.role && !VALID_ROLES.includes(opts.role)) {
+    throw new Error(`Invalid role: ${opts.role} (expected one of ${VALID_ROLES.join(', ')})`);
+  }
+
+  const kindsToUse = opts.kind ? [opts.kind] : ['function', 'method', 'class'];
+  const q = new NodeQuery()
+    .select(
+      `n.id, n.name, n.kind, n.file, n.line, n.end_line, n.role,
+              COALESCE(fi.cnt, 0) AS fan_in,
+              COALESCE(fc.cognitive, 0) AS cognitive,
+              COALESCE(fc.maintainability_index, 0) AS mi,
+              COALESCE(fc.cyclomatic, 0) AS cyclomatic,
+              COALESCE(fc.max_nesting, 0) AS max_nesting,
+              COALESCE(fcc.commit_count, 0) AS churn`,
+    )
+    .kinds(kindsToUse)
+    .withFanIn()
+    .withComplexity()
+    .withChurn()
+    .excludeTests(opts.noTests)
+    .fileFilter(opts.file)
+    .roleFilter(opts.role)
+    .orderBy('n.file, n.line');
+
+  return q.all(db);
+}
+
+/**
+ * Shared query builder for function/method/class node listing.
+ * @param {object} [opts]
+ * @returns {NodeQuery}
+ */
+function _functionNodeQuery(opts = {}) {
+  return new NodeQuery()
+    .select('name, kind, file, line, end_line, role')
+    .kinds(['function', 'method', 'class'])
+    .fileFilter(opts.file)
+    .nameLike(opts.pattern)
+    .excludeTests(opts.noTests)
+    .orderBy('file, line');
+}
+
+/**
+ * List function/method/class nodes with basic info.
+ * @param {object} db
+ * @param {object} [opts]
+ * @returns {object[]}
+ */
+export function listFunctionNodes(db, opts = {}) {
+  return _functionNodeQuery(opts).all(db);
+}
+
+/**
+ * Iterator version of listFunctionNodes for memory efficiency.
+ * @param {object} db
+ * @param {object} [opts]
+ * @returns {IterableIterator}
+ */
+export function iterateFunctionNodes(db, opts = {}) {
+  return _functionNodeQuery(opts).iterate(db);
+}
+
+/**
+ * Count total nodes.
+ * @param {object} db
+ * @returns {number}
+ */
+export function countNodes(db) {
+  return db.prepare('SELECT COUNT(*) AS cnt FROM nodes').get().cnt;
+}
+
+/**
+ * Count total edges.
+ * @param {object} db
+ * @returns {number}
+ */
+export function countEdges(db) {
+  return db.prepare('SELECT COUNT(*) AS cnt FROM edges').get().cnt;
+}
+
+/**
+ * Count distinct files.
+ * @param {object} db
+ * @returns {number}
+ */
+export function countFiles(db) {
+  return db.prepare('SELECT COUNT(DISTINCT file) AS cnt FROM nodes').get().cnt;
+}
+
+// ─── Shared node lookups ───────────────────────────────────────────────
+
+/**
+ * Find a single node by ID.
+ * @param {object} db
+ * @param {number} id
+ * @returns {object|undefined}
+ */
+export function findNodeById(db, id) {
+  return db.prepare('SELECT * FROM nodes WHERE id = ?').get(id);
+}
+
+/**
+ * Find non-file nodes for a given file path (exact match), ordered by line.
+ * @param {object} db
+ * @param {string} file - Exact file path
+ * @returns {object[]}
+ */
+export function findNodesByFile(db, file) {
+  return db
+    .prepare("SELECT * FROM nodes WHERE file = ? AND kind != 'file' ORDER BY line")
+    .all(file);
+}
+
+/**
+ * Find file-kind nodes matching a LIKE pattern.
+ * @param {object} db
+ * @param {string} fileLike - LIKE pattern (caller wraps with %)
+ * @returns {object[]}
+ */
+export function findFileNodes(db, fileLike) {
+  return db.prepare("SELECT * FROM nodes WHERE file LIKE ? AND kind = 'file'").all(fileLike);
+}
+
+// ─── Statement caches (one prepared statement per db instance) ────────────
+// WeakMap keys on the db object so statements are GC'd when the db closes.
+const _getNodeIdStmt = new WeakMap();
+const _getFunctionNodeIdStmt = new WeakMap();
+const _bulkNodeIdsByFileStmt = new WeakMap();
+
+/**
+ * Look up a node's ID by its unique (name, kind, file, line) tuple.
+ * Shared by builder, watcher, structure, complexity, cfg, engine.
+ * @param {object} db
+ * @param {string} name
+ * @param {string} kind
+ * @param {string} file
+ * @param {number} line
+ * @returns {number|undefined}
+ */
+export function getNodeId(db, name, kind, file, line) {
+  let stmt = _getNodeIdStmt.get(db);
+  if (!stmt) {
+    stmt = db.prepare('SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?');
+    _getNodeIdStmt.set(db, stmt);
+  }
+  return stmt.get(name, kind, file, line)?.id;
+}
+
+/**
+ * Look up a function/method node's ID (kind-restricted variant of getNodeId).
+ * Used by complexity.js, cfg.js where only function/method kinds are expected.
+ * @param {object} db
+ * @param {string} name
+ * @param {string} file
+ * @param {number} line
+ * @returns {number|undefined}
+ */
+export function getFunctionNodeId(db, name, file, line) {
+  let stmt = _getFunctionNodeIdStmt.get(db);
+  if (!stmt) {
+    stmt = db.prepare(
+      "SELECT id FROM nodes WHERE name = ? AND kind IN ('function','method') AND file = ? AND line = ?",
+    );
+    _getFunctionNodeIdStmt.set(db, stmt);
+  }
+  return stmt.get(name, file, line)?.id;
+}
+
+/**
+ * Bulk-fetch all node IDs for a file in one query.
+ * Returns rows suitable for building a `name|kind|line -> id` lookup map.
+ * Shared by builder, ast.js, ast-analysis/engine.js.
+ * @param {object} db
+ * @param {string} file
+ * @returns {{ id: number, name: string, kind: string, line: number }[]}
+ */
+export function bulkNodeIdsByFile(db, file) {
+  let stmt = _bulkNodeIdsByFileStmt.get(db);
+  if (!stmt) {
+    stmt = db.prepare('SELECT id, name, kind, line FROM nodes WHERE file = ?');
+    _bulkNodeIdsByFileStmt.set(db, stmt);
+  }
+  return stmt.all(file);
+}
+
+/**
+ * Find child nodes (parameters, properties, constants) of a parent.
+ * @param {object} db
+ * @param {number} parentId
+ * @returns {{ name: string, kind: string, line: number, end_line: number|null }[]}
+ */
+export function findNodeChildren(db, parentId) {
+  return db
+    .prepare('SELECT name, kind, line, end_line FROM nodes WHERE parent_id = ? ORDER BY line')
+    .all(parentId);
+}

package/src/db.js

@@ -9,11 +9,50 @@ export {
   testFilterSQL,
 } from './db/query-builder.js';
 export {
+  bulkNodeIdsByFile,
+  countCrossFileCallers,
   countEdges,
   countFiles,
   countNodes,
+  deleteCfgForNode,
+  findAllIncomingEdges,
+  findAllOutgoingEdges,
+  findCalleeNames,
+  findCallees,
+  findCallerNames,
+  findCallers,
+  findCrossFileCallTargets,
+  findDistinctCallers,
+  findFileNodes,
+  findImportDependents,
+  findImportSources,
+  findImportTargets,
+  findIntraFileCallEdges,
+  findNodeById,
+  findNodeChildren,
+  findNodesByFile,
   findNodesForTriage,
   findNodesWithFanIn,
+  getCallableNodes,
+  getCallEdges,
+  getCfgBlocks,
+  getCfgEdges,
+  getClassHierarchy,
+  getCoChangeMeta,
+  getComplexityForNode,
+  getEmbeddingCount,
+  getEmbeddingMeta,
+  getFileNodesAll,
+  getFunctionNodeId,
+  getImportEdges,
+  getNodeId,
+  hasCfgTables,
+  hasCoChanges,
+  hasDataflowTable,
+  hasEmbeddings,
   iterateFunctionNodes,
   listFunctionNodes,
-} from './db/repository.js';
+  purgeFileData,
+  purgeFilesData,
+  upsertCoChangeMeta,
+} from './db/repository/index.js';

package/src/embedder.js

@@ -2,7 +2,14 @@ import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
-import { closeDb, findDbPath, openDb, openReadonlyOrFail } from './db.js';
+import {
+  closeDb,
+  findCalleeNames,
+  findCallerNames,
+  findDbPath,
+  openDb,
+  openReadonlyOrFail,
+} from './db.js';
 import { info, warn } from './logger.js';
 import { normalizeSymbol } from './queries.js';
 
@@ -166,7 +173,7 @@ function extractLeadingComment(lines, fnLineIndex) {
  * Build graph-enriched text for a symbol using dependency context.
  * Produces compact, semantic text (~100 tokens) instead of full source code.
  */
-function buildStructuredText(node, file, lines, calleesStmt, callersStmt) {
+function buildStructuredText(node, file, lines, db) {
   const readable = splitIdentifier(node.name);
   const parts = [`${node.kind} ${node.name} (${readable}) in ${file}`];
   const startLine = Math.max(0, node.line - 1);
@@ -179,25 +186,15 @@ function buildStructuredText(node, file, lines, calleesStmt, callersStmt) {
   }
 
   // Graph context: callees (capped at 10)
-  const callees = calleesStmt.all(node.id);
+  const callees = findCalleeNames(db, node.id);
   if (callees.length > 0) {
-    parts.push(
-      `Calls: ${callees
-        .slice(0, 10)
-        .map((c) => c.name)
-        .join(', ')}`,
-    );
+    parts.push(`Calls: ${callees.slice(0, 10).join(', ')}`);
   }
 
   // Graph context: callers (capped at 10)
-  const callers = callersStmt.all(node.id);
+  const callers = findCallerNames(db, node.id);
   if (callers.length > 0) {
-    parts.push(
-      `Called by: ${callers
-        .slice(0, 10)
-        .map((c) => c.name)
-        .join(', ')}`,
-    );
+    parts.push(`Called by: ${callers.slice(0, 10).join(', ')}`);
   }
 
   // Leading comment (high semantic value) or first few lines of code
@@ -438,23 +435,6 @@ export async function buildEmbeddings(rootDir, modelKey, customDbPath, options =
 
   console.log(`Building embeddings for ${nodes.length} symbols (strategy: ${strategy})...`);
 
-  // Prepare graph-context queries for structured strategy
-  let calleesStmt, callersStmt;
-  if (strategy === 'structured') {
-    calleesStmt = db.prepare(`
-      SELECT DISTINCT n.name FROM edges e
-      JOIN nodes n ON e.target_id = n.id
-      WHERE e.source_id = ? AND e.kind = 'calls'
-      ORDER BY n.name
-    `);
-    callersStmt = db.prepare(`
-      SELECT DISTINCT n.name FROM edges e
-      JOIN nodes n ON e.source_id = n.id
-      WHERE e.target_id = ? AND e.kind = 'calls'
-      ORDER BY n.name
-    `);
-  }
-
   const byFile = new Map();
   for (const node of nodes) {
     if (!byFile.has(node.file)) byFile.set(node.file, []);
@@ -482,7 +462,7 @@ export async function buildEmbeddings(rootDir, modelKey, customDbPath, options =
     for (const node of fileNodes) {
       let text =
         strategy === 'structured'
-          ? buildStructuredText(node, file, lines, calleesStmt, callersStmt)
+          ? buildStructuredText(node, file, lines, db)
           : buildSourceText(node, file, lines);
 
       // Detect and handle context window overflow

package/src/export.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
+import { isTestFile } from './infrastructure/test-filter.js';
 import { paginateResult } from './paginate.js';
-import { isTestFile } from './test-filter.js';
 
 const DEFAULT_MIN_CONFIDENCE = 0.5;
 

package/src/extractors/javascript.js

@@ -1,3 +1,4 @@
+import { debug } from '../logger.js';
 import { findChild, nodeEndLine } from './helpers.js';
 
 /**
@@ -173,6 +174,9 @@ function extractSymbolsQuery(tree, query) {
   // Extract top-level constants via targeted walk (query patterns don't cover these)
   extractConstantsWalk(tree.rootNode, definitions);
 
+  // Extract dynamic import() calls via targeted walk (query patterns don't match `import` function type)
+  extractDynamicImportsWalk(tree.rootNode, imports);
+
   return { definitions, calls, imports, classes, exports: exps };
 }
 
@@ -224,6 +228,41 @@ function extractConstantsWalk(rootNode, definitions) {
   }
 }
 
+/**
+ * Recursive walk to find dynamic import() calls.
+ * Query patterns match call_expression with identifier/member_expression/subscript_expression
+ * functions, but import() has function type `import` which none of those patterns cover.
+ */
+function extractDynamicImportsWalk(node, imports) {
+  if (node.type === 'call_expression') {
+    const fn = node.childForFieldName('function');
+    if (fn && fn.type === 'import') {
+      const args = node.childForFieldName('arguments') || findChild(node, 'arguments');
+      if (args) {
+        const strArg = findChild(args, 'string');
+        if (strArg) {
+          const modPath = strArg.text.replace(/['"]/g, '');
+          const names = extractDynamicImportNames(node);
+          imports.push({
+            source: modPath,
+            names,
+            line: node.startPosition.row + 1,
+            dynamicImport: true,
+          });
+        } else {
+          debug(
+            `Skipping non-static dynamic import() at line ${node.startPosition.row + 1} (template literal or variable)`,
+          );
+        }
+      }
+      return; // no need to recurse into import() children
+    }
+  }
+  for (let i = 0; i < node.childCount; i++) {
+    extractDynamicImportsWalk(node.child(i), imports);
+  }
+}
+
 function handleCommonJSAssignment(left, right, node, imports) {
   if (!left || !right) return;
   const leftText = left.text;
@@ -455,11 +494,36 @@ function extractSymbolsWalk(tree) {
       case 'call_expression': {
         const fn = node.childForFieldName('function');
         if (fn) {
-          const callInfo = extractCallInfo(fn, node);
-          if (callInfo) calls.push(callInfo);
-          if (fn.type === 'member_expression') {
-            const cbDef = extractCallbackDefinition(node, fn);
-            if (cbDef) definitions.push(cbDef);
+          // Dynamic import(): import('./foo.js') → extract as an import entry
+          if (fn.type === 'import') {
+            const args = node.childForFieldName('arguments') || findChild(node, 'arguments');
+            if (args) {
+              const strArg = findChild(args, 'string');
+              if (strArg) {
+                const modPath = strArg.text.replace(/['"]/g, '');
+                // Extract destructured names from parent context:
+                //   const { a, b } = await import('./foo.js')
+                // (standalone import('./foo.js').then(...) calls produce an edge with empty names)
+                const names = extractDynamicImportNames(node);
+                imports.push({
+                  source: modPath,
+                  names,
+                  line: node.startPosition.row + 1,
+                  dynamicImport: true,
+                });
+              } else {
+                debug(
+                  `Skipping non-static dynamic import() at line ${node.startPosition.row + 1} (template literal or variable)`,
+                );
+              }
+            }
+          } else {
+            const callInfo = extractCallInfo(fn, node);
+            if (callInfo) calls.push(callInfo);
+            if (fn.type === 'member_expression') {
+              const cbDef = extractCallbackDefinition(node, fn);
+              if (cbDef) definitions.push(cbDef);
+            }
           }
         }
         break;
@@ -941,3 +1005,64 @@ function extractImportNames(node) {
   scan(node);
   return names;
 }
+
+/**
+ * Extract destructured names from a dynamic import() call expression.
+ *
+ * Handles:
+ *   const { a, b } = await import('./foo.js')   → ['a', 'b']
+ *   const mod = await import('./foo.js')         → ['mod']
+ *   import('./foo.js')                           → [] (no names extractable)
+ *
+ * Walks up the AST from the call_expression to find the enclosing
+ * variable_declarator and reads the name/object_pattern.
+ */
+function extractDynamicImportNames(callNode) {
+  // Walk up: call_expression → await_expression → variable_declarator
+  let current = callNode.parent;
+  // Skip await_expression wrapper if present
+  if (current && current.type === 'await_expression') current = current.parent;
+  // We should now be at a variable_declarator (or not, if standalone import())
+  if (!current || current.type !== 'variable_declarator') return [];
+
+  const nameNode = current.childForFieldName('name');
+  if (!nameNode) return [];
+
+  // const { a, b } = await import(...)  →  object_pattern
+  if (nameNode.type === 'object_pattern') {
+    const names = [];
+    for (let i = 0; i < nameNode.childCount; i++) {
+      const child = nameNode.child(i);
+      if (child.type === 'shorthand_property_identifier_pattern') {
+        names.push(child.text);
+      } else if (child.type === 'pair_pattern') {
+        // { a: localName } → use localName (the alias) for the local binding,
+        // but use the key (original name) for import resolution
+        const key = child.childForFieldName('key');
+        if (key) names.push(key.text);
+      }
+    }
+    return names;
+  }
+
+  // const mod = await import(...)  →  identifier (namespace-like import)
+  if (nameNode.type === 'identifier') {
+    return [nameNode.text];
+  }
+
+  // const [a, b] = await import(...)  →  array_pattern (rare but possible)
+  if (nameNode.type === 'array_pattern') {
+    const names = [];
+    for (let i = 0; i < nameNode.childCount; i++) {
+      const child = nameNode.child(i);
+      if (child.type === 'identifier') names.push(child.text);
+      else if (child.type === 'rest_pattern') {
+        const inner = child.child(0) || child.childForFieldName('name');
+        if (inner && inner.type === 'identifier') names.push(inner.text);
+      }
+    }
+    return names;
+  }
+
+  return [];
+}

package/src/flow.js

@@ -6,11 +6,10 @@
  */
 
 import { openReadonlyOrFail } from './db.js';
+import { isTestFile } from './infrastructure/test-filter.js';
 import { paginateResult } from './paginate.js';
-import { CORE_SYMBOL_KINDS, findMatchingNodes, kindIcon } from './queries.js';
-import { outputResult } from './result-formatter.js';
+import { CORE_SYMBOL_KINDS, findMatchingNodes } from './queries.js';
 import { FRAMEWORK_ENTRY_PREFIXES } from './structure.js';
-import { isTestFile } from './test-filter.js';
 
 /**
  * Determine the entry point type from a node name based on framework prefixes.
@@ -227,70 +226,3 @@ export function flowData(name, dbPath, opts = {}) {
     db.close();
   }
 }
-
-/**
- * CLI formatter — text or JSON output.
- */
-export function flow(name, dbPath, opts = {}) {
-  if (opts.list) {
-    const data = listEntryPointsData(dbPath, {
-      noTests: opts.noTests,
-      limit: opts.limit,
-      offset: opts.offset,
-    });
-    if (outputResult(data, 'entries', opts)) return;
-    if (data.count === 0) {
-      console.log('No entry points found. Run "codegraph build" first.');
-      return;
-    }
-    console.log(`\nEntry points (${data.count} total):\n`);
-    for (const [type, entries] of Object.entries(data.byType)) {
-      console.log(`  ${type} (${entries.length}):`);
-      for (const e of entries) {
-        console.log(`    [${kindIcon(e.kind)}] ${e.name}  ${e.file}:${e.line}`);
-      }
-      console.log();
-    }
-    return;
-  }
-
-  const data = flowData(name, dbPath, opts);
-  if (outputResult(data, 'steps', opts)) return;
-
-  if (!data.entry) {
-    console.log(`No matching entry point or function found for "${name}".`);
-    return;
-  }
-
-  const e = data.entry;
-  const typeTag = e.type !== 'exported' ? ` (${e.type})` : '';
-  console.log(`\nFlow from: [${kindIcon(e.kind)}] ${e.name}${typeTag}  ${e.file}:${e.line}`);
-  console.log(
-    `Depth: ${data.depth}  Reached: ${data.totalReached} nodes  Leaves: ${data.leaves.length}`,
-  );
-  if (data.truncated) {
-    console.log(`  (truncated at depth ${data.depth})`);
-  }
-  console.log();
-
-  if (data.steps.length === 0) {
-    console.log('  (leaf node — no callees)');
-    return;
-  }
-
-  for (const step of data.steps) {
-    console.log(`  depth ${step.depth}:`);
-    for (const n of step.nodes) {
-      const isLeaf = data.leaves.some((l) => l.name === n.name && l.file === n.file);
-      const leafTag = isLeaf ? ' [leaf]' : '';
-      console.log(`    [${kindIcon(n.kind)}] ${n.name}  ${n.file}:${n.line}${leafTag}`);
-    }
-  }
-
-  if (data.cycles.length > 0) {
-    console.log('\n  Cycles detected:');
-    for (const c of data.cycles) {
-      console.log(`    ${c.from} -> ${c.to} (at depth ${c.depth})`);
-    }
-  }
-}