@optave/codegraph 3.1.0 → 3.1.2

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
@@ -625,37 +605,39 @@ export async function searchData(query, customDbPath, opts = {}) {
   if (!prepared) return null;
   const { db, rows, modelKey, storedDim } = prepared;
 
-  const {
-    vectors: [queryVec],
-    dim,
-  } = await embed([query], modelKey);
+  try {
+    const {
+      vectors: [queryVec],
+      dim,
+    } = await embed([query], modelKey);
 
-  if (storedDim && dim !== storedDim) {
-    console.log(
-      `Warning: query model dimension (${dim}) doesn't match stored embeddings (${storedDim}).`,
-    );
-    console.log(`  Re-run \`codegraph embed\` with the same model, or use --model to match.`);
-    db.close();
-    return null;
-  }
+    if (storedDim && dim !== storedDim) {
+      console.log(
+        `Warning: query model dimension (${dim}) doesn't match stored embeddings (${storedDim}).`,
+      );
+      console.log(`  Re-run \`codegraph embed\` with the same model, or use --model to match.`);
+      return null;
+    }
 
-  const hc = new Map();
-  const results = [];
-  for (const row of rows) {
-    const vec = new Float32Array(new Uint8Array(row.vector).buffer);
-    const sim = cosineSim(queryVec, vec);
+    const hc = new Map();
+    const results = [];
+    for (const row of rows) {
+      const vec = new Float32Array(new Uint8Array(row.vector).buffer);
+      const sim = cosineSim(queryVec, vec);
 
-    if (sim >= minScore) {
-      results.push({
-        ...normalizeSymbol(row, db, hc),
-        similarity: sim,
-      });
+      if (sim >= minScore) {
+        results.push({
+          ...normalizeSymbol(row, db, hc),
+          similarity: sim,
+        });
+      }
     }
-  }
 
-  results.sort((a, b) => b.similarity - a.similarity);
-  db.close();
-  return { results: results.slice(0, limit) };
+    results.sort((a, b) => b.similarity - a.similarity);
+    return { results: results.slice(0, limit) };
+  } finally {
+    db.close();
+  }
 }
 
 /**
@@ -671,82 +653,84 @@ export async function multiSearchData(queries, customDbPath, opts = {}) {
   if (!prepared) return null;
   const { db, rows, modelKey, storedDim } = prepared;
 
-  const { vectors: queryVecs, dim } = await embed(queries, modelKey);
-
-  // Warn about similar queries that may bias RRF results
-  const SIMILARITY_WARN_THRESHOLD = 0.85;
-  for (let i = 0; i < queryVecs.length; i++) {
-    for (let j = i + 1; j < queryVecs.length; j++) {
-      const sim = cosineSim(queryVecs[i], queryVecs[j]);
-      if (sim >= SIMILARITY_WARN_THRESHOLD) {
-        warn(
-          `Queries "${queries[i]}" and "${queries[j]}" are very similar ` +
-            `(${(sim * 100).toFixed(0)}% cosine similarity). ` +
-            `This may bias RRF results toward their shared matches. ` +
-            `Consider using more distinct queries.`,
-        );
+  try {
+    const { vectors: queryVecs, dim } = await embed(queries, modelKey);
+
+    // Warn about similar queries that may bias RRF results
+    const SIMILARITY_WARN_THRESHOLD = 0.85;
+    for (let i = 0; i < queryVecs.length; i++) {
+      for (let j = i + 1; j < queryVecs.length; j++) {
+        const sim = cosineSim(queryVecs[i], queryVecs[j]);
+        if (sim >= SIMILARITY_WARN_THRESHOLD) {
+          warn(
+            `Queries "${queries[i]}" and "${queries[j]}" are very similar ` +
+              `(${(sim * 100).toFixed(0)}% cosine similarity). ` +
+              `This may bias RRF results toward their shared matches. ` +
+              `Consider using more distinct queries.`,
+          );
+        }
       }
     }
-  }
 
-  if (storedDim && dim !== storedDim) {
-    console.log(
-      `Warning: query model dimension (${dim}) doesn't match stored embeddings (${storedDim}).`,
-    );
-    console.log(`  Re-run \`codegraph embed\` with the same model, or use --model to match.`);
-    db.close();
-    return null;
-  }
+    if (storedDim && dim !== storedDim) {
+      console.log(
+        `Warning: query model dimension (${dim}) doesn't match stored embeddings (${storedDim}).`,
+      );
+      console.log(`  Re-run \`codegraph embed\` with the same model, or use --model to match.`);
+      return null;
+    }
 
-  // Parse row vectors once
-  const rowVecs = rows.map((row) => new Float32Array(new Uint8Array(row.vector).buffer));
+    // Parse row vectors once
+    const rowVecs = rows.map((row) => new Float32Array(new Uint8Array(row.vector).buffer));
 
-  // For each query: compute similarities, filter by minScore, rank
-  const perQueryRanked = queries.map((_query, qi) => {
-    const scored = [];
-    for (let ri = 0; ri < rows.length; ri++) {
-      const sim = cosineSim(queryVecs[qi], rowVecs[ri]);
-      if (sim >= minScore) {
-        scored.push({ rowIndex: ri, similarity: sim });
+    // For each query: compute similarities, filter by minScore, rank
+    const perQueryRanked = queries.map((_query, qi) => {
+      const scored = [];
+      for (let ri = 0; ri < rows.length; ri++) {
+        const sim = cosineSim(queryVecs[qi], rowVecs[ri]);
+        if (sim >= minScore) {
+          scored.push({ rowIndex: ri, similarity: sim });
+        }
       }
-    }
-    scored.sort((a, b) => b.similarity - a.similarity);
-    // Assign 1-indexed ranks
-    return scored.map((item, rank) => ({ ...item, rank: rank + 1 }));
-  });
+      scored.sort((a, b) => b.similarity - a.similarity);
+      // Assign 1-indexed ranks
+      return scored.map((item, rank) => ({ ...item, rank: rank + 1 }));
+    });
 
-  // Fuse results using RRF: for each unique row, sum 1/(k + rank_i) across queries
-  const fusionMap = new Map(); // rowIndex -> { rrfScore, queryScores[] }
-  for (let qi = 0; qi < queries.length; qi++) {
-    for (const item of perQueryRanked[qi]) {
-      if (!fusionMap.has(item.rowIndex)) {
-        fusionMap.set(item.rowIndex, { rrfScore: 0, queryScores: [] });
+    // Fuse results using RRF: for each unique row, sum 1/(k + rank_i) across queries
+    const fusionMap = new Map(); // rowIndex -> { rrfScore, queryScores[] }
+    for (let qi = 0; qi < queries.length; qi++) {
+      for (const item of perQueryRanked[qi]) {
+        if (!fusionMap.has(item.rowIndex)) {
+          fusionMap.set(item.rowIndex, { rrfScore: 0, queryScores: [] });
+        }
+        const entry = fusionMap.get(item.rowIndex);
+        entry.rrfScore += 1 / (k + item.rank);
+        entry.queryScores.push({
+          query: queries[qi],
+          similarity: item.similarity,
+          rank: item.rank,
+        });
       }
-      const entry = fusionMap.get(item.rowIndex);
-      entry.rrfScore += 1 / (k + item.rank);
-      entry.queryScores.push({
-        query: queries[qi],
-        similarity: item.similarity,
-        rank: item.rank,
+    }
+
+    // Build results sorted by RRF score
+    const hc = new Map();
+    const results = [];
+    for (const [rowIndex, entry] of fusionMap) {
+      const row = rows[rowIndex];
+      results.push({
+        ...normalizeSymbol(row, db, hc),
+        rrf: entry.rrfScore,
+        queryScores: entry.queryScores,
       });
     }
-  }
 
-  // Build results sorted by RRF score
-  const hc = new Map();
-  const results = [];
-  for (const [rowIndex, entry] of fusionMap) {
-    const row = rows[rowIndex];
-    results.push({
-      ...normalizeSymbol(row, db, hc),
-      rrf: entry.rrfScore,
-      queryScores: entry.queryScores,
-    });
+    results.sort((a, b) => b.rrf - a.rrf);
+    return { results: results.slice(0, limit) };
+  } finally {
+    db.close();
   }
-
-  results.sort((a, b) => b.rrf - a.rrf);
-  db.close();
-  return { results: results.slice(0, limit) };
 }
 
 /**
@@ -788,64 +772,64 @@ export function ftsSearchData(query, customDbPath, opts = {}) {
 
   const db = openReadonlyOrFail(customDbPath);
 
-  if (!hasFtsIndex(db)) {
-    db.close();
-    return null;
-  }
-
-  const ftsQuery = sanitizeFtsQuery(query);
-  if (!ftsQuery) {
-    db.close();
-    return { results: [] };
-  }
+  try {
+    if (!hasFtsIndex(db)) {
+      return null;
+    }
 
-  let sql = `
-    SELECT f.rowid AS node_id, rank AS bm25_score,
-           n.name, n.kind, n.file, n.line, n.end_line, n.role
-    FROM fts_index f
-    JOIN nodes n ON f.rowid = n.id
-    WHERE fts_index MATCH ?
-  `;
-  const params = [ftsQuery];
+    const ftsQuery = sanitizeFtsQuery(query);
+    if (!ftsQuery) {
+      return { results: [] };
+    }
 
-  if (opts.kind) {
-    sql += ' AND n.kind = ?';
-    params.push(opts.kind);
-  }
+    let sql = `
+      SELECT f.rowid AS node_id, rank AS bm25_score,
+             n.name, n.kind, n.file, n.line, n.end_line, n.role
+      FROM fts_index f
+      JOIN nodes n ON f.rowid = n.id
+      WHERE fts_index MATCH ?
+    `;
+    const params = [ftsQuery];
+
+    if (opts.kind) {
+      sql += ' AND n.kind = ?';
+      params.push(opts.kind);
+    }
 
-  const isGlob = opts.filePattern && /[*?[\]]/.test(opts.filePattern);
-  if (opts.filePattern && !isGlob) {
-    sql += ' AND n.file LIKE ?';
-    params.push(`%${opts.filePattern}%`);
-  }
+    const isGlob = opts.filePattern && /[*?[\]]/.test(opts.filePattern);
+    if (opts.filePattern && !isGlob) {
+      sql += ' AND n.file LIKE ?';
+      params.push(`%${opts.filePattern}%`);
+    }
 
-  sql += ' ORDER BY rank LIMIT ?';
-  params.push(limit * 5); // fetch generous set for post-filtering
+    sql += ' ORDER BY rank LIMIT ?';
+    params.push(limit * 5); // fetch generous set for post-filtering
 
-  let rows;
-  try {
-    rows = db.prepare(sql).all(...params);
-  } catch {
-    // Invalid FTS5 query syntax — return empty
-    db.close();
-    return { results: [] };
-  }
+    let rows;
+    try {
+      rows = db.prepare(sql).all(...params);
+    } catch {
+      // Invalid FTS5 query syntax — return empty
+      return { results: [] };
+    }
 
-  if (isGlob) {
-    rows = rows.filter((row) => globMatch(row.file, opts.filePattern));
-  }
-  if (noTests) {
-    rows = rows.filter((row) => !TEST_PATTERN.test(row.file));
-  }
+    if (isGlob) {
+      rows = rows.filter((row) => globMatch(row.file, opts.filePattern));
+    }
+    if (noTests) {
+      rows = rows.filter((row) => !TEST_PATTERN.test(row.file));
+    }
 
-  const hc = new Map();
-  const results = rows.slice(0, limit).map((row) => ({
-    ...normalizeSymbol(row, db, hc),
-    bm25Score: -row.bm25_score, // FTS5 rank is negative; negate for display
-  }));
+    const hc = new Map();
+    const results = rows.slice(0, limit).map((row) => ({
+      ...normalizeSymbol(row, db, hc),
+      bm25Score: -row.bm25_score, // FTS5 rank is negative; negate for display
+    }));
 
-  db.close();
-  return { results };
+    return { results };
+  } finally {
+    db.close();
+  }
 }
 
 /**

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 './queries.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 [];
+}