@optave/codegraph 3.9.0 → 3.9.2

package/src/domain/graph/builder/stages/build-edges.ts

@@ -119,6 +119,23 @@ function buildImportEdges(
             : 'imports';
       allEdgeRows.push([fileNodeId, targetRow.id, edgeKind, 1.0, 0]);
 
+      // 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 && ctx.nodesByNameAndFile) {
+        for (const name of imp.names) {
+          const cleanName = name.replace(/^\*\s+as\s+/, '');
+          let targetFile = resolvedPath;
+          if (isBarrelFile(ctx, resolvedPath)) {
+            const actual = resolveBarrelExport(ctx, resolvedPath, cleanName);
+            if (actual) targetFile = actual;
+          }
+          const candidates = ctx.nodesByNameAndFile.get(`${cleanName}|${targetFile}`);
+          if (candidates && candidates.length > 0) {
+            allEdgeRows.push([fileNodeId, candidates[0]!.id, 'imports-type', 1.0, 0]);
+          }
+        }
+      }
+
       if (!imp.reexport && isBarrelFile(ctx, resolvedPath)) {
         buildBarrelEdges(ctx, imp, resolvedPath, fileNodeId, edgeKind, getNodeIdStmt, allEdgeRows);
       }
@@ -280,7 +297,18 @@ function buildImportEdgesNative(
     }
   }
 
-  // 6. Call native
+  // 6. Build symbol node entries for type-only import resolution
+  const symbolNodes: Array<{ name: string; file: string; nodeId: number }> = [];
+  if (ctx.nodesByNameAndFile) {
+    for (const [key, nodes] of ctx.nodesByNameAndFile) {
+      if (nodes.length > 0) {
+        const [name, file] = key.split('|');
+        symbolNodes.push({ name: name!, file: file!, nodeId: nodes[0]!.id });
+      }
+    }
+  }
+
+  // 7. Call native
   const nativeEdges = native.buildImportEdges!(
     files,
     resolvedImports,
@@ -288,6 +316,7 @@ function buildImportEdgesNative(
     fileNodeIds,
     barrelFiles,
     rootDir,
+    symbolNodes,
   ) as NativeEdge[];
 
   for (const e of nativeEdges) {
@@ -313,7 +342,7 @@ function buildCallEdgesNative(
     if (!fileNodeRow) continue;
 
     const importedNames = buildImportedNamesForNative(ctx, relPath, symbols, rootDir);
-    const typeMap: Array<{ name: string; typeName: string; confidence: number }> =
+    const typeMapRaw: Array<{ name: string; typeName: string; confidence: number }> =
       symbols.typeMap instanceof Map
         ? [...symbols.typeMap.entries()].map(([name, entry]) => ({
             name,
@@ -323,6 +352,19 @@ function buildCallEdgesNative(
         : Array.isArray(symbols.typeMap)
           ? (symbols.typeMap as Array<{ name: string; typeName: string; confidence: number }>)
           : [];
+    // Deduplicate: keep highest-confidence entry per name (first-wins on tie),
+    // matching JS setTypeMapEntry semantics.  The Map branch is already
+    // deduped by setTypeMapEntry — this loop is only needed for the Array
+    // branch (pre-rebuilt native addon) but runs unconditionally as
+    // belt-and-suspenders since it's a cheap O(n) pass.
+    const typeMapDedup = new Map<string, { name: string; typeName: string; confidence: number }>();
+    for (const entry of typeMapRaw) {
+      const existing = typeMapDedup.get(entry.name);
+      if (!existing || entry.confidence > existing.confidence) {
+        typeMapDedup.set(entry.name, entry);
+      }
+    }
+    const typeMap = [...typeMapDedup.values()];
     nativeFiles.push({
       file: relPath,
       fileNodeId: fileNodeRow.id,
@@ -670,7 +712,7 @@ function loadNodes(ctx: PipelineContext): { rows: QueryNodeRow[]; scoped: boolea
   const nodeKindFilter = `kind IN ('function','method','class','interface','struct','type','module','enum','trait','record','constant')`;
 
   // Gate: only scope for small incremental on large codebases
-  if (!isFullBuild && fileSymbols.size <= 5) {
+  if (!isFullBuild && fileSymbols.size <= ctx.config.build.smallFilesThreshold) {
     const existingFileCount = (
       db.prepare("SELECT COUNT(*) as c FROM nodes WHERE kind = 'file'").get() as { c: number }
     ).c;

package/src/domain/graph/builder/stages/build-structure.ts

@@ -37,7 +37,7 @@ export async function buildStructure(ctx: PipelineContext): Promise<void> {
   // For small incremental builds on large codebases, use a fast path that
   // updates only the changed files' metrics via targeted SQL instead of
   // loading ALL definitions from DB (~8ms) and recomputing ALL metrics (~15ms).
-  // Gate: ≤5 changed files AND significantly more existing files (>20) to
+  // Gate: ≤smallFilesThreshold changed files AND significantly more existing files (>20) to
   // avoid triggering on small test fixtures where directory metrics matter.
   const useNativeReads = ctx.engineName === 'native' && !!ctx.nativeDb;
   const existingFileCount = !isFullBuild
@@ -52,7 +52,7 @@ export async function buildStructure(ctx: PipelineContext): Promise<void> {
   const useSmallIncrementalFastPath =
     !isFullBuild &&
     changedFileList != null &&
-    changedFileList.length <= 5 &&
+    changedFileList.length <= ctx.config.build.smallFilesThreshold &&
     existingFileCount > 20;
 
   if (!isFullBuild && !useSmallIncrementalFastPath) {

package/src/domain/graph/builder/stages/detect-changes.ts

@@ -58,26 +58,9 @@ function getChangedFiles(
   db: BetterSqlite3Database,
   allFiles: string[],
   rootDir: string,
-  nativeDb?: NativeDatabase,
 ): ChangeResult {
-  // Batched native path: single napi call for table check + all rows + max mtime
-  if (nativeDb?.getFileHashData) {
-    const data = nativeDb.getFileHashData();
-    if (!data.exists) {
-      return {
-        changed: allFiles.map((f) => ({ file: f })),
-        removed: [],
-        isFullBuild: true,
-      };
-    }
-    const existing = new Map<string, FileHashRow>(data.rows.map((r) => [r.file, r]));
-    const removed = detectRemovedFiles(existing, allFiles, rootDir);
-    const journalResult = tryJournalTier(db, existing, rootDir, removed, data.maxMtime);
-    if (journalResult) return journalResult;
-    return mtimeAndHashTiers(existing, allFiles, rootDir, removed);
-  }
-
-  // WASM / fallback path
+  // NativeDatabase is not open during change detection (deferred to after
+  // early-exit check). All queries use better-sqlite3 here.
   let hasTable = false;
   try {
     db.prepare('SELECT 1 FROM file_hashes LIMIT 1').get();
@@ -294,14 +277,14 @@ async function runPendingAnalysis(ctx: PipelineContext): Promise<boolean> {
     rootDir,
     analysisOpts,
   );
-  if (needsCfg) {
-    const { buildCFGData } = await import('../../../../features/cfg.js');
-    await buildCFGData(db, analysisSymbols, rootDir, engineOpts);
-  }
-  if (needsDataflow) {
-    const { buildDataflowEdges } = await import('../../../../features/dataflow.js');
-    await buildDataflowEdges(db, analysisSymbols, rootDir, engineOpts);
-  }
+  const { runAnalyses } = await import('../../../../ast-analysis/engine.js');
+  await runAnalyses(
+    db,
+    analysisSymbols,
+    rootDir,
+    { ast: false, complexity: false, cfg: needsCfg, dataflow: needsDataflow },
+    engineOpts,
+  );
   return true;
 }
 
@@ -487,12 +470,7 @@ export async function detectChanges(ctx: PipelineContext): Promise<void> {
   }
   const increResult =
     incremental && !forceFullRebuild
-      ? getChangedFiles(
-          db,
-          allFiles,
-          rootDir,
-          ctx.engineName === 'native' ? ctx.nativeDb : undefined,
-        )
+      ? getChangedFiles(db, allFiles, rootDir)
       : {
           changed: allFiles.map((f): ChangedFile => ({ file: f })),
           removed: [] as string[],

package/src/domain/graph/builder/stages/finalize.ts

@@ -258,7 +258,7 @@ export async function finalize(ctx: PipelineContext): Promise<void> {
   // immediately after build.
   const pair = { db: ctx.db, nativeDb: ctx.nativeDb };
   const isTempDir = path.resolve(rootDir).startsWith(path.resolve(tmpdir()));
-  if (!isFullBuild && allSymbols.size <= 5 && !isTempDir) {
+  if (!isFullBuild && allSymbols.size <= ctx.config.build.smallFilesThreshold && !isTempDir) {
     closeDbPairDeferred(pair);
   } else {
     closeDbPair(pair);

package/src/domain/graph/builder/stages/insert-nodes.ts

@@ -159,23 +159,26 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
   }
   const fileHashes = buildFileHashes(allSymbols, precomputedData, metadataUpdates, rootDir);
 
-  // WAL guard: same suspendJsDb/resumeJsDb pattern used by feature modules
-  // (ast, cfg, complexity, dataflow). Checkpoint JS side before native write,
-  // then checkpoint native side after, so neither library reads WAL frames
-  // written by the other (#696, #709, #715, #717).
+  // In native-first mode (single rusqlite connection), no WAL dance is needed.
+  // In dual-connection mode, checkpoint JS side before native write, then
+  // checkpoint native side after (#696, #709, #715, #717).
   let result: boolean;
-  try {
-    if (ctx.db) {
-      ctx.db.pragma('wal_checkpoint(TRUNCATE)');
-    }
+  if (ctx.nativeFirstProxy) {
     result = ctx.nativeDb!.bulkInsertNodes(batches, fileHashes, removed);
-  } finally {
+  } else {
     try {
-      ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-    } catch (e) {
-      debug(
-        `tryNativeInsert: WAL checkpoint failed (nativeDb may already be closed): ${toErrorMessage(e)}`,
-      );
+      if (ctx.db) {
+        ctx.db.pragma('wal_checkpoint(TRUNCATE)');
+      }
+      result = ctx.nativeDb!.bulkInsertNodes(batches, fileHashes, removed);
+    } finally {
+      try {
+        ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+      } catch (e) {
+        debug(
+          `tryNativeInsert: WAL checkpoint failed (nativeDb may already be closed): ${toErrorMessage(e)}`,
+        );
+      }
     }
   }
   return result;

package/src/domain/graph/builder/stages/resolve-imports.ts

@@ -34,15 +34,14 @@ function buildReexportMap(ctx: PipelineContext): void {
 
 /**
  * Find barrel files related to changed files for scoped re-parsing.
- * For small incremental builds (<=5 files), only barrels that re-export from
+ * For small incremental builds (<=smallFilesThreshold files), only barrels that re-export from
  * or are imported by the changed files. For larger changes, all barrels.
  */
 function findBarrelCandidates(ctx: PipelineContext): Array<{ file: string }> {
   const { db, fileSymbols, rootDir, aliases } = ctx;
   const changedRelPaths = new Set<string>(fileSymbols.keys());
 
-  const SMALL_CHANGE_THRESHOLD = 5;
-  if (changedRelPaths.size <= SMALL_CHANGE_THRESHOLD) {
+  if (changedRelPaths.size <= ctx.config.build.smallFilesThreshold) {
     const allBarrelFiles = new Set(
       (
         db
@@ -180,6 +179,13 @@ export function isBarrelFile(ctx: PipelineContext, relPath: string): boolean {
   return reexports.length >= ownDefs;
 }
 
+/** Check if a re-export source directly defines the symbol. */
+function sourceDefinesSymbol(ctx: PipelineContext, source: string, symbolName: string): boolean {
+  const targetSymbols = ctx.fileSymbols.get(source);
+  if (!targetSymbols) return false;
+  return targetSymbols.definitions.some((d) => d.name === symbolName);
+}
+
 export function resolveBarrelExport(
   ctx: PipelineContext,
   barrelPath: string,
@@ -188,31 +194,24 @@ export function resolveBarrelExport(
 ): string | null {
   if (visited.has(barrelPath)) return null;
   visited.add(barrelPath);
+
   const reexports = ctx.reexportMap.get(barrelPath) as ReexportEntry[] | undefined;
   if (!reexports) return null;
+
   for (const re of reexports) {
+    // Named re-export: only follow if the symbol is in the export list
     if (re.names.length > 0 && !re.wildcardReexport) {
-      if (re.names.includes(symbolName)) {
-        const targetSymbols = ctx.fileSymbols.get(re.source);
-        if (targetSymbols) {
-          const hasDef = targetSymbols.definitions.some((d) => d.name === symbolName);
-          if (hasDef) return re.source;
-          const deeper = resolveBarrelExport(ctx, re.source, symbolName, visited);
-          if (deeper) return deeper;
-        }
-        return re.source;
-      }
-      continue;
-    }
-    if (re.wildcardReexport || re.names.length === 0) {
-      const targetSymbols = ctx.fileSymbols.get(re.source);
-      if (targetSymbols) {
-        const hasDef = targetSymbols.definitions.some((d) => d.name === symbolName);
-        if (hasDef) return re.source;
-        const deeper = resolveBarrelExport(ctx, re.source, symbolName, visited);
-        if (deeper) return deeper;
-      }
+      if (!re.names.includes(symbolName)) continue;
+      if (sourceDefinesSymbol(ctx, re.source, symbolName)) return re.source;
+      const deeper = resolveBarrelExport(ctx, re.source, symbolName, visited);
+      return deeper ?? re.source;
     }
+
+    // Wildcard or namespace re-export: check if target defines the symbol
+    if (sourceDefinesSymbol(ctx, re.source, symbolName)) return re.source;
+    const deeper = resolveBarrelExport(ctx, re.source, symbolName, visited);
+    if (deeper) return deeper;
   }
+
   return null;
 }

package/src/domain/graph/watcher.ts

@@ -2,20 +2,16 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { closeDb, getNodeId as getNodeIdQuery, initSchema, openDb } from '../../db/index.js';
 import { debug, info } from '../../infrastructure/logger.js';
-import { EXTENSIONS, IGNORE_DIRS, normalizePath } from '../../shared/constants.js';
+import { isSupportedFile, normalizePath, shouldIgnore } from '../../shared/constants.js';
 import { DbError } from '../../shared/errors.js';
 import { createParseTreeCache, getActiveEngine } from '../parser.js';
 import { type IncrementalStmts, rebuildFile } from './builder/incremental.js';
 import { appendChangeEvents, buildChangeEvent, diffSymbols } from './change-journal.js';
 import { appendJournalEntries } from './journal.js';
 
-function shouldIgnore(filePath: string): boolean {
+function shouldIgnorePath(filePath: string): boolean {
   const parts = filePath.split(path.sep);
-  return parts.some((p) => IGNORE_DIRS.has(p));
-}
-
-function isTrackedExt(filePath: string): boolean {
-  return EXTENSIONS.has(path.extname(filePath));
+  return parts.some((p) => shouldIgnore(p));
 }
 
 /** Prepare all SQL statements needed by the watcher's incremental rebuild. */
@@ -141,24 +137,35 @@ function collectTrackedFiles(dir: string, result: string[]): void {
   let entries: fs.Dirent[];
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
+  } catch (e: unknown) {
+    debug(`collectTrackedFiles: cannot read ${dir}: ${(e as Error).message}`);
     return;
   }
   for (const entry of entries) {
-    if (IGNORE_DIRS.has(entry.name) || entry.name.startsWith('.')) continue;
+    if (shouldIgnore(entry.name)) continue;
     const full = path.join(dir, entry.name);
     if (entry.isDirectory()) {
       collectTrackedFiles(full, result);
-    } else if (EXTENSIONS.has(path.extname(entry.name))) {
+    } else if (isSupportedFile(entry.name)) {
       result.push(full);
     }
   }
 }
 
-export async function watchProject(
-  rootDir: string,
-  opts: { engine?: string; poll?: boolean; pollInterval?: number } = {},
-): Promise<void> {
+/** Shared watcher state passed between setup and watcher sub-functions. */
+interface WatcherContext {
+  rootDir: string;
+  db: ReturnType<typeof openDb>;
+  stmts: IncrementalStmts;
+  engineOpts: import('../../types.js').EngineOpts;
+  cache: ReturnType<typeof createParseTreeCache>;
+  pending: Set<string>;
+  timer: ReturnType<typeof setTimeout> | null;
+  debounceMs: number;
+}
+
+/** Initialize DB, engine, cache, and statements for watch mode. */
+function setupWatcher(rootDir: string, opts: { engine?: string }): WatcherContext {
   const dbPath = path.join(rootDir, '.codegraph', 'graph.db');
   if (!fs.existsSync(dbPath)) {
     throw new DbError('No graph.db found. Run `codegraph build` first.', { file: dbPath });
@@ -183,111 +190,124 @@ export async function watchProject(
 
   const stmts = prepareWatcherStatements(db);
 
-  const pending = new Set<string>();
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  const DEBOUNCE_MS = 300;
-
-  const usePoll = opts.poll ?? process.platform === 'win32';
-  const POLL_INTERVAL_MS = opts.pollInterval ?? 2000;
+  return {
+    rootDir,
+    db,
+    stmts,
+    engineOpts,
+    cache,
+    pending: new Set<string>(),
+    timer: null,
+    debounceMs: 300,
+  };
+}
 
-  info(`Watching ${rootDir} for changes${usePoll ? ' (polling mode)' : ''}...`);
-  info('Press Ctrl+C to stop.');
+/** Schedule debounced processing of pending files. */
+function scheduleDebouncedProcess(ctx: WatcherContext): void {
+  if (ctx.timer) clearTimeout(ctx.timer);
+  ctx.timer = setTimeout(async () => {
+    const files = [...ctx.pending];
+    ctx.pending.clear();
+    await processPendingFiles(files, ctx.db, ctx.rootDir, ctx.stmts, ctx.engineOpts, ctx.cache);
+  }, ctx.debounceMs);
+}
 
-  let cleanup: () => void;
+/** Start polling-based file watcher. Returns cleanup function. */
+function startPollingWatcher(ctx: WatcherContext, pollIntervalMs: number): () => void {
+  const mtimeMap = new Map<string, number>();
+
+  const initial: string[] = [];
+  collectTrackedFiles(ctx.rootDir, initial);
+  for (const f of initial) {
+    try {
+      mtimeMap.set(f, fs.statSync(f).mtimeMs);
+    } catch {
+      /* deleted between collect and stat */
+    }
+  }
+  info(`Polling ${initial.length} tracked files every ${pollIntervalMs}ms`);
 
-  if (usePoll) {
-    // Polling mode: avoids native OS file watchers (NtNotifyChangeDirectoryFileEx)
-    // which can crash ReFS drivers on Windows Dev Drives.
-    const mtimeMap = new Map<string, number>();
+  const pollTimer = setInterval(() => {
+    const current: string[] = [];
+    collectTrackedFiles(ctx.rootDir, current);
+    const currentSet = new Set(current);
 
-    // Seed initial mtimes
-    const initial: string[] = [];
-    collectTrackedFiles(rootDir, initial);
-    for (const f of initial) {
+    for (const f of current) {
       try {
-        mtimeMap.set(f, fs.statSync(f).mtimeMs);
+        const mtime = fs.statSync(f).mtimeMs;
+        const prev = mtimeMap.get(f);
+        if (prev === undefined || mtime !== prev) {
+          mtimeMap.set(f, mtime);
+          ctx.pending.add(f);
+        }
       } catch {
         /* deleted between collect and stat */
       }
     }
-    info(`Polling ${initial.length} tracked files every ${POLL_INTERVAL_MS}ms`);
-
-    const pollTimer = setInterval(() => {
-      const current: string[] = [];
-      collectTrackedFiles(rootDir, current);
-      const currentSet = new Set(current);
-
-      // Detect modified or new files
-      for (const f of current) {
-        try {
-          const mtime = fs.statSync(f).mtimeMs;
-          const prev = mtimeMap.get(f);
-          if (prev === undefined || mtime !== prev) {
-            mtimeMap.set(f, mtime);
-            pending.add(f);
-          }
-        } catch {
-          /* deleted between collect and stat */
-        }
-      }
 
-      // Detect deleted files
-      for (const f of mtimeMap.keys()) {
-        if (!currentSet.has(f)) {
-          mtimeMap.delete(f);
-          pending.add(f);
-        }
+    for (const f of mtimeMap.keys()) {
+      if (!currentSet.has(f)) {
+        mtimeMap.delete(f);
+        ctx.pending.add(f);
       }
+    }
 
-      if (pending.size > 0) {
-        if (timer) clearTimeout(timer);
-        timer = setTimeout(async () => {
-          const files = [...pending];
-          pending.clear();
-          await processPendingFiles(files, db, rootDir, stmts, engineOpts, cache);
-        }, DEBOUNCE_MS);
-      }
-    }, POLL_INTERVAL_MS);
-
-    cleanup = () => clearInterval(pollTimer);
-  } else {
-    // Native OS watcher — efficient but can trigger ReFS crashes on Windows Dev Drives.
-    // Use --poll if you experience BSOD/HYPERVISOR_ERROR on ReFS volumes.
-    const watcher = fs.watch(rootDir, { recursive: true }, (_eventType, filename) => {
-      if (!filename) return;
-      if (shouldIgnore(filename)) return;
-      if (!isTrackedExt(filename)) return;
-
-      const fullPath = path.join(rootDir, filename);
-      pending.add(fullPath);
-
-      if (timer) clearTimeout(timer);
-      timer = setTimeout(async () => {
-        const files = [...pending];
-        pending.clear();
-        await processPendingFiles(files, db, rootDir, stmts, engineOpts, cache);
-      }, DEBOUNCE_MS);
-    });
-
-    cleanup = () => watcher.close();
-  }
+    if (ctx.pending.size > 0) {
+      scheduleDebouncedProcess(ctx);
+    }
+  }, pollIntervalMs);
+
+  return () => clearInterval(pollTimer);
+}
+
+/** Start native OS file watcher. Returns cleanup function. */
+function startNativeWatcher(ctx: WatcherContext): () => void {
+  const watcher = fs.watch(ctx.rootDir, { recursive: true }, (_eventType, filename) => {
+    if (!filename) return;
+    if (shouldIgnorePath(filename)) return;
+    if (!isSupportedFile(filename)) return;
 
-  process.on('SIGINT', () => {
+    ctx.pending.add(path.join(ctx.rootDir, filename));
+    scheduleDebouncedProcess(ctx);
+  });
+
+  return () => watcher.close();
+}
+
+/** Register SIGINT handler to flush journal and clean up. */
+function setupShutdownHandler(ctx: WatcherContext, cleanup: () => void): void {
+  process.once('SIGINT', () => {
     info('Stopping watcher...');
     cleanup();
-    // Flush any pending file paths to journal before exit
-    if (pending.size > 0) {
-      const entries = [...pending].map((filePath) => ({
-        file: normalizePath(path.relative(rootDir, filePath)),
+    if (ctx.pending.size > 0) {
+      const entries = [...ctx.pending].map((filePath) => ({
+        file: normalizePath(path.relative(ctx.rootDir, filePath)),
       }));
       try {
-        appendJournalEntries(rootDir, entries);
+        appendJournalEntries(ctx.rootDir, entries);
       } catch (e: unknown) {
         debug(`Journal flush on exit failed (non-fatal): ${(e as Error).message}`);
       }
     }
-    if (cache) cache.clear();
-    closeDb(db);
+    if (ctx.cache) ctx.cache.clear();
+    closeDb(ctx.db);
     process.exit(0);
   });
 }
+
+export async function watchProject(
+  rootDir: string,
+  opts: { engine?: string; poll?: boolean; pollInterval?: number } = {},
+): Promise<void> {
+  const ctx = setupWatcher(rootDir, opts);
+
+  const usePoll = opts.poll ?? process.platform === 'win32';
+  const pollIntervalMs = opts.pollInterval ?? 2000;
+
+  info(`Watching ${rootDir} for changes${usePoll ? ' (polling mode)' : ''}...`);
+  info('Press Ctrl+C to stop.');
+
+  const cleanup = usePoll ? startPollingWatcher(ctx, pollIntervalMs) : startNativeWatcher(ctx);
+
+  setupShutdownHandler(ctx, cleanup);
+}

package/src/domain/parser.ts

@@ -5,7 +5,7 @@ import type { Tree } from 'web-tree-sitter';
 import { Language, Parser, Query } from 'web-tree-sitter';
 import { debug, warn } from '../infrastructure/logger.js';
 import { getNative, getNativePackageVersion, loadNative } from '../infrastructure/native.js';
-import { toErrorMessage } from '../shared/errors.js';
+import { ParseError, toErrorMessage } from '../shared/errors.js';
 import type {
   EngineMode,
   ExtractorOutput,
@@ -143,6 +143,8 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(call_expression function: (identifier) @callfn_name) @callfn_node',
   '(call_expression function: (member_expression) @callmem_fn) @callmem_node',
   '(call_expression function: (subscript_expression) @callsub_fn) @callsub_node',
+  '(new_expression constructor: (identifier) @newfn_name) @newfn_node',
+  '(new_expression constructor: (member_expression) @newmem_fn) @newmem_node',
   '(expression_statement (assignment_expression left: (member_expression) @assign_left right: (_) @assign_right)) @assign_node',
 ];
 
@@ -186,7 +188,11 @@ async function doLoadLanguage(entry: LanguageRegistryEntry): Promise<void> {
       _queryCache.set(entry.id, new Query(lang, patterns.join('\n')));
     }
   } catch (e: unknown) {
-    if (entry.required) throw e;
+    if (entry.required)
+      throw new ParseError(`Required parser ${entry.id} failed to initialize`, {
+        file: entry.grammarFile,
+        cause: e as Error,
+      });
     warn(
       `${entry.id} parser failed to initialize: ${(e as Error).message}. ${entry.id} files will be skipped.`,
     );

package/src/domain/queries.ts

@@ -22,7 +22,7 @@ export {
   VALID_ROLES,
 } from '../shared/kinds.js';
 // ── Shared utilities ─────────────────────────────────────────────────────
-export { kindIcon, normalizeSymbol } from '../shared/normalize.js';
+export { kindIcon, normalizeSymbol, toSymbolRef } from '../shared/normalize.js';
 export { briefData } from './analysis/brief.js';
 export { contextData, explainData } from './analysis/context.js';
 export { fileDepsData, filePathData, fnDepsData, pathData } from './analysis/dependencies.js';