@optave/codegraph 3.1.3 → 3.1.5

package/src/{check.js → features/check.js}

@@ -1,10 +1,11 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { loadConfig } from './config.js';
-import { findCycles } from './cycles.js';
-import { findDbPath, openReadonlyOrFail } from './db.js';
-import { isTestFile } from './infrastructure/test-filter.js';
+import { findDbPath, openReadonlyOrFail } from '../db/index.js';
+import { bfsTransitiveCallers } from '../domain/analysis/impact.js';
+import { findCycles } from '../domain/graph/cycles.js';
+import { loadConfig } from '../infrastructure/config.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
 import { matchOwners, parseCodeowners } from './owners.js';
 
 // ─── Diff Parser ──────────────────────────────────────────────────────
@@ -96,31 +97,10 @@ export function checkMaxBlastRadius(db, changedRanges, threshold, noTests, maxDe
       }
       if (!overlaps) continue;
 
-      // BFS transitive callers
-      const visited = new Set([def.id]);
-      let frontier = [def.id];
-      let totalCallers = 0;
-      for (let d = 1; d <= maxDepth; d++) {
-        const nextFrontier = [];
-        for (const fid of frontier) {
-          const callers = db
-            .prepare(
-              `SELECT DISTINCT n.id, n.name, n.kind, n.file, n.line
-               FROM edges e JOIN nodes n ON e.source_id = n.id
-               WHERE e.target_id = ? AND e.kind = 'calls'`,
-            )
-            .all(fid);
-          for (const c of callers) {
-            if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
-              visited.add(c.id);
-              nextFrontier.push(c.id);
-              totalCallers++;
-            }
-          }
-        }
-        frontier = nextFrontier;
-        if (frontier.length === 0) break;
-      }
+      const { totalDependents: totalCallers } = bfsTransitiveCallers(db, def.id, {
+        noTests,
+        maxDepth,
+      });
 
       if (totalCallers > maxFound) maxFound = totalCallers;
       if (totalCallers > threshold) {
@@ -240,7 +220,10 @@ export function checkData(customDbPath, opts = {}) {
     const maxDepth = opts.depth || 3;
 
     // Load config defaults for check predicates
-    const config = loadConfig(repoRoot);
+    // NOTE: opts.config is loaded from process.cwd() at startup (via CLI context),
+    // which may differ from the DB's parent repo root when --db points to an external
+    // project. This is an acceptable trade-off to avoid duplicate I/O on the hot path.
+    const config = opts.config || loadConfig(repoRoot);
     const checkConfig = config.check || {};
 
     // Resolve which predicates are enabled: CLI flags ?? config ?? built-in defaults

package/src/{cochange.js → features/cochange.js}

@@ -8,11 +8,11 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { normalizePath } from './constants.js';
-import { closeDb, findDbPath, initSchema, openDb, openReadonlyOrFail } from './db.js';
-import { isTestFile } from './infrastructure/test-filter.js';
-import { warn } from './logger.js';
-import { paginateResult } from './paginate.js';
+import { closeDb, findDbPath, initSchema, openDb, openReadonlyOrFail } from '../db/index.js';
+import { warn } from '../infrastructure/logger.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
+import { normalizePath } from '../shared/constants.js';
+import { paginateResult } from '../shared/paginate.js';
 
 /**
  * Scan git history and return parsed commit data.

package/src/{communities.js → features/communities.js}

@@ -1,78 +1,8 @@
 import path from 'node:path';
-import Graph from 'graphology';
-import louvain from 'graphology-communities-louvain';
-import {
-  getCallableNodes,
-  getCallEdges,
-  getFileNodesAll,
-  getImportEdges,
-  openReadonlyOrFail,
-} from './db.js';
-import { isTestFile } from './infrastructure/test-filter.js';
-import { paginateResult } from './paginate.js';
-
-// ─── Graph Construction ───────────────────────────────────────────────
-
-/**
- * Build a graphology graph from the codegraph SQLite database.
- *
- * @param {object} db - open better-sqlite3 database (readonly)
- * @param {object} opts
- * @param {boolean} [opts.functions] - Function-level instead of file-level
- * @param {boolean} [opts.noTests] - Exclude test files
- * @returns {Graph}
- */
-function buildGraphologyGraph(db, opts = {}) {
-  const graph = new Graph({ type: 'undirected' });
-
-  if (opts.functions) {
-    // Function-level: nodes = function/method/class symbols, edges = calls
-    let nodes = getCallableNodes(db);
-    if (opts.noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
-
-    const nodeIds = new Set();
-    for (const n of nodes) {
-      const key = String(n.id);
-      graph.addNode(key, { label: n.name, file: n.file, kind: n.kind });
-      nodeIds.add(n.id);
-    }
-
-    const edges = getCallEdges(db);
-    for (const e of edges) {
-      if (!nodeIds.has(e.source_id) || !nodeIds.has(e.target_id)) continue;
-      const src = String(e.source_id);
-      const tgt = String(e.target_id);
-      if (src === tgt) continue;
-      if (!graph.hasEdge(src, tgt)) {
-        graph.addEdge(src, tgt);
-      }
-    }
-  } else {
-    // File-level: nodes = files, edges = imports + imports-type (deduplicated, cross-file)
-    let nodes = getFileNodesAll(db);
-    if (opts.noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
-
-    const nodeIds = new Set();
-    for (const n of nodes) {
-      const key = String(n.id);
-      graph.addNode(key, { label: n.file, file: n.file });
-      nodeIds.add(n.id);
-    }
-
-    const edges = getImportEdges(db);
-    for (const e of edges) {
-      if (!nodeIds.has(e.source_id) || !nodeIds.has(e.target_id)) continue;
-      const src = String(e.source_id);
-      const tgt = String(e.target_id);
-      if (src === tgt) continue;
-      if (!graph.hasEdge(src, tgt)) {
-        graph.addEdge(src, tgt);
-      }
-    }
-  }
-
-  return graph;
-}
+import { openRepo } from '../db/index.js';
+import { louvainCommunities } from '../graph/algorithms/louvain.js';
+import { buildDependencyGraph } from '../graph/builders/dependency.js';
+import { paginateResult } from '../shared/paginate.js';
 
 // ─── Directory Helpers ────────────────────────────────────────────────
 
@@ -96,40 +26,39 @@ function getDirectory(filePath) {
  * @returns {{ communities: object[], modularity: number, drift: object, summary: object }}
  */
 export function communitiesData(customDbPath, opts = {}) {
-  const db = openReadonlyOrFail(customDbPath);
-  const resolution = opts.resolution ?? 1.0;
+  const { repo, close } = openRepo(customDbPath, opts);
   let graph;
   try {
-    graph = buildGraphologyGraph(db, {
-      functions: opts.functions,
+    graph = buildDependencyGraph(repo, {
+      fileLevel: !opts.functions,
       noTests: opts.noTests,
     });
   } finally {
-    db.close();
+    close();
   }
 
   // Handle empty or trivial graphs
-  if (graph.order === 0 || graph.size === 0) {
+  if (graph.nodeCount === 0 || graph.edgeCount === 0) {
     return {
       communities: [],
       modularity: 0,
       drift: { splitCandidates: [], mergeCandidates: [] },
-      summary: { communityCount: 0, modularity: 0, nodeCount: graph.order, driftScore: 0 },
+      summary: { communityCount: 0, modularity: 0, nodeCount: graph.nodeCount, driftScore: 0 },
     };
   }
 
   // Run Louvain
-  const details = louvain.detailed(graph, { resolution });
-  const assignments = details.communities; // node → community id
-  const modularity = details.modularity;
+  const resolution = opts.resolution ?? 1.0;
+  const { assignments, modularity } = louvainCommunities(graph, { resolution });
 
   // Group nodes by community
   const communityMap = new Map(); // community id → node keys[]
-  graph.forEachNode((key) => {
-    const cid = assignments[key];
+  for (const [key] of graph.nodes()) {
+    const cid = assignments.get(key);
+    if (cid == null) continue;
     if (!communityMap.has(cid)) communityMap.set(cid, []);
     communityMap.get(cid).push(key);
-  });
+  }
 
   // Build community objects
   const communities = [];
@@ -139,7 +68,7 @@ export function communitiesData(customDbPath, opts = {}) {
     const dirCounts = {};
     const memberData = [];
     for (const key of members) {
-      const attrs = graph.getNodeAttributes(key);
+      const attrs = graph.getNodeAttrs(key);
       const dir = getDirectory(attrs.file);
       dirCounts[dir] = (dirCounts[dir] || 0) + 1;
       memberData.push({
@@ -196,7 +125,6 @@ export function communitiesData(customDbPath, opts = {}) {
   mergeCandidates.sort((a, b) => b.directoryCount - a.directoryCount);
 
   // Drift score: 0-100 based on how much directory structure diverges from communities
-  // Higher = more drift (directories don't match communities)
   const totalDirs = dirToCommunities.size;
   const splitDirs = splitCandidates.length;
   const splitRatio = totalDirs > 0 ? splitDirs / totalDirs : 0;
@@ -214,7 +142,7 @@ export function communitiesData(customDbPath, opts = {}) {
     summary: {
       communityCount: communities.length,
       modularity: +modularity.toFixed(4),
-      nodeCount: graph.order,
+      nodeCount: graph.nodeCount,
       driftScore,
     },
   };

package/src/{complexity.js → features/complexity.js}

@@ -3,20 +3,20 @@ import path from 'node:path';
 import {
   computeLOCMetrics as _computeLOCMetrics,
   computeMaintainabilityIndex as _computeMaintainabilityIndex,
-} from './ast-analysis/metrics.js';
-import { COMPLEXITY_RULES, HALSTEAD_RULES } from './ast-analysis/rules/index.js';
+} from '../ast-analysis/metrics.js';
+import { COMPLEXITY_RULES, HALSTEAD_RULES } from '../ast-analysis/rules/index.js';
 import {
   findFunctionNode as _findFunctionNode,
   buildExtensionSet,
   buildExtToLangMap,
-} from './ast-analysis/shared.js';
-import { walkWithVisitors } from './ast-analysis/visitor.js';
-import { createComplexityVisitor } from './ast-analysis/visitors/complexity-visitor.js';
-import { loadConfig } from './config.js';
-import { getFunctionNodeId, openReadonlyOrFail } from './db.js';
-import { isTestFile } from './infrastructure/test-filter.js';
-import { info } from './logger.js';
-import { paginateResult } from './paginate.js';
+} from '../ast-analysis/shared.js';
+import { walkWithVisitors } from '../ast-analysis/visitor.js';
+import { createComplexityVisitor } from '../ast-analysis/visitors/complexity-visitor.js';
+import { getFunctionNodeId, openReadonlyOrFail } from '../db/index.js';
+import { loadConfig } from '../infrastructure/config.js';
+import { info } from '../infrastructure/logger.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
+import { paginateResult } from '../shared/paginate.js';
 
 // Re-export rules for backward compatibility
 export { COMPLEXITY_RULES, HALSTEAD_RULES };
@@ -360,12 +360,12 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
     }
   }
   if (needsFallback) {
-    const { createParsers } = await import('./parser.js');
+    const { createParsers } = await import('../domain/parser.js');
     parsers = await createParsers();
     extToLang = buildExtToLangMap();
   }
 
-  const { getParser } = await import('./parser.js');
+  const { getParser } = await import('../domain/parser.js');
 
   const upsert = db.prepare(
     `INSERT OR REPLACE INTO function_complexity
@@ -524,7 +524,7 @@ export function complexityData(customDbPath, opts = {}) {
     const kindFilter = opts.kind || null;
 
     // Load thresholds from config
-    const config = loadConfig(process.cwd());
+    const config = opts.config || loadConfig(process.cwd());
     const thresholds = config.manifesto?.rules || {
       cognitive: { warn: 15, fail: null },
       cyclomatic: { warn: 10, fail: null },

package/src/{dataflow.js → features/dataflow.js}

@@ -11,23 +11,22 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { DATAFLOW_RULES } from './ast-analysis/rules/index.js';
+import { DATAFLOW_RULES } from '../ast-analysis/rules/index.js';
 import {
   makeDataflowRules as _makeDataflowRules,
   buildExtensionSet,
   buildExtToLangMap,
-} from './ast-analysis/shared.js';
-import { walkWithVisitors } from './ast-analysis/visitor.js';
-import { createDataflowVisitor } from './ast-analysis/visitors/dataflow-visitor.js';
-import { hasDataflowTable, openReadonlyOrFail } from './db.js';
-import { isTestFile } from './infrastructure/test-filter.js';
-import { info } from './logger.js';
-import { paginateResult } from './paginate.js';
-import { ALL_SYMBOL_KINDS, normalizeSymbol } from './queries.js';
+} from '../ast-analysis/shared.js';
+import { walkWithVisitors } from '../ast-analysis/visitor.js';
+import { createDataflowVisitor } from '../ast-analysis/visitors/dataflow-visitor.js';
+import { hasDataflowTable, openReadonlyOrFail } from '../db/index.js';
+import { ALL_SYMBOL_KINDS, normalizeSymbol } from '../domain/queries.js';
+import { info } from '../infrastructure/logger.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
+import { paginateResult } from '../shared/paginate.js';
 
 // Re-export for backward compatibility
-export { DATAFLOW_RULES };
-export { _makeDataflowRules as makeDataflowRules };
+export { _makeDataflowRules as makeDataflowRules, DATAFLOW_RULES };
 
 export const DATAFLOW_EXTENSIONS = buildExtensionSet(DATAFLOW_RULES);
 
@@ -89,13 +88,13 @@ export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts)
   }
 
   if (needsFallback) {
-    const { createParsers } = await import('./parser.js');
+    const { createParsers } = await import('../domain/parser.js');
     parsers = await createParsers();
   }
 
   let getParserFn = null;
   if (parsers) {
-    const mod = await import('./parser.js');
+    const mod = await import('../domain/parser.js');
     getParserFn = mod.getParser;
   }