@divmain/jdm-asm 0.2.0

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@divmain/jdm-asm",
+  "version": "0.2.0",
+  "description": "JDM to AssemblyScript WASM Compiler - Transforms JSON Decision Models into efficient WebAssembly",
+  "license": "MIT",
+  "author": "Dale Bustad <git@dale.link>",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "node scripts/run-all-tests.ts",
+    "build": "tsup src/index.ts --format esm --dts",
+    "lint": "oxlint src tests",
+    "format": "oxfmt --write src tests",
+    "format:check": "oxfmt --check src tests",
+    "bench": "node --stack-size=65536 --import tsx benchmarks/run.ts",
+    "bench:compare": "node --stack-size=65536 --import tsx benchmarks/compare.ts",
+    "bench:optimization": "node --stack-size=65536 --import tsx benchmarks/optimization-bench.ts",
+    "asbuild": "asc src/runtime/index.ts --target release",
+    "asbuild:debug": "asc src/runtime/index.ts --target debug"
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.0",
+    "assemblyscript": "^0.28.9",
+    "chevrotain": "^11.0.3",
+    "graphology": "^0.26.0",
+    "graphology-dag": "^0.4.1"
+  },
+  "devDependencies": {
+    "@gorules/zen-engine": "^0.51.5",
+    "@types/estree": "^1.0.8",
+    "@types/node": "^22.10.2",
+    "mitata": "^1.0.10",
+    "oxfmt": "^0.24.0",
+    "oxlint": "^1.39.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  }
+}

package/scripts/run-all-tests.ts

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+
+/**
+ * Full Test Runner
+ *
+ * Executes all compatibility tests and generates a summary report.
+ *
+ * Usage:
+ *   node scripts/run-all-tests.ts [options]
+ *
+ * Options:
+ *   --watch          Run tests in watch mode
+ *   --verbose        Show detailed output
+ *   --json           Output results as JSON
+ */
+
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+
+interface TestSummary {
+  total: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  duration: number;
+}
+
+interface TestRunnerOptions {
+  watch?: boolean;
+  verbose?: boolean;
+  json?: boolean;
+}
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args: string[]): TestRunnerOptions {
+  const options: TestRunnerOptions = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case '--watch':
+        options.watch = true;
+        break;
+      case '--verbose':
+        options.verbose = true;
+        break;
+      case '--json':
+        options.json = true;
+        break;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Run vitest command and capture output
+ */
+async function runVitest(options: TestRunnerOptions): Promise<TestSummary> {
+  return new Promise((resolve) => {
+    const args = options.watch ? ['watch'] : ['run'];
+
+    const vitest = spawn('npx', ['vitest', ...args], {
+      stdio: ['inherit', 'pipe', 'pipe'],
+      shell: true
+    });
+
+    let output = '';
+    let failedCount = 0;
+    let skippedCount = 0;
+    let passedCount = 0;
+    let totalCount = 0;
+
+    vitest.stdout.on('data', (data) => {
+      const text = data.toString();
+      output += text;
+
+      // Parse test results from output
+      // Look for patterns like "Test Files  ...  (X)"
+      const testFilesMatch = text.match(/Test Files\s+(.*)\s+\((\d+)\)/);
+      if (testFilesMatch && !totalCount) {
+        totalCount = parseInt(testFilesMatch[2], 10);
+      }
+
+      // Look for pass/fail counts
+      const passMatch = text.match(/\b(\d+)\s+passed/);
+      if (passMatch) {
+        passedCount = parseInt(passMatch[1], 10) || passedCount;
+      }
+
+      const failMatch = text.match(/\b(\d+)\s+failed/);
+      if (failMatch) {
+        failedCount = parseInt(failMatch[1], 10) || failedCount;
+      }
+
+      const skipMatch = text.match(/\b(\d+)\s+skipped/);
+      if (skipMatch) {
+        skippedCount = parseInt(skipMatch[1], 10) || skippedCount;
+      }
+
+      if (options.verbose) {
+        process.stdout.write(text);
+      }
+    });
+
+    vitest.stderr.on('data', (data) => {
+      const text = data.toString();
+      output += text;
+      if (options.verbose) {
+        process.stderr.write(text);
+      }
+    });
+
+    const startTime = Date.now();
+
+    vitest.on('close', (code) => {
+      const duration = Date.now() - startTime;
+
+      const summary: TestSummary = {
+        total: totalCount,
+        passed: passedCount,
+        failed: failedCount,
+        skipped: skippedCount,
+        duration,
+      };
+
+      // If we couldn't parse the output, count based on exit code
+      if (totalCount === 0) {
+        summary.failed = code === 0 ? 0 : (summary.failed || 1);
+      }
+
+      resolve(summary);
+    });
+
+    vitest.on('error', (err) => {
+      console.error('Error running vitest:', err);
+      resolve({
+        total: 0,
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        duration: 0,
+      });
+    });
+  });
+}
+
+/**
+ * Print summary report
+ */
+function printSummary(summary: TestSummary): void {
+  console.log('\n' + '='.repeat(60));
+  console.log('📊 Test Results Summary');
+  console.log('='.repeat(60));
+  console.log(`Total Tests:    ${summary.total}`);
+  console.log(`✅ Passed:       ${summary.passed}`);
+  console.log(`❌ Failed:       ${summary.failed}`);
+  console.log(`⏭️  Skipped:     ${summary.skipped}`);
+  console.log(`⏱️  Duration:     ${summary.duration}ms`);
+  console.log('='.repeat(60));
+
+  if (summary.total > 0) {
+    const successRate = Math.round((summary.passed / summary.total) * 100);
+    console.log(`Success Rate:   ${successRate}%`);
+  }
+
+  console.log('='.repeat(60));
+
+  if (summary.failed === 0) {
+    console.log('🎉 All tests passed!');
+  } else {
+    console.log(`⚠️  ${summary.failed} test(s) failed or had issues`);
+    console.log('💡 Run with --verbose for detailed error messages');
+  }
+}
+
+/**
+ * Save summary as JSON
+ */
+function saveJsonSummary(summary: TestSummary, outputDir: string): void {
+  const outputPath = path.join(outputDir, 'test-results.json');
+  fs.mkdirSync(outputDir, { recursive: true });
+  fs.writeFileSync(outputPath, JSON.stringify(summary, null, 2));
+  console.log(`\n📄 Results saved to: ${outputPath}`);
+}
+
+/**
+ * Main entry point
+ */
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  console.log('🧪 Running Full Test Suite\n');
+
+  try {
+    const summary = await runVitest(options);
+
+    if (options.json) {
+      console.log(JSON.stringify(summary, null, 2));
+    } else {
+      printSummary(summary);
+      saveJsonSummary(summary, path.join(process.cwd(), 'dist', 'test-results'));
+    }
+
+    // Exit with appropriate code
+    process.exit(summary.failed > 0 ? 1 : 0);
+  } catch (error) {
+    console.error('❌ Test runner failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}

package/src/compiler/EXPRESSION_SUBSETS.md

@@ -0,0 +1,228 @@
+# Expression Language Subsets - Implementation Plan
+
+This document defines the incremental implementation plan for expression subsets in the ZEN expression language.
+
+## Overview
+
+The expression language will be implemented in stages, going from basic functionality to advanced features. Each subset builds upon the previous ones.
+
+## Subset 1: Basic Arithmetic & Comparisons
+
+**Supported Features:**
+
+- Numeric literals: `42`, `3.14`, `1_000_000` (underscore separators)
+- String literals: `"hello"`, `'world'`
+- Boolean literals: `true`, `false`
+- Null literal: `null`
+- Identifiers: `variableName`, `_private`
+- Arithmetic operators: `+`, `-`, `*`, `/`, `%` (modulo), `^` (power)
+- Comparison operators: `==`, `!=`, `<`, `>`, `<=`, `>=`
+
+**Example Expressions:**
+
+```javascript
+age + 1;
+(price * quantity) / 100;
+score >= 80;
+name == 'admin';
+```
+
+**Implementation Status:** Implemented in Phase 3
+
+---
+
+## Subset 2: Logical Operators
+
+**Supported Features:**
+
+- Logical AND: `and`
+- Logical OR: `or`
+- Logical NOT: `not`
+- Parenthesized expressions: `(a + b) * c`
+
+**Operator Precedence:**
+
+1. Parentheses
+2. NOT (unary)
+3. Arithmetic (`*`, `/`, `%`)
+4. Arithmetic (`+`, `-`)
+5. Power (`^`) - right-associative
+6. Comparisons (`==`, `!=`, `<`, `>`, `<=`, `>=`)
+7. AND
+8. OR
+
+**Example Expressions:**
+
+```javascript
+age >= 18 and hasLicense
+(score > 90 or grade == 'A') and not suspended
+not (a and b) == (not a or not b)
+```
+
+**Implementation Status:** Implemented in Phase 3
+
+---
+
+## Subset 3: String Operations
+
+**Supported Features:**
+
+- String concatenation with `+` operator
+- Template literals: `` `Hello ${name}` ``, `` `Value: ${x}, Total: ${y}` ``
+- Template literals with multiple interpolations
+- Escaped characters in strings
+
+**Example Expressions:**
+
+```javascript
+firstName +
+  ' ' +
+  lastName`Hello, ${name}!``Order ${orderId}: ${items.length} items (${total})``Quote: "Hello\nWorld"`;
+```
+
+**Implementation Status:** Implemented in Phase 3
+
+---
+
+## Subset 4: Object & Array Access
+
+**Supported Features:**
+
+- Member access with dot notation: `object.property`
+- Nested member access: `user.profile.age`
+- Array/tuple access with brackets: `items[0]`
+- Dynamic index access: `entries[index]`
+- Nested access combinations: `users[i].name`
+
+**Example Expressions:**
+
+```javascript
+customer.name;
+order.items[i].price;
+settings.features.enabled;
+data[offset + 2];
+```
+
+**Implementation Status:** Implemented in Phase 3
+
+---
+
+## Subset 5: Built-in Functions
+
+**Supported Features:**
+
+- Function call syntax: `functionName(arg1, arg2)`
+- Standard library functions (to be implemented in Phase 5):
+  - Mathematical: `abs()`, `min()`, `max()`, `round()`, `floor()`, `ceil()`
+  - String: `length()`, `substring()`, `toUpperCase()`, `toLowerCase()`, `trim()`
+  - Array: `size()`, `includes()`, `indexOf()`
+  - Type conversion: `string()`, `number()`, `bool()`
+
+**Example Expressions:**
+
+```javascript
+min(score, 0);
+max(a, b, c);
+substring(name, 0, 3);
+length(items);
+string(age);
+```
+
+**Implementation Status:** Parser implemented, function evaluation runtime in Phase 5
+
+---
+
+## Subset 6: Membership & Range Operators
+
+**Supported Features:**
+
+- Membership operator: `value in array`
+- Negated membership: `value not in array`
+- Interval notation: `[1..10]`, `(5..15)`, `[1..10)`, `(5..10]`
+- Open/closed interval semantics:
+  - `[` inclusive start, `(` exclusive start
+  - `]` inclusive end, `)` exclusive end
+
+**Example Expressions:**
+
+```javascript
+status in ["active", "pending", "review"]
+score not in [0, 59]
+age in [18..120]  // inclusive: 18 <= age <= 120
+level in (0..100] // exclusive start, inclusive end: 0 < level <= 100
+```
+
+**Implementation Status:** Implemented in Phase 3
+
+---
+
+## Subset 7: Ternary & Advanced
+
+**Supported Features:**
+
+- Ternary operator: `condition ? trueValue : falseValue`
+- Special references:
+  - `$` - Dollar reference (current value in unary mode)
+  - `#` - Hash reference (current element in higher-order functions)
+
+**Example Expressions:**
+
+```javascript
+age >= 18 ? "adult" : "minor"
+score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : "F"
+items.filter(# > 5)  // # refers to each item
+map(items, # * 2)    // # refers to each item
+```
+
+**Implementation Status:** Implemented in Phase 3
+
+---
+
+## Unary Mode Syntax
+
+Unary mode is used in decision table cells and has special syntax transformations:
+
+| Unary Expression | Transformed To                     |
+| ---------------- | ---------------------------------- |
+| `"admin"`        | `$ == "admin"`                     |
+| `> 100`          | `$ > 100`                          |
+| `[1..10]`        | `$ in [1..10]`                     |
+| `"a", "b", "c"`  | `$ == "a" or $ == "b" or $ == "c"` |
+| `$ > 100`        | `$ > 100` (unchanged)              |
+| `` (empty)       | `true`                             |
+
+Empty cells or `-` match everything (always return `true`).
+
+**Implementation Status:** Implemented in Phase 3
+
+---
+
+## Priority of Operators (Lowest to Highest)
+
+7. Ternary (`? :`)
+8. Logical OR (`or`)
+9. Logical AND (`and`)
+10. Comparison (`==`, `!=`, `<`, `>`, `<=`, `>=`, `in`, `not in`)
+11. Additive (`+`, `-`)
+12. Multiplicative (`*`, `/`, `%`)
+13. Power (`^`) - right-associative
+14. Unary (`not`, `-`)
+    -1. Postfix (`.property`, `[index]`, `(call)`)
+
+## Phase 3 Implementation Coverage
+
+Phase 3 implements:
+
+- ✅ Subset 1: Basic Arithmetic & Comparisons
+- ✅ Subset 2: Logical Operators
+- ✅ Subset 3: String Operations (template literals)
+- ✅ Subset 4: Object & Array Access
+- ✅ Subset 5: Built-in Functions (parsing only)
+- ✅ Subset 6: Membership & Range Operators
+- ✅ Subset 7: Ternary & Advanced
+- ✅ Unary Mode syntax transformations
+
+Future phases will add:
+
+- Phase 5: Built-in function evaluation runtime
+- Phase 7: Full code generation for AssemblyScript