@optave/codegraph 3.2.0 → 3.3.1

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

@@ -102,6 +102,16 @@ function buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodes, native)
     if (!fileNodeRow) continue;
 
     const importedNames = buildImportedNamesForNative(ctx, relPath, symbols, rootDir);
+    const typeMap =
+      symbols.typeMap instanceof Map
+        ? [...symbols.typeMap.entries()].map(([name, entry]) => ({
+            name,
+            typeName: typeof entry === 'string' ? entry : entry.type,
+            confidence: typeof entry === 'object' ? entry.confidence : 0.9,
+          }))
+        : Array.isArray(symbols.typeMap)
+          ? symbols.typeMap
+          : [];
     nativeFiles.push({
       file: relPath,
       fileNodeId: fileNodeRow.id,
@@ -114,6 +124,7 @@ function buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodes, native)
       calls: symbols.calls,
       importedNames,
       classes: symbols.classes,
+      typeMap,
     });
   }
 
@@ -121,6 +132,14 @@ function buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodes, native)
   for (const e of nativeEdges) {
     allEdgeRows.push([e.sourceId, e.targetId, e.kind, e.confidence, e.dynamic]);
   }
+
+  // Older native binaries (< 3.2.0) don't emit receiver or type-resolved method-call
+  // edges. Supplement them on the JS side if the native binary missed them.
+  // TODO: Remove once all published native binaries handle receivers (>= 3.2.0)
+  const hasReceiver = nativeEdges.some((e) => e.kind === 'receiver');
+  if (!hasReceiver) {
+    supplementReceiverEdges(ctx, nativeFiles, getNodeIdStmt, allEdgeRows);
+  }
 }
 
 function buildImportedNamesForNative(ctx, relPath, symbols, rootDir) {
@@ -140,6 +159,53 @@ function buildImportedNamesForNative(ctx, relPath, symbols, rootDir) {
   return importedNames;
 }
 
+// ── Receiver edge supplement for older native binaries ──────────────────
+
+function supplementReceiverEdges(ctx, nativeFiles, getNodeIdStmt, allEdgeRows) {
+  const seenCallEdges = new Set();
+  // Collect existing edges to avoid duplicates
+  for (const row of allEdgeRows) {
+    seenCallEdges.add(`${row[0]}|${row[1]}|${row[2]}`);
+  }
+
+  for (const nf of nativeFiles) {
+    const relPath = nf.file;
+    const typeMap = new Map(
+      nf.typeMap.map((t) => [t.name, { type: t.typeName, confidence: t.confidence ?? 0.9 }]),
+    );
+    const fileNodeRow = { id: nf.fileNodeId };
+
+    for (const call of nf.calls) {
+      if (!call.receiver || BUILTIN_RECEIVERS.has(call.receiver)) continue;
+      if (call.receiver === 'this' || call.receiver === 'self' || call.receiver === 'super')
+        continue;
+
+      const caller = findCaller(call, nf.definitions, relPath, getNodeIdStmt, fileNodeRow);
+
+      // Receiver edge: caller → receiver type node
+      buildReceiverEdge(ctx, call, caller, relPath, seenCallEdges, allEdgeRows, typeMap);
+
+      // Type-resolved method call: caller → Type.method
+      const typeEntry = typeMap.get(call.receiver);
+      const typeName = typeEntry ? typeEntry.type : null;
+      if (typeName) {
+        const qualifiedName = `${typeName}.${call.name}`;
+        const targets = (ctx.nodesByName.get(qualifiedName) || []).filter(
+          (n) => n.kind === 'method',
+        );
+        for (const t of targets) {
+          const key = `${caller.id}|${t.id}|calls`;
+          if (t.id !== caller.id && !seenCallEdges.has(key)) {
+            seenCallEdges.add(key);
+            const confidence = computeConfidence(relPath, t.file, null);
+            allEdgeRows.push([caller.id, t.id, 'calls', confidence, call.dynamic ? 1 : 0]);
+          }
+        }
+      }
+    }
+  }
+}
+
 // ── Call edges (JS fallback) ────────────────────────────────────────────
 
 function buildCallEdgesJS(ctx, getNodeIdStmt, allEdgeRows) {
@@ -151,6 +217,7 @@ function buildCallEdgesJS(ctx, getNodeIdStmt, allEdgeRows) {
     if (!fileNodeRow) continue;
 
     const importedNames = buildImportedNamesMap(ctx, relPath, symbols, rootDir);
+    const typeMap = symbols.typeMap || new Map();
     const seenCallEdges = new Set();
 
     buildFileCallEdges(
@@ -162,6 +229,7 @@ function buildCallEdgesJS(ctx, getNodeIdStmt, allEdgeRows) {
       seenCallEdges,
       getNodeIdStmt,
       allEdgeRows,
+      typeMap,
     );
     buildClassHierarchyEdges(ctx, relPath, symbols, allEdgeRows);
   }
@@ -202,7 +270,7 @@ function findCaller(call, definitions, relPath, getNodeIdStmt, fileNodeRow) {
   return caller || fileNodeRow;
 }
 
-function resolveCallTargets(ctx, call, relPath, importedNames) {
+function resolveCallTargets(ctx, call, relPath, importedNames, typeMap) {
   const importedFrom = importedNames.get(call.name);
   let targets;
 
@@ -219,7 +287,7 @@ function resolveCallTargets(ctx, call, relPath, importedNames) {
   if (!targets || targets.length === 0) {
     targets = ctx.nodesByNameAndFile.get(`${call.name}|${relPath}`) || [];
     if (targets.length === 0) {
-      targets = resolveByMethodOrGlobal(ctx, call, relPath);
+      targets = resolveByMethodOrGlobal(ctx, call, relPath, typeMap);
     }
   }
 
@@ -234,11 +302,21 @@ function resolveCallTargets(ctx, call, relPath, importedNames) {
   return { targets, importedFrom };
 }
 
-function resolveByMethodOrGlobal(ctx, call, relPath) {
-  const methodCandidates = (ctx.nodesByName.get(call.name) || []).filter(
-    (n) => n.name.endsWith(`.${call.name}`) && n.kind === 'method',
-  );
-  if (methodCandidates.length > 0) return methodCandidates;
+function resolveByMethodOrGlobal(ctx, call, relPath, typeMap) {
+  // Type-aware resolution: translate variable receiver to its declared type
+  if (call.receiver && typeMap) {
+    const typeEntry = typeMap.get(call.receiver);
+    const typeName = typeEntry
+      ? typeof typeEntry === 'string'
+        ? typeEntry
+        : typeEntry.type
+      : null;
+    if (typeName) {
+      const qualifiedName = `${typeName}.${call.name}`;
+      const typed = (ctx.nodesByName.get(qualifiedName) || []).filter((n) => n.kind === 'method');
+      if (typed.length > 0) return typed;
+    }
+  }
 
   if (
     !call.receiver ||
@@ -262,13 +340,20 @@ function buildFileCallEdges(
   seenCallEdges,
   getNodeIdStmt,
   allEdgeRows,
+  typeMap,
 ) {
   for (const call of symbols.calls) {
     if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
 
     const caller = findCaller(call, symbols.definitions, relPath, getNodeIdStmt, fileNodeRow);
     const isDynamic = call.dynamic ? 1 : 0;
-    const { targets, importedFrom } = resolveCallTargets(ctx, call, relPath, importedNames);
+    const { targets, importedFrom } = resolveCallTargets(
+      ctx,
+      call,
+      relPath,
+      importedNames,
+      typeMap,
+    );
 
     for (const t of targets) {
       const edgeKey = `${caller.id}|${t.id}`;
@@ -287,35 +372,47 @@ function buildFileCallEdges(
       call.receiver !== 'self' &&
       call.receiver !== 'super'
     ) {
-      buildReceiverEdge(ctx, call, caller, relPath, seenCallEdges, allEdgeRows);
+      buildReceiverEdge(ctx, call, caller, relPath, seenCallEdges, allEdgeRows, typeMap);
     }
   }
 }
 
-function buildReceiverEdge(ctx, call, caller, relPath, seenCallEdges, allEdgeRows) {
+function buildReceiverEdge(ctx, call, caller, relPath, seenCallEdges, allEdgeRows, typeMap) {
   const receiverKinds = new Set(['class', 'struct', 'interface', 'type', 'module']);
-  const samefile = ctx.nodesByNameAndFile.get(`${call.receiver}|${relPath}`) || [];
-  const candidates = samefile.length > 0 ? samefile : ctx.nodesByName.get(call.receiver) || [];
+  const typeEntry = typeMap?.get(call.receiver);
+  const typeName = typeEntry ? (typeof typeEntry === 'string' ? typeEntry : typeEntry.type) : null;
+  const typeConfidence = typeEntry && typeof typeEntry === 'object' ? typeEntry.confidence : null;
+  const effectiveReceiver = typeName || call.receiver;
+  const samefile = ctx.nodesByNameAndFile.get(`${effectiveReceiver}|${relPath}`) || [];
+  const candidates = samefile.length > 0 ? samefile : ctx.nodesByName.get(effectiveReceiver) || [];
   const receiverNodes = candidates.filter((n) => receiverKinds.has(n.kind));
   if (receiverNodes.length > 0 && caller) {
     const recvTarget = receiverNodes[0];
     const recvKey = `recv|${caller.id}|${recvTarget.id}`;
     if (!seenCallEdges.has(recvKey)) {
       seenCallEdges.add(recvKey);
-      allEdgeRows.push([caller.id, recvTarget.id, 'receiver', 0.7, 0]);
+      // Use type source confidence when available, otherwise 0.7 for untyped receiver
+      const confidence = typeConfidence ?? (typeName ? 0.9 : 0.7);
+      allEdgeRows.push([caller.id, recvTarget.id, 'receiver', confidence, 0]);
     }
   }
 }
 
 // ── Class hierarchy edges ───────────────────────────────────────────────
 
+const HIERARCHY_SOURCE_KINDS = new Set(['class', 'struct', 'record', 'enum']);
+const EXTENDS_TARGET_KINDS = new Set(['class', 'struct', 'trait', 'record']);
+const IMPLEMENTS_TARGET_KINDS = new Set(['interface', 'trait', 'class']);
+
 function buildClassHierarchyEdges(ctx, relPath, symbols, allEdgeRows) {
   for (const cls of symbols.classes) {
     if (cls.extends) {
-      const sourceRow = (ctx.nodesByNameAndFile.get(`${cls.name}|${relPath}`) || []).find(
-        (n) => n.kind === 'class',
+      const sourceRow = (ctx.nodesByNameAndFile.get(`${cls.name}|${relPath}`) || []).find((n) =>
+        HIERARCHY_SOURCE_KINDS.has(n.kind),
+      );
+      const targetRows = (ctx.nodesByName.get(cls.extends) || []).filter((n) =>
+        EXTENDS_TARGET_KINDS.has(n.kind),
       );
-      const targetRows = (ctx.nodesByName.get(cls.extends) || []).filter((n) => n.kind === 'class');
       if (sourceRow) {
         for (const t of targetRows) {
           allEdgeRows.push([sourceRow.id, t.id, 'extends', 1.0, 0]);
@@ -324,11 +421,11 @@ function buildClassHierarchyEdges(ctx, relPath, symbols, allEdgeRows) {
     }
 
     if (cls.implements) {
-      const sourceRow = (ctx.nodesByNameAndFile.get(`${cls.name}|${relPath}`) || []).find(
-        (n) => n.kind === 'class',
+      const sourceRow = (ctx.nodesByNameAndFile.get(`${cls.name}|${relPath}`) || []).find((n) =>
+        HIERARCHY_SOURCE_KINDS.has(n.kind),
       );
-      const targetRows = (ctx.nodesByName.get(cls.implements) || []).filter(
-        (n) => n.kind === 'interface' || n.kind === 'class',
+      const targetRows = (ctx.nodesByName.get(cls.implements) || []).filter((n) =>
+        IMPLEMENTS_TARGET_KINDS.has(n.kind),
       );
       if (sourceRow) {
         for (const t of targetRows) {

package/src/domain/graph/resolve.js

@@ -3,6 +3,306 @@ import path from 'node:path';
 import { loadNative } from '../../infrastructure/native.js';
 import { normalizePath } from '../../shared/constants.js';
 
+// ── package.json exports resolution ─────────────────────────────────
+
+/** Cache: packageDir → parsed exports field (or null) */
+const _exportsCache = new Map();
+
+/**
+ * Parse a bare specifier into { packageName, subpath }.
+ * Scoped: "@scope/pkg/sub" → { packageName: "@scope/pkg", subpath: "./sub" }
+ * Plain:  "pkg/sub"        → { packageName: "pkg", subpath: "./sub" }
+ * No sub: "pkg"            → { packageName: "pkg", subpath: "." }
+ */
+export function parseBareSpecifier(specifier) {
+  let packageName, rest;
+  if (specifier.startsWith('@')) {
+    const parts = specifier.split('/');
+    if (parts.length < 2) return null;
+    packageName = `${parts[0]}/${parts[1]}`;
+    rest = parts.slice(2).join('/');
+  } else {
+    const slashIdx = specifier.indexOf('/');
+    if (slashIdx === -1) {
+      packageName = specifier;
+      rest = '';
+    } else {
+      packageName = specifier.slice(0, slashIdx);
+      rest = specifier.slice(slashIdx + 1);
+    }
+  }
+  return { packageName, subpath: rest ? `./${rest}` : '.' };
+}
+
+/**
+ * Find the package directory for a given package name, starting from rootDir.
+ * Walks up node_modules directories.
+ */
+function findPackageDir(packageName, rootDir) {
+  let dir = rootDir;
+  while (true) {
+    const candidate = path.join(dir, 'node_modules', packageName);
+    if (fs.existsSync(path.join(candidate, 'package.json'))) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * Read and cache the exports field from a package's package.json.
+ * Returns the exports value or null.
+ */
+function getPackageExports(packageDir) {
+  if (_exportsCache.has(packageDir)) return _exportsCache.get(packageDir);
+  try {
+    const raw = fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8');
+    const pkg = JSON.parse(raw);
+    const exports = pkg.exports ?? null;
+    _exportsCache.set(packageDir, exports);
+    return exports;
+  } catch {
+    _exportsCache.set(packageDir, null);
+    return null;
+  }
+}
+
+/** Condition names to try, in priority order. */
+const CONDITION_ORDER = ['import', 'require', 'default'];
+
+/**
+ * Resolve a conditional exports value (string, object with conditions, or array).
+ * Returns a string target or null.
+ */
+function resolveCondition(value) {
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const r = resolveCondition(item);
+      if (r) return r;
+    }
+    return null;
+  }
+  if (value && typeof value === 'object') {
+    for (const cond of CONDITION_ORDER) {
+      if (cond in value) return resolveCondition(value[cond]);
+    }
+    return null;
+  }
+  return null;
+}
+
+/**
+ * Match a subpath against an exports map key that uses a wildcard pattern.
+ * Key: "./lib/*" matches subpath "./lib/foo/bar" → substitution "foo/bar"
+ */
+function matchSubpathPattern(pattern, subpath) {
+  const starIdx = pattern.indexOf('*');
+  if (starIdx === -1) return null;
+  const prefix = pattern.slice(0, starIdx);
+  const suffix = pattern.slice(starIdx + 1);
+  if (!subpath.startsWith(prefix)) return null;
+  if (suffix && !subpath.endsWith(suffix)) return null;
+  const matched = subpath.slice(prefix.length, suffix ? -suffix.length || undefined : undefined);
+  if (!suffix && subpath.length <= prefix.length) return null;
+  return matched;
+}
+
+/**
+ * Resolve a bare specifier through the package.json exports field.
+ * Returns an absolute path or null.
+ */
+export function resolveViaExports(specifier, rootDir) {
+  const parsed = parseBareSpecifier(specifier);
+  if (!parsed) return null;
+
+  const packageDir = findPackageDir(parsed.packageName, rootDir);
+  if (!packageDir) return null;
+
+  const exports = getPackageExports(packageDir);
+  if (exports == null) return null;
+
+  const { subpath } = parsed;
+
+  // Simple string exports: "exports": "./index.js"
+  if (typeof exports === 'string') {
+    if (subpath === '.') {
+      const resolved = path.resolve(packageDir, exports);
+      return fs.existsSync(resolved) ? resolved : null;
+    }
+    return null;
+  }
+
+  // Array form at top level
+  if (Array.isArray(exports)) {
+    if (subpath === '.') {
+      const target = resolveCondition(exports);
+      if (target) {
+        const resolved = path.resolve(packageDir, target);
+        return fs.existsSync(resolved) ? resolved : null;
+      }
+    }
+    return null;
+  }
+
+  if (typeof exports !== 'object') return null;
+
+  // Determine if exports is a conditions object (no keys start with ".")
+  // or a subpath map (keys start with ".")
+  const keys = Object.keys(exports);
+  const isSubpathMap = keys.length > 0 && keys.some((k) => k.startsWith('.'));
+
+  if (!isSubpathMap) {
+    // Conditions object at top level → applies to "." subpath only
+    if (subpath === '.') {
+      const target = resolveCondition(exports);
+      if (target) {
+        const resolved = path.resolve(packageDir, target);
+        return fs.existsSync(resolved) ? resolved : null;
+      }
+    }
+    return null;
+  }
+
+  // Subpath map: try exact match first, then pattern match
+  if (subpath in exports) {
+    const target = resolveCondition(exports[subpath]);
+    if (target) {
+      const resolved = path.resolve(packageDir, target);
+      return fs.existsSync(resolved) ? resolved : null;
+    }
+  }
+
+  // Pattern matching (keys with *)
+  for (const [pattern, value] of Object.entries(exports)) {
+    if (!pattern.includes('*')) continue;
+    const matched = matchSubpathPattern(pattern, subpath);
+    if (matched == null) continue;
+    const rawTarget = resolveCondition(value);
+    if (!rawTarget) continue;
+    const target = rawTarget.replace(/\*/g, matched);
+    const resolved = path.resolve(packageDir, target);
+    if (fs.existsSync(resolved)) return resolved;
+  }
+
+  return null;
+}
+
+/** Clear the exports cache (for testing). */
+export function clearExportsCache() {
+  _exportsCache.clear();
+}
+
+// ── Monorepo workspace resolution ───────────────────────────────────
+
+/** Cache: rootDir → Map<packageName, { dir, entry }> */
+const _workspaceCache = new Map();
+
+/** Set of resolved relative paths that came from workspace resolution. */
+const _workspaceResolvedPaths = new Set();
+
+/**
+ * Set the workspace map for a given rootDir.
+ * Called by the build pipeline after detecting workspaces.
+ * @param {string} rootDir
+ * @param {Map<string, { dir: string, entry: string|null }>} map
+ */
+export function setWorkspaces(rootDir, map) {
+  _workspaceCache.set(rootDir, map);
+  _workspaceResolvedPaths.clear();
+  _exportsCache.clear();
+}
+
+/**
+ * Get workspace packages for a rootDir. Returns empty map if not set.
+ */
+function getWorkspaces(rootDir) {
+  return _workspaceCache.get(rootDir) || new Map();
+}
+
+/**
+ * Resolve a bare specifier through monorepo workspace packages.
+ *
+ * For "@myorg/utils" → finds the workspace package dir → resolves entry point.
+ * For "@myorg/utils/sub" → finds package dir → tries exports field → filesystem probe.
+ *
+ * @returns {string|null} Absolute path to resolved file, or null.
+ */
+export function resolveViaWorkspace(specifier, rootDir) {
+  const parsed = parseBareSpecifier(specifier);
+  if (!parsed) return null;
+
+  const workspaces = getWorkspaces(rootDir);
+  if (workspaces.size === 0) return null;
+
+  const info = workspaces.get(parsed.packageName);
+  if (!info) return null;
+
+  // Root import ("@myorg/utils") — use the entry point
+  if (parsed.subpath === '.') {
+    // Try exports field first (reuses existing exports logic)
+    const exportsResult = resolveViaExports(specifier, rootDir);
+    if (exportsResult) return exportsResult;
+    // Fall back to workspace entry
+    return info.entry;
+  }
+
+  // Subpath import ("@myorg/utils/helpers") — try exports, then filesystem probe
+  const exportsResult = resolveViaExports(specifier, rootDir);
+  if (exportsResult) return exportsResult;
+
+  // Filesystem probe within the package directory
+  const subRel = parsed.subpath.slice(2); // strip "./"
+  const base = path.resolve(info.dir, subRel);
+  for (const ext of [
+    '',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '/index.ts',
+    '/index.tsx',
+    '/index.js',
+  ]) {
+    const candidate = base + ext;
+    if (fs.existsSync(candidate)) return candidate;
+  }
+
+  // Try src/ subdirectory (common monorepo convention)
+  const srcBase = path.resolve(info.dir, 'src', subRel);
+  for (const ext of [
+    '',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '/index.ts',
+    '/index.tsx',
+    '/index.js',
+  ]) {
+    const candidate = srcBase + ext;
+    if (fs.existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+/**
+ * Check if a resolved relative path was resolved via workspace detection.
+ * Used by computeConfidence to assign high confidence (0.95) to workspace imports.
+ */
+export function isWorkspaceResolved(resolvedPath) {
+  return _workspaceResolvedPaths.has(resolvedPath);
+}
+
+/** Clear workspace caches (for testing). */
+export function clearWorkspaceCache() {
+  _workspaceCache.clear();
+  _workspaceResolvedPaths.clear();
+}
+
 // ── Alias format conversion ─────────────────────────────────────────
 
 /**
@@ -60,7 +360,18 @@ function resolveImportPathJS(fromFile, importSource, rootDir, aliases) {
     const aliasResolved = resolveViaAlias(importSource, aliases, rootDir);
     if (aliasResolved) return normalizePath(path.relative(rootDir, aliasResolved));
   }
-  if (!importSource.startsWith('.')) return importSource;
+  if (!importSource.startsWith('.')) {
+    // Workspace packages take priority over node_modules
+    const wsResolved = resolveViaWorkspace(importSource, rootDir);
+    if (wsResolved) {
+      const rel = normalizePath(path.relative(rootDir, wsResolved));
+      _workspaceResolvedPaths.add(rel);
+      return rel;
+    }
+    const exportsResolved = resolveViaExports(importSource, rootDir);
+    if (exportsResolved) return normalizePath(path.relative(rootDir, exportsResolved));
+    return importSource;
+  }
   const dir = path.dirname(fromFile);
   const resolved = path.resolve(dir, importSource);
 
@@ -78,6 +389,7 @@ function resolveImportPathJS(fromFile, importSource, rootDir, aliases) {
     '.jsx',
     '.mjs',
     '.py',
+    '.pyi',
     '/index.ts',
     '/index.tsx',
     '/index.js',
@@ -96,6 +408,8 @@ function computeConfidenceJS(callerFile, targetFile, importedFrom) {
   if (!targetFile || !callerFile) return 0.3;
   if (callerFile === targetFile) return 1.0;
   if (importedFrom === targetFile) return 1.0;
+  // Workspace-resolved imports get high confidence even across package boundaries
+  if (importedFrom && _workspaceResolvedPaths.has(importedFrom)) return 0.95;
   if (path.dirname(callerFile) === path.dirname(targetFile)) return 0.7;
   const callerParent = path.dirname(path.dirname(callerFile));
   const targetParent = path.dirname(path.dirname(targetFile));