@optave/codegraph 3.3.1 → 3.4.1

package/src/domain/graph/builder/context.js

@@ -1,85 +0,0 @@
-/**
- * PipelineContext — shared mutable state threaded through all build stages.
- *
- * Each stage reads what it needs and writes what it produces.
- * This replaces the closure-captured locals in the old monolithic buildGraph().
- */
-export class PipelineContext {
-  // ── Inputs (set during setup) ──────────────────────────────────────
-  /** @type {string} Absolute root directory */
-  rootDir;
-  /** @type {import('better-sqlite3').Database} */
-  db;
-  /** @type {string} Absolute path to the database file */
-  dbPath;
-  /** @type {object} From loadConfig() */
-  config;
-  /** @type {object} Original buildGraph opts */
-  opts;
-  /** @type {{ engine: string, dataflow: boolean, ast: boolean }} */
-  engineOpts;
-  /** @type {string} 'native' | 'wasm' */
-  engineName;
-  /** @type {string|null} */
-  engineVersion;
-  /** @type {{ baseUrl: string|null, paths: object }} */
-  aliases;
-  /** @type {boolean} Whether incremental mode is enabled */
-  incremental;
-  /** @type {boolean} Force full rebuild (engine/schema mismatch) */
-  forceFullRebuild = false;
-  /** @type {number} Current schema version */
-  schemaVersion;
-
-  // ── File collection (set by collectFiles stage) ────────────────────
-  /** @type {string[]} Absolute file paths */
-  allFiles;
-  /** @type {Set<string>} Absolute directory paths */
-  discoveredDirs;
-
-  // ── Change detection (set by detectChanges stage) ──────────────────
-  /** @type {boolean} */
-  isFullBuild;
-  /** @type {Array<{ file: string, relPath?: string, content?: string, hash?: string, stat?: object, _reverseDepOnly?: boolean }>} */
-  parseChanges;
-  /** @type {Array<{ relPath: string, hash: string, stat: object }>} Metadata-only self-heal updates */
-  metadataUpdates;
-  /** @type {string[]} Relative paths of deleted files */
-  removed;
-  /** @type {boolean} True when no changes detected — skip remaining stages */
-  earlyExit = false;
-
-  // ── Parsing (set by parseFiles stage) ──────────────────────────────
-  /** @type {Map<string, object>} relPath → symbols from parseFilesAuto */
-  allSymbols;
-  /** @type {Map<string, object>} relPath → symbols (includes incrementally loaded) */
-  fileSymbols;
-  /** @type {Array<{ file: string, relPath?: string }>} Files to parse this build */
-  filesToParse;
-
-  // ── Import resolution (set by resolveImports stage) ────────────────
-  /** @type {Map<string, string>|null} "absFile|source" → resolved path */
-  batchResolved;
-  /** @type {Map<string, Array>} relPath → re-export descriptors */
-  reexportMap;
-  /** @type {Set<string>} Files loaded only for barrel resolution (don't rebuild edges) */
-  barrelOnlyFiles;
-
-  // ── Node lookup (set by insertNodes / buildEdges stages) ───────────
-  /** @type {Map<string, Array>} name → node rows */
-  nodesByName;
-  /** @type {Map<string, Array>} "name|file" → node rows */
-  nodesByNameAndFile;
-
-  // ── Misc state ─────────────────────────────────────────────────────
-  /** @type {boolean} Whether embeddings table exists */
-  hasEmbeddings = false;
-  /** @type {Map<string, number>} relPath → line count */
-  lineCountMap;
-
-  // ── Phase timing ───────────────────────────────────────────────────
-  timing = {};
-
-  /** @type {number} performance.now() at build start */
-  buildStart;
-}

package/src/domain/graph/builder/helpers.js

@@ -1,218 +0,0 @@
-/**
- * Builder helper functions — shared utilities used across pipeline stages.
- *
- * Extracted from the monolithic builder.js so stages can import individually.
- */
-import { createHash } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import { purgeFilesData } from '../../../db/index.js';
-import { warn } from '../../../infrastructure/logger.js';
-import { EXTENSIONS, IGNORE_DIRS } from '../../../shared/constants.js';
-
-export const BUILTIN_RECEIVERS = new Set([
-  'console',
-  'Math',
-  'JSON',
-  'Object',
-  'Array',
-  'String',
-  'Number',
-  'Boolean',
-  'Date',
-  'RegExp',
-  'Map',
-  'Set',
-  'WeakMap',
-  'WeakSet',
-  'Promise',
-  'Symbol',
-  'Error',
-  'TypeError',
-  'RangeError',
-  'Proxy',
-  'Reflect',
-  'Intl',
-  'globalThis',
-  'window',
-  'document',
-  'process',
-  'Buffer',
-  'require',
-]);
-
-/**
- * Recursively collect all source files under `dir`.
- * When `directories` is a Set, also tracks which directories contain files.
- */
-export function collectFiles(
-  dir,
-  files = [],
-  config = {},
-  directories = null,
-  _visited = new Set(),
-) {
-  const trackDirs = directories instanceof Set;
-  let hasFiles = false;
-
-  // Merge config ignoreDirs with defaults
-  const extraIgnore = config.ignoreDirs ? new Set(config.ignoreDirs) : null;
-
-  // Detect symlink loops (before I/O to avoid wasted readdirSync)
-  let realDir;
-  try {
-    realDir = fs.realpathSync(dir);
-  } catch {
-    return trackDirs ? { files, directories } : files;
-  }
-  if (_visited.has(realDir)) {
-    warn(`Symlink loop detected, skipping: ${dir}`);
-    return trackDirs ? { files, directories } : files;
-  }
-  _visited.add(realDir);
-
-  let entries;
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch (err) {
-    warn(`Cannot read directory ${dir}: ${err.message}`);
-    return trackDirs ? { files, directories } : files;
-  }
-
-  for (const entry of entries) {
-    if (entry.name.startsWith('.') && entry.name !== '.') {
-      if (IGNORE_DIRS.has(entry.name)) continue;
-      if (entry.isDirectory()) continue;
-    }
-    if (IGNORE_DIRS.has(entry.name)) continue;
-    if (extraIgnore?.has(entry.name)) continue;
-
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      collectFiles(full, files, config, directories, _visited);
-    } else if (EXTENSIONS.has(path.extname(entry.name))) {
-      files.push(full);
-      hasFiles = true;
-    }
-  }
-  if (trackDirs && hasFiles) {
-    directories.add(dir);
-  }
-  return trackDirs ? { files, directories } : files;
-}
-
-/**
- * Load path aliases from tsconfig.json / jsconfig.json.
- */
-export function loadPathAliases(rootDir) {
-  const aliases = { baseUrl: null, paths: {} };
-  for (const configName of ['tsconfig.json', 'jsconfig.json']) {
-    const configPath = path.join(rootDir, configName);
-    if (!fs.existsSync(configPath)) continue;
-    try {
-      const raw = fs
-        .readFileSync(configPath, 'utf-8')
-        .replace(/\/\/.*$/gm, '')
-        .replace(/\/\*[\s\S]*?\*\//g, '')
-        .replace(/,\s*([\]}])/g, '$1');
-      const config = JSON.parse(raw);
-      const opts = config.compilerOptions || {};
-      if (opts.baseUrl) aliases.baseUrl = path.resolve(rootDir, opts.baseUrl);
-      if (opts.paths) {
-        for (const [pattern, targets] of Object.entries(opts.paths)) {
-          aliases.paths[pattern] = targets.map((t) => path.resolve(aliases.baseUrl || rootDir, t));
-        }
-      }
-      break;
-    } catch (err) {
-      warn(`Failed to parse ${configName}: ${err.message}`);
-    }
-  }
-  return aliases;
-}
-
-/**
- * Compute MD5 hash of file contents for incremental builds.
- */
-export function fileHash(content) {
-  return createHash('md5').update(content).digest('hex');
-}
-
-/**
- * Stat a file, returning { mtimeMs, size } or null on error.
- */
-export function fileStat(filePath) {
-  try {
-    const s = fs.statSync(filePath);
-    return { mtimeMs: s.mtimeMs, size: s.size };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Read a file with retry on transient errors (EBUSY/EACCES/EPERM).
- */
-const TRANSIENT_CODES = new Set(['EBUSY', 'EACCES', 'EPERM']);
-const RETRY_DELAY_MS = 50;
-
-export function readFileSafe(filePath, retries = 2) {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      return fs.readFileSync(filePath, 'utf-8');
-    } catch (err) {
-      if (attempt < retries && TRANSIENT_CODES.has(err.code)) {
-        const end = Date.now() + RETRY_DELAY_MS;
-        while (Date.now() < end) {}
-        continue;
-      }
-      throw err;
-    }
-  }
-}
-
-/**
- * Purge all graph data for the specified files.
- */
-export function purgeFilesFromGraph(db, files, options = {}) {
-  purgeFilesData(db, files, options);
-}
-
-/** Batch INSERT chunk size for multi-value INSERTs. */
-const BATCH_CHUNK = 200;
-
-/**
- * Batch-insert node rows via multi-value INSERT statements.
- * Each row: [name, kind, file, line, end_line, parent_id, qualified_name, scope, visibility]
- */
-export function batchInsertNodes(db, rows) {
-  if (!rows.length) return;
-  const ph = '(?,?,?,?,?,?,?,?,?)';
-  for (let i = 0; i < rows.length; i += BATCH_CHUNK) {
-    const chunk = rows.slice(i, i + BATCH_CHUNK);
-    const vals = [];
-    for (const r of chunk) vals.push(r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8]);
-    db.prepare(
-      'INSERT OR IGNORE INTO nodes (name,kind,file,line,end_line,parent_id,qualified_name,scope,visibility) VALUES ' +
-        chunk.map(() => ph).join(','),
-    ).run(...vals);
-  }
-}
-
-/**
- * Batch-insert edge rows via multi-value INSERT statements.
- * Each row: [source_id, target_id, kind, confidence, dynamic]
- */
-export function batchInsertEdges(db, rows) {
-  if (!rows.length) return;
-  const ph = '(?,?,?,?,?)';
-  for (let i = 0; i < rows.length; i += BATCH_CHUNK) {
-    const chunk = rows.slice(i, i + BATCH_CHUNK);
-    const vals = [];
-    for (const r of chunk) vals.push(r[0], r[1], r[2], r[3], r[4]);
-    db.prepare(
-      'INSERT INTO edges (source_id,target_id,kind,confidence,dynamic) VALUES ' +
-        chunk.map(() => ph).join(','),
-    ).run(...vals);
-  }
-}

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

@@ -1,113 +0,0 @@
-/**
- * Stage: buildStructure + classifyRoles
- *
- * Builds directory structure, containment edges, metrics, and classifies node roles.
- */
-import path from 'node:path';
-import { performance } from 'node:perf_hooks';
-import { debug } from '../../../../infrastructure/logger.js';
-import { normalizePath } from '../../../../shared/constants.js';
-import { readFileSafe } from '../helpers.js';
-
-/**
- * @param {import('../context.js').PipelineContext} ctx
- */
-export async function buildStructure(ctx) {
-  const { db, fileSymbols, rootDir, discoveredDirs, allSymbols, isFullBuild } = ctx;
-
-  // Build line count map (prefer cached _lineCount from parser)
-  ctx.lineCountMap = new Map();
-  for (const [relPath, symbols] of fileSymbols) {
-    if (symbols.lineCount ?? symbols._lineCount) {
-      ctx.lineCountMap.set(relPath, symbols.lineCount ?? symbols._lineCount);
-    } else {
-      const absPath = path.join(rootDir, relPath);
-      try {
-        const content = readFileSafe(absPath);
-        ctx.lineCountMap.set(relPath, content.split('\n').length);
-      } catch {
-        ctx.lineCountMap.set(relPath, 0);
-      }
-    }
-  }
-
-  // For incremental builds, load unchanged files from DB for complete structure
-  if (!isFullBuild) {
-    const existingFiles = db.prepare("SELECT DISTINCT file FROM nodes WHERE kind = 'file'").all();
-    const defsByFile = db.prepare(
-      "SELECT name, kind, line FROM nodes WHERE file = ? AND kind != 'file' AND kind != 'directory'",
-    );
-    const importCountByFile = db.prepare(
-      `SELECT COUNT(DISTINCT n2.file) AS cnt FROM edges e
-       JOIN nodes n1 ON e.source_id = n1.id
-       JOIN nodes n2 ON e.target_id = n2.id
-       WHERE n1.file = ? AND e.kind = 'imports'`,
-    );
-    const lineCountByFile = db.prepare(
-      `SELECT n.name AS file, m.line_count
-       FROM node_metrics m JOIN nodes n ON m.node_id = n.id
-       WHERE n.kind = 'file'`,
-    );
-    const cachedLineCounts = new Map();
-    for (const row of lineCountByFile.all()) {
-      cachedLineCounts.set(row.file, row.line_count);
-    }
-    let loadedFromDb = 0;
-    for (const { file: relPath } of existingFiles) {
-      if (!fileSymbols.has(relPath)) {
-        const importCount = importCountByFile.get(relPath)?.cnt || 0;
-        fileSymbols.set(relPath, {
-          definitions: defsByFile.all(relPath),
-          imports: new Array(importCount),
-          exports: [],
-        });
-        loadedFromDb++;
-      }
-      if (!ctx.lineCountMap.has(relPath)) {
-        const cached = cachedLineCounts.get(relPath);
-        if (cached != null) {
-          ctx.lineCountMap.set(relPath, cached);
-        } else {
-          const absPath = path.join(rootDir, relPath);
-          try {
-            const content = readFileSafe(absPath);
-            ctx.lineCountMap.set(relPath, content.split('\n').length);
-          } catch {
-            ctx.lineCountMap.set(relPath, 0);
-          }
-        }
-      }
-    }
-    debug(`Structure: ${fileSymbols.size} files (${loadedFromDb} loaded from DB)`);
-  }
-
-  // Build directory structure
-  const t0 = performance.now();
-  const relDirs = new Set();
-  for (const absDir of discoveredDirs) {
-    relDirs.add(normalizePath(path.relative(rootDir, absDir)));
-  }
-  try {
-    const { buildStructure: buildStructureFn } = await import('../../../../features/structure.js');
-    const changedFilePaths = isFullBuild ? null : [...allSymbols.keys()];
-    buildStructureFn(db, fileSymbols, rootDir, ctx.lineCountMap, relDirs, changedFilePaths);
-  } catch (err) {
-    debug(`Structure analysis failed: ${err.message}`);
-  }
-  ctx.timing.structureMs = performance.now() - t0;
-
-  // Classify node roles
-  const t1 = performance.now();
-  try {
-    const { classifyNodeRoles } = await import('../../../../features/structure.js');
-    const roleSummary = classifyNodeRoles(db);
-    debug(
-      `Roles: ${Object.entries(roleSummary)
-        .map(([r, c]) => `${r}=${c}`)
-        .join(', ')}`,
-    );
-  } catch (err) {
-    debug(`Role classification failed: ${err.message}`);
-  }
-  ctx.timing.rolesMs = performance.now() - t1;
-}

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

@@ -1,139 +0,0 @@
-/**
- * Stage: finalize
- *
- * WASM cleanup, stats logging, drift detection, build metadata, registry, journal.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { performance } from 'node:perf_hooks';
-import { closeDb, getBuildMeta, setBuildMeta } from '../../../../db/index.js';
-import { debug, info, warn } from '../../../../infrastructure/logger.js';
-import { writeJournalHeader } from '../../journal.js';
-
-const __builderDir = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/i, '$1'));
-const CODEGRAPH_VERSION = JSON.parse(
-  fs.readFileSync(path.join(__builderDir, '..', '..', '..', '..', '..', 'package.json'), 'utf-8'),
-).version;
-
-/**
- * @param {import('../context.js').PipelineContext} ctx
- */
-export async function finalize(ctx) {
-  const { db, allSymbols, rootDir, isFullBuild, hasEmbeddings, config, opts, schemaVersion } = ctx;
-
-  const t0 = performance.now();
-
-  // Release cached WASM trees
-  for (const [, symbols] of allSymbols) {
-    if (symbols._tree && typeof symbols._tree.delete === 'function') {
-      try {
-        symbols._tree.delete();
-      } catch {}
-    }
-    symbols._tree = null;
-    symbols._langId = null;
-  }
-
-  const nodeCount = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c;
-  const actualEdgeCount = db.prepare('SELECT COUNT(*) as c FROM edges').get().c;
-  info(`Graph built: ${nodeCount} nodes, ${actualEdgeCount} edges`);
-  info(`Stored in ${ctx.dbPath}`);
-
-  // Incremental drift detection
-  if (!isFullBuild) {
-    const prevNodes = getBuildMeta(db, 'node_count');
-    const prevEdges = getBuildMeta(db, 'edge_count');
-    if (prevNodes && prevEdges) {
-      const prevN = Number(prevNodes);
-      const prevE = Number(prevEdges);
-      if (prevN > 0) {
-        const nodeDrift = Math.abs(nodeCount - prevN) / prevN;
-        const edgeDrift = prevE > 0 ? Math.abs(actualEdgeCount - prevE) / prevE : 0;
-        const driftThreshold = config.build?.driftThreshold ?? 0.2;
-        if (nodeDrift > driftThreshold || edgeDrift > driftThreshold) {
-          warn(
-            `Incremental build diverged significantly from previous counts (nodes: ${prevN}→${nodeCount} [${(nodeDrift * 100).toFixed(1)}%], edges: ${prevE}→${actualEdgeCount} [${(edgeDrift * 100).toFixed(1)}%], threshold: ${(driftThreshold * 100).toFixed(0)}%). Consider rebuilding with --no-incremental.`,
-          );
-        }
-      }
-    }
-  }
-
-  // Orphaned embeddings warning
-  if (hasEmbeddings) {
-    try {
-      const orphaned = db
-        .prepare('SELECT COUNT(*) as c FROM embeddings WHERE node_id NOT IN (SELECT id FROM nodes)')
-        .get().c;
-      if (orphaned > 0) {
-        warn(
-          `${orphaned} embeddings are orphaned (nodes changed). Run "codegraph embed" to refresh.`,
-        );
-      }
-    } catch {
-      /* ignore — embeddings table may have been dropped */
-    }
-  }
-
-  // Unused exports warning
-  try {
-    const unusedCount = db
-      .prepare(
-        `SELECT COUNT(*) as c FROM nodes
-       WHERE exported = 1 AND kind != 'file'
-         AND id NOT IN (
-           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 e.kind = 'calls' AND caller.file != target.file
-         )`,
-      )
-      .get().c;
-    if (unusedCount > 0) {
-      warn(
-        `${unusedCount} exported symbol${unusedCount > 1 ? 's have' : ' has'} zero cross-file consumers. Run "codegraph exports <file> --unused" to inspect.`,
-      );
-    }
-  } catch {
-    /* exported column may not exist on older DBs */
-  }
-
-  // Persist build metadata
-  try {
-    setBuildMeta(db, {
-      engine: ctx.engineName,
-      engine_version: ctx.engineVersion || '',
-      codegraph_version: CODEGRAPH_VERSION,
-      schema_version: String(schemaVersion),
-      built_at: new Date().toISOString(),
-      node_count: nodeCount,
-      edge_count: actualEdgeCount,
-    });
-  } catch (err) {
-    warn(`Failed to write build metadata: ${err.message}`);
-  }
-
-  closeDb(db);
-
-  // Write journal header after successful build
-  writeJournalHeader(rootDir, Date.now());
-
-  // Auto-registration
-  if (!opts.skipRegistry) {
-    const { tmpdir } = await import('node:os');
-    const tmpDir = path.resolve(tmpdir());
-    const resolvedRoot = path.resolve(rootDir);
-    if (resolvedRoot.startsWith(tmpDir)) {
-      debug(`Skipping auto-registration for temp directory: ${resolvedRoot}`);
-    } else {
-      try {
-        const { registerRepo } = await import('../../../../infrastructure/registry.js');
-        registerRepo(rootDir);
-      } catch (err) {
-        debug(`Auto-registration failed: ${err.message}`);
-      }
-    }
-  }
-
-  ctx.timing.finalizeMs = performance.now() - t0;
-}

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

@@ -1,143 +0,0 @@
-/**
- * Stage: resolveImports
- *
- * Batch import resolution + barrel/re-export map construction.
- * For incremental builds, loads unchanged barrel files for resolution.
- */
-import path from 'node:path';
-import { performance } from 'node:perf_hooks';
-import { parseFilesAuto } from '../../../parser.js';
-import { resolveImportPath, resolveImportsBatch } from '../../resolve.js';
-
-/**
- * @param {import('../context.js').PipelineContext} ctx
- */
-export async function resolveImports(ctx) {
-  const { db, fileSymbols, rootDir, aliases, allFiles, isFullBuild, engineOpts } = ctx;
-
-  // Collect all (fromFile, importSource) pairs and resolve in one native call
-  const t0 = performance.now();
-  const batchInputs = [];
-  for (const [relPath, symbols] of fileSymbols) {
-    const absFile = path.join(rootDir, relPath);
-    for (const imp of symbols.imports) {
-      batchInputs.push({ fromFile: absFile, importSource: imp.source });
-    }
-  }
-  ctx.batchResolved = resolveImportsBatch(batchInputs, rootDir, aliases, allFiles);
-  ctx.timing.resolveMs = performance.now() - t0;
-
-  // Build re-export map for barrel resolution
-  ctx.reexportMap = new Map();
-  for (const [relPath, symbols] of fileSymbols) {
-    const reexports = symbols.imports.filter((imp) => imp.reexport);
-    if (reexports.length > 0) {
-      ctx.reexportMap.set(
-        relPath,
-        reexports.map((imp) => ({
-          source: getResolved(ctx, path.join(rootDir, relPath), imp.source),
-          names: imp.names,
-          wildcardReexport: imp.wildcardReexport || false,
-        })),
-      );
-    }
-  }
-
-  // For incremental builds, load unchanged barrel files into reexportMap
-  ctx.barrelOnlyFiles = new Set();
-  if (!isFullBuild) {
-    const barrelCandidates = db
-      .prepare(
-        `SELECT DISTINCT n1.file FROM edges e
-         JOIN nodes n1 ON e.source_id = n1.id
-         WHERE e.kind = 'reexports' AND n1.kind = 'file'`,
-      )
-      .all();
-    for (const { file: relPath } of barrelCandidates) {
-      if (fileSymbols.has(relPath)) continue;
-      const absPath = path.join(rootDir, relPath);
-      try {
-        const symbols = await parseFilesAuto([absPath], rootDir, engineOpts);
-        const fileSym = symbols.get(relPath);
-        if (fileSym) {
-          fileSymbols.set(relPath, fileSym);
-          ctx.barrelOnlyFiles.add(relPath);
-          const reexports = fileSym.imports.filter((imp) => imp.reexport);
-          if (reexports.length > 0) {
-            ctx.reexportMap.set(
-              relPath,
-              reexports.map((imp) => ({
-                source: getResolved(ctx, absPath, imp.source),
-                names: imp.names,
-                wildcardReexport: imp.wildcardReexport || false,
-              })),
-            );
-          }
-        }
-      } catch {
-        /* skip if unreadable */
-      }
-    }
-  }
-}
-
-/**
- * Resolve an import source, preferring batch results.
- * Exported so other stages (build-edges) can reuse it.
- */
-export function getResolved(ctx, absFile, importSource) {
-  if (ctx.batchResolved) {
-    const key = `${absFile}|${importSource}`;
-    const hit = ctx.batchResolved.get(key);
-    if (hit !== undefined) return hit;
-  }
-  return resolveImportPath(absFile, importSource, ctx.rootDir, ctx.aliases);
-}
-
-/**
- * Check if a file is a barrel (re-export hub).
- */
-export function isBarrelFile(ctx, relPath) {
-  const symbols = ctx.fileSymbols.get(relPath);
-  if (!symbols) return false;
-  const reexports = symbols.imports.filter((imp) => imp.reexport);
-  if (reexports.length === 0) return false;
-  const ownDefs = symbols.definitions.length;
-  return reexports.length >= ownDefs;
-}
-
-/**
- * Resolve a symbol through barrel re-export chains.
- */
-export function resolveBarrelExport(ctx, barrelPath, symbolName, visited = new Set()) {
-  if (visited.has(barrelPath)) return null;
-  visited.add(barrelPath);
-  const reexports = ctx.reexportMap.get(barrelPath);
-  if (!reexports) return null;
-
-  for (const re of reexports) {
-    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;
-      }
-    }
-  }
-  return null;
-}