@optave/codegraph 1.1.0 → 1.3.0

package/src/constants.js

@@ -1,28 +1,41 @@
-import path from 'path';
-
-export const IGNORE_DIRS = new Set([
-  'node_modules', '.git', 'dist', 'build', '.next', '.nuxt', '.svelte-kit',
-  'coverage', '.codegraph', '__pycache__', '.tox', 'vendor', '.venv', 'venv',
-  'env', '.env'
-]);
-
-export const EXTENSIONS = new Set([
-  '.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs',
-  '.tf', '.hcl', '.py'
-]);
-
-export function shouldIgnore(dirName) {
-  return IGNORE_DIRS.has(dirName) || dirName.startsWith('.');
-}
-
-export function isSupportedFile(filePath) {
-  return EXTENSIONS.has(path.extname(filePath));
-}
-
-/**
- * Normalize a file path to always use forward slashes.
- * Ensures cross-platform consistency in the SQLite database.
- */
-export function normalizePath(filePath) {
-  return filePath.split(path.sep).join('/');
-}
+import path from 'node:path';
+import { SUPPORTED_EXTENSIONS } from './parser.js';
+
+export const IGNORE_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  '.next',
+  '.nuxt',
+  '.svelte-kit',
+  'coverage',
+  '.codegraph',
+  '__pycache__',
+  '.tox',
+  'vendor',
+  '.venv',
+  'venv',
+  'env',
+  '.env',
+]);
+
+// Re-export as an indirect binding to avoid TDZ in the circular
+// parser.js ↔ constants.js import (no value read at evaluation time).
+export { SUPPORTED_EXTENSIONS as EXTENSIONS };
+
+export function shouldIgnore(dirName) {
+  return IGNORE_DIRS.has(dirName) || dirName.startsWith('.');
+}
+
+export function isSupportedFile(filePath) {
+  return SUPPORTED_EXTENSIONS.has(path.extname(filePath));
+}
+
+/**
+ * Normalize a file path to always use forward slashes.
+ * Ensures cross-platform consistency in the SQLite database.
+ */
+export function normalizePath(filePath) {
+  return filePath.split(path.sep).join('/');
+}

package/src/cycles.js

@@ -1,104 +1,125 @@
-/**
- * Detect circular dependencies in the codebase using Tarjan's SCC algorithm.
- * @param {object} db - Open SQLite database
- * @param {object} opts - { fileLevel: true }
- * @returns {string[][]} Array of cycles, each cycle is an array of file paths
- */
-export function findCycles(db, opts = {}) {
-  const fileLevel = opts.fileLevel !== false;
-
-  // Build adjacency list
-  let edges;
-  if (fileLevel) {
-    edges = db.prepare(`
-      SELECT DISTINCT n1.file AS source, n2.file AS target
-      FROM edges e
-      JOIN nodes n1 ON e.source_id = n1.id
-      JOIN nodes n2 ON e.target_id = n2.id
-      WHERE n1.file != n2.file AND e.kind IN ('imports', 'imports-type')
-    `).all();
-  } else {
-    edges = db.prepare(`
-      SELECT DISTINCT
-        (n1.name || '|' || n1.file) AS source,
-        (n2.name || '|' || n2.file) AS target
-      FROM edges e
-      JOIN nodes n1 ON e.source_id = n1.id
-      JOIN nodes n2 ON e.target_id = n2.id
-      WHERE n1.kind IN ('function', 'method', 'class')
-        AND n2.kind IN ('function', 'method', 'class')
-        AND e.kind = 'calls'
-        AND n1.id != n2.id
-    `).all();
-  }
-
-  const graph = new Map();
-  for (const { source, target } of edges) {
-    if (!graph.has(source)) graph.set(source, []);
-    graph.get(source).push(target);
-    if (!graph.has(target)) graph.set(target, []);
-  }
-
-  // Tarjan's strongly connected components algorithm
-  let index = 0;
-  const stack = [];
-  const onStack = new Set();
-  const indices = new Map();
-  const lowlinks = new Map();
-  const sccs = [];
-
-  function strongconnect(v) {
-    indices.set(v, index);
-    lowlinks.set(v, index);
-    index++;
-    stack.push(v);
-    onStack.add(v);
-
-    for (const w of (graph.get(v) || [])) {
-      if (!indices.has(w)) {
-        strongconnect(w);
-        lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
-      } else if (onStack.has(w)) {
-        lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
-      }
-    }
-
-    if (lowlinks.get(v) === indices.get(v)) {
-      const scc = [];
-      let w;
-      do {
-        w = stack.pop();
-        onStack.delete(w);
-        scc.push(w);
-      } while (w !== v);
-      if (scc.length > 1) sccs.push(scc);
-    }
-  }
-
-  for (const node of graph.keys()) {
-    if (!indices.has(node)) strongconnect(node);
-  }
-
-  return sccs;
-}
-
-/**
- * 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');
-}
+import { loadNative } from './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 }
+ * @returns {string[][]} Array of cycles, each cycle is an array of file paths
+ */
+export function findCycles(db, opts = {}) {
+  const fileLevel = opts.fileLevel !== false;
+
+  // Build adjacency list from SQLite (stays in JS — only the algorithm can move to Rust)
+  let edges;
+  if (fileLevel) {
+    edges = db
+      .prepare(`
+      SELECT DISTINCT n1.file AS source, n2.file AS target
+      FROM edges e
+      JOIN nodes n1 ON e.source_id = n1.id
+      JOIN nodes n2 ON e.target_id = n2.id
+      WHERE n1.file != n2.file AND e.kind IN ('imports', 'imports-type')
+    `)
+      .all();
+  } else {
+    edges = db
+      .prepare(`
+      SELECT DISTINCT
+        (n1.name || '|' || n1.file) AS source,
+        (n2.name || '|' || n2.file) AS target
+      FROM edges e
+      JOIN nodes n1 ON e.source_id = n1.id
+      JOIN nodes n2 ON e.target_id = n2.id
+      WHERE n1.kind IN ('function', 'method', 'class')
+        AND n2.kind IN ('function', 'method', 'class')
+        AND e.kind = 'calls'
+        AND n1.id != n2.id
+    `)
+      .all();
+  }
+
+  // Try native Rust implementation
+  const native = loadNative();
+  if (native) {
+    return native.detectCycles(edges);
+  }
+
+  // Fallback: JS Tarjan
+  return findCyclesJS(edges);
+}
+
+/**
+ * Pure-JS Tarjan's SCC implementation.
+ */
+export function findCyclesJS(edges) {
+  const graph = new Map();
+  for (const { source, target } of edges) {
+    if (!graph.has(source)) graph.set(source, []);
+    graph.get(source).push(target);
+    if (!graph.has(target)) graph.set(target, []);
+  }
+
+  // Tarjan's strongly connected components algorithm
+  let index = 0;
+  const stack = [];
+  const onStack = new Set();
+  const indices = new Map();
+  const lowlinks = new Map();
+  const sccs = [];
+
+  function strongconnect(v) {
+    indices.set(v, index);
+    lowlinks.set(v, index);
+    index++;
+    stack.push(v);
+    onStack.add(v);
+
+    for (const w of graph.get(v) || []) {
+      if (!indices.has(w)) {
+        strongconnect(w);
+        lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
+      } else if (onStack.has(w)) {
+        lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
+      }
+    }
+
+    if (lowlinks.get(v) === indices.get(v)) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        scc.push(w);
+      } while (w !== v);
+      if (scc.length > 1) sccs.push(scc);
+    }
+  }
+
+  for (const node of graph.keys()) {
+    if (!indices.has(node)) strongconnect(node);
+  }
+
+  return sccs;
+}
+
+/**
+ * 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/db.js

@@ -1,117 +1,129 @@
-import Database from 'better-sqlite3';
-import path from 'path';
-import fs from 'fs';
-import { warn, debug, info } from './logger.js';
-
-// ─── Schema Migrations ─────────────────────────────────────────────────
-export const MIGRATIONS = [
-  {
-    version: 1,
-    up: `
-      CREATE TABLE IF NOT EXISTS nodes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL,
-        kind TEXT NOT NULL,
-        file TEXT NOT NULL,
-        line INTEGER,
-        end_line INTEGER,
-        UNIQUE(name, kind, file, line)
-      );
-      CREATE TABLE IF NOT EXISTS edges (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        source_id INTEGER NOT NULL,
-        target_id INTEGER NOT NULL,
-        kind TEXT NOT NULL,
-        confidence REAL DEFAULT 1.0,
-        dynamic INTEGER DEFAULT 0,
-        FOREIGN KEY(source_id) REFERENCES nodes(id),
-        FOREIGN KEY(target_id) REFERENCES nodes(id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name);
-      CREATE INDEX IF NOT EXISTS idx_nodes_file ON nodes(file);
-      CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind);
-      CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
-      CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
-      CREATE INDEX IF NOT EXISTS idx_edges_kind ON edges(kind);
-    `
-  },
-  {
-    version: 2,
-    up: `
-      CREATE INDEX IF NOT EXISTS idx_nodes_name_kind_file ON nodes(name, kind, file);
-      CREATE INDEX IF NOT EXISTS idx_nodes_file_kind ON nodes(file, kind);
-      CREATE INDEX IF NOT EXISTS idx_edges_source_kind ON edges(source_id, kind);
-      CREATE INDEX IF NOT EXISTS idx_edges_target_kind ON edges(target_id, kind);
-    `
-  },
-  {
-    version: 3,
-    up: `
-      CREATE TABLE IF NOT EXISTS file_hashes (
-        file TEXT PRIMARY KEY,
-        hash TEXT NOT NULL,
-        mtime INTEGER NOT NULL
-      );
-    `
-  }
-];
-
-export function openDb(dbPath) {
-  const dir = path.dirname(dbPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
-  return db;
-}
-
-export function initSchema(db) {
-  db.exec(`CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL DEFAULT 0)`);
-
-  const row = db.prepare('SELECT version FROM schema_version').get();
-  let currentVersion = row ? row.version : 0;
-
-  if (!row) {
-    db.prepare('INSERT INTO schema_version (version) VALUES (0)').run();
-  }
-
-  for (const migration of MIGRATIONS) {
-    if (migration.version > currentVersion) {
-      debug(`Running migration v${migration.version}`);
-      db.exec(migration.up);
-      db.prepare('UPDATE schema_version SET version = ?').run(migration.version);
-      currentVersion = migration.version;
-    }
-  }
-
-  try { db.exec('ALTER TABLE nodes ADD COLUMN end_line INTEGER'); } catch { /* already exists */ }
-  try { db.exec('ALTER TABLE edges ADD COLUMN confidence REAL DEFAULT 1.0'); } catch { /* already exists */ }
-  try { db.exec('ALTER TABLE edges ADD COLUMN dynamic INTEGER DEFAULT 0'); } catch { /* already exists */ }
-}
-
-export function findDbPath(customPath) {
-  if (customPath) return path.resolve(customPath);
-  let dir = process.cwd();
-  while (true) {
-    const candidate = path.join(dir, '.codegraph', 'graph.db');
-    if (fs.existsSync(candidate)) return candidate;
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return path.join(process.cwd(), '.codegraph', 'graph.db');
-}
-
-/**
- * Open a database in readonly mode, with a user-friendly error if the DB doesn't exist.
- */
-export function openReadonlyOrFail(customPath) {
-  const dbPath = findDbPath(customPath);
-  if (!fs.existsSync(dbPath)) {
-    console.error(
-      `No codegraph database found at ${dbPath}.\n` +
-      `Run "codegraph build" first to analyze your codebase.`
-    );
-    process.exit(1);
-  }
-  return new Database(dbPath, { readonly: true });
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import Database from 'better-sqlite3';
+import { debug } from './logger.js';
+
+// ─── Schema Migrations ─────────────────────────────────────────────────
+export const MIGRATIONS = [
+  {
+    version: 1,
+    up: `
+      CREATE TABLE IF NOT EXISTS nodes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        file TEXT NOT NULL,
+        line INTEGER,
+        end_line INTEGER,
+        UNIQUE(name, kind, file, line)
+      );
+      CREATE TABLE IF NOT EXISTS edges (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_id INTEGER NOT NULL,
+        target_id INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        confidence REAL DEFAULT 1.0,
+        dynamic INTEGER DEFAULT 0,
+        FOREIGN KEY(source_id) REFERENCES nodes(id),
+        FOREIGN KEY(target_id) REFERENCES nodes(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name);
+      CREATE INDEX IF NOT EXISTS idx_nodes_file ON nodes(file);
+      CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind);
+      CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
+      CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
+      CREATE INDEX IF NOT EXISTS idx_edges_kind ON edges(kind);
+    `,
+  },
+  {
+    version: 2,
+    up: `
+      CREATE INDEX IF NOT EXISTS idx_nodes_name_kind_file ON nodes(name, kind, file);
+      CREATE INDEX IF NOT EXISTS idx_nodes_file_kind ON nodes(file, kind);
+      CREATE INDEX IF NOT EXISTS idx_edges_source_kind ON edges(source_id, kind);
+      CREATE INDEX IF NOT EXISTS idx_edges_target_kind ON edges(target_id, kind);
+    `,
+  },
+  {
+    version: 3,
+    up: `
+      CREATE TABLE IF NOT EXISTS file_hashes (
+        file TEXT PRIMARY KEY,
+        hash TEXT NOT NULL,
+        mtime INTEGER NOT NULL
+      );
+    `,
+  },
+];
+
+export function openDb(dbPath) {
+  const dir = path.dirname(dbPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  return db;
+}
+
+export function initSchema(db) {
+  db.exec(`CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL DEFAULT 0)`);
+
+  const row = db.prepare('SELECT version FROM schema_version').get();
+  let currentVersion = row ? row.version : 0;
+
+  if (!row) {
+    db.prepare('INSERT INTO schema_version (version) VALUES (0)').run();
+  }
+
+  for (const migration of MIGRATIONS) {
+    if (migration.version > currentVersion) {
+      debug(`Running migration v${migration.version}`);
+      db.exec(migration.up);
+      db.prepare('UPDATE schema_version SET version = ?').run(migration.version);
+      currentVersion = migration.version;
+    }
+  }
+
+  try {
+    db.exec('ALTER TABLE nodes ADD COLUMN end_line INTEGER');
+  } catch {
+    /* already exists */
+  }
+  try {
+    db.exec('ALTER TABLE edges ADD COLUMN confidence REAL DEFAULT 1.0');
+  } catch {
+    /* already exists */
+  }
+  try {
+    db.exec('ALTER TABLE edges ADD COLUMN dynamic INTEGER DEFAULT 0');
+  } catch {
+    /* already exists */
+  }
+}
+
+export function findDbPath(customPath) {
+  if (customPath) return path.resolve(customPath);
+  let dir = process.cwd();
+  while (true) {
+    const candidate = path.join(dir, '.codegraph', 'graph.db');
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path.join(process.cwd(), '.codegraph', 'graph.db');
+}
+
+/**
+ * Open a database in readonly mode, with a user-friendly error if the DB doesn't exist.
+ */
+export function openReadonlyOrFail(customPath) {
+  const dbPath = findDbPath(customPath);
+  if (!fs.existsSync(dbPath)) {
+    console.error(
+      `No codegraph database found at ${dbPath}.\n` +
+        `Run "codegraph build" first to analyze your codebase.`,
+    );
+    process.exit(1);
+  }
+  return new Database(dbPath, { readonly: true });
+}