@optave/codegraph 3.12.0 → 3.15.0

package/src/features/manifesto.ts

@@ -157,17 +157,27 @@ interface ManifestoOpts {
   offset?: number;
 }
 
-function evaluateFunctionRules(
-  db: BetterSqlite3Database,
+interface EvaluateRulesContext {
+  defs: RuleDef[];
+  rows: Array<Record<string, unknown>>;
+}
+
+/**
+ * Shared rule-evaluation loop used by both evaluateFunctionRules and evaluateFileRules.
+ * Iterates rows, applies threshold checks for each active rule definition, and
+ * accumulates violations + per-rule worst-status tracking into ruleResults.
+ */
+function evaluateRules(
+  ctx: EvaluateRulesContext,
   rules: ResolvedRules,
-  opts: ManifestoOpts,
   violations: Violation[],
   ruleResults: RuleResult[],
 ): void {
-  const functionDefs = RULE_DEFS.filter((d) => d.level === 'function');
-  const activeDefs = functionDefs.filter((d) => isEnabled(rules[d.name]!));
+  const { defs, rows } = ctx;
+  const activeDefs = defs.filter((d) => isEnabled(rules[d.name]!));
+
   if (activeDefs.length === 0) {
-    for (const def of functionDefs) {
+    for (const def of defs) {
       ruleResults.push({
         name: def.name,
         level: def.level,
@@ -179,39 +189,9 @@ function evaluateFunctionRules(
     return;
   }
 
-  let where = "WHERE n.kind IN ('function','method')";
-  const params: unknown[] = [];
-  if (opts.noTests) where += NO_TEST_SQL;
-  {
-    const fc = buildFileConditionSQL(opts.file as string, 'n.file');
-    where += fc.sql;
-    params.push(...fc.params);
-  }
-  if (opts.kind) {
-    where += ' AND n.kind = ?';
-    params.push(opts.kind);
-  }
-
-  let rows: Array<Record<string, unknown>>;
-  try {
-    rows = db
-      .prepare(
-        `SELECT n.name, n.kind, n.file, n.line,
-                fc.cognitive, fc.cyclomatic, fc.max_nesting
-         FROM function_complexity fc
-         JOIN nodes n ON fc.node_id = n.id
-         ${where}`,
-      )
-      .all(...params) as Array<Record<string, unknown>>;
-  } catch (err: unknown) {
-    debug(`manifesto function query failed: ${(err as Error).message}`);
-    rows = [];
-  }
-
-  // Track worst status per rule
   const worst: Record<string, string> = {};
   const counts: Record<string, number> = {};
-  for (const def of functionDefs) {
+  for (const def of defs) {
     worst[def.name] = 'pass';
     counts[def.name] = 0;
   }
@@ -234,7 +214,7 @@ function evaluateFunctionRules(
     }
   }
 
-  for (const def of functionDefs) {
+  for (const def of defs) {
     ruleResults.push({
       name: def.name,
       level: def.level,
@@ -245,6 +225,60 @@ function evaluateFunctionRules(
   }
 }
 
+function evaluateFunctionRules(
+  db: BetterSqlite3Database,
+  rules: ResolvedRules,
+  opts: ManifestoOpts,
+  violations: Violation[],
+  ruleResults: RuleResult[],
+): void {
+  const defs = RULE_DEFS.filter((d) => d.level === 'function');
+  const activeDefs = defs.filter((d) => isEnabled(rules[d.name]!));
+  if (activeDefs.length === 0) {
+    for (const def of defs) {
+      ruleResults.push({
+        name: def.name,
+        level: def.level,
+        status: 'pass',
+        thresholds: rules[def.name]!,
+        violationCount: 0,
+      });
+    }
+    return;
+  }
+
+  let where = "WHERE n.kind IN ('function','method')";
+  const params: unknown[] = [];
+  if (opts.noTests) where += NO_TEST_SQL;
+  {
+    const fc = buildFileConditionSQL(opts.file as string, 'n.file');
+    where += fc.sql;
+    params.push(...fc.params);
+  }
+  if (opts.kind) {
+    where += ' AND n.kind = ?';
+    params.push(opts.kind);
+  }
+
+  let rows: Array<Record<string, unknown>>;
+  try {
+    rows = db
+      .prepare(
+        `SELECT n.name, n.kind, n.file, n.line,
+                fc.cognitive, fc.cyclomatic, fc.max_nesting
+         FROM function_complexity fc
+         JOIN nodes n ON fc.node_id = n.id
+         ${where}`,
+      )
+      .all(...params) as Array<Record<string, unknown>>;
+  } catch (err: unknown) {
+    debug(`manifesto function query failed: ${(err as Error).message}`);
+    rows = [];
+  }
+
+  evaluateRules({ defs, rows }, rules, violations, ruleResults);
+}
+
 function evaluateFileRules(
   db: BetterSqlite3Database,
   rules: ResolvedRules,
@@ -252,10 +286,10 @@ function evaluateFileRules(
   violations: Violation[],
   ruleResults: RuleResult[],
 ): void {
-  const fileDefs = RULE_DEFS.filter((d) => d.level === 'file');
-  const activeDefs = fileDefs.filter((d) => isEnabled(rules[d.name]!));
+  const defs = RULE_DEFS.filter((d) => d.level === 'file');
+  const activeDefs = defs.filter((d) => isEnabled(rules[d.name]!));
   if (activeDefs.length === 0) {
-    for (const def of fileDefs) {
+    for (const def of defs) {
       ruleResults.push({
         name: def.name,
         level: def.level,
@@ -293,40 +327,7 @@ function evaluateFileRules(
     rows = [];
   }
 
-  const worst: Record<string, string> = {};
-  const counts: Record<string, number> = {};
-  for (const def of fileDefs) {
-    worst[def.name] = 'pass';
-    counts[def.name] = 0;
-  }
-
-  for (const row of rows) {
-    for (const def of activeDefs) {
-      const value = row[def.metric] as number | null;
-      if (value == null) continue;
-      const meta = {
-        name: row.name as string,
-        file: row.file as string,
-        line: row.line as number,
-      };
-      const status = checkThreshold(def.name, rules[def.name]!, value, meta, violations);
-      if (status !== 'pass') {
-        counts[def.name] = (counts[def.name] ?? 0) + 1;
-        if (status === 'fail') worst[def.name] = 'fail';
-        else if (worst[def.name] !== 'fail') worst[def.name] = 'warn';
-      }
-    }
-  }
-
-  for (const def of fileDefs) {
-    ruleResults.push({
-      name: def.name,
-      level: def.level,
-      status: worst[def.name]!,
-      thresholds: rules[def.name]!,
-      violationCount: counts[def.name] ?? 0,
-    });
-  }
+  evaluateRules({ defs, rows }, rules, violations, ruleResults);
 }
 
 function evaluateGraphRules(

package/src/features/sequence.ts

@@ -10,6 +10,34 @@ import { FRAMEWORK_ENTRY_PREFIXES } from './structure.js';
 
 // ─── Alias generation ────────────────────────────────────────────────
 
+/** Build aliases for a group of paths that share the same basename.
+ *  Progressively adds parent dirs until all aliases are unique. */
+function resolveCollisionAliases(paths: string[], aliases: Map<string, string>): void {
+  for (let depth = 2; depth <= 10; depth++) {
+    const trial = new Map<string, string>();
+    let allUnique = true;
+    const seen = new Set<string>();
+
+    for (const p of paths) {
+      const parts = p.replace(/\.[^.]+$/, '').split('/');
+      const alias = parts
+        .slice(-depth)
+        .join('_')
+        .replace(/[^a-zA-Z0-9_-]/g, '_');
+      trial.set(p, alias);
+      if (seen.has(alias)) allUnique = false;
+      seen.add(alias);
+    }
+
+    if (allUnique || depth === 10) {
+      for (const [p, alias] of trial) {
+        aliases.set(p, alias);
+      }
+      break;
+    }
+  }
+}
+
 function buildAliases(files: string[]): Map<string, string> {
   const aliases = new Map<string, string>();
   const basenames = new Map<string, string[]>();
@@ -26,29 +54,7 @@ function buildAliases(files: string[]): Map<string, string> {
       aliases.set(paths[0]!, base);
     } else {
       // Collision — progressively add parent dirs until aliases are unique
-      for (let depth = 2; depth <= 10; depth++) {
-        const trial = new Map<string, string>();
-        let allUnique = true;
-        const seen = new Set<string>();
-
-        for (const p of paths) {
-          const parts = p.replace(/\.[^.]+$/, '').split('/');
-          const alias = parts
-            .slice(-depth)
-            .join('_')
-            .replace(/[^a-zA-Z0-9_-]/g, '_');
-          trial.set(p, alias);
-          if (seen.has(alias)) allUnique = false;
-          seen.add(alias);
-        }
-
-        if (allUnique || depth === 10) {
-          for (const [p, alias] of trial) {
-            aliases.set(p, alias);
-          }
-          break;
-        }
-      }
+      resolveCollisionAliases(paths, aliases);
     }
   }
 

package/src/features/snapshot.ts

@@ -25,6 +25,41 @@ interface SnapshotSaveOptions {
   force?: boolean;
 }
 
+/**
+ * Atomically place `tmp` at `dest`.
+ * - force=true: renameSync (overwrites any existing file).
+ * - force=false: linkSync so EEXIST is detected atomically; then unlink tmp.
+ * Callers are responsible for cleaning up `tmp` on any thrown error.
+ */
+function atomicPlaceFile(tmp: string, dest: string, name: string, force?: boolean): void {
+  if (force) {
+    // renameSync overwrites atomically — the correct semantics for --force.
+    fs.renameSync(tmp, dest);
+    return;
+  }
+
+  // Non-force path: linkSync fails atomically with EEXIST if dest exists,
+  // closing the TOCTOU window between existsSync above and the final
+  // placement. We then unlink the temp file; on POSIX and NTFS, link
+  // creates a second reference so tmp can safely be removed.
+  try {
+    fs.linkSync(tmp, dest);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'EEXIST') {
+      throw new ConfigError(`Snapshot "${name}" already exists. Use --force to overwrite.`);
+    }
+    throw err;
+  }
+  try {
+    fs.unlinkSync(tmp);
+  } catch (cleanupErr) {
+    // Best-effort — dest is already in place, so a leftover tmp file is
+    // harmless. Log at debug so repeated failures surface during
+    // troubleshooting without noising up normal operation.
+    debug(`snapshotSave: failed to remove temp file ${tmp}: ${cleanupErr}`);
+  }
+}
+
 export function snapshotSave(
   name: string,
   options: SnapshotSaveOptions = {},
@@ -73,31 +108,7 @@ export function snapshotSave(
   }
 
   try {
-    if (options.force) {
-      // renameSync overwrites atomically — the correct semantics for --force.
-      fs.renameSync(tmp, dest);
-    } else {
-      // Non-force path: linkSync fails atomically with EEXIST if dest exists,
-      // closing the TOCTOU window between existsSync above and the final
-      // placement. We then unlink the temp file; on POSIX and NTFS, link
-      // creates a second reference so tmp can safely be removed.
-      try {
-        fs.linkSync(tmp, dest);
-      } catch (err) {
-        if ((err as NodeJS.ErrnoException).code === 'EEXIST') {
-          throw new ConfigError(`Snapshot "${name}" already exists. Use --force to overwrite.`);
-        }
-        throw err;
-      }
-      try {
-        fs.unlinkSync(tmp);
-      } catch (cleanupErr) {
-        // Best-effort — dest is already in place, so a leftover tmp file is
-        // harmless. Log at debug so repeated failures surface during
-        // troubleshooting without noising up normal operation.
-        debug(`snapshotSave: failed to remove temp file ${tmp}: ${cleanupErr}`);
-      }
-    }
+    atomicPlaceFile(tmp, dest, name, options.force);
   } catch (err) {
     try {
       fs.unlinkSync(tmp);

package/src/features/structure-query.ts

@@ -324,7 +324,7 @@ export function hotspotsData(
   metric: string;
   level: string;
   limit: number;
-  hotspots: unknown[];
+  items: unknown[];
 } {
   const { db, nativeDb, close } = openReadonlyWithNative(customDbPath);
   try {
@@ -337,19 +337,19 @@ export function hotspotsData(
     // ── Native fast path: single query instead of 4 eagerly prepared ──
     if (nativeDb?.getHotspots) {
       const rows = nativeDb.getHotspots(kind, metric, noTests, limit);
-      const hotspots = rows.map(mapNativeHotspotRow);
-      const base = { metric, level, limit, hotspots };
-      return paginateResult(base, 'hotspots', { limit: opts.limit, offset: opts.offset });
+      const items = rows.map(mapNativeHotspotRow);
+      const base = { metric, level, limit, items };
+      return paginateResult(base, 'items', { limit: opts.limit, offset: opts.offset });
     }
 
     // ── JS fallback ───────────────────────────────────────────────────
     const testFilter = testFilterSQL('n.name', noTests && kind === 'file');
     const stmt = db.prepare(buildHotspotQuery(metric, testFilter));
     const rows = stmt.all(kind, limit) as HotspotRow[];
-    const hotspots = rows.map(mapJsHotspotRow);
+    const items = rows.map(mapJsHotspotRow);
 
-    const base = { metric, level, limit, hotspots };
-    return paginateResult(base, 'hotspots', { limit: opts.limit, offset: opts.offset });
+    const base = { metric, level, limit, items };
+    return paginateResult(base, 'items', { limit: opts.limit, offset: opts.offset });
   } finally {
     close();
   }