@optave/codegraph 3.2.0 → 3.3.0

package/src/domain/analysis/module-map.js

@@ -1,7 +1,9 @@
 import path from 'node:path';
 import { openReadonlyOrFail, testFilterSQL } from '../../db/index.js';
+import { loadConfig } from '../../infrastructure/config.js';
 import { debug } from '../../infrastructure/logger.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
+import { DEAD_ROLE_PREFIX } from '../../shared/kinds.js';
 import { findCycles } from '../graph/cycles.js';
 import { LANGUAGE_REGISTRY } from '../parser.js';
 
@@ -159,7 +161,7 @@ function getEmbeddingsInfo(db) {
   return null;
 }
 
-function computeQualityMetrics(db, testFilter) {
+function computeQualityMetrics(db, testFilter, fpThreshold = FALSE_POSITIVE_CALLER_THRESHOLD) {
   const qualityTestFilter = testFilter.replace(/n\.file/g, 'file');
 
   const totalCallable = db
@@ -192,7 +194,7 @@ function computeQualityMetrics(db, testFilter) {
       HAVING caller_count > ?
       ORDER BY caller_count DESC
     `)
-    .all(FALSE_POSITIVE_CALLER_THRESHOLD);
+    .all(fpThreshold);
   const falsePositiveWarnings = fpRows
     .filter((r) =>
       FALSE_POSITIVE_NAMES.has(r.name.includes('.') ? r.name.split('.').pop() : r.name),
@@ -237,7 +239,12 @@ function countRoles(db, noTests) {
       .all();
   }
   const roles = {};
-  for (const r of roleRows) roles[r.role] = r.c;
+  let deadTotal = 0;
+  for (const r of roleRows) {
+    roles[r.role] = r.c;
+    if (r.role.startsWith(DEAD_ROLE_PREFIX)) deadTotal += r.c;
+  }
+  if (deadTotal > 0) roles.dead = deadTotal;
   return roles;
 }
 
@@ -314,6 +321,7 @@ export function statsData(customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
+    const config = opts.config || loadConfig();
     const testFilter = testFilterSQL('n.file', noTests);
 
     const testFileIds = noTests ? buildTestFileIds(db) : null;
@@ -327,7 +335,8 @@ export function statsData(customDbPath, opts = {}) {
 
     const hotspots = findHotspots(db, noTests, 5);
     const embeddings = getEmbeddingsInfo(db);
-    const quality = computeQualityMetrics(db, testFilter);
+    const fpThreshold = config.analysis?.falsePositiveCallers ?? FALSE_POSITIVE_CALLER_THRESHOLD;
+    const quality = computeQualityMetrics(db, testFilter, fpThreshold);
     const roles = countRoles(db, noTests);
     const complexity = getComplexitySummary(db, testFilter);
 

package/src/domain/analysis/roles.js

@@ -1,6 +1,7 @@
 import { openReadonlyOrFail } from '../../db/index.js';
 import { buildFileConditionSQL } from '../../db/query-builder.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
+import { DEAD_ROLE_PREFIX } from '../../shared/kinds.js';
 import { normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 
@@ -13,8 +14,13 @@ export function rolesData(customDbPath, opts = {}) {
     const params = [];
 
     if (filterRole) {
-      conditions.push('role = ?');
-      params.push(filterRole);
+      if (filterRole === DEAD_ROLE_PREFIX) {
+        conditions.push('role LIKE ?');
+        params.push(`${DEAD_ROLE_PREFIX}%`);
+      } else {
+        conditions.push('role = ?');
+        params.push(filterRole);
+      }
     }
     {
       const fc = buildFileConditionSQL(opts.file, 'file');

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

@@ -87,7 +87,7 @@ function findCaller(call, definitions, relPath, stmts) {
   return caller;
 }
 
-function resolveCallTargets(stmts, call, relPath, importedNames) {
+function resolveCallTargets(stmts, call, relPath, importedNames, typeMap) {
   const importedFrom = importedNames.get(call.name);
   let targets;
   if (importedFrom) {
@@ -99,16 +99,36 @@ function resolveCallTargets(stmts, call, relPath, importedNames) {
       targets = stmts.findNodeByName.all(call.name);
     }
   }
+  // Type-aware resolution: translate variable receiver to declared type
+  if ((!targets || targets.length === 0) && call.receiver && typeMap) {
+    const typeEntry = typeMap.get(call.receiver);
+    const typeName = typeEntry
+      ? typeof typeEntry === 'string'
+        ? typeEntry
+        : typeEntry.type
+      : null;
+    if (typeName) {
+      const qualified = `${typeName}.${call.name}`;
+      targets = stmts.findNodeByName.all(qualified);
+    }
+  }
   return { targets, importedFrom };
 }
 
 function buildCallEdges(stmts, relPath, symbols, fileNodeRow, importedNames) {
+  const typeMap = symbols.typeMap || new Map();
   let edgesAdded = 0;
   for (const call of symbols.calls) {
     if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
 
     const caller = findCaller(call, symbols.definitions, relPath, stmts) || fileNodeRow;
-    const { targets, importedFrom } = resolveCallTargets(stmts, call, relPath, importedNames);
+    const { targets, importedFrom } = resolveCallTargets(
+      stmts,
+      call,
+      relPath,
+      importedNames,
+      typeMap,
+    );
 
     for (const t of targets) {
       if (t.id !== caller.id) {

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

@@ -7,9 +7,10 @@
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { closeDb, getBuildMeta, initSchema, MIGRATIONS, openDb } from '../../../db/index.js';
-import { loadConfig } from '../../../infrastructure/config.js';
+import { detectWorkspaces, loadConfig } from '../../../infrastructure/config.js';
 import { info } from '../../../infrastructure/logger.js';
 import { getActiveEngine } from '../../parser.js';
+import { setWorkspaces } from '../resolve.js';
 import { PipelineContext } from './context.js';
 import { loadPathAliases } from './helpers.js';
 import { buildEdges } from './stages/build-edges.js';
@@ -86,6 +87,13 @@ function setupPipeline(ctx) {
   checkEngineSchemaMismatch(ctx);
   loadAliases(ctx);
 
+  // Workspace packages (monorepo)
+  const workspaces = detectWorkspaces(ctx.rootDir);
+  if (workspaces.size > 0) {
+    setWorkspaces(ctx.rootDir, workspaces);
+    info(`Detected ${workspaces.size} workspace packages`);
+  }
+
   ctx.timing.setupMs = performance.now() - ctx.buildStart;
 }
 

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