@optave/codegraph 3.8.1 → 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) {
@@ -354,7 +383,10 @@ function buildImportedNamesForNative(
   rootDir: string,
 ): Array<{ name: string; file: string }> {
   const importedNames: Array<{ name: string; file: string }> = [];
-  for (const imp of symbols.imports) {
+  // Process dynamic imports first (lower priority), then static imports
+  // (higher priority). Rust HashMap::collect keeps the last entry per key,
+  // so static imports win when both contribute the same name.
+  const addImports = (imp: (typeof symbols.imports)[number]) => {
     const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
     for (const name of imp.names) {
       const cleanName = name.replace(/^\*\s+as\s+/, '');
@@ -365,6 +397,12 @@ function buildImportedNamesForNative(
       }
       importedNames.push({ name: cleanName, file: targetFile });
     }
+  };
+  for (const imp of symbols.imports) {
+    if (imp.dynamicImport) addImports(imp);
+  }
+  for (const imp of symbols.imports) {
+    if (!imp.dynamicImport) addImports(imp);
   }
   return importedNames;
 }
@@ -409,12 +447,25 @@ function buildImportedNamesMap(
   rootDir: string,
 ): Map<string, string> {
   const importedNames = new Map<string, string>();
+  // Process dynamic imports first (lower priority), then static imports
+  // (higher priority). Static imports represent direct bindings while dynamic
+  // imports often use aliased destructuring (`{ foo: bar } = await import(…)`).
+  // When both contribute the same name, the static binding is authoritative.
   for (const imp of symbols.imports) {
+    if (!imp.dynamicImport) continue;
     const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
     for (const name of imp.names) {
       importedNames.set(name.replace(/^\*\s+as\s+/, ''), resolvedPath);
     }
   }
+  for (const imp of symbols.imports) {
+    if (imp.dynamicImport) continue;
+    const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
+    for (const name of imp.names) {
+      const cleanName = name.replace(/^\*\s+as\s+/, '');
+      importedNames.set(cleanName, resolvedPath);
+    }
+  }
   return importedNames;
 }
 

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);
+}