@optave/codegraph 3.1.4 → 3.2.0

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,8 +1,8 @@
 import path from 'node:path';
-import { openReadonlyOrFail } from './db.js';
-import { louvainCommunities } from './graph/algorithms/louvain.js';
-import { buildDependencyGraph } from './graph/builders/dependency.js';
-import { paginateResult } from './paginate.js';
+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 ────────────────────────────────────────────────
 
@@ -11,48 +11,18 @@ function getDirectory(filePath) {
   return dir === '.' ? '(root)' : dir;
 }
 
-// ─── Core Analysis ────────────────────────────────────────────────────
+// ─── Community Building ──────────────────────────────────────────────
 
 /**
- * Run Louvain community detection and return structured data.
- *
- * @param {string} [customDbPath] - Path to graph.db
- * @param {object} [opts]
- * @param {boolean} [opts.functions] - Function-level instead of file-level
- * @param {number}  [opts.resolution] - Louvain resolution (default 1.0)
- * @param {boolean} [opts.noTests] - Exclude test files
- * @param {boolean} [opts.drift] - Drift-only mode (omit community member lists)
- * @param {boolean} [opts.json] - JSON output (used by CLI wrapper only)
- * @returns {{ communities: object[], modularity: number, drift: object, summary: object }}
+ * Group graph nodes by Louvain community assignment and build structured objects.
+ * @param {object} graph - The dependency graph
+ * @param {Map<string, number>} assignments - Node key → community ID
+ * @param {object} opts
+ * @param {boolean} [opts.drift] - If true, omit member lists
+ * @returns {{ communities: object[], communityDirs: Map<number, Set<string>> }}
  */
-export function communitiesData(customDbPath, opts = {}) {
-  const db = openReadonlyOrFail(customDbPath);
-  let graph;
-  try {
-    graph = buildDependencyGraph(db, {
-      fileLevel: !opts.functions,
-      noTests: opts.noTests,
-    });
-  } finally {
-    db.close();
-  }
-
-  // Handle empty or trivial graphs
-  if (graph.nodeCount === 0 || graph.edgeCount === 0) {
-    return {
-      communities: [],
-      modularity: 0,
-      drift: { splitCandidates: [], mergeCandidates: [] },
-      summary: { communityCount: 0, modularity: 0, nodeCount: graph.nodeCount, driftScore: 0 },
-    };
-  }
-
-  // Run Louvain
-  const resolution = opts.resolution ?? 1.0;
-  const { assignments, modularity } = louvainCommunities(graph, { resolution });
-
-  // Group nodes by community
-  const communityMap = new Map(); // community id → node keys[]
+function buildCommunityObjects(graph, assignments, opts) {
+  const communityMap = new Map();
   for (const [key] of graph.nodes()) {
     const cid = assignments.get(key);
     if (cid == null) continue;
@@ -60,9 +30,8 @@ export function communitiesData(customDbPath, opts = {}) {
     communityMap.get(cid).push(key);
   }
 
-  // Build community objects
   const communities = [];
-  const communityDirs = new Map(); // community id → Set<dir>
+  const communityDirs = new Map();
 
   for (const [cid, members] of communityMap) {
     const dirCounts = {};
@@ -88,19 +57,27 @@ export function communitiesData(customDbPath, opts = {}) {
     });
   }
 
-  // Sort by size descending
   communities.sort((a, b) => b.size - a.size);
+  return { communities, communityDirs };
+}
 
-  // ─── Drift Analysis ─────────────────────────────────────────────
+// ─── Drift Analysis ──────────────────────────────────────────────────
 
-  // Split candidates: directories with members in 2+ communities
-  const dirToCommunities = new Map(); // dir → Set<community id>
+/**
+ * Compute split/merge candidates and drift score from community directory data.
+ * @param {object[]} communities - Community objects with `directories`
+ * @param {Map<number, Set<string>>} communityDirs - Community ID → directory set
+ * @returns {{ splitCandidates: object[], mergeCandidates: object[], driftScore: number }}
+ */
+function analyzeDrift(communities, communityDirs) {
+  const dirToCommunities = new Map();
   for (const [cid, dirs] of communityDirs) {
     for (const dir of dirs) {
       if (!dirToCommunities.has(dir)) dirToCommunities.set(dir, new Set());
       dirToCommunities.get(dir).add(cid);
     }
   }
+
   const splitCandidates = [];
   for (const [dir, cids] of dirToCommunities) {
     if (cids.size >= 2) {
@@ -109,7 +86,6 @@ export function communitiesData(customDbPath, opts = {}) {
   }
   splitCandidates.sort((a, b) => b.communityCount - a.communityCount);
 
-  // Merge candidates: communities spanning 2+ directories
   const mergeCandidates = [];
   for (const c of communities) {
     const dirCount = Object.keys(c.directories).length;
@@ -124,17 +100,56 @@ 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
   const totalDirs = dirToCommunities.size;
-  const splitDirs = splitCandidates.length;
-  const splitRatio = totalDirs > 0 ? splitDirs / totalDirs : 0;
-
+  const splitRatio = totalDirs > 0 ? splitCandidates.length / totalDirs : 0;
   const totalComms = communities.length;
-  const mergeComms = mergeCandidates.length;
-  const mergeRatio = totalComms > 0 ? mergeComms / totalComms : 0;
-
+  const mergeRatio = totalComms > 0 ? mergeCandidates.length / totalComms : 0;
   const driftScore = Math.round(((splitRatio + mergeRatio) / 2) * 100);
 
+  return { splitCandidates, mergeCandidates, driftScore };
+}
+
+// ─── Core Analysis ────────────────────────────────────────────────────
+
+/**
+ * Run Louvain community detection and return structured data.
+ *
+ * @param {string} [customDbPath] - Path to graph.db
+ * @param {object} [opts]
+ * @param {boolean} [opts.functions] - Function-level instead of file-level
+ * @param {number}  [opts.resolution] - Louvain resolution (default 1.0)
+ * @param {boolean} [opts.noTests] - Exclude test files
+ * @param {boolean} [opts.drift] - Drift-only mode (omit community member lists)
+ * @param {boolean} [opts.json] - JSON output (used by CLI wrapper only)
+ * @returns {{ communities: object[], modularity: number, drift: object, summary: object }}
+ */
+export function communitiesData(customDbPath, opts = {}) {
+  const { repo, close } = openRepo(customDbPath, opts);
+  let graph;
+  try {
+    graph = buildDependencyGraph(repo, {
+      fileLevel: !opts.functions,
+      noTests: opts.noTests,
+    });
+  } finally {
+    close();
+  }
+
+  if (graph.nodeCount === 0 || graph.edgeCount === 0) {
+    return {
+      communities: [],
+      modularity: 0,
+      drift: { splitCandidates: [], mergeCandidates: [] },
+      summary: { communityCount: 0, modularity: 0, nodeCount: graph.nodeCount, driftScore: 0 },
+    };
+  }
+
+  const resolution = opts.resolution ?? 1.0;
+  const { assignments, modularity } = louvainCommunities(graph, { resolution });
+
+  const { communities, communityDirs } = buildCommunityObjects(graph, assignments, opts);
+  const { splitCandidates, mergeCandidates, driftScore } = analyzeDrift(communities, communityDirs);
+
   const base = {
     communities: opts.drift ? [] : communities,
     modularity: +modularity.toFixed(4),

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

@@ -3,20 +3,21 @@ 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 { buildFileConditionSQL } from '../db/query-builder.js';
+import { loadConfig } from '../infrastructure/config.js';
+import { debug, 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 };
@@ -330,42 +331,139 @@ export function computeAllMetrics(functionNode, langId) {
  */
 export { _findFunctionNode as findFunctionNode };
 
-/**
- * Re-parse changed files with WASM tree-sitter, find function AST subtrees,
- * compute complexity, and upsert into function_complexity table.
- *
- * @param {object} db - open better-sqlite3 database (read-write)
- * @param {Map<string, object>} fileSymbols - Map<relPath, { definitions, ... }>
- * @param {string} rootDir - absolute project root path
- * @param {object} [engineOpts] - engine options (unused; always uses WASM for AST)
- */
-export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOpts) {
-  // Only initialize WASM parsers if some files lack both a cached tree AND pre-computed complexity
-  let parsers = null;
-  let extToLang = null;
-  let needsFallback = false;
+async function initWasmParsersIfNeeded(fileSymbols) {
   for (const [relPath, symbols] of fileSymbols) {
     if (!symbols._tree) {
-      // Only consider files whose language actually has complexity rules
       const ext = path.extname(relPath).toLowerCase();
       if (!COMPLEXITY_EXTENSIONS.has(ext)) continue;
-      // Check if all function/method defs have pre-computed complexity (native engine)
       const hasPrecomputed = symbols.definitions.every(
         (d) => (d.kind !== 'function' && d.kind !== 'method') || d.complexity,
       );
       if (!hasPrecomputed) {
-        needsFallback = true;
-        break;
+        const { createParsers } = await import('../domain/parser.js');
+        const parsers = await createParsers();
+        const extToLang = buildExtToLangMap();
+        return { parsers, extToLang };
       }
     }
   }
-  if (needsFallback) {
-    const { createParsers } = await import('./parser.js');
-    parsers = await createParsers();
-    extToLang = buildExtToLangMap();
+  return { parsers: null, extToLang: null };
+}
+
+function getTreeForFile(symbols, relPath, rootDir, parsers, extToLang, getParser) {
+  let tree = symbols._tree;
+  let langId = symbols._langId;
+
+  const allPrecomputed = symbols.definitions.every(
+    (d) => (d.kind !== 'function' && d.kind !== 'method') || d.complexity,
+  );
+
+  if (!allPrecomputed && !tree) {
+    const ext = path.extname(relPath).toLowerCase();
+    if (!COMPLEXITY_EXTENSIONS.has(ext)) return null;
+    if (!extToLang) return null;
+    langId = extToLang.get(ext);
+    if (!langId) return null;
+
+    const absPath = path.join(rootDir, relPath);
+    let code;
+    try {
+      code = fs.readFileSync(absPath, 'utf-8');
+    } catch (e) {
+      debug(`complexity: cannot read ${relPath}: ${e.message}`);
+      return null;
+    }
+
+    const parser = getParser(parsers, absPath);
+    if (!parser) return null;
+
+    try {
+      tree = parser.parse(code);
+    } catch (e) {
+      debug(`complexity: parse failed for ${relPath}: ${e.message}`);
+      return null;
+    }
   }
 
-  const { getParser } = await import('./parser.js');
+  return { tree, langId };
+}
+
+function upsertPrecomputedComplexity(db, upsert, def, relPath) {
+  const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+  if (!nodeId) return 0;
+  const ch = def.complexity.halstead;
+  const cl = def.complexity.loc;
+  upsert.run(
+    nodeId,
+    def.complexity.cognitive,
+    def.complexity.cyclomatic,
+    def.complexity.maxNesting ?? 0,
+    cl ? cl.loc : 0,
+    cl ? cl.sloc : 0,
+    cl ? cl.commentLines : 0,
+    ch ? ch.n1 : 0,
+    ch ? ch.n2 : 0,
+    ch ? ch.bigN1 : 0,
+    ch ? ch.bigN2 : 0,
+    ch ? ch.vocabulary : 0,
+    ch ? ch.length : 0,
+    ch ? ch.volume : 0,
+    ch ? ch.difficulty : 0,
+    ch ? ch.effort : 0,
+    ch ? ch.bugs : 0,
+    def.complexity.maintainabilityIndex ?? 0,
+  );
+  return 1;
+}
+
+function upsertAstComplexity(db, upsert, def, relPath, tree, langId, rules) {
+  if (!tree || !rules) return 0;
+
+  const funcNode = _findFunctionNode(tree.rootNode, def.line, def.endLine, rules);
+  if (!funcNode) return 0;
+
+  const metrics = computeAllMetrics(funcNode, langId);
+  if (!metrics) return 0;
+
+  const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+  if (!nodeId) return 0;
+
+  const h = metrics.halstead;
+  upsert.run(
+    nodeId,
+    metrics.cognitive,
+    metrics.cyclomatic,
+    metrics.maxNesting,
+    metrics.loc.loc,
+    metrics.loc.sloc,
+    metrics.loc.commentLines,
+    h ? h.n1 : 0,
+    h ? h.n2 : 0,
+    h ? h.bigN1 : 0,
+    h ? h.bigN2 : 0,
+    h ? h.vocabulary : 0,
+    h ? h.length : 0,
+    h ? h.volume : 0,
+    h ? h.difficulty : 0,
+    h ? h.effort : 0,
+    h ? h.bugs : 0,
+    metrics.mi,
+  );
+  return 1;
+}
+
+/**
+ * Re-parse changed files with WASM tree-sitter, find function AST subtrees,
+ * compute complexity, and upsert into function_complexity table.
+ *
+ * @param {object} db - open better-sqlite3 database (read-write)
+ * @param {Map<string, object>} fileSymbols - Map<relPath, { definitions, ... }>
+ * @param {string} rootDir - absolute project root path
+ * @param {object} [engineOpts] - engine options (unused; always uses WASM for AST)
+ */
+export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOpts) {
+  const { parsers, extToLang } = await initWasmParsersIfNeeded(fileSymbols);
+  const { getParser } = await import('../domain/parser.js');
 
   const upsert = db.prepare(
     `INSERT OR REPLACE INTO function_complexity
@@ -381,39 +479,9 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
 
   const tx = db.transaction(() => {
     for (const [relPath, symbols] of fileSymbols) {
-      // Check if all function/method defs have pre-computed complexity
-      const allPrecomputed = symbols.definitions.every(
-        (d) => (d.kind !== 'function' && d.kind !== 'method') || d.complexity,
-      );
-
-      let tree = symbols._tree;
-      let langId = symbols._langId;
-
-      // Only attempt WASM fallback if we actually need AST-based computation
-      if (!allPrecomputed && !tree) {
-        const ext = path.extname(relPath).toLowerCase();
-        if (!COMPLEXITY_EXTENSIONS.has(ext)) continue; // Language has no complexity rules
-        if (!extToLang) continue; // No WASM parsers available
-        langId = extToLang.get(ext);
-        if (!langId) continue;
-
-        const absPath = path.join(rootDir, relPath);
-        let code;
-        try {
-          code = fs.readFileSync(absPath, 'utf-8');
-        } catch {
-          continue;
-        }
-
-        const parser = getParser(parsers, absPath);
-        if (!parser) continue;
-
-        try {
-          tree = parser.parse(code);
-        } catch {
-          continue;
-        }
-      }
+      const result = getTreeForFile(symbols, relPath, rootDir, parsers, extToLang, getParser);
+      const tree = result ? result.tree : null;
+      const langId = result ? result.langId : null;
 
       const rules = langId ? COMPLEXITY_RULES.get(langId) : null;
 
@@ -421,71 +489,11 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
         if (def.kind !== 'function' && def.kind !== 'method') continue;
         if (!def.line) continue;
 
-        // Use pre-computed complexity from native engine if available
         if (def.complexity) {
-          const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-          if (!nodeId) continue;
-          const ch = def.complexity.halstead;
-          const cl = def.complexity.loc;
-          upsert.run(
-            nodeId,
-            def.complexity.cognitive,
-            def.complexity.cyclomatic,
-            def.complexity.maxNesting ?? 0,
-            cl ? cl.loc : 0,
-            cl ? cl.sloc : 0,
-            cl ? cl.commentLines : 0,
-            ch ? ch.n1 : 0,
-            ch ? ch.n2 : 0,
-            ch ? ch.bigN1 : 0,
-            ch ? ch.bigN2 : 0,
-            ch ? ch.vocabulary : 0,
-            ch ? ch.length : 0,
-            ch ? ch.volume : 0,
-            ch ? ch.difficulty : 0,
-            ch ? ch.effort : 0,
-            ch ? ch.bugs : 0,
-            def.complexity.maintainabilityIndex ?? 0,
-          );
-          analyzed++;
-          continue;
+          analyzed += upsertPrecomputedComplexity(db, upsert, def, relPath);
+        } else {
+          analyzed += upsertAstComplexity(db, upsert, def, relPath, tree, langId, rules);
         }
-
-        // Fallback: compute from AST tree
-        if (!tree || !rules) continue;
-
-        const funcNode = _findFunctionNode(tree.rootNode, def.line, def.endLine, rules);
-        if (!funcNode) continue;
-
-        // Single-pass: complexity + Halstead + LOC + MI in one DFS walk
-        const metrics = computeAllMetrics(funcNode, langId);
-        if (!metrics) continue;
-
-        const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-        if (!nodeId) continue;
-
-        const h = metrics.halstead;
-        upsert.run(
-          nodeId,
-          metrics.cognitive,
-          metrics.cyclomatic,
-          metrics.maxNesting,
-          metrics.loc.loc,
-          metrics.loc.sloc,
-          metrics.loc.commentLines,
-          h ? h.n1 : 0,
-          h ? h.n2 : 0,
-          h ? h.bigN1 : 0,
-          h ? h.bigN2 : 0,
-          h ? h.vocabulary : 0,
-          h ? h.length : 0,
-          h ? h.volume : 0,
-          h ? h.difficulty : 0,
-          h ? h.effort : 0,
-          h ? h.bugs : 0,
-          metrics.mi,
-        );
-        analyzed++;
       }
     }
   });
@@ -524,7 +532,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 },
@@ -547,9 +555,10 @@ export function complexityData(customDbPath, opts = {}) {
       where += ' AND n.name LIKE ?';
       params.push(`%${target}%`);
     }
-    if (fileFilter) {
-      where += ' AND n.file LIKE ?';
-      params.push(`%${fileFilter}%`);
+    {
+      const fc = buildFileConditionSQL(fileFilter, 'n.file');
+      where += fc.sql;
+      params.push(...fc.params);
     }
     if (kindFilter) {
       where += ' AND n.kind = ?';
@@ -606,13 +615,14 @@ export function complexityData(customDbPath, opts = {}) {
          ORDER BY ${orderBy}`,
         )
         .all(...params);
-    } catch {
+    } catch (e) {
+      debug(`complexity query failed (table may not exist): ${e.message}`);
       // Check if graph has nodes even though complexity table is missing/empty
       let hasGraph = false;
       try {
         hasGraph = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c > 0;
-      } catch {
-        /* ignore */
+      } catch (e2) {
+        debug(`nodes table check failed: ${e2.message}`);
       }
       return { functions: [], summary: null, thresholds, hasGraph };
     }
@@ -701,8 +711,8 @@ export function complexityData(customDbPath, opts = {}) {
           ).length,
         };
       }
-    } catch {
-      /* ignore */
+    } catch (e) {
+      debug(`complexity summary query failed: ${e.message}`);
     }
 
     // When summary is null (no complexity rows), check if graph has nodes
@@ -710,8 +720,8 @@ export function complexityData(customDbPath, opts = {}) {
     if (summary === null) {
       try {
         hasGraph = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c > 0;
-      } catch {
-        /* ignore */
+      } catch (e) {
+        debug(`nodes table check failed: ${e.message}`);
       }
     }
 
@@ -753,9 +763,10 @@ export function* iterComplexity(customDbPath, opts = {}) {
       where += ' AND n.name LIKE ?';
       params.push(`%${opts.target}%`);
     }
-    if (opts.file) {
-      where += ' AND n.file LIKE ?';
-      params.push(`%${opts.file}%`);
+    {
+      const fc = buildFileConditionSQL(opts.file, 'n.file');
+      where += fc.sql;
+      params.push(...fc.params);
     }
     if (opts.kind) {
       where += ' AND n.kind = ?';