@optave/codegraph 3.3.0 → 3.4.0

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

@@ -1,85 +0,0 @@
-/**
- * PipelineContext — shared mutable state threaded through all build stages.
- *
- * Each stage reads what it needs and writes what it produces.
- * This replaces the closure-captured locals in the old monolithic buildGraph().
- */
-export class PipelineContext {
-  // ── Inputs (set during setup) ──────────────────────────────────────
-  /** @type {string} Absolute root directory */
-  rootDir;
-  /** @type {import('better-sqlite3').Database} */
-  db;
-  /** @type {string} Absolute path to the database file */
-  dbPath;
-  /** @type {object} From loadConfig() */
-  config;
-  /** @type {object} Original buildGraph opts */
-  opts;
-  /** @type {{ engine: string, dataflow: boolean, ast: boolean }} */
-  engineOpts;
-  /** @type {string} 'native' | 'wasm' */
-  engineName;
-  /** @type {string|null} */
-  engineVersion;
-  /** @type {{ baseUrl: string|null, paths: object }} */
-  aliases;
-  /** @type {boolean} Whether incremental mode is enabled */
-  incremental;
-  /** @type {boolean} Force full rebuild (engine/schema mismatch) */
-  forceFullRebuild = false;
-  /** @type {number} Current schema version */
-  schemaVersion;
-
-  // ── File collection (set by collectFiles stage) ────────────────────
-  /** @type {string[]} Absolute file paths */
-  allFiles;
-  /** @type {Set<string>} Absolute directory paths */
-  discoveredDirs;
-
-  // ── Change detection (set by detectChanges stage) ──────────────────
-  /** @type {boolean} */
-  isFullBuild;
-  /** @type {Array<{ file: string, relPath?: string, content?: string, hash?: string, stat?: object, _reverseDepOnly?: boolean }>} */
-  parseChanges;
-  /** @type {Array<{ relPath: string, hash: string, stat: object }>} Metadata-only self-heal updates */
-  metadataUpdates;
-  /** @type {string[]} Relative paths of deleted files */
-  removed;
-  /** @type {boolean} True when no changes detected — skip remaining stages */
-  earlyExit = false;
-
-  // ── Parsing (set by parseFiles stage) ──────────────────────────────
-  /** @type {Map<string, object>} relPath → symbols from parseFilesAuto */
-  allSymbols;
-  /** @type {Map<string, object>} relPath → symbols (includes incrementally loaded) */
-  fileSymbols;
-  /** @type {Array<{ file: string, relPath?: string }>} Files to parse this build */
-  filesToParse;
-
-  // ── Import resolution (set by resolveImports stage) ────────────────
-  /** @type {Map<string, string>|null} "absFile|source" → resolved path */
-  batchResolved;
-  /** @type {Map<string, Array>} relPath → re-export descriptors */
-  reexportMap;
-  /** @type {Set<string>} Files loaded only for barrel resolution (don't rebuild edges) */
-  barrelOnlyFiles;
-
-  // ── Node lookup (set by insertNodes / buildEdges stages) ───────────
-  /** @type {Map<string, Array>} name → node rows */
-  nodesByName;
-  /** @type {Map<string, Array>} "name|file" → node rows */
-  nodesByNameAndFile;
-
-  // ── Misc state ─────────────────────────────────────────────────────
-  /** @type {boolean} Whether embeddings table exists */
-  hasEmbeddings = false;
-  /** @type {Map<string, number>} relPath → line count */
-  lineCountMap;
-
-  // ── Phase timing ───────────────────────────────────────────────────
-  timing = {};
-
-  /** @type {number} performance.now() at build start */
-  buildStart;
-}

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

@@ -1,218 +0,0 @@
-/**
- * Builder helper functions — shared utilities used across pipeline stages.
- *
- * Extracted from the monolithic builder.js so stages can import individually.
- */
-import { createHash } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import { purgeFilesData } from '../../../db/index.js';
-import { warn } from '../../../infrastructure/logger.js';
-import { EXTENSIONS, IGNORE_DIRS } from '../../../shared/constants.js';
-
-export const BUILTIN_RECEIVERS = new Set([
-  'console',
-  'Math',
-  'JSON',
-  'Object',
-  'Array',
-  'String',
-  'Number',
-  'Boolean',
-  'Date',
-  'RegExp',
-  'Map',
-  'Set',
-  'WeakMap',
-  'WeakSet',
-  'Promise',
-  'Symbol',
-  'Error',
-  'TypeError',
-  'RangeError',
-  'Proxy',
-  'Reflect',
-  'Intl',
-  'globalThis',
-  'window',
-  'document',
-  'process',
-  'Buffer',
-  'require',
-]);
-
-/**
- * Recursively collect all source files under `dir`.
- * When `directories` is a Set, also tracks which directories contain files.
- */
-export function collectFiles(
-  dir,
-  files = [],
-  config = {},
-  directories = null,
-  _visited = new Set(),
-) {
-  const trackDirs = directories instanceof Set;
-  let hasFiles = false;
-
-  // Merge config ignoreDirs with defaults
-  const extraIgnore = config.ignoreDirs ? new Set(config.ignoreDirs) : null;
-
-  // Detect symlink loops (before I/O to avoid wasted readdirSync)
-  let realDir;
-  try {
-    realDir = fs.realpathSync(dir);
-  } catch {
-    return trackDirs ? { files, directories } : files;
-  }
-  if (_visited.has(realDir)) {
-    warn(`Symlink loop detected, skipping: ${dir}`);
-    return trackDirs ? { files, directories } : files;
-  }
-  _visited.add(realDir);
-
-  let entries;
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch (err) {
-    warn(`Cannot read directory ${dir}: ${err.message}`);
-    return trackDirs ? { files, directories } : files;
-  }
-
-  for (const entry of entries) {
-    if (entry.name.startsWith('.') && entry.name !== '.') {
-      if (IGNORE_DIRS.has(entry.name)) continue;
-      if (entry.isDirectory()) continue;
-    }
-    if (IGNORE_DIRS.has(entry.name)) continue;
-    if (extraIgnore?.has(entry.name)) continue;
-
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      collectFiles(full, files, config, directories, _visited);
-    } else if (EXTENSIONS.has(path.extname(entry.name))) {
-      files.push(full);
-      hasFiles = true;
-    }
-  }
-  if (trackDirs && hasFiles) {
-    directories.add(dir);
-  }
-  return trackDirs ? { files, directories } : files;
-}
-
-/**
- * Load path aliases from tsconfig.json / jsconfig.json.
- */
-export function loadPathAliases(rootDir) {
-  const aliases = { baseUrl: null, paths: {} };
-  for (const configName of ['tsconfig.json', 'jsconfig.json']) {
-    const configPath = path.join(rootDir, configName);
-    if (!fs.existsSync(configPath)) continue;
-    try {
-      const raw = fs
-        .readFileSync(configPath, 'utf-8')
-        .replace(/\/\/.*$/gm, '')
-        .replace(/\/\*[\s\S]*?\*\//g, '')
-        .replace(/,\s*([\]}])/g, '$1');
-      const config = JSON.parse(raw);
-      const opts = config.compilerOptions || {};
-      if (opts.baseUrl) aliases.baseUrl = path.resolve(rootDir, opts.baseUrl);
-      if (opts.paths) {
-        for (const [pattern, targets] of Object.entries(opts.paths)) {
-          aliases.paths[pattern] = targets.map((t) => path.resolve(aliases.baseUrl || rootDir, t));
-        }
-      }
-      break;
-    } catch (err) {
-      warn(`Failed to parse ${configName}: ${err.message}`);
-    }
-  }
-  return aliases;
-}
-
-/**
- * Compute MD5 hash of file contents for incremental builds.
- */
-export function fileHash(content) {
-  return createHash('md5').update(content).digest('hex');
-}
-
-/**
- * Stat a file, returning { mtimeMs, size } or null on error.
- */
-export function fileStat(filePath) {
-  try {
-    const s = fs.statSync(filePath);
-    return { mtimeMs: s.mtimeMs, size: s.size };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Read a file with retry on transient errors (EBUSY/EACCES/EPERM).
- */
-const TRANSIENT_CODES = new Set(['EBUSY', 'EACCES', 'EPERM']);
-const RETRY_DELAY_MS = 50;
-
-export function readFileSafe(filePath, retries = 2) {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      return fs.readFileSync(filePath, 'utf-8');
-    } catch (err) {
-      if (attempt < retries && TRANSIENT_CODES.has(err.code)) {
-        const end = Date.now() + RETRY_DELAY_MS;
-        while (Date.now() < end) {}
-        continue;
-      }
-      throw err;
-    }
-  }
-}
-
-/**
- * Purge all graph data for the specified files.
- */
-export function purgeFilesFromGraph(db, files, options = {}) {
-  purgeFilesData(db, files, options);
-}
-
-/** Batch INSERT chunk size for multi-value INSERTs. */
-const BATCH_CHUNK = 200;
-
-/**
- * Batch-insert node rows via multi-value INSERT statements.
- * Each row: [name, kind, file, line, end_line, parent_id, qualified_name, scope, visibility]
- */
-export function batchInsertNodes(db, rows) {
-  if (!rows.length) return;
-  const ph = '(?,?,?,?,?,?,?,?,?)';
-  for (let i = 0; i < rows.length; i += BATCH_CHUNK) {
-    const chunk = rows.slice(i, i + BATCH_CHUNK);
-    const vals = [];
-    for (const r of chunk) vals.push(r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8]);
-    db.prepare(
-      'INSERT OR IGNORE INTO nodes (name,kind,file,line,end_line,parent_id,qualified_name,scope,visibility) VALUES ' +
-        chunk.map(() => ph).join(','),
-    ).run(...vals);
-  }
-}
-
-/**
- * Batch-insert edge rows via multi-value INSERT statements.
- * Each row: [source_id, target_id, kind, confidence, dynamic]
- */
-export function batchInsertEdges(db, rows) {
-  if (!rows.length) return;
-  const ph = '(?,?,?,?,?)';
-  for (let i = 0; i < rows.length; i += BATCH_CHUNK) {
-    const chunk = rows.slice(i, i + BATCH_CHUNK);
-    const vals = [];
-    for (const r of chunk) vals.push(r[0], r[1], r[2], r[3], r[4]);
-    db.prepare(
-      'INSERT INTO edges (source_id,target_id,kind,confidence,dynamic) VALUES ' +
-        chunk.map(() => ph).join(','),
-    ).run(...vals);
-  }
-}

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

@@ -1,224 +0,0 @@
-/**
- * Incremental single-file rebuild — used by watch mode.
- *
- * Reuses pipeline helpers instead of duplicating node insertion and edge building
- * logic from the main builder. This eliminates the watcher.js divergence (ROADMAP 3.9).
- */
-import fs from 'node:fs';
-import path from 'node:path';
-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, 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 {string} rootDir - Absolute root directory
- * @param {string} filePath - Absolute file path
- * @param {object} stmts - Prepared DB statements
- * @param {object} engineOpts - Engine options
- * @param {object|null} cache - Parse tree cache (native only)
- * @param {object} [options]
- * @param {Function} [options.diffSymbols] - Symbol diff function
- * @returns {Promise<object|null>} Update result or null on failure
- */
-export async function rebuildFile(_db, rootDir, filePath, stmts, engineOpts, cache, options = {}) {
-  const { diffSymbols } = options;
-  const relPath = normalizePath(path.relative(rootDir, filePath));
-  const oldNodes = stmts.countNodes.get(relPath)?.c || 0;
-  const oldSymbols = diffSymbols ? stmts.listSymbols.all(relPath) : [];
-
-  stmts.deleteEdgesForFile.run(relPath);
-  stmts.deleteNodes.run(relPath);
-
-  if (!fs.existsSync(filePath)) {
-    if (cache) cache.remove(filePath);
-    const symbolDiff = diffSymbols ? diffSymbols(oldSymbols, []) : null;
-    return {
-      file: relPath,
-      nodesAdded: 0,
-      nodesRemoved: oldNodes,
-      edgesAdded: 0,
-      deleted: true,
-      event: 'deleted',
-      symbolDiff,
-      nodesBefore: oldNodes,
-      nodesAfter: 0,
-    };
-  }
-
-  let code;
-  try {
-    code = readFileSafe(filePath);
-  } catch (err) {
-    warn(`Cannot read ${relPath}: ${err.message}`);
-    return null;
-  }
-
-  const symbols = await parseFileIncremental(cache, filePath, code, engineOpts);
-  if (!symbols) return null;
-
-  insertFileNodes(stmts, relPath, symbols);
-
-  const newNodes = stmts.countNodes.get(relPath)?.c || 0;
-  const newSymbols = diffSymbols ? stmts.listSymbols.all(relPath) : [];
-
-  const fileNodeRow = stmts.getNodeId.get(relPath, 'file', relPath, 0);
-  if (!fileNodeRow)
-    return { file: relPath, nodesAdded: newNodes, nodesRemoved: oldNodes, edgesAdded: 0 };
-
-  const aliases = { baseUrl: null, paths: {} };
-
-  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';
-
-  return {
-    file: relPath,
-    nodesAdded: newNodes,
-    nodesRemoved: oldNodes,
-    edgesAdded,
-    deleted: false,
-    event,
-    symbolDiff,
-    nodesBefore: oldNodes,
-    nodesAfter: newNodes,
-  };
-}

package/src/domain/graph/cycles.js

@@ -1,82 +0,0 @@
-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/domain/search/stores/sqlite-blob.js

@@ -1,24 +0,0 @@
-/**
- * @typedef {object} VectorStore
- * @property {(queryVec: Float32Array, rows: Array<{vector: Buffer}>) => Array<{index: number, score: number}>} search
- *   Score every row against a query vector and return scored indices.
- *
- * Future implementations (e.g. HNSW via `hnsw.js`) implement this same shape
- * for approximate nearest-neighbor search.
- */
-
-/**
- * Cosine similarity between two Float32Arrays.
- */
-export function cosineSim(a, b) {
-  let dot = 0,
-    normA = 0,
-    normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  return denom === 0 ? 0 : dot / denom;
-}