@optave/codegraph 3.1.5 → 3.3.0

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

@@ -12,10 +12,141 @@ import { parseFileIncremental } from '../../parser.js';
 import { computeConfidence, resolveImportPath } from '../resolve.js';
 import { BUILTIN_RECEIVERS, readFileSafe } from './helpers.js';
 
+// ── Node insertion ──────────────────────────────────────────────────────
+
+function insertFileNodes(stmts, relPath, symbols) {
+  stmts.insertNode.run(relPath, 'file', relPath, 0, null);
+  for (const def of symbols.definitions) {
+    stmts.insertNode.run(def.name, def.kind, relPath, def.line, def.endLine || null);
+  }
+  for (const exp of symbols.exports) {
+    stmts.insertNode.run(exp.name, exp.kind, relPath, exp.line, null);
+  }
+}
+
+// ── Import edge building ────────────────────────────────────────────────
+
+function buildImportEdges(stmts, relPath, symbols, rootDir, fileNodeId, aliases) {
+  let edgesAdded = 0;
+  for (const imp of symbols.imports) {
+    const resolvedPath = resolveImportPath(
+      path.join(rootDir, relPath),
+      imp.source,
+      rootDir,
+      aliases,
+    );
+    const targetRow = stmts.getNodeId.get(resolvedPath, 'file', resolvedPath, 0);
+    if (targetRow) {
+      const edgeKind = imp.reexport ? 'reexports' : imp.typeOnly ? 'imports-type' : 'imports';
+      stmts.insertEdge.run(fileNodeId, targetRow.id, edgeKind, 1.0, 0);
+      edgesAdded++;
+    }
+  }
+  return edgesAdded;
+}
+
+function buildImportedNamesMap(symbols, rootDir, relPath, aliases) {
+  const importedNames = new Map();
+  for (const imp of symbols.imports) {
+    const resolvedPath = resolveImportPath(
+      path.join(rootDir, relPath),
+      imp.source,
+      rootDir,
+      aliases,
+    );
+    for (const name of imp.names) {
+      importedNames.set(name.replace(/^\*\s+as\s+/, ''), resolvedPath);
+    }
+  }
+  return importedNames;
+}
+
+// ── Call edge building ──────────────────────────────────────────────────
+
+function findCaller(call, definitions, relPath, stmts) {
+  let caller = null;
+  let callerSpan = Infinity;
+  for (const def of definitions) {
+    if (def.line <= call.line) {
+      const end = def.endLine || Infinity;
+      if (call.line <= end) {
+        const span = end - def.line;
+        if (span < callerSpan) {
+          const row = stmts.getNodeId.get(def.name, def.kind, relPath, def.line);
+          if (row) {
+            caller = row;
+            callerSpan = span;
+          }
+        }
+      } else if (!caller) {
+        const row = stmts.getNodeId.get(def.name, def.kind, relPath, def.line);
+        if (row) caller = row;
+      }
+    }
+  }
+  return caller;
+}
+
+function resolveCallTargets(stmts, call, relPath, importedNames, typeMap) {
+  const importedFrom = importedNames.get(call.name);
+  let targets;
+  if (importedFrom) {
+    targets = stmts.findNodeInFile.all(call.name, importedFrom);
+  }
+  if (!targets || targets.length === 0) {
+    targets = stmts.findNodeInFile.all(call.name, relPath);
+    if (targets.length === 0) {
+      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,
+      typeMap,
+    );
+
+    for (const t of targets) {
+      if (t.id !== caller.id) {
+        const confidence = computeConfidence(relPath, t.file, importedFrom ?? null);
+        stmts.insertEdge.run(caller.id, t.id, 'calls', confidence, call.dynamic ? 1 : 0);
+        edgesAdded++;
+      }
+    }
+  }
+  return edgesAdded;
+}
+
+// ── Main entry point ────────────────────────────────────────────────────
+
 /**
  * Parse a single file and update the database incrementally.
  *
- * @param {import('better-sqlite3').Database} db
+ * @param {import('better-sqlite3').Database} _db
  * @param {string} rootDir - Absolute root directory
  * @param {string} filePath - Absolute file path
  * @param {object} stmts - Prepared DB statements
@@ -61,105 +192,20 @@ export async function rebuildFile(_db, rootDir, filePath, stmts, engineOpts, cac
   const symbols = await parseFileIncremental(cache, filePath, code, engineOpts);
   if (!symbols) return null;
 
-  // Insert nodes
-  stmts.insertNode.run(relPath, 'file', relPath, 0, null);
-  for (const def of symbols.definitions) {
-    stmts.insertNode.run(def.name, def.kind, relPath, def.line, def.endLine || null);
-  }
-  for (const exp of symbols.exports) {
-    stmts.insertNode.run(exp.name, exp.kind, relPath, exp.line, null);
-  }
+  insertFileNodes(stmts, relPath, symbols);
 
   const newNodes = stmts.countNodes.get(relPath)?.c || 0;
   const newSymbols = diffSymbols ? stmts.listSymbols.all(relPath) : [];
 
-  let edgesAdded = 0;
   const fileNodeRow = stmts.getNodeId.get(relPath, 'file', relPath, 0);
   if (!fileNodeRow)
     return { file: relPath, nodesAdded: newNodes, nodesRemoved: oldNodes, edgesAdded: 0 };
-  const fileNodeId = fileNodeRow.id;
 
-  // Load aliases for import resolution
   const aliases = { baseUrl: null, paths: {} };
 
-  // Import edges
-  for (const imp of symbols.imports) {
-    const resolvedPath = resolveImportPath(
-      path.join(rootDir, relPath),
-      imp.source,
-      rootDir,
-      aliases,
-    );
-    const targetRow = stmts.getNodeId.get(resolvedPath, 'file', resolvedPath, 0);
-    if (targetRow) {
-      const edgeKind = imp.reexport ? 'reexports' : imp.typeOnly ? 'imports-type' : 'imports';
-      stmts.insertEdge.run(fileNodeId, targetRow.id, edgeKind, 1.0, 0);
-      edgesAdded++;
-    }
-  }
-
-  // Build import name → resolved file mapping
-  const importedNames = new Map();
-  for (const imp of symbols.imports) {
-    const resolvedPath = resolveImportPath(
-      path.join(rootDir, relPath),
-      imp.source,
-      rootDir,
-      aliases,
-    );
-    for (const name of imp.names) {
-      importedNames.set(name.replace(/^\*\s+as\s+/, ''), resolvedPath);
-    }
-  }
-
-  // Call edges
-  for (const call of symbols.calls) {
-    if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
-
-    let caller = null;
-    let callerSpan = Infinity;
-    for (const def of symbols.definitions) {
-      if (def.line <= call.line) {
-        const end = def.endLine || Infinity;
-        if (call.line <= end) {
-          const span = end - def.line;
-          if (span < callerSpan) {
-            const row = stmts.getNodeId.get(def.name, def.kind, relPath, def.line);
-            if (row) {
-              caller = row;
-              callerSpan = span;
-            }
-          }
-        } else if (!caller) {
-          const row = stmts.getNodeId.get(def.name, def.kind, relPath, def.line);
-          if (row) caller = row;
-        }
-      }
-    }
-    if (!caller) caller = fileNodeRow;
-
-    const importedFrom = importedNames.get(call.name);
-    let targets;
-    if (importedFrom) {
-      targets = stmts.findNodeInFile.all(call.name, importedFrom);
-    }
-    if (!targets || targets.length === 0) {
-      targets = stmts.findNodeInFile.all(call.name, relPath);
-      if (targets.length === 0) {
-        targets = stmts.findNodeByName.all(call.name);
-      }
-    }
-
-    for (const t of targets) {
-      if (t.id !== caller.id) {
-        const confidence = importedFrom
-          ? computeConfidence(relPath, t.file, importedFrom)
-          : computeConfidence(relPath, t.file, null);
-        stmts.insertEdge.run(caller.id, t.id, 'calls', confidence, call.dynamic ? 1 : 0);
-        edgesAdded++;
-      }
-    }
-  }
+  let edgesAdded = buildImportEdges(stmts, relPath, symbols, rootDir, fileNodeRow.id, aliases);
+  const importedNames = buildImportedNamesMap(symbols, rootDir, relPath, aliases);
+  edgesAdded += buildCallEdges(stmts, relPath, symbols, fileNodeRow, importedNames);
 
   const symbolDiff = diffSymbols ? diffSymbols(oldSymbols, newSymbols) : null;
   const event = oldNodes === 0 ? 'added' : 'modified';

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';
@@ -23,94 +24,80 @@ import { parseFiles } from './stages/parse-files.js';
 import { resolveImports } from './stages/resolve-imports.js';
 import { runAnalyses } from './stages/run-analyses.js';
 
-/**
- * Build the dependency graph for a codebase.
- *
- * Signature and return value are identical to the original monolithic buildGraph().
- *
- * @param {string} rootDir - Root directory to scan
- * @param {object} [opts] - Build options
- * @returns {Promise<{ phases: object } | undefined>}
- */
-export async function buildGraph(rootDir, opts = {}) {
-  const ctx = new PipelineContext();
-  ctx.buildStart = performance.now();
-  ctx.opts = opts;
+// ── Setup helpers ───────────────────────────────────────────────────────
 
-  // ── Setup (creates DB, loads config, selects engine) ──────────────
-  ctx.rootDir = path.resolve(rootDir);
-  ctx.dbPath = path.join(ctx.rootDir, '.codegraph', 'graph.db');
-  ctx.db = openDb(ctx.dbPath);
-  try {
-    initSchema(ctx.db);
-
-    ctx.config = loadConfig(ctx.rootDir);
-    ctx.incremental =
-      opts.incremental !== false && ctx.config.build && ctx.config.build.incremental !== false;
-
-    ctx.engineOpts = {
-      engine: opts.engine || 'auto',
-      dataflow: opts.dataflow !== false,
-      ast: opts.ast !== false,
-    };
-    const { name: engineName, version: engineVersion } = getActiveEngine(ctx.engineOpts);
-    ctx.engineName = engineName;
-    ctx.engineVersion = engineVersion;
-    info(`Using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
-
-    // Engine/schema mismatch detection
-    ctx.schemaVersion = MIGRATIONS[MIGRATIONS.length - 1].version;
-    ctx.forceFullRebuild = false;
-    if (ctx.incremental) {
-      const prevEngine = getBuildMeta(ctx.db, 'engine');
-      if (prevEngine && prevEngine !== engineName) {
-        info(`Engine changed (${prevEngine} → ${engineName}), promoting to full rebuild.`);
-        ctx.forceFullRebuild = true;
-      }
-      const prevSchema = getBuildMeta(ctx.db, 'schema_version');
-      if (prevSchema && Number(prevSchema) !== ctx.schemaVersion) {
-        info(
-          `Schema version changed (${prevSchema} → ${ctx.schemaVersion}), promoting to full rebuild.`,
-        );
-        ctx.forceFullRebuild = true;
-      }
-    }
+function initializeEngine(ctx) {
+  ctx.engineOpts = {
+    engine: ctx.opts.engine || 'auto',
+    dataflow: ctx.opts.dataflow !== false,
+    ast: ctx.opts.ast !== false,
+  };
+  const { name: engineName, version: engineVersion } = getActiveEngine(ctx.engineOpts);
+  ctx.engineName = engineName;
+  ctx.engineVersion = engineVersion;
+  info(`Using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
+}
 
-    // Path aliases
-    ctx.aliases = loadPathAliases(ctx.rootDir);
-    if (ctx.config.aliases) {
-      for (const [key, value] of Object.entries(ctx.config.aliases)) {
-        const pattern = key.endsWith('/') ? `${key}*` : key;
-        const target = path.resolve(ctx.rootDir, value);
-        ctx.aliases.paths[pattern] = [target.endsWith('/') ? `${target}*` : `${target}/*`];
-      }
-    }
-    if (ctx.aliases.baseUrl || Object.keys(ctx.aliases.paths).length > 0) {
-      info(
-        `Loaded path aliases: baseUrl=${ctx.aliases.baseUrl || 'none'}, ${Object.keys(ctx.aliases.paths).length} path mappings`,
-      );
+function checkEngineSchemaMismatch(ctx) {
+  ctx.schemaVersion = MIGRATIONS[MIGRATIONS.length - 1].version;
+  ctx.forceFullRebuild = false;
+  if (!ctx.incremental) return;
+
+  const prevEngine = getBuildMeta(ctx.db, 'engine');
+  if (prevEngine && prevEngine !== ctx.engineName) {
+    info(`Engine changed (${prevEngine} → ${ctx.engineName}), promoting to full rebuild.`);
+    ctx.forceFullRebuild = true;
+  }
+  const prevSchema = getBuildMeta(ctx.db, 'schema_version');
+  if (prevSchema && Number(prevSchema) !== ctx.schemaVersion) {
+    info(
+      `Schema version changed (${prevSchema} → ${ctx.schemaVersion}), promoting to full rebuild.`,
+    );
+    ctx.forceFullRebuild = true;
+  }
+}
+
+function loadAliases(ctx) {
+  ctx.aliases = loadPathAliases(ctx.rootDir);
+  if (ctx.config.aliases) {
+    for (const [key, value] of Object.entries(ctx.config.aliases)) {
+      const pattern = key.endsWith('/') ? `${key}*` : key;
+      const target = path.resolve(ctx.rootDir, value);
+      ctx.aliases.paths[pattern] = [target.endsWith('/') ? `${target}*` : `${target}/*`];
     }
+  }
+  if (ctx.aliases.baseUrl || Object.keys(ctx.aliases.paths).length > 0) {
+    info(
+      `Loaded path aliases: baseUrl=${ctx.aliases.baseUrl || 'none'}, ${Object.keys(ctx.aliases.paths).length} path mappings`,
+    );
+  }
+}
 
-    ctx.timing.setupMs = performance.now() - ctx.buildStart;
+function setupPipeline(ctx) {
+  ctx.rootDir = path.resolve(ctx.rootDir);
+  ctx.dbPath = path.join(ctx.rootDir, '.codegraph', 'graph.db');
+  ctx.db = openDb(ctx.dbPath);
+  initSchema(ctx.db);
 
-    // ── Pipeline stages ─────────────────────────────────────────────
-    await collectFiles(ctx);
-    await detectChanges(ctx);
+  ctx.config = loadConfig(ctx.rootDir);
+  ctx.incremental =
+    ctx.opts.incremental !== false && ctx.config.build && ctx.config.build.incremental !== false;
 
-    if (ctx.earlyExit) return;
+  initializeEngine(ctx);
+  checkEngineSchemaMismatch(ctx);
+  loadAliases(ctx);
 
-    await parseFiles(ctx);
-    await insertNodes(ctx);
-    await resolveImports(ctx);
-    await buildEdges(ctx);
-    await buildStructure(ctx);
-    await runAnalyses(ctx);
-    await finalize(ctx);
-  } catch (err) {
-    if (!ctx.earlyExit) closeDb(ctx.db);
-    throw err;
+  // 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;
+}
+
+function formatTimingResult(ctx) {
   return {
     phases: {
       setupMs: +ctx.timing.setupMs.toFixed(1),
@@ -128,3 +115,50 @@ export async function buildGraph(rootDir, opts = {}) {
     },
   };
 }
+
+// ── Pipeline stages execution ───────────────────────────────────────────
+
+async function runPipelineStages(ctx) {
+  await collectFiles(ctx);
+  await detectChanges(ctx);
+
+  if (ctx.earlyExit) return;
+
+  await parseFiles(ctx);
+  await insertNodes(ctx);
+  await resolveImports(ctx);
+  await buildEdges(ctx);
+  await buildStructure(ctx);
+  await runAnalyses(ctx);
+  await finalize(ctx);
+}
+
+// ── Main entry point ────────────────────────────────────────────────────
+
+/**
+ * Build the dependency graph for a codebase.
+ *
+ * Signature and return value are identical to the original monolithic buildGraph().
+ *
+ * @param {string} rootDir - Root directory to scan
+ * @param {object} [opts] - Build options
+ * @returns {Promise<{ phases: object } | undefined>}
+ */
+export async function buildGraph(rootDir, opts = {}) {
+  const ctx = new PipelineContext();
+  ctx.buildStart = performance.now();
+  ctx.opts = opts;
+  ctx.rootDir = rootDir;
+
+  try {
+    setupPipeline(ctx);
+    await runPipelineStages(ctx);
+  } catch (err) {
+    if (!ctx.earlyExit) closeDb(ctx.db);
+    throw err;
+  }
+
+  if (ctx.earlyExit) return;
+
+  return formatTimingResult(ctx);
+}