@monoes/monograph 1.2.10 → 1.3.0

package/dist/src/pipeline/phases/scope-resolution.js

@@ -1,5 +1,5 @@
-import { readFileSync } from 'fs';
-import { join, extname } from 'path';
+import { readFileSync, existsSync } from 'fs';
+import { join, extname, dirname, resolve as resolvePath } from 'path';
 import { makeId } from '../../types.js';
 // ── JS/TS keywords to skip for direct calls ───────────────────────────────────
 const JS_KEYWORDS = new Set([
@@ -37,8 +37,9 @@ const PY_EXTS = new Set(['.py']);
 const GO_EXTS = new Set(['.go']);
 const JAVA_EXTS = new Set(['.java']);
 const RUST_EXTS = new Set(['.rs']);
+const CJS_MJS_EXTS = new Set(['.cjs', '.mjs']);
 function isSupportedExt(ext) {
-    return TS_JS_EXTS.has(ext) || PY_EXTS.has(ext) || GO_EXTS.has(ext) || JAVA_EXTS.has(ext) || RUST_EXTS.has(ext);
+    return TS_JS_EXTS.has(ext) || CJS_MJS_EXTS.has(ext) || PY_EXTS.has(ext) || GO_EXTS.has(ext) || JAVA_EXTS.has(ext) || RUST_EXTS.has(ext);
 }
 // ── Language-specific extractors ──────────────────────────────────────────────
 export function extractGoCallSites(source, filePath, fileNodeId) {
@@ -89,12 +90,26 @@ export function extractRustCallSites(source, filePath, fileNodeId) {
     }
     return sites;
 }
+// ── Stage 0.5: Track constructor assignments for type-aware method resolution ─
+/**
+ * Scan source for `const/let/var x = new ClassName(...)` patterns.
+ * Returns a map: localVarName → ClassName (e.g. "svc" → "MyService").
+ */
+function extractConstructorAssignments(source) {
+    const result = new Map();
+    const pattern = /(?:const|let|var)\s+(\w+)\s*=\s*new\s+([A-Z][\w$]*)\s*(?:<[^>]*>\s*)?\(/g;
+    let m;
+    while ((m = pattern.exec(source)) !== null) {
+        result.set(m[1], m[2]);
+    }
+    return result;
+}
 // ── Stage 1 + 2: Extract and classify call sites ──────────────────────────────
 function extractCallSites(source, filePath, fileNodeId, ext) {
     const sites = [];
-    if (TS_JS_EXTS.has(ext)) {
-        // Method calls: word.word(
-        const methodPattern = /(\w+)\.(\w+)\s*\(/g;
+    if (TS_JS_EXTS.has(ext) || CJS_MJS_EXTS.has(ext)) {
+        // Method calls: word.word( or word.word<T>(
+        const methodPattern = /(\w+)\.(\w+)\s*(?:<[^>]*>\s*)?\(/g;
         let m;
         while ((m = methodPattern.exec(source)) !== null) {
             sites.push({
@@ -106,8 +121,22 @@ function extractCallSites(source, filePath, fileNodeId, ext) {
                 methodName: m[2],
             });
         }
-        // Direct calls: word( not preceded by . or word char
-        const directPattern = /(?<![.[\w])([A-Za-z_$][\w$]*)\s*\(/g;
+        // Chained method calls: ).method( or ].method( — receiver unknown, resolve by method name
+        const chainedPattern = /[)\]]\s*\.(\w+)\s*(?:<[^>]*>\s*)?\(/g;
+        while ((m = chainedPattern.exec(source)) !== null) {
+            const name = m[1];
+            if (JS_KEYWORDS.has(name))
+                continue;
+            sites.push({
+                callerFileNodeId: fileNodeId,
+                callerFilePath: filePath,
+                calleeRaw: `?.${name}`,
+                form: 'method',
+                methodName: name,
+            });
+        }
+        // Direct calls: word( or word<T>( — not preceded by . or word char
+        const directPattern = /(?<![.[\w])([A-Za-z_$][\w$]*)\s*(?:<[^>]*>\s*)?\(/g;
         while ((m = directPattern.exec(source)) !== null) {
             const name = m[1];
             if (JS_KEYWORDS.has(name))
@@ -120,6 +149,17 @@ function extractCallSites(source, filePath, fileNodeId, ext) {
                 methodName: name,
             });
         }
+        // Constructor calls: new ClassName( or new ClassName<T>(
+        const newPattern = /\bnew\s+([A-Z][\w$]*)\s*(?:<[^>]*>\s*)?\(/g;
+        while ((m = newPattern.exec(source)) !== null) {
+            sites.push({
+                callerFileNodeId: fileNodeId,
+                callerFilePath: filePath,
+                calleeRaw: `new ${m[1]}`,
+                form: 'direct',
+                methodName: m[1],
+            });
+        }
         // Dynamic calls: obj[key]( → mark as dynamic
         const dynamicPattern = /\w+\s*\[[\w'"` ]+\]\s*\(/g;
         while ((m = dynamicPattern.exec(source)) !== null) {
@@ -171,56 +211,326 @@ function extractCallSites(source, filePath, fileNodeId, ext) {
     }
     return sites;
 }
-// ── Stage 3: Build import maps from DB (batch) ────────────────────────────────
+// ── Stage 3: Build import maps by parsing source imports ─────────────────────
+const IMPORT_RE = /import\s+(?:type\s+)?(?:\{([^}]+)\}|(\w+)|\*\s+as\s+(\w+))(?:\s*,\s*(?:\{([^}]+)\}|(\w+)|\*\s+as\s+(\w+)))?\s+from\s+['"]([^'"]+)['"]/g;
+// CJS require: const x = require('y') or const { a, b } = require('y')
+const REQUIRE_RE = /(?:const|let|var)\s+(?:\{([^}]+)\}|(\w+))\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+// Python: from x import y, z  OR  import x
+const PY_FROM_IMPORT_RE = /from\s+([\w.]+)\s+import\s+(.+)/g;
+const PY_IMPORT_RE = /^import\s+([\w.]+)(?:\s+as\s+(\w+))?/gm;
+// Go: import "path" or import ( "path" )
+const GO_IMPORT_RE = /import\s+(?:"([^"]+)"|(?:\w+\s+)?"([^"]+)"|\(\s*([\s\S]*?)\s*\))/g;
+// Java: import com.foo.Bar;
+const JAVA_IMPORT_RE = /import\s+(?:static\s+)?([\w.]+)\s*;/g;
+// Rust: use crate::module::Item; or use super::foo;
+const RUST_USE_RE = /use\s+((?:crate|super|self)(?:::\w+)+)(?:::\{([^}]+)\})?;/g;
+// TS/JS re-exports: export { foo, bar } from './module'
+const REEXPORT_RE = /export\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+const RESOLVE_EXTS = ['.ts', '.tsx', '.js', '.jsx'];
+const PY_RESOLVE_EXTS = ['.py'];
+const GO_RESOLVE_EXTS = ['.go'];
+const JAVA_RESOLVE_EXTS = ['.java'];
+const RUST_RESOLVE_EXTS = ['.rs'];
 /**
- * Load all IMPORTS edges once and return a map of fileNodeId → (name → filePath).
- * Eliminates the N+1 pattern of querying per-file inside the main loop.
+ * Build package-name → directory map from workspace package.json files.
+ * Scans packages/ for package.json and maps npm name to its relative src path.
  */
-function buildAllImportMaps(ctx, symbolNodes) {
+function buildWorkspacePackageMap(repoPath) {
     const result = new Map();
-    if (!ctx.db)
-        return result;
-    // Build a lookup: fileNodeId → filePath from symbolNodes
-    const idToFilePath = new Map();
-    for (const n of symbolNodes) {
-        if (n.label === 'File' && n.filePath) {
-            idToFilePath.set(n.id, n.filePath);
-            // Also register the alternate makeId form
-            const altId = makeId(n.filePath.replace(/\//g, '_'), 'file');
-            if (altId !== n.id)
-                idToFilePath.set(altId, n.filePath);
-        }
-    }
-    // Load ALL IMPORTS edges in one query
-    const importsRows = ctx.db
-        .prepare(`SELECT source_id, target_id FROM edges WHERE relation = 'IMPORTS'`)
-        .all();
-    for (const row of importsRows) {
-        const targetPath = idToFilePath.get(row.target_id);
-        if (!targetPath)
-            continue;
-        let fileMap = result.get(row.source_id);
-        if (!fileMap) {
-            fileMap = new Map();
-            result.set(row.source_id, fileMap);
+    const packagesDir = join(repoPath, 'packages');
+    try {
+        const scanDirs = (base, depth) => {
+            if (depth > 2)
+                return;
+            let entries;
+            try {
+                entries = require('fs').readdirSync(base);
+            }
+            catch {
+                return;
+            }
+            for (const e of entries) {
+                const full = join(base, e);
+                const pkgJson = join(full, 'package.json');
+                try {
+                    const pkg = JSON.parse(readFileSync(pkgJson, 'utf-8'));
+                    if (pkg.name) {
+                        const relDir = full.slice(repoPath.length + 1); // e.g. packages/@monomind/cli
+                        result.set(pkg.name, relDir);
+                    }
+                }
+                catch {
+                    // No package.json — recurse for @scoped dirs
+                    if (e.startsWith('@'))
+                        scanDirs(full, depth + 1);
+                }
+            }
+        };
+        scanDirs(packagesDir, 0);
+    }
+    catch { /* no packages dir */ }
+    return result;
+}
+function resolveModuleSpecifier(importerPath, specifier, repoPath, knownFiles, workspaceMap) {
+    if (specifier.startsWith('.')) {
+        const dir = dirname(importerPath);
+        const raw = resolvePath('/', dir, specifier).slice(1);
+        // Strip .js/.jsx — TS source uses .js extensions but files are .ts
+        const base = raw.replace(/\.(js|jsx)$/, '');
+        for (const candidate of [
+            raw,
+            base,
+            ...RESOLVE_EXTS.map(e => base + e),
+            ...RESOLVE_EXTS.map(e => base + '/index' + e),
+        ]) {
+            if (knownFiles.has(candidate))
+                return candidate;
+        }
+        for (const ext of RESOLVE_EXTS) {
+            if (existsSync(join(repoPath, base + ext)))
+                return base + ext;
+        }
+        return null;
+    }
+    // Workspace package specifier: @monomind/hooks → packages/@monomind/hooks/src/index.ts
+    // Also handles subpath: @monomind/hooks/src/foo → packages/@monomind/hooks/src/foo.ts
+    for (const [pkgName, pkgDir] of workspaceMap) {
+        if (specifier === pkgName) {
+            // Bare import: resolve to package entry point (src/index.ts)
+            for (const entry of RESOLVE_EXTS.map(e => pkgDir + '/src/index' + e)) {
+                if (knownFiles.has(entry))
+                    return entry;
+            }
+            return null;
+        }
+        if (specifier.startsWith(pkgName + '/')) {
+            const subpath = specifier.slice(pkgName.length + 1);
+            const base = pkgDir + '/' + subpath;
+            for (const candidate of [
+                base,
+                ...RESOLVE_EXTS.map(e => base + e),
+                ...RESOLVE_EXTS.map(e => base + '/index' + e),
+            ]) {
+                if (knownFiles.has(candidate))
+                    return candidate;
+            }
+            return null;
+        }
+    }
+    return null;
+}
+function resolvePythonModule(importerPath, modulePath, knownFiles) {
+    // Try relative to importer's directory, then absolute from repo root
+    const dir = dirname(importerPath);
+    for (const base of [dir + '/' + modulePath, modulePath]) {
+        for (const candidate of [base + '.py', base + '/__init__.py']) {
+            if (knownFiles.has(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+function resolveGoPackage(importerPath, goPath, knownFiles) {
+    for (const f of knownFiles) {
+        if (f.startsWith(goPath + '/') && f.endsWith('.go'))
+            return f;
+    }
+    return null;
+}
+function resolveJavaImport(qualifiedName, knownFiles) {
+    // com.foo.Bar → com/foo/Bar.java or src/main/java/com/foo/Bar.java
+    const pathPart = qualifiedName.replace(/\./g, '/');
+    for (const candidate of [pathPart + '.java', 'src/main/java/' + pathPart + '.java', 'src/' + pathPart + '.java']) {
+        if (knownFiles.has(candidate))
+            return candidate;
+    }
+    // Wildcard: com.foo.* → find any .java file in com/foo/
+    if (pathPart.endsWith('/*')) {
+        const dir = pathPart.slice(0, -2);
+        for (const f of knownFiles) {
+            if (f.endsWith('.java') && (f.startsWith(dir + '/') || f.includes('/' + dir + '/')))
+                return f;
+        }
+    }
+    return null;
+}
+function resolveRustUse(usePath, importerPath, knownFiles) {
+    // crate::module::item → src/module.rs or src/module/mod.rs
+    const parts = usePath.split('::');
+    if (parts[0] === 'crate')
+        parts[0] = 'src';
+    else if (parts[0] === 'super') {
+        const dir = dirname(importerPath);
+        parts[0] = dirname(dir);
+    }
+    else if (parts[0] === 'self') {
+        parts[0] = dirname(importerPath);
+    }
+    // Last segment is the item name — try with and without it
+    for (let len = parts.length; len >= 2; len--) {
+        const base = parts.slice(0, len).join('/');
+        for (const candidate of [base + '.rs', base + '/mod.rs']) {
+            if (knownFiles.has(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+function extractImportNames(clause) {
+    return clause
+        .split(',')
+        .map(s => s.trim().split(/\s+as\s+/).pop().trim())
+        .filter(Boolean);
+}
+/**
+ * Parse each file's import statements to build importedName → resolvedFilePath maps.
+ * Replaces the broken DB-edge approach (IMPORTS edges target Variable nodes, not Files).
+ */
+function buildAllImportMapsFromSource(repoPath, fileNodesByPath, fileContents) {
+    const result = new Map();
+    const knownFiles = new Set(fileNodesByPath.keys());
+    const workspaceMap = buildWorkspacePackageMap(repoPath);
+    for (const [filePath, fileNode] of fileNodesByPath) {
+        const ext = extname(filePath).toLowerCase();
+        const importMap = new Map();
+        let source = fileContents?.get(filePath);
+        if (!source) {
+            try {
+                source = readFileSync(join(repoPath, filePath), 'utf-8');
+            }
+            catch {
+                continue;
+            }
+        }
+        if (TS_JS_EXTS.has(ext) || ext === '.cjs' || ext === '.mjs') {
+            // ESM imports
+            IMPORT_RE.lastIndex = 0;
+            let m;
+            while ((m = IMPORT_RE.exec(source)) !== null) {
+                const specifier = m[7];
+                const resolved = resolveModuleSpecifier(filePath, specifier, repoPath, knownFiles, workspaceMap);
+                if (!resolved)
+                    continue;
+                if (m[1])
+                    for (const n of extractImportNames(m[1]))
+                        importMap.set(n, resolved);
+                if (m[4])
+                    for (const n of extractImportNames(m[4]))
+                        importMap.set(n, resolved);
+                if (m[2])
+                    importMap.set(m[2], resolved);
+                if (m[5])
+                    importMap.set(m[5], resolved);
+                if (m[3])
+                    importMap.set(m[3], resolved);
+                if (m[6])
+                    importMap.set(m[6], resolved);
+                const baseName = resolved.split('/').pop().replace(/\.\w+$/, '');
+                importMap.set(baseName, resolved);
+            }
+            // CJS require()
+            REQUIRE_RE.lastIndex = 0;
+            while ((m = REQUIRE_RE.exec(source)) !== null) {
+                const specifier = m[3];
+                const resolved = resolveModuleSpecifier(filePath, specifier, repoPath, knownFiles, workspaceMap);
+                if (!resolved)
+                    continue;
+                if (m[1])
+                    for (const n of extractImportNames(m[1]))
+                        importMap.set(n, resolved);
+                if (m[2])
+                    importMap.set(m[2], resolved);
+                const baseName = resolved.split('/').pop().replace(/\.\w+$/, '');
+                importMap.set(baseName, resolved);
+            }
+        }
+        else if (PY_EXTS.has(ext)) {
+            // Python: from module import name
+            PY_FROM_IMPORT_RE.lastIndex = 0;
+            let m;
+            while ((m = PY_FROM_IMPORT_RE.exec(source)) !== null) {
+                const modulePath = m[1].replace(/\./g, '/');
+                const resolved = resolvePythonModule(filePath, modulePath, knownFiles);
+                if (!resolved)
+                    continue;
+                for (const name of m[2].split(',').map(s => s.trim().split(/\s+as\s+/).pop().trim()).filter(Boolean)) {
+                    importMap.set(name, resolved);
+                }
+                const baseName = resolved.split('/').pop().replace(/\.\w+$/, '');
+                importMap.set(baseName, resolved);
+            }
+            // Python: import module
+            PY_IMPORT_RE.lastIndex = 0;
+            while ((m = PY_IMPORT_RE.exec(source)) !== null) {
+                const modulePath = m[1].replace(/\./g, '/');
+                const resolved = resolvePythonModule(filePath, modulePath, knownFiles);
+                if (!resolved)
+                    continue;
+                const alias = m[2] ?? m[1].split('.').pop();
+                importMap.set(alias, resolved);
+            }
+        }
+        else if (GO_EXTS.has(ext)) {
+            GO_IMPORT_RE.lastIndex = 0;
+            let m;
+            while ((m = GO_IMPORT_RE.exec(source)) !== null) {
+                const paths = m[3]
+                    ? m[3].match(/"([^"]+)"/g)?.map(s => s.slice(1, -1)) ?? []
+                    : [m[1] ?? m[2]].filter(Boolean);
+                for (const goPath of paths) {
+                    const resolved = resolveGoPackage(filePath, goPath, knownFiles);
+                    if (!resolved)
+                        continue;
+                    const pkgName = goPath.split('/').pop();
+                    importMap.set(pkgName, resolved);
+                }
+            }
+        }
+        else if (JAVA_EXTS.has(ext)) {
+            JAVA_IMPORT_RE.lastIndex = 0;
+            let m;
+            while ((m = JAVA_IMPORT_RE.exec(source)) !== null) {
+                const resolved = resolveJavaImport(m[1], knownFiles);
+                if (!resolved)
+                    continue;
+                const className = m[1].split('.').pop();
+                importMap.set(className, resolved);
+            }
+        }
+        else if (RUST_EXTS.has(ext)) {
+            RUST_USE_RE.lastIndex = 0;
+            let m;
+            while ((m = RUST_USE_RE.exec(source)) !== null) {
+                if (m[2]) {
+                    // use crate::module::{Item1, Item2}
+                    for (const name of m[2].split(',').map(s => s.trim()).filter(Boolean)) {
+                        const resolved = resolveRustUse(m[1] + '::' + name, filePath, knownFiles);
+                        if (resolved)
+                            importMap.set(name.split('::').pop(), resolved);
+                    }
+                }
+                else {
+                    const resolved = resolveRustUse(m[1], filePath, knownFiles);
+                    if (!resolved)
+                        continue;
+                    const itemName = m[1].split('::').pop();
+                    importMap.set(itemName, resolved);
+                }
+            }
+        }
+        if (importMap.size > 0) {
+            result.set(fileNode.id, importMap);
         }
-        const parts = targetPath.split('/');
-        const baseName = parts[parts.length - 1].replace(/\.\w+$/, '');
-        fileMap.set(baseName, targetPath);
-        fileMap.set(targetPath, targetPath);
     }
     return result;
 }
-/** Returns the pre-built import map for a given file node (empty map if not found). */
 function getImportMap(allImportMaps, fileNodeId) {
     return allImportMaps.get(fileNodeId) ?? new Map();
 }
 // ── Stage 4 helpers: preloaded function/method index ──────────────────────────
 /**
- * Load all Function/Method/Constructor nodes once.
- * Returns two indices:
- * - byFilePath: filePath → name → id[] (for resolveTarget candidate lookup)
- * - nameCounts: name → total occurrences across all files (for ambiguity check)
+ * Load all callable nodes once (Function, Method, Constructor, Class).
+ * Class is included so `new ClassName()` can resolve to Class nodes.
  */
 function buildFunctionIndex(ctx) {
     const byFilePath = new Map();
@@ -228,7 +538,7 @@ function buildFunctionIndex(ctx) {
     if (!ctx.db)
         return { byFilePath, nameCounts };
     const rows = ctx.db
-        .prepare(`SELECT id, name, file_path FROM nodes WHERE label IN ('Function', 'Method', 'Constructor') AND file_path IS NOT NULL`)
+        .prepare(`SELECT id, name, file_path FROM nodes WHERE label IN ('Function', 'Method', 'Constructor', 'Class') AND file_path IS NOT NULL`)
         .all();
     for (const row of rows) {
         // byFilePath index
@@ -249,69 +559,96 @@ function buildFunctionIndex(ctx) {
     return { byFilePath, nameCounts };
 }
 // ── Stage 4 + 5: Resolve target node (index-based, no per-call DB query) ──────
-function resolveTarget(site, callerFilePath, importMap, fnIndex) {
+function pickBestId(ids, site) {
+    if (ids.length === 1)
+        return ids[0];
+    if (ids.length === 0)
+        return null;
+    // Disambiguate: prefer Function for direct calls, Method for method calls
+    const suffix = site.form === 'method' ? '_method' : '_function';
+    const match = ids.find(id => id.endsWith(suffix));
+    // For `new ClassName()` prefer _class
+    if (!match && site.calleeRaw.startsWith('new ')) {
+        const classMatch = ids.find(id => id.endsWith('_class'));
+        if (classMatch)
+            return classMatch;
+    }
+    return match ?? ids[0];
+}
+function resolveTarget(site, callerFilePath, importMap, fnIndex, ctorMap, importedFiles) {
     const methodName = site.methodName;
     if (!methodName)
         return null;
     let candidateFilePaths;
     if (site.form === 'method' && site.receiverName) {
-        // Stage 3: Infer receiver type — look up receiver in import map
         const receiverPath = importMap.get(site.receiverName);
-        candidateFilePaths = receiverPath ? [receiverPath] : [callerFilePath];
+        if (receiverPath) {
+            candidateFilePaths = [receiverPath];
+        }
+        else {
+            const className = ctorMap?.get(site.receiverName);
+            const classFilePath = className ? importMap.get(className) : undefined;
+            if (classFilePath) {
+                candidateFilePaths = [classFilePath, callerFilePath];
+            }
+            else {
+                const sameFileIds = fnIndex.get(callerFilePath)?.get(methodName);
+                if (sameFileIds && sameFileIds.length > 0) {
+                    return { targetId: pickBestId(sameFileIds, site) };
+                }
+                const matches = importedFiles.filter(fp => fnIndex.get(fp)?.has(methodName));
+                if (matches.length === 1) {
+                    const ids = fnIndex.get(matches[0]).get(methodName);
+                    return { targetId: pickBestId(ids, site) };
+                }
+                return null;
+            }
+        }
     }
     else if (site.form === 'direct') {
-        // Direct call: same file first, then all imported files
-        candidateFilePaths = [callerFilePath, ...importMap.values()];
+        const importedFrom = importMap.get(methodName);
+        if (importedFrom) {
+            candidateFilePaths = [importedFrom, callerFilePath];
+        }
+        else {
+            candidateFilePaths = [callerFilePath, ...importedFiles];
+        }
     }
     else {
         return null;
     }
-    // Stage 5: O(1) lookup in preloaded index instead of per-call DB query
     for (const fp of candidateFilePaths) {
         const ids = fnIndex.get(fp)?.get(methodName);
-        if (ids && ids.length === 1) {
-            return { targetId: ids[0] };
+        if (ids && ids.length > 0) {
+            const best = pickBestId(ids, site);
+            if (best)
+                return { targetId: best };
         }
-        // ids.length > 1 → ambiguous within this file — skip to next candidate
     }
     return null;
 }
-// ── Stage 6: Emit edge ────────────────────────────────────────────────────────
-function emitEdge(ctx, sourceId, targetId) {
-    if (!ctx.db)
-        return 'skipped';
+function prepareEdgeStmts(db) {
+    return {
+        selectExisting: db.prepare(`SELECT id, confidence_score FROM edges WHERE source_id = ? AND target_id = ? AND relation = 'CALLS'`),
+        updateScore: db.prepare(`UPDATE edges SET confidence_score = ?, confidence = 'EXTRACTED' WHERE id = ?`),
+        insertNew: db.prepare(`INSERT OR IGNORE INTO edges (id, source_id, target_id, relation, confidence, confidence_score) VALUES (?, ?, ?, 'CALLS', 'EXTRACTED', ?)`),
+    };
+}
+const RESOLVED_CONFIDENCE_SCORE = 0.75;
+function emitEdge(stmts, sourceId, targetId) {
     if (sourceId === targetId)
         return 'skipped';
-    const RESOLVED_CONFIDENCE_SCORE = 0.75;
-    // Check if a CALLS edge already exists
-    const existing = ctx.db
-        .prepare(`
-      SELECT id, confidence_score FROM edges
-      WHERE source_id = ? AND target_id = ? AND relation = 'CALLS'
-    `)
-        .get(sourceId, targetId);
+    const existing = stmts.selectExisting.get(sourceId, targetId);
     if (existing) {
         const newScore = Math.max(existing.confidence_score, RESOLVED_CONFIDENCE_SCORE);
         if (newScore > existing.confidence_score) {
-            ctx.db
-                .prepare(`
-          UPDATE edges
-          SET confidence_score = ?, confidence = 'EXTRACTED'
-          WHERE id = ?
-        `)
-                .run(newScore, existing.id);
+            stmts.updateScore.run(newScore, existing.id);
         }
         return 'upgraded';
     }
-    // Insert new CALLS edge
     const edgeId = makeId(sourceId, targetId, 'calls_resolved');
     try {
-        ctx.db
-            .prepare(`
-        INSERT OR IGNORE INTO edges (id, source_id, target_id, relation, confidence, confidence_score)
-        VALUES (?, ?, ?, 'CALLS', 'EXTRACTED', ?)
-      `)
-            .run(edgeId, sourceId, targetId, RESOLVED_CONFIDENCE_SCORE);
+        stmts.insertNew.run(edgeId, sourceId, targetId, RESOLVED_CONFIDENCE_SCORE);
         return 'inserted';
     }
     catch {
@@ -323,6 +660,9 @@ export const scopeResolutionPhase = {
     name: 'scope-resolution',
     deps: ['parse', 'cross-file'],
     async execute(ctx, deps) {
+        if (ctx.allFilesCached) {
+            return { resolvedEdges: 0, skippedDynamic: 0, ambiguous: 0, reexportEdges: 0, orphanImportsRemoved: 0, importsReconstructed: 0 };
+        }
         const { symbolNodes } = deps.get('parse');
         let resolvedEdges = 0;
         let skippedDynamic = 0;
@@ -353,50 +693,153 @@ export const scopeResolutionPhase = {
                 }
             }
         }
-        // Preload all IMPORTS edges → per-file import maps (one DB query total)
-        const allImportMaps = buildAllImportMaps(ctx, symbolNodes);
+        // Parse source imports → per-file import maps (replaces broken DB-edge approach)
+        const { fileContents } = deps.get('parse');
+        const allImportMaps = buildAllImportMapsFromSource(ctx.repoPath, fileNodesByPath, fileContents);
         // Preload all Function/Method/Constructor nodes into indices (one DB query total)
         const { byFilePath: fnIndex, nameCounts } = buildFunctionIndex(ctx);
-        for (const [filePath, fileNode] of fileNodesByPath) {
-            const ext = extname(filePath).toLowerCase();
-            if (!isSupportedExt(ext))
-                continue;
-            // Read file source
-            let source;
-            try {
-                source = readFileSync(join(ctx.repoPath, filePath), 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            // Stage 1+2: Extract call sites
-            const callSites = extractCallSites(source, filePath, fileNode.id, ext);
-            // Stage 3: Get pre-built import map for this file (O(1))
-            const importMap = getImportMap(allImportMaps, fileNode.id);
-            for (const site of callSites) {
-                if (site.form === 'dynamic') {
-                    skippedDynamic++;
+        const edgeStmts = ctx.db ? prepareEdgeStmts(ctx.db) : null;
+        const resolveAllCalls = ctx.db?.transaction(() => {
+            for (const [filePath, fileNode] of fileNodesByPath) {
+                const ext = extname(filePath).toLowerCase();
+                if (!isSupportedExt(ext))
                     continue;
+                // Read file source (prefer cached from parse phase)
+                let source = fileContents.get(filePath);
+                if (!source) {
+                    try {
+                        source = readFileSync(join(ctx.repoPath, filePath), 'utf-8');
+                    }
+                    catch {
+                        continue;
+                    }
                 }
-                // Stage 4+5: Resolve target using preloaded indices (no DB query)
-                const resolved = resolveTarget(site, filePath, importMap, fnIndex);
-                if (!resolved) {
-                    // Could not resolve — method calls with unresolvable receivers are simply skipped
-                    continue;
+                // Stage 1+2: Extract call sites
+                const callSites = extractCallSites(source, filePath, fileNode.id, ext);
+                // Stage 3: Get pre-built import map for this file (O(1))
+                const importMap = getImportMap(allImportMaps, fileNode.id);
+                // Track constructor assignments for type-aware method resolution
+                const ctorMap = (TS_JS_EXTS.has(ext) || CJS_MJS_EXTS.has(ext)) ? extractConstructorAssignments(source) : undefined;
+                // Precompute once per file instead of per call site
+                const importedFiles = [...new Set(importMap.values())];
+                for (const site of callSites) {
+                    if (site.form === 'dynamic') {
+                        skippedDynamic++;
+                        continue;
+                    }
+                    // Stage 4+5: Resolve target using preloaded indices (no DB query)
+                    const resolved = resolveTarget(site, filePath, importMap, fnIndex, ctorMap, importedFiles);
+                    if (!resolved) {
+                        continue;
+                    }
+                    // Ambiguity check using preloaded name counts (no DB query)
+                    if (site.methodName && (nameCounts.get(site.methodName) ?? 0) > 1) {
+                        ambiguous++;
+                    }
+                    // Stage 6: Emit edge (source is the file node of the caller)
+                    const result = edgeStmts ? emitEdge(edgeStmts, site.callerFileNodeId, resolved.targetId) : 'skipped';
+                    if (result === 'inserted' || result === 'upgraded') {
+                        resolvedEdges++;
+                    }
                 }
-                // Ambiguity check using preloaded name counts (no DB query)
-                if (site.methodName && (nameCounts.get(site.methodName) ?? 0) > 1) {
-                    ambiguous++;
-                    // Still emit — we found exactly one candidate in the caller's context
+            }
+        });
+        resolveAllCalls?.();
+        // Scan for re-exports: export { foo, bar } from './module'
+        // Creates REFERENCES edges so re-exported symbols don't appear as dead code.
+        let reexportEdges = 0;
+        if (ctx.db) {
+            const insertRef = ctx.db.prepare(`
+        INSERT OR IGNORE INTO edges (id, source_id, target_id, relation, confidence, confidence_score)
+        VALUES (?, ?, ?, 'REFERENCES', 'EXTRACTED', 0.85)
+      `);
+            const insertReexports = ctx.db.transaction(() => {
+                for (const [filePath, fileNode] of fileNodesByPath) {
+                    const ext = extname(filePath).toLowerCase();
+                    if (!TS_JS_EXTS.has(ext) && !CJS_MJS_EXTS.has(ext))
+                        continue;
+                    let source = fileContents.get(filePath);
+                    if (!source) {
+                        try {
+                            source = readFileSync(join(ctx.repoPath, filePath), 'utf-8');
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                    const importMap = getImportMap(allImportMaps, fileNode.id);
+                    REEXPORT_RE.lastIndex = 0;
+                    let m;
+                    while ((m = REEXPORT_RE.exec(source)) !== null) {
+                        const specifier = m[2];
+                        const names = extractImportNames(m[1]);
+                        // Resolve the source module
+                        const knownFiles = new Set(fileNodesByPath.keys());
+                        const workspaceMap = buildWorkspacePackageMap(ctx.repoPath);
+                        const resolvedFile = resolveModuleSpecifier(filePath, specifier, ctx.repoPath, knownFiles, workspaceMap);
+                        if (!resolvedFile)
+                            continue;
+                        for (const name of names) {
+                            // Find the function/class node in the source file
+                            const ids = fnIndex.get(resolvedFile)?.get(name);
+                            if (!ids || ids.length === 0)
+                                continue;
+                            const targetId = ids.length === 1 ? ids[0] : (ids.find(id => id.endsWith('_function')) ?? ids[0]);
+                            const edgeId = makeId(fileNode.id, targetId, 'reexport_ref');
+                            try {
+                                insertRef.run(edgeId, fileNode.id, targetId);
+                                reexportEdges++;
+                            }
+                            catch { /* duplicate */ }
+                        }
+                    }
                 }
-                // Stage 6: Emit edge (source is the file node of the caller)
-                const result = emitEdge(ctx, site.callerFileNodeId, resolved.targetId);
-                if (result === 'inserted' || result === 'upgraded') {
-                    resolvedEdges++;
+            });
+            insertReexports();
+        }
+        // Clean up orphan IMPORTS edges that target Variable nodes instead of Files.
+        let orphanImportsRemoved = 0;
+        if (ctx.db) {
+            const result = ctx.db
+                .prepare(`
+          DELETE FROM edges WHERE id IN (
+            SELECT e.id FROM edges e
+            JOIN nodes t ON e.target_id = t.id
+            WHERE e.relation = 'IMPORTS' AND t.label = 'Variable'
+          )
+        `)
+                .run();
+            orphanImportsRemoved = result.changes;
+        }
+        // Reconstruct proper File→File IMPORTS edges from source-parsed import maps.
+        let importsReconstructed = 0;
+        if (ctx.db) {
+            const insertImport = ctx.db.prepare(`
+        INSERT OR IGNORE INTO edges (id, source_id, target_id, relation, confidence, confidence_score)
+        VALUES (?, ?, ?, 'IMPORTS', 'EXTRACTED', 0.9)
+      `);
+            const fileIdByPath = new Map();
+            for (const [fp, node] of fileNodesByPath)
+                fileIdByPath.set(fp, node.id);
+            const insertAll = ctx.db.transaction(() => {
+                for (const [fileNodeId, importMap] of allImportMaps) {
+                    const targetPaths = new Set(importMap.values());
+                    for (const targetPath of targetPaths) {
+                        const targetFileId = fileIdByPath.get(targetPath);
+                        if (!targetFileId || targetFileId === fileNodeId)
+                            continue;
+                        const edgeId = makeId(fileNodeId, targetFileId, 'imports_file');
+                        try {
+                            insertImport.run(edgeId, fileNodeId, targetFileId);
+                            importsReconstructed++;
+                        }
+                        catch { /* duplicate — already exists */ }
+                    }
                 }
-            }
+            });
+            insertAll();
         }
-        return { resolvedEdges, skippedDynamic, ambiguous };
+        return { resolvedEdges, skippedDynamic, ambiguous, reexportEdges, orphanImportsRemoved, importsReconstructed };
     },
 };
 //# sourceMappingURL=scope-resolution.js.map