@divmain/jdm-asm 0.2.0 → 0.2.3

package/tests/scripts/analyze-coverage.ts

@@ -1,166 +0,0 @@
-/**
- * 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

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