@divmain/jdm-asm 0.2.0

package/tests/scripts/analyze-coverage.ts

@@ -0,0 +1,166 @@
+/**
+ * Coverage Analysis Script
+ *
+ * Analyzes zen-engine test fixtures to understand coverage categories
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { parseJDM } from '../../src/compiler/parser';
+
+export interface TestFileInfo {
+  name: string;
+  path: string;
+  categorized: boolean;
+  category?: string;
+  nodeTypes: string[];
+  features: string[];
+}
+
+export interface CoverageAnalysis {
+  totalFiles: number;
+  categorizedFiles: number;
+  uncategorizedFiles: number;
+  categories: Record<string, number>;
+  fileDetails: TestFileInfo[];
+}
+
+function analyzeJDMFile(filePath: string): TestFileInfo {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const jdm = parseJDM(content);
+
+    const nodeTypes: string[] = jdm.nodes.map((n: { type: string }) => n.type);
+    const features: string[] = extractFeatures(jdm, nodeTypes);
+
+    return {
+      name: path.basename(filePath),
+      path: filePath,
+      categorized: false,
+      nodeTypes,
+      features,
+    };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to parse ${filePath}: ${message}`);
+    return {
+      name: path.basename(filePath),
+      path: filePath,
+      categorized: false,
+      nodeTypes: [],
+      features: [],
+    };
+  }
+}
+
+function extractFeatures(jdm: any, nodeTypes: string[]): string[] {
+  const features = new Set<string>();
+
+  // Add node types as features
+  for (const type of nodeTypes) {
+    features.add(type);
+  }
+
+  // Analyze nodes for additional features
+  for (const node of jdm.nodes) {
+    if (node.type === 'decisionTable') {
+      // Check for different hit policies
+      if (node.decisionTable?.hitPolicy) {
+        features.add(`hit-policy-${node.decisionTable.hitPolicy}`);
+      }
+      // Check for input/output
+      if (node.decisionTable?.inputs?.length > 0) {
+        features.add('decision-table-inputs');
+      }
+      if (node.decisionTable?.outputs?.length > 0) {
+        features.add('decision-table-outputs');
+      }
+    }
+
+    if (node.type === 'switch') {
+      features.add('switch-node');
+      if (node.switch?.collect) {
+        features.add('switch-collect');
+      }
+    }
+  }
+
+  return Array.from(features);
+}
+
+export function analyzeCoverage(testDataPath: string): CoverageAnalysis {
+  const zenReferencePath = path.join(testDataPath, 'zen-reference');
+
+  if (!fs.existsSync(zenReferencePath)) {
+    return {
+      totalFiles: 0,
+      categorizedFiles: 0,
+      uncategorizedFiles: 0,
+      categories: {},
+      fileDetails: [],
+    };
+  }
+
+  const files = fs
+    .readdirSync(zenReferencePath)
+    .filter((f) => f.endsWith('.json') || f.endsWith('.jdm'))
+    .map((f) => path.join(zenReferencePath, f));
+
+  // Also check graphs subdirectory
+  const graphsPath = path.join(zenReferencePath, 'graphs');
+  if (fs.existsSync(graphsPath)) {
+    const graphFiles = fs
+      .readdirSync(graphsPath)
+      .filter((f) => f.endsWith('.json'))
+      .map((f) => path.join(graphsPath, f));
+    files.push(...graphFiles);
+  }
+
+  const fileDetails = files.map(analyzeJDMFile);
+
+  // Generate category statistics
+  const categories: Record<string, number> = {};
+  let categorizedCount = 0;
+
+  for (const file of fileDetails) {
+    if (file.categorized && file.category) {
+      categories[file.category] = (categories[file.category] || 0) + 1;
+      categorizedCount++;
+    }
+  }
+
+  return {
+    totalFiles: files.length,
+    categorizedFiles: categorizedCount,
+    uncategorizedFiles: files.length - categorizedCount,
+    categories,
+    fileDetails,
+  };
+}
+
+export function printCoverageAnalysis(analysis: CoverageAnalysis): void {
+  console.log('# Zen-Engine Test Coverage Analysis\n');
+  console.log(`Total Files: ${analysis.totalFiles}`);
+  console.log(`Categorized: ${analysis.categorizedFiles}`);
+  console.log(`Uncategorized: ${analysis.uncategorizedFiles}\n`);
+
+  if (Object.keys(analysis.categories).length > 0) {
+    console.log('## Categories');
+    for (const [category, count] of Object.entries(analysis.categories)) {
+      console.log(`- ${category}: ${count} files`);
+    }
+    console.log();
+  }
+
+  console.log('## Uncategorized Files');
+  const uncategorized = analysis.fileDetails.filter((f) => !f.categorized);
+  for (const file of uncategorized) {
+    console.log(`- ${file.name} (${file.nodeTypes.join(', ') || 'unknown'})`);
+  }
+}
+
+// CLI entry point
+// CLI entry point
+const testDataPath = process.argv[2] || path.join(process.cwd(), 'test-data');
+const analysis = analyzeCoverage(testDataPath);
+printCoverageAnalysis(analysis);

package/tests/scripts/categorize-tests.ts

@@ -0,0 +1,396 @@
+/**
+ * Test Categorization Script
+ *
+ * Scans JDM nodes and determines which test category a fixture belongs to
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { parseJDM } from '../../src/compiler/parser';
+import { NodeType } from '../../src/compiler/parser';
+
+export enum TestCategory {
+  EXPRESSIONS = 'expressions',
+  DECISION_TABLES = 'decision-tables',
+  SWITCH_NODES = 'switch-nodes',
+  SUB_DECISIONS = 'sub-decisions',
+  FUNCTION_NODES = 'function-nodes', // Will be skipped initially
+  OTHER = 'other',
+}
+
+export interface CategorizedTest {
+  name: string;
+  sourcePath: string;
+  targetPath: string;
+  category: TestCategory;
+  reason: string;
+  nodeTypes: string[];
+  features: string[];
+}
+
+export interface CategorizationResult {
+  totalFiles: number;
+  categorizedFiles: number;
+  skippedFiles: number;
+  categories: Record<string, CategorizedTest[]>;
+}
+
+/**
+ * Determine test category based on JDM content
+ */
+export function categorizeTest(filePath: string): CategorizedTest {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const jdm = parseJDM(content);
+
+  const fileDetails = path.parse(filePath);
+  const nodeName = fileDetails.name;
+
+  // Check for node types
+  const nodeTypes = jdm.nodes.map((n: any) => n.type);
+
+  // Function nodes - not yet supported
+  if (nodeTypes.includes(NodeType.FUNCTION)) {
+    return {
+      name: nodeName,
+      sourcePath: filePath,
+      targetPath: '', // Not copied
+      category: TestCategory.FUNCTION_NODES,
+      reason: 'Contains function node (not yet supported)',
+      nodeTypes,
+      features: [],
+    };
+  }
+
+  // Switch nodes
+  if (nodeTypes.includes(NodeType.SWITCH)) {
+    const subsetDir = determineSwitchSubset(jdm, nodeTypes);
+    return {
+      name: nodeName,
+      sourcePath: filePath,
+      targetPath: path.join('test-data/switch-nodes', subsetDir, fileDetails.base),
+      category: TestCategory.SWITCH_NODES,
+      reason: 'Contains switch node',
+      nodeTypes,
+      features: extractSwitchFeatures(jdm),
+    };
+  }
+
+  // Decision tables
+  if (nodeTypes.includes(NodeType.DECISION_TABLE)) {
+    const subsetDir = determineDecisionTableSubset(jdm, nodeTypes);
+    return {
+      name: nodeName,
+      sourcePath: filePath,
+      targetPath: path.join('test-data/decision-tables', subsetDir, fileDetails.base),
+      category: TestCategory.DECISION_TABLES,
+      reason: 'Contains decision table node',
+      nodeTypes,
+      features: extractDecisionTableFeatures(jdm),
+    };
+  }
+
+  // Sub-decisions (multiple decision nodes)
+  const decisionCount = nodeTypes.filter((t: string) => t === NodeType.DECISION).length;
+  if (decisionCount > 1) {
+    const subsetDir = determineSubDecisionSubset(jdm, nodeTypes);
+    return {
+      name: nodeName,
+      sourcePath: filePath,
+      targetPath: path.join('test-data/sub-decisions', subsetDir, fileDetails.base),
+      category: TestCategory.SUB_DECISIONS,
+      reason: `Contains ${decisionCount} sub-decision nodes`,
+      nodeTypes,
+      features: ['sub-decisions', `node-count:${decisionCount}`],
+    };
+  }
+
+  // Expression-only tests
+  const expressionCount = nodeTypes.filter((t: string) => t === NodeType.EXPRESSION).length;
+  if (expressionCount > 0) {
+    const subsetDir = determineExpressionSubset(jdm, nodeTypes);
+    return {
+      name: nodeName,
+      sourcePath: filePath,
+      targetPath: path.join('test-data/expressions', subsetDir, fileDetails.base),
+      category: TestCategory.EXPRESSIONS,
+      reason: `Contains ${expressionCount} expression nodes`,
+      nodeTypes,
+      features: extractExpressionFeatures(jdm),
+    };
+  }
+
+  // Everything else
+  return {
+    name: nodeName,
+    sourcePath: filePath,
+    targetPath: path.join('test-data/other', fileDetails.base),
+    category: TestCategory.OTHER,
+    reason: 'Uncategorized node types',
+    nodeTypes,
+    features: [],
+  };
+}
+
+function determineExpressionSubset(jdm: any, _nodeTypes: string[]): string {
+  // Analyze expression complexity
+  let hasArithmetic = false;
+  let hasLogical = false;
+  let hasStrings = false;
+  let hasFunctions = false;
+
+  for (const node of jdm.nodes) {
+    if (node.type === NodeType.EXPRESSION && node.expression) {
+      const expr = JSON.stringify(node.expression);
+
+      if (/[+\-*/]/.test(expr)) {
+        hasArithmetic = true;
+      }
+      if (/\b(and|or|not)\b/i.test(expr)) {
+        hasLogical = true;
+      }
+      if (/["']|concat/i.test(expr)) {
+        hasStrings = true;
+      }
+      if (/\w+\(/.test(expr)) {
+        hasFunctions = true;
+      }
+    }
+  }
+
+  if (hasLogical && !hasArithmetic && !hasStrings) {
+    return 'logical';
+  }
+  if (hasStrings && !hasArithmetic) {
+    return 'string';
+  }
+  if (hasFunctions) {
+    return 'functions';
+  }
+  return 'arithmetic';
+}
+
+function determineDecisionTableSubset(jdm: any, _nodeTypes: string[]): string {
+  // Analyze decision table characteristics
+  for (const node of jdm.nodes) {
+    if (node.type === NodeType.DECISION_TABLE && node.decisionTable) {
+      const dt = node.decisionTable;
+
+      // Check hit policy
+      if (dt.hitPolicy) {
+        return `hit-policy-${dt.hitPolicy.toLowerCase()}`;
+      }
+
+      // Check for unary vs expression mode
+      if (dt.inputs?.some((i: any) => i.expression)) {
+        return 'expression-mode';
+      }
+
+      return 'unary-mode';
+    }
+  }
+
+  return 'basic';
+}
+
+function determineSwitchSubset(jdm: any, _nodeTypes: string[]): string {
+  // Analyze switch node characteristics
+  for (const node of jdm.nodes) {
+    if (node.type === NodeType.SWITCH && node.switch) {
+      if (node.switch.collect) {
+        return 'collect-mode';
+      }
+      return 'basic';
+    }
+  }
+
+  return 'basic';
+}
+
+function determineSubDecisionSubset(jdm: any, nodeTypes: string[]): string {
+  const decisionCount = nodeTypes.filter((t: string) => t === NodeType.DECISION).length;
+
+  // Categorizes test complexity.
+  //   >5 decisions = complex-multi (diamond patterns, deep nesting)
+  //   3-5 = simple-multi (basic chaining)
+  //   <=2 = basic (single sub-decision)
+  if (decisionCount > 5) {
+    return 'complex-multi';
+  }
+  if (decisionCount > 2) {
+    return 'simple-multi';
+  }
+  return 'basic';
+}
+
+function extractExpressionFeatures(jdm: any): string[] {
+  const features: string[] = [];
+
+  for (const node of jdm.nodes) {
+    if (node.type === NodeType.EXPRESSION && node.expression) {
+      const expr = JSON.stringify(node.expression);
+
+      if (/[+\-*/]/.test(expr)) {
+        features.push('arithmetic');
+      }
+      if (/[=!<>]/.test(expr)) {
+        features.push('comparisons');
+      }
+      if (/\b(and|or|not)\b/i.test(expr)) {
+        features.push('logical-ops');
+      }
+      if (/["']|concat/i.test(expr)) {
+        features.push('string-ops');
+      }
+      if (/\w+\(/.test(expr)) {
+        features.push('built-in-functions');
+      }
+    }
+  }
+
+  return features;
+}
+
+function extractDecisionTableFeatures(jdm: any): string[] {
+  const features: string[] = [];
+
+  for (const node of jdm.nodes) {
+    if (node.type === NodeType.DECISION_TABLE && node.decisionTable) {
+      const dt = node.decisionTable;
+
+      if (dt.hitPolicy) {
+        features.push(`hit-policy:${dt.hitPolicy}`);
+      }
+      if (dt.inputs?.length) {
+        features.push(`inputs:${dt.inputs.length}`);
+      }
+      if (dt.outputs?.length) {
+        features.push(`outputs:${dt.outputs.length}`);
+      }
+      if (dt.rules?.length) {
+        features.push(`rules:${dt.rules.length}`);
+      }
+    }
+  }
+
+  return features;
+}
+
+function extractSwitchFeatures(jdm: any): string[] {
+  const features: string[] = [];
+
+  for (const node of jdm.nodes) {
+    if (node.type === NodeType.SWITCH && node.switch) {
+      const sw = node.switch;
+
+      if (sw.collect) {
+        features.push('collect-mode');
+      }
+      if (sw.default) {
+        features.push('default-case');
+      }
+      if (sw.cases?.length) {
+        features.push(`cases:${sw.cases.length}`);
+      }
+    }
+  }
+
+  return features;
+}
+
+/**
+ * Categorize all test files in a directory
+ */
+export function categorizeTests(sourceDir: string): CategorizationResult {
+  const categories: Record<string, CategorizedTest[]> = {};
+
+  // Initialize categories
+  Object.values(TestCategory).forEach((cat) => {
+    categories[cat] = [];
+  });
+
+  const files = fs
+    .readdirSync(sourceDir)
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => path.join(sourceDir, f));
+
+  const sourceGraphsDir = path.join(sourceDir, 'graphs');
+  if (fs.existsSync(sourceGraphsDir)) {
+    const graphFiles = fs
+      .readdirSync(sourceGraphsDir)
+      .filter((f) => f.endsWith('.json'))
+      .map((f) => path.join(sourceGraphsDir, f));
+    files.push(...graphFiles);
+  }
+
+  for (const filePath of files) {
+    try {
+      const categorized = categorizeTest(filePath);
+      categories[categorized.category].push(categorized);
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`Failed to categorize ${filePath}: ${message}`);
+    }
+  }
+
+  const totalFiles = files.length;
+  const categorizedFiles = Object.values(categories)
+    .flat()
+    .filter((t) => t.category !== TestCategory.FUNCTION_NODES).length;
+  const skippedFiles = categories[TestCategory.FUNCTION_NODES].length;
+
+  return {
+    totalFiles,
+    categorizedFiles,
+    skippedFiles,
+    categories,
+  };
+}
+
+/**
+ * Copy test files to their categorized locations
+ */
+export function organizeTests(sourceDir: string, targetBaseDir: string = 'test-data'): void {
+  const result = categorizeTests(sourceDir);
+
+  console.log(`Categorized ${result.categorizedFiles} of ${result.totalFiles} files`);
+  console.log(`Skipped ${result.skippedFiles} files with function nodes\n`);
+
+  for (const category of Object.values(TestCategory)) {
+    const tests = result.categories[category];
+
+    if (tests.length === 0) {
+      continue;
+    }
+
+    console.log(`\n## ${category} (${tests.length} files)`);
+
+    for (const test of tests) {
+      if (test.category === TestCategory.FUNCTION_NODES) {
+        console.log(`  ⏭️  Skipped: ${test.name} - ${test.reason}`);
+        continue;
+      }
+
+      const targetDir = path.join(targetBaseDir, path.dirname(test.targetPath));
+      const targetFile = path.join(targetBaseDir, test.targetPath);
+
+      // Create target directory
+      fs.mkdirSync(targetDir, { recursive: true });
+
+      // Copy file
+      if (fs.existsSync(test.sourcePath)) {
+        fs.copyFileSync(test.sourcePath, targetFile);
+        console.log(`  ✅ ${test.name} -> ${test.targetPath}`);
+      } else {
+        console.log(`  ❌ ${test.name} - source not found`);
+      }
+    }
+  }
+}
+
+// CLI entry point
+// CLI entry point
+const testDataPath = process.argv[2] || path.join(process.cwd(), 'test-data/zen-reference');
+const targetBaseDir = process.argv[3] || path.join(process.cwd(), 'test-data');
+
+console.log(`Organizing tests from ${testDataPath} to ${targetBaseDir}\n`);
+organizeTests(testDataPath, targetBaseDir);