@optave/codegraph 3.3.0 → 3.4.0

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

@@ -0,0 +1,81 @@
+/**
+ * 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().
+ */
+import type BetterSqlite3 from 'better-sqlite3';
+import type {
+  BuildGraphOpts,
+  CodegraphConfig,
+  EngineOpts,
+  ExtractorOutput,
+  FileToParse,
+  MetadataUpdate,
+  NodeRow,
+  ParseChange,
+  PathAliases,
+} from '../../../types.js';
+
+export class PipelineContext {
+  // ── Inputs (set during setup) ──────────────────────────────────────
+  rootDir!: string;
+  db!: BetterSqlite3.Database;
+  dbPath!: string;
+  config!: CodegraphConfig;
+  opts!: BuildGraphOpts;
+  engineOpts!: EngineOpts;
+  engineName!: 'native' | 'wasm';
+  engineVersion!: string | null;
+  aliases!: PathAliases;
+  incremental!: boolean;
+  forceFullRebuild: boolean = false;
+  schemaVersion!: number;
+
+  // ── File collection (set by collectFiles stage) ────────────────────
+  allFiles!: string[];
+  discoveredDirs!: Set<string>;
+
+  // ── Change detection (set by detectChanges stage) ──────────────────
+  isFullBuild!: boolean;
+  parseChanges!: ParseChange[];
+  metadataUpdates!: MetadataUpdate[];
+  removed!: string[];
+  earlyExit: boolean = false;
+
+  // ── Parsing (set by parseFiles stage) ──────────────────────────────
+  allSymbols!: Map<string, ExtractorOutput>;
+  fileSymbols!: Map<string, ExtractorOutput>;
+  filesToParse!: FileToParse[];
+
+  // ── Import resolution (set by resolveImports stage) ────────────────
+  batchResolved!: Map<string, string> | null;
+  reexportMap!: Map<string, unknown[]>;
+  barrelOnlyFiles!: Set<string>;
+
+  // ── Node lookup (set by insertNodes / buildEdges stages) ───────────
+  nodesByName!: Map<string, NodeRow[]>;
+  nodesByNameAndFile!: Map<string, NodeRow[]>;
+
+  // ── Misc state ─────────────────────────────────────────────────────
+  hasEmbeddings: boolean = false;
+  lineCountMap!: Map<string, number>;
+
+  // ── Phase timing ───────────────────────────────────────────────────
+  timing: {
+    setupMs?: number;
+    parseMs?: number;
+    insertMs?: number;
+    resolveMs?: number;
+    edgesMs?: number;
+    structureMs?: number;
+    rolesMs?: number;
+    astMs?: number;
+    complexityMs?: number;
+    cfgMs?: number;
+    dataflowMs?: number;
+    finalizeMs?: number;
+    [key: string]: number | undefined;
+  } = {};
+  buildStart!: number;
+}

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

@@ -0,0 +1,289 @@
+/**
+ * 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 type BetterSqlite3 from 'better-sqlite3';
+import { purgeFilesData } from '../../../db/index.js';
+import { warn } from '../../../infrastructure/logger.js';
+import { EXTENSIONS, IGNORE_DIRS } from '../../../shared/constants.js';
+import type { BetterSqlite3Database, CodegraphConfig, PathAliases } from '../../../types.js';
+
+export const BUILTIN_RECEIVERS: Set<string> = 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: string,
+  files: string[],
+  config: Partial<CodegraphConfig>,
+  directories: Set<string>,
+  _visited?: Set<string>,
+): { files: string[]; directories: Set<string> };
+export function collectFiles(
+  dir: string,
+  files?: string[],
+  config?: Partial<CodegraphConfig>,
+  directories?: null,
+  _visited?: Set<string>,
+): string[];
+export function collectFiles(
+  dir: string,
+  files: string[] = [],
+  config: Partial<CodegraphConfig> = {},
+  directories: Set<string> | null = null,
+  _visited: Set<string> = new Set(),
+): string[] | { files: string[]; directories: Set<string> } {
+  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: string;
+  try {
+    realDir = fs.realpathSync(dir);
+  } catch {
+    return trackDirs ? { files, directories: directories as Set<string> } : files;
+  }
+  if (_visited.has(realDir)) {
+    warn(`Symlink loop detected, skipping: ${dir}`);
+    return trackDirs ? { files, directories: directories as Set<string> } : files;
+  }
+  _visited.add(realDir);
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err: unknown) {
+    warn(`Cannot read directory ${dir}: ${(err as Error).message}`);
+    return trackDirs ? { files, directories: directories as Set<string> } : 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()) {
+      if (trackDirs) {
+        collectFiles(full, files, config, directories as Set<string>, _visited);
+      } else {
+        collectFiles(full, files, config, null, _visited);
+      }
+    } else if (EXTENSIONS.has(path.extname(entry.name))) {
+      files.push(full);
+      hasFiles = true;
+    }
+  }
+  if (trackDirs && hasFiles) {
+    (directories as Set<string>).add(dir);
+  }
+  return trackDirs ? { files, directories: directories as Set<string> } : files;
+}
+
+/**
+ * Load path aliases from tsconfig.json / jsconfig.json.
+ */
+export function loadPathAliases(rootDir: string): PathAliases {
+  const aliases: PathAliases = { 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) as {
+        compilerOptions?: { baseUrl?: string; paths?: Record<string, string[]> };
+      };
+      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: string) =>
+            path.resolve(aliases.baseUrl || rootDir, t),
+          );
+        }
+      }
+      break;
+    } catch (err: unknown) {
+      warn(`Failed to parse ${configName}: ${(err as Error).message}`);
+    }
+  }
+  return aliases;
+}
+
+/**
+ * Compute MD5 hash of file contents for incremental builds.
+ */
+export function fileHash(content: string): string {
+  return createHash('md5').update(content).digest('hex');
+}
+
+/**
+ * Stat a file, returning { mtimeMs, size } or null on error.
+ */
+export function fileStat(filePath: string): { mtimeMs: number; size: number } | null {
+  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: Set<string> = new Set(['EBUSY', 'EACCES', 'EPERM']);
+const RETRY_DELAY_MS = 50;
+
+export function readFileSafe(filePath: string, retries: number = 2): string {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return fs.readFileSync(filePath, 'utf-8');
+    } catch (err: unknown) {
+      if (attempt < retries && TRANSIENT_CODES.has((err as NodeJS.ErrnoException).code ?? '')) {
+        const sharedBuf = new SharedArrayBuffer(4);
+        Atomics.wait(new Int32Array(sharedBuf), 0, 0, RETRY_DELAY_MS);
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+
+/**
+ * Purge all graph data for the specified files.
+ */
+export function purgeFilesFromGraph(
+  db: BetterSqlite3.Database,
+  files: string[],
+  options: Record<string, unknown> = {},
+): void {
+  // Double-cast needed: better-sqlite3 types don't declare `open`/`name` properties
+  purgeFilesData(db as unknown as BetterSqlite3Database, files, options);
+}
+
+/** Batch INSERT chunk size for multi-value INSERTs. */
+const BATCH_CHUNK = 500;
+
+// Statement caches keyed by chunk size — avoids recompiling for every batch.
+const nodeStmtCache = new WeakMap<BetterSqlite3.Database, Map<number, BetterSqlite3.Statement>>();
+const edgeStmtCache = new WeakMap<BetterSqlite3.Database, Map<number, BetterSqlite3.Statement>>();
+
+function getNodeStmt(db: BetterSqlite3.Database, chunkSize: number): BetterSqlite3.Statement {
+  let cache = nodeStmtCache.get(db);
+  if (!cache) {
+    cache = new Map();
+    nodeStmtCache.set(db, cache);
+  }
+  let stmt = cache.get(chunkSize);
+  if (!stmt) {
+    const ph = '(?,?,?,?,?,?,?,?,?)';
+    stmt = db.prepare(
+      'INSERT OR IGNORE INTO nodes (name,kind,file,line,end_line,parent_id,qualified_name,scope,visibility) VALUES ' +
+        Array.from({ length: chunkSize }, () => ph).join(','),
+    );
+    cache.set(chunkSize, stmt);
+  }
+  return stmt;
+}
+
+function getEdgeStmt(db: BetterSqlite3.Database, chunkSize: number): BetterSqlite3.Statement {
+  let cache = edgeStmtCache.get(db);
+  if (!cache) {
+    cache = new Map();
+    edgeStmtCache.set(db, cache);
+  }
+  let stmt = cache.get(chunkSize);
+  if (!stmt) {
+    const ph = '(?,?,?,?,?)';
+    stmt = db.prepare(
+      'INSERT INTO edges (source_id,target_id,kind,confidence,dynamic) VALUES ' +
+        Array.from({ length: chunkSize }, () => ph).join(','),
+    );
+    cache.set(chunkSize, stmt);
+  }
+  return stmt;
+}
+
+/**
+ * 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: BetterSqlite3.Database, rows: unknown[][]): void {
+  if (!rows.length) return;
+  for (let i = 0; i < rows.length; i += BATCH_CHUNK) {
+    const end = Math.min(i + BATCH_CHUNK, rows.length);
+    const chunkSize = end - i;
+    const stmt = getNodeStmt(db, chunkSize);
+    const vals: unknown[] = [];
+    for (let j = i; j < end; j++) {
+      const r = rows[j] as unknown[];
+      vals.push(r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8]);
+    }
+    stmt.run(...vals);
+  }
+}
+
+/**
+ * Batch-insert edge rows via multi-value INSERT statements.
+ * Each row: [source_id, target_id, kind, confidence, dynamic]
+ */
+export function batchInsertEdges(db: BetterSqlite3.Database, rows: unknown[][]): void {
+  if (!rows.length) return;
+  for (let i = 0; i < rows.length; i += BATCH_CHUNK) {
+    const end = Math.min(i + BATCH_CHUNK, rows.length);
+    const chunkSize = end - i;
+    const stmt = getEdgeStmt(db, chunkSize);
+    const vals: unknown[] = [];
+    for (let j = i; j < end; j++) {
+      const r = rows[j] as unknown[];
+      vals.push(r[0], r[1], r[2], r[3], r[4]);
+    }
+    stmt.run(...vals);
+  }
+}