fix: resolve dogfood issues #408–#411

crates/codegraph-core/src/extractors/javascript.rs

@@ -204,7 +204,23 @@ fn walk_node(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
 
         "call_expression" => {
             if let Some(fn_node) = node.child_by_field_name("function") {
-                if let Some(call_info) = extract_call_info(&fn_node, node, source) {
+                // Detect dynamic import() expressions
+                if fn_node.kind() == "import" {
+                    if let Some(args) = node.child_by_field_name("arguments")
+                        .or_else(|| find_child(node, "arguments"))
+                    {
+                        if let Some(str_node) = find_child(&args, "string")
+                            .or_else(|| find_child(&args, "template_string"))
+                        {
+                            let mod_path = node_text(&str_node, source)
+                                .replace(&['\'', '"', '`'][..], "");
+                            let names = extract_dynamic_import_names(node, source);
+                            let mut imp = Import::new(mod_path, names, start_line(node));
+                            imp.dynamic_import = Some(true);
+                            symbols.imports.push(imp);
+                        }
+                    }
+                } else if let Some(call_info) = extract_call_info(&fn_node, node, source) {
                     symbols.calls.push(call_info);
                 }
             }
@@ -1000,6 +1016,96 @@ fn find_parent_class<'a>(node: &Node<'a>, source: &[u8]) -> Option<String> {
     None
 }
 
+/// Extract named bindings from a dynamic `import()` call expression.
+/// Handles: `const { a, b } = await import(...)` and `const mod = await import(...)`
+fn extract_dynamic_import_names(call_node: &Node, source: &[u8]) -> Vec<String> {
+    // Walk up: call_expression → await_expression? → variable_declarator
+    let mut current = call_node.parent();
+    if let Some(parent) = current {
+        if parent.kind() == "await_expression" {
+            current = parent.parent();
+        }
+    }
+    let declarator = match current {
+        Some(n) if n.kind() == "variable_declarator" => n,
+        _ => return Vec::new(),
+    };
+    let name_node = match declarator.child_by_field_name("name") {
+        Some(n) => n,
+        None => return Vec::new(),
+    };
+    match name_node.kind() {
+        // const { a, b } = await import(...)
+        "object_pattern" => {
+            let mut names = Vec::new();
+            for i in 0..name_node.child_count() {
+                if let Some(child) = name_node.child(i) {
+                    if child.kind() == "shorthand_property_identifier_pattern"
+                        || child.kind() == "shorthand_property_identifier"
+                    {
+                        names.push(node_text(&child, source).to_string());
+                    } else if child.kind() == "pair_pattern" || child.kind() == "pair" {
+                        if let Some(val) = child.child_by_field_name("value") {
+                            // Handle `{ foo: bar = 'default' }` — extract the left-hand binding
+                            let binding = if val.kind() == "assignment_pattern" {
+                                val.child_by_field_name("left").unwrap_or(val)
+                            } else if val.kind() == "identifier" {
+                                val
+                            } else {
+                                // Nested pattern (e.g. `{ foo: { bar } }`) — skip;
+                                // full nested support requires recursive extraction.
+                                continue;
+                            };
+                            names.push(node_text(&binding, source).to_string());
+                        } else if let Some(key) = child.child_by_field_name("key") {
+                            names.push(node_text(&key, source).to_string());
+                        }
+                    } else if child.kind() == "object_assignment_pattern" {
+                        // Handle `{ a = 'default' }` — extract the left-hand binding
+                        if let Some(left) = child.child_by_field_name("left") {
+                            names.push(node_text(&left, source).to_string());
+                        }
+                    } else if child.kind() == "rest_pattern" || child.kind() == "rest_element" {
+                        // Handle `{ a, ...rest }` — extract the identifier inside the spread
+                        if let Some(inner) = child.child(0) {
+                            if inner.kind() == "identifier" {
+                                names.push(node_text(&inner, source).to_string());
+                            }
+                        }
+                    }
+                }
+            }
+            names
+        }
+        // const mod = await import(...)
+        "identifier" => vec![node_text(&name_node, source).to_string()],
+        // const [first, second] = await import(...)
+        "array_pattern" => {
+            let mut names = Vec::new();
+            for i in 0..name_node.child_count() {
+                if let Some(child) = name_node.child(i) {
+                    if child.kind() == "identifier" {
+                        names.push(node_text(&child, source).to_string());
+                    } else if child.kind() == "assignment_pattern" {
+                        if let Some(left) = child.child_by_field_name("left") {
+                            names.push(node_text(&left, source).to_string());
+                        }
+                    } else if child.kind() == "rest_pattern" || child.kind() == "rest_element" {
+                        // Handle `[a, ...rest]` — extract the identifier inside the spread
+                        if let Some(inner) = child.child(0) {
+                            if inner.kind() == "identifier" {
+                                names.push(node_text(&inner, source).to_string());
+                            }
+                        }
+                    }
+                }
+            }
+            names
+        }
+        _ => Vec::new(),
+    }
+}
+
 fn extract_import_names(node: &Node, source: &[u8]) -> Vec<String> {
     let mut names = Vec::new();
     scan_import_names(node, source, &mut names);
@@ -1334,4 +1440,22 @@ mod tests {
         assert_eq!(str_nodes.len(), 1);
         assert!(str_nodes[0].name.contains("hello template"));
     }
+
+    #[test]
+    fn finds_dynamic_import() {
+        let s = parse_js("const mod = import('./foo.js');");
+        let dyn_imports: Vec<_> = s.imports.iter().filter(|i| i.dynamic_import == Some(true)).collect();
+        assert_eq!(dyn_imports.len(), 1);
+        assert_eq!(dyn_imports[0].source, "./foo.js");
+    }
+
+    #[test]
+    fn finds_dynamic_import_with_destructuring() {
+        let s = parse_js("const { a, b } = await import('./bar.js');");
+        let dyn_imports: Vec<_> = s.imports.iter().filter(|i| i.dynamic_import == Some(true)).collect();
+        assert_eq!(dyn_imports.len(), 1);
+        assert_eq!(dyn_imports[0].source, "./bar.js");
+        assert!(dyn_imports[0].names.contains(&"a".to_string()));
+        assert!(dyn_imports[0].names.contains(&"b".to_string()));
+    }
 }

crates/codegraph-core/src/types.rs

@@ -136,6 +136,8 @@ pub struct Import {
     pub ruby_require: Option<bool>,
     #[napi(js_name = "phpUse")]
     pub php_use: Option<bool>,
+    #[napi(js_name = "dynamicImport")]
+    pub dynamic_import: Option<bool>,
 }
 
 impl Import {
@@ -154,6 +156,7 @@ impl Import {
             csharp_using: None,
             ruby_require: None,
             php_use: None,
+            dynamic_import: None,
         }
     }
 }

scripts/benchmark.js

@@ -179,14 +179,22 @@ if (!hasWasm && !hasNative) {
 
 let wasm = null;
 if (hasWasm) {
-	wasm = await benchmarkEngine('wasm');
+	try {
+		wasm = await benchmarkEngine('wasm');
+	} catch (err) {
+		console.error(`WASM benchmark failed: ${err?.message ?? String(err)}`);
+	}
 } else {
 	console.error('WASM grammars not built — skipping WASM benchmark');
 }
 
 let native = null;
 if (hasNative) {
-	native = await benchmarkEngine('native');
+	try {
+		native = await benchmarkEngine('native');
+	} catch (err) {
+		console.error(`Native benchmark failed: ${err?.message ?? String(err)}`);
+	}
 } else {
 	console.error('Native engine not available — skipping native benchmark');
 }
@@ -195,6 +203,11 @@ if (hasNative) {
 console.log = origLog;
 
 const primary = wasm || native;
+if (!primary) {
+	console.error('Error: Both engines failed. No results to report.');
+	cleanup();
+	process.exit(1);
+}
 const result = {
 	version,
 	date: new Date().toISOString().slice(0, 10),

scripts/embedding-benchmark.js

@@ -128,9 +128,14 @@ for (const key of modelKeys) {
 			`  Hit@1=${r.hits1}/${r.total} Hit@3=${r.hits3}/${r.total} Hit@5=${r.hits5}/${r.total} misses=${r.misses}`,
 		);
 	} catch (err) {
-		console.error(`  FAILED: ${err.message}`);
+		console.error(`  FAILED: ${err?.message ?? String(err)}`);
+	} finally {
+		try {
+			await disposeModel();
+		} catch (disposeErr) {
+			console.error(`  disposeModel failed: ${disposeErr?.message ?? String(disposeErr)}`);
+		}
 	}
-	await disposeModel();
 }
 
 // Restore console.log for JSON output

src/builder.js

@@ -1354,8 +1354,13 @@ export async function buildGraph(rootDir, opts = {}) {
 
   _t.finalize0 = performance.now();
 
-  // Release any remaining cached WASM trees for GC
+  // Release any remaining cached WASM trees — call .delete() to free WASM memory
   for (const [, symbols] of allSymbols) {
+    if (symbols._tree && typeof symbols._tree.delete === 'function') {
+      try {
+        symbols._tree.delete();
+      } catch {}
+    }
     symbols._tree = null;
     symbols._langId = null;
   }

src/cli.js

@@ -1390,7 +1390,7 @@ program
   .command('info')
   .description('Show codegraph engine info and diagnostics')
   .action(async () => {
-    const { isNativeAvailable, loadNative } = await import('./native.js');
+    const { getNativePackageVersion, isNativeAvailable, loadNative } = await import('./native.js');
     const { getActiveEngine } = await import('./parser.js');
 
     const engine = program.opts().engine;
@@ -1405,9 +1405,17 @@ program
     console.log(`  Native engine : ${nativeAvailable ? 'available' : 'unavailable'}`);
     if (nativeAvailable) {
       const native = loadNative();
-      const nativeVersion =
+      const binaryVersion =
         typeof native.engineVersion === 'function' ? native.engineVersion() : 'unknown';
-      console.log(`  Native version: ${nativeVersion}`);
+      const pkgVersion = getNativePackageVersion();
+      const knownBinaryVersion = binaryVersion !== 'unknown' ? binaryVersion : null;
+      if (pkgVersion && knownBinaryVersion && pkgVersion !== knownBinaryVersion) {
+        console.log(
+          `  Native version: ${pkgVersion} (binary reports ${knownBinaryVersion} — stale)`,
+        );
+      } else {
+        console.log(`  Native version: ${pkgVersion ?? binaryVersion}`);
+      }
     }
     console.log(`  Engine flag   : --engine ${engine}`);
     console.log(`  Active engine : ${activeName}${activeVersion ? ` (v${activeVersion})` : ''}`);

src/index.js

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

src/native.js

@@ -11,14 +11,15 @@ import os from 'node:os';
 
 let _cached; // undefined = not yet tried, null = failed, object = module
 let _loadError = null;
+const _require = createRequire(import.meta.url);
 
 /**
  * Detect whether the current Linux environment uses glibc or musl.
  * Returns 'gnu' for glibc, 'musl' for musl, 'gnu' as fallback.
  */
 function detectLibc() {
   try {
-    const { readdirSync } = require('node:fs');
+    const { readdirSync } = _require('node:fs');
     const files = readdirSync('/lib');
     if (files.some((f) => f.startsWith('ld-musl-') && f.endsWith('.so.1'))) {
       return 'musl';
@@ -38,28 +39,34 @@ const PLATFORM_PACKAGES = {
   'win32-x64': '@optave/codegraph-win32-x64-msvc',
 };
 
+/**
+ * Resolve the platform-specific npm package name for the native addon.
+ * Returns null if the current platform is not supported.
+ */
+function resolvePlatformPackage() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const key = platform === 'linux' ? `${platform}-${arch}-${detectLibc()}` : `${platform}-${arch}`;
+  return PLATFORM_PACKAGES[key] || null;
+}
+
 /**
  * Try to load the native napi addon.
  * Returns the module on success, null on failure.
  */
 export function loadNative() {
   if (_cached !== undefined) return _cached;
 
-  const require = createRequire(import.meta.url);
-
-  const platform = os.platform();
-  const arch = os.arch();
-  const key = platform === 'linux' ? `${platform}-${arch}-${detectLibc()}` : `${platform}-${arch}`;
-  const pkg = PLATFORM_PACKAGES[key];
+  const pkg = resolvePlatformPackage();
   if (pkg) {
     try {
-      _cached = require(pkg);
+      _cached = _require(pkg);
       return _cached;
     } catch (err) {
       _loadError = err;
     }
   } else {
-    _loadError = new Error(`Unsupported platform: ${key}`);
+    _loadError = new Error(`Unsupported platform: ${os.platform()}-${os.arch()}`);
   }
 
   _cached = null;
@@ -73,6 +80,21 @@ export function isNativeAvailable() {
   return loadNative() !== null;
 }
 
+/**
+ * Read the version from the platform-specific npm package.json.
+ * Returns null if the package is not installed or has no version.
+ */
+export function getNativePackageVersion() {
+  const pkg = resolvePlatformPackage();
+  if (!pkg) return null;
+  try {
+    const pkgJson = _require(`${pkg}/package.json`);
+    return pkgJson.version || null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Return the native module or throw if not available.
  */