@skillstech/thunderlang 0.1.7 → 0.3.0

package/src/target-cs.mjs

@@ -0,0 +1,98 @@
+// C# target adapter. Emits a self-contained Program.cs that defines each decision as a typed
+// static method (using the same exprToCSharp translator the codegen uses), calls every test case
+// with typed literal arguments, and prints the results as one JSON line. It runs through a
+// throwaway `dotnet` console project (scaffold + `dotnet run`), so a live C# run grades real
+// compiled + executed code. Returns null (skip cleanly) when no usable .NET SDK exists.
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { exprToCSharp } from './expr.mjs';
+import { inputNames, inferInputTypes, buildCases, parseLastJsonObject, cachedSmoke, strLit, litFor } from './target-util.mjs';
+
+const CS_TYPE = { number: 'double', bool: 'bool', string: 'string' };
+
+// Scaffold a bare console project in `dir`, overwrite Program.cs with `source`, and run it.
+// Returns stdout, or null on any failure. A bare console app has no external packages, so the
+// implicit restore is offline.
+function dotnetRun(dir, source) {
+  const proj = join(dir, 'app');
+  const env = { ...process.env, DOTNET_CLI_TELEMETRY_OPTOUT: '1', DOTNET_NOLOGO: '1', DOTNET_SKIP_FIRST_TIME_EXPERIENCE: '1' };
+  const mk = spawnSync('dotnet', ['new', 'console', '-o', proj], { encoding: 'utf8', timeout: 120000, env });
+  if (mk.status !== 0) return null;
+  writeFileSync(join(proj, 'Program.cs'), source);
+  const run = spawnSync('dotnet', ['run', '--project', proj, '-c', 'Release'], { encoding: 'utf8', timeout: 240000, env });
+  if (run.status !== 0) return null;
+  return run.stdout;
+}
+
+// The emitted C# source (also usable for display / `gen`-parity).
+export function emitCSharpModule(ast, cases = buildCases(ast)) {
+  const L = [
+    'using System;',
+    'using System.Collections.Generic;',
+    'using System.Linq;',
+    'using System.Text;',
+    'class ThunderTarget {',
+  ];
+  const typesByDec = {};
+  for (const d of ast.decisions || []) {
+    const names = inputNames(d);
+    const types = inferInputTypes(ast, d);
+    typesByDec[d.name] = types;
+    const params = names.map((n) => `${CS_TYPE[types[n]] || 'string'} ${n}`).join(', ');
+    L.push(`  static string ${d.name}(${params}) {`);
+    for (const r of d.rules || []) {
+      let cond; try { cond = exprToCSharp(r.when, { inputs: names }); } catch { cond = 'false'; }
+      L.push(`    if (${cond}) return ${strLit(r.result)};`);
+    }
+    L.push(`    return ${d.default == null ? 'null' : strLit(d.default)};`, '  }');
+  }
+  L.push('  static string J(string s) {');
+  L.push('    if (s == null) return "null";');
+  L.push('    var b = new StringBuilder("\\"");');
+  L.push('    foreach (char c in s) {');
+  L.push('      if (c == \'\\\\\' || c == \'"\') b.Append(\'\\\\\').Append(c);');
+  L.push('      else if (c == \'\\n\') b.Append("\\\\n"); else b.Append(c); }');
+  L.push('    return b.Append(\'"\').ToString(); }');
+  L.push('  static void Main() {');
+  L.push('    var outp = new List<KeyValuePair<string,string>>();');
+  for (const c of cases) {
+    const dec = (ast.decisions || []).find((d) => d.name === c.fn);
+    if (!dec) continue;
+    const types = typesByDec[c.fn];
+    const argList = inputNames(dec).map((n) => litFor(types[n], c.given[n])).join(', ');
+    L.push(`    outp.Add(new KeyValuePair<string,string>(${strLit(c.key)}, ${c.fn}(${argList})));`);
+  }
+  L.push('    var sb = new StringBuilder("{"); bool first = true;');
+  L.push('    foreach (var e in outp) {');
+  L.push('      if (!first) sb.Append(","); first = false;');
+  L.push('      sb.Append(J(e.Key)).Append(":").Append(J(e.Value)); }');
+  L.push('    Console.WriteLine(sb.Append("}").ToString());');
+  L.push('  }');
+  L.push('}');
+  return L.join('\n');
+}
+
+export function csharpAvailable() {
+  return cachedSmoke('csharp', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'tl-cs-smoke-'));
+    try {
+      const src = 'using System; class ThunderTarget { static void Main(){ Console.WriteLine("{\\"ok\\":\\"1\\"}"); } }';
+      const out = dotnetRun(dir, src);
+      return !!out && /"ok"/.test(out);
+    } finally { try { rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ } }
+  });
+}
+
+// Run every decision test case through generated, compiled C#. Returns { "Test / case": actual }
+// or null when no usable .NET SDK is present.
+export function runCSharpTarget(ast) {
+  if (!csharpAvailable()) return null;
+  const cases = buildCases(ast);
+  const dir = mkdtempSync(join(tmpdir(), 'tl-cs-'));
+  try {
+    const out = dotnetRun(dir, emitCSharpModule(ast, cases));
+    return out == null ? null : parseLastJsonObject(out);
+  } finally { try { rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ } }
+}

package/src/target-java.mjs

@@ -0,0 +1,87 @@
+// Java target adapter. Emits a self-contained ThunderTarget.java that defines each decision as a
+// typed static method (using the same exprToJava translator the codegen uses), calls every test
+// case with typed literal arguments, and prints the results as one JSON line. It runs through the
+// JDK 11+ single-file source launcher (`java ThunderTarget.java`) , no separate javac step , so a
+// live Java run grades real executed code. Returns null (skip cleanly) when no usable JDK exists.
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { exprToJava } from './expr.mjs';
+import { inputNames, inferInputTypes, buildCases, parseLastJsonObject, cachedSmoke, strLit, litFor } from './target-util.mjs';
+
+const JAVA_TYPE = { number: 'double', bool: 'boolean', string: 'String' };
+
+// The emitted Java source (also usable for display / `gen`-parity).
+export function emitJavaModule(ast, cases = buildCases(ast)) {
+  const L = [
+    'import java.util.LinkedHashMap;',
+    'import java.util.Map;',
+    '',
+    'public class ThunderTarget {',
+  ];
+  const typesByDec = {};
+  for (const d of ast.decisions || []) {
+    const names = inputNames(d);
+    const types = inferInputTypes(ast, d);
+    typesByDec[d.name] = types;
+    const params = names.map((n) => `${JAVA_TYPE[types[n]] || 'String'} ${n}`).join(', ');
+    L.push(`  static String ${d.name}(${params}) {`);
+    for (const r of d.rules || []) {
+      let cond; try { cond = exprToJava(r.when, { inputs: names }); } catch { cond = 'false'; }
+      L.push(`    if (${cond}) return ${strLit(r.result)};`);
+    }
+    L.push(`    return ${d.default == null ? 'null' : strLit(d.default)};`, '  }');
+  }
+  L.push('  static String j(String s) {');
+  L.push('    if (s == null) return "null";');
+  L.push('    StringBuilder b = new StringBuilder("\\"");');
+  L.push('    for (int i = 0; i < s.length(); i++) { char c = s.charAt(i);');
+  L.push('      if (c == \'\\\\\' || c == \'"\') b.append(\'\\\\\').append(c);');
+  L.push('      else if (c == \'\\n\') b.append("\\\\n"); else b.append(c); }');
+  L.push('    return b.append(\'"\').toString(); }');
+  L.push('  public static void main(String[] args) {');
+  L.push('    Map<String,String> out = new LinkedHashMap<>();');
+  for (const c of cases) {
+    const dec = (ast.decisions || []).find((d) => d.name === c.fn);
+    if (!dec) continue;
+    const types = typesByDec[c.fn];
+    const argList = inputNames(dec).map((n) => litFor(types[n], c.given[n])).join(', ');
+    L.push(`    out.put(${strLit(c.key)}, ${c.fn}(${argList}));`);
+  }
+  L.push('    StringBuilder sb = new StringBuilder("{"); boolean first = true;');
+  L.push('    for (Map.Entry<String,String> e : out.entrySet()) {');
+  L.push('      if (!first) sb.append(","); first = false;');
+  L.push('      sb.append(j(e.getKey())).append(":").append(j(e.getValue())); }');
+  L.push('    System.out.println(sb.append("}").toString());');
+  L.push('  }');
+  L.push('}');
+  return L.join('\n');
+}
+
+export function javaAvailable() {
+  return cachedSmoke('java', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'tl-java-smoke-'));
+    try {
+      const f = join(dir, 'Hi.java');
+      writeFileSync(f, 'public class Hi { public static void main(String[] a){ System.out.println("{\\"ok\\":\\"1\\"}"); } }');
+      const r = spawnSync('java', [f], { encoding: 'utf8', timeout: 60000 });
+      return r.status === 0 && /"ok"/.test(r.stdout || '');
+    } finally { try { rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ } }
+  });
+}
+
+// Run every decision test case through generated, compiled Java. Returns { "Test / case": actual }
+// or null when no usable JDK is present.
+export function runJavaTarget(ast) {
+  if (!javaAvailable()) return null;
+  const cases = buildCases(ast);
+  const dir = mkdtempSync(join(tmpdir(), 'tl-java-'));
+  try {
+    const f = join(dir, 'ThunderTarget.java');
+    writeFileSync(f, emitJavaModule(ast, cases));
+    const r = spawnSync('java', [f], { encoding: 'utf8', timeout: 120000 });
+    if (r.status !== 0) return null;
+    return parseLastJsonObject(r.stdout);
+  } finally { try { rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ } }
+}

package/src/target-py.mjs

@@ -0,0 +1,90 @@
+// Python target adapter. Compiles each decision into an executable Python function using the
+// SAME expression translator the codegen uses (exprToPython), then runs the test cases through a
+// real `python3` child process and returns actual outputs. Like the TypeScript adapter, this makes
+// conformance "grade a live target" rather than "grade fed results" — the generated Python is
+// executed for real. Returns null (not a partial result) when python3 is unavailable, so callers
+// can report the target as skipped rather than failing.
+import { spawnSync } from 'node:child_process';
+import { exprToPython } from './expr.mjs';
+
+const inputNames = (dec) => (dec.inputs || []).map((i) => String(i).split(':')[0].trim()).filter(Boolean);
+
+function coerceVal(v) {
+  if (v == null || typeof v !== 'string') return v;
+  const s = v.trim();
+  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  return v;
+}
+
+// True when a runnable python3 interpreter is present on this machine.
+export function pythonAvailable() {
+  try {
+    const r = spawnSync('python3', ['--version'], { encoding: 'utf8', timeout: 10000 });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+// The emitted Python source (for display / gen-parity).
+export function emitPythonModule(ast) {
+  const L = ['# Executable Python target compiled from the decision(s). Deterministic, no AI.'];
+  for (const d of ast.decisions || []) {
+    L.push(`def ${d.name}(${inputNames(d).join(', ')}):`);
+    for (const r of d.rules || []) {
+      let cond; try { cond = exprToPython(r.when, { inputs: inputNames(d) }); } catch { cond = 'False'; }
+      L.push(`    if ${cond}: return ${JSON.stringify(r.result)}`);
+    }
+    L.push(`    return ${d.default == null ? 'None' : JSON.stringify(d.default)}`);
+    L.push('');
+  }
+  return L.join('\n');
+}
+
+// Run every decision test case through generated Python. Returns { "Test / case": actual },
+// or null if python3 is unavailable or the interpreter failed to run the program.
+export function runPythonTarget(ast) {
+  if (!pythonAvailable()) return null;
+
+  // Build the list of calls to make, one per test case, in a stable order.
+  const cases = [];
+  for (const t of ast.tests || []) {
+    const dec = (ast.decisions || []).find((d) => d.name === t.name);
+    if (!dec) continue;
+    const names = inputNames(dec);
+    for (const c of t.cases || []) {
+      cases.push({
+        key: `${t.name} / ${c.name || 'case'}`,
+        fn: t.name,
+        args: names.map((n) => coerceVal((c.given || {})[n])),
+      });
+    }
+  }
+
+  // Emit a self-contained program: decision defs + a driver that runs each case and prints JSON.
+  // Cases (with already-coerced arg types) are handed in as a JSON literal parsed by json.loads,
+  // so Python receives real ints/floats/bools/strings rather than stringified values.
+  const program = [
+    'import json',
+    emitPythonModule(ast),
+    `CASES = json.loads(${JSON.stringify(JSON.stringify(cases))})`,
+    'out = {}',
+    'for c in CASES:',
+    '    fn = globals().get(c["fn"])',
+    '    try:',
+    '        out[c["key"]] = fn(*c["args"]) if callable(fn) else None',
+    '    except Exception:',
+    '        out[c["key"]] = None',
+    'print(json.dumps(out))',
+  ].join('\n');
+
+  const res = spawnSync('python3', ['-'], { input: program, encoding: 'utf8', timeout: 30000 });
+  if (res.status !== 0 || !res.stdout) return null;
+  try {
+    return JSON.parse(res.stdout.trim().split('\n').pop());
+  } catch {
+    return null;
+  }
+}

package/src/target-ts.mjs

@@ -0,0 +1,66 @@
+// TypeScript/JS target adapter. Compiles each decision into an executable function using the
+// SAME expression translator the TypeScript codegen uses (exprToJs), then runs the test cases
+// through the generated code and returns actual outputs. This turns conformance from "grade fed
+// results" into "grade a live target": the generated implementation is executed for real.
+// Type annotations are erased at runtime, so running the type-stripped JS is faithful to the TS.
+import { exprToJs } from './expr.mjs';
+
+const inputNames = (dec) => (dec.inputs || []).map((i) => String(i).split(':')[0].trim()).filter(Boolean);
+
+function coerceVal(v) {
+  if (v == null || typeof v !== 'string') return v;
+  const s = v.trim();
+  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  return v;
+}
+
+// The emitted source (for display / `gen`-parity); the runtime uses new Function on the body.
+export function emitDecisionModule(ast) {
+  const L = ['// Executable target compiled from the decision(s). Deterministic, no AI.'];
+  for (const d of ast.decisions || []) {
+    L.push(`export function ${d.name}(${inputNames(d).join(', ')}) {`);
+    for (const r of d.rules || []) {
+      let cond; try { cond = exprToJs(r.when, { inputs: inputNames(d) }); } catch { cond = 'false'; }
+      L.push(`  if (${cond}) return ${JSON.stringify(r.result)};`);
+    }
+    L.push(`  return ${JSON.stringify(d.default ?? null)};`, '}');
+  }
+  return L.join('\n');
+}
+
+// Compile each decision to a runnable function.
+function compileDecisionFns(ast) {
+  const fns = {};
+  for (const d of ast.decisions || []) {
+    const names = inputNames(d);
+    const body = [];
+    for (const r of d.rules || []) {
+      let cond; try { cond = exprToJs(r.when, { inputs: names }); } catch { cond = 'false'; }
+      body.push(`if (${cond}) return ${JSON.stringify(r.result)};`);
+    }
+    body.push(`return ${JSON.stringify(d.default ?? null)};`);
+    try { fns[d.name] = new Function(...names, body.join('\n')); } catch { fns[d.name] = null; }
+  }
+  return fns;
+}
+
+// Run every decision test case through the generated code. Returns { "Test / case": actual }.
+export function runTypescriptTarget(ast) {
+  const fns = compileDecisionFns(ast);
+  const out = {};
+  for (const t of ast.tests || []) {
+    const dec = (ast.decisions || []).find((d) => d.name === t.name);
+    if (!dec) continue;
+    const names = inputNames(dec);
+    const fn = fns[t.name];
+    for (const c of t.cases || []) {
+      const key = `${t.name} / ${c.name || 'case'}`;
+      if (typeof fn !== 'function') { out[key] = null; continue; }
+      const args = names.map((n) => coerceVal((c.given || {})[n]));
+      try { out[key] = fn(...args); } catch { out[key] = null; }
+    }
+  }
+  return out;
+}

package/src/target-util.mjs

@@ -0,0 +1,95 @@
+// Shared helpers for the compiled target adapters (Python/C#/Java). The statically typed targets
+// (C#, Java) need a declared type for every decision parameter, which ThunderLang source leaves
+// implicit, so we infer each input's type from the test-case values that will actually be passed.
+import { spawnSync } from 'node:child_process';
+
+export const inputNames = (dec) => (dec.inputs || []).map((i) => String(i).split(':')[0].trim()).filter(Boolean);
+
+export function coerceVal(v) {
+  if (v == null || typeof v !== 'string') return v;
+  const s = v.trim();
+  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  return v;
+}
+
+// Every case-call we will emit, in a stable order: { key, fn, given: {name: coercedValue} }.
+export function buildCases(ast) {
+  const cases = [];
+  for (const t of ast.tests || []) {
+    const dec = (ast.decisions || []).find((d) => d.name === t.name);
+    if (!dec) continue;
+    const names = inputNames(dec);
+    for (const c of t.cases || []) {
+      const given = {};
+      for (const n of names) given[n] = coerceVal((c.given || {})[n]);
+      cases.push({ key: `${t.name} / ${c.name || 'case'}`, fn: t.name, given });
+    }
+  }
+  return cases;
+}
+
+// Infer one type per input for a decision, scanning every case that targets it. Numeric usage
+// wins (a relational comparison must compile), then boolean, else string. Falls back to 'string'.
+export function inferInputTypes(ast, dec) {
+  const names = inputNames(dec);
+  const types = {};
+  for (const n of names) {
+    let t = 'string';
+    for (const test of (ast.tests || []).filter((x) => x.name === dec.name)) {
+      for (const c of test.cases || []) {
+        const raw = (c.given || {})[n];
+        if (raw == null) continue;
+        const cv = coerceVal(raw);
+        if (typeof cv === 'number') { t = 'number'; break; }
+        if (typeof cv === 'boolean' && t !== 'number') t = 'bool';
+      }
+      if (t === 'number') break;
+    }
+    types[n] = t;
+  }
+  return types;
+}
+
+// Pick the last line of stdout that parses as a JSON object , build/tool chatter may precede it.
+export function parseLastJsonObject(stdout) {
+  if (!stdout) return null;
+  const lines = stdout.split('\n').map((l) => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (!lines[i].startsWith('{')) continue;
+    try { return JSON.parse(lines[i]); } catch { /* keep scanning upward */ }
+  }
+  return null;
+}
+
+// Cached toolchain-availability smoke tests. Each actually exercises the exact invocation the
+// adapter uses (single-file `java`, or scaffold + `dotnet run`) so a target is only reported
+// runnable when it can genuinely compile and run, not merely because a binary is on PATH.
+const _cache = {};
+export function cachedSmoke(key, fn) {
+  if (key in _cache) return _cache[key];
+  let ok = false;
+  try { ok = !!fn(); } catch { ok = false; }
+  _cache[key] = ok;
+  return ok;
+}
+
+// A source literal for a value at an inferred type. JSON string escaping is valid in Java and C#
+// string literals too, so we reuse JSON.stringify for the string case.
+export const strLit = (s) => JSON.stringify(String(s));
+export function litFor(type, v) {
+  if (v == null) return type === 'string' ? '""' : type === 'bool' ? 'false' : '0';
+  if (type === 'number') return String(v);
+  if (type === 'bool') return v === true || v === 'true' ? 'true' : 'false';
+  return strLit(v);
+}
+
+export function toolOnPath(cmd, args = ['--version']) {
+  try {
+    const r = spawnSync(cmd, args, { encoding: 'utf8', timeout: 15000 });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}

package/src/testing.mjs

@@ -42,7 +42,7 @@ export function runTests(ast) {
         const inputs = coerce(c.given);
         const run = evaluateDecision(dec, inputs);
         const pass = c.expect == null || String(run.result) === String(c.expect);
-        results.push({ ...label, kind: 'decision', expected: c.expect, actual: run.result, pass, ...(run.ok ? {} : { note: 'a condition failed to evaluate' }) });
+        results.push({ ...label, kind: 'decision', expected: c.expect, actual: run.result, matched: run.matched, pass, ...(run.ok ? {} : { note: 'a condition failed to evaluate' }) });
       } else if (lc) {
         const sim = simulateLifecycle(lc, c.events || []);
         const passState = c.expect == null || sim.finalState === c.expect;