@optave/codegraph 3.4.0 → 3.5.0

package/src/extractors/python.ts

@@ -6,7 +6,7 @@ import type {
   TreeSitterTree,
   TypeMapEntry,
 } from '../types.js';
-import { findChild, nodeEndLine, pythonVisibility } from './helpers.js';
+import { findChild, MAX_WALK_DEPTH, nodeEndLine, pythonVisibility } from './helpers.js';
 
 /** Built-in globals that start with uppercase but are not user-defined types. */
 const BUILTIN_GLOBALS_PY: Set<string> = new Set([
@@ -365,7 +365,7 @@ function extractPythonTypeMapDepth(
   ctx: ExtractorOutput,
   depth: number,
 ): void {
-  if (depth >= 200) return;
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // typed_parameter: identifier : type (confidence 0.9)
   if (node.type === 'typed_parameter') {

package/src/extractors/rust.ts

@@ -5,7 +5,7 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { findChild, nodeEndLine, rustVisibility } from './helpers.js';
+import { findChild, MAX_WALK_DEPTH, nodeEndLine, rustVisibility } from './helpers.js';
 
 /**
  * Extract symbols from Rust files.
@@ -227,7 +227,8 @@ function extractRustParameters(paramListNode: TreeSitterNode | null): SubDeclara
     const param = paramListNode.child(i);
     if (!param) continue;
     if (param.type === 'self_parameter') {
-      params.push({ name: 'self', kind: 'parameter', line: param.startPosition.row + 1 });
+      // Skip self parameters — matches native engine behaviour
+      continue;
     } else if (param.type === 'parameter') {
       const pattern = param.childForFieldName('pattern');
       if (pattern) {
@@ -274,7 +275,7 @@ function extractRustTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function extractRustTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
-  if (depth >= 200) return;
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // let x: MyType = ...
   if (node.type === 'let_declaration') {

package/src/features/ast.ts

@@ -65,8 +65,73 @@ export async function buildAstNodes(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbols>,
   _rootDir: string,
-  _engineOpts?: unknown,
+  engineOpts?: {
+    nativeDb?: {
+      bulkInsertAstNodes(
+        batches: Array<{
+          file: string;
+          nodes: Array<{
+            line: number;
+            kind: string;
+            name: string;
+            text?: string | null;
+            receiver?: string | null;
+          }>;
+        }>,
+      ): number;
+    };
+  },
 ): Promise<void> {
+  // ── Native bulk-insert fast path ──────────────────────────────────────
+  // Uses NativeDatabase persistent connection (Phase 6.15+).
+  // Standalone napi functions were removed in 6.17.
+  const nativeDb = engineOpts?.nativeDb;
+  if (nativeDb?.bulkInsertAstNodes) {
+    let needsJsFallback = false;
+    const batches: Array<{
+      file: string;
+      nodes: Array<{
+        line: number;
+        kind: string;
+        name: string;
+        text?: string | null;
+        receiver?: string | null;
+      }>;
+    }> = [];
+
+    for (const [relPath, symbols] of fileSymbols) {
+      if (Array.isArray(symbols.astNodes)) {
+        batches.push({
+          file: relPath,
+          nodes: symbols.astNodes.map((n) => ({
+            line: n.line,
+            kind: n.kind,
+            name: n.name,
+            text: n.text,
+            receiver: n.receiver,
+          })),
+        });
+      } else if (symbols.calls || symbols._tree) {
+        needsJsFallback = true;
+        break;
+      }
+    }
+
+    if (!needsJsFallback) {
+      const expectedNodes = batches.reduce((s, b) => s + b.nodes.length, 0);
+      const inserted = nativeDb.bulkInsertAstNodes(batches);
+      if (inserted === expectedNodes) {
+        debug(`AST extraction (native bulk): ${inserted} nodes stored`);
+        return;
+      }
+      debug(
+        `AST extraction (native bulk): expected ${expectedNodes}, got ${inserted} — falling back to JS`,
+      );
+      // fall through to JS path
+    }
+  }
+
+  // ── JS fallback path ──────────────────────────────────────────────────
   let insertStmt: ReturnType<BetterSqlite3Database['prepare']>;
   try {
     insertStmt = db.prepare(

package/src/features/audit.ts

@@ -30,7 +30,7 @@ function resolveThresholds(
         const repoRoot = path.resolve(dbDir, '..');
         return loadConfig(repoRoot);
       })();
-    const userRules = (cfg as Record<string, unknown>)['manifesto'] || {};
+    const userRules = (cfg as Record<string, unknown>).manifesto || {};
     const resolved: Record<string, ThresholdEntry> = {};
     for (const def of FUNCTION_RULES) {
       const user = (userRules as Record<string, { warn?: number; fail?: number }>)[def.name];
@@ -163,7 +163,6 @@ export function auditData(
   const explained = explainData(target, customDbPath, { noTests, depth: 0 });
 
   // Apply --file and --kind filters for function targets
-  // biome-ignore lint/suspicious/noExplicitAny: explainData returns a union type that varies by kind
   let results: any[] = explained.results;
   if (explained.kind === 'function') {
     if (fileFilters.length > 0)

package/src/features/branch-compare.ts

@@ -2,17 +2,11 @@ import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import Database from 'better-sqlite3';
+import { getDatabase } from '../db/better-sqlite3.js';
 import { buildGraph } from '../domain/graph/builder.js';
 import { kindIcon } from '../domain/queries.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
-import type { BetterSqlite3Database, EngineMode } from '../types.js';
-
-type DatabaseConstructor = new (
-  path: string,
-  opts?: Record<string, unknown>,
-) => BetterSqlite3Database;
-const Db = Database as unknown as DatabaseConstructor;
+import type { EngineMode } from '../types.js';
 
 // ─── Git Helpers ────────────────────────────────────────────────────────
 
@@ -111,7 +105,8 @@ function loadSymbolsFromDb(
   changedFiles: string[],
   noTests: boolean,
 ): Map<string, SymbolInfo> {
-  const db = new Db(dbPath, { readonly: true });
+  const Database = getDatabase();
+  const db = new Database(dbPath, { readonly: true });
   try {
     const symbols = new Map<string, SymbolInfo>();
 
@@ -180,7 +175,8 @@ function loadCallersFromDb(
 ): CallerInfo[] {
   if (nodeIds.length === 0) return [];
 
-  const db = new Db(dbPath, { readonly: true });
+  const Database = getDatabase();
+  const db = new Database(dbPath, { readonly: true });
   try {
     const allCallers = new Set<string>();
 

package/src/features/cfg.ts

@@ -62,8 +62,7 @@ export function buildFunctionCFG(functionNode: TreeSitterNode, langId: string):
   };
 
   const results = walkWithVisitors(functionNode, [visitor], langId, walkerOpts);
-  // biome-ignore lint/complexity/useLiteralKeys: noPropertyAccessFromIndexSignature requires bracket notation
-  const cfgResults = (results['cfg'] || []) as Array<{
+  const cfgResults = (results.cfg || []) as Array<{
     funcNode: TreeSitterNode;
     blocks: CfgBuildBlock[];
     edges: CfgBuildEdge[];
@@ -214,8 +213,7 @@ function buildVisitorCfgMap(
     },
   };
   const walkResults = walkWithVisitors(tree?.rootNode, [visitor], langId, walkerOpts);
-  // biome-ignore lint/complexity/useLiteralKeys: noPropertyAccessFromIndexSignature requires bracket notation
-  const cfgResults = (walkResults['cfg'] || []) as VisitorCfgResult[];
+  const cfgResults = (walkResults.cfg || []) as VisitorCfgResult[];
   const visitorCfgByLine = new Map<number, VisitorCfgResult[]>();
   for (const r of cfgResults) {
     if (r.funcNode) {

package/src/features/cochange.ts

@@ -472,10 +472,10 @@ function getCoChangeMeta(db: BetterSqlite3Database): CoChangeMeta | null {
       meta[row.key] = row.value;
     }
     return {
-      analyzedAt: meta['analyzed_at'] || null,
-      since: meta['since'] || null,
-      minSupport: meta['min_support'] ? parseInt(meta['min_support'], 10) : null,
-      lastCommit: meta['last_analyzed_commit'] || null,
+      analyzedAt: meta.analyzed_at || null,
+      since: meta.since || null,
+      minSupport: meta.min_support ? parseInt(meta.min_support, 10) : null,
+      lastCommit: meta.last_analyzed_commit || null,
     };
   } catch {
     return null;

package/src/features/communities.ts

@@ -50,12 +50,12 @@ function buildCommunityObjects(
     const memberData: CommunityMember[] = [];
     for (const key of members) {
       const attrs = graph.getNodeAttrs(key)!;
-      const dir = getDirectory(attrs['file'] as string);
+      const dir = getDirectory(attrs.file as string);
       dirCounts[dir] = (dirCounts[dir] || 0) + 1;
       memberData.push({
-        name: attrs['label'] as string,
-        file: attrs['file'] as string,
-        ...(attrs['kind'] ? { kind: attrs['kind'] as string } : {}),
+        name: attrs.label as string,
+        file: attrs.file as string,
+        ...(attrs.kind ? { kind: attrs.kind as string } : {}),
       });
     }
 

package/src/features/complexity-query.ts

@@ -0,0 +1,370 @@
+/**
+ * Complexity query functions — read-only DB queries for complexity metrics.
+ *
+ * Split from complexity.ts to separate query-time concerns (DB reads, filtering,
+ * pagination) from compute-time concerns (AST traversal, metric algorithms).
+ */
+
+import { openReadonlyOrFail } from '../db/index.js';
+import { buildFileConditionSQL } from '../db/query-builder.js';
+import { loadConfig } from '../infrastructure/config.js';
+import { debug } from '../infrastructure/logger.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
+import { paginateResult } from '../shared/paginate.js';
+import type { CodegraphConfig } from '../types.js';
+
+// ─── Query-Time Functions ─────────────────────────────────────────────────
+
+interface ComplexityRow {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  end_line: number | null;
+  cognitive: number;
+  cyclomatic: number;
+  max_nesting: number;
+  loc: number;
+  sloc: number;
+  maintainability_index: number;
+  halstead_volume: number;
+  halstead_difficulty: number;
+  halstead_effort: number;
+  halstead_bugs: number;
+}
+
+export function complexityData(
+  customDbPath?: string,
+  opts: {
+    target?: string;
+    limit?: number;
+    sort?: string;
+    aboveThreshold?: boolean;
+    file?: string;
+    kind?: string;
+    noTests?: boolean;
+    config?: CodegraphConfig;
+    offset?: number;
+  } = {},
+): Record<string, unknown> {
+  const db = openReadonlyOrFail(customDbPath);
+  try {
+    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 },
+      cyclomatic: { warn: 10, fail: null },
+      maxNesting: { warn: 4, fail: null },
+      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);
+
+    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 orderMap: Record<string, string> = {
+      cognitive: 'fc.cognitive DESC',
+      cyclomatic: 'fc.cyclomatic DESC',
+      nesting: 'fc.max_nesting DESC',
+      mi: 'fc.maintainability_index ASC',
+      volume: 'fc.halstead_volume DESC',
+      effort: 'fc.halstead_effort DESC',
+      bugs: 'fc.halstead_bugs DESC',
+      loc: 'fc.loc DESC',
+    };
+    const orderBy = orderMap[sort] || 'fc.cognitive DESC';
+
+    let rows: ComplexityRow[];
+    try {
+      rows = db
+        .prepare<ComplexityRow>(
+          `SELECT n.name, n.kind, n.file, n.line, n.end_line,
+                fc.cognitive, fc.cyclomatic, fc.max_nesting,
+                fc.loc, fc.sloc, fc.maintainability_index,
+                fc.halstead_volume, fc.halstead_difficulty, fc.halstead_effort, fc.halstead_bugs
+         FROM function_complexity fc
+         JOIN nodes n ON fc.node_id = n.id
+         ${where} ${having}
+         ORDER BY ${orderBy}`,
+        )
+        .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 };
+    }
+
+    // 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) => {
+      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 base = { functions, summary, thresholds, hasGraph };
+    return paginateResult(base, 'functions', { limit: opts.limit, offset: opts.offset });
+  } finally {
+    db.close();
+  }
+}
+
+interface IterComplexityRow {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  end_line: number | null;
+  cognitive: number;
+  cyclomatic: number;
+  max_nesting: number;
+  loc: number;
+  sloc: number;
+}
+
+export function* iterComplexity(
+  customDbPath?: string,
+  opts: {
+    noTests?: boolean;
+    file?: string;
+    target?: string;
+    kind?: string;
+    sort?: string;
+  } = {},
+): Generator<{
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  endLine: number | null;
+  cognitive: number;
+  cyclomatic: number;
+  maxNesting: number;
+  loc: number;
+  sloc: number;
+}> {
+  const db = openReadonlyOrFail(customDbPath);
+  try {
+    const noTests = opts.noTests || false;
+    const sort = opts.sort || 'cognitive';
+
+    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 (opts.target) {
+      where += ' AND n.name LIKE ?';
+      params.push(`%${opts.target}%`);
+    }
+    {
+      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);
+    }
+
+    const orderMap: Record<string, string> = {
+      cognitive: 'fc.cognitive DESC',
+      cyclomatic: 'fc.cyclomatic DESC',
+      nesting: 'fc.max_nesting DESC',
+      mi: 'fc.maintainability_index ASC',
+      volume: 'fc.halstead_volume DESC',
+      effort: 'fc.halstead_effort DESC',
+      bugs: 'fc.halstead_bugs DESC',
+      loc: 'fc.loc DESC',
+    };
+    const orderBy = orderMap[sort] || 'fc.cognitive DESC';
+
+    const stmt = db.prepare<IterComplexityRow>(
+      `SELECT n.name, n.kind, n.file, n.line, n.end_line,
+              fc.cognitive, fc.cyclomatic, fc.max_nesting, fc.loc, fc.sloc
+       FROM function_complexity fc
+       JOIN nodes n ON fc.node_id = n.id
+       ${where}
+       ORDER BY ${orderBy}`,
+    );
+    for (const r of stmt.iterate(...params)) {
+      if (noTests && isTestFile(r.file)) continue;
+      yield {
+        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,
+      };
+    }
+  } finally {
+    db.close();
+  }
+}