@optave/codegraph 3.0.3 → 3.1.0

package/src/parser.js

@@ -183,77 +183,55 @@ function resolveEngine(opts = {}) {
 }
 
 /**
- * Normalize native engine output to match the camelCase convention
- * used by the WASM extractors.
+ * Patch native engine output in-place for the few remaining semantic transforms.
+ * With #[napi(js_name)] on Rust types, most fields already arrive as camelCase.
+ * This only handles:
+ *  - _lineCount compat for builder.js
+ *  - Backward compat for older native binaries missing js_name annotations
+ *  - dataflow argFlows/mutations bindingType → binding wrapper
  */
-function normalizeNativeSymbols(result) {
-  return {
-    _lineCount: result.lineCount ?? result.line_count ?? null,
-    definitions: (result.definitions || []).map((d) => ({
-      name: d.name,
-      kind: d.kind,
-      line: d.line,
-      endLine: d.endLine ?? d.end_line ?? null,
-      decorators: d.decorators,
-      complexity: d.complexity
-        ? {
-            cognitive: d.complexity.cognitive,
-            cyclomatic: d.complexity.cyclomatic,
-            maxNesting: d.complexity.maxNesting,
-            halstead: d.complexity.halstead ?? null,
-            loc: d.complexity.loc ?? null,
-            maintainabilityIndex: d.complexity.maintainabilityIndex ?? null,
-          }
-        : null,
-      children: d.children?.length
-        ? d.children.map((c) => ({
-            name: c.name,
-            kind: c.kind,
-            line: c.line,
-            endLine: c.endLine ?? c.end_line ?? null,
-          }))
-        : undefined,
-    })),
-    calls: (result.calls || []).map((c) => ({
-      name: c.name,
-      line: c.line,
-      dynamic: c.dynamic,
-      receiver: c.receiver,
-    })),
-    imports: (result.imports || []).map((i) => ({
-      source: i.source,
-      names: i.names || [],
-      line: i.line,
-      typeOnly: i.typeOnly ?? i.type_only,
-      reexport: i.reexport,
-      wildcardReexport: i.wildcardReexport ?? i.wildcard_reexport,
-      pythonImport: i.pythonImport ?? i.python_import,
-      goImport: i.goImport ?? i.go_import,
-      rustUse: i.rustUse ?? i.rust_use,
-      javaImport: i.javaImport ?? i.java_import,
-      csharpUsing: i.csharpUsing ?? i.csharp_using,
-      rubyRequire: i.rubyRequire ?? i.ruby_require,
-      phpUse: i.phpUse ?? i.php_use,
-    })),
-    classes: (result.classes || []).map((c) => ({
-      name: c.name,
-      extends: c.extends,
-      implements: c.implements,
-      line: c.line,
-    })),
-    exports: (result.exports || []).map((e) => ({
-      name: e.name,
-      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,
-    })),
-  };
+function patchNativeResult(r) {
+  // lineCount: napi(js_name) emits "lineCount"; older binaries may emit "line_count"
+  r.lineCount = r.lineCount ?? r.line_count ?? null;
+  r._lineCount = r.lineCount;
+
+  // Backward compat for older binaries missing js_name annotations
+  if (r.definitions) {
+    for (const d of r.definitions) {
+      if (d.endLine === undefined && d.end_line !== undefined) {
+        d.endLine = d.end_line;
+      }
+    }
+  }
+  if (r.imports) {
+    for (const i of r.imports) {
+      if (i.typeOnly === undefined) i.typeOnly = i.type_only;
+      if (i.wildcardReexport === undefined) i.wildcardReexport = i.wildcard_reexport;
+      if (i.pythonImport === undefined) i.pythonImport = i.python_import;
+      if (i.goImport === undefined) i.goImport = i.go_import;
+      if (i.rustUse === undefined) i.rustUse = i.rust_use;
+      if (i.javaImport === undefined) i.javaImport = i.java_import;
+      if (i.csharpUsing === undefined) i.csharpUsing = i.csharp_using;
+      if (i.rubyRequire === undefined) i.rubyRequire = i.ruby_require;
+      if (i.phpUse === undefined) i.phpUse = i.php_use;
+    }
+  }
+
+  // dataflow: wrap bindingType into binding object for argFlows and mutations
+  if (r.dataflow) {
+    if (r.dataflow.argFlows) {
+      for (const f of r.dataflow.argFlows) {
+        f.binding = f.bindingType ? { type: f.bindingType } : null;
+      }
+    }
+    if (r.dataflow.mutations) {
+      for (const m of r.dataflow.mutations) {
+        m.binding = m.bindingType ? { type: m.bindingType } : null;
+      }
+    }
+  }
+
+  return r;
 }
 
 /**
@@ -384,8 +362,8 @@ export async function parseFileAuto(filePath, source, opts = {}) {
   const { native } = resolveEngine(opts);
 
   if (native) {
-    const result = native.parseFile(filePath, source);
-    return result ? normalizeNativeSymbols(result) : null;
+    const result = native.parseFile(filePath, source, !!opts.dataflow, opts.ast !== false);
+    return result ? patchNativeResult(result) : null;
   }
 
   // WASM path
@@ -407,11 +385,16 @@ export async function parseFilesAuto(filePaths, rootDir, opts = {}) {
   const result = new Map();
 
   if (native) {
-    const nativeResults = native.parseFiles(filePaths, rootDir);
+    const nativeResults = native.parseFiles(
+      filePaths,
+      rootDir,
+      !!opts.dataflow,
+      opts.ast !== false,
+    );
     for (const r of nativeResults) {
       if (!r) continue;
       const relPath = path.relative(rootDir, r.file).split(path.sep).join('/');
-      result.set(relPath, normalizeNativeSymbols(r));
+      result.set(relPath, patchNativeResult(r));
     }
     return result;
   }
@@ -476,7 +459,7 @@ export function createParseTreeCache() {
 export async function parseFileIncremental(cache, filePath, source, opts = {}) {
   if (cache) {
     const result = cache.parseFile(filePath, source);
-    return result ? normalizeNativeSymbols(result) : null;
+    return result ? patchNativeResult(result) : null;
   }
   return parseFileAuto(filePath, source, opts);
 }

package/src/queries.js

@@ -163,7 +163,7 @@ function resolveMethodViaHierarchy(db, methodName) {
  * Find nodes matching a name query, ranked by relevance.
  * Scoring: exact=100, prefix=60, word-boundary=40, substring=10, plus fan-in tiebreaker.
  */
-function findMatchingNodes(db, name, opts = {}) {
+export function findMatchingNodes(db, name, opts = {}) {
   const kinds = opts.kind ? [opts.kind] : FUNCTION_KINDS;
   const placeholders = kinds.map(() => '?').join(', ');
   const params = [`%${name}%`, ...kinds];
@@ -3134,31 +3134,49 @@ export function roles(customDbPath, opts = {}) {
 
 // ─── exportsData ─────────────────────────────────────────────────────
 
-function exportsFileImpl(db, target, noTests, getFileLines) {
+function exportsFileImpl(db, target, noTests, getFileLines, unused) {
   const fileNodes = db
     .prepare(`SELECT * FROM nodes WHERE file LIKE ? AND kind = 'file'`)
     .all(`%${target}%`);
   if (fileNodes.length === 0) return [];
 
+  // Detect whether exported column exists
+  let hasExportedCol = false;
+  try {
+    db.prepare('SELECT exported FROM nodes LIMIT 0').raw();
+    hasExportedCol = true;
+  } catch {
+    /* old DB without exported column */
+  }
+
   return fileNodes.map((fn) => {
     const symbols = db
       .prepare(`SELECT * FROM nodes WHERE file = ? AND kind != 'file' ORDER BY line`)
       .all(fn.file);
 
-    // IDs of symbols that have incoming calls from other files (exported)
-    const exportedIds = new Set(
-      db
+    let exported;
+    if (hasExportedCol) {
+      // Use the exported column populated during build
+      exported = db
         .prepare(
-          `SELECT DISTINCT e.target_id FROM edges e
-           JOIN nodes caller ON e.source_id = caller.id
-           JOIN nodes target ON e.target_id = target.id
-           WHERE target.file = ? AND caller.file != ? AND e.kind = 'calls'`,
+          "SELECT * FROM nodes WHERE file = ? AND kind != 'file' AND exported = 1 ORDER BY line",
         )
-        .all(fn.file, fn.file)
-        .map((r) => r.target_id),
-    );
-
-    const exported = symbols.filter((s) => exportedIds.has(s.id));
+        .all(fn.file);
+    } else {
+      // Fallback: symbols that have incoming calls from other files
+      const exportedIds = new Set(
+        db
+          .prepare(
+            `SELECT DISTINCT e.target_id FROM edges e
+             JOIN nodes caller ON e.source_id = caller.id
+             JOIN nodes target ON e.target_id = target.id
+             WHERE target.file = ? AND caller.file != ? AND e.kind = 'calls'`,
+          )
+          .all(fn.file, fn.file)
+          .map((r) => r.target_id),
+      );
+      exported = symbols.filter((s) => exportedIds.has(s.id));
+    }
     const internalCount = symbols.length - exported.length;
 
     const results = exported.map((s) => {
@@ -3185,6 +3203,8 @@ function exportsFileImpl(db, target, noTests, getFileLines) {
       };
     });
 
+    const totalUnused = results.filter((r) => r.consumerCount === 0).length;
+
     // Files that re-export this file (barrel → this file)
     const reexports = db
       .prepare(
@@ -3194,12 +3214,18 @@ function exportsFileImpl(db, target, noTests, getFileLines) {
       .all(fn.id)
       .map((r) => ({ file: r.file }));
 
+    let filteredResults = results;
+    if (unused) {
+      filteredResults = results.filter((r) => r.consumerCount === 0);
+    }
+
     return {
       file: fn.file,
-      results,
+      results: filteredResults,
       reexports,
       totalExported: exported.length,
       totalInternal: internalCount,
+      totalUnused,
     };
   });
 }
@@ -3229,12 +3255,13 @@ export function exportsData(file, customDbPath, opts = {}) {
     }
   }
 
-  const fileResults = exportsFileImpl(db, file, noTests, getFileLines);
+  const unused = opts.unused || false;
+  const fileResults = exportsFileImpl(db, file, noTests, getFileLines, unused);
   db.close();
 
   if (fileResults.length === 0) {
     return paginateResult(
-      { file, results: [], reexports: [], totalExported: 0, totalInternal: 0 },
+      { file, results: [], reexports: [], totalExported: 0, totalInternal: 0, totalUnused: 0 },
       'results',
       { limit: opts.limit, offset: opts.offset },
     );
@@ -3248,6 +3275,7 @@ export function exportsData(file, customDbPath, opts = {}) {
     reexports: first.reexports,
     totalExported: first.totalExported,
     totalInternal: first.totalInternal,
+    totalUnused: first.totalUnused,
   };
   return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
 }
@@ -3264,13 +3292,24 @@ export function fileExports(file, customDbPath, opts = {}) {
   }
 
   if (data.results.length === 0) {
-    console.log(`No exported symbols found for "${file}". Run "codegraph build" first.`);
+    if (opts.unused) {
+      console.log(`No unused exports found for "${file}".`);
+    } else {
+      console.log(`No exported symbols found for "${file}". Run "codegraph build" first.`);
+    }
     return;
   }
 
-  console.log(
-    `\n# ${data.file} — ${data.totalExported} exported, ${data.totalInternal} internal\n`,
-  );
+  if (opts.unused) {
+    console.log(
+      `\n# ${data.file} — ${data.totalUnused} unused export${data.totalUnused !== 1 ? 's' : ''} (of ${data.totalExported} exported)\n`,
+    );
+  } else {
+    const unusedNote = data.totalUnused > 0 ? ` (${data.totalUnused} unused)` : '';
+    console.log(
+      `\n# ${data.file} — ${data.totalExported} exported${unusedNote}, ${data.totalInternal} internal\n`,
+    );
+  }
 
   for (const sym of data.results) {
     const icon = kindIcon(sym.kind);

package/src/resolve.js

@@ -146,8 +146,12 @@ export function computeConfidence(callerFile, targetFile, importedFrom) {
 /**
  * Batch resolve multiple imports in a single native call.
  * Returns Map<"fromFile|importSource", resolvedPath> or null when native unavailable.
+ * @param {Array} inputs - Array of { fromFile, importSource }
+ * @param {string} rootDir - Project root
+ * @param {object} aliases - Path aliases
+ * @param {string[]} [knownFiles] - Optional file paths for FS cache (avoids syscalls)
  */
-export function resolveImportsBatch(inputs, rootDir, aliases) {
+export function resolveImportsBatch(inputs, rootDir, aliases, knownFiles) {
   const native = loadNative();
   if (!native) return null;
 
@@ -156,7 +160,12 @@ export function resolveImportsBatch(inputs, rootDir, aliases) {
       fromFile,
       importSource,
     }));
-    const results = native.resolveImports(nativeInputs, rootDir, convertAliasesForNative(aliases));
+    const results = native.resolveImports(
+      nativeInputs,
+      rootDir,
+      convertAliasesForNative(aliases),
+      knownFiles || null,
+    );
     const map = new Map();
     for (const r of results) {
       map.set(`${r.fromFile}|${r.importSource}`, normalizePath(path.normalize(r.resolvedPath)));