fix: eliminate redundant file re-parsing in complexity metrics

Cache WASM parse trees from parseFilesAuto and pass them to
buildComplexityMetrics, avoiding redundant parser init, file I/O,
and AST re-parsing. Native engine falls back to re-parsing as before.
Trees are nulled after use to allow prompt GC.

Impact: 5 functions changed, 7 affected

Author: github-actions[bot]

src/builder.js

@@ -1014,6 +1014,12 @@ export async function buildGraph(rootDir, opts = {}) {
     debug(`Complexity analysis failed: ${err.message}`);
   }
 
+  // Release any remaining cached WASM trees for GC
+  for (const [, symbols] of allSymbols) {
+    symbols._tree = null;
+    symbols._langId = null;
+  }
+
   const nodeCount = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c;
   info(`Graph built: ${nodeCount} nodes, ${edgeCount} edges`);
   info(`Stored in ${dbPath}`);

src/complexity.js

@@ -234,17 +234,28 @@ function findFunctionNode(rootNode, startLine, _endLine, rules) {
  * @param {object} [engineOpts] - engine options (unused; always uses WASM for AST)
  */
 export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOpts) {
-  const { createParsers, getParser } = await import('./parser.js');
-  const parsers = await createParsers();
-
-  // Map extensions to language IDs
-  const { LANGUAGE_REGISTRY } = await import('./parser.js');
-  const extToLang = new Map();
-  for (const entry of LANGUAGE_REGISTRY) {
-    for (const ext of entry.extensions) {
-      extToLang.set(ext, entry.id);
+  // Only initialize WASM parsers if some files lack a cached tree (native engine path)
+  let parsers = null;
+  let extToLang = null;
+  let needsFallback = false;
+  for (const [, symbols] of fileSymbols) {
+    if (!symbols._tree) {
+      needsFallback = true;
+      break;
     }
   }
+  if (needsFallback) {
+    const { createParsers, LANGUAGE_REGISTRY } = await import('./parser.js');
+    parsers = await createParsers();
+    extToLang = new Map();
+    for (const entry of LANGUAGE_REGISTRY) {
+      for (const ext of entry.extensions) {
+        extToLang.set(ext, entry.id);
+      }
+    }
+  }
+
+  const { getParser } = await import('./parser.js');
 
   const upsert = db.prepare(
     'INSERT OR REPLACE INTO function_complexity (node_id, cognitive, cyclomatic, max_nesting) VALUES (?, ?, ?, ?)',
@@ -257,30 +268,35 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
 
   const tx = db.transaction(() => {
     for (const [relPath, symbols] of fileSymbols) {
-      const ext = path.extname(relPath).toLowerCase();
-      const langId = extToLang.get(ext);
-      if (!langId) continue;
+      let tree = symbols._tree;
+      let langId = symbols._langId;
+
+      // Fallback: re-read and re-parse when no cached tree (native engine)
+      if (!tree) {
+        const ext = path.extname(relPath).toLowerCase();
+        langId = extToLang.get(ext);
+        if (!langId) continue;
+
+        const absPath = path.join(rootDir, relPath);
+        let code;
+        try {
+          code = fs.readFileSync(absPath, 'utf-8');
+        } catch {
+          continue;
+        }
 
-      const rules = COMPLEXITY_RULES.get(langId);
-      if (!rules) continue;
+        const parser = getParser(parsers, absPath);
+        if (!parser) continue;
 
-      const absPath = path.join(rootDir, relPath);
-      let code;
-      try {
-        code = fs.readFileSync(absPath, 'utf-8');
-      } catch {
-        continue;
+        try {
+          tree = parser.parse(code);
+        } catch {
+          continue;
+        }
       }
 
-      const parser = getParser(parsers, absPath);
-      if (!parser) continue;
-
-      let tree;
-      try {
-        tree = parser.parse(code);
-      } catch {
-        continue;
-      }
+      const rules = COMPLEXITY_RULES.get(langId);
+      if (!rules) continue;
 
       for (const def of symbols.definitions) {
         if (def.kind !== 'function' && def.kind !== 'method') continue;
@@ -298,6 +314,9 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
         upsert.run(row.id, result.cognitive, result.cyclomatic, result.maxNesting);
         analyzed++;
       }
+
+      // Release cached tree for GC
+      symbols._tree = null;
     }
   });
 

src/parser.js

@@ -279,7 +279,8 @@ function wasmExtractSymbols(parsers, filePath, code) {
   const entry = _extToLang.get(ext);
   if (!entry) return null;
   const query = _queryCache.get(entry.id) || null;
-  return entry.extractor(tree, filePath, query);
+  const symbols = entry.extractor(tree, filePath, query);
+  return symbols ? { symbols, tree, langId: entry.id } : null;
 }
 
 /**
@@ -300,7 +301,8 @@ export async function parseFileAuto(filePath, source, opts = {}) {
 
   // WASM path
   const parsers = await createParsers();
-  return wasmExtractSymbols(parsers, filePath, source);
+  const extracted = wasmExtractSymbols(parsers, filePath, source);
+  return extracted ? extracted.symbols : null;
 }
 
 /**
@@ -335,10 +337,12 @@ export async function parseFilesAuto(filePaths, rootDir, opts = {}) {
       warn(`Skipping ${path.relative(rootDir, filePath)}: ${err.message}`);
       continue;
     }
-    const symbols = wasmExtractSymbols(parsers, filePath, code);
-    if (symbols) {
+    const extracted = wasmExtractSymbols(parsers, filePath, code);
+    if (extracted) {
       const relPath = path.relative(rootDir, filePath).split(path.sep).join('/');
-      result.set(relPath, symbols);
+      extracted.symbols._tree = extracted.tree;
+      extracted.symbols._langId = extracted.langId;
+      result.set(relPath, extracted.symbols);
     }
   }
   return result;