@optave/codegraph 3.9.0 → 3.9.2

package/src/extractors/go.ts

@@ -266,44 +266,69 @@ function handleTypedIdentifiers(
 }
 
 /** Infer type from a single RHS expression in a short var declaration. */
-function inferShortVarType(
+/** x := Struct{...} — composite literal (confidence 1.0). */
+function inferCompositeLiteral(
   varNode: TreeSitterNode,
   rhs: TreeSitterNode,
   typeMap: Map<string, { type: string; confidence: number }>,
-): void {
-  // x := Struct{...} — composite literal (confidence 1.0)
-  if (rhs.type === 'composite_literal') {
-    const typeNode = rhs.childForFieldName('type');
-    if (typeNode) {
-      const typeName = extractGoTypeName(typeNode);
-      if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
-    }
-  }
-  // x := &Struct{...} — address-of composite literal (confidence 1.0)
-  if (rhs.type === 'unary_expression') {
-    const operand = rhs.childForFieldName('operand');
-    if (operand && operand.type === 'composite_literal') {
-      const typeNode = operand.childForFieldName('type');
-      if (typeNode) {
-        const typeName = extractGoTypeName(typeNode);
-        if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
-      }
-    }
-  }
-  // x := NewFoo() or x := pkg.NewFoo() — factory function (confidence 0.7)
-  if (rhs.type === 'call_expression') {
-    const fn = rhs.childForFieldName('function');
-    if (fn && fn.type === 'selector_expression') {
-      const field = fn.childForFieldName('field');
-      if (field?.text.startsWith('New')) {
-        const typeName = field.text.slice(3);
-        if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 0.7);
-      }
-    } else if (fn && fn.type === 'identifier' && fn.text.startsWith('New')) {
-      const typeName = fn.text.slice(3);
+): boolean {
+  if (rhs.type !== 'composite_literal') return false;
+  const typeNode = rhs.childForFieldName('type');
+  if (!typeNode) return false;
+  const typeName = extractGoTypeName(typeNode);
+  if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
+  return true;
+}
+
+/** x := &Struct{...} — address-of composite literal (confidence 1.0). */
+function inferAddressOfComposite(
+  varNode: TreeSitterNode,
+  rhs: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
+): boolean {
+  if (rhs.type !== 'unary_expression') return false;
+  const operand = rhs.childForFieldName('operand');
+  if (!operand || operand.type !== 'composite_literal') return false;
+  const typeNode = operand.childForFieldName('type');
+  if (!typeNode) return false;
+  const typeName = extractGoTypeName(typeNode);
+  if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
+  return true;
+}
+
+/** x := NewFoo() or x := pkg.NewFoo() — factory function (confidence 0.7). */
+function inferFactoryCall(
+  varNode: TreeSitterNode,
+  rhs: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
+): boolean {
+  if (rhs.type !== 'call_expression') return false;
+  const fn = rhs.childForFieldName('function');
+  if (!fn) return false;
+
+  if (fn.type === 'selector_expression') {
+    const field = fn.childForFieldName('field');
+    if (field?.text.startsWith('New')) {
+      const typeName = field.text.slice(3);
       if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 0.7);
+      return true;
     }
+  } else if (fn.type === 'identifier' && fn.text.startsWith('New')) {
+    const typeName = fn.text.slice(3);
+    if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 0.7);
+    return true;
   }
+  return false;
+}
+
+function inferShortVarType(
+  varNode: TreeSitterNode,
+  rhs: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
+): void {
+  if (inferCompositeLiteral(varNode, rhs, typeMap)) return;
+  if (inferAddressOfComposite(varNode, rhs, typeMap)) return;
+  inferFactoryCall(varNode, rhs, typeMap);
 }
 
 /** Handle short_var_declaration: x := Struct{}, x := &Struct{}, x := NewFoo(). */

package/src/extractors/javascript.ts

@@ -202,6 +202,48 @@ function handleExportCapture(
   }
 }
 
+function handleInterfaceCapture(
+  c: Record<string, TreeSitterNode>,
+  definitions: Definition[],
+): void {
+  const ifaceNode = c.iface_node!;
+  const ifaceName = c.iface_name!.text;
+  definitions.push({
+    name: ifaceName,
+    kind: 'interface',
+    line: ifaceNode.startPosition.row + 1,
+    endLine: nodeEndLine(ifaceNode),
+  });
+  const body =
+    ifaceNode.childForFieldName('body') ||
+    findChild(ifaceNode, 'interface_body') ||
+    findChild(ifaceNode, 'object_type');
+  if (body) extractInterfaceMethods(body, ifaceName, definitions);
+}
+
+function handleTypeCapture(c: Record<string, TreeSitterNode>, definitions: Definition[]): void {
+  const typeNode = c.type_node!;
+  definitions.push({
+    name: c.type_name!.text,
+    kind: 'type',
+    line: typeNode.startPosition.row + 1,
+    endLine: nodeEndLine(typeNode),
+  });
+}
+
+function handleImportCapture(c: Record<string, TreeSitterNode>, imports: Import[]): void {
+  const impNode = c.imp_node!;
+  const isTypeOnly = impNode.text.startsWith('import type');
+  const modPath = c.imp_source!.text.replace(/['"]/g, '');
+  const names = extractImportNames(impNode);
+  imports.push({
+    source: modPath,
+    names,
+    line: impNode.startPosition.row + 1,
+    typeOnly: isTypeOnly,
+  });
+}
+
 /** Dispatch a single query match to the appropriate handler. */
 function dispatchQueryMatch(
   c: Record<string, TreeSitterNode>,
@@ -220,35 +262,11 @@ function dispatchQueryMatch(
   } else if (c.meth_node) {
     handleMethodCapture(c, definitions);
   } else if (c.iface_node) {
-    const ifaceName = c.iface_name!.text;
-    definitions.push({
-      name: ifaceName,
-      kind: 'interface',
-      line: c.iface_node.startPosition.row + 1,
-      endLine: nodeEndLine(c.iface_node),
-    });
-    const body =
-      c.iface_node.childForFieldName('body') ||
-      findChild(c.iface_node, 'interface_body') ||
-      findChild(c.iface_node, 'object_type');
-    if (body) extractInterfaceMethods(body, ifaceName, definitions);
+    handleInterfaceCapture(c, definitions);
   } else if (c.type_node) {
-    definitions.push({
-      name: c.type_name!.text,
-      kind: 'type',
-      line: c.type_node.startPosition.row + 1,
-      endLine: nodeEndLine(c.type_node),
-    });
+    handleTypeCapture(c, definitions);
   } else if (c.imp_node) {
-    const isTypeOnly = c.imp_node.text.startsWith('import type');
-    const modPath = c.imp_source!.text.replace(/['"]/g, '');
-    const names = extractImportNames(c.imp_node);
-    imports.push({
-      source: modPath,
-      names,
-      line: c.imp_node.startPosition.row + 1,
-      typeOnly: isTypeOnly,
-    });
+    handleImportCapture(c, imports);
   } else if (c.exp_node) {
     handleExportCapture(c, exps, imports);
   } else if (c.callfn_node) {
@@ -264,6 +282,14 @@ function dispatchQueryMatch(
   } else if (c.callsub_node) {
     const callInfo = extractCallInfo(c.callsub_fn!, c.callsub_node);
     if (callInfo) calls.push(callInfo);
+  } else if (c.newfn_node) {
+    calls.push({
+      name: c.newfn_name!.text,
+      line: c.newfn_node.startPosition.row + 1,
+    });
+  } else if (c.newmem_node) {
+    const callInfo = extractCallInfo(c.newmem_fn!, c.newmem_node);
+    if (callInfo) calls.push(callInfo);
   } else if (c.assign_node) {
     handleCommonJSAssignment(c.assign_left!, c.assign_right!, c.assign_node, imports);
   }
@@ -502,6 +528,9 @@ function walkJavaScriptNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'call_expression':
       handleCallExpr(node, ctx);
       break;
+    case 'new_expression':
+      handleNewExpr(node, ctx);
+      break;
     case 'import_statement':
       handleImportStmt(node, ctx);
       break;
@@ -689,6 +718,17 @@ function handleCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+function handleNewExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const ctor = node.childForFieldName('constructor') || node.child(1);
+  if (!ctor) return;
+  if (ctor.type === 'identifier') {
+    ctx.calls.push({ name: ctor.text, line: node.startPosition.row + 1 });
+  } else if (ctor.type === 'member_expression') {
+    const callInfo = extractCallInfo(ctor, node);
+    if (callInfo) ctx.calls.push(callInfo);
+  }
+}
+
 /** Handle a dynamic import() call expression and add to imports if static. */
 function handleDynamicImportCall(node: TreeSitterNode, imports: Import[]): void {
   const args = node.childForFieldName('arguments') || findChild(node, 'arguments');

package/src/features/audit.ts

@@ -7,6 +7,7 @@ import { loadConfig } from '../infrastructure/config.js';
 import { debug } from '../infrastructure/logger.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
 import { toErrorMessage } from '../shared/errors.js';
+import { toSymbolRef } from '../shared/normalize.js';
 import type { BetterSqlite3Database, CodegraphConfig } from '../types.js';
 import { RULE_DEFS } from './manifesto.js';
 
@@ -317,7 +318,7 @@ function enrichSymbol(
          WHERE e.source_id = ? AND e.kind = 'calls'`,
         )
         .all(nodeId) as SymbolRef[]
-    ).map((c) => ({ name: c.name, kind: c.kind, file: c.file, line: c.line }));
+    ).map(toSymbolRef);
 
     callers = (
       db
@@ -327,7 +328,7 @@ function enrichSymbol(
          WHERE e.target_id = ? AND e.kind = 'calls'`,
         )
         .all(nodeId) as SymbolRef[]
-    ).map((c) => ({ name: c.name, kind: c.kind, file: c.file, line: c.line }));
+    ).map(toSymbolRef);
     if (noTests) callers = callers.filter((c) => !isTestFile(c.file));
 
     const testCallerRows = db

package/src/features/boundaries.ts

@@ -1,5 +1,5 @@
-import { debug } from '../infrastructure/logger.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
+import { BoundaryError } from '../shared/errors.js';
 import type { BetterSqlite3Database } from '../types.js';
 
 // ─── Glob-to-Regex ───────────────────────────────────────────────────
@@ -269,8 +269,7 @@ export function evaluateBoundaries(
 
   const { valid, errors } = validateBoundaryConfig(boundaryConfig);
   if (!valid) {
-    debug(`boundary config validation failed: ${errors.join('; ')}`);
-    return { violations: [], violationCount: 0 };
+    throw new BoundaryError(`Invalid boundary configuration: ${errors.join('; ')}`);
   }
 
   const modules = resolveModules(boundaryConfig);
@@ -297,8 +296,7 @@ export function evaluateBoundaries(
       )
       .all() as Array<{ source: string; target: string }>;
   } catch (err) {
-    debug(`boundary edge query failed: ${(err as Error).message}`);
-    return { violations: [], violationCount: 0 };
+    throw new BoundaryError('Boundary evaluation failed', { cause: err as Error });
   }
 
   if (opts.noTests) {

package/src/features/branch-compare.ts

@@ -9,6 +9,7 @@ import { debug } from '../infrastructure/logger.js';
 import { getNative, isNativeAvailable } from '../infrastructure/native.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
 import { toErrorMessage } from '../shared/errors.js';
+import { toSymbolRef } from '../shared/normalize.js';
 import type { EngineMode, NativeDatabase } from '../types.js';
 
 // ─── Git Helpers ────────────────────────────────────────────────────────
@@ -255,9 +256,7 @@ function loadCallersFromDb(
             if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
               visited.add(c.id);
               nextFrontier.push(c.id);
-              allCallers.add(
-                JSON.stringify({ name: c.name, kind: c.kind, file: c.file, line: c.line }),
-              );
+              allCallers.add(JSON.stringify(toSymbolRef(c)));
             }
           }
         }

package/src/features/complexity.ts

@@ -535,75 +535,97 @@ function upsertAstComplexity(
   return 1;
 }
 
-export async function buildComplexityMetrics(
+/** Collect native bulk-insert rows from precomputed complexity data.
+ *  Returns the rows array, or null if any definition is missing complexity
+ *  (signalling that JS fallback is needed). */
+function collectNativeBulkRows(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+): Array<Record<string, unknown>> | null {
+  const rows: Array<Record<string, unknown>> = [];
+
+  for (const [relPath, symbols] of fileSymbols) {
+    for (const def of symbols.definitions) {
+      if (def.kind !== 'function' && def.kind !== 'method') continue;
+      if (!def.line) continue;
+      // Interface/type property signatures and single-line stubs are extracted
+      // as methods but the native engine correctly never assigns complexity.
+      // Mirror the leniency in initWasmParsersIfNeeded to avoid bailing out
+      // of the native bulk-insert path for every TypeScript codebase (#846).
+      if (!def.complexity) {
+        if (def.name.includes('.') || !def.endLine || def.endLine <= def.line) continue;
+        return null; // genuine function body missing complexity — needs JS fallback
+      }
+      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,
+      });
+    }
+  }
+
+  return rows;
+}
+
+/** Try the native bulk-insert fast path. Returns true if all rows were
+ *  inserted successfully (caller can return early). */
+function tryNativeBulkInsert(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbols>,
-  rootDir: string,
   engineOpts?: {
     nativeDb?: { bulkInsertComplexity?(rows: Array<Record<string, unknown>>): number };
     suspendJsDb?: () => void;
     resumeJsDb?: () => void;
   },
-): Promise<void> {
-  // ── Native bulk-insert fast path ──────────────────────────────────────
+): boolean {
   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 (!nativeDb?.bulkInsertComplexity) return false;
+
+  const rows = collectNativeBulkRows(db, fileSymbols);
+  if (rows === null) return false; // missing complexity — needs JS fallback
+  if (rows.length === 0) return true; // nothing to insert — native path done
+
+  let inserted: number;
+  try {
+    engineOpts?.suspendJsDb?.();
+    inserted = nativeDb.bulkInsertComplexity(rows);
+  } finally {
+    engineOpts?.resumeJsDb?.();
+  }
 
-    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`);
-    }
+  if (inserted === rows.length) {
+    info(`Complexity (native bulk): ${inserted} functions analyzed`);
+    return true;
   }
+  debug(`Native bulkInsertComplexity partial: ${inserted}/${rows.length} — falling back to JS`);
+  return false;
+}
 
-  // ── JS fallback path ─────────────────────────────────────────────────
+/** JS/WASM fallback: parse files and compute metrics via AST traversal. */
+async function computeJsFallbackMetrics(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  rootDir: string,
+): Promise<void> {
   const { parsers, extToLang } = await initWasmParsersIfNeeded(fileSymbols);
   const { getParser } = await import('../domain/parser.js');
 
@@ -649,6 +671,20 @@ export async function buildComplexityMetrics(
   }
 }
 
+export async function buildComplexityMetrics(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  rootDir: string,
+  engineOpts?: {
+    nativeDb?: { bulkInsertComplexity?(rows: Array<Record<string, unknown>>): number };
+    suspendJsDb?: () => void;
+    resumeJsDb?: () => void;
+  },
+): Promise<void> {
+  if (tryNativeBulkInsert(db, fileSymbols, engineOpts)) return;
+  await computeJsFallbackMetrics(db, fileSymbols, rootDir);
+}
+
 // ─── Query-Time Functions (re-exported from complexity-query.ts) ──────────
 // Split to separate query-time concerns (DB reads, filtering, pagination)
 // from compute-time concerns (AST traversal, metric algorithms).