@optave/codegraph 3.9.0 → 3.9.1

package/src/ast-analysis/engine.ts

@@ -215,25 +215,37 @@ function runNativeAnalysis(
   }
 }
 
+/** Index native results by line number and match to a definition by name. */
+function indexNativeByLine<T extends { line: number; name: string }>(
+  results: T[],
+): Map<number, T[]> {
+  const byLine = new Map<number, T[]>();
+  for (const r of results) {
+    if (!byLine.has(r.line)) byLine.set(r.line, []);
+    byLine.get(r.line)!.push(r);
+  }
+  return byLine;
+}
+
+function matchNativeResult<T extends { name: string }>(
+  candidates: T[] | undefined,
+  defName: string,
+): T | undefined {
+  if (!candidates) return undefined;
+  if (candidates.length === 1) return candidates[0];
+  return candidates.find((r) => r.name === defName) ?? candidates[0];
+}
+
 /** Store native complexity results on definitions, matched by line number. */
 function storeNativeComplexityResults(
   results: NativeFunctionComplexityResult[],
   defs: Definition[],
 ): void {
-  const byLine = new Map<number, NativeFunctionComplexityResult[]>();
-  for (const r of results) {
-    if (!byLine.has(r.line)) byLine.set(r.line, []);
-    byLine.get(r.line)!.push(r);
-  }
+  const byLine = indexNativeByLine(results);
 
   for (const def of defs) {
     if ((def.kind === 'function' || def.kind === 'method') && def.line && !def.complexity) {
-      const candidates = byLine.get(def.line);
-      if (!candidates) continue;
-      const match =
-        candidates.length === 1
-          ? candidates[0]
-          : (candidates.find((r) => r.name === def.name) ?? candidates[0]);
+      const match = matchNativeResult(byLine.get(def.line), def.name);
       if (!match) continue;
       const { complexity: c } = match;
       def.complexity = {
@@ -284,11 +296,7 @@ function overrideCyclomaticFromCfg(def: Definition, cfgCyclomatic: number): void
 
 /** Store native CFG results on definitions, matched by line number. */
 function storeNativeCfgResults(results: NativeFunctionCfgResult[], defs: Definition[]): void {
-  const byLine = new Map<number, NativeFunctionCfgResult[]>();
-  for (const r of results) {
-    if (!byLine.has(r.line)) byLine.set(r.line, []);
-    byLine.get(r.line)!.push(r);
-  }
+  const byLine = indexNativeByLine(results);
 
   for (const def of defs) {
     if (
@@ -297,12 +305,7 @@ function storeNativeCfgResults(results: NativeFunctionCfgResult[], defs: Definit
       def.cfg !== null &&
       !def.cfg?.blocks?.length
     ) {
-      const candidates = byLine.get(def.line);
-      if (!candidates) continue;
-      const match =
-        candidates.length === 1
-          ? candidates[0]
-          : (candidates.find((r) => r.name === def.name) ?? candidates[0]);
+      const match = matchNativeResult(byLine.get(def.line), def.name);
       if (!match) continue;
       def.cfg = match.cfg;
 
@@ -353,42 +356,61 @@ function reconcileCfgCyclomatic(fileSymbols: Map<string, ExtractorOutput>): void
 
 // ─── WASM pre-parse ─────────────────────────────────────────────────────
 
+/** Check whether a single file needs a WASM tree for any enabled analysis pass. */
+function fileNeedsWasmTree(
+  relPath: string,
+  symbols: ExtractorOutput,
+  flags: { doAst: boolean; doComplexity: boolean; doCfg: boolean; doDataflow: boolean },
+): boolean {
+  if (symbols._tree) return false;
+  const ext = path.extname(relPath).toLowerCase();
+  const defs = symbols.definitions || [];
+  const lid = symbols._langId || '';
+
+  if (
+    flags.doAst &&
+    !Array.isArray(symbols.astNodes) &&
+    (WALK_EXTENSIONS.has(ext) || AST_TYPE_MAPS.has(lid))
+  )
+    return true;
+  if (
+    flags.doComplexity &&
+    (COMPLEXITY_EXTENSIONS.has(ext) || COMPLEXITY_RULES.has(lid)) &&
+    defs.some((d) => hasFuncBody(d) && !d.complexity)
+  )
+    return true;
+  if (
+    flags.doCfg &&
+    (CFG_EXTENSIONS.has(ext) || CFG_RULES.has(lid)) &&
+    defs.some((d) => hasFuncBody(d) && d.cfg !== null && !Array.isArray(d.cfg?.blocks))
+  )
+    return true;
+  if (
+    flags.doDataflow &&
+    !symbols.dataflow &&
+    (DATAFLOW_EXTENSIONS.has(ext) || DATAFLOW_RULES.has(lid))
+  )
+    return true;
+  return false;
+}
+
 async function ensureWasmTreesIfNeeded(
   fileSymbols: Map<string, ExtractorOutput>,
   opts: AnalysisOpts,
   rootDir: string,
 ): Promise<void> {
-  const doAst = opts.ast !== false;
-  const doComplexity = opts.complexity !== false;
-  const doCfg = opts.cfg !== false;
-  const doDataflow = opts.dataflow !== false;
+  const flags = {
+    doAst: opts.ast !== false,
+    doComplexity: opts.complexity !== false,
+    doCfg: opts.cfg !== false,
+    doDataflow: opts.dataflow !== false,
+  };
 
-  if (!doAst && !doComplexity && !doCfg && !doDataflow) return;
+  if (!flags.doAst && !flags.doComplexity && !flags.doCfg && !flags.doDataflow) return;
 
   let needsWasmTrees = false;
   for (const [relPath, symbols] of fileSymbols) {
-    if (symbols._tree) continue;
-    const ext = path.extname(relPath).toLowerCase();
-    const defs = symbols.definitions || [];
-
-    // AST: need tree when native didn't provide non-call astNodes
-    const lid = symbols._langId || '';
-    const needsAst =
-      doAst &&
-      !Array.isArray(symbols.astNodes) &&
-      (WALK_EXTENSIONS.has(ext) || AST_TYPE_MAPS.has(lid));
-    const needsComplexity =
-      doComplexity &&
-      (COMPLEXITY_EXTENSIONS.has(ext) || COMPLEXITY_RULES.has(lid)) &&
-      defs.some((d) => hasFuncBody(d) && !d.complexity);
-    const needsCfg =
-      doCfg &&
-      (CFG_EXTENSIONS.has(ext) || CFG_RULES.has(lid)) &&
-      defs.some((d) => hasFuncBody(d) && d.cfg !== null && !Array.isArray(d.cfg?.blocks));
-    const needsDataflow =
-      doDataflow && !symbols.dataflow && (DATAFLOW_EXTENSIONS.has(ext) || DATAFLOW_RULES.has(lid));
-
-    if (needsAst || needsComplexity || needsCfg || needsDataflow) {
+    if (fileNeedsWasmTree(relPath, symbols, flags)) {
       needsWasmTrees = true;
       break;
     }
@@ -607,7 +629,7 @@ async function delegateToBuildFunctions(
     } catch (err: unknown) {
       debug(`buildAstNodes failed: ${toErrorMessage(err)}`);
     }
-    timing.astMs = performance.now() - t0;
+    timing.astMs += performance.now() - t0;
   }
 
   if (opts.complexity !== false) {
@@ -618,7 +640,7 @@ async function delegateToBuildFunctions(
     } catch (err: unknown) {
       debug(`buildComplexityMetrics failed: ${toErrorMessage(err)}`);
     }
-    timing.complexityMs = performance.now() - t0;
+    timing.complexityMs += performance.now() - t0;
   }
 
   if (opts.cfg !== false) {
@@ -629,7 +651,7 @@ async function delegateToBuildFunctions(
     } catch (err: unknown) {
       debug(`buildCFGData failed: ${toErrorMessage(err)}`);
     }
-    timing.cfgMs = performance.now() - t0;
+    timing.cfgMs += performance.now() - t0;
   }
 
   if (opts.dataflow !== false) {
@@ -640,7 +662,7 @@ async function delegateToBuildFunctions(
     } catch (err: unknown) {
       debug(`buildDataflowEdges failed: ${toErrorMessage(err)}`);
     }
-    timing.dataflowMs = performance.now() - t0;
+    timing.dataflowMs += performance.now() - t0;
   }
 }
 
@@ -668,7 +690,7 @@ export async function runAnalyses(
   // This fills in complexity/CFG/dataflow for files that the native parse pipeline
   // missed, avoiding the need to parse with WASM + run JS visitors.
   const native = loadNative();
-  if (native?.analyzeComplexity ?? native?.buildCfgAnalysis ?? native?.extractDataflowAnalysis) {
+  if (native?.analyzeComplexity || native?.buildCfgAnalysis || native?.extractDataflowAnalysis) {
     const t0native = performance.now();
     runNativeAnalysis(native, fileSymbols, rootDir, opts, extToLang);
     debug(`native standalone analysis: ${(performance.now() - t0native).toFixed(1)}ms`);
@@ -677,7 +699,10 @@ export async function runAnalyses(
   // WASM pre-parse for files that still need it (AST store, or native gaps)
   await ensureWasmTreesIfNeeded(fileSymbols, opts, rootDir);
 
-  // Unified pre-walk: run all applicable visitors in a single DFS per file
+  // Unified pre-walk: run all applicable visitors in a single DFS per file.
+  // Time each file's walk and distribute equally among active visitors
+  // so that phase timers (astMs, complexityMs, etc.) reflect real work — not
+  // just the DB-write tail in delegateToBuildFunctions.
   const t0walk = performance.now();
 
   for (const [relPath, symbols] of fileSymbols) {
@@ -692,7 +717,22 @@ export async function runAnalyses(
 
     if (visitors.length === 0) continue;
 
+    const walkStart = performance.now();
     const results = walkWithVisitors(symbols._tree.rootNode, visitors, langId, walkerOpts);
+    const walkMs = performance.now() - walkStart;
+
+    // Distribute walk time equally among active visitors
+    const activeCount = [astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor].filter(
+      Boolean,
+    ).length;
+    if (activeCount > 0) {
+      const share = walkMs / activeCount;
+      if (astVisitor) timing.astMs += share;
+      if (complexityVisitor) timing.complexityMs += share;
+      if (cfgVisitor) timing.cfgMs += share;
+      if (dataflowVisitor) timing.dataflowMs += share;
+    }
+
     const defs = symbols.definitions || [];
 
     if (astVisitor) {
@@ -705,6 +745,10 @@ export async function runAnalyses(
     if (dataflowVisitor) symbols.dataflow = results.dataflow as DataflowResult;
   }
 
+  // Total wall-clock time for the unified walk loop, including per-file
+  // setupVisitors overhead. Walk time is already distributed into per-phase
+  // timers above, so this field overlaps with (astMs + complexityMs + ...).
+  // It is kept as a diagnostic cross-check, not an additive bucket.
   timing._unifiedWalkMs = performance.now() - t0walk;
 
   // Reconcile: apply CFG-derived cyclomatic override for any definitions that have

package/src/ast-analysis/visitors/ast-store-visitor.ts

@@ -102,27 +102,25 @@ export function createAstStoreVisitor(
     return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
   }
 
-  function resolveNameAndText(
-    node: TreeSitterNode,
-    kind: string,
-  ): { name: string | null | undefined; text: string | null; skip?: boolean } {
-    switch (kind) {
-      case 'new':
-        return { name: extractNewName(node), text: truncate(node.text) };
-      case 'throw':
-        return { name: extractThrowName(node), text: extractExpressionText(node) };
-      case 'await':
-        return { name: extractAwaitName(node), text: extractExpressionText(node) };
-      case 'string': {
-        const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
-        if (content.length < 2) return { name: null, text: null, skip: true };
-        return { name: truncate(content, 100), text: truncate(node.text) };
-      }
-      case 'regex':
-        return { name: node.text || '?', text: truncate(node.text) };
-      default:
-        return { name: undefined, text: null };
-    }
+  type NameTextResult = { name: string | null | undefined; text: string | null; skip?: boolean };
+  type KindHandler = (node: TreeSitterNode) => NameTextResult;
+
+  const kindHandlers: Record<string, KindHandler> = {
+    new: (node) => ({ name: extractNewName(node), text: truncate(node.text) }),
+    throw: (node) => ({ name: extractThrowName(node), text: extractExpressionText(node) }),
+    await: (node) => ({ name: extractAwaitName(node), text: extractExpressionText(node) }),
+    string: (node) => {
+      const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
+      if (content.length < 2) return { name: null, text: null, skip: true };
+      return { name: truncate(content, 100), text: truncate(node.text) };
+    },
+    regex: (node) => ({ name: node.text || '?', text: truncate(node.text) }),
+  };
+  const defaultResult: NameTextResult = { name: undefined, text: null };
+
+  function resolveNameAndText(node: TreeSitterNode, kind: string): NameTextResult {
+    const handler = kindHandlers[kind];
+    return handler ? handler(node) : defaultResult;
   }
 
   function collectNode(node: TreeSitterNode, kind: string): void {

package/src/db/connection.ts

@@ -311,6 +311,7 @@ export function openReadonlyOrFail(customPath?: string): BetterSqlite3Database {
   }
   const Database = getDatabase();
   const db = new Database(dbPath, { readonly: true }) as unknown as BetterSqlite3Database;
+  db.pragma('busy_timeout = 5000');
 
   warnOnVersionMismatch(() => {
     const row = db
@@ -359,7 +360,7 @@ function openRepoNative(customDbPath?: string): { repo: Repository; close(): voi
  */
 export function openRepo(
   customDbPath?: string,
-  opts: { repo?: Repository } = {},
+  opts: { repo?: Repository; engine?: 'native' | 'wasm' | 'auto' } = {},
 ): { repo: Repository; close(): void } {
   if (opts.repo != null) {
     if (!(opts.repo instanceof Repository)) {
@@ -370,15 +371,25 @@ export function openRepo(
     return { repo: opts.repo, close() {} };
   }
 
+  // Respect explicit engine selection: opts.engine > CODEGRAPH_ENGINE env > auto.
+  // This ensures --engine wasm and benchmark workers bypass the native path.
+  const engine = opts.engine || process.env.CODEGRAPH_ENGINE || 'auto';
+
   // Try native rusqlite path first (Phase 6.14)
-  if (isNativeAvailable()) {
+  if (engine !== 'wasm' && isNativeAvailable()) {
     try {
       return openRepoNative(customDbPath);
     } catch (e) {
       // Re-throw user-visible errors (e.g. DB not found) — only silently
       // fall back for native-engine failures (e.g. incompatible native binary).
       if (e instanceof DbError) throw e;
-      debug(`openRepo: native path failed, falling back to better-sqlite3: ${toErrorMessage(e)}`);
+      // Re-throw locking/busy errors — falling back to better-sqlite3 would
+      // hit the same contention (and potentially hang without busy_timeout).
+      const msg = toErrorMessage(e);
+      if (/\b(busy|locked|SQLITE_BUSY|SQLITE_LOCKED)\b/i.test(msg)) {
+        throw new DbError(`Database is busy (another process may be writing): ${msg}`, {});
+      }
+      debug(`openRepo: native path failed, falling back to better-sqlite3: ${msg}`);
     }
   }
 
@@ -405,14 +416,22 @@ export function openReadonlyWithNative(customPath?: string): {
 } {
   const db = openReadonlyOrFail(customPath);
 
+  // Respect explicit engine selection, consistent with openRepo().
+  const engine = process.env.CODEGRAPH_ENGINE || 'auto';
+
   let nativeDb: NativeDatabase | undefined;
-  if (isNativeAvailable()) {
+  if (engine !== 'wasm' && isNativeAvailable()) {
     try {
       const dbPath = findDbPath(customPath);
       const native = getNative();
       nativeDb = native.NativeDatabase.openReadonly(dbPath);
     } catch (e) {
-      debug(`openReadonlyWithNative: native path failed: ${toErrorMessage(e)}`);
+      const msg = toErrorMessage(e);
+      if (/\b(busy|locked|SQLITE_BUSY|SQLITE_LOCKED)\b/i.test(msg)) {
+        debug(`openReadonlyWithNative: native path busy, skipping native DB: ${msg}`);
+      } else {
+        debug(`openReadonlyWithNative: native path failed: ${msg}`);
+      }
     }
   }
 

package/src/db/repository/base.ts

@@ -223,4 +223,47 @@ export class Repository implements IRepository {
   hasCoChangesTable(): boolean {
     return false;
   }
+
+  // ── Composite queries ──────────────────────────────────────────────
+  /**
+   * Complete fnDeps query in a single call. Returns null when not natively
+   * supported — callers should fall back to the JS-orchestrated path.
+   */
+  fnDeps(
+    _name: string,
+    _opts?: { depth?: number; noTests?: boolean; file?: string; kind?: string },
+  ): FnDepsResult | null {
+    return null;
+  }
+}
+
+// ── Composite query result types ────────────────────────────────────────
+
+export interface FnDepsNode {
+  name: string;
+  kind: string;
+  file: string;
+  line: number | null;
+}
+
+export interface FnDepsCallerNode extends FnDepsNode {
+  viaHierarchy?: string;
+}
+
+export interface FnDepsEntry {
+  name: string;
+  kind: string;
+  file: string;
+  line: number | null;
+  endLine: number | null;
+  role: string | null;
+  fileHash: string | null;
+  callees: FnDepsNode[];
+  callers: FnDepsCallerNode[];
+  transitiveCallers: Record<number, FnDepsNode[]>;
+}
+
+export interface FnDepsResult {
+  name: string;
+  results: FnDepsEntry[];
 }

package/src/db/repository/index.ts

@@ -1,5 +1,6 @@
 // Barrel re-export for repository/ modules.
 
+export type { FnDepsCallerNode, FnDepsEntry, FnDepsNode, FnDepsResult } from './base.js';
 export { Repository } from './base.js';
 export { purgeFileData, purgeFilesData } from './build-stmts.js';
 export { cachedStmt } from './cached-stmt.js';

package/src/db/repository/native-repository.ts

@@ -45,7 +45,13 @@ import type {
   TriageNodeRow,
   TriageQueryOpts,
 } from '../../types.js';
-import { Repository } from './base.js';
+import {
+  type FnDepsCallerNode,
+  type FnDepsEntry,
+  type FnDepsNode,
+  type FnDepsResult,
+  Repository,
+} from './base.js';
 
 // ── Row converters (napi camelCase → Repository snake_case) ─────────────
 
@@ -461,4 +467,64 @@ export class NativeRepository extends Repository {
     }
     return false;
   }
+
+  // ── Composite queries ──────────────────────────────────────────────
+  fnDeps(
+    name: string,
+    opts?: { depth?: number; noTests?: boolean; file?: string; kind?: string },
+  ): FnDepsResult | null {
+    if (typeof this.#ndb.fnDeps !== 'function') return null;
+    const raw = this.#ndb.fnDeps(
+      name,
+      opts?.depth ?? undefined,
+      opts?.noTests ?? undefined,
+      opts?.file ?? undefined,
+      opts?.kind ?? undefined,
+    );
+    // Convert from native format (transitive_callers as array of groups)
+    // to JS format (transitiveCallers as Record<number, Array>)
+    return {
+      name: raw.name,
+      results: raw.results.map((entry: any): FnDepsEntry => {
+        const transitiveCallers: Record<number, FnDepsNode[]> = {};
+        for (const group of entry.transitiveCallers ?? []) {
+          transitiveCallers[group.depth] = (group.callers ?? []).map(
+            (c: any): FnDepsNode => ({
+              name: c.name,
+              kind: c.kind,
+              file: c.file,
+              line: c.line ?? null,
+            }),
+          );
+        }
+        return {
+          name: entry.name,
+          kind: entry.kind,
+          file: entry.file,
+          line: entry.line ?? null,
+          endLine: entry.endLine ?? entry.end_line ?? null,
+          role: entry.role ?? null,
+          fileHash: entry.fileHash ?? entry.file_hash ?? null,
+          callees: (entry.callees ?? []).map(
+            (c: any): FnDepsNode => ({
+              name: c.name,
+              kind: c.kind,
+              file: c.file,
+              line: c.line ?? null,
+            }),
+          ),
+          callers: (entry.callers ?? []).map(
+            (c: any): FnDepsCallerNode => ({
+              name: c.name,
+              kind: c.kind,
+              file: c.file,
+              line: c.line ?? null,
+              viaHierarchy: c.viaHierarchy ?? c.via_hierarchy ?? undefined,
+            }),
+          ),
+          transitiveCallers,
+        };
+      }),
+    };
+  }
 }

package/src/domain/analysis/dependencies.ts

@@ -173,6 +173,19 @@ export function fnDepsData(
   } = {},
 ) {
   return withRepo(customDbPath, (repo) => {
+    // Try native composite path — single NAPI call for the entire query.
+    const nativeResult = repo.fnDeps(name, {
+      depth: opts.depth,
+      noTests: opts.noTests,
+      file: opts.file,
+      kind: opts.kind,
+    });
+    if (nativeResult) {
+      const base = { name: nativeResult.name, results: nativeResult.results };
+      return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+    }
+
+    // Fallback: JS-orchestrated path (used when native engine is unavailable)
     const depth = opts.depth || 3;
     const noTests = opts.noTests || false;
     const hc = new Map();

package/src/domain/graph/builder/incremental.ts

@@ -366,6 +366,27 @@ function buildImportEdges(
       stmts.insertEdge.run(fileNodeId, targetRow.id, edgeKind, 1.0, 0);
       edgesAdded++;
 
+      // Type-only imports: create symbol-level edges so the target symbols
+      // get fan-in credit and aren't falsely classified as dead code.
+      if (imp.typeOnly) {
+        for (const name of imp.names) {
+          const cleanName = name.replace(/^\*\s+as\s+/, '');
+          let targetFile = resolvedPath;
+          if (db && isBarrelFile(db, resolvedPath)) {
+            const actual = resolveBarrelTarget(db, resolvedPath, cleanName);
+            if (actual) targetFile = actual;
+          }
+          const candidates = stmts.findNodeInFile.all(cleanName, targetFile) as Array<{
+            id: number;
+            file: string;
+          }>;
+          if (candidates.length > 0) {
+            stmts.insertEdge.run(fileNodeId, candidates[0]!.id, 'imports-type', 1.0, 0);
+            edgesAdded++;
+          }
+        }
+      }
+
       // Barrel resolution: create edges through re-export chains
       if (!imp.reexport && db) {
         edgesAdded += resolveBarrelImportEdges(db, stmts, fileNodeId, resolvedPath, imp);