@optave/codegraph 3.5.0 → 3.7.0

package/src/features/complexity-query.ts

@@ -33,6 +33,176 @@ interface ComplexityRow {
   halstead_bugs: number;
 }
 
+const isValidThreshold = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v);
+
+/** Build WHERE clause and params for complexity query filtering. */
+function buildComplexityWhere(opts: {
+  noTests: boolean;
+  target: string | null;
+  fileFilter: string | null;
+  kindFilter: string | null;
+}): { where: string; params: unknown[] } {
+  let where = "WHERE n.kind IN ('function','method')";
+  const params: unknown[] = [];
+
+  if (opts.noTests) {
+    where += ` AND n.file NOT LIKE '%.test.%'
+       AND n.file NOT LIKE '%.spec.%'
+       AND n.file NOT LIKE '%__test__%'
+       AND n.file NOT LIKE '%__tests__%'
+       AND n.file NOT LIKE '%.stories.%'`;
+  }
+  if (opts.target) {
+    where += ' AND n.name LIKE ?';
+    params.push(`%${opts.target}%`);
+  }
+  {
+    const fc = buildFileConditionSQL(opts.fileFilter as string, 'n.file');
+    where += fc.sql;
+    params.push(...fc.params);
+  }
+  if (opts.kindFilter) {
+    where += ' AND n.kind = ?';
+    params.push(opts.kindFilter);
+  }
+  return { where, params };
+}
+
+/** Build HAVING clause for above-threshold filtering. */
+function buildThresholdHaving(thresholds: any): string {
+  const conditions: string[] = [];
+  if (isValidThreshold(thresholds.cognitive?.warn)) {
+    conditions.push(`fc.cognitive >= ${thresholds.cognitive.warn}`);
+  }
+  if (isValidThreshold(thresholds.cyclomatic?.warn)) {
+    conditions.push(`fc.cyclomatic >= ${thresholds.cyclomatic.warn}`);
+  }
+  if (isValidThreshold(thresholds.maxNesting?.warn)) {
+    conditions.push(`fc.max_nesting >= ${thresholds.maxNesting.warn}`);
+  }
+  if (isValidThreshold(thresholds.maintainabilityIndex?.warn)) {
+    conditions.push(
+      `fc.maintainability_index > 0 AND fc.maintainability_index <= ${thresholds.maintainabilityIndex.warn}`,
+    );
+  }
+  return conditions.length > 0 ? `AND (${conditions.join(' OR ')})` : '';
+}
+
+/** Map a raw DB row to the public complexity result shape. */
+function mapComplexityRow(r: ComplexityRow, thresholds: any): Record<string, unknown> {
+  const exceeds: string[] = [];
+  if (
+    isValidThreshold(thresholds.cognitive?.warn) &&
+    r.cognitive >= (thresholds.cognitive?.warn ?? 0)
+  )
+    exceeds.push('cognitive');
+  if (
+    isValidThreshold(thresholds.cyclomatic?.warn) &&
+    r.cyclomatic >= (thresholds.cyclomatic?.warn ?? 0)
+  )
+    exceeds.push('cyclomatic');
+  if (
+    isValidThreshold(thresholds.maxNesting?.warn) &&
+    r.max_nesting >= (thresholds.maxNesting?.warn ?? 0)
+  )
+    exceeds.push('maxNesting');
+  if (
+    isValidThreshold(thresholds.maintainabilityIndex?.warn) &&
+    r.maintainability_index > 0 &&
+    r.maintainability_index <= (thresholds.maintainabilityIndex?.warn ?? 0)
+  )
+    exceeds.push('maintainabilityIndex');
+
+  return {
+    name: r.name,
+    kind: r.kind,
+    file: r.file,
+    line: r.line,
+    endLine: r.end_line || null,
+    cognitive: r.cognitive,
+    cyclomatic: r.cyclomatic,
+    maxNesting: r.max_nesting,
+    loc: r.loc || 0,
+    sloc: r.sloc || 0,
+    maintainabilityIndex: r.maintainability_index || 0,
+    halstead: {
+      volume: r.halstead_volume || 0,
+      difficulty: r.halstead_difficulty || 0,
+      effort: r.halstead_effort || 0,
+      bugs: r.halstead_bugs || 0,
+    },
+    exceeds: exceeds.length > 0 ? exceeds : undefined,
+  };
+}
+
+/** Check whether a row exceeds any threshold (for summary counting). */
+function exceedsAnyThreshold(
+  r: { cognitive: number; cyclomatic: number; max_nesting: number; maintainability_index: number },
+  thresholds: any,
+): boolean {
+  return (
+    (isValidThreshold(thresholds.cognitive?.warn) &&
+      r.cognitive >= (thresholds.cognitive?.warn ?? 0)) ||
+    (isValidThreshold(thresholds.cyclomatic?.warn) &&
+      r.cyclomatic >= (thresholds.cyclomatic?.warn ?? 0)) ||
+    (isValidThreshold(thresholds.maxNesting?.warn) &&
+      r.max_nesting >= (thresholds.maxNesting?.warn ?? 0)) ||
+    (isValidThreshold(thresholds.maintainabilityIndex?.warn) &&
+      r.maintainability_index > 0 &&
+      r.maintainability_index <= (thresholds.maintainabilityIndex?.warn ?? 0))
+  );
+}
+
+/** Compute summary statistics across all complexity rows. */
+function computeComplexitySummary(
+  db: ReturnType<typeof openReadonlyOrFail>,
+  noTests: boolean,
+  thresholds: any,
+): Record<string, unknown> | null {
+  try {
+    const allRows = db
+      .prepare<{
+        cognitive: number;
+        cyclomatic: number;
+        max_nesting: number;
+        maintainability_index: number;
+      }>(
+        `SELECT fc.cognitive, fc.cyclomatic, fc.max_nesting, fc.maintainability_index
+         FROM function_complexity fc JOIN nodes n ON fc.node_id = n.id
+         WHERE n.kind IN ('function','method')
+         ${noTests ? `AND n.file NOT LIKE '%.test.%' AND n.file NOT LIKE '%.spec.%' AND n.file NOT LIKE '%__test__%' AND n.file NOT LIKE '%__tests__%' AND n.file NOT LIKE '%.stories.%'` : ''}`,
+      )
+      .all();
+
+    if (allRows.length === 0) return null;
+
+    const miValues = allRows.map((r) => r.maintainability_index || 0);
+    return {
+      analyzed: allRows.length,
+      avgCognitive: +(allRows.reduce((s, r) => s + r.cognitive, 0) / allRows.length).toFixed(1),
+      avgCyclomatic: +(allRows.reduce((s, r) => s + r.cyclomatic, 0) / allRows.length).toFixed(1),
+      maxCognitive: Math.max(...allRows.map((r) => r.cognitive)),
+      maxCyclomatic: Math.max(...allRows.map((r) => r.cyclomatic)),
+      avgMI: +(miValues.reduce((s, v) => s + v, 0) / miValues.length).toFixed(1),
+      minMI: +Math.min(...miValues).toFixed(1),
+      aboveWarn: allRows.filter((r) => exceedsAnyThreshold(r, thresholds)).length,
+    };
+  } catch (e: unknown) {
+    debug(`complexity summary query failed: ${(e as Error).message}`);
+    return null;
+  }
+}
+
+/** Check if graph has nodes (used when complexity table is missing). */
+function checkHasGraph(db: ReturnType<typeof openReadonlyOrFail>): boolean {
+  try {
+    return (db.prepare<{ c: number }>('SELECT COUNT(*) as c FROM nodes').get()?.c ?? 0) > 0;
+  } catch (e: unknown) {
+    debug(`nodes table check failed: ${(e as Error).message}`);
+    return false;
+  }
+}
+
 export function complexityData(
   customDbPath?: string,
   opts: {
@@ -52,11 +222,7 @@ export function complexityData(
     const sort = opts.sort || 'cognitive';
     const noTests = opts.noTests || false;
     const aboveThreshold = opts.aboveThreshold || false;
-    const target = opts.target || null;
-    const fileFilter = opts.file || null;
-    const kindFilter = opts.kind || null;
 
-    // Load thresholds from config
     const config = opts.config || loadConfig(process.cwd());
     const thresholds: any = config.manifesto?.rules || {
       cognitive: { warn: 15, fail: null },
@@ -65,55 +231,14 @@ export function complexityData(
       maintainabilityIndex: { warn: 20, fail: null },
     };
 
-    // Build query
-    let where = "WHERE n.kind IN ('function','method')";
-    const params: unknown[] = [];
-
-    if (noTests) {
-      where += ` AND n.file NOT LIKE '%.test.%'
-       AND n.file NOT LIKE '%.spec.%'
-       AND n.file NOT LIKE '%__test__%'
-       AND n.file NOT LIKE '%__tests__%'
-       AND n.file NOT LIKE '%.stories.%'`;
-    }
-    if (target) {
-      where += ' AND n.name LIKE ?';
-      params.push(`%${target}%`);
-    }
-    {
-      const fc = buildFileConditionSQL(fileFilter as string, 'n.file');
-      where += fc.sql;
-      params.push(...fc.params);
-    }
-    if (kindFilter) {
-      where += ' AND n.kind = ?';
-      params.push(kindFilter);
-    }
-
-    const isValidThreshold = (v: unknown): v is number =>
-      typeof v === 'number' && Number.isFinite(v);
+    const { where, params } = buildComplexityWhere({
+      noTests,
+      target: opts.target || null,
+      fileFilter: opts.file || null,
+      kindFilter: opts.kind || null,
+    });
 
-    let having = '';
-    if (aboveThreshold) {
-      const conditions: string[] = [];
-      if (isValidThreshold(thresholds.cognitive?.warn)) {
-        conditions.push(`fc.cognitive >= ${thresholds.cognitive.warn}`);
-      }
-      if (isValidThreshold(thresholds.cyclomatic?.warn)) {
-        conditions.push(`fc.cyclomatic >= ${thresholds.cyclomatic.warn}`);
-      }
-      if (isValidThreshold(thresholds.maxNesting?.warn)) {
-        conditions.push(`fc.max_nesting >= ${thresholds.maxNesting.warn}`);
-      }
-      if (isValidThreshold(thresholds.maintainabilityIndex?.warn)) {
-        conditions.push(
-          `fc.maintainability_index > 0 AND fc.maintainability_index <= ${thresholds.maintainabilityIndex.warn}`,
-        );
-      }
-      if (conditions.length > 0) {
-        having = `AND (${conditions.join(' OR ')})`;
-      }
-    }
+    const having = aboveThreshold ? buildThresholdHaving(thresholds) : '';
 
     const orderMap: Record<string, string> = {
       cognitive: 'fc.cognitive DESC',
@@ -143,121 +268,14 @@ export function complexityData(
         .all(...params);
     } catch (e: unknown) {
       debug(`complexity query failed (table may not exist): ${(e as Error).message}`);
-      // Check if graph has nodes even though complexity table is missing/empty
-      let hasGraph = false;
-      try {
-        hasGraph = (db.prepare<{ c: number }>('SELECT COUNT(*) as c FROM nodes').get()?.c ?? 0) > 0;
-      } catch (e2: unknown) {
-        debug(`nodes table check failed: ${(e2 as Error).message}`);
-      }
-      return { functions: [], summary: null, thresholds, hasGraph };
+      return { functions: [], summary: null, thresholds, hasGraph: checkHasGraph(db) };
     }
 
-    // Post-filter test files if needed (belt-and-suspenders for isTestFile)
     const filtered = noTests ? rows.filter((r) => !isTestFile(r.file)) : rows;
+    const functions = filtered.map((r) => mapComplexityRow(r, thresholds));
 
-    const functions = filtered.map((r) => {
-      const exceeds: string[] = [];
-      if (
-        isValidThreshold(thresholds.cognitive?.warn) &&
-        r.cognitive >= (thresholds.cognitive?.warn ?? 0)
-      )
-        exceeds.push('cognitive');
-      if (
-        isValidThreshold(thresholds.cyclomatic?.warn) &&
-        r.cyclomatic >= (thresholds.cyclomatic?.warn ?? 0)
-      )
-        exceeds.push('cyclomatic');
-      if (
-        isValidThreshold(thresholds.maxNesting?.warn) &&
-        r.max_nesting >= (thresholds.maxNesting?.warn ?? 0)
-      )
-        exceeds.push('maxNesting');
-      if (
-        isValidThreshold(thresholds.maintainabilityIndex?.warn) &&
-        r.maintainability_index > 0 &&
-        r.maintainability_index <= (thresholds.maintainabilityIndex?.warn ?? 0)
-      )
-        exceeds.push('maintainabilityIndex');
-
-      return {
-        name: r.name,
-        kind: r.kind,
-        file: r.file,
-        line: r.line,
-        endLine: r.end_line || null,
-        cognitive: r.cognitive,
-        cyclomatic: r.cyclomatic,
-        maxNesting: r.max_nesting,
-        loc: r.loc || 0,
-        sloc: r.sloc || 0,
-        maintainabilityIndex: r.maintainability_index || 0,
-        halstead: {
-          volume: r.halstead_volume || 0,
-          difficulty: r.halstead_difficulty || 0,
-          effort: r.halstead_effort || 0,
-          bugs: r.halstead_bugs || 0,
-        },
-        exceeds: exceeds.length > 0 ? exceeds : undefined,
-      };
-    });
-
-    // Summary stats
-    let summary: Record<string, unknown> | null = null;
-    try {
-      const allRows = db
-        .prepare<{
-          cognitive: number;
-          cyclomatic: number;
-          max_nesting: number;
-          maintainability_index: number;
-        }>(
-          `SELECT fc.cognitive, fc.cyclomatic, fc.max_nesting, fc.maintainability_index
-         FROM function_complexity fc JOIN nodes n ON fc.node_id = n.id
-         WHERE n.kind IN ('function','method')
-         ${noTests ? `AND n.file NOT LIKE '%.test.%' AND n.file NOT LIKE '%.spec.%' AND n.file NOT LIKE '%__test__%' AND n.file NOT LIKE '%__tests__%' AND n.file NOT LIKE '%.stories.%'` : ''}`,
-        )
-        .all();
-
-      if (allRows.length > 0) {
-        const miValues = allRows.map((r) => r.maintainability_index || 0);
-        summary = {
-          analyzed: allRows.length,
-          avgCognitive: +(allRows.reduce((s, r) => s + r.cognitive, 0) / allRows.length).toFixed(1),
-          avgCyclomatic: +(allRows.reduce((s, r) => s + r.cyclomatic, 0) / allRows.length).toFixed(
-            1,
-          ),
-          maxCognitive: Math.max(...allRows.map((r) => r.cognitive)),
-          maxCyclomatic: Math.max(...allRows.map((r) => r.cyclomatic)),
-          avgMI: +(miValues.reduce((s, v) => s + v, 0) / miValues.length).toFixed(1),
-          minMI: +Math.min(...miValues).toFixed(1),
-          aboveWarn: allRows.filter(
-            (r) =>
-              (isValidThreshold(thresholds.cognitive?.warn) &&
-                r.cognitive >= (thresholds.cognitive?.warn ?? 0)) ||
-              (isValidThreshold(thresholds.cyclomatic?.warn) &&
-                r.cyclomatic >= (thresholds.cyclomatic?.warn ?? 0)) ||
-              (isValidThreshold(thresholds.maxNesting?.warn) &&
-                r.max_nesting >= (thresholds.maxNesting?.warn ?? 0)) ||
-              (isValidThreshold(thresholds.maintainabilityIndex?.warn) &&
-                r.maintainability_index > 0 &&
-                r.maintainability_index <= (thresholds.maintainabilityIndex?.warn ?? 0)),
-          ).length,
-        };
-      }
-    } catch (e: unknown) {
-      debug(`complexity summary query failed: ${(e as Error).message}`);
-    }
-
-    // When summary is null (no complexity rows), check if graph has nodes
-    let hasGraph = false;
-    if (summary === null) {
-      try {
-        hasGraph = (db.prepare<{ c: number }>('SELECT COUNT(*) as c FROM nodes').get()?.c ?? 0) > 0;
-      } catch (e: unknown) {
-        debug(`nodes table check failed: ${(e as Error).message}`);
-      }
-    }
+    const summary = computeComplexitySummary(db, noTests, thresholds);
+    const hasGraph = summary === null ? checkHasGraph(db) : false;
 
     const base = { functions, summary, thresholds, hasGraph };
     return paginateResult(base, 'functions', { limit: opts.limit, offset: opts.offset });

package/src/features/complexity.ts

@@ -502,8 +502,71 @@ export async function buildComplexityMetrics(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbols>,
   rootDir: string,
-  _engineOpts?: unknown,
+  engineOpts?: {
+    nativeDb?: { bulkInsertComplexity?(rows: Array<Record<string, unknown>>): number };
+    suspendJsDb?: () => void;
+    resumeJsDb?: () => void;
+  },
 ): Promise<void> {
+  // ── Native bulk-insert fast path ──────────────────────────────────────
+  const nativeDb = engineOpts?.nativeDb;
+  if (nativeDb?.bulkInsertComplexity) {
+    const rows: Array<Record<string, unknown>> = [];
+    let needsJsFallback = false;
+
+    for (const [relPath, symbols] of fileSymbols) {
+      for (const def of symbols.definitions) {
+        if (def.kind !== 'function' && def.kind !== 'method') continue;
+        if (!def.line) continue;
+        if (!def.complexity) {
+          needsJsFallback = true;
+          break;
+        }
+        const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+        if (!nodeId) continue;
+        const ch = def.complexity.halstead;
+        const cl = def.complexity.loc;
+        rows.push({
+          nodeId,
+          cognitive: def.complexity.cognitive ?? 0,
+          cyclomatic: def.complexity.cyclomatic ?? 0,
+          maxNesting: def.complexity.maxNesting ?? 0,
+          loc: cl ? cl.loc : 0,
+          sloc: cl ? cl.sloc : 0,
+          commentLines: cl ? cl.commentLines : 0,
+          halsteadN1: ch ? ch.n1 : 0,
+          halsteadN2: ch ? ch.n2 : 0,
+          halsteadBigN1: ch ? ch.bigN1 : 0,
+          halsteadBigN2: ch ? ch.bigN2 : 0,
+          halsteadVocabulary: ch ? ch.vocabulary : 0,
+          halsteadLength: ch ? ch.length : 0,
+          halsteadVolume: ch ? ch.volume : 0,
+          halsteadDifficulty: ch ? ch.difficulty : 0,
+          halsteadEffort: ch ? ch.effort : 0,
+          halsteadBugs: ch ? ch.bugs : 0,
+          maintainabilityIndex: def.complexity.maintainabilityIndex ?? 0,
+        });
+      }
+      if (needsJsFallback) break;
+    }
+
+    if (!needsJsFallback && rows.length > 0) {
+      let inserted: number;
+      try {
+        engineOpts?.suspendJsDb?.();
+        inserted = nativeDb.bulkInsertComplexity(rows);
+      } finally {
+        engineOpts?.resumeJsDb?.();
+      }
+      if (inserted === rows.length) {
+        info(`Complexity (native bulk): ${inserted} functions analyzed`);
+        return;
+      }
+      debug(`Native bulkInsertComplexity partial: ${inserted}/${rows.length} — falling back to JS`);
+    }
+  }
+
+  // ── JS fallback path ─────────────────────────────────────────────────
   const { parsers, extToLang } = await initWasmParsersIfNeeded(fileSymbols);
   const { getParser } = await import('../domain/parser.js');