@divmain/jdm-asm 0.2.0

package/tests/scripts/coverage-analysis.ts

@@ -0,0 +1,836 @@
+/**
+ * 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);
+}