@skillstech/thunderlang 0.2.0 → 0.4.1

package/CHANGELOG.md

@@ -3,6 +3,45 @@
 All notable changes to `@skillstech/thunderlang`. Pre-1.0: the language and the
 `intent-graph-v1` schema version independently and may still change.
 
+## 0.4.1
+
+The coherence release. Additive; no breaking changes. Version chosen to align with OpenThunder
+(TL and OT version in lockstep; OT is moving from 0.4.0 to match).
+
+- **Python code generation.** `thunder gen <file> --target python` now emits a typed Python 3
+  scaffold, aligning the codegen axis with live execution. Also fixes a real gap: C# and Java `gen`
+  silently dropped `requires` preconditions that TypeScript emitted; they are now emitted as guided
+  TODOs.
+- **Language support matrix.** New `docs/language-support-matrix.md` documents the three axes , lift
+  (14 languages), gen, and live target execution (4) , and makes them discoverable.
+- **VS Code extension.** `editors/vscode/` ships a real extension: syntax highlighting and a Language
+  Server client that launches `thunder lsp`. Packageable with `vsce package`.
+- **Grouped, scannable CLI help.** `thunder --help` is reorganized into nine labeled groups with a
+  one-line mental model. Command behavior is unchanged (help text only); a test guards that no
+  command was dropped.
+- **Verify-real-code loop, productized.** New MCP tools `intent_prove`, `intent_conform`, and
+  `intent_drift` let AI agents drive the full loop. `docs/verifying-ai-changes.md` is rewritten as
+  the headline workflow (author intent, write code, prove conformance, gate the merge) with a CI
+  recipe.
+- **Honest Playwright scaffolds.** The exported Playwright tests now open with `test.fixme` so an
+  unfilled scaffold cannot pass vacuously.
+- **intent-graph-v1 stability policy.** New `docs/schema-stability.md` commits to additive-only type
+  sets within v1, an IR version that moves independently of the package, a deprecation policy, and a
+  road to 1.0, so consumers like OpenThunder can depend on the IR safely.
+
+## 0.3.0
+
+The 14-language lift release. Additive; no breaking changes. Restores the OpenThunder -> ThunderLang
+recover-intent loop for every language OpenThunder's archgraph core can now discover.
+
+- **Kotlin, Scala, and Elixir lift adapters.** `thunder lift` now extracts candidate intent from
+  `.kt`/`.kts`, `.scala`/`.sc`, and `.ex`/`.exs`, bringing the supported-language count to 14. A new
+  `name: Type` parameter parser handles the JVM signature shape; Elixir joins the dynamic-language set.
+- **Fix: repo-walk language coverage.** `LIFT_EXTS` was stale and silently skipped Python, Java, C#,
+  Go, C++, PHP, and Ruby during repo/`--all` lifts; it now mirrors the full adapter set.
+- **Fix: single-file lift language detection.** `thunder lift <file>` now auto-detects the language by
+  extension instead of defaulting to TypeScript, consistent with `--all`/repo modes.
+
 ## 0.2.0
 
 The cross-language target execution release. Additive; no breaking changes.

package/dist/core.cjs

@@ -161,6 +161,7 @@ __export(core_exports, {
   toDesignTokens: () => toDesignTokens,
   toFinding: () => toFinding,
   toJava: () => toJava,
+  toPython: () => toPython,
   toTypeScript: () => toTypeScript,
   twelveFactorReport: () => twelveFactorReport,
   twelveFactorSummary: () => twelveFactorSummary,
@@ -3336,6 +3337,7 @@ function exprToCode(src, { inputs = [], dialect = "js" } = {}) {
 var exprToJs = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "js" });
 var exprToCSharp = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "csharp" });
 var exprToJava = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "java" });
+var exprToPython = (src, opts = {}) => exprToCode(src, { ...opts, dialect: "python" });
 
 // src/runtime.mjs
 var RUNTIME_SCHEMA = "intent-runtime-v1";
@@ -4288,7 +4290,7 @@ function notesSummary(ast) {
     byLens
   };
 }
-var COMPILER_VERSION = "0.2.0";
+var COMPILER_VERSION = "0.4.1";
 var PROOF_SCHEMA_VERSION = "0.1.0";
 var SOURCE_PRODUCT = "skillstech-compiler";
 function buildContractGraph(ast, generatedAt) {
@@ -5378,6 +5380,112 @@ function extractFactsRuby(source, file = "input.rb") {
   }
   return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: "ruby", sourceRoot: file, functions, tests, errors };
 }
+function parseNameColonTypeParams(raw) {
+  return splitTopLevel(raw, ",").map((p) => p.trim()).filter(Boolean).map((p) => {
+    const cleaned = p.replace(/@\w+(\([^)]*\))?/g, "").replace(/^(?:val|var|vararg|implicit|final|lazy)\s+/, "").replace(/=.*$/, "").trim();
+    const mm = cleaned.match(/^([A-Za-z_]\w*)\s*:\s*(.+)$/);
+    if (mm) return { name: mm[1], type: mm[2].trim() };
+    return { name: cleaned.replace(/[^\w].*$/, "") || cleaned, type: null };
+  });
+}
+function extractFactsKotlin(source, file = "input.kt") {
+  let m;
+  const functions = [];
+  const tests = [];
+  const seen = /* @__PURE__ */ new Set();
+  const testMethods = /* @__PURE__ */ new Set();
+  const ta = /@Test\b[\s\S]{0,120}?\bfun\s+(?:`([^`]+)`|(\w+))\s*\(/g;
+  while (m = ta.exec(source)) testMethods.add(m[1] || m[2]);
+  const fnRe = /\bfun\s+(?:<[^>]*>\s*)?(?:[A-Za-z_][\w.]*\.)?(?:`([^`]+)`|([A-Za-z_]\w*))\s*\(([^)]*)\)\s*(?::\s*([^{=\n]+))?/g;
+  while (m = fnRe.exec(source)) {
+    const name = m[1] || m[2];
+    if (testMethods.has(name)) {
+      if (!tests.some((t) => t.name === name)) tests.push({ name, file, line: lineOf(source, m.index) });
+      continue;
+    }
+    if (seen.has(name)) continue;
+    seen.add(name);
+    functions.push({ name, file, line: lineOf(source, m.index), parameters: parseNameColonTypeParams(m[3] || ""), returnType: m[4] ? m[4].trim() : null, evidence: [{ kind: "fun", file, line: lineOf(source, m.index) }] });
+  }
+  const errors = [];
+  const addErr = addErrOf(errors, /* @__PURE__ */ new Set(), { _src: source, _file: file });
+  let mm;
+  const ce = /class\s+(\w*(?:Exception|Error))\b/g;
+  while (mm = ce.exec(source)) addErr(mm[1], mm.index);
+  const th = /throw\s+(\w+)\s*\(/g;
+  while (mm = th.exec(source)) addErr(mm[1], mm.index);
+  return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: "kotlin", sourceRoot: file, functions, tests, errors };
+}
+function extractFactsScala(source, file = "input.scala") {
+  let m;
+  const functions = [];
+  const tests = [];
+  const seen = /* @__PURE__ */ new Set();
+  const fnRe = /\bdef\s+([A-Za-z_]\w*)\s*(?:\[[^\]]*\])?\s*\(([^)]*)\)\s*(?::\s*([^={\n]+))?/g;
+  while (m = fnRe.exec(source)) {
+    const name = m[1];
+    if (seen.has(name)) continue;
+    seen.add(name);
+    functions.push({ name, file, line: lineOf(source, m.index), parameters: parseNameColonTypeParams(m[2] || ""), returnType: m[3] ? m[3].trim() : null, evidence: [{ kind: "def", file, line: lineOf(source, m.index) }] });
+  }
+  const seenT = /* @__PURE__ */ new Set();
+  const addTest = (n, idx) => {
+    const k = String(n).toLowerCase();
+    if (n && !seenT.has(k)) {
+      seenT.add(k);
+      tests.push({ name: n, file, line: lineOf(source, idx) });
+    }
+  };
+  const tr = /\btest\s*\(\s*"([^"]+)"/g;
+  while (m = tr.exec(source)) addTest(m[1], m.index);
+  const inRe = /"([^"]+)"\s+(?:in|should|must)\b/g;
+  while (m = inRe.exec(source)) addTest(m[1], m.index);
+  const errors = [];
+  const addErr = addErrOf(errors, /* @__PURE__ */ new Set(), { _src: source, _file: file });
+  let mm;
+  const ce = /class\s+(\w*(?:Exception|Error))\b/g;
+  while (mm = ce.exec(source)) addErr(mm[1], mm.index);
+  const th = /throw\s+new\s+(\w+)\s*\(/g;
+  while (mm = th.exec(source)) addErr(mm[1], mm.index);
+  return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: "scala", sourceRoot: file, functions, tests, errors };
+}
+function extractFactsElixir(source, file = "input.ex") {
+  let m;
+  const functions = [];
+  const tests = [];
+  const seen = /* @__PURE__ */ new Set();
+  const seenT = /* @__PURE__ */ new Set();
+  const addTest = (n, idx) => {
+    const k = String(n).toLowerCase();
+    if (n && !seenT.has(k)) {
+      seenT.add(k);
+      tests.push({ name: n, file, line: lineOf(source, idx) });
+    }
+  };
+  const tr = /\btest\s+"([^"]+)"/g;
+  while (m = tr.exec(source)) addTest(m[1], m.index);
+  const fnRe = /^[ \t]*defp?\s+([a-z_]\w*[!?]?)\s*(?:\(([^)]*)\))?/gm;
+  while (m = fnRe.exec(source)) {
+    const name = m[1];
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const parameters = splitTopLevel(m[2] || "", ",").map((p) => p.trim()).filter(Boolean).map((p) => ({ name: p.split(/\\\\/)[0].trim().replace(/^%\{?/, "").replace(/[^\w].*$/, "") || p, type: null }));
+    functions.push({ name, file, line: lineOf(source, m.index), indent: (m[0].match(/^[ \t]*/) || [""])[0].length, parameters, returnType: null, evidence: [{ kind: "def", file, line: lineOf(source, m.index) }] });
+  }
+  const errors = [];
+  const seenErr = /* @__PURE__ */ new Set();
+  const addErr = (n, idx) => {
+    if (n && !seenErr.has(n)) {
+      seenErr.add(n);
+      errors.push({ name: n, file, line: lineOf(source, idx) });
+    }
+  };
+  const modErr = /defmodule\s+([\w.]*(?:Error|Exception))\b/g;
+  while (m = modErr.exec(source)) addErr(m[1].split(".").pop(), m.index);
+  const raiseRe = /raise\s+([A-Z][\w.]*)/g;
+  while (m = raiseRe.exec(source)) addErr(m[1].split(".").pop(), m.index);
+  return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: "elixir", sourceRoot: file, functions, tests, errors };
+}
 var ADAPTERS = {
   typescript: extractFactsTypeScript,
   ts: extractFactsTypeScript,
@@ -5401,10 +5509,18 @@ var ADAPTERS = {
   cc: extractFactsCpp,
   php: extractFactsPhp,
   ruby: extractFactsRuby,
-  rb: extractFactsRuby
+  rb: extractFactsRuby,
+  kotlin: extractFactsKotlin,
+  kt: extractFactsKotlin,
+  kts: extractFactsKotlin,
+  scala: extractFactsScala,
+  sc: extractFactsScala,
+  elixir: extractFactsElixir,
+  ex: extractFactsElixir,
+  exs: extractFactsElixir
 };
-var SUPPORTED_LANGUAGES = ["typescript", "javascript", "python", "java", "csharp", "go", "rust", "cpp", "php", "ruby", "perl"];
-var DYNAMIC_LANGUAGES = /* @__PURE__ */ new Set(["perl", "javascript", "python", "ruby", "php"]);
+var SUPPORTED_LANGUAGES = ["typescript", "javascript", "python", "java", "csharp", "go", "rust", "cpp", "php", "ruby", "perl", "kotlin", "scala", "elixir"];
+var DYNAMIC_LANGUAGES = /* @__PURE__ */ new Set(["perl", "javascript", "python", "ruby", "php", "elixir"]);
 var LANG_DISPLAY = {
   typescript: "TypeScript",
   javascript: "JavaScript",
@@ -5416,7 +5532,10 @@ var LANG_DISPLAY = {
   cpp: "C++",
   php: "PHP",
   ruby: "Ruby",
-  perl: "Perl"
+  perl: "Perl",
+  kotlin: "Kotlin",
+  scala: "Scala",
+  elixir: "Elixir"
 };
 function unwrapReturn(ret) {
   if (!ret) return { output: null, error: null };
@@ -5540,6 +5659,9 @@ function languageForFile(file) {
   if (/\.(cpp|cc|cxx|hpp|hh|c|h)$/i.test(file)) return "cpp";
   if (/\.php$/i.test(file)) return "php";
   if (/\.rb$/i.test(file)) return "ruby";
+  if (/\.kts?$/i.test(file)) return "kotlin";
+  if (/\.(scala|sc)$/i.test(file)) return "scala";
+  if (/\.exs?$/i.test(file)) return "elixir";
   if (/\.(mjs|cjs|jsx?)$/i.test(file)) return "javascript";
   return "typescript";
 }
@@ -5547,7 +5669,7 @@ function isPublicFn(fn, language) {
   const name = fn.name || "";
   if (/(?:Internal|Impl|_impl|_helper|_test|Helper)$/.test(name)) return false;
   if (language === "go" || language === "golang") return /^[A-Z]/.test(name) && name !== "Test";
-  if (language === "python" || language === "ruby") return !name.startsWith("_") && (fn.indent == null || fn.indent <= 4);
+  if (language === "python" || language === "ruby" || language === "elixir") return !name.startsWith("_") && (fn.indent == null || fn.indent <= 4);
   return !name.startsWith("_") && name !== "init" && name !== "constructor";
 }
 function liftAll(source, { language = "typescript", file = "", publicOnly = true } = {}) {
@@ -5622,7 +5744,10 @@ var LANG_EXT = {
   cpp: "cpp",
   php: "php",
   ruby: "rb",
-  perl: "pl"
+  perl: "pl",
+  kotlin: "kt",
+  scala: "scala",
+  elixir: "ex"
 };
 function liftSource(source, { language = "typescript", file = "", seeds = void 0 } = {}) {
   const key = String(language).toLowerCase();
@@ -6548,7 +6673,7 @@ function toCSharp(ast) {
       try {
         cond = exprToCSharp(r.when, { inputs });
       } catch {
-        cond = `false /* TODO: "${r.when}" */`;
+        cond = `false /* TODO: could not translate "${r.when}" */`;
       }
       L.push(`    if (${cond}) return ${JSON.stringify(r.result)}; // rule ${r.name}`);
     }
@@ -6557,6 +6682,7 @@ function toCSharp(ast) {
   const inName = (ast.inputs || []).length ? `${subject}Input` : null;
   const outName = (ast.outputs || []).length ? `${subject}Output` : "void";
   L.push(`  public static ${outName} Run(${inName ? `${inName} input` : ""})`, "  {");
+  for (const r of ast.requires || []) L.push(`    // precondition: ${r}  , TODO: validate`);
   for (const n of ast.neverRules || []) L.push(`    // NEVER: ${n.statement}`);
   for (const g of ast.guarantees || []) L.push(`    // GUARANTEE: ${g.statement}`);
   L.push('    throw new NotImplementedException("TODO: implement , the intent above defines what this must do.");', "  }");
@@ -6617,7 +6743,7 @@ function toJava(ast) {
       try {
         cond = exprToJava(r.when, { inputs });
       } catch {
-        cond = `false /* TODO: "${r.when}" */`;
+        cond = `false /* TODO: could not translate "${r.when}" */`;
       }
       L.push(`    if (${cond}) return ${JSON.stringify(r.result)}; // rule ${r.name}`);
     }
@@ -6626,18 +6752,98 @@ function toJava(ast) {
   const inName = (ast.inputs || []).length ? `${subject}Input` : null;
   const outName = (ast.outputs || []).length ? `${subject}Output` : "void";
   L.push(`  public static ${outName} run(${inName ? `${inName} input` : ""}) {`);
+  for (const r of ast.requires || []) L.push(`    // precondition: ${r}  , TODO: validate`);
   for (const n of ast.neverRules || []) L.push(`    // NEVER: ${n.statement}`);
   for (const g of ast.guarantees || []) L.push(`    // GUARANTEE: ${g.statement}`);
   L.push('    throw new UnsupportedOperationException("TODO: implement , the intent above defines what this must do.");', "  }");
   L.push("}", "");
   return L.join("\n");
 }
+var PY_TYPES = {
+  Email: "str",
+  Url: "str",
+  UserId: "str",
+  AccountId: "str",
+  OrderId: "str",
+  InvoiceId: "str",
+  CustomerId: "str",
+  Secret: "str",
+  Token: "str",
+  Jwt: "str",
+  IdempotencyKey: "str",
+  Currency: "str",
+  Date: "str",
+  DateTime: "str",
+  Money: "float",
+  Percentage: "float",
+  Count: "int",
+  Duration: "int",
+  Flag: "bool"
+};
+function pyType(type, domain) {
+  if (!type) return "object";
+  const list = /^List<(.+)>$/.exec(type);
+  if (list) return `list[${pyType(list[1], domain)}]`;
+  const base = type.replace(/\(.*\)/, "");
+  if (PY_TYPES[base]) return PY_TYPES[base];
+  domain.add(base);
+  return base;
+}
+var snake = (s) => pascal2(s).replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+function toPython(ast) {
+  const subject = pascal2(subjectName(ast) || "Intent");
+  const domain = /* @__PURE__ */ new Set();
+  const L = [
+    `# ${subject} , generated from ThunderLang (intent-codegen-v1). Deterministic, no AI.`,
+    "# The dataclass contract and the decision logic are fully determined by the intent;",
+    "# business logic marked TODO is yours, bound by the guarantees and never-rules below.",
+    ""
+  ];
+  const hasData = (ast.inputs || []).length || (ast.outputs || []).length;
+  if (hasData) L.push("from __future__ import annotations", "from dataclasses import dataclass", "");
+  const cls = (name, fields) => fields.length ? ["@dataclass", `class ${name}:`, ...fields.map((f) => `    ${f.name}: ${pyType(f.type, domain)}`), ""] : [];
+  if ((ast.inputs || []).length) L.push(...cls(`${subject}Input`, ast.inputs));
+  if ((ast.outputs || []).length) L.push(...cls(`${subject}Output`, ast.outputs));
+  for (const d of ast.decisions || []) {
+    const inputs = d.inputs || [];
+    L.push(`# decision ${d.name} , first matching rule wins.`);
+    L.push(`def ${snake(d.name)}(${inputs.join(", ")}) -> str:`);
+    for (const r of d.rules || []) {
+      let cond, note = "";
+      try {
+        cond = exprToPython(r.when, { inputs });
+      } catch {
+        cond = "False";
+        note = `  # TODO: could not translate "${r.when}"`;
+      }
+      L.push(`    if ${cond}:${note}`);
+      L.push(`        return ${JSON.stringify(r.result)}  # rule ${r.name}`);
+    }
+    L.push(`    return ${JSON.stringify(d.default ?? "Undecided")}  # default`, "");
+  }
+  const inName = (ast.inputs || []).length ? `${subject}Input` : null;
+  const outName = (ast.outputs || []).length ? `${subject}Output` : "None";
+  L.push(`def run(${inName ? `input: ${inName}` : ""}) -> ${outName}:`);
+  for (const r of ast.requires || []) L.push(`    # precondition: ${r}  , TODO: validate`);
+  for (const n of ast.neverRules || []) L.push(`    # NEVER: ${n.statement}`);
+  for (const g of ast.guarantees || []) L.push(`    # GUARANTEE: ${g.statement}`);
+  L.push('    raise NotImplementedError("TODO: implement , the intent above defines what this must do.")', "");
+  const stubs = [...domain].filter((t) => !PY_TYPES[t] && /^[A-Z]/.test(t)).sort();
+  if (stubs.length) {
+    L.push("# Domain types referenced by the intent , complete these.");
+    for (const t of stubs) L.push(`class ${t}: pass  # TODO: fields`);
+    L.push("");
+  }
+  return L.join("\n");
+}
 var GENERATORS = {
   typescript: toTypeScript,
   ts: toTypeScript,
   csharp: toCSharp,
   cs: toCSharp,
-  java: toJava
+  java: toJava,
+  python: toPython,
+  py: toPython
 };
 
 // src/changes.mjs
@@ -6854,6 +7060,7 @@ function changeReport(pairs) {
   toDesignTokens,
   toFinding,
   toJava,
+  toPython,
   toTypeScript,
   twelveFactorReport,
   twelveFactorSummary,