@optave/codegraph 3.0.4 → 3.1.1

package/src/cfg.js

@@ -7,265 +7,25 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { COMPLEXITY_RULES } from './complexity.js';
+import { CFG_RULES, COMPLEXITY_RULES } from './ast-analysis/rules/index.js';
+import {
+  makeCfgRules as _makeCfgRules,
+  buildExtensionSet,
+  buildExtToLangMap,
+  findFunctionNode,
+} from './ast-analysis/shared.js';
 import { openReadonlyOrFail } from './db.js';
 import { info } from './logger.js';
-import { paginateResult, printNdjson } from './paginate.js';
-import { LANGUAGE_REGISTRY } from './parser.js';
-import { isTestFile } from './queries.js';
-
-// ─── CFG Node Type Rules (extends COMPLEXITY_RULES) ──────────────────────
-
-const CFG_DEFAULTS = {
-  ifNode: null,
-  ifNodes: null,
-  elifNode: null,
-  elseClause: null,
-  elseViaAlternative: false,
-  ifConsequentField: null,
-  forNodes: new Set(),
-  whileNode: null,
-  whileNodes: null,
-  doNode: null,
-  infiniteLoopNode: null,
-  unlessNode: null,
-  untilNode: null,
-  switchNode: null,
-  switchNodes: null,
-  caseNode: null,
-  caseNodes: null,
-  defaultNode: null,
-  tryNode: null,
-  catchNode: null,
-  finallyNode: null,
-  returnNode: null,
-  throwNode: null,
-  breakNode: null,
-  continueNode: null,
-  blockNode: null,
-  blockNodes: null,
-  labeledNode: null,
-  functionNodes: new Set(),
-};
-
-const CFG_RULE_KEYS = new Set(Object.keys(CFG_DEFAULTS));
-
-export function makeCfgRules(overrides) {
-  for (const key of Object.keys(overrides)) {
-    if (!CFG_RULE_KEYS.has(key)) {
-      throw new Error(`CFG rules: unknown key "${key}"`);
-    }
-  }
-  const rules = { ...CFG_DEFAULTS, ...overrides };
-  if (!(rules.functionNodes instanceof Set) || rules.functionNodes.size === 0) {
-    throw new Error('CFG rules: functionNodes must be a non-empty Set');
-  }
-  if (!(rules.forNodes instanceof Set)) {
-    throw new Error('CFG rules: forNodes must be a Set');
-  }
-  return rules;
-}
+import { paginateResult } from './paginate.js';
 
-const JS_TS_CFG = makeCfgRules({
-  ifNode: 'if_statement',
-  elseClause: 'else_clause',
-  forNodes: new Set(['for_statement', 'for_in_statement']),
-  whileNode: 'while_statement',
-  doNode: 'do_statement',
-  switchNode: 'switch_statement',
-  caseNode: 'switch_case',
-  defaultNode: 'switch_default',
-  tryNode: 'try_statement',
-  catchNode: 'catch_clause',
-  finallyNode: 'finally_clause',
-  returnNode: 'return_statement',
-  throwNode: 'throw_statement',
-  breakNode: 'break_statement',
-  continueNode: 'continue_statement',
-  blockNode: 'statement_block',
-  labeledNode: 'labeled_statement',
-  functionNodes: new Set([
-    'function_declaration',
-    'function_expression',
-    'arrow_function',
-    'method_definition',
-    'generator_function',
-    'generator_function_declaration',
-  ]),
-});
-
-const PYTHON_CFG = makeCfgRules({
-  ifNode: 'if_statement',
-  elifNode: 'elif_clause',
-  elseClause: 'else_clause',
-  forNodes: new Set(['for_statement']),
-  whileNode: 'while_statement',
-  switchNode: 'match_statement',
-  caseNode: 'case_clause',
-  tryNode: 'try_statement',
-  catchNode: 'except_clause',
-  finallyNode: 'finally_clause',
-  returnNode: 'return_statement',
-  throwNode: 'raise_statement',
-  breakNode: 'break_statement',
-  continueNode: 'continue_statement',
-  blockNode: 'block',
-  functionNodes: new Set(['function_definition']),
-});
-
-const GO_CFG = makeCfgRules({
-  ifNode: 'if_statement',
-  elseViaAlternative: true,
-  forNodes: new Set(['for_statement']),
-  switchNodes: new Set([
-    'expression_switch_statement',
-    'type_switch_statement',
-    'select_statement',
-  ]),
-  caseNode: 'expression_case',
-  caseNodes: new Set(['type_case', 'communication_case']),
-  defaultNode: 'default_case',
-  returnNode: 'return_statement',
-  breakNode: 'break_statement',
-  continueNode: 'continue_statement',
-  blockNode: 'block',
-  labeledNode: 'labeled_statement',
-  functionNodes: new Set(['function_declaration', 'method_declaration', 'func_literal']),
-});
-
-const RUST_CFG = makeCfgRules({
-  ifNode: 'if_expression',
-  ifNodes: new Set(['if_let_expression']),
-  elseClause: 'else_clause',
-  forNodes: new Set(['for_expression']),
-  whileNode: 'while_expression',
-  whileNodes: new Set(['while_let_expression']),
-  infiniteLoopNode: 'loop_expression',
-  switchNode: 'match_expression',
-  caseNode: 'match_arm',
-  returnNode: 'return_expression',
-  breakNode: 'break_expression',
-  continueNode: 'continue_expression',
-  blockNode: 'block',
-  functionNodes: new Set(['function_item', 'closure_expression']),
-});
-
-const JAVA_CFG = makeCfgRules({
-  ifNode: 'if_statement',
-  elseViaAlternative: true,
-  forNodes: new Set(['for_statement', 'enhanced_for_statement']),
-  whileNode: 'while_statement',
-  doNode: 'do_statement',
-  switchNode: 'switch_expression',
-  caseNode: 'switch_block_statement_group',
-  caseNodes: new Set(['switch_rule']),
-  tryNode: 'try_statement',
-  catchNode: 'catch_clause',
-  finallyNode: 'finally_clause',
-  returnNode: 'return_statement',
-  throwNode: 'throw_statement',
-  breakNode: 'break_statement',
-  continueNode: 'continue_statement',
-  blockNode: 'block',
-  labeledNode: 'labeled_statement',
-  functionNodes: new Set(['method_declaration', 'constructor_declaration', 'lambda_expression']),
-});
-
-const CSHARP_CFG = makeCfgRules({
-  ifNode: 'if_statement',
-  elseViaAlternative: true,
-  forNodes: new Set(['for_statement', 'foreach_statement']),
-  whileNode: 'while_statement',
-  doNode: 'do_statement',
-  switchNode: 'switch_statement',
-  caseNode: 'switch_section',
-  tryNode: 'try_statement',
-  catchNode: 'catch_clause',
-  finallyNode: 'finally_clause',
-  returnNode: 'return_statement',
-  throwNode: 'throw_statement',
-  breakNode: 'break_statement',
-  continueNode: 'continue_statement',
-  blockNode: 'block',
-  labeledNode: 'labeled_statement',
-  functionNodes: new Set([
-    'method_declaration',
-    'constructor_declaration',
-    'lambda_expression',
-    'local_function_statement',
-  ]),
-});
-
-const RUBY_CFG = makeCfgRules({
-  ifNode: 'if',
-  elifNode: 'elsif',
-  elseClause: 'else',
-  forNodes: new Set(['for']),
-  whileNode: 'while',
-  unlessNode: 'unless',
-  untilNode: 'until',
-  switchNode: 'case',
-  caseNode: 'when',
-  defaultNode: 'else',
-  tryNode: 'begin',
-  catchNode: 'rescue',
-  finallyNode: 'ensure',
-  returnNode: 'return',
-  breakNode: 'break',
-  continueNode: 'next',
-  blockNodes: new Set(['then', 'do', 'body_statement']),
-  functionNodes: new Set(['method', 'singleton_method']),
-});
-
-const PHP_CFG = makeCfgRules({
-  ifNode: 'if_statement',
-  elifNode: 'else_if_clause',
-  elseClause: 'else_clause',
-  ifConsequentField: 'body',
-  forNodes: new Set(['for_statement', 'foreach_statement']),
-  whileNode: 'while_statement',
-  doNode: 'do_statement',
-  switchNode: 'switch_statement',
-  caseNode: 'case_statement',
-  defaultNode: 'default_statement',
-  tryNode: 'try_statement',
-  catchNode: 'catch_clause',
-  finallyNode: 'finally_clause',
-  returnNode: 'return_statement',
-  throwNode: 'throw_expression',
-  breakNode: 'break_statement',
-  continueNode: 'continue_statement',
-  blockNode: 'compound_statement',
-  functionNodes: new Set([
-    'function_definition',
-    'method_declaration',
-    'anonymous_function_creation_expression',
-    'arrow_function',
-  ]),
-});
-
-export const CFG_RULES = new Map([
-  ['javascript', JS_TS_CFG],
-  ['typescript', JS_TS_CFG],
-  ['tsx', JS_TS_CFG],
-  ['python', PYTHON_CFG],
-  ['go', GO_CFG],
-  ['rust', RUST_CFG],
-  ['java', JAVA_CFG],
-  ['csharp', CSHARP_CFG],
-  ['ruby', RUBY_CFG],
-  ['php', PHP_CFG],
-]);
-
-const CFG_LANG_IDS = new Set(CFG_RULES.keys());
-
-// JS/TS extensions
-const CFG_EXTENSIONS = new Set();
-for (const entry of LANGUAGE_REGISTRY) {
-  if (CFG_LANG_IDS.has(entry.id)) {
-    for (const ext of entry.extensions) CFG_EXTENSIONS.add(ext);
-  }
-}
+import { outputResult } from './result-formatter.js';
+import { isTestFile } from './test-filter.js';
+
+// Re-export for backward compatibility
+export { CFG_RULES };
+export { _makeCfgRules as makeCfgRules };
+
+const CFG_EXTENSIONS = buildExtensionSet(CFG_RULES);
 
 // ─── Core Algorithm: AST → CFG ──────────────────────────────────────────
 
@@ -327,11 +87,23 @@ export function buildFunctionCFG(functionNode, langId) {
    */
   function getStatements(node) {
     if (!node) return [];
-    // Block-like nodes: extract named children
-    if (node.type === rules.blockNode || rules.blockNodes?.has(node.type)) {
+    // Block-like nodes (including statement_list wrappers from tree-sitter-go 0.25+)
+    if (
+      node.type === 'statement_list' ||
+      node.type === rules.blockNode ||
+      rules.blockNodes?.has(node.type)
+    ) {
       const stmts = [];
       for (let i = 0; i < node.namedChildCount; i++) {
-        stmts.push(node.namedChild(i));
+        const child = node.namedChild(i);
+        if (child.type === 'statement_list') {
+          // Unwrap nested statement_list (block → statement_list → stmts)
+          for (let j = 0; j < child.namedChildCount; j++) {
+            stmts.push(child.namedChild(j));
+          }
+        } else {
+          stmts.push(child);
+        }
       }
       return stmts;
     }
@@ -888,7 +660,14 @@ export function buildFunctionCFG(functionNode, langId) {
         for (let j = 0; j < caseClause.namedChildCount; j++) {
           const child = caseClause.namedChild(j);
           if (child !== valueNode && child !== patternNode && child.type !== 'switch_label') {
-            caseStmts.push(child);
+            if (child.type === 'statement_list') {
+              // Unwrap statement_list (tree-sitter-go 0.25+)
+              for (let k = 0; k < child.namedChildCount; k++) {
+                caseStmts.push(child.namedChild(k));
+              }
+            } else {
+              caseStmts.push(child);
+            }
           }
         }
       }
@@ -1046,9 +825,12 @@ export function buildFunctionCFG(functionNode, langId) {
 export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
   // Lazily init WASM parsers if needed
   let parsers = null;
-  let extToLang = null;
   let needsFallback = false;
 
+  // Always build ext→langId map so native-only builds (where _langId is unset)
+  // can still derive the language from the file extension.
+  const extToLang = buildExtToLangMap();
+
   for (const [relPath, symbols] of fileSymbols) {
     if (!symbols._tree) {
       const ext = path.extname(relPath).toLowerCase();
@@ -1068,12 +850,6 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
   if (needsFallback) {
     const { createParsers } = await import('./parser.js');
     parsers = await createParsers();
-    extToLang = new Map();
-    for (const entry of LANGUAGE_REGISTRY) {
-      for (const ext of entry.extensions) {
-        extToLang.set(ext, entry.id);
-      }
-    }
   }
 
   let getParserFn = null;
@@ -1082,7 +858,7 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
     getParserFn = mod.getParser;
   }
 
-  const { findFunctionNode } = await import('./complexity.js');
+  // findFunctionNode imported from ./ast-analysis/shared.js at module level
 
   const insertBlock = db.prepare(
     `INSERT INTO cfg_blocks (function_node_id, block_index, block_type, start_line, end_line, label)
@@ -1115,9 +891,9 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
 
       // WASM fallback if no cached tree and not all native
       if (!tree && !allNative) {
-        if (!extToLang || !getParserFn) continue;
+        if (!getParserFn) continue;
         langId = extToLang.get(ext);
-        if (!langId || !CFG_LANG_IDS.has(langId)) continue;
+        if (!langId || !CFG_RULES.has(langId)) continue;
 
         const absPath = path.join(rootDir, relPath);
         let code;
@@ -1138,7 +914,7 @@ export async function buildCFGData(db, fileSymbols, rootDir, _engineOpts) {
       }
 
       if (!langId) {
-        langId = extToLang ? extToLang.get(ext) : null;
+        langId = extToLang.get(ext);
         if (!langId) continue;
       }
 
@@ -1253,72 +1029,73 @@ function findNodes(db, name, opts = {}) {
  */
 export function cfgData(name, customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);
-  const noTests = opts.noTests || false;
-
-  if (!hasCfgTables(db)) {
-    db.close();
-    return {
-      name,
-      results: [],
-      warning:
-        'No CFG data found. Rebuild with `codegraph build` (CFG is now included by default).',
-    };
-  }
+  try {
+    const noTests = opts.noTests || false;
+
+    if (!hasCfgTables(db)) {
+      return {
+        name,
+        results: [],
+        warning:
+          'No CFG data found. Rebuild with `codegraph build` (CFG is now included by default).',
+      };
+    }
 
-  const nodes = findNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
-  if (nodes.length === 0) {
-    db.close();
-    return { name, results: [] };
-  }
+    const nodes = findNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+    if (nodes.length === 0) {
+      return { name, results: [] };
+    }
 
-  const blockStmt = db.prepare(
-    `SELECT id, block_index, block_type, start_line, end_line, label
-     FROM cfg_blocks WHERE function_node_id = ?
-     ORDER BY block_index`,
-  );
-  const edgeStmt = db.prepare(
-    `SELECT e.kind,
-            sb.block_index AS source_index, sb.block_type AS source_type,
-            tb.block_index AS target_index, tb.block_type AS target_type
-     FROM cfg_edges e
-     JOIN cfg_blocks sb ON e.source_block_id = sb.id
-     JOIN cfg_blocks tb ON e.target_block_id = tb.id
-     WHERE e.function_node_id = ?
-     ORDER BY sb.block_index, tb.block_index`,
-  );
+    const blockStmt = db.prepare(
+      `SELECT id, block_index, block_type, start_line, end_line, label
+       FROM cfg_blocks WHERE function_node_id = ?
+       ORDER BY block_index`,
+    );
+    const edgeStmt = db.prepare(
+      `SELECT e.kind,
+              sb.block_index AS source_index, sb.block_type AS source_type,
+              tb.block_index AS target_index, tb.block_type AS target_type
+       FROM cfg_edges e
+       JOIN cfg_blocks sb ON e.source_block_id = sb.id
+       JOIN cfg_blocks tb ON e.target_block_id = tb.id
+       WHERE e.function_node_id = ?
+       ORDER BY sb.block_index, tb.block_index`,
+    );
 
-  const results = nodes.map((node) => {
-    const cfgBlocks = blockStmt.all(node.id);
-    const cfgEdges = edgeStmt.all(node.id);
-
-    return {
-      name: node.name,
-      kind: node.kind,
-      file: node.file,
-      line: node.line,
-      blocks: cfgBlocks.map((b) => ({
-        index: b.block_index,
-        type: b.block_type,
-        startLine: b.start_line,
-        endLine: b.end_line,
-        label: b.label,
-      })),
-      edges: cfgEdges.map((e) => ({
-        source: e.source_index,
-        sourceType: e.source_type,
-        target: e.target_index,
-        targetType: e.target_type,
-        kind: e.kind,
-      })),
-      summary: {
-        blockCount: cfgBlocks.length,
-        edgeCount: cfgEdges.length,
-      },
-    };
-  });
+    const results = nodes.map((node) => {
+      const cfgBlocks = blockStmt.all(node.id);
+      const cfgEdges = edgeStmt.all(node.id);
+
+      return {
+        name: node.name,
+        kind: node.kind,
+        file: node.file,
+        line: node.line,
+        blocks: cfgBlocks.map((b) => ({
+          index: b.block_index,
+          type: b.block_type,
+          startLine: b.start_line,
+          endLine: b.end_line,
+          label: b.label,
+        })),
+        edges: cfgEdges.map((e) => ({
+          source: e.source_index,
+          sourceType: e.source_type,
+          target: e.target_index,
+          targetType: e.target_type,
+          kind: e.kind,
+        })),
+        summary: {
+          blockCount: cfgBlocks.length,
+          edgeCount: cfgEdges.length,
+        },
+      };
+    });
 
-  db.close();
-  return paginateResult({ name, results }, 'results', opts);
+    return paginateResult({ name, results }, 'results', opts);
+  } finally {
+    db.close();
+  }
 }
 
 // ─── Export Formats ─────────────────────────────────────────────────────
@@ -1416,14 +1193,7 @@ function edgeStyle(kind) {
 export function cfg(name, customDbPath, opts = {}) {
   const data = cfgData(name, customDbPath, opts);
 
-  if (opts.json) {
-    console.log(JSON.stringify(data, null, 2));
-    return;
-  }
-  if (opts.ndjson) {
-    printNdjson(data.results);
-    return;
-  }
+  if (outputResult(data, 'results', opts)) return;
 
   if (data.warning) {
     console.log(`\u26A0  ${data.warning}`);

package/src/check.js

@@ -5,7 +5,8 @@ import { loadConfig } from './config.js';
 import { findCycles } from './cycles.js';
 import { findDbPath, openReadonlyOrFail } from './db.js';
 import { matchOwners, parseCodeowners } from './owners.js';
-import { isTestFile } from './queries.js';
+import { outputResult } from './result-formatter.js';
+import { isTestFile } from './test-filter.js';
 
 // ─── Diff Parser ──────────────────────────────────────────────────────
 
@@ -361,8 +362,7 @@ export function check(customDbPath, opts = {}) {
     process.exit(1);
   }
 
-  if (opts.json) {
-    console.log(JSON.stringify(data, null, 2));
+  if (outputResult(data, null, opts)) {
     if (!data.passed) process.exit(1);
     return;
   }