@divmain/jdm-asm 0.2.1 → 0.2.3

package/tests/scripts/coverage-analysis.ts

@@ -1,836 +0,0 @@
-/**
- * Coverage Gap Analysis
- *
- * Analyze zen-engine test coverage and identify gaps
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-
-export interface FeatureCoverage {
-  tested: boolean;
-  testCount: number;
-  testFiles: string[];
-}
-
-export interface BuiltInFunctionCoverage {
-  sum: FeatureCoverage;
-  min: FeatureCoverage;
-  max: FeatureCoverage;
-  avg: FeatureCoverage;
-  count: FeatureCoverage;
-  filter: FeatureCoverage;
-  map: FeatureCoverage;
-  contains: FeatureCoverage;
-  any: FeatureCoverage;
-  all: FeatureCoverage;
-  not: FeatureCoverage;
-  date: FeatureCoverage;
-  string: FeatureCoverage;
-  number: FeatureCoverage;
-  abs: FeatureCoverage;
-  ceil: FeatureCoverage;
-  floor: FeatureCoverage;
-  round: FeatureCoverage;
-}
-
-export interface DecisionTableCoverage {
-  unary: FeatureCoverage;
-  expression: FeatureCoverage;
-  hitPolicyFirst: FeatureCoverage;
-  hitPolicyCollect: FeatureCoverage;
-  hitPolicyUnique: FeatureCoverage;
-  hitPolicyPriority: FeatureCoverage;
-  hitPolicyAny: FeatureCoverage;
-  hitPolicyRuleOrder: FeatureCoverage;
-  hitPolicyOutputOrder: FeatureCoverage;
-  emptyCells: FeatureCoverage;
-  loop: FeatureCoverage;
-  passThrough: FeatureCoverage;
-}
-
-export interface SwitchNodeCoverage {
-  basic: FeatureCoverage;
-  collect: FeatureCoverage;
-  multipleCases: FeatureCoverage;
-  defaultCase: FeatureCoverage;
-}
-
-export interface SubDecisionsCoverage {
-  nesting: FeatureCoverage;
-  recursion: FeatureCoverage;
-  crossReferences: FeatureCoverage;
-}
-
-export interface CoverageReport {
-  arithmetic: FeatureCoverage;
-  comparisons: FeatureCoverage;
-  logicalOps: FeatureCoverage;
-  stringOps: FeatureCoverage;
-  arrayAccess: FeatureCoverage;
-  objectAccess: FeatureCoverage;
-  builtInFuncs: BuiltInFunctionCoverage;
-  decisionTable: DecisionTableCoverage;
-  switchNode: SwitchNodeCoverage;
-  subDecisions: SubDecisionsCoverage;
-  existingTests: number;
-  gaps: string[];
-  coverage: number;
-  testFiles: string[];
-}
-
-/**
- * Initialize empty feature coverage
- */
-function initFeatureCoverage(): FeatureCoverage {
-  return {
-    tested: false,
-    testCount: 0,
-    testFiles: [],
-  };
-}
-
-/**
- * Initialize built-in function coverage
- */
-function initBuiltInFunctionCoverage(): BuiltInFunctionCoverage {
-  const functions = [
-    'sum',
-    'min',
-    'max',
-    'avg',
-    'count',
-    'filter',
-    'map',
-    'contains',
-    'any',
-    'all',
-    'not',
-    'date',
-    'string',
-    'number',
-    'abs',
-    'ceil',
-    'floor',
-    'round',
-  ];
-  const result: any = {};
-  for (const fn of functions) {
-    result[fn] = initFeatureCoverage();
-  }
-  return result as BuiltInFunctionCoverage;
-}
-
-/**
- * Initialize decision table coverage
- */
-function initDecisionTableCoverage(): DecisionTableCoverage {
-  return {
-    unary: initFeatureCoverage(),
-    expression: initFeatureCoverage(),
-    hitPolicyFirst: initFeatureCoverage(),
-    hitPolicyCollect: initFeatureCoverage(),
-    hitPolicyUnique: initFeatureCoverage(),
-    hitPolicyPriority: initFeatureCoverage(),
-    hitPolicyAny: initFeatureCoverage(),
-    hitPolicyRuleOrder: initFeatureCoverage(),
-    hitPolicyOutputOrder: initFeatureCoverage(),
-    emptyCells: initFeatureCoverage(),
-    loop: initFeatureCoverage(),
-    passThrough: initFeatureCoverage(),
-  };
-}
-
-/**
- * Initialize switch node coverage
- */
-function initSwitchNodeCoverage(): SwitchNodeCoverage {
-  return {
-    basic: initFeatureCoverage(),
-    collect: initFeatureCoverage(),
-    multipleCases: initFeatureCoverage(),
-    defaultCase: initFeatureCoverage(),
-  };
-}
-
-/**
- * Initialize sub-decision coverage
- */
-function initSubDecisionsCoverage(): SubDecisionsCoverage {
-  return {
-    nesting: initFeatureCoverage(),
-    recursion: initFeatureCoverage(),
-    crossReferences: initFeatureCoverage(),
-  };
-}
-
-/**
- * Check if content contains arithmetic operations
- */
-function hasArithmetic(content: string): boolean {
-  return /[+\-*/%]/.test(content) && !/\/\/|\/\*/.test(content);
-}
-
-/**
- * Check if content contains comparison operations
- */
-function hasComparisons(content: string): boolean {
-  return (
-    /[=!<>]=?|!=|<>/.test(content) && !/(\/\/|\/\*)|[^=!==<>/]=(!==|<=|>=|=|<|>)/.test(content)
-  );
-}
-
-/**
- * Check if content contains logical operations
- */
-function hasLogicalOps(content: string): boolean {
-  return /\b(and|or|not|xor)\b/i.test(content);
-}
-
-/**
- * Check if content contains string operations
- */
-function hasStringOps(content: string): boolean {
-  return /["']|string\s*\(|substring\s*\(|concat\s*\(|upper\s*\(|lower\s*\(|trim\s*\(/i.test(
-    content,
-  );
-}
-
-/**
- * Check if content contains array access
- */
-function hasArrayAccess(content: string): boolean {
-  return /\w+\[[0-9]+\]|\[[^\]]+\]\.\w+/.test(content);
-}
-
-/**
- * Check if content contains object access
- */
-function hasObjectAccess(content: string): boolean {
-  return /\.\w+/.test(content) && !/[()[]\]]/.test(content);
-}
-
-/**
- * Extract built-in function usage
- */
-function extractBuiltInFunctions(content: string): string[] {
-  const functionPattern =
-    /\b(sum|min|max|avg|count|filter|map|contains|any|all|not|date|string|number|abs|ceil|floor|round)\s*\(/gi;
-  const matches = content.match(functionPattern);
-  if (!matches) {
-    return [];
-  }
-
-  const functions = matches.map((m) => m.toLowerCase().replace(/\s*\($/, ''));
-  return [...new Set(functions)];
-}
-
-/**
- * Extract decision table features
- */
-function extractDecisionTableFeatures(node: any): string[] {
-  const features: string[] = [];
-  const content = node.content;
-
-  if (!content) {
-    return features;
-  }
-
-  // Check hit policy
-  if (content.hitPolicy) {
-    features.push(
-      `hitPolicy${content.hitPolicy.charAt(0).toUpperCase() + content.hitPolicy.slice(1).toLowerCase()}`,
-    );
-  }
-
-  // Check input types (unary vs expression)
-  if (content.inputs) {
-    const expressionInputs = content.inputs.filter((i: any) => i.type === 'expression');
-    if (expressionInputs.length > 0 && expressionInputs.length === content.inputs.length) {
-      features.push('expression');
-    } else if (expressionInputs.length === 0) {
-      features.push('unary');
-    }
-  }
-
-  // Check for empty cells
-  if (content.rules) {
-    for (const rule of content.rules) {
-      for (const [key, value] of Object.entries(rule)) {
-        if (key !== '_id' && (value === '' || value === null || value === undefined)) {
-          features.push('emptyCells');
-          break;
-        }
-      }
-    }
-  }
-
-  // Check for execution mode
-  if (content.executionMode === 'loop') {
-    features.push('loop');
-  }
-
-  // Check for pass through
-  if (content.passThrough) {
-    features.push('passThrough');
-  }
-
-  return features;
-}
-
-/**
- * Extract switch node features
- */
-function extractSwitchFeatures(node: any): string[] {
-  const features: string[] = [];
-  const content = node.content;
-
-  if (!content) {
-    return features;
-  }
-
-  // Check for collect property
-  if (content.collect) {
-    features.push('collect');
-  } else {
-    features.push('basic');
-  }
-
-  // Check for multiple cases
-  if (content.statements && content.statements.length > 2) {
-    features.push('multipleCases');
-  }
-
-  // Check for default case (empty condition)
-  if (content.statements) {
-    const hasDefault = content.statements.some((s: any) => !s.condition || s.condition === '');
-    if (hasDefault) {
-      features.push('defaultCase');
-    }
-  }
-
-  return features;
-}
-
-/**
- * Extract sub-decision features
- */
-function extractSubDecisionFeatures(nodes: any[], edges: any[]): string[] {
-  const features: string[] = [];
-
-  const decisionCount = nodes.filter(
-    (n: any) => n.type === 'decisionNode' || n.type === 'expressionNode',
-  ).length;
-
-  if (decisionCount > 1) {
-    features.push('nesting');
-  }
-
-  // Check for cyclic references (recursion)
-  for (const edge of edges) {
-    // If there's a back edge from later to earlier in flow, it might be recursion
-    const sourceIndex = nodes.findIndex((n: any) => n.id === edge.sourceId);
-    const targetIndex = nodes.findIndex((n: any) => n.id === edge.targetId);
-    if (sourceIndex > targetIndex && sourceIndex - targetIndex === 1) {
-      features.push('recursion');
-    }
-  }
-
-  // Check for cross-references
-  for (const edge of edges) {
-    const source = nodes.find((n: any) => n.id === edge.sourceId);
-    const target = nodes.find((n: any) => n.id === edge.targetId);
-    if (source && target && source.type === 'decisionNode' && target.type === 'decisionNode') {
-      features.push('crossReferences');
-    }
-  }
-
-  return features;
-}
-
-/**
- * Analyze a single test file
- */
-function analyzeTestFile(filePath: string, coverage: CoverageReport): void {
-  try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const jdm = JSON.parse(content);
-
-    // Track test file
-    coverage.testFiles.push(filePath);
-
-    // Analyze nodes
-    for (const node of jdm.nodes || []) {
-      const nodeContent = JSON.stringify(node.content || node);
-
-      // Expression language features
-      if (node.type === 'expressionNode' || node.type === 'decisionTableNode') {
-        if (hasArithmetic(nodeContent)) {
-          coverage.arithmetic.tested = true;
-          coverage.arithmetic.testCount++;
-          if (!coverage.arithmetic.testFiles.includes(filePath)) {
-            coverage.arithmetic.testFiles.push(filePath);
-          }
-        }
-
-        if (hasComparisons(nodeContent)) {
-          coverage.comparisons.tested = true;
-          coverage.comparisons.testCount++;
-          if (!coverage.comparisons.testFiles.includes(filePath)) {
-            coverage.comparisons.testFiles.push(filePath);
-          }
-        }
-
-        if (hasLogicalOps(nodeContent)) {
-          coverage.logicalOps.tested = true;
-          coverage.logicalOps.testCount++;
-          if (!coverage.logicalOps.testFiles.includes(filePath)) {
-            coverage.logicalOps.testFiles.push(filePath);
-          }
-        }
-
-        if (hasStringOps(nodeContent)) {
-          coverage.stringOps.tested = true;
-          coverage.stringOps.testCount++;
-          if (!coverage.stringOps.testFiles.includes(filePath)) {
-            coverage.stringOps.testFiles.push(filePath);
-          }
-        }
-
-        if (hasArrayAccess(nodeContent)) {
-          coverage.arrayAccess.tested = true;
-          coverage.arrayAccess.testCount++;
-          if (!coverage.arrayAccess.testFiles.includes(filePath)) {
-            coverage.arrayAccess.testFiles.push(filePath);
-          }
-        }
-
-        if (hasObjectAccess(nodeContent)) {
-          coverage.objectAccess.tested = true;
-          coverage.objectAccess.testCount++;
-          if (!coverage.objectAccess.testFiles.includes(filePath)) {
-            coverage.objectAccess.testFiles.push(filePath);
-          }
-        }
-
-        // Built-in functions
-        const functions = extractBuiltInFunctions(nodeContent);
-        for (const fn of functions) {
-          if (coverage.builtInFuncs[fn as keyof BuiltInFunctionCoverage]) {
-            const cov = coverage.builtInFuncs[fn as keyof BuiltInFunctionCoverage];
-            cov.tested = true;
-            cov.testCount++;
-            if (!cov.testFiles.includes(filePath)) {
-              cov.testFiles.push(filePath);
-            }
-          }
-        }
-      }
-
-      // Decision table features
-      if (node.type === 'decisionTableNode') {
-        const dtFeatures = extractDecisionTableFeatures(node);
-        for (const feature of dtFeatures) {
-          if (coverage.decisionTable[feature as keyof DecisionTableCoverage]) {
-            const cov = coverage.decisionTable[feature as keyof DecisionTableCoverage];
-            cov.tested = true;
-            cov.testCount++;
-            if (!cov.testFiles.includes(filePath)) {
-              cov.testFiles.push(filePath);
-            }
-          }
-        }
-      }
-
-      // Switch node features
-      if (node.type === 'switchNode') {
-        const swFeatures = extractSwitchFeatures(node);
-        for (const feature of swFeatures) {
-          if (coverage.switchNode[feature as keyof SwitchNodeCoverage]) {
-            const cov = coverage.switchNode[feature as keyof SwitchNodeCoverage];
-            cov.tested = true;
-            cov.testCount++;
-            if (!cov.testFiles.includes(filePath)) {
-              cov.testFiles.push(filePath);
-            }
-          }
-        }
-      }
-    }
-
-    // Sub-decision features
-    const subDecisionFeatures = extractSubDecisionFeatures(jdm.nodes || [], jdm.edges || []);
-    for (const feature of subDecisionFeatures) {
-      if (coverage.subDecisions[feature as keyof SubDecisionsCoverage]) {
-        const cov = coverage.subDecisions[feature as keyof SubDecisionsCoverage];
-        cov.tested = true;
-        cov.testCount++;
-        if (!cov.testFiles.includes(filePath)) {
-          cov.testFiles.push(filePath);
-        }
-      }
-    }
-  } catch {
-    // Silently skip invalid files
-  }
-}
-
-/**
- * Identify coverage gaps
- */
-function identifyGaps(coverage: CoverageReport): void {
-  const gaps: string[] = [];
-
-  // Expression language features
-  if (!coverage.arithmetic.tested) {
-    gaps.push('Arithmetic operations (+, -, *, /)');
-  }
-  if (!coverage.comparisons.tested) {
-    gaps.push('Comparison operators (==, !=, <, >, <=, >=)');
-  }
-  if (!coverage.logicalOps.tested) {
-    gaps.push('Logical operations (and, or, not)');
-  }
-  if (!coverage.stringOps.tested) {
-    gaps.push('String operations');
-  }
-  if (!coverage.arrayAccess.tested) {
-    gaps.push('Array access (e.g., items[0])');
-  }
-  if (!coverage.objectAccess.tested) {
-    gaps.push('Object access (e.g., customer.name)');
-  }
-
-  // Built-in functions
-  for (const [func, cov] of Object.entries(coverage.builtInFuncs)) {
-    if (!cov.tested) {
-      gaps.push(`${func}() function`);
-    }
-  }
-
-  // Decision table features
-  if (!coverage.decisionTable.unary.tested) {
-    gaps.push('Decision table unary mode');
-  }
-  if (!coverage.decisionTable.expression.tested) {
-    gaps.push('Decision table expression mode');
-  }
-  if (!coverage.decisionTable.hitPolicyFirst.tested) {
-    gaps.push('Decision table hit policy: FIRST');
-  }
-  if (!coverage.decisionTable.hitPolicyCollect.tested) {
-    gaps.push('Decision table hit policy: COLLECT');
-  }
-  if (!coverage.decisionTable.hitPolicyUnique.tested) {
-    gaps.push('Decision table hit policy: UNIQUE');
-  }
-  if (!coverage.decisionTable.hitPolicyPriority.tested) {
-    gaps.push('Decision table hit policy: PRIORITY');
-  }
-  if (!coverage.decisionTable.hitPolicyAny.tested) {
-    gaps.push('Decision table hit policy: ANY');
-  }
-  if (!coverage.decisionTable.hitPolicyRuleOrder.tested) {
-    gaps.push('Decision table hit policy: RULE ORDER');
-  }
-  if (!coverage.decisionTable.hitPolicyOutputOrder.tested) {
-    gaps.push('Decision table hit policy: OUTPUT ORDER');
-  }
-  if (!coverage.decisionTable.emptyCells.tested) {
-    gaps.push('Decision table empty cells');
-  }
-  if (!coverage.decisionTable.loop.tested) {
-    gaps.push('Decision table loop execution mode');
-  }
-  if (!coverage.decisionTable.passThrough.tested) {
-    gaps.push('Decision table pass through');
-  }
-
-  // Switch node features
-  if (!coverage.switchNode.basic.tested) {
-    gaps.push('Switch node basic mode');
-  }
-  if (!coverage.switchNode.collect.tested) {
-    gaps.push('Switch node collect mode');
-  }
-  if (!coverage.switchNode.multipleCases.tested) {
-    gaps.push('Switch node multiple cases');
-  }
-  if (!coverage.switchNode.defaultCase.tested) {
-    gaps.push('Switch node default case');
-  }
-
-  // Sub-decision features
-  if (!coverage.subDecisions.nesting.tested) {
-    gaps.push('Sub-decision nesting');
-  }
-  if (!coverage.subDecisions.recursion.tested) {
-    gaps.push('Sub-decision recursion');
-  }
-  if (!coverage.subDecisions.crossReferences.tested) {
-    gaps.push('Sub-decision cross-references');
-  }
-
-  coverage.gaps = gaps;
-}
-
-/**
- * Calculate overall coverage percentage
- */
-function calculateCoverage(coverage: CoverageReport): void {
-  let totalFeatures = 0;
-  let testedFeatures = 0;
-
-  // Expression language features
-  const expressionFeatures = [
-    coverage.arithmetic,
-    coverage.comparisons,
-    coverage.logicalOps,
-    coverage.stringOps,
-    coverage.arrayAccess,
-    coverage.objectAccess,
-  ];
-  for (const f of expressionFeatures) {
-    totalFeatures++;
-    if (f.tested) {
-      testedFeatures++;
-    }
-  }
-
-  // Built-in functions
-  for (const cov of Object.values(coverage.builtInFuncs)) {
-    totalFeatures++;
-    if (cov.tested) {
-      testedFeatures++;
-    }
-  }
-
-  // Decision table features
-  for (const cov of Object.values(coverage.decisionTable)) {
-    totalFeatures++;
-    if (cov.tested) {
-      testedFeatures++;
-    }
-  }
-
-  // Switch node features
-  for (const cov of Object.values(coverage.switchNode)) {
-    totalFeatures++;
-    if (cov.tested) {
-      testedFeatures++;
-    }
-  }
-
-  // Sub-decision features
-  for (const cov of Object.values(coverage.subDecisions)) {
-    totalFeatures++;
-    if (cov.tested) {
-      testedFeatures++;
-    }
-  }
-
-  coverage.coverage = totalFeatures > 0 ? testedFeatures / totalFeatures : 0;
-}
-
-/**
- * Find all test JSON files recursively
- */
-function findTestFiles(dir: string): string[] {
-  const files: string[] = [];
-
-  function traverse(currentDir: string) {
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (
-        entry.isDirectory() &&
-        !entry.name.startsWith('node_modules') &&
-        !entry.name.startsWith('.')
-      ) {
-        traverse(path.join(currentDir, entry.name));
-      } else if (entry.isFile() && entry.name.endsWith('.json')) {
-        files.push(path.join(currentDir, entry.name));
-      }
-    }
-  }
-
-  traverse(dir);
-  return files;
-}
-
-/**
- * Analyze zen-engine test coverage and identify gaps
- */
-export function analyzeCoverage(
-  testDataDir: string = path.join(process.cwd(), 'test-data'),
-): CoverageReport {
-  const coverage: CoverageReport = {
-    arithmetic: initFeatureCoverage(),
-    comparisons: initFeatureCoverage(),
-    logicalOps: initFeatureCoverage(),
-    stringOps: initFeatureCoverage(),
-    arrayAccess: initFeatureCoverage(),
-    objectAccess: initFeatureCoverage(),
-    builtInFuncs: initBuiltInFunctionCoverage(),
-    decisionTable: initDecisionTableCoverage(),
-    switchNode: initSwitchNodeCoverage(),
-    subDecisions: initSubDecisionsCoverage(),
-    existingTests: 0,
-    gaps: [],
-    coverage: 0,
-    testFiles: [],
-  };
-
-  // Find all test JSON files
-  const testFiles = findTestFiles(testDataDir);
-  coverage.existingTests = testFiles.length;
-
-  // Analyze each test file
-  for (const testFile of testFiles) {
-    // Skip node_modules and hidden directories
-    if (testFile.includes('node_modules') || testFile.includes('/.')) {
-      continue;
-    }
-    analyzeTestFile(testFile, coverage);
-  }
-
-  // Identify gaps
-  identifyGaps(coverage);
-
-  // Calculate coverage
-  calculateCoverage(coverage);
-
-  return coverage;
-}
-
-/**
- * Pretty print coverage report
- */
-export function printCoverageReport(coverage: CoverageReport): void {
-  console.log('\n' + '='.repeat(70));
-  console.log('COVERAGE GAP ANALYSIS REPORT');
-  console.log('='.repeat(70));
-  console.log(`\n## Summary`);
-  console.log(`- Total test files: ${coverage.existingTests}`);
-  console.log(`- Coverage: ${(coverage.coverage * 100).toFixed(1)}%`);
-  console.log(`- Gaps found: ${coverage.gaps.length}`);
-
-  console.log(`\n## Expression Language Features`);
-  console.log(
-    `- Arithmetic: ${coverage.arithmetic.tested ? '✅' : '❌'} (${coverage.arithmetic.testCount} tests)`,
-  );
-  console.log(
-    `- Comparisons: ${coverage.comparisons.tested ? '✅' : '❌'} (${coverage.comparisons.testCount} tests)`,
-  );
-  console.log(
-    `- Logical ops: ${coverage.logicalOps.tested ? '✅' : '❌'} (${coverage.logicalOps.testCount} tests)`,
-  );
-  console.log(
-    `- String ops: ${coverage.stringOps.tested ? '✅' : '❌'} (${coverage.stringOps.testCount} tests)`,
-  );
-  console.log(
-    `- Array access: ${coverage.arrayAccess.tested ? '✅' : '❌'} (${coverage.arrayAccess.testCount} tests)`,
-  );
-  console.log(
-    `- Object access: ${coverage.objectAccess.tested ? '✅' : '❌'} (${coverage.objectAccess.testCount} tests)`,
-  );
-
-  console.log(`\n## Built-in Functions`);
-  for (const [func, cov] of Object.entries(coverage.builtInFuncs)) {
-    console.log(`- ${func}(): ${cov.tested ? '✅' : '❌'} (${cov.testCount} tests)`);
-  }
-
-  console.log(`\n## Decision Table Features`);
-  console.log(
-    `- Unary mode: ${coverage.decisionTable.unary.tested ? '✅' : '❌'} (${coverage.decisionTable.unary.testCount} tests)`,
-  );
-  console.log(
-    `- Expression mode: ${coverage.decisionTable.expression.tested ? '✅' : '❌'} (${coverage.decisionTable.expression.testCount} tests)`,
-  );
-  console.log(
-    `- Hit policy FIRST: ${coverage.decisionTable.hitPolicyFirst.tested ? '✅' : '❌'} (${coverage.decisionTable.hitPolicyFirst.testCount} tests)`,
-  );
-  console.log(
-    `- Hit policy COLLECT: ${coverage.decisionTable.hitPolicyCollect.tested ? '✅' : '❌'} (${coverage.decisionTable.hitPolicyCollect.testCount} tests)`,
-  );
-  console.log(
-    `- Hit policy UNIQUE: ${coverage.decisionTable.hitPolicyUnique.tested ? '✅' : '❌'} (${coverage.decisionTable.hitPolicyUnique.testCount} tests)`,
-  );
-  console.log(
-    `- Hit policy PRIORITY: ${coverage.decisionTable.hitPolicyPriority.tested ? '✅' : '❌'} (${coverage.decisionTable.hitPolicyPriority.testCount} tests)`,
-  );
-  console.log(
-    `- Hit policy ANY: ${coverage.decisionTable.hitPolicyAny.tested ? '✅' : '❌'} (${coverage.decisionTable.hitPolicyAny.testCount} tests)`,
-  );
-  console.log(
-    `- Hit policy RULE ORDER: ${coverage.decisionTable.hitPolicyRuleOrder.tested ? '✅' : '❌'} (${coverage.decisionTable.hitPolicyRuleOrder.testCount} tests)`,
-  );
-  console.log(
-    `- Hit policy OUTPUT ORDER: ${coverage.decisionTable.hitPolicyOutputOrder.tested ? '✅' : '❌'} (${coverage.decisionTable.hitPolicyOutputOrder.testCount} tests)`,
-  );
-  console.log(
-    `- Empty cells: ${coverage.decisionTable.emptyCells.tested ? '✅' : '❌'} (${coverage.decisionTable.emptyCells.testCount} tests)`,
-  );
-  console.log(
-    `- Loop execution: ${coverage.decisionTable.loop.tested ? '✅' : '❌'} (${coverage.decisionTable.loop.testCount} tests)`,
-  );
-  console.log(
-    `- Pass through: ${coverage.decisionTable.passThrough.tested ? '✅' : '❌'} (${coverage.decisionTable.passThrough.testCount} tests)`,
-  );
-
-  console.log(`\n## Switch Node Features`);
-  console.log(
-    `- Basic mode: ${coverage.switchNode.basic.tested ? '✅' : '❌'} (${coverage.switchNode.basic.testCount} tests)`,
-  );
-  console.log(
-    `- Collect mode: ${coverage.switchNode.collect.tested ? '✅' : '❌'} (${coverage.switchNode.collect.testCount} tests)`,
-  );
-  console.log(
-    `- Multiple cases: ${coverage.switchNode.multipleCases.tested ? '✅' : '❌'} (${coverage.switchNode.multipleCases.testCount} tests)`,
-  );
-  console.log(
-    `- Default case: ${coverage.switchNode.defaultCase.tested ? '✅' : '❌'} (${coverage.switchNode.defaultCase.testCount} tests)`,
-  );
-
-  console.log(`\n## Sub-Decision Features`);
-  console.log(
-    `- Nesting: ${coverage.subDecisions.nesting.tested ? '✅' : '❌'} (${coverage.subDecisions.nesting.testCount} tests)`,
-  );
-  console.log(
-    `- Recursion: ${coverage.subDecisions.recursion.tested ? '✅' : '❌'} (${coverage.subDecisions.recursion.testCount} tests)`,
-  );
-  console.log(
-    `- Cross references: ${coverage.subDecisions.crossReferences.tested ? '✅' : '❌'} (${coverage.subDecisions.crossReferences.testCount} tests)`,
-  );
-
-  if (coverage.gaps.length > 0) {
-    console.log(`\n## Coverage Gaps (${coverage.gaps.length})`);
-    for (const gap of coverage.gaps) {
-      console.log(`- ${gap}`);
-    }
-  } else {
-    console.log(`\n## Coverage Gaps`);
-    console.log('✅ All features covered!');
-  }
-
-  console.log('='.repeat(70));
-}
-
-/**
- * CLI entry point - run as: node -e "import('./dist/tests/coverage-analysis.js')
- *   .then(async (m) => { const report = m.analyzeCoverage(); m.printCoverageReport(report); })"
- */
-export async function runCLI(testDataPath?: string): Promise<void> {
-  const testDataDir = testDataPath || path.join(process.cwd(), 'test-data');
-  const report = analyzeCoverage(testDataDir);
-  printCoverageReport(report);
-}
-
-// For direct execution via Node.js
-if (
-  globalThis.__filename?.endsWith('coverage-analysis.ts') &&
-  process.argv[1]?.endsWith('coverage-analysis.ts')
-) {
-  const testDataPath = process.argv[2] || path.join(process.cwd(), 'test-data');
-  const report = analyzeCoverage(testDataPath);
-  printCoverageReport(report);
-}