@skillstech/thunderlang 0.2.0 → 0.4.1

package/dist/index.cjs

@@ -294,6 +294,7 @@ __export(index_exports, {
   toMermaid: () => toMermaid,
   toOpenAPI: () => toOpenAPI,
   toPlaywright: () => toPlaywright,
+  toPython: () => toPython,
   toSMV: () => toSMV,
   toSarif: () => toSarif,
   toTypeScript: () => toTypeScript,
@@ -2287,7 +2288,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) {
@@ -3753,6 +3754,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,
@@ -3776,10 +3883,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",
@@ -3791,7 +3906,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 };
@@ -3915,6 +4033,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";
 }
@@ -3922,7 +4043,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 } = {}) {
@@ -3997,7 +4118,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();
@@ -5024,7 +5148,9 @@ function toPlaywright(ast) {
   const exps = ast.experiences || [];
   const L = [];
   L.push("// Playwright test scaffold generated from experience intent by @skillstech/thunderlang.");
-  L.push("// SKELETON: fill in selectors and assertions. It is not a passing test until you do.");
+  L.push("// SKELETON: fill in selectors and assertions. Every test starts with a test.fixme");
+  L.push('// guard so an unimplemented scaffold reports "fixme" instead of passing vacuously;');
+  L.push("// remove the guard from each test once its body is real.");
   L.push("import { test, expect } from '@playwright/test';");
   L.push("");
   if (!exps.length) {
@@ -5039,6 +5165,7 @@ function toPlaywright(ast) {
     }
     for (const j of exp.journeys || []) {
       L.push(`  test(${jsStr(j.name || "journey")}, async ({ page }) => {`);
+      L.push(`    test.fixme(true, ${jsStr("scaffold: implement the steps, then remove this guard")});`);
       if (!(j.steps || []).length) L.push("    // TODO: no steps declared for this journey");
       for (const step of j.steps || []) {
         L.push(`    await test.step(${jsStr(step)}, async () => {`);
@@ -5050,10 +5177,12 @@ function toPlaywright(ast) {
     for (const st of exp.states || []) {
       if (st.hasRecovery) {
         L.push(`  test(${jsStr(`failure state "${st.name}" offers a recovery path`)}, async ({ page }) => {`);
+        L.push(`    test.fixme(true, ${jsStr("scaffold: implement this state check, then remove this guard")});`);
         L.push(`    // TODO: drive the UI into "${st.name}", assert a recovery action is available`);
         L.push("  });");
       } else {
         L.push(`  test(${jsStr(`reaches state: ${st.name}`)}, async ({ page }) => {`);
+        L.push(`    test.fixme(true, ${jsStr("scaffold: implement this state check, then remove this guard")});`);
         L.push(`    // TODO: drive the UI to "${st.name}" and assert it is shown`);
         L.push("  });");
       }
@@ -6228,6 +6357,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";
@@ -7725,7 +7855,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}`);
     }
@@ -7734,6 +7864,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.");', "  }");
@@ -7794,7 +7925,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}`);
     }
@@ -7803,18 +7934,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
@@ -8404,6 +8615,54 @@ function verifyDiff(intentText, { before = null, after, language = "typescript"
   };
 }
 
+// src/mcp.mjs
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+
+// src/conformance.mjs
+function buildConformance(ast, { targets = [], results = null } = {}) {
+  const sem = runTests(ast);
+  const cases = (sem.results || []).map((r) => ({
+    key: `${r.target} / ${r.case}`,
+    test: r.target,
+    case: r.case,
+    inputs: r.inputs || {},
+    expected: r.expected,
+    semantic: r.actual,
+    semanticPass: !!r.pass
+  }));
+  const columns = (targets.length ? targets : ast.targets || []).map((t) => String(t).toLowerCase());
+  const rows = cases.map((c) => {
+    const t = {};
+    for (const col of columns) {
+      const tr = results && results[col];
+      if (!tr || !(c.key in tr)) {
+        t[col] = { status: "declared" };
+        continue;
+      }
+      const actual = tr[c.key];
+      t[col] = { status: String(actual) === String(c.expected) ? "pass" : "fail", actual };
+    }
+    return { ...c, targets: t };
+  });
+  const failures = [];
+  for (const row of rows) for (const col of columns) {
+    const tr = row.targets[col];
+    if (tr.status === "fail") failures.push({ target: col, case: row.key, expected: row.expected, actual: tr.actual });
+  }
+  return {
+    schema: "thunder-conformance-v1",
+    mission: ast.mission,
+    total: cases.length,
+    columns,
+    semanticFailures: cases.filter((c) => !c.semanticPass).length,
+    graded: !!results,
+    failures,
+    cases: rows
+  };
+}
+
 // src/draft.mjs
 var DRAFT_SCHEMA = "intent-draft-v1";
 var SECRET_TYPES2 = /* @__PURE__ */ new Set(["secret", "password", "passwd", "jwt", "token", "apikey", "api_key", "privatekey", "private_key", "credential", "cvv"]);
@@ -8495,6 +8754,75 @@ function draftIntent(brief = {}) {
 // src/mcp.mjs
 var PROTOCOL_VERSION = "2024-11-05";
 var str = { type: "string" };
+function resolveObligations(ast) {
+  const t = runTests(ast);
+  const testPass = /* @__PURE__ */ new Map();
+  for (const res of t.results || []) {
+    const cur = testPass.get(res.target);
+    testPass.set(res.target, cur === void 0 ? !!res.pass : cur && !!res.pass);
+  }
+  const norm4 = (s) => String(s).toLowerCase().replace(/[^a-z0-9]/g, "");
+  const matchTest = (verifyText) => {
+    const v = norm4(verifyText);
+    if (!v) return null;
+    for (const [name, pass] of testPass) {
+      const n = norm4(name);
+      if (n && (n === v || n.includes(v) || v.includes(n))) return { name, pass };
+    }
+    return null;
+  };
+  const build = (kind, o) => {
+    const verify = o.verify || [];
+    let status = "unverified", provenBy = null;
+    if (verify.length) {
+      let m = null;
+      for (const vt of verify) {
+        const x = matchTest(vt);
+        if (x) {
+          m = x;
+          if (!x.pass) break;
+        }
+      }
+      if (m) {
+        status = m.pass ? "verified" : "failed";
+        provenBy = m.name;
+      } else status = "declared";
+    }
+    return { kind, id: o.id, status, provenBy };
+  };
+  const obligations = [...ast.guarantees.map((g) => build("guarantee", g)), ...ast.neverRules.map((n) => build("prohibition", n))];
+  return { obligations, tests: t, failed: obligations.filter((o) => o.status === "failed").length };
+}
+var LOCKFILES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "poetry.lock", "Pipfile.lock", "Cargo.lock", "go.sum", "Gemfile.lock", "composer.lock"];
+function proofFreshness(proof, environment) {
+  let head = null;
+  try {
+    head = (0, import_node_child_process.execSync)("git rev-parse HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim() || null;
+  } catch {
+    head = null;
+  }
+  let lock = null, dir = process.cwd();
+  for (let i = 0; i < 6 && !lock; i++) {
+    for (const lf of LOCKFILES) {
+      const p = (0, import_node_path.join)(dir, lf);
+      if ((0, import_node_fs.existsSync)(p)) {
+        lock = p;
+        break;
+      }
+    }
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return {
+    intentHash: proof.sourceHash,
+    compilerVersion: proof.compilerVersion,
+    implementation: head,
+    dependencies: lock ? { file: (0, import_node_path.basename)(lock), hash: sha256((0, import_node_fs.readFileSync)(lock, "utf8")) } : null,
+    environment: environment || null,
+    generatedAt: proof.generatedAt
+  };
+}
 var TOOLS = [
   {
     name: "intent_check",
@@ -8520,6 +8848,75 @@ var TOOLS = [
     },
     run: ({ intent, after, before = null, language = "typescript" }) => verifyDiff(String(intent), { before: before == null ? null : String(before), after: String(after), language })
   },
+  {
+    name: "intent_prove",
+    description: "Emit the durable intent-proof-v1 artifact for .intent source: per-claim verdicts (verified / failed / planned / needs_verification, each bound to the named test that proves it) plus the freshness tuple (intent hash, compiler version, commit, dependency lockfile) that lets `thunder verify` mark the proof STALE later. Mirrors `thunder prove`; an unverified claim never reads as passed. Call it after the gate passes to record WHAT was proven.",
+    inputSchema: {
+      type: "object",
+      required: ["source"],
+      properties: {
+        source: { ...str, description: "the .intent source" },
+        sourceFile: { ...str, description: "file name to record in the proof (default intent.thunder)" },
+        environment: { ...str, description: "environment name to bind into the freshness tuple (optional)" }
+      }
+    },
+    run: ({ source, sourceFile = "intent.thunder", environment }) => {
+      const text = String(source);
+      const ast = parseIntent(text);
+      const diagnostics = semanticDiagnostics(ast);
+      const resolved = resolveObligations(ast);
+      const proof = buildProof(ast, {
+        sourceFile: String(sourceFile),
+        sourceHash: sha256(text),
+        targetsRequested: ast.targets || [],
+        targetsGenerated: [],
+        diagnostics,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const CLAIM_MAP = { verified: "verified", failed: "failed", declared: "planned", unverified: "needs_verification" };
+      const byId = new Map(resolved.obligations.map((o) => [o.id, o]));
+      const applyStatus = (claim) => {
+        const o = byId.get(claim.id);
+        return o ? { ...claim, status: CLAIM_MAP[o.status], provenBy: o.provenBy || null } : claim;
+      };
+      proof.guarantees = proof.guarantees.map(applyStatus);
+      proof.neverRules = proof.neverRules.map(applyStatus);
+      proof.freshness = proofFreshness(proof, environment);
+      const ok = proof.verification.semanticPassed && resolved.tests.ok !== false && resolved.failed === 0;
+      return { ok, proofId: `proof-${proof.sourceHash.replace("sha256:", "").slice(0, 6)}`, ...proof, tests: resolved.tests };
+    }
+  },
+  {
+    name: "intent_conform",
+    description: 'Grade cross-target conformance (thunder-conformance-v1): the deterministic engine defines the canonical result every in-file test case must produce, and each target\'s outputs (passed via `results`) are graded against it. Same tests, every implementation , a diverging target case is a CONFORMANCE FAILURE. Mirrors `thunder conform`. Without `results`, targets honestly stay "declared", never "pass".',
+    inputSchema: {
+      type: "object",
+      required: ["source"],
+      properties: {
+        source: { ...str, description: "the .intent source (with test blocks)" },
+        targets: { type: "array", items: str, description: "target languages to grade (default: the targets the intent declares)" },
+        results: { type: "object", description: 'per-target actual outputs to grade: {target: {"Test / case": result}}' }
+      }
+    },
+    run: ({ source, targets = [], results = null }) => {
+      const rep = buildConformance(parseIntent(String(source)), { targets: Array.isArray(targets) ? targets.map(String) : [], results });
+      return { ok: rep.semanticFailures === 0 && rep.failures.length === 0, ...rep };
+    }
+  },
+  {
+    name: "intent_drift",
+    description: "Check whether real code, as it exists TODAY, still satisfies its intent , the standing-guard complement to intent_verify_diff (no diff needed). Re-lifts the code and reports drift findings: guarantees with no matching evidence, never-rules with no guard, declared inputs missing from the signature, and new behavior the intent never declared. Mirrors `thunder drift`.",
+    inputSchema: {
+      type: "object",
+      required: ["intent", "code"],
+      properties: {
+        intent: { ...str, description: "the approved .intent source (the contract)" },
+        code: { ...str, description: "the implementation source as it exists now" },
+        language: { ...str, description: `source language (default typescript). One of: ${SUPPORTED_LANGUAGES.join(", ")}` }
+      }
+    },
+    run: ({ intent, code, language = "typescript" }) => checkDrift(String(intent), String(code), { language })
+  },
   {
     name: "intent_draft",
     description: "Turn a STRUCTURED brief into a rigorous, canonically-formatted ThunderLang draft plus a review checklist of what a human must still fill in (unverified guarantees, unguarded secrets, missing goal). Use this after distilling a user request into structured fields; the draft is a proposal for human approval, never verified.",
@@ -9385,6 +9782,7 @@ function startLspServer({ readable = process.stdin, writable = process.stdout }
   toMermaid,
   toOpenAPI,
   toPlaywright,
+  toPython,
   toSMV,
   toSarif,
   toTypeScript,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillstech/thunderlang",
-  "version": "0.2.0",
+  "version": "0.4.1",
   "description": "Deterministic ThunderLang compiler, CLI, and Language Server. No AI required. Turns .thunder files into the canonical Intent Graph, docs, and a proof, and EXECUTES the intent: run decisions, simulate lifecycles, and check outcome contracts. Interops with DMN, BPMN, JSON Schema, and OpenAPI.",
   "type": "module",
   "main": "./src/index.mjs",