@optave/codegraph 3.1.4 → 3.2.0

package/src/{builder → domain/graph/builder}/incremental.js

@@ -6,16 +6,127 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { normalizePath } from '../constants.js';
-import { warn } from '../logger.js';
-import { parseFileIncremental } from '../parser.js';
+import { warn } from '../../../infrastructure/logger.js';
+import { normalizePath } from '../../../shared/constants.js';
+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) {
+  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);
+    }
+  }
+  return { targets, importedFrom };
+}
+
+function buildCallEdges(stmts, relPath, symbols, fileNodeRow, importedNames) {
+  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);
+
+    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 +172,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

@@ -0,0 +1,156 @@
+/**
+ * Pipeline orchestrator — runs build stages sequentially through a shared PipelineContext.
+ *
+ * This is the heart of the builder refactor (ROADMAP 3.9): the monolithic buildGraph()
+ * is decomposed into independently testable stages that communicate via PipelineContext.
+ */
+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 { info } from '../../../infrastructure/logger.js';
+import { getActiveEngine } from '../../parser.js';
+import { PipelineContext } from './context.js';
+import { loadPathAliases } from './helpers.js';
+import { buildEdges } from './stages/build-edges.js';
+import { buildStructure } from './stages/build-structure.js';
+// Pipeline stages
+import { collectFiles } from './stages/collect-files.js';
+import { detectChanges } from './stages/detect-changes.js';
+import { finalize } from './stages/finalize.js';
+import { insertNodes } from './stages/insert-nodes.js';
+import { parseFiles } from './stages/parse-files.js';
+import { resolveImports } from './stages/resolve-imports.js';
+import { runAnalyses } from './stages/run-analyses.js';
+
+// ── Setup helpers ───────────────────────────────────────────────────────
+
+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})` : ''}`);
+}
+
+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`,
+    );
+  }
+}
+
+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);
+
+  ctx.config = loadConfig(ctx.rootDir);
+  ctx.incremental =
+    ctx.opts.incremental !== false && ctx.config.build && ctx.config.build.incremental !== false;
+
+  initializeEngine(ctx);
+  checkEngineSchemaMismatch(ctx);
+  loadAliases(ctx);
+
+  ctx.timing.setupMs = performance.now() - ctx.buildStart;
+}
+
+function formatTimingResult(ctx) {
+  return {
+    phases: {
+      setupMs: +ctx.timing.setupMs.toFixed(1),
+      parseMs: +(ctx.timing.parseMs ?? 0).toFixed(1),
+      insertMs: +(ctx.timing.insertMs ?? 0).toFixed(1),
+      resolveMs: +(ctx.timing.resolveMs ?? 0).toFixed(1),
+      edgesMs: +(ctx.timing.edgesMs ?? 0).toFixed(1),
+      structureMs: +(ctx.timing.structureMs ?? 0).toFixed(1),
+      rolesMs: +(ctx.timing.rolesMs ?? 0).toFixed(1),
+      astMs: +(ctx.timing.astMs ?? 0).toFixed(1),
+      complexityMs: +(ctx.timing.complexityMs ?? 0).toFixed(1),
+      ...(ctx.timing.cfgMs != null && { cfgMs: +ctx.timing.cfgMs.toFixed(1) }),
+      ...(ctx.timing.dataflowMs != null && { dataflowMs: +ctx.timing.dataflowMs.toFixed(1) }),
+      finalizeMs: +(ctx.timing.finalizeMs ?? 0).toFixed(1),
+    },
+  };
+}
+
+// ── 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);
+}