@optave/codegraph 3.3.1 → 3.4.1

package/src/ast-analysis/{engine.js → engine.ts}

@@ -19,6 +19,22 @@ import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { bulkNodeIdsByFile } from '../db/index.js';
 import { debug } from '../infrastructure/logger.js';
+import type {
+  AnalysisOpts,
+  AnalysisTiming,
+  ASTNodeRow,
+  BetterSqlite3Database,
+  CfgBlock,
+  CfgEdge,
+  DataflowResult,
+  Definition,
+  EngineOpts,
+  ExtractorOutput,
+  TreeSitterNode,
+  Visitor,
+  WalkOptions,
+  WalkResults,
+} from '../types.js';
 import { computeLOCMetrics, computeMaintainabilityIndex } from './metrics.js';
 import {
   AST_TYPE_MAPS,
@@ -35,6 +51,35 @@ import { createCfgVisitor } from './visitors/cfg-visitor.js';
 import { createComplexityVisitor } from './visitors/complexity-visitor.js';
 import { createDataflowVisitor } from './visitors/dataflow-visitor.js';
 
+// ─── Visitor result shapes (internal, not exported) ──────────────────────
+
+interface ComplexityFuncResult {
+  funcNode: TreeSitterNode;
+  funcName: string | null;
+  metrics: {
+    cognitive: number;
+    cyclomatic: number;
+    maxNesting: number;
+    halstead?: { volume: number; difficulty: number; effort: number; bugs: number };
+  };
+}
+
+interface CfgFuncResult {
+  funcNode: TreeSitterNode;
+  blocks: CfgBlock[];
+  edges: CfgEdge[];
+  cyclomatic?: number;
+}
+
+interface SetupResult {
+  visitors: Visitor[];
+  walkerOpts: WalkOptions;
+  astVisitor: Visitor | null;
+  complexityVisitor: Visitor | null;
+  cfgVisitor: Visitor | null;
+  dataflowVisitor: Visitor | null;
+}
+
 // ─── Extension sets for quick language-support checks ────────────────────
 
 const CFG_EXTENSIONS = buildExtensionSet(CFG_RULES);
@@ -44,15 +89,19 @@ const WALK_EXTENSIONS = buildExtensionSet(AST_TYPE_MAPS);
 
 // ─── Lazy imports (heavy modules loaded only when needed) ────────────────
 
-let _parserModule = null;
-async function getParserModule() {
+let _parserModule: Awaited<typeof import('../domain/parser.js')> | null = null;
+async function getParserModule(): Promise<typeof import('../domain/parser.js')> {
   if (!_parserModule) _parserModule = await import('../domain/parser.js');
   return _parserModule;
 }
 
 // ─── WASM pre-parse ─────────────────────────────────────────────────────
 
-async function ensureWasmTreesIfNeeded(fileSymbols, opts, rootDir) {
+async function ensureWasmTreesIfNeeded(
+  fileSymbols: Map<string, ExtractorOutput>,
+  opts: AnalysisOpts,
+  rootDir: string,
+): Promise<void> {
   const doComplexity = opts.complexity !== false;
   const doCfg = opts.cfg !== false;
   const doDataflow = opts.dataflow !== false;
@@ -65,20 +114,31 @@ async function ensureWasmTreesIfNeeded(fileSymbols, opts, rootDir) {
     const ext = path.extname(relPath).toLowerCase();
     const defs = symbols.definitions || [];
 
+    // Only consider definitions with a real function body.
+    // Interface/type property signatures are extracted as methods but correctly
+    // lack complexity/CFG data from the native engine. Exclude them by:
+    // 1. Single-line span (endLine === line) — type property on one line
+    // 2. Dotted names (e.g. "Interface.prop") — child definitions of types
+    const hasFuncBody = (d: {
+      name: string;
+      kind: string;
+      line: number;
+      endLine?: number | null;
+    }) =>
+      (d.kind === 'function' || d.kind === 'method') &&
+      d.line > 0 &&
+      d.endLine != null &&
+      d.endLine > d.line &&
+      !d.name.includes('.');
+
     const needsComplexity =
       doComplexity &&
       COMPLEXITY_EXTENSIONS.has(ext) &&
-      defs.some((d) => (d.kind === 'function' || d.kind === 'method') && d.line && !d.complexity);
+      defs.some((d) => hasFuncBody(d) && !d.complexity);
     const needsCfg =
       doCfg &&
       CFG_EXTENSIONS.has(ext) &&
-      defs.some(
-        (d) =>
-          (d.kind === 'function' || d.kind === 'method') &&
-          d.line &&
-          d.cfg !== null &&
-          !Array.isArray(d.cfg?.blocks),
-      );
+      defs.some((d) => hasFuncBody(d) && d.cfg !== null && !Array.isArray(d.cfg?.blocks));
     const needsDataflow = doDataflow && !symbols.dataflow && DATAFLOW_EXTENSIONS.has(ext);
 
     if (needsComplexity || needsCfg || needsDataflow) {
@@ -91,15 +151,21 @@ async function ensureWasmTreesIfNeeded(fileSymbols, opts, rootDir) {
     try {
       const { ensureWasmTrees } = await getParserModule();
       await ensureWasmTrees(fileSymbols, rootDir);
-    } catch (err) {
-      debug(`ensureWasmTrees failed: ${err.message}`);
+    } catch (err: unknown) {
+      debug(`ensureWasmTrees failed: ${(err as Error).message}`);
     }
   }
 }
 
 // ─── Per-file visitor setup ─────────────────────────────────────────────
 
-function setupVisitors(db, relPath, symbols, langId, opts) {
+function setupVisitors(
+  db: BetterSqlite3Database,
+  relPath: string,
+  symbols: ExtractorOutput,
+  langId: string,
+  opts: AnalysisOpts,
+): SetupResult {
   const ext = path.extname(relPath).toLowerCase();
   const defs = symbols.definitions || [];
   const doAst = opts.ast !== false;
@@ -107,18 +173,18 @@ function setupVisitors(db, relPath, symbols, langId, opts) {
   const doCfg = opts.cfg !== false;
   const doDataflow = opts.dataflow !== false;
 
-  const visitors = [];
-  const walkerOpts = {
-    functionNodeTypes: new Set(),
-    nestingNodeTypes: new Set(),
-    getFunctionName: (_node) => null,
+  const visitors: Visitor[] = [];
+  const walkerOpts: WalkOptions = {
+    functionNodeTypes: new Set<string>(),
+    nestingNodeTypes: new Set<string>(),
+    getFunctionName: (_node: TreeSitterNode) => null,
   };
 
   // AST-store visitor
-  let astVisitor = null;
+  let astVisitor: Visitor | null = null;
   const astTypeMap = AST_TYPE_MAPS.get(langId);
-  if (doAst && astTypeMap && WALK_EXTENSIONS.has(ext) && !symbols.astNodes?.length) {
-    const nodeIdMap = new Map();
+  if (doAst && astTypeMap && WALK_EXTENSIONS.has(ext) && !Array.isArray(symbols.astNodes)) {
+    const nodeIdMap = new Map<string, number>();
     for (const row of bulkNodeIdsByFile(db, relPath)) {
       nodeIdMap.set(`${row.name}|${row.kind}|${row.line}`, row.id);
     }
@@ -127,37 +193,49 @@ function setupVisitors(db, relPath, symbols, langId, opts) {
   }
 
   // Complexity visitor (file-level mode)
-  let complexityVisitor = null;
+  let complexityVisitor: Visitor | null = null;
   const cRules = COMPLEXITY_RULES.get(langId);
   const hRules = HALSTEAD_RULES.get(langId);
   if (doComplexity && cRules) {
+    // Only trigger WASM complexity for definitions with real function bodies.
+    // Interface/type property signatures (dotted names, single-line span)
+    // correctly lack native complexity data and should not trigger a fallback.
     const needsWasmComplexity = defs.some(
-      (d) => (d.kind === 'function' || d.kind === 'method') && d.line && !d.complexity,
+      (d) =>
+        (d.kind === 'function' || d.kind === 'method') &&
+        d.line > 0 &&
+        d.endLine != null &&
+        d.endLine > d.line &&
+        !d.name.includes('.') &&
+        !d.complexity,
     );
     if (needsWasmComplexity) {
       complexityVisitor = createComplexityVisitor(cRules, hRules, { fileLevelWalk: true, langId });
       visitors.push(complexityVisitor);
 
-      for (const t of cRules.nestingNodes) walkerOpts.nestingNodeTypes.add(t);
+      for (const t of cRules.nestingNodes) walkerOpts.nestingNodeTypes?.add(t);
 
       const dfRules = DATAFLOW_RULES.get(langId);
-      walkerOpts.getFunctionName = (node) => {
+      walkerOpts.getFunctionName = (node: TreeSitterNode): string | null => {
         const nameNode = node.childForFieldName('name');
         if (nameNode) return nameNode.text;
-        if (dfRules) return getFuncName(node, dfRules);
+        if (dfRules) return getFuncName(node, dfRules as any);
         return null;
       };
     }
   }
 
   // CFG visitor
-  let cfgVisitor = null;
+  let cfgVisitor: Visitor | null = null;
   const cfgRulesForLang = CFG_RULES.get(langId);
   if (doCfg && cfgRulesForLang && CFG_EXTENSIONS.has(ext)) {
     const needsWasmCfg = defs.some(
       (d) =>
         (d.kind === 'function' || d.kind === 'method') &&
-        d.line &&
+        d.line > 0 &&
+        d.endLine != null &&
+        d.endLine > d.line &&
+        !d.name.includes('.') &&
         d.cfg !== null &&
         !Array.isArray(d.cfg?.blocks),
     );
@@ -168,7 +246,7 @@ function setupVisitors(db, relPath, symbols, langId, opts) {
   }
 
   // Dataflow visitor
-  let dataflowVisitor = null;
+  let dataflowVisitor: Visitor | null = null;
   const dfRules = DATAFLOW_RULES.get(langId);
   if (doDataflow && dfRules && DATAFLOW_EXTENSIONS.has(ext) && !symbols.dataflow) {
     dataflowVisitor = createDataflowVisitor(dfRules);
@@ -180,14 +258,14 @@ function setupVisitors(db, relPath, symbols, langId, opts) {
 
 // ─── Result storage helpers ─────────────────────────────────────────────
 
-function storeComplexityResults(results, defs, langId) {
-  const complexityResults = results.complexity || [];
-  const resultByLine = new Map();
+function storeComplexityResults(results: WalkResults, defs: Definition[], langId: string): void {
+  const complexityResults = (results.complexity || []) as ComplexityFuncResult[];
+  const resultByLine = new Map<number, ComplexityFuncResult[]>();
   for (const r of complexityResults) {
     if (r.funcNode) {
       const line = r.funcNode.startPosition.row + 1;
       if (!resultByLine.has(line)) resultByLine.set(line, []);
-      resultByLine.get(line).push(r);
+      resultByLine.get(line)?.push(r);
     }
   }
   for (const def of defs) {
@@ -221,14 +299,14 @@ function storeComplexityResults(results, defs, langId) {
   }
 }
 
-function storeCfgResults(results, defs) {
-  const cfgResults = results.cfg || [];
-  const cfgByLine = new Map();
+function storeCfgResults(results: WalkResults, defs: Definition[]): void {
+  const cfgResults = (results.cfg || []) as CfgFuncResult[];
+  const cfgByLine = new Map<number, CfgFuncResult[]>();
   for (const r of cfgResults) {
     if (r.funcNode) {
       const line = r.funcNode.startPosition.row + 1;
       if (!cfgByLine.has(line)) cfgByLine.set(line, []);
-      cfgByLine.get(line).push(r);
+      cfgByLine.get(line)?.push(r);
     }
   }
   for (const def of defs) {
@@ -254,7 +332,7 @@ function storeCfgResults(results, defs) {
           def.complexity.cyclomatic = cfgResult.cyclomatic;
           const { loc, halstead } = def.complexity;
           const volume = halstead ? halstead.volume : 0;
-          const commentRatio = loc?.loc > 0 ? loc.commentLines / loc.loc : 0;
+          const commentRatio = loc && loc.loc > 0 ? loc.commentLines / loc.loc : 0;
           def.complexity.maintainabilityIndex = computeMaintainabilityIndex(
             volume,
             cfgResult.cyclomatic,
@@ -269,14 +347,21 @@ function storeCfgResults(results, defs) {
 
 // ─── Build delegation ───────────────────────────────────────────────────
 
-async function delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOpts, timing) {
+async function delegateToBuildFunctions(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, ExtractorOutput>,
+  rootDir: string,
+  opts: AnalysisOpts,
+  engineOpts: EngineOpts | undefined,
+  timing: AnalysisTiming,
+): Promise<void> {
   if (opts.ast !== false) {
     const t0 = performance.now();
     try {
       const { buildAstNodes } = await import('../features/ast.js');
-      await buildAstNodes(db, fileSymbols, rootDir, engineOpts);
-    } catch (err) {
-      debug(`buildAstNodes failed: ${err.message}`);
+      await buildAstNodes(db, fileSymbols as Map<string, any>, rootDir, engineOpts);
+    } catch (err: unknown) {
+      debug(`buildAstNodes failed: ${(err as Error).message}`);
     }
     timing.astMs = performance.now() - t0;
   }
@@ -285,9 +370,9 @@ async function delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOp
     const t0 = performance.now();
     try {
       const { buildComplexityMetrics } = await import('../features/complexity.js');
-      await buildComplexityMetrics(db, fileSymbols, rootDir, engineOpts);
-    } catch (err) {
-      debug(`buildComplexityMetrics failed: ${err.message}`);
+      await buildComplexityMetrics(db, fileSymbols as Map<string, any>, rootDir, engineOpts);
+    } catch (err: unknown) {
+      debug(`buildComplexityMetrics failed: ${(err as Error).message}`);
     }
     timing.complexityMs = performance.now() - t0;
   }
@@ -297,8 +382,8 @@ async function delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOp
     try {
       const { buildCFGData } = await import('../features/cfg.js');
       await buildCFGData(db, fileSymbols, rootDir, engineOpts);
-    } catch (err) {
-      debug(`buildCFGData failed: ${err.message}`);
+    } catch (err: unknown) {
+      debug(`buildCFGData failed: ${(err as Error).message}`);
     }
     timing.cfgMs = performance.now() - t0;
   }
@@ -308,8 +393,8 @@ async function delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOp
     try {
       const { buildDataflowEdges } = await import('../features/dataflow.js');
       await buildDataflowEdges(db, fileSymbols, rootDir, engineOpts);
-    } catch (err) {
-      debug(`buildDataflowEdges failed: ${err.message}`);
+    } catch (err: unknown) {
+      debug(`buildDataflowEdges failed: ${(err as Error).message}`);
     }
     timing.dataflowMs = performance.now() - t0;
   }
@@ -317,18 +402,14 @@ async function delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOp
 
 // ─── Public API ──────────────────────────────────────────────────────────
 
-/**
- * Run all enabled AST analyses in a coordinated pass.
- *
- * @param {object} db - open better-sqlite3 database (read-write)
- * @param {Map<string, object>} fileSymbols - Map<relPath, { definitions, calls, _tree, _langId, ... }>
- * @param {string} rootDir - absolute project root path
- * @param {object} opts - build options (ast, complexity, cfg, dataflow toggles)
- * @param {object} [engineOpts] - engine options
- * @returns {Promise<{ astMs: number, complexityMs: number, cfgMs: number, dataflowMs: number }>}
- */
-export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
-  const timing = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
+export async function runAnalyses(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, ExtractorOutput>,
+  rootDir: string,
+  opts: AnalysisOpts,
+  engineOpts?: EngineOpts,
+): Promise<AnalysisTiming> {
+  const timing: AnalysisTiming = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
 
   const doAst = opts.ast !== false;
   const doComplexity = opts.complexity !== false;
@@ -361,13 +442,13 @@ export async function runAnalyses(db, fileSymbols, rootDir, opts, engineOpts) {
     const defs = symbols.definitions || [];
 
     if (astVisitor) {
-      const astRows = results['ast-store'] || [];
+      const astRows = (results['ast-store'] || []) as ASTNodeRow[];
       if (astRows.length > 0) symbols.astNodes = astRows;
     }
 
     if (complexityVisitor) storeComplexityResults(results, defs, langId);
     if (cfgVisitor) storeCfgResults(results, defs);
-    if (dataflowVisitor) symbols.dataflow = results.dataflow;
+    if (dataflowVisitor) symbols.dataflow = results.dataflow as DataflowResult;
   }
 
   timing._unifiedWalkMs = performance.now() - t0walk;

package/src/ast-analysis/{metrics.js → metrics.ts}

@@ -5,6 +5,8 @@
  * all stateless math that can be reused by visitor-based and standalone paths.
  */
 
+import type { HalsteadDerivedMetrics, LOCMetrics, TreeSitterNode } from '../types.js';
+
 // ─── Halstead Derived Metrics ─────────────────────────────────────────────
 
 /**
@@ -14,7 +16,10 @@
  * @param {Map<string, number>} operands  - operand text → count
  * @returns {{ n1: number, n2: number, bigN1: number, bigN2: number, vocabulary: number, length: number, volume: number, difficulty: number, effort: number, bugs: number }}
  */
-export function computeHalsteadDerived(operators, operands) {
+export function computeHalsteadDerived(
+  operators: Map<string, number>,
+  operands: Map<string, number>,
+): HalsteadDerivedMetrics {
   const n1 = operators.size;
   const n2 = operands.size;
   let bigN1 = 0;
@@ -47,7 +52,7 @@ export function computeHalsteadDerived(operators, operands) {
 
 const C_STYLE_PREFIXES = ['//', '/*', '*', '*/'];
 
-const COMMENT_PREFIXES = new Map([
+const COMMENT_PREFIXES = new Map<string, string[]>([
   ['javascript', C_STYLE_PREFIXES],
   ['typescript', C_STYLE_PREFIXES],
   ['tsx', C_STYLE_PREFIXES],
@@ -67,7 +72,7 @@ const COMMENT_PREFIXES = new Map([
  * @param {string} [language] - Language ID (falls back to C-style prefixes)
  * @returns {{ loc: number, sloc: number, commentLines: number }}
  */
-export function computeLOCMetrics(functionNode, language) {
+export function computeLOCMetrics(functionNode: TreeSitterNode, language?: string): LOCMetrics {
   const text = functionNode.text;
   const lines = text.split('\n');
   const loc = lines.length;
@@ -103,7 +108,12 @@ export function computeLOCMetrics(functionNode, language) {
  * @param {number} [commentRatio] - Comment ratio (0-1), optional
  * @returns {number} Normalized MI (0-100)
  */
-export function computeMaintainabilityIndex(volume, cyclomatic, sloc, commentRatio) {
+export function computeMaintainabilityIndex(
+  volume: number,
+  cyclomatic: number,
+  sloc: number,
+  commentRatio?: number,
+): number {
   const safeVolume = Math.max(volume, 1);
   const safeSLOC = Math.max(sloc, 1);
 

package/src/ast-analysis/rules/{csharp.js → csharp.ts}

@@ -1,12 +1,14 @@
-/**
- * C# — AST analysis rules.
- */
-
+import type {
+  CfgRulesConfig,
+  ComplexityRules,
+  DataflowRulesConfig,
+  HalsteadRules,
+} from '../../types.js';
 import { makeCfgRules, makeDataflowRules } from '../shared.js';
 
 // ─── Complexity ───────────────────────────────────────────────────────────
 
-export const complexity = {
+export const complexity: ComplexityRules = {
   branchNodes: new Set([
     'if_statement',
     'else_clause',
@@ -47,7 +49,7 @@ export const complexity = {
 
 // ─── Halstead ─────────────────────────────────────────────────────────────
 
-export const halstead = {
+export const halstead: HalsteadRules = {
   operatorLeafTypes: new Set([
     '+',
     '-',
@@ -139,7 +141,7 @@ export const halstead = {
 
 // ─── CFG ──────────────────────────────────────────────────────────────────
 
-export const cfg = makeCfgRules({
+export const cfg: CfgRulesConfig = makeCfgRules({
   ifNode: 'if_statement',
   elseViaAlternative: true,
   forNodes: new Set(['for_statement', 'foreach_statement']),
@@ -166,7 +168,7 @@ export const cfg = makeCfgRules({
 
 // ─── Dataflow ─────────────────────────────────────────────────────────────
 
-export const dataflow = makeDataflowRules({
+export const dataflow: DataflowRulesConfig = makeDataflowRules({
   functionNodes: new Set([
     'method_declaration',
     'constructor_declaration',
@@ -198,4 +200,4 @@ export const dataflow = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes = null;
+export const astTypes: Record<string, string> | null = null;

package/src/ast-analysis/rules/{go.js → go.ts}

@@ -1,12 +1,14 @@
-/**
- * Go — AST analysis rules.
- */
-
+import type {
+  CfgRulesConfig,
+  ComplexityRules,
+  DataflowRulesConfig,
+  HalsteadRules,
+} from '../../types.js';
 import { makeCfgRules, makeDataflowRules } from '../shared.js';
 
 // ─── Complexity ───────────────────────────────────────────────────────────
 
-export const complexity = {
+export const complexity: ComplexityRules = {
   branchNodes: new Set([
     'if_statement',
     'for_statement',
@@ -35,7 +37,7 @@ export const complexity = {
 
 // ─── Halstead ─────────────────────────────────────────────────────────────
 
-export const halstead = {
+export const halstead: HalsteadRules = {
   operatorLeafTypes: new Set([
     '+',
     '-',
@@ -122,7 +124,7 @@ export const halstead = {
 
 // ─── CFG ──────────────────────────────────────────────────────────────────
 
-export const cfg = makeCfgRules({
+export const cfg: CfgRulesConfig = makeCfgRules({
   ifNode: 'if_statement',
   elseViaAlternative: true,
   forNodes: new Set(['for_statement']),
@@ -144,7 +146,7 @@ export const cfg = makeCfgRules({
 
 // ─── Dataflow ─────────────────────────────────────────────────────────────
 
-export const dataflow = makeDataflowRules({
+export const dataflow: DataflowRulesConfig = makeDataflowRules({
   functionNodes: new Set(['function_declaration', 'method_declaration', 'func_literal']),
   returnNode: 'return_statement',
   varDeclaratorNodes: new Set(['short_var_declaration', 'var_declaration']),
@@ -163,7 +165,7 @@ export const dataflow = makeDataflowRules({
   expressionListType: 'expression_list',
   extractParamName(node) {
     if (node.type === 'parameter_declaration') {
-      const names = [];
+      const names: string[] = [];
       for (const c of node.namedChildren) {
         if (c.type === 'identifier') names.push(c.text);
       }
@@ -179,4 +181,4 @@ export const dataflow = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes = null;
+export const astTypes: Record<string, string> | null = null;

package/src/ast-analysis/rules/{index.js → index.ts}

@@ -1,9 +1,9 @@
-/**
- * Assembled rule maps for all AST analysis modules.
- *
- * Re-exports per-language rules as Maps keyed by language ID.
- */
-
+import type {
+  CfgRulesConfig,
+  ComplexityRules,
+  DataflowRulesConfig,
+  HalsteadRules,
+} from '../../types.js';
 import * as csharp from './csharp.js';
 import * as go from './go.js';
 import * as java from './java.js';
@@ -15,7 +15,7 @@ import * as rust from './rust.js';
 
 // ─── Complexity Rules ─────────────────────────────────────────────────────
 
-export const COMPLEXITY_RULES = new Map([
+export const COMPLEXITY_RULES: Map<string, ComplexityRules> = new Map([
   ['javascript', javascript.complexity],
   ['typescript', javascript.complexity],
   ['tsx', javascript.complexity],
@@ -30,7 +30,7 @@ export const COMPLEXITY_RULES = new Map([
 
 // ─── Halstead Rules ───────────────────────────────────────────────────────
 
-export const HALSTEAD_RULES = new Map([
+export const HALSTEAD_RULES: Map<string, HalsteadRules> = new Map([
   ['javascript', javascript.halstead],
   ['typescript', javascript.halstead],
   ['tsx', javascript.halstead],
@@ -45,7 +45,7 @@ export const HALSTEAD_RULES = new Map([
 
 // ─── CFG Rules ────────────────────────────────────────────────────────────
 
-export const CFG_RULES = new Map([
+export const CFG_RULES: Map<string, CfgRulesConfig> = new Map([
   ['javascript', javascript.cfg],
   ['typescript', javascript.cfg],
   ['tsx', javascript.cfg],
@@ -60,7 +60,7 @@ export const CFG_RULES = new Map([
 
 // ─── Dataflow Rules ──────────────────────────────────────────────────────
 
-export const DATAFLOW_RULES = new Map([
+export const DATAFLOW_RULES: Map<string, DataflowRulesConfig> = new Map([
   ['javascript', javascript.dataflow],
   ['typescript', javascript.dataflow],
   ['tsx', javascript.dataflow],
@@ -75,8 +75,8 @@ export const DATAFLOW_RULES = new Map([
 
 // ─── AST Type Maps ───────────────────────────────────────────────────────
 
-export const AST_TYPE_MAPS = new Map([
-  ['javascript', javascript.astTypes],
-  ['typescript', javascript.astTypes],
-  ['tsx', javascript.astTypes],
+export const AST_TYPE_MAPS: Map<string, Record<string, string>> = new Map([
+  ['javascript', javascript.astTypes as Record<string, string>],
+  ['typescript', javascript.astTypes as Record<string, string>],
+  ['tsx', javascript.astTypes as Record<string, string>],
 ]);

package/src/ast-analysis/rules/{java.js → java.ts}

@@ -1,12 +1,14 @@
-/**
- * Java — AST analysis rules.
- */
-
+import type {
+  CfgRulesConfig,
+  ComplexityRules,
+  DataflowRulesConfig,
+  HalsteadRules,
+} from '../../types.js';
 import { makeCfgRules, makeDataflowRules } from '../shared.js';
 
 // ─── Complexity ───────────────────────────────────────────────────────────
 
-export const complexity = {
+export const complexity: ComplexityRules = {
   branchNodes: new Set([
     'if_statement',
     'for_statement',
@@ -40,7 +42,7 @@ export const complexity = {
 
 // ─── Halstead ─────────────────────────────────────────────────────────────
 
-export const halstead = {
+export const halstead: HalsteadRules = {
   operatorLeafTypes: new Set([
     '+',
     '-',
@@ -123,7 +125,7 @@ export const halstead = {
 
 // ─── CFG ──────────────────────────────────────────────────────────────────
 
-export const cfg = makeCfgRules({
+export const cfg: CfgRulesConfig = makeCfgRules({
   ifNode: 'if_statement',
   elseViaAlternative: true,
   forNodes: new Set(['for_statement', 'enhanced_for_statement']),
@@ -146,7 +148,7 @@ export const cfg = makeCfgRules({
 
 // ─── Dataflow ─────────────────────────────────────────────────────────────
 
-export const dataflow = makeDataflowRules({
+export const dataflow: DataflowRulesConfig = makeDataflowRules({
   functionNodes: new Set(['method_declaration', 'constructor_declaration', 'lambda_expression']),
   returnNode: 'return_statement',
   varDeclaratorNode: 'variable_declarator',
@@ -172,4 +174,4 @@ export const dataflow = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes = null;
+export const astTypes: Record<string, string> | null = null;