@orcalang/orca-lang 0.1.19 → 0.1.21

package/src/compiler/dt-compiler.ts

@@ -1,5 +1,5 @@
 // Decision Table Compiler
-// Compiles verified decision tables to TypeScript evaluator functions or JSON
+// Compiles verified decision tables to TypeScript, Python, Go evaluator functions or JSON
 
 import { DecisionTableDef, CellValue } from '../parser/dt-ast.js';
 
@@ -11,6 +11,14 @@ function toPascalCase(name: string): string {
     .join('');
 }
 
+// Convert PascalCase or camelCase to snake_case
+export function toSnakeCase(name: string): string {
+  return name
+    .replace(/([A-Z])/g, '_$1')
+    .toLowerCase()
+    .replace(/^_/, '');
+}
+
 // Generate TypeScript type for input interface
 function generateInputType(dt: DecisionTableDef): string {
   const lines: string[] = [];
@@ -230,3 +238,217 @@ export function compileDecisionTableToJSON(dt: DecisionTableDef): string {
 
   return JSON.stringify(json, null, 2);
 }
+
+// ============================================================
+// Python Compiler
+// ============================================================
+
+function generatePythonType(type: string): string {
+  if (type === 'bool') return 'bool';
+  if (type === 'int_range') return 'int';
+  return 'str';
+}
+
+function generatePythonConditionCheck(condName: string, condType: string, cell: CellValue): string {
+  switch (cell.kind) {
+    case 'any':
+      return '';
+    case 'exact':
+      if (condType === 'bool') 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(' or ');
+      return `(${checks})`;
+    }
+    default:
+      return '';
+  }
+}
+
+export function compileDecisionTableToPython(dt: DecisionTableDef): string {
+  const inputClassName = `${toPascalCase(dt.name)}Input`;
+  const outputClassName = `${toPascalCase(dt.name)}Output`;
+  const fnName = `evaluate_${toSnakeCase(dt.name)}`;
+
+  const lines: string[] = [
+    'from typing import Optional',
+    'from dataclasses import dataclass',
+    '',
+    '',
+    '@dataclass',
+    `class ${inputClassName}:`,
+  ];
+
+  for (const cond of dt.conditions) {
+    const typeStr = generatePythonType(cond.type);
+    const comment = cond.type === 'enum' && cond.values.length > 0
+      ? `  # ${cond.values.join(', ')}`
+      : '';
+    lines.push(`    ${cond.name}: ${typeStr}${comment}`);
+  }
+
+  lines.push('');
+  lines.push('');
+  lines.push('@dataclass');
+  lines.push(`class ${outputClassName}:`);
+
+  for (const action of dt.actions) {
+    const typeStr = generatePythonType(action.type);
+    const comment = action.type === 'enum' && action.values && action.values.length > 0
+      ? `  # ${action.values.join(', ')}`
+      : '';
+    lines.push(`    ${action.name}: ${typeStr}${comment}`);
+  }
+
+  lines.push('');
+  lines.push('');
+  lines.push(`def ${fnName}(input: ${inputClassName}) -> Optional[${outputClassName}]:`);
+
+  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 = generatePythonConditionCheck(condName, condType, cell);
+      if (check) checks.push(check);
+    }
+
+    const actionArgs = dt.actions
+      .map(a => {
+        const value = rule.actions.get(a.name);
+        if (value === undefined) return null;
+        if (a.type === 'bool') return `${a.name}=${value}`;
+        return `${a.name}='${value}'`;
+      })
+      .filter((v): v is string => v !== null)
+      .join(', ');
+
+    lines.push(`    # Rule ${ruleNum}`);
+    if (checks.length === 0) {
+      lines.push(`    return ${outputClassName}(${actionArgs})`);
+    } else {
+      lines.push(`    if ${checks.join(' and ')}:`);
+      lines.push(`        return ${outputClassName}(${actionArgs})`);
+    }
+  }
+
+  lines.push('    return None  # no rule matched');
+
+  return lines.join('\n');
+}
+
+// ============================================================
+// Go Compiler
+// ============================================================
+
+function generateGoType(type: string): string {
+  if (type === 'bool') return 'bool';
+  if (type === 'int_range') return 'int';
+  return 'string';
+}
+
+function generateGoConditionCheck(condName: string, condType: string, cell: CellValue): string {
+  const goField = toPascalCase(condName);
+  switch (cell.kind) {
+    case 'any':
+      return '';
+    case 'exact':
+      if (condType === 'bool') return `input.${goField} == ${cell.value}`;
+      return `input.${goField} == "${cell.value}"`;
+    case 'negated':
+      if (condType === 'bool') return `input.${goField} != ${cell.value}`;
+      return `input.${goField} != "${cell.value}"`;
+    case 'set': {
+      const checks = cell.values.map(v =>
+        condType === 'bool' ? `input.${goField} == ${v}` : `input.${goField} == "${v}"`
+      ).join(' || ');
+      return `(${checks})`;
+    }
+    default:
+      return '';
+  }
+}
+
+export function compileDecisionTableToGo(dt: DecisionTableDef): string {
+  const inputTypeName = `${toPascalCase(dt.name)}Input`;
+  const outputTypeName = `${toPascalCase(dt.name)}Output`;
+  const fnName = `Evaluate${toPascalCase(dt.name)}`;
+
+  const lines: string[] = [];
+
+  lines.push(`// ${inputTypeName} defines the input conditions for the ${dt.name} decision table`);
+  lines.push(`type ${inputTypeName} struct {`);
+  for (const cond of dt.conditions) {
+    const goType = generateGoType(cond.type);
+    const fieldName = toPascalCase(cond.name);
+    const comment = cond.type === 'enum' && cond.values.length > 0
+      ? ` // ${cond.values.join(', ')}`
+      : '';
+    lines.push(`\t${fieldName} ${goType}${comment}`);
+  }
+  lines.push('}');
+  lines.push('');
+
+  lines.push(`// ${outputTypeName} defines the decision outputs for the ${dt.name} decision table`);
+  lines.push(`type ${outputTypeName} struct {`);
+  for (const action of dt.actions) {
+    const goType = generateGoType(action.type);
+    const fieldName = toPascalCase(action.name);
+    const comment = action.type === 'enum' && action.values && action.values.length > 0
+      ? ` // ${action.values.join(', ')}`
+      : '';
+    lines.push(`\t${fieldName} ${goType}${comment}`);
+  }
+  lines.push('}');
+  lines.push('');
+
+  const policy = dt.policy ?? 'first-match';
+  lines.push(`// ${fnName} evaluates the ${dt.name} decision table (${policy} policy)`);
+  lines.push(`func ${fnName}(input ${inputTypeName}) *${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 = generateGoConditionCheck(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 fieldName = toPascalCase(a.name);
+        if (a.type === 'bool') return `${fieldName}: ${value}`;
+        return `${fieldName}: "${value}"`;
+      })
+      .filter((v): v is string => v !== null)
+      .join(', ');
+
+    lines.push(`\t// Rule ${ruleNum}`);
+    if (checks.length === 0) {
+      lines.push(`\treturn &${outputTypeName}{${actionFields}}`);
+    } else {
+      lines.push(`\tif ${checks.join(' && ')} {`);
+      lines.push(`\t\treturn &${outputTypeName}{${actionFields}}`);
+      lines.push(`\t}`);
+    }
+  }
+
+  lines.push('\treturn nil // no rule matched');
+  lines.push('}');
+
+  return lines.join('\n');
+}

package/src/index.ts

@@ -22,6 +22,7 @@ import { checkStructural, analyzeFile } from './verifier/structural.js';
 import { checkCompleteness } from './verifier/completeness.js';
 import { checkDeterminism } from './verifier/determinism.js';
 import { checkProperties } from './verifier/properties.js';
+import { computeAlignedDTOutputDomain } from './verifier/dt-verifier.js';
 import { compileToXState, compileToXStateMachine } from './compiler/xstate.js';
 import { compileToMermaid } from './compiler/mermaid.js';
 import { verifySkill, compileSkill, generateActionsSkill, refineSkill, generateOrcaSkill, generateOrcaMultiSkill, parseSkill, type SkillInput } from './skills.js';
@@ -232,7 +233,10 @@ async function verify(input: SkillInput, json: boolean = false): Promise<void> {
   const structural = checkStructural(machine);
   const completeness = checkCompleteness(machine);
   const determinism = checkDeterminism(machine);
-  const properties = checkProperties(machine);
+  const dtOutputDomain = file.decisionTables.length > 0
+    ? computeAlignedDTOutputDomain({ machines: [machine], decisionTables: file.decisionTables })
+    : undefined;
+  const properties = checkProperties(machine, { dtOutputDomain });
 
   const allErrors = [
     ...structural.errors,

package/src/parser/ast-to-markdown.ts

@@ -101,7 +101,8 @@ function emitStates(states: StateDef[], level: number): string[] {
     if (state.onEntry) lines.push(`- on_entry: ${state.onEntry}`);
     if (state.onExit) lines.push(`- on_exit: ${state.onExit}`);
     if (state.timeout) lines.push(`- timeout: ${state.timeout.duration} -> ${state.timeout.target}`);
-    if (state.ignoredEvents?.length) lines.push(`- ignore: ${state.ignoredEvents.join(', ')}`);
+    if (state.ignoredAll) lines.push(`- ignore: *`);
+    else if (state.ignoredEvents?.length) lines.push(`- ignore: ${state.ignoredEvents.join(', ')}`);
     if (state.onDone) lines.push(`- on_done: -> ${state.onDone}`);
 
     if (state.parallel) {

package/src/parser/ast.ts

@@ -120,6 +120,7 @@ export interface StateDef {
   parent?: string;  // Parent state name for hierarchical states
   transitions?: Transition[];
   ignoredEvents?: string[];
+  ignoredAll?: boolean;     // true when "- ignore: *" — all unhandled events discarded
 }
 
 export interface Transition {

package/src/parser/markdown-parser.ts

@@ -391,6 +391,7 @@ interface StateEntry {
   invoke?: InvokeDef;
   _pendingOnError?: string;  // temp: on_error parsed before invoke
   ignoredEvents?: string[];
+  ignoredAll?: boolean;
   line: number;
 }
 
@@ -431,9 +432,14 @@ function parseStateBullet(entry: StateEntry, text: string): void {
       entry.timeout = { duration: rest.slice(0, arrowIdx).trim(), target: rest.slice(arrowIdx + 2).trim() };
     }
   } else if (text.startsWith('ignore:')) {
-    const names = text.slice(7).trim().split(',').map(e => e.trim()).filter(Boolean);
-    if (!entry.ignoredEvents) entry.ignoredEvents = [];
-    entry.ignoredEvents.push(...names);
+    const val = text.slice(7).trim();
+    if (val === '*') {
+      entry.ignoredAll = true;
+    } else {
+      const names = val.split(',').map(e => e.trim()).filter(Boolean);
+      if (!entry.ignoredEvents) entry.ignoredEvents = [];
+      entry.ignoredEvents.push(...names);
+    }
   } else if (text.startsWith('on_done:')) {
     let val = text.slice(8).trim();
     if (val.startsWith('->')) val = val.slice(2).trim();
@@ -630,6 +636,7 @@ function buildStatesAtLevel(
     if (entry.onDone) state.onDone = entry.onDone;
     if (entry.timeout) state.timeout = entry.timeout;
     if (entry.ignoredEvents?.length) state.ignoredEvents = entry.ignoredEvents;
+    if (entry.ignoredAll) state.ignoredAll = true;
     if (entry.invoke) state.invoke = entry.invoke;
 
     i++;
@@ -678,6 +685,7 @@ function buildParallelRegions(
         if (e.onDone) s.onDone = e.onDone;
         if (e.timeout) s.timeout = e.timeout;
         if (e.ignoredEvents?.length) s.ignoredEvents = e.ignoredEvents;
+        if (e.ignoredAll) s.ignoredAll = true;
         if (e.invoke) s.invoke = e.invoke;
         regionStates.push(s);
         i++;