@optave/codegraph 3.3.1 → 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/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;
-}

package/src/features/batch.js

@@ -1,156 +0,0 @@
-/**
- * Batch query orchestration — run the same query command against multiple targets
- * and return all results in a single JSON payload.
- *
- * Designed for multi-agent swarms that need to dispatch 20+ queries in one call.
- */
-
-import {
-  contextData,
-  explainData,
-  exportsData,
-  fileDepsData,
-  fnDepsData,
-  fnImpactData,
-  impactAnalysisData,
-  whereData,
-} from '../domain/queries.js';
-import { ConfigError } from '../shared/errors.js';
-import { complexityData } from './complexity.js';
-import { dataflowData } from './dataflow.js';
-import { flowData } from './flow.js';
-
-/**
- * Map of supported batch commands → their data function + first-arg semantics.
- * `sig` describes how the target string is passed to the data function:
- *   - 'name'   → dataFn(target, dbPath, opts)
- *   - 'target' → dataFn(target, dbPath, opts)
- *   - 'file'   → dataFn(target, dbPath, opts)
- *   - 'dbOnly' → dataFn(dbPath, { ...opts, target })  (target goes into opts)
- */
-export const BATCH_COMMANDS = {
-  'fn-impact': { fn: fnImpactData, sig: 'name' },
-  context: { fn: contextData, sig: 'name' },
-  explain: { fn: explainData, sig: 'target' },
-  where: { fn: whereData, sig: 'target' },
-  query: { fn: fnDepsData, sig: 'name' },
-  impact: { fn: impactAnalysisData, sig: 'file' },
-  deps: { fn: fileDepsData, sig: 'file' },
-  exports: { fn: exportsData, sig: 'file' },
-  flow: { fn: flowData, sig: 'name' },
-  dataflow: { fn: dataflowData, sig: 'name' },
-  complexity: { fn: complexityData, sig: 'dbOnly' },
-};
-
-/**
- * Run a query command against multiple targets, returning all results.
- *
- * @param {string} command - One of the keys in BATCH_COMMANDS
- * @param {string[]} targets - List of target names/paths
- * @param {string} [customDbPath] - Path to graph.db
- * @param {object} [opts] - Shared options passed to every invocation
- * @returns {{ command: string, total: number, succeeded: number, failed: number, results: object[] }}
- */
-export function batchData(command, targets, customDbPath, opts = {}) {
-  const entry = BATCH_COMMANDS[command];
-  if (!entry) {
-    throw new ConfigError(
-      `Unknown batch command "${command}". Valid commands: ${Object.keys(BATCH_COMMANDS).join(', ')}`,
-    );
-  }
-
-  const results = [];
-  let succeeded = 0;
-  let failed = 0;
-
-  for (const target of targets) {
-    try {
-      let data;
-      if (entry.sig === 'dbOnly') {
-        // complexityData(dbPath, { ...opts, target })
-        data = entry.fn(customDbPath, { ...opts, target });
-      } else {
-        // All other: dataFn(target, dbPath, opts)
-        data = entry.fn(target, customDbPath, opts);
-      }
-      results.push({ target, ok: true, data });
-      succeeded++;
-    } catch (err) {
-      results.push({ target, ok: false, error: err.message });
-      failed++;
-    }
-  }
-
-  return { command, total: targets.length, succeeded, failed, results };
-}
-
-/**
- * Expand comma-separated positional args into individual entries.
- * `['a,b', 'c']` → `['a', 'b', 'c']`.
- * Trims whitespace, filters empties. Passes through object items unchanged.
- *
- * @param {Array<string|object>} targets
- * @returns {Array<string|object>}
- */
-export function splitTargets(targets) {
-  const out = [];
-  for (const item of targets) {
-    if (typeof item !== 'string') {
-      out.push(item);
-      continue;
-    }
-    for (const part of item.split(',')) {
-      const trimmed = part.trim();
-      if (trimmed) out.push(trimmed);
-    }
-  }
-  return out;
-}
-
-/**
- * Multi-command batch orchestration — run different commands per target.
- *
- * @param {Array<{command: string, target: string, opts?: object}>} items
- * @param {string} [customDbPath]
- * @param {object} [sharedOpts] - Default opts merged under per-item opts
- * @returns {{ mode: 'multi', total: number, succeeded: number, failed: number, results: object[] }}
- */
-export function multiBatchData(items, customDbPath, sharedOpts = {}) {
-  const results = [];
-  let succeeded = 0;
-  let failed = 0;
-
-  for (const item of items) {
-    const { command, target, opts: itemOpts } = item;
-    const entry = BATCH_COMMANDS[command];
-
-    if (!entry) {
-      results.push({
-        command,
-        target,
-        ok: false,
-        error: `Unknown batch command "${command}". Valid commands: ${Object.keys(BATCH_COMMANDS).join(', ')}`,
-      });
-      failed++;
-      continue;
-    }
-
-    const merged = { ...sharedOpts, ...itemOpts };
-
-    try {
-      let data;
-      if (entry.sig === 'dbOnly') {
-        data = entry.fn(customDbPath, { ...merged, target });
-      } else {
-        data = entry.fn(target, customDbPath, merged);
-      }
-      results.push({ command, target, ok: true, data });
-      succeeded++;
-    } catch (err) {
-      results.push({ command, target, ok: false, error: err.message });
-      failed++;
-    }
-  }
-
-  return { mode: 'multi', total: items.length, succeeded, failed, results };
-}

package/src/graph/algorithms/louvain.js

@@ -1,26 +0,0 @@
-/**
- * Louvain community detection via graphology.
- *
- * @param {import('../model.js').CodeGraph} graph
- * @param {{ resolution?: number }} [opts]
- * @returns {{ assignments: Map<string, number>, modularity: number }}
- */
-import graphologyLouvain from 'graphology-communities-louvain';
-
-export function louvainCommunities(graph, opts = {}) {
-  const gy = graph.toGraphology({ type: 'undirected' });
-
-  if (gy.order === 0 || gy.size === 0) {
-    return { assignments: new Map(), modularity: 0 };
-  }
-
-  const resolution = opts.resolution ?? 1.0;
-  const details = graphologyLouvain.detailed(gy, { resolution });
-
-  const assignments = new Map();
-  for (const [nodeId, communityId] of Object.entries(details.communities)) {
-    assignments.set(nodeId, communityId);
-  }
-
-  return { assignments, modularity: details.modularity };
-}

package/src/graph/builders/structure.js

@@ -1,40 +0,0 @@
-/**
- * Build a containment graph (directory → file) from the SQLite database.
- */
-
-import { CodeGraph } from '../model.js';
-
-/**
- * @param {object} db - Open better-sqlite3 database (readonly)
- * @returns {CodeGraph} Directed graph with directory→file containment edges
- */
-export function buildStructureGraph(db) {
-  const graph = new CodeGraph();
-
-  const dirs = db.prepare("SELECT id, name FROM nodes WHERE kind = 'directory'").all();
-
-  for (const d of dirs) {
-    graph.addNode(String(d.id), { label: d.name, kind: 'directory' });
-  }
-
-  const files = db.prepare("SELECT id, name, file FROM nodes WHERE kind = 'file'").all();
-
-  for (const f of files) {
-    graph.addNode(String(f.id), { label: f.name, kind: 'file', file: f.file });
-  }
-
-  const containsEdges = db
-    .prepare(`
-      SELECT e.source_id, e.target_id
-      FROM edges e
-      JOIN nodes n ON e.source_id = n.id
-      WHERE e.kind = 'contains' AND n.kind = 'directory'
-    `)
-    .all();
-
-  for (const e of containsEdges) {
-    graph.addEdge(String(e.source_id), String(e.target_id), { kind: 'contains' });
-  }
-
-  return graph;
-}

package/src/graph/builders/temporal.js

@@ -1,33 +0,0 @@
-/**
- * Build a co-change (temporal) graph weighted by Jaccard similarity.
- */
-
-import { CodeGraph } from '../model.js';
-
-/**
- * @param {object} db - Open better-sqlite3 database (readonly)
- * @param {{ minJaccard?: number }} [opts]
- * @returns {CodeGraph} Undirected graph weighted by Jaccard similarity
- */
-export function buildTemporalGraph(db, opts = {}) {
-  const minJaccard = opts.minJaccard ?? 0.0;
-  const graph = new CodeGraph({ directed: false });
-
-  // Check if co_changes table exists
-  const tableCheck = db
-    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='co_changes'")
-    .get();
-  if (!tableCheck) return graph;
-
-  const rows = db
-    .prepare('SELECT file_a, file_b, jaccard FROM co_changes WHERE jaccard >= ?')
-    .all(minJaccard);
-
-  for (const r of rows) {
-    if (!graph.hasNode(r.file_a)) graph.addNode(r.file_a, { label: r.file_a });
-    if (!graph.hasNode(r.file_b)) graph.addNode(r.file_b, { label: r.file_b });
-    graph.addEdge(r.file_a, r.file_b, { jaccard: r.jaccard });
-  }
-
-  return graph;
-}