@optave/codegraph 3.0.0 → 3.0.2

package/src/extractors/javascript.js

@@ -170,9 +170,60 @@ function extractSymbolsQuery(tree, query) {
     }
   }
 
+  // Extract top-level constants via targeted walk (query patterns don't cover these)
+  extractConstantsWalk(tree.rootNode, definitions);
+
   return { definitions, calls, imports, classes, exports: exps };
 }
 
+/**
+ * Walk program-level children to extract `const x = <literal>` as constants.
+ * The query-based fast path has no pattern for lexical_declaration/variable_declaration,
+ * so constants are missed. This targeted walk fills that gap without a full tree traversal.
+ */
+function extractConstantsWalk(rootNode, definitions) {
+  for (let i = 0; i < rootNode.childCount; i++) {
+    const node = rootNode.child(i);
+    if (!node) continue;
+
+    let declNode = node;
+    // Handle `export const …` — unwrap the export_statement to its declaration child
+    if (node.type === 'export_statement') {
+      const inner = node.childForFieldName('declaration');
+      if (!inner) continue;
+      declNode = inner;
+    }
+
+    const t = declNode.type;
+    if (t !== 'lexical_declaration' && t !== 'variable_declaration') continue;
+    if (!declNode.text.startsWith('const ')) continue;
+
+    for (let j = 0; j < declNode.childCount; j++) {
+      const declarator = declNode.child(j);
+      if (!declarator || declarator.type !== 'variable_declarator') continue;
+      const nameN = declarator.childForFieldName('name');
+      const valueN = declarator.childForFieldName('value');
+      if (!nameN || nameN.type !== 'identifier' || !valueN) continue;
+      // Skip functions — already captured by query patterns
+      const valType = valueN.type;
+      if (
+        valType === 'arrow_function' ||
+        valType === 'function_expression' ||
+        valType === 'function'
+      )
+        continue;
+      if (isConstantValue(valueN)) {
+        definitions.push({
+          name: nameN.text,
+          kind: 'constant',
+          line: declNode.startPosition.row + 1,
+          endLine: nodeEndLine(declNode),
+        });
+      }
+    }
+  }
+}
+
 function handleCommonJSAssignment(left, right, node, imports) {
   if (!left || !right) return;
   const leftText = left.text;

package/src/flow.js

@@ -45,7 +45,10 @@ export function listEntryPointsData(dbPath, opts = {}) {
     .prepare(
       `SELECT n.name, n.kind, n.file, n.line, n.role
        FROM nodes n
-       WHERE (${prefixConditions})
+       WHERE (
+         (${prefixConditions})
+         OR n.role = 'entry'
+       )
          AND n.kind NOT IN ('file', 'directory')
        ORDER BY n.name`,
     )
@@ -59,7 +62,7 @@ export function listEntryPointsData(dbPath, opts = {}) {
     file: r.file,
     line: r.line,
     role: r.role,
-    type: entryPointType(r.name),
+    type: entryPointType(r.name) || (r.role === 'entry' ? 'exported' : null),
   }));
 
   const byType = {};

package/src/index.js

@@ -123,7 +123,7 @@ export { matchOwners, owners, ownersData, ownersForFiles, parseCodeowners } from
 export { MCP_DEFAULTS, MCP_MAX_LIMIT, paginate, paginateResult, printNdjson } from './paginate.js';
 
 // Unified parser API
-export { getActiveEngine, parseFileAuto, parseFilesAuto } from './parser.js';
+export { getActiveEngine, isWasmAvailable, parseFileAuto, parseFilesAuto } from './parser.js';
 // Query functions (data-returning)
 export {
   ALL_SYMBOL_KINDS,

package/src/mcp.js

@@ -638,7 +638,7 @@ const BASE_TOOLS = [
   },
   {
     name: 'cfg',
-    description: 'Show intraprocedural control flow graph for a function. Requires build --cfg.',
+    description: 'Show intraprocedural control flow graph for a function.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -658,7 +658,7 @@ const BASE_TOOLS = [
   },
   {
     name: 'dataflow',
-    description: 'Show data flow edges or data-dependent blast radius. Requires build --dataflow.',
+    description: 'Show data flow edges or data-dependent blast radius.',
     inputSchema: {
       type: 'object',
       properties: {

package/src/parser.js

@@ -38,6 +38,9 @@ function grammarPath(name) {
 
 let _initialized = false;
 
+// Memoized parsers — avoids reloading WASM grammars on every createParsers() call
+let _cachedParsers = null;
+
 // Query cache for JS/TS/TSX extractors (populated during createParsers)
 const _queryCache = new Map();
 
@@ -66,6 +69,8 @@ const TS_EXTRA_PATTERNS = [
 ];
 
 export async function createParsers() {
+  if (_cachedParsers) return _cachedParsers;
+
   if (!_initialized) {
     await Parser.init();
     _initialized = true;
@@ -94,6 +99,7 @@ export async function createParsers() {
       parsers.set(entry.id, null);
     }
   }
+  _cachedParsers = parsers;
   return parsers;
 }
 
@@ -104,6 +110,63 @@ export function getParser(parsers, filePath) {
   return parsers.get(entry.id) || null;
 }
 
+/**
+ * Pre-parse files missing `_tree` via WASM so downstream phases (CFG, dataflow)
+ * don't each need to create parsers and re-parse independently.
+ * Only parses files whose extension is in SUPPORTED_EXTENSIONS.
+ *
+ * @param {Map<string, object>} fileSymbols - Map<relPath, { definitions, _tree, _langId, ... }>
+ * @param {string} rootDir - absolute project root
+ */
+export async function ensureWasmTrees(fileSymbols, rootDir) {
+  // Check if any file needs a tree
+  let needsParse = false;
+  for (const [relPath, symbols] of fileSymbols) {
+    if (!symbols._tree) {
+      const ext = path.extname(relPath).toLowerCase();
+      if (_extToLang.has(ext)) {
+        needsParse = true;
+        break;
+      }
+    }
+  }
+  if (!needsParse) return;
+
+  const parsers = await createParsers();
+
+  for (const [relPath, symbols] of fileSymbols) {
+    if (symbols._tree) continue;
+    const ext = path.extname(relPath).toLowerCase();
+    const entry = _extToLang.get(ext);
+    if (!entry) continue;
+    const parser = parsers.get(entry.id);
+    if (!parser) continue;
+
+    const absPath = path.join(rootDir, relPath);
+    let code;
+    try {
+      code = fs.readFileSync(absPath, 'utf-8');
+    } catch {
+      continue;
+    }
+    try {
+      symbols._tree = parser.parse(code);
+      symbols._langId = entry.id;
+    } catch {
+      // skip files that fail to parse
+    }
+  }
+}
+
+/**
+ * Check whether the required WASM grammar files exist on disk.
+ */
+export function isWasmAvailable() {
+  return LANGUAGE_REGISTRY.filter((e) => e.required).every((e) =>
+    fs.existsSync(grammarPath(e.grammarFile)),
+  );
+}
+
 // ── Unified API ──────────────────────────────────────────────────────────────
 
 function resolveEngine(opts = {}) {
@@ -183,6 +246,13 @@ function normalizeNativeSymbols(result) {
       kind: e.kind,
       line: e.line,
     })),
+    astNodes: (result.astNodes ?? result.ast_nodes ?? []).map((n) => ({
+      kind: n.kind,
+      name: n.name,
+      line: n.line,
+      text: n.text ?? null,
+      receiver: n.receiver ?? null,
+    })),
   };
 }
 

package/src/structure.js

@@ -17,7 +17,7 @@ import { isTestFile } from './queries.js';
  * @param {Map<string, number>} lineCountMap - Map of relPath → line count
  * @param {Set<string>} directories - Set of relative directory paths
  */
-export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, directories) {
+export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, directories, changedFiles) {
   const insertNode = db.prepare(
     'INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)',
   );
@@ -33,15 +33,49 @@ export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, director
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
 
-  // Clean previous directory nodes/edges (idempotent rebuild)
-  // Scope contains-edge delete to directory-sourced edges only,
-  // preserving symbol-level contains edges (file→def, class→method, etc.)
-  db.exec(`
-    DELETE FROM edges WHERE kind = 'contains'
-      AND source_id IN (SELECT id FROM nodes WHERE kind = 'directory');
-    DELETE FROM node_metrics;
-    DELETE FROM nodes WHERE kind = 'directory';
-  `);
+  const isIncremental = changedFiles != null && changedFiles.length > 0;
+
+  if (isIncremental) {
+    // Incremental: only clean up data for changed files and their ancestor directories
+    const affectedDirs = new Set();
+    for (const f of changedFiles) {
+      let d = normalizePath(path.dirname(f));
+      while (d && d !== '.') {
+        affectedDirs.add(d);
+        d = normalizePath(path.dirname(d));
+      }
+    }
+    const deleteContainsForDir = db.prepare(
+      "DELETE FROM edges WHERE kind = 'contains' AND source_id IN (SELECT id FROM nodes WHERE name = ? AND kind = 'directory')",
+    );
+    const deleteMetricForNode = db.prepare('DELETE FROM node_metrics WHERE node_id = ?');
+    db.transaction(() => {
+      // Delete contains edges only from affected directories
+      for (const dir of affectedDirs) {
+        deleteContainsForDir.run(dir);
+      }
+      // Delete metrics for changed files
+      for (const f of changedFiles) {
+        const fileRow = getNodeId.get(f, 'file', f, 0);
+        if (fileRow) deleteMetricForNode.run(fileRow.id);
+      }
+      // Delete metrics for affected directories
+      for (const dir of affectedDirs) {
+        const dirRow = getNodeId.get(dir, 'directory', dir, 0);
+        if (dirRow) deleteMetricForNode.run(dirRow.id);
+      }
+    })();
+  } else {
+    // Full rebuild: clean previous directory nodes/edges (idempotent)
+    // Scope contains-edge delete to directory-sourced edges only,
+    // preserving symbol-level contains edges (file→def, class→method, etc.)
+    db.exec(`
+      DELETE FROM edges WHERE kind = 'contains'
+        AND source_id IN (SELECT id FROM nodes WHERE kind = 'directory');
+      DELETE FROM node_metrics;
+      DELETE FROM nodes WHERE kind = 'directory';
+    `);
+  }
 
   // Step 1: Ensure all directories are represented (including intermediate parents)
   const allDirs = new Set();
@@ -61,7 +95,7 @@ export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, director
     }
   }
 
-  // Step 2: Insert directory nodes
+  // Step 2: Insert directory nodes (INSERT OR IGNORE — safe for incremental)
   const insertDirs = db.transaction(() => {
     for (const dir of allDirs) {
       insertNode.run(dir, 'directory', dir, 0, null);
@@ -70,11 +104,28 @@ export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, director
   insertDirs();
 
   // Step 3: Insert 'contains' edges (dir → file, dir → subdirectory)
+  // On incremental, only re-insert for affected directories (others are intact)
+  const affectedDirs = isIncremental
+    ? (() => {
+        const dirs = new Set();
+        for (const f of changedFiles) {
+          let d = normalizePath(path.dirname(f));
+          while (d && d !== '.') {
+            dirs.add(d);
+            d = normalizePath(path.dirname(d));
+          }
+        }
+        return dirs;
+      })()
+    : null;
+
   const insertContains = db.transaction(() => {
     // dir → file
     for (const relPath of fileSymbols.keys()) {
       const dir = normalizePath(path.dirname(relPath));
       if (!dir || dir === '.') continue;
+      // On incremental, skip dirs whose contains edges are intact
+      if (affectedDirs && !affectedDirs.has(dir)) continue;
       const dirRow = getNodeId.get(dir, 'directory', dir, 0);
       const fileRow = getNodeId.get(relPath, 'file', relPath, 0);
       if (dirRow && fileRow) {
@@ -85,6 +136,8 @@ export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, director
     for (const dir of allDirs) {
       const parent = normalizePath(path.dirname(dir));
       if (!parent || parent === '.' || parent === dir) continue;
+      // On incremental, skip parent dirs whose contains edges are intact
+      if (affectedDirs && !affectedDirs.has(parent)) continue;
       const parentRow = getNodeId.get(parent, 'directory', parent, 0);
       const childRow = getNodeId.get(dir, 'directory', dir, 0);
       if (parentRow && childRow) {