@optave/codegraph 3.9.0 → 3.9.1

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) {

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

@@ -180,6 +180,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 +195,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

@@ -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',
 ];
 

package/src/extractors/go.ts

@@ -266,44 +266,69 @@ function handleTypedIdentifiers(
 }
 
 /** Infer type from a single RHS expression in a short var declaration. */
-function inferShortVarType(
+/** x := Struct{...} — composite literal (confidence 1.0). */
+function inferCompositeLiteral(
   varNode: TreeSitterNode,
   rhs: TreeSitterNode,
   typeMap: Map<string, { type: string; confidence: number }>,
-): void {
-  // x := Struct{...} — composite literal (confidence 1.0)
-  if (rhs.type === 'composite_literal') {
-    const typeNode = rhs.childForFieldName('type');
-    if (typeNode) {
-      const typeName = extractGoTypeName(typeNode);
-      if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
-    }
-  }
-  // x := &Struct{...} — address-of composite literal (confidence 1.0)
-  if (rhs.type === 'unary_expression') {
-    const operand = rhs.childForFieldName('operand');
-    if (operand && operand.type === 'composite_literal') {
-      const typeNode = operand.childForFieldName('type');
-      if (typeNode) {
-        const typeName = extractGoTypeName(typeNode);
-        if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
-      }
-    }
-  }
-  // x := NewFoo() or x := pkg.NewFoo() — factory function (confidence 0.7)
-  if (rhs.type === 'call_expression') {
-    const fn = rhs.childForFieldName('function');
-    if (fn && fn.type === 'selector_expression') {
-      const field = fn.childForFieldName('field');
-      if (field?.text.startsWith('New')) {
-        const typeName = field.text.slice(3);
-        if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 0.7);
-      }
-    } else if (fn && fn.type === 'identifier' && fn.text.startsWith('New')) {
-      const typeName = fn.text.slice(3);
+): boolean {
+  if (rhs.type !== 'composite_literal') return false;
+  const typeNode = rhs.childForFieldName('type');
+  if (!typeNode) return false;
+  const typeName = extractGoTypeName(typeNode);
+  if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
+  return true;
+}
+
+/** x := &Struct{...} — address-of composite literal (confidence 1.0). */
+function inferAddressOfComposite(
+  varNode: TreeSitterNode,
+  rhs: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
+): boolean {
+  if (rhs.type !== 'unary_expression') return false;
+  const operand = rhs.childForFieldName('operand');
+  if (!operand || operand.type !== 'composite_literal') return false;
+  const typeNode = operand.childForFieldName('type');
+  if (!typeNode) return false;
+  const typeName = extractGoTypeName(typeNode);
+  if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
+  return true;
+}
+
+/** x := NewFoo() or x := pkg.NewFoo() — factory function (confidence 0.7). */
+function inferFactoryCall(
+  varNode: TreeSitterNode,
+  rhs: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
+): boolean {
+  if (rhs.type !== 'call_expression') return false;
+  const fn = rhs.childForFieldName('function');
+  if (!fn) return false;
+
+  if (fn.type === 'selector_expression') {
+    const field = fn.childForFieldName('field');
+    if (field?.text.startsWith('New')) {
+      const typeName = field.text.slice(3);
       if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 0.7);
+      return true;
     }
+  } else if (fn.type === 'identifier' && fn.text.startsWith('New')) {
+    const typeName = fn.text.slice(3);
+    if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 0.7);
+    return true;
   }
+  return false;
+}
+
+function inferShortVarType(
+  varNode: TreeSitterNode,
+  rhs: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
+): void {
+  if (inferCompositeLiteral(varNode, rhs, typeMap)) return;
+  if (inferAddressOfComposite(varNode, rhs, typeMap)) return;
+  inferFactoryCall(varNode, rhs, typeMap);
 }
 
 /** Handle short_var_declaration: x := Struct{}, x := &Struct{}, x := NewFoo(). */

package/src/extractors/javascript.ts

@@ -202,6 +202,48 @@ function handleExportCapture(
   }
 }
 
+function handleInterfaceCapture(
+  c: Record<string, TreeSitterNode>,
+  definitions: Definition[],
+): void {
+  const ifaceNode = c.iface_node!;
+  const ifaceName = c.iface_name!.text;
+  definitions.push({
+    name: ifaceName,
+    kind: 'interface',
+    line: ifaceNode.startPosition.row + 1,
+    endLine: nodeEndLine(ifaceNode),
+  });
+  const body =
+    ifaceNode.childForFieldName('body') ||
+    findChild(ifaceNode, 'interface_body') ||
+    findChild(ifaceNode, 'object_type');
+  if (body) extractInterfaceMethods(body, ifaceName, definitions);
+}
+
+function handleTypeCapture(c: Record<string, TreeSitterNode>, definitions: Definition[]): void {
+  const typeNode = c.type_node!;
+  definitions.push({
+    name: c.type_name!.text,
+    kind: 'type',
+    line: typeNode.startPosition.row + 1,
+    endLine: nodeEndLine(typeNode),
+  });
+}
+
+function handleImportCapture(c: Record<string, TreeSitterNode>, imports: Import[]): void {
+  const impNode = c.imp_node!;
+  const isTypeOnly = impNode.text.startsWith('import type');
+  const modPath = c.imp_source!.text.replace(/['"]/g, '');
+  const names = extractImportNames(impNode);
+  imports.push({
+    source: modPath,
+    names,
+    line: impNode.startPosition.row + 1,
+    typeOnly: isTypeOnly,
+  });
+}
+
 /** Dispatch a single query match to the appropriate handler. */
 function dispatchQueryMatch(
   c: Record<string, TreeSitterNode>,
@@ -220,35 +262,11 @@ function dispatchQueryMatch(
   } else if (c.meth_node) {
     handleMethodCapture(c, definitions);
   } else if (c.iface_node) {
-    const ifaceName = c.iface_name!.text;
-    definitions.push({
-      name: ifaceName,
-      kind: 'interface',
-      line: c.iface_node.startPosition.row + 1,
-      endLine: nodeEndLine(c.iface_node),
-    });
-    const body =
-      c.iface_node.childForFieldName('body') ||
-      findChild(c.iface_node, 'interface_body') ||
-      findChild(c.iface_node, 'object_type');
-    if (body) extractInterfaceMethods(body, ifaceName, definitions);
+    handleInterfaceCapture(c, definitions);
   } else if (c.type_node) {
-    definitions.push({
-      name: c.type_name!.text,
-      kind: 'type',
-      line: c.type_node.startPosition.row + 1,
-      endLine: nodeEndLine(c.type_node),
-    });
+    handleTypeCapture(c, definitions);
   } else if (c.imp_node) {
-    const isTypeOnly = c.imp_node.text.startsWith('import type');
-    const modPath = c.imp_source!.text.replace(/['"]/g, '');
-    const names = extractImportNames(c.imp_node);
-    imports.push({
-      source: modPath,
-      names,
-      line: c.imp_node.startPosition.row + 1,
-      typeOnly: isTypeOnly,
-    });
+    handleImportCapture(c, imports);
   } else if (c.exp_node) {
     handleExportCapture(c, exps, imports);
   } else if (c.callfn_node) {
@@ -264,6 +282,14 @@ function dispatchQueryMatch(
   } else if (c.callsub_node) {
     const callInfo = extractCallInfo(c.callsub_fn!, c.callsub_node);
     if (callInfo) calls.push(callInfo);
+  } else if (c.newfn_node) {
+    calls.push({
+      name: c.newfn_name!.text,
+      line: c.newfn_node.startPosition.row + 1,
+    });
+  } else if (c.newmem_node) {
+    const callInfo = extractCallInfo(c.newmem_fn!, c.newmem_node);
+    if (callInfo) calls.push(callInfo);
   } else if (c.assign_node) {
     handleCommonJSAssignment(c.assign_left!, c.assign_right!, c.assign_node, imports);
   }
@@ -502,6 +528,9 @@ function walkJavaScriptNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'call_expression':
       handleCallExpr(node, ctx);
       break;
+    case 'new_expression':
+      handleNewExpr(node, ctx);
+      break;
     case 'import_statement':
       handleImportStmt(node, ctx);
       break;
@@ -689,6 +718,17 @@ function handleCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+function handleNewExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const ctor = node.childForFieldName('constructor') || node.child(1);
+  if (!ctor) return;
+  if (ctor.type === 'identifier') {
+    ctx.calls.push({ name: ctor.text, line: node.startPosition.row + 1 });
+  } else if (ctor.type === 'member_expression') {
+    const callInfo = extractCallInfo(ctor, node);
+    if (callInfo) ctx.calls.push(callInfo);
+  }
+}
+
 /** Handle a dynamic import() call expression and add to imports if static. */
 function handleDynamicImportCall(node: TreeSitterNode, imports: Import[]): void {
   const args = node.childForFieldName('arguments') || findChild(node, 'arguments');