@orcalang/orca-lang 0.1.21 → 0.1.24

package/src/compiler/dt-compiler.ts

@@ -55,7 +55,7 @@ function generateTypeScriptType(type: string, values: string[]): string {
   if (type === 'enum') {
     return values.length > 0 ? values.map(v => `'${v}'`).join(' | ') : 'string';
   }
-  if (type === 'int_range') {
+  if (type === 'int_range' || type === 'decimal_range') {
     return 'number';
   }
   return 'string';
@@ -68,10 +68,12 @@ function generateConditionCheck(condName: string, condType: string, cell: CellVa
       return ''; // No condition needed
 
     case 'exact':
-      // For bool type, compare to boolean; for others, compare to string
       if (condType === 'bool') {
         return `input.${condName} === ${cell.value}`;
       }
+      if (condType === 'int_range' || condType === 'decimal_range') {
+        return `input.${condName} === ${cell.value}`;
+      }
       return `input.${condName} === '${cell.value}'`;
 
     case 'negated':
@@ -80,7 +82,7 @@ function generateConditionCheck(condName: string, condType: string, cell: CellVa
       }
       return `input.${condName} !== '${cell.value}'`;
 
-    case 'set':
+    case 'set': {
       const checks = cell.values.map(v => {
         if (condType === 'bool') {
           return `input.${condName} === ${v}`;
@@ -88,6 +90,16 @@ function generateConditionCheck(condName: string, condType: string, cell: CellVa
         return `input.${condName} === '${v}'`;
       }).join(' || ');
       return `(${checks})`;
+    }
+
+    case 'compare':
+      return `input.${condName} ${cell.op} ${cell.value}`;
+
+    case 'range': {
+      const lowCheck = cell.lowInc ? `input.${condName} >= ${cell.low}` : `input.${condName} > ${cell.low}`;
+      const highCheck = cell.highInc ? `input.${condName} <= ${cell.high}` : `input.${condName} < ${cell.high}`;
+      return `(${lowCheck} && ${highCheck})`;
+    }
 
     default:
       return '';
@@ -246,6 +258,7 @@ export function compileDecisionTableToJSON(dt: DecisionTableDef): string {
 function generatePythonType(type: string): string {
   if (type === 'bool') return 'bool';
   if (type === 'int_range') return 'int';
+  if (type === 'decimal_range') return 'float';
   return 'str';
 }
 
@@ -255,6 +268,7 @@ function generatePythonConditionCheck(condName: string, condType: string, cell:
       return '';
     case 'exact':
       if (condType === 'bool') return `input.${condName} == ${cell.value}`;
+      if (condType === 'int_range' || condType === 'decimal_range') return `input.${condName} == ${cell.value}`;
       return `input.${condName} == '${cell.value}'`;
     case 'negated':
       if (condType === 'bool') return `input.${condName} != ${cell.value}`;
@@ -265,6 +279,13 @@ function generatePythonConditionCheck(condName: string, condType: string, cell:
       ).join(' or ');
       return `(${checks})`;
     }
+    case 'compare':
+      return `input.${condName} ${cell.op} ${cell.value}`;
+    case 'range': {
+      const lowCheck = cell.lowInc ? `input.${condName} >= ${cell.low}` : `input.${condName} > ${cell.low}`;
+      const highCheck = cell.highInc ? `input.${condName} <= ${cell.high}` : `input.${condName} < ${cell.high}`;
+      return `(${lowCheck} and ${highCheck})`;
+    }
     default:
       return '';
   }
@@ -352,6 +373,7 @@ export function compileDecisionTableToPython(dt: DecisionTableDef): string {
 function generateGoType(type: string): string {
   if (type === 'bool') return 'bool';
   if (type === 'int_range') return 'int';
+  if (type === 'decimal_range') return 'float64';
   return 'string';
 }
 
@@ -362,6 +384,7 @@ function generateGoConditionCheck(condName: string, condType: string, cell: Cell
       return '';
     case 'exact':
       if (condType === 'bool') return `input.${goField} == ${cell.value}`;
+      if (condType === 'int_range' || condType === 'decimal_range') return `input.${goField} == ${cell.value}`;
       return `input.${goField} == "${cell.value}"`;
     case 'negated':
       if (condType === 'bool') return `input.${goField} != ${cell.value}`;
@@ -372,6 +395,13 @@ function generateGoConditionCheck(condName: string, condType: string, cell: Cell
       ).join(' || ');
       return `(${checks})`;
     }
+    case 'compare':
+      return `input.${goField} ${cell.op} ${cell.value}`;
+    case 'range': {
+      const lowCheck = cell.lowInc ? `input.${goField} >= ${cell.low}` : `input.${goField} > ${cell.low}`;
+      const highCheck = cell.highInc ? `input.${goField} <= ${cell.high}` : `input.${goField} < ${cell.high}`;
+      return `(${lowCheck} && ${highCheck})`;
+    }
     default:
       return '';
   }
@@ -452,3 +482,121 @@ export function compileDecisionTableToGo(dt: DecisionTableDef): string {
 
   return lines.join('\n');
 }
+
+// ============================================================
+// Rust Compiler
+// ============================================================
+
+function generateRustType(type: string): string {
+  if (type === 'bool') return 'bool';
+  if (type === 'int_range') return 'i64';
+  if (type === 'decimal_range') return 'f64';
+  return 'String';
+}
+
+function generateRustConditionCheck(condName: string, condType: string, cell: CellValue): string {
+  switch (cell.kind) {
+    case 'any':
+      return '';
+    case 'exact':
+      if (condType === 'bool') return `input.${condName} == ${cell.value}`;
+      if (condType === 'int_range' || condType === 'decimal_range') return `input.${condName} == ${cell.value}`;
+      return `input.${condName} == "${cell.value}"`;
+    case 'negated':
+      if (condType === 'bool') return `input.${condName} != ${cell.value}`;
+      return `input.${condName} != "${cell.value}"`;
+    case 'set': {
+      const checks = cell.values.map(v =>
+        condType === 'bool' ? `input.${condName} == ${v}` : `input.${condName} == "${v}"`
+      ).join(' || ');
+      return `(${checks})`;
+    }
+    case 'compare':
+      return `input.${condName} ${cell.op} ${cell.value}`;
+    case 'range': {
+      const lowCheck = cell.lowInc ? `input.${condName} >= ${cell.low}` : `input.${condName} > ${cell.low}`;
+      const highCheck = cell.highInc ? `input.${condName} <= ${cell.high}` : `input.${condName} < ${cell.high}`;
+      return `(${lowCheck} && ${highCheck})`;
+    }
+    default:
+      return '';
+  }
+}
+
+export function compileDecisionTableToRust(dt: DecisionTableDef): string {
+  const inputTypeName = `${toPascalCase(dt.name)}Input`;
+  const outputTypeName = `${toPascalCase(dt.name)}Output`;
+  const fnName = `evaluate_${toSnakeCase(dt.name)}`;
+
+  const lines: string[] = [];
+
+  lines.push(`/// Input conditions for the ${dt.name} decision table`);
+  lines.push('#[derive(Debug, Clone)]');
+  lines.push(`pub struct ${inputTypeName} {`);
+  for (const cond of dt.conditions) {
+    const rustType = generateRustType(cond.type);
+    const comment = cond.type === 'enum' && cond.values.length > 0
+      ? ` // ${cond.values.join(', ')}`
+      : '';
+    lines.push(`    pub ${cond.name}: ${rustType},${comment}`);
+  }
+  lines.push('}');
+  lines.push('');
+
+  lines.push(`/// Decision outputs for the ${dt.name} decision table`);
+  lines.push('#[derive(Debug, Clone)]');
+  lines.push(`pub struct ${outputTypeName} {`);
+  for (const action of dt.actions) {
+    const rustType = generateRustType(action.type);
+    const comment = action.type === 'enum' && action.values && action.values.length > 0
+      ? ` // ${action.values.join(', ')}`
+      : '';
+    lines.push(`    pub ${action.name}: ${rustType},${comment}`);
+  }
+  lines.push('}');
+  lines.push('');
+
+  const policy = dt.policy ?? 'first-match';
+  lines.push(`/// Evaluate the ${dt.name} decision table (${policy} policy)`);
+  lines.push(`pub fn ${fnName}(input: &${inputTypeName}) -> Option<${outputTypeName}> {`);
+
+  for (let ruleIdx = 0; ruleIdx < dt.rules.length; ruleIdx++) {
+    const rule = dt.rules[ruleIdx];
+    const ruleNum = rule.number ?? ruleIdx + 1;
+
+    const checks: string[] = [];
+    for (const [condName, cell] of rule.conditions) {
+      const condDef = dt.conditions.find(c => c.name === condName);
+      const condType = condDef?.type ?? 'string';
+      const check = generateRustConditionCheck(condName, condType, cell);
+      if (check) checks.push(check);
+    }
+
+    const actionFields = dt.actions
+      .map(a => {
+        const value = rule.actions.get(a.name);
+        if (value === undefined) return null;
+        const aType = a.type as string;
+        if (aType === 'bool') return `${a.name}: ${value}`;
+        if (aType === 'int_range') return `${a.name}: ${value}`;
+        if (aType === 'decimal_range') return `${a.name}: ${value}`;
+        return `${a.name}: "${value}".to_string()`;
+      })
+      .filter((v): v is string => v !== null)
+      .join(', ');
+
+    lines.push(`    // Rule ${ruleNum}`);
+    if (checks.length === 0) {
+      lines.push(`    return Some(${outputTypeName} { ${actionFields} });`);
+    } else {
+      lines.push(`    if ${checks.join(' && ')} {`);
+      lines.push(`        return Some(${outputTypeName} { ${actionFields} });`);
+      lines.push(`    }`);
+    }
+  }
+
+  lines.push('    None // no rule matched');
+  lines.push('}');
+
+  return lines.join('\n');
+}

package/src/health-check.ts

@@ -186,6 +186,85 @@ async function runHealthCheck(): Promise<HealthReport> {
     }
   }
 
+  // ── Step 7: runtime-rust tests ──────────────────────────────────
+  {
+    const step: StepResult = { name: 'runtime-rust:test', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running runtime-rust tests ━━━');
+    const result = runCommand('cd packages/runtime-rust && cargo test 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Tests passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} runtime-rust tests ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 7b: demo-fortran ─────────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-fortran', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+
+    // Check if gfortran is available
+    const gfortranCheck = runCommand('which gfortran 2>/dev/null', REPO_ROOT);
+    if (gfortranCheck.status !== 0) {
+      step.duration = Date.now() - start;
+      step.status = 'success';
+      step.output = 'Skipped (gfortran not installed)';
+      report.steps.push(step);
+      console.log(`  ○ demo-fortran skipped (gfortran not installed) (${step.duration}ms)\n`);
+    } else {
+      console.log('━━━ Building and running demo-fortran ━━━');
+      const result = runCommand('cd packages/demo-fortran && make run 2>&1', REPO_ROOT);
+      step.duration = Date.now() - start;
+      step.status = result.status === 0 ? 'success' : 'failed';
+      step.output = result.status === 0 ? 'Demo passed' : result.stdout;
+      report.steps.push(step);
+      console.log(`  ${step.status === 'success' ? '✓' : '✗'} demo-fortran ${step.status} (${step.duration}ms)\n`);
+      if (step.status === 'failed') {
+        report.endTime = Date.now();
+        return report;
+      }
+    }
+  }
+
+  // ── Step 7c: demo-rust ─────────────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-rust', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-rust tests ━━━');
+    const result = runCommand('cd packages/demo-rust && cargo test 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Tests passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} demo-rust tests ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 7d: demo-rust-event ───────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-rust-event', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-rust-event ━━━');
+    const result = runCommand('cd packages/demo-rust-event && cargo run 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Demo passed' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} demo-rust-event ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
   // ── Step 8: demo-nanolab tests ─────────────────────────────────
   {
     const step: StepResult = { name: 'demo-nanolab:test', status: 'pending', output: '', duration: 0 };

package/src/parser/dt-ast.ts

@@ -1,6 +1,6 @@
 // Decision Table AST Types
 
-export type ConditionType = 'bool' | 'enum' | 'int_range' | 'string';
+export type ConditionType = 'bool' | 'enum' | 'int_range' | 'decimal_range' | 'string';
 
 export interface ConditionDef {
   name: string;
@@ -22,7 +22,9 @@ export type CellValue =
   | { kind: 'any' }                           // "-" wildcard
   | { kind: 'exact'; value: string }          // exact match
   | { kind: 'negated'; value: string }        // "!value"
-  | { kind: 'set'; values: string[] };        // "a,b" (match any in set)
+  | { kind: 'set'; values: string[] }         // "a,b" (match any in set)
+  | { kind: 'compare'; op: '>' | '>=' | '<' | '<='; value: number }  // >=750, <0.3
+  | { kind: 'range'; low: number; high: number; lowInc: boolean; highInc: boolean }; // 700..749, 0.3-0.4
 
 export interface Rule {
   number?: number;           // optional rule # from the # column

package/src/parser/dt-parser.ts

@@ -21,7 +21,37 @@ function findColumnIndex(headers: string[], name: string): number {
 
 // --- Cell Value Parsing ---
 
-function parseCellValue(text: string | undefined): CellValue {
+function parseNumericCell(text: string): CellValue | null {
+  // Suffix form: 750+ means >=750
+  const suffixPlus = text.match(/^(-?\d+(?:\.\d+)?)\+$/);
+  if (suffixPlus) {
+    return { kind: 'compare', op: '>=', value: parseFloat(suffixPlus[1]) };
+  }
+
+  // Comparison operators: >=750, <=0.3, >100, <600
+  const cmpMatch = text.match(/^(>=|<=|>|<)\s*(-?\d+(?:\.\d+)?)$/);
+  if (cmpMatch) {
+    return { kind: 'compare', op: cmpMatch[1] as '>' | '>=' | '<' | '<=', value: parseFloat(cmpMatch[2]) };
+  }
+
+  // Range with .. separator: 1..50 (inclusive both ends)
+  const dotRange = text.match(/^(-?\d+(?:\.\d+)?)\s*\.\.\s*(-?\d+(?:\.\d+)?)$/);
+  if (dotRange) {
+    return { kind: 'range', low: parseFloat(dotRange[1]), high: parseFloat(dotRange[2]), lowInc: true, highInc: true };
+  }
+
+  // Range with - separator for numbers: 700-749, 0.3-0.4
+  // Must have at least one side that looks numeric (digit-starting).
+  // Negative numbers on the left are ambiguous with subtraction — require left >= 0.
+  const dashRange = text.match(/^(\d+(?:\.\d+)?)\s*-\s*(\d+(?:\.\d+)?)$/);
+  if (dashRange) {
+    return { kind: 'range', low: parseFloat(dashRange[1]), high: parseFloat(dashRange[2]), lowInc: true, highInc: true };
+  }
+
+  return null;
+}
+
+function parseCellValue(text: string | undefined, condType?: ConditionType): CellValue {
   if (!text || text.trim() === '' || text.trim() === '-') {
     return { kind: 'any' };
   }
@@ -36,6 +66,12 @@ function parseCellValue(text: string | undefined): CellValue {
     }
   }
 
+  // Numeric range/compare patterns — only attempt for numeric condition types
+  if (condType === 'int_range' || condType === 'decimal_range') {
+    const numeric = parseNumericCell(trimmed);
+    if (numeric) return numeric;
+  }
+
   // Set: a,b,c
   if (trimmed.includes(',')) {
     return { kind: 'set', values: trimmed.split(',').map(v => v.trim()).filter(Boolean) };
@@ -65,11 +101,11 @@ function parseConditionsTable(table: MdTable): ConditionDef[] {
 
     if (type === 'bool') {
       values = valuesStr.trim() ? valuesStr.split(',').map(v => v.trim()) : ['true', 'false'];
-    } else if (type === 'int_range') {
-      // Parse min..max format
-      const rangeMatch = valuesStr.match(/(\d+)\s*\.\.\s*(\d+)/);
+    } else if (type === 'int_range' || type === 'decimal_range') {
+      // Parse min..max format (integers or decimals)
+      const rangeMatch = valuesStr.match(/(-?\d+(?:\.\d+)?)\s*\.\.\s*(-?\d+(?:\.\d+)?)/);
       if (rangeMatch) {
-        range = { min: parseInt(rangeMatch[1], 10), max: parseInt(rangeMatch[2], 10) };
+        range = { min: parseFloat(rangeMatch[1]), max: parseFloat(rangeMatch[2]) };
         values = [];
       } else {
         values = [];
@@ -116,7 +152,8 @@ function parseActionsTable(table: MdTable): ActionOutputDef[] {
 function parseRulesTable(
   table: MdTable,
   conditionNames: Set<string>,
-  actionNames: Set<string>
+  actionNames: Set<string>,
+  conditionDefs?: ConditionDef[]
 ): { rules: Rule[]; warnings: string[] } {
   const warnings: string[] = [];
   const rules: Rule[] = [];
@@ -167,7 +204,8 @@ function parseRulesTable(
           rule.number = num;
         }
       } else if (col.type === 'condition') {
-        const cellValue = parseCellValue(cell);
+        const condDef = conditionDefs?.find(c => c.name === col.name);
+        const cellValue = parseCellValue(cell, condDef?.type);
         rule.conditions.set(col.name, cellValue);
       } else if (col.type === 'action') {
         const value = cell?.trim() || '';
@@ -254,7 +292,7 @@ export function parseDecisionTable(elements: MdElement[]): { decisionTable: Deci
       } else if (currentSection === 'actions') {
         actions = parseActionsTable(el);
       } else if (currentSection === 'rules') {
-        const result = parseRulesTable(el, new Set(conditions.map(c => c.name)), new Set(actions.map(a => a.name)));
+        const result = parseRulesTable(el, new Set(conditions.map(c => c.name)), new Set(actions.map(a => a.name)), conditions);
         rules = result.rules;
         warnings.push(...result.warnings);
       }