@optave/codegraph 3.11.0 → 3.11.1

package/src/domain/analysis/module-map.ts

@@ -4,7 +4,7 @@ import { loadConfig } from '../../infrastructure/config.js';
 import { debug } from '../../infrastructure/logger.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { DEAD_ROLE_PREFIX } from '../../shared/kinds.js';
-import type { BetterSqlite3Database } from '../../types.js';
+import type { BetterSqlite3Database, NativeDatabase } from '../../types.js';
 import { findCycles } from '../graph/cycles.js';
 import { LANGUAGE_REGISTRY } from '../parser.js';
 
@@ -198,30 +198,13 @@ function computeQualityMetrics(
   ).c;
   const callConfidence = totalCallEdges > 0 ? highConfCallEdges / totalCallEdges : 0;
 
-  const fpRows = db
-    .prepare(`
-      SELECT n.name, n.file, n.line, COUNT(e.source_id) as caller_count
-      FROM nodes n
-      LEFT JOIN edges e ON n.id = e.target_id AND e.kind = 'calls'
-      WHERE n.kind IN ('function', 'method')
-      GROUP BY n.id
-      HAVING caller_count > ?
-      ORDER BY caller_count DESC
-    `)
-    .all(fpThreshold) as Array<{ name: string; file: string; line: number; caller_count: number }>;
-  const falsePositiveWarnings = fpRows
-    .filter((r) =>
-      FALSE_POSITIVE_NAMES.has(r.name.includes('.') ? r.name.split('.').pop()! : r.name),
-    )
-    .map((r) => ({ name: r.name, file: r.file, line: r.line, callerCount: r.caller_count }));
+  const falsePositiveWarnings = buildFalsePositiveWarnings(queryFalsePositiveRows(db, fpThreshold));
 
   let fpEdgeCount = 0;
   for (const fp of falsePositiveWarnings) fpEdgeCount += fp.callerCount;
   const falsePositiveRatio = totalCallEdges > 0 ? fpEdgeCount / totalCallEdges : 0;
 
-  const score = Math.round(
-    callerCoverage * 40 + callConfidence * 40 + (1 - falsePositiveRatio) * 20,
-  );
+  const score = computeQualityScore(callerCoverage, callConfidence, falsePositiveRatio);
 
   return {
     score,
@@ -347,6 +330,169 @@ export function moduleMapData(customDbPath: string, limit = 20, opts: { noTests?
   }
 }
 
+type FalsePositiveRow = { name: string; file: string; line: number; caller_count: number };
+
+/** SQL query for false-positive caller counts above a threshold (shared by native and JS paths). */
+function queryFalsePositiveRows(
+  db: BetterSqlite3Database,
+  fpThreshold: number,
+): FalsePositiveRow[] {
+  return db
+    .prepare(`
+      SELECT n.name, n.file, n.line, COUNT(e.source_id) as caller_count
+      FROM nodes n
+      LEFT JOIN edges e ON n.id = e.target_id AND e.kind = 'calls'
+      WHERE n.kind IN ('function', 'method')
+      GROUP BY n.id
+      HAVING caller_count > ?
+      ORDER BY caller_count DESC
+    `)
+    .all(fpThreshold) as FalsePositiveRow[];
+}
+
+/** Filter false-positive rows by the configured name set and shape them for the report. */
+function buildFalsePositiveWarnings(rows: FalsePositiveRow[]) {
+  return rows
+    .filter((r) =>
+      FALSE_POSITIVE_NAMES.has(r.name.includes('.') ? r.name.split('.').pop()! : r.name),
+    )
+    .map((r) => ({ name: r.name, file: r.file, line: r.line, callerCount: r.caller_count }));
+}
+
+/** Compute the composite quality score (0-100) from coverage, confidence, and FP ratio. */
+function computeQualityScore(
+  callerCoverage: number,
+  callConfidence: number,
+  falsePositiveRatio: number,
+): number {
+  return Math.round(callerCoverage * 40 + callConfidence * 40 + (1 - falsePositiveRatio) * 20);
+}
+
+/** Aggregate role counts and derive the `dead` total. */
+function aggregateRolesFromNative(roleCounts: Array<{ role: string; count: number }>) {
+  const roles: Record<string, number> & { dead?: number } = {};
+  let deadTotal = 0;
+  for (const r of roleCounts) {
+    roles[r.role] = r.count;
+    if (r.role.startsWith(DEAD_ROLE_PREFIX)) deadTotal += r.count;
+  }
+  if (deadTotal > 0) roles.dead = deadTotal;
+  return roles;
+}
+
+type NativeGraphStatsFn = NonNullable<NativeDatabase['getGraphStats']>;
+type NativeGraphStats = ReturnType<NativeGraphStatsFn>;
+
+/** Build the native fast-path stats result by combining native aggregations with JS-only sections. */
+function buildStatsFromNative(
+  db: BetterSqlite3Database,
+  nativeStats: NativeGraphStats,
+  config: any,
+  jsSections: {
+    files: ReturnType<typeof countFilesByLanguage>;
+    fileCycles: unknown[];
+    fnCycles: unknown[];
+  },
+) {
+  const s = nativeStats;
+  const nodesByKind: Record<string, number> = {};
+  for (const k of s.nodesByKind) nodesByKind[k.kind] = k.count;
+  const edgesByKind: Record<string, number> = {};
+  for (const k of s.edgesByKind) edgesByKind[k.kind] = k.count;
+  const roles = aggregateRolesFromNative(s.roleCounts);
+
+  const callerCoverage =
+    s.quality.callableTotal > 0 ? s.quality.callableWithCallers / s.quality.callableTotal : 0;
+  const callConfidence =
+    s.quality.callEdges > 0 ? s.quality.highConfCallEdges / s.quality.callEdges : 0;
+
+  // False-positive analysis still uses JS (needs FALSE_POSITIVE_NAMES set)
+  const fpThreshold = config.analysis?.falsePositiveCallers ?? FALSE_POSITIVE_CALLER_THRESHOLD;
+  const falsePositiveWarnings = buildFalsePositiveWarnings(queryFalsePositiveRows(db, fpThreshold));
+  let fpEdgeCount = 0;
+  for (const fp of falsePositiveWarnings) fpEdgeCount += fp.callerCount;
+  const falsePositiveRatio = s.quality.callEdges > 0 ? fpEdgeCount / s.quality.callEdges : 0;
+  const score = computeQualityScore(callerCoverage, callConfidence, falsePositiveRatio);
+
+  return {
+    nodes: { total: s.totalNodes, byKind: nodesByKind },
+    edges: { total: s.totalEdges, byKind: edgesByKind },
+    files: jsSections.files,
+    cycles: { fileLevel: jsSections.fileCycles.length, functionLevel: jsSections.fnCycles.length },
+    hotspots: s.hotspots.map((h) => ({ file: h.file, fanIn: h.fanIn, fanOut: h.fanOut })),
+    embeddings: s.embeddings
+      ? {
+          count: s.embeddings.count,
+          model: s.embeddings.model,
+          dim: s.embeddings.dim,
+          builtAt: s.embeddings.builtAt,
+        }
+      : null,
+    quality: {
+      score,
+      callerCoverage: {
+        ratio: callerCoverage,
+        covered: s.quality.callableWithCallers,
+        total: s.quality.callableTotal,
+      },
+      callConfidence: {
+        ratio: callConfidence,
+        highConf: s.quality.highConfCallEdges,
+        total: s.quality.callEdges,
+      },
+      falsePositiveWarnings,
+    },
+    roles,
+    complexity: s.complexity
+      ? {
+          analyzed: s.complexity.analyzed,
+          avgCognitive: s.complexity.avgCognitive,
+          avgCyclomatic: s.complexity.avgCyclomatic,
+          maxCognitive: s.complexity.maxCognitive,
+          maxCyclomatic: s.complexity.maxCyclomatic,
+          avgMI: s.complexity.avgMi,
+          minMI: s.complexity.minMi,
+        }
+      : null,
+  };
+}
+
+/** Build the JS-fallback stats result using SQL aggregations from the helpers above. */
+function buildStatsFromJs(
+  db: BetterSqlite3Database,
+  noTests: boolean,
+  config: any,
+  jsSections: {
+    files: ReturnType<typeof countFilesByLanguage>;
+    fileCycles: unknown[];
+    fnCycles: unknown[];
+  },
+) {
+  const testFilter = testFilterSQL('n.file', noTests);
+
+  const { total: totalNodes, byKind: nodesByKind } = countNodesByKind(db, noTests);
+  const { total: totalEdges, byKind: edgesByKind } = countEdgesByKind(db, noTests);
+
+  const hotspots = findHotspots(db, noTests, 5);
+  const embeddings = getEmbeddingsInfo(db);
+  const fpThreshold = config.analysis?.falsePositiveCallers ?? FALSE_POSITIVE_CALLER_THRESHOLD;
+  const quality = computeQualityMetrics(db, testFilter, fpThreshold);
+  const roles = countRoles(db, noTests);
+  const complexity = getComplexitySummary(db, testFilter);
+
+  return {
+    nodes: { total: totalNodes, byKind: nodesByKind },
+    edges: { total: totalEdges, byKind: edgesByKind },
+    files: jsSections.files,
+    cycles: { fileLevel: jsSections.fileCycles.length, functionLevel: jsSections.fnCycles.length },
+    hotspots,
+    embeddings,
+    quality,
+    roles,
+    complexity,
+  };
+}
+
 export function statsData(customDbPath: string, opts: { noTests?: boolean; config?: any } = {}) {
   const { db, nativeDb, close } = openReadonlyWithNative(customDbPath);
   try {
@@ -354,127 +500,16 @@ export function statsData(customDbPath: string, opts: { noTests?: boolean; confi
     const config = opts.config || loadConfig();
 
     // These always need JS (non-SQL logic)
-    const files = countFilesByLanguage(db, noTests);
-    const fileCycles = findCycles(db, { fileLevel: true, noTests });
-    const fnCycles = findCycles(db, { fileLevel: false, noTests });
-
-    // ── Native fast path: batch all SQL aggregations in one napi call ──
-    if (nativeDb?.getGraphStats) {
-      const s = nativeDb.getGraphStats(noTests);
-      const nodesByKind: Record<string, number> = {};
-      for (const k of s.nodesByKind) nodesByKind[k.kind] = k.count;
-      const edgesByKind: Record<string, number> = {};
-      for (const k of s.edgesByKind) edgesByKind[k.kind] = k.count;
-      const roles: Record<string, number> & { dead?: number } = {};
-      let deadTotal = 0;
-      for (const r of s.roleCounts) {
-        roles[r.role] = r.count;
-        if (r.role.startsWith(DEAD_ROLE_PREFIX)) deadTotal += r.count;
-      }
-      if (deadTotal > 0) roles.dead = deadTotal;
-
-      const callerCoverage =
-        s.quality.callableTotal > 0 ? s.quality.callableWithCallers / s.quality.callableTotal : 0;
-      const callConfidence =
-        s.quality.callEdges > 0 ? s.quality.highConfCallEdges / s.quality.callEdges : 0;
-
-      // False-positive analysis still uses JS (needs FALSE_POSITIVE_NAMES set)
-      const fpThreshold = config.analysis?.falsePositiveCallers ?? FALSE_POSITIVE_CALLER_THRESHOLD;
-      const fpRows = db
-        .prepare(`
-          SELECT n.name, n.file, n.line, COUNT(e.source_id) as caller_count
-          FROM nodes n
-          LEFT JOIN edges e ON n.id = e.target_id AND e.kind = 'calls'
-          WHERE n.kind IN ('function', 'method')
-          GROUP BY n.id
-          HAVING caller_count > ?
-          ORDER BY caller_count DESC
-        `)
-        .all(fpThreshold) as Array<{
-        name: string;
-        file: string;
-        line: number;
-        caller_count: number;
-      }>;
-      const falsePositiveWarnings = fpRows
-        .filter((r) =>
-          FALSE_POSITIVE_NAMES.has(r.name.includes('.') ? r.name.split('.').pop()! : r.name),
-        )
-        .map((r) => ({ name: r.name, file: r.file, line: r.line, callerCount: r.caller_count }));
-      let fpEdgeCount = 0;
-      for (const fp of falsePositiveWarnings) fpEdgeCount += fp.callerCount;
-      const falsePositiveRatio = s.quality.callEdges > 0 ? fpEdgeCount / s.quality.callEdges : 0;
-      const score = Math.round(
-        callerCoverage * 40 + callConfidence * 40 + (1 - falsePositiveRatio) * 20,
-      );
-
-      return {
-        nodes: { total: s.totalNodes, byKind: nodesByKind },
-        edges: { total: s.totalEdges, byKind: edgesByKind },
-        files,
-        cycles: { fileLevel: fileCycles.length, functionLevel: fnCycles.length },
-        hotspots: s.hotspots.map((h) => ({ file: h.file, fanIn: h.fanIn, fanOut: h.fanOut })),
-        embeddings: s.embeddings
-          ? {
-              count: s.embeddings.count,
-              model: s.embeddings.model,
-              dim: s.embeddings.dim,
-              builtAt: s.embeddings.builtAt,
-            }
-          : null,
-        quality: {
-          score,
-          callerCoverage: {
-            ratio: callerCoverage,
-            covered: s.quality.callableWithCallers,
-            total: s.quality.callableTotal,
-          },
-          callConfidence: {
-            ratio: callConfidence,
-            highConf: s.quality.highConfCallEdges,
-            total: s.quality.callEdges,
-          },
-          falsePositiveWarnings,
-        },
-        roles,
-        complexity: s.complexity
-          ? {
-              analyzed: s.complexity.analyzed,
-              avgCognitive: s.complexity.avgCognitive,
-              avgCyclomatic: s.complexity.avgCyclomatic,
-              maxCognitive: s.complexity.maxCognitive,
-              maxCyclomatic: s.complexity.maxCyclomatic,
-              avgMI: s.complexity.avgMi,
-              minMI: s.complexity.minMi,
-            }
-          : null,
-      };
-    }
-
-    // ── JS fallback ───────────────────────────────────────────────────
-    const testFilter = testFilterSQL('n.file', noTests);
-
-    const { total: totalNodes, byKind: nodesByKind } = countNodesByKind(db, noTests);
-    const { total: totalEdges, byKind: edgesByKind } = countEdgesByKind(db, noTests);
-
-    const hotspots = findHotspots(db, noTests, 5);
-    const embeddings = getEmbeddingsInfo(db);
-    const fpThreshold = config.analysis?.falsePositiveCallers ?? FALSE_POSITIVE_CALLER_THRESHOLD;
-    const quality = computeQualityMetrics(db, testFilter, fpThreshold);
-    const roles = countRoles(db, noTests);
-    const complexity = getComplexitySummary(db, testFilter);
-
-    return {
-      nodes: { total: totalNodes, byKind: nodesByKind },
-      edges: { total: totalEdges, byKind: edgesByKind },
-      files,
-      cycles: { fileLevel: fileCycles.length, functionLevel: fnCycles.length },
-      hotspots,
-      embeddings,
-      quality,
-      roles,
-      complexity,
+    const jsSections = {
+      files: countFilesByLanguage(db, noTests),
+      fileCycles: findCycles(db, { fileLevel: true, noTests }),
+      fnCycles: findCycles(db, { fileLevel: false, noTests }),
     };
+
+    const nativeStats = nativeDb?.getGraphStats?.(noTests);
+    return nativeStats
+      ? buildStatsFromNative(db, nativeStats, config, jsSections)
+      : buildStatsFromJs(db, noTests, config, jsSections);
   } finally {
     close();
   }

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

@@ -76,108 +76,117 @@ export function passesIncludeExclude(
   return true;
 }
 
+/** Per-walk state computed once at the top-level invocation. */
+interface CollectContext {
+  readonly rootDir: string;
+  readonly includeRegexes: readonly RegExp[];
+  readonly excludeRegexes: readonly RegExp[];
+  readonly hasGlobFilters: boolean;
+  readonly extraIgnore: Set<string> | null;
+  readonly visited: Set<string>;
+}
+
+/** Detect a symlink loop for `dir`. Returns true if `dir` was already visited. */
+function isSymlinkLoop(dir: string, visited: Set<string>): boolean {
+  let realDir: string;
+  try {
+    realDir = fs.realpathSync(dir);
+  } catch {
+    return true;
+  }
+  if (visited.has(realDir)) {
+    warn(`Symlink loop detected, skipping: ${dir}`);
+    return true;
+  }
+  visited.add(realDir);
+  return false;
+}
+
+/** Read directory entries, returning null on error (already logged). */
+function readDirSafe(dir: string): fs.Dirent[] | null {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err: unknown) {
+    warn(`Cannot read directory ${dir}: ${(err as Error).message}`);
+    return null;
+  }
+}
+
+/** True if `entry` is a source file we should collect under `ctx`. */
+function isCollectableSourceFile(full: string, entry: fs.Dirent, ctx: CollectContext): boolean {
+  if (!EXTENSIONS.has(path.extname(entry.name))) return false;
+  if (!ctx.hasGlobFilters) return true;
+  const rel = normalizePath(path.relative(ctx.rootDir, full));
+  return passesIncludeExclude(rel, ctx.includeRegexes, ctx.excludeRegexes);
+}
+
+function walkCollect(
+  dir: string,
+  files: string[],
+  directories: Set<string> | null,
+  ctx: CollectContext,
+): void {
+  if (isSymlinkLoop(dir, ctx.visited)) return;
+
+  const entries = readDirSafe(dir);
+  if (!entries) return;
+
+  let hasFiles = false;
+  for (const entry of entries) {
+    if (shouldSkipEntry(entry, ctx.extraIgnore)) continue;
+
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkCollect(full, files, directories, ctx);
+    } else if (isCollectableSourceFile(full, entry, ctx)) {
+      files.push(full);
+      hasFiles = true;
+    }
+  }
+  if (directories && hasFiles) {
+    directories.add(dir);
+  }
+}
+
 /**
  * Recursively collect all source files under `dir`.
  * When `directories` is a Set, also tracks which directories contain files.
  *
- * The first invocation establishes `dir` as the project root against which
- * `config.include` / `config.exclude` globs are matched.
+ * `dir` establishes the project root against which `config.include` /
+ * `config.exclude` globs are matched.
  */
 export function collectFiles(
   dir: string,
   files: string[],
   config: Partial<CodegraphConfig>,
   directories: Set<string>,
-  _visited?: Set<string>,
-  _rootDir?: string,
-  _includeRegexes?: readonly RegExp[],
-  _excludeRegexes?: readonly RegExp[],
 ): { files: string[]; directories: Set<string> };
 export function collectFiles(
   dir: string,
   files?: string[],
   config?: Partial<CodegraphConfig>,
   directories?: null,
-  _visited?: Set<string>,
-  _rootDir?: string,
-  _includeRegexes?: readonly RegExp[],
-  _excludeRegexes?: readonly RegExp[],
 ): string[];
 export function collectFiles(
   dir: string,
   files: string[] = [],
   config: Partial<CodegraphConfig> = {},
   directories: Set<string> | null = null,
-  _visited: Set<string> = new Set(),
-  _rootDir?: string,
-  _includeRegexes?: readonly RegExp[],
-  _excludeRegexes?: readonly RegExp[],
 ): string[] | { files: string[]; directories: Set<string> } {
   const trackDirs = directories instanceof Set;
-  let hasFiles = false;
-
-  // First call: compute root and compile include/exclude patterns once,
-  // then pass them down recursive calls so we don't recompile per directory.
-  const rootDir = _rootDir ?? dir;
-  const includeRegexes = _includeRegexes ?? compileGlobs(config.include);
-  const excludeRegexes = _excludeRegexes ?? compileGlobs(config.exclude);
-  const hasGlobFilters = includeRegexes.length > 0 || excludeRegexes.length > 0;
-
-  // 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;
-  }
+  const includeRegexes = compileGlobs(config.include);
+  const excludeRegexes = compileGlobs(config.exclude);
+  const ctx: CollectContext = {
+    rootDir: dir,
+    includeRegexes,
+    excludeRegexes,
+    hasGlobFilters: includeRegexes.length > 0 || excludeRegexes.length > 0,
+    extraIgnore: config.ignoreDirs ? new Set(config.ignoreDirs) : null,
+    visited: new Set(),
+  };
 
-  for (const entry of entries) {
-    if (shouldSkipEntry(entry, extraIgnore)) continue;
+  walkCollect(dir, files, trackDirs ? (directories as Set<string>) : null, ctx);
 
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (trackDirs) {
-        collectFiles(
-          full,
-          files,
-          config,
-          directories as Set<string>,
-          _visited,
-          rootDir,
-          includeRegexes,
-          excludeRegexes,
-        );
-      } else {
-        collectFiles(full, files, config, null, _visited, rootDir, includeRegexes, excludeRegexes);
-      }
-    } else if (EXTENSIONS.has(path.extname(entry.name))) {
-      if (hasGlobFilters) {
-        const rel = normalizePath(path.relative(rootDir, full));
-        if (!passesIncludeExclude(rel, includeRegexes, excludeRegexes)) continue;
-      }
-      files.push(full);
-      hasFiles = true;
-    }
-  }
-  if (trackDirs && hasFiles) {
-    (directories as Set<string>).add(dir);
-  }
   return trackDirs ? { files, directories: directories as Set<string> } : files;
 }