@optave/codegraph 3.1.3 → 3.1.5

package/src/domain/graph/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/index.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/domain/graph/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 '../../../../infrastructure/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/domain/graph/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/domain/graph/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 '../../../../infrastructure/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}`);
+  }
+}

package/src/domain/graph/builder.js

@@ -0,0 +1,11 @@
+// Barrel re-export — keeps all existing `import { ... } from './builder.js'` working.
+// See src/builder/ for the pipeline implementation (ROADMAP 3.9).
+
+export {
+  collectFiles,
+  loadPathAliases,
+  purgeFilesFromGraph,
+  readFileSafe,
+} from './builder/helpers.js';
+export { buildGraph } from './builder/pipeline.js';
+export { resolveImportPath } from './resolve.js';

package/src/{change-journal.js → domain/graph/change-journal.js}

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { debug, warn } from './logger.js';
+import { debug, warn } from '../../infrastructure/logger.js';
 
 export const CHANGE_EVENTS_FILENAME = 'change-events.ndjson';
 export const DEFAULT_MAX_BYTES = 1024 * 1024; // 1 MB

package/src/domain/graph/cycles.js

@@ -0,0 +1,82 @@
+import { tarjan } from '../../graph/algorithms/tarjan.js';
+import { buildDependencyGraph } from '../../graph/builders/dependency.js';
+import { CodeGraph } from '../../graph/model.js';
+import { loadNative } from '../../infrastructure/native.js';
+
+/**
+ * Detect circular dependencies in the codebase using Tarjan's SCC algorithm.
+ * Dispatches to native Rust implementation when available, falls back to JS.
+ * @param {object} db - Open SQLite database
+ * @param {object} opts - { fileLevel: true, noTests: false }
+ * @returns {string[][]} Array of cycles, each cycle is an array of file paths
+ */
+export function findCycles(db, opts = {}) {
+  const fileLevel = opts.fileLevel !== false;
+  const noTests = opts.noTests || false;
+
+  const graph = buildDependencyGraph(db, { fileLevel, noTests });
+
+  // Build a label map: DB string ID → human-readable key
+  // File-level: file path; Function-level: name|file composite (for native Rust compat)
+  const idToLabel = new Map();
+  for (const [id, attrs] of graph.nodes()) {
+    if (fileLevel) {
+      idToLabel.set(id, attrs.file);
+    } else {
+      idToLabel.set(id, `${attrs.label}|${attrs.file}`);
+    }
+  }
+
+  // Build edge array with human-readable keys (for native engine)
+  const edges = graph.toEdgeArray().map((e) => ({
+    source: idToLabel.get(e.source),
+    target: idToLabel.get(e.target),
+  }));
+
+  // Try native Rust implementation
+  const native = loadNative();
+  if (native) {
+    return native.detectCycles(edges);
+  }
+
+  // Fallback: JS Tarjan via graph subsystem
+  // Re-key graph with human-readable labels for consistent output
+  const labelGraph = new CodeGraph();
+  for (const { source, target } of edges) {
+    labelGraph.addEdge(source, target);
+  }
+  return tarjan(labelGraph);
+}
+
+/**
+ * Pure-JS Tarjan's SCC implementation.
+ * Kept for backward compatibility — accepts raw {source, target}[] edges.
+ */
+export function findCyclesJS(edges) {
+  const graph = new CodeGraph();
+  for (const { source, target } of edges) {
+    graph.addEdge(source, target);
+  }
+  return tarjan(graph);
+}
+
+/**
+ * Format cycles for human-readable output.
+ */
+export function formatCycles(cycles) {
+  if (cycles.length === 0) {
+    return 'No circular dependencies detected.';
+  }
+
+  const lines = [`Found ${cycles.length} circular dependency cycle(s):\n`];
+  for (let i = 0; i < cycles.length; i++) {
+    const cycle = cycles[i];
+    lines.push(`  Cycle ${i + 1} (${cycle.length} files):`);
+    for (const file of cycle) {
+      lines.push(`    -> ${file}`);
+    }
+    lines.push(`    -> ${cycle[0]} (back to start)`);
+    lines.push('');
+  }
+  return lines.join('\n');
+}

package/src/{journal.js → domain/graph/journal.js}

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { debug, warn } from './logger.js';
+import { debug, warn } from '../../infrastructure/logger.js';
 
 export const JOURNAL_FILENAME = 'changes.journal';
 const HEADER_PREFIX = '# codegraph-journal v1 ';

package/src/{resolve.js → domain/graph/resolve.js}

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { normalizePath } from './constants.js';
-import { loadNative } from './native.js';
+import { loadNative } from '../../infrastructure/native.js';
+import { normalizePath } from '../../shared/constants.js';
 
 // ── Alias format conversion ─────────────────────────────────────────
 
@@ -178,4 +178,4 @@ export function resolveImportsBatch(inputs, rootDir, aliases, knownFiles) {
 
 // ── Exported for testing ────────────────────────────────────────────
 
-export { resolveImportPathJS, computeConfidenceJS };
+export { computeConfidenceJS, resolveImportPathJS };