@orcalang/orca-lang 0.1.17 → 0.1.19

package/src/compiler/dt-compiler.ts

@@ -0,0 +1,232 @@
+// Decision Table Compiler
+// Compiles verified decision tables to TypeScript evaluator functions or JSON
+
+import { DecisionTableDef, CellValue } from '../parser/dt-ast.js';
+
+// Convert camelCase or snake_case to PascalCase
+function toPascalCase(name: string): string {
+  return name
+    .split(/[_-]/)
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+}
+
+// Generate TypeScript type for input interface
+function generateInputType(dt: DecisionTableDef): string {
+  const lines: string[] = [];
+  lines.push(`export interface ${toPascalCase(dt.name)}Input {`);
+
+  for (const cond of dt.conditions) {
+    const typeStr = generateTypeScriptType(cond.type, cond.values);
+    lines.push(`  ${cond.name}: ${typeStr};`);
+  }
+
+  lines.push('}');
+  return lines.join('\n');
+}
+
+// Generate TypeScript type for output interface
+function generateOutputType(dt: DecisionTableDef): string {
+  const lines: string[] = [];
+  lines.push(`export interface ${toPascalCase(dt.name)}Output {`);
+
+  for (const action of dt.actions) {
+    const typeStr = generateTypeScriptType(action.type, action.values || []);
+    lines.push(`  ${action.name}: ${typeStr};`);
+  }
+
+  lines.push('}');
+  return lines.join('\n');
+}
+
+// Generate TypeScript type string from condition/action type
+function generateTypeScriptType(type: string, values: string[]): string {
+  if (type === 'bool') {
+    return 'boolean';
+  }
+  if (type === 'enum') {
+    return values.length > 0 ? values.map(v => `'${v}'`).join(' | ') : 'string';
+  }
+  if (type === 'int_range') {
+    return 'number';
+  }
+  return 'string';
+}
+
+// Generate condition check code
+function generateConditionCheck(condName: string, condType: string, cell: CellValue): string {
+  switch (cell.kind) {
+    case 'any':
+      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}`;
+      }
+      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 => {
+        if (condType === 'bool') {
+          return `input.${condName} === ${v}`;
+        }
+        return `input.${condName} === '${v}'`;
+      }).join(' || ');
+      return `(${checks})`;
+
+    default:
+      return '';
+  }
+}
+
+// Generate return statement for a rule
+function generateReturnStatement(dt: DecisionTableDef, ruleIndex: number): string {
+  const rule = dt.rules[ruleIndex];
+  const actionEntries: string[] = [];
+
+  for (const action of dt.actions) {
+    const value = rule.actions.get(action.name);
+    if (value !== undefined) {
+      if (action.type === 'bool') {
+        // Bool actions use true/false
+        actionEntries.push(`      ${action.name}: ${value}`);
+      } else {
+        actionEntries.push(`      ${action.name}: '${value}'`);
+      }
+    }
+  }
+
+  return `return {\n${actionEntries.join(',\n')}\n    };`;
+}
+
+// Compile to TypeScript evaluator function
+export function compileDecisionTableToTypeScript(dt: DecisionTableDef): string {
+  const inputTypeName = `${toPascalCase(dt.name)}Input`;
+  const outputTypeName = `${toPascalCase(dt.name)}Output`;
+  const functionName = `evaluate${toPascalCase(dt.name)}`;
+
+  const lines: string[] = [];
+
+  // Input interface
+  lines.push(generateInputType(dt));
+  lines.push('');
+
+  // Output interface
+  lines.push(generateOutputType(dt));
+  lines.push('');
+
+  // Evaluator function
+  lines.push(`export function ${functionName}(input: ${inputTypeName}): ${outputTypeName} | null {`);
+
+  // Generate rule checks
+  for (let ruleIdx = 0; ruleIdx < dt.rules.length; ruleIdx++) {
+    const rule = dt.rules[ruleIdx];
+    const ruleNum = rule.number ?? ruleIdx + 1;
+
+    // Collect condition checks
+    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 = generateConditionCheck(condName, condType, cell);
+      if (check) {
+        checks.push(check);
+      }
+    }
+
+    // Build the if statement
+    if (checks.length === 0) {
+      // Rule with all wildcards - always matches
+      lines.push(`  // Rule ${ruleNum}: always matches`);
+      lines.push(`  {`);
+      lines.push(`    ${generateReturnStatement(dt, ruleIdx)}`);
+      lines.push(`  }`);
+    } else {
+      lines.push(`  // Rule ${ruleNum}`);
+      const conditionStr = checks.join(' && ');
+      lines.push(`  if (${conditionStr}) {`);
+      lines.push(`    ${generateReturnStatement(dt, ruleIdx)}`);
+      lines.push(`  }`);
+    }
+  }
+
+  // Default return null
+  lines.push('  return null; // no rule matched');
+  lines.push('}');
+
+  return lines.join('\n');
+}
+
+// Compile to JSON
+export interface DTJSONRule {
+  conditions: Record<string, string>;
+  actions: Record<string, string>;
+}
+
+export interface DTJSON {
+  name: string;
+  conditions: Array<{
+    name: string;
+    type: string;
+    values: string[];
+  }>;
+  actions: Array<{
+    name: string;
+    type: string;
+    values?: string[];
+  }>;
+  rules: DTJSONRule[];
+  policy: 'first-match' | 'all-match';
+}
+
+export function compileDecisionTableToJSON(dt: DecisionTableDef): string {
+  const json: DTJSON = {
+    name: dt.name,
+    conditions: dt.conditions.map(c => ({
+      name: c.name,
+      type: c.type,
+      values: c.values,
+    })),
+    actions: dt.actions.map(a => {
+      const result: { name: string; type: string; values?: string[] } = {
+        name: a.name,
+        type: a.type,
+      };
+      if (a.values) {
+        result.values = a.values;
+      }
+      return result;
+    }),
+    rules: dt.rules.map(rule => {
+      // Omit wildcard conditions (kind: 'any')
+      const conditions: Record<string, string> = {};
+      for (const [name, cell] of rule.conditions) {
+        if (cell.kind === 'exact') {
+          conditions[name] = cell.value;
+        } else if (cell.kind === 'negated') {
+          conditions[name] = `!${cell.value}`;
+        } else if (cell.kind === 'set') {
+          conditions[name] = cell.values.join(',');
+        }
+        // 'any' is omitted
+      }
+
+      const actions: Record<string, string> = {};
+      for (const [name, value] of rule.actions) {
+        actions[name] = value;
+      }
+
+      return { conditions, actions };
+    }),
+    policy: dt.policy,
+  };
+
+  return JSON.stringify(json, null, 2);
+}

package/src/health-check.ts

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+// Health Check Runner - Dogfooding Orca to check itself
+// Uses sequential execution pattern modeled after Orca state machine semantics
+
+import { execSync } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(__dirname, '../../..');
+
+interface StepResult {
+  name: string;
+  status: 'pending' | 'success' | 'failed';
+  output: string;
+  duration: number;
+  passed?: number;
+  skipped?: number;
+}
+
+interface HealthReport {
+  steps: StepResult[];
+  startTime: number;
+  endTime: number;
+  totalPassed: number;
+  totalFailed: number;
+}
+
+function runCommand(cmd: string, cwd: string, timeout = 120000): { status: number; stdout: string; stderr: string } {
+  try {
+    const stdout = execSync(cmd, { cwd, encoding: 'utf-8', timeout, maxBuffer: 10 * 1024 * 1024 });
+    return { status: 0, stdout: stdout as string, stderr: '' };
+  } catch (e: any) {
+    return {
+      status: e.status || 1,
+      stdout: e.stdout?.toString() || '',
+      stderr: e.stderr?.toString() || e.message || ''
+    };
+  }
+}
+
+async function runHealthCheck(): Promise<HealthReport> {
+  const report: HealthReport = {
+    steps: [],
+    startTime: Date.now(),
+    endTime: 0,
+    totalPassed: 0,
+    totalFailed: 0
+  };
+
+  // ── Step 1: Build ──────────────────────────────────────────────
+  {
+    const step: StepResult = { name: 'build', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Building TypeScript packages ━━━');
+    const result = runCommand('pnpm run build', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Build succeeded' : result.stderr || result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} Build ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 2: orca-lang tests ─────────────────────────────────────
+  {
+    const step: StepResult = { name: 'test:lang', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running orca-lang tests ━━━');
+    const result = runCommand('cd packages/orca-lang && pnpm test 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    const match = result.stdout.match(/(\d+) passed.*?(\d+) skipped/);
+    step.passed = match ? parseInt(match[1]) : 0;
+    step.skipped = match ? parseInt(match[2]) : 0;
+    step.status = result.status === 0 && step.passed >= 180 ? 'success' : 'failed';
+    step.output = `${step.passed} passed, ${step.skipped} skipped`;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} ${step.passed} tests passed, ${step.skipped} skipped (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 3: demo-ts smoke test ─────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-ts:test', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-ts smoke test ━━━');
+    const result = runCommand('pnpm --filter orca-demo-ts run 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-ts tests ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 4: demo-ts ticket demo ─────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-ts:ticket', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-ts ticket demo ━━━');
+    const result = runCommand('pnpm -w run run:demo-ts:ticket 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' ? '✓' : '✗'} Support Ticket demo ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 5: demo-python ─────────────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-python', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-python ━━━');
+    const result = runCommand('.venv/bin/python packages/demo-python/demo.py 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-python ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 6: demo-go ─────────────────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-go (trip)', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Running demo-go (trip) ━━━');
+    const result = runCommand('pnpm run test:demo-go 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-go (trip) ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 6b: demo-go:loan ──────────────────────────────────────
+  {
+    const step: StepResult = { name: 'demo-go:loan', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+
+    // Build the loan binary first (not pre-built like 'trip')
+    console.log('━━━ Building demo-go:loan binary ━━━');
+    const buildResult = runCommand('cd packages/demo-go && go build -o loan ./cmd/loan 2>&1', REPO_ROOT);
+    if (buildResult.status !== 0) {
+      step.duration = Date.now() - start;
+      step.status = 'failed';
+      step.output = buildResult.stderr || buildResult.stdout;
+      report.steps.push(step);
+      console.log(`  ✗ Build failed (${step.duration}ms): ${step.output}\n`);
+      report.endTime = Date.now();
+      return report;
+    }
+    console.log(`  ✓ Build succeeded (${Date.now() - start}ms)\n`);
+
+    console.log('━━━ Running demo-go:loan (loan application) ━━━');
+    const runStart = Date.now();
+    const result = runCommand('cd packages/demo-go && ./loan 2>&1', REPO_ROOT);
+    step.duration = Date.now() - runStart;
+    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-go:loan (loan) ${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 };
+    const start = Date.now();
+    console.log('━━━ Running demo-nanolab tests ━━━');
+    const result = runCommand('pnpm run test:demo-nanolab 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-nanolab tests ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  // ── Step 8: Example verification ────────────────────────────────
+  {
+    const step: StepResult = { name: 'examples:verify', status: 'pending', output: '', duration: 0 };
+    const start = Date.now();
+    console.log('━━━ Verifying example files ━━━');
+    const result = runCommand('cd packages/orca-lang && pnpm exec tsx src/index.ts verify examples/simple-toggle.orca.md examples/payment-processor.orca.md 2>&1', REPO_ROOT);
+    step.duration = Date.now() - start;
+    step.status = result.status === 0 ? 'success' : 'failed';
+    step.output = result.status === 0 ? 'Examples verified' : result.stdout;
+    report.steps.push(step);
+    console.log(`  ${step.status === 'success' ? '✓' : '✗'} Examples verified ${step.status} (${step.duration}ms)\n`);
+    if (step.status === 'failed') {
+      report.endTime = Date.now();
+      return report;
+    }
+  }
+
+  report.endTime = Date.now();
+  return report;
+}
+
+function printReport(report: HealthReport) {
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║                    HEALTH CHECK REPORT                     ║');
+  console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+  for (const step of report.steps) {
+    const icon = step.status === 'success' ? '✓' : step.status === 'failed' ? '✗' : '○';
+    const label = step.status === 'success' ? 'PASS' : step.status === 'failed' ? 'FAIL' : 'SKIP';
+    console.log(`  ${icon} ${step.name.padEnd(20)} ${label.padEnd(6)} ${step.duration}ms${step.passed !== undefined ? ` (${step.passed} tests)` : ''}`);
+  }
+
+  const totalDuration = report.endTime - report.startTime;
+  report.totalPassed = report.steps.filter(s => s.status === 'success').length;
+  report.totalFailed = report.steps.filter(s => s.status === 'failed').length;
+
+  console.log(`\n  Total time: ${totalDuration}ms`);
+  console.log(`  Passed: ${report.totalPassed}/${report.totalPassed + report.totalFailed}\n`);
+
+  if (report.totalFailed === 0) {
+    console.log('  ✓ ALL CHECKS PASSED - Project is healthy\n');
+  } else {
+    console.log(`  ✗ ${report.totalFailed} CHECK(S) FAILED\n`);
+    // Print failed step outputs
+    for (const step of report.steps.filter(s => s.status === 'failed')) {
+      console.log(`  ── ${step.name} output ──`);
+      console.log(`  ${step.output.split('\n').slice(0, 10).join('\n  ')}`);
+      if (step.output.split('\n').length > 10) console.log('  ... (truncated)');
+      console.log();
+    }
+  }
+}
+
+async function main() {
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║           ORCA HEALTH CHECK - SELF-HOSTED RUNNER           ║');
+  console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+  const report = await runHealthCheck();
+  printReport(report);
+
+  process.exit(report.totalFailed > 0 ? 1 : 0);
+}
+
+main().catch(err => {
+  console.error('Health check failed with error:', err);
+  process.exit(1);
+});

package/src/parser/ast.ts

@@ -1,5 +1,7 @@
 // Orca AST Type Definitions
 
+import { DecisionTableDef } from './dt-ast.js';
+
 export interface Position {
   line: number;
   column: number;
@@ -228,6 +230,7 @@ export interface MachineDef {
 // Multi-machine file (for machine invocation)
 export interface OrcaFile {
   machines: MachineDef[];
+  decisionTables: DecisionTableDef[];  // NEW
 }
 
 export interface ParseResult {

package/src/parser/dt-ast.ts

@@ -0,0 +1,40 @@
+// Decision Table AST Types
+
+export type ConditionType = 'bool' | 'enum' | 'int_range' | 'string';
+
+export interface ConditionDef {
+  name: string;
+  type: ConditionType;
+  values: string[];         // enum values, or ['true','false'] for bool
+  range?: { min: number; max: number };  // for int_range
+}
+
+export type ActionType = 'bool' | 'enum' | 'string';
+
+export interface ActionOutputDef {
+  name: string;
+  type: ActionType;
+  description?: string;
+  values?: string[];        // valid values for enum type
+}
+
+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)
+
+export interface Rule {
+  number?: number;           // optional rule # from the # column
+  conditions: Map<string, CellValue>;   // condition name → cell value
+  actions: Map<string, string>;          // action name → output value
+}
+
+export interface DecisionTableDef {
+  name: string;
+  description?: string;
+  conditions: ConditionDef[];
+  actions: ActionOutputDef[];
+  rules: Rule[];
+  policy: 'first-match' | 'all-match';  // default: first-match
+}