@optave/codegraph 3.1.2 → 3.1.4

package/src/builder/stages/insert-nodes.js

@@ -0,0 +1,195 @@
+/**
+ * Stage: insertNodes
+ *
+ * Batch-inserts file nodes, definitions, exports, children, and contains/parameter_of edges.
+ * Updates file hashes for incremental builds.
+ */
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { bulkNodeIdsByFile } from '../../db.js';
+import {
+  batchInsertEdges,
+  batchInsertNodes,
+  fileHash,
+  fileStat,
+  readFileSafe,
+} from '../helpers.js';
+
+/**
+ * @param {import('../context.js').PipelineContext} ctx
+ */
+export async function insertNodes(ctx) {
+  const { db, allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
+
+  // Build lookup from incremental data (pre-computed hashes + stats)
+  const precomputedData = new Map();
+  for (const item of filesToParse) {
+    if (item.relPath) {
+      precomputedData.set(item.relPath, item);
+    }
+  }
+
+  const bulkGetNodeIds = { all: (file) => bulkNodeIdsByFile(db, file) };
+
+  // Prepare hash upsert
+  let upsertHash;
+  try {
+    upsertHash = db.prepare(
+      'INSERT OR REPLACE INTO file_hashes (file, hash, mtime, size) VALUES (?, ?, ?, ?)',
+    );
+  } catch {
+    upsertHash = null;
+  }
+
+  // Populate fileSymbols before the transaction so it is a pure input
+  // to (rather than a side-effect of) the DB write — avoids partial
+  // population if the transaction rolls back.
+  for (const [relPath, symbols] of allSymbols) {
+    ctx.fileSymbols.set(relPath, symbols);
+  }
+
+  const insertAll = db.transaction(() => {
+    // Phase 1: Batch insert all file nodes + definitions + exports
+    // Row format: [name, kind, file, line, end_line, parent_id, qualified_name, scope, visibility]
+    const phase1Rows = [];
+    for (const [relPath, symbols] of allSymbols) {
+      phase1Rows.push([relPath, 'file', relPath, 0, null, null, null, null, null]);
+      for (const def of symbols.definitions) {
+        // Methods already have 'Class.method' as name — use as qualified_name.
+        // For methods, scope is the class portion; for top-level defs, scope is null.
+        const dotIdx = def.name.lastIndexOf('.');
+        const scope = dotIdx !== -1 ? def.name.slice(0, dotIdx) : null;
+        phase1Rows.push([
+          def.name,
+          def.kind,
+          relPath,
+          def.line,
+          def.endLine || null,
+          null,
+          def.name,
+          scope,
+          def.visibility || null,
+        ]);
+      }
+      for (const exp of symbols.exports) {
+        phase1Rows.push([exp.name, exp.kind, relPath, exp.line, null, null, exp.name, null, null]);
+      }
+    }
+    batchInsertNodes(db, phase1Rows);
+
+    // Phase 1b: Mark exported symbols
+    const markExported = db.prepare(
+      'UPDATE nodes SET exported = 1 WHERE name = ? AND kind = ? AND file = ? AND line = ?',
+    );
+    for (const [relPath, symbols] of allSymbols) {
+      for (const exp of symbols.exports) {
+        markExported.run(exp.name, exp.kind, relPath, exp.line);
+      }
+    }
+
+    // Phase 3: Batch insert children (needs parent IDs from Phase 2)
+    const childRows = [];
+    for (const [relPath, symbols] of allSymbols) {
+      const nodeIdMap = new Map();
+      for (const row of bulkGetNodeIds.all(relPath)) {
+        nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+      }
+      for (const def of symbols.definitions) {
+        if (!def.children?.length) continue;
+        const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
+        if (!defId) continue;
+        for (const child of def.children) {
+          const qualifiedName = `${def.name}.${child.name}`;
+          childRows.push([
+            child.name,
+            child.kind,
+            relPath,
+            child.line,
+            child.endLine || null,
+            defId,
+            qualifiedName,
+            def.name,
+            child.visibility || null,
+          ]);
+        }
+      }
+    }
+    batchInsertNodes(db, childRows);
+
+    // Phase 5: Batch insert contains/parameter_of edges
+    const edgeRows = [];
+    for (const [relPath, symbols] of allSymbols) {
+      const nodeIdMap = new Map();
+      for (const row of bulkGetNodeIds.all(relPath)) {
+        nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+      }
+      const fileId = nodeIdMap.get(`${relPath}|file|0`);
+      for (const def of symbols.definitions) {
+        const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
+        if (fileId && defId) {
+          edgeRows.push([fileId, defId, 'contains', 1.0, 0]);
+        }
+        if (def.children?.length && defId) {
+          for (const child of def.children) {
+            const childId = nodeIdMap.get(`${child.name}|${child.kind}|${child.line}`);
+            if (childId) {
+              edgeRows.push([defId, childId, 'contains', 1.0, 0]);
+              if (child.kind === 'parameter') {
+                edgeRows.push([childId, defId, 'parameter_of', 1.0, 0]);
+              }
+            }
+          }
+        }
+      }
+
+      // Update file hash — skip reverse-dep files (unchanged)
+      if (upsertHash) {
+        const precomputed = precomputedData.get(relPath);
+        if (precomputed?._reverseDepOnly) {
+          // no-op: file unchanged, hash already correct
+        } else if (precomputed?.hash) {
+          const stat = precomputed.stat || fileStat(path.join(rootDir, relPath));
+          const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
+          const size = stat ? stat.size : 0;
+          upsertHash.run(relPath, precomputed.hash, mtime, size);
+        } else {
+          const absPath = path.join(rootDir, relPath);
+          let code;
+          try {
+            code = readFileSafe(absPath);
+          } catch {
+            code = null;
+          }
+          if (code !== null) {
+            const stat = fileStat(absPath);
+            const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
+            const size = stat ? stat.size : 0;
+            upsertHash.run(relPath, fileHash(code), mtime, size);
+          }
+        }
+      }
+    }
+    batchInsertEdges(db, edgeRows);
+
+    // Also update metadata-only entries (self-heal mtime/size without re-parse)
+    if (upsertHash) {
+      for (const item of metadataUpdates) {
+        const mtime = item.stat ? Math.floor(item.stat.mtimeMs) : 0;
+        const size = item.stat ? item.stat.size : 0;
+        upsertHash.run(item.relPath, item.hash, mtime, size);
+      }
+    }
+  });
+
+  const t0 = performance.now();
+  insertAll();
+  ctx.timing.insertMs = performance.now() - t0;
+
+  // Clean up removed file hashes
+  if (upsertHash && removed.length > 0) {
+    const deleteHash = db.prepare('DELETE FROM file_hashes WHERE file = ?');
+    for (const relPath of removed) {
+      deleteHash.run(relPath);
+    }
+  }
+}

package/src/builder/stages/parse-files.js

@@ -0,0 +1,28 @@
+/**
+ * Stage: parseFiles
+ *
+ * Parses source files via parseFilesAuto (native or WASM engine).
+ * Populates ctx.allSymbols, ctx.fileSymbols, ctx.filesToParse.
+ */
+import { performance } from 'node:perf_hooks';
+import { info } from '../../logger.js';
+import { parseFilesAuto } from '../../parser.js';
+
+/**
+ * @param {import('../context.js').PipelineContext} ctx
+ */
+export async function parseFiles(ctx) {
+  const { allFiles, parseChanges, isFullBuild, engineOpts, rootDir } = ctx;
+
+  ctx.filesToParse = isFullBuild ? allFiles.map((f) => ({ file: f })) : parseChanges;
+  ctx.fileSymbols = new Map();
+
+  const filePaths = ctx.filesToParse.map((item) => item.file);
+  const t0 = performance.now();
+  ctx.allSymbols = await parseFilesAuto(filePaths, rootDir, engineOpts);
+  ctx.timing.parseMs = performance.now() - t0;
+
+  const parsed = ctx.allSymbols.size;
+  const skipped = ctx.filesToParse.length - parsed;
+  info(`Parsed ${parsed} files (${skipped} skipped)`);
+}

package/src/builder/stages/resolve-imports.js

@@ -0,0 +1,143 @@
+/**
+ * Stage: resolveImports
+ *
+ * Batch import resolution + barrel/re-export map construction.
+ * For incremental builds, loads unchanged barrel files for resolution.
+ */
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { parseFilesAuto } from '../../parser.js';
+import { resolveImportPath, resolveImportsBatch } from '../../resolve.js';
+
+/**
+ * @param {import('../context.js').PipelineContext} ctx
+ */
+export async function resolveImports(ctx) {
+  const { db, fileSymbols, rootDir, aliases, allFiles, isFullBuild, engineOpts } = ctx;
+
+  // Collect all (fromFile, importSource) pairs and resolve in one native call
+  const t0 = performance.now();
+  const batchInputs = [];
+  for (const [relPath, symbols] of fileSymbols) {
+    const absFile = path.join(rootDir, relPath);
+    for (const imp of symbols.imports) {
+      batchInputs.push({ fromFile: absFile, importSource: imp.source });
+    }
+  }
+  ctx.batchResolved = resolveImportsBatch(batchInputs, rootDir, aliases, allFiles);
+  ctx.timing.resolveMs = performance.now() - t0;
+
+  // Build re-export map for barrel resolution
+  ctx.reexportMap = new Map();
+  for (const [relPath, symbols] of fileSymbols) {
+    const reexports = symbols.imports.filter((imp) => imp.reexport);
+    if (reexports.length > 0) {
+      ctx.reexportMap.set(
+        relPath,
+        reexports.map((imp) => ({
+          source: getResolved(ctx, path.join(rootDir, relPath), imp.source),
+          names: imp.names,
+          wildcardReexport: imp.wildcardReexport || false,
+        })),
+      );
+    }
+  }
+
+  // For incremental builds, load unchanged barrel files into reexportMap
+  ctx.barrelOnlyFiles = new Set();
+  if (!isFullBuild) {
+    const barrelCandidates = db
+      .prepare(
+        `SELECT DISTINCT n1.file FROM edges e
+         JOIN nodes n1 ON e.source_id = n1.id
+         WHERE e.kind = 'reexports' AND n1.kind = 'file'`,
+      )
+      .all();
+    for (const { file: relPath } of barrelCandidates) {
+      if (fileSymbols.has(relPath)) continue;
+      const absPath = path.join(rootDir, relPath);
+      try {
+        const symbols = await parseFilesAuto([absPath], rootDir, engineOpts);
+        const fileSym = symbols.get(relPath);
+        if (fileSym) {
+          fileSymbols.set(relPath, fileSym);
+          ctx.barrelOnlyFiles.add(relPath);
+          const reexports = fileSym.imports.filter((imp) => imp.reexport);
+          if (reexports.length > 0) {
+            ctx.reexportMap.set(
+              relPath,
+              reexports.map((imp) => ({
+                source: getResolved(ctx, absPath, imp.source),
+                names: imp.names,
+                wildcardReexport: imp.wildcardReexport || false,
+              })),
+            );
+          }
+        }
+      } catch {
+        /* skip if unreadable */
+      }
+    }
+  }
+}
+
+/**
+ * Resolve an import source, preferring batch results.
+ * Exported so other stages (build-edges) can reuse it.
+ */
+export function getResolved(ctx, absFile, importSource) {
+  if (ctx.batchResolved) {
+    const key = `${absFile}|${importSource}`;
+    const hit = ctx.batchResolved.get(key);
+    if (hit !== undefined) return hit;
+  }
+  return resolveImportPath(absFile, importSource, ctx.rootDir, ctx.aliases);
+}
+
+/**
+ * Check if a file is a barrel (re-export hub).
+ */
+export function isBarrelFile(ctx, relPath) {
+  const symbols = ctx.fileSymbols.get(relPath);
+  if (!symbols) return false;
+  const reexports = symbols.imports.filter((imp) => imp.reexport);
+  if (reexports.length === 0) return false;
+  const ownDefs = symbols.definitions.length;
+  return reexports.length >= ownDefs;
+}
+
+/**
+ * Resolve a symbol through barrel re-export chains.
+ */
+export function resolveBarrelExport(ctx, barrelPath, symbolName, visited = new Set()) {
+  if (visited.has(barrelPath)) return null;
+  visited.add(barrelPath);
+  const reexports = ctx.reexportMap.get(barrelPath);
+  if (!reexports) return null;
+
+  for (const re of reexports) {
+    if (re.names.length > 0 && !re.wildcardReexport) {
+      if (re.names.includes(symbolName)) {
+        const targetSymbols = ctx.fileSymbols.get(re.source);
+        if (targetSymbols) {
+          const hasDef = targetSymbols.definitions.some((d) => d.name === symbolName);
+          if (hasDef) return re.source;
+          const deeper = resolveBarrelExport(ctx, re.source, symbolName, visited);
+          if (deeper) return deeper;
+        }
+        return re.source;
+      }
+      continue;
+    }
+    if (re.wildcardReexport || re.names.length === 0) {
+      const targetSymbols = ctx.fileSymbols.get(re.source);
+      if (targetSymbols) {
+        const hasDef = targetSymbols.definitions.some((d) => d.name === symbolName);
+        if (hasDef) return re.source;
+        const deeper = resolveBarrelExport(ctx, re.source, symbolName, visited);
+        if (deeper) return deeper;
+      }
+    }
+  }
+  return null;
+}

package/src/builder/stages/run-analyses.js

@@ -0,0 +1,44 @@
+/**
+ * Stage: runAnalyses
+ *
+ * Dispatches to the unified AST analysis engine (AST nodes, complexity, CFG, dataflow).
+ * Filters out reverse-dep files for incremental builds.
+ */
+import { debug, warn } from '../../logger.js';
+
+/**
+ * @param {import('../context.js').PipelineContext} ctx
+ */
+export async function runAnalyses(ctx) {
+  const { db, allSymbols, rootDir, opts, engineOpts, isFullBuild, filesToParse } = ctx;
+
+  // For incremental builds, exclude reverse-dep-only files
+  let astComplexitySymbols = allSymbols;
+  if (!isFullBuild) {
+    const reverseDepFiles = new Set(
+      filesToParse.filter((item) => item._reverseDepOnly).map((item) => item.relPath),
+    );
+    if (reverseDepFiles.size > 0) {
+      astComplexitySymbols = new Map();
+      for (const [relPath, symbols] of allSymbols) {
+        if (!reverseDepFiles.has(relPath)) {
+          astComplexitySymbols.set(relPath, symbols);
+        }
+      }
+      debug(
+        `AST/complexity/CFG/dataflow: processing ${astComplexitySymbols.size} changed files (skipping ${reverseDepFiles.size} reverse-deps)`,
+      );
+    }
+  }
+
+  const { runAnalyses: runAnalysesFn } = await import('../../ast-analysis/engine.js');
+  try {
+    const analysisTiming = await runAnalysesFn(db, astComplexitySymbols, rootDir, opts, engineOpts);
+    ctx.timing.astMs = analysisTiming.astMs;
+    ctx.timing.complexityMs = analysisTiming.complexityMs;
+    ctx.timing.cfgMs = analysisTiming.cfgMs;
+    ctx.timing.dataflowMs = analysisTiming.dataflowMs;
+  } catch (err) {
+    warn(`Analysis engine failed (AST/complexity/CFG/dataflow may be incomplete): ${err.message}`);
+  }
+}