lemmascript 0.5.11 → 0.5.12

package/README.md

@@ -45,7 +45,7 @@ See the external case studies:
 **Install from npm:**
 
 ```sh
-npm install lemmascript
+npm install -g lemmascript
 ```
 
 **Or from source:**
@@ -67,17 +67,21 @@ git clone https://github.com/namin/velvet.git -b lemma ../velvet
 ### Dafny backend
 
 ```sh
-npx lsc gen --backend=dafny src/myModule.ts
-npx lsc check --backend=dafny src/myModule.ts
-npx lsc regen --backend=dafny src/myModule.ts
+lsc gen --backend=dafny src/myModule.ts
+lsc check --backend=dafny src/myModule.ts
+lsc regen --backend=dafny src/myModule.ts
 ```
 
+With no file argument, `lsc check` batches over `LemmaScript-files.txt` (one `filepath [timeout] [extra dafny flags…]` per line — the list `tools/check.sh` runs in CI).
+
+From a sibling source checkout, the equivalent of `lsc` is `npx tsx ../LemmaScript/tools/src/lsc.ts` — no build step, toolchain edits apply immediately.
+
 The Dafny backend generates two files per TS source: `foo.dfy.gen` (always regeneratable) and `foo.dfy` (source of truth, with LLM/user proof additions). The diff between them must be additions-only.
 
 ### Lean backend
 
 ```sh
-npx lsc gen --backend=lean src/myModule.ts
+lsc gen --backend=lean src/myModule.ts
 lake build
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemmascript",
-  "version": "0.5.11",
+  "version": "0.5.12",
   "description": "A verification toolchain for TypeScript — generates Lean 4 or Dafny from annotated TS",
   "type": "module",
   "engines": {

package/tools/dist/lsc.js

@@ -5,7 +5,9 @@
  * Pipeline: extract → resolve → narrow → transform → peephole → emit
  */
 import { Project, ScriptTarget } from "ts-morph";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
+import { execFileSync } from "child_process";
+import { createRequire } from "module";
 import path from "path";
 import { extractModule } from "./extract.js";
 import { resolveModule } from "./resolve.js";
@@ -20,20 +22,44 @@ import { leanGen, leanCheck } from "./lean-commands.js";
 import { runInfo } from "./info-command.js";
 function main() {
     const args = process.argv.slice(2);
-    // `lsc claimcheck …` forwards verbatim to the lemmascript-claimcheck CLI
-    // (a dependency; its cli reads the rewritten process.argv).
+    // `lsc claimcheck <file.ts> …` forwards verbatim to the lemmascript-claimcheck
+    // CLI (a dependency; its cli reads the rewritten process.argv). With no
+    // leading <file.ts>, batch: one satellite run per LemmaScript-files.txt entry,
+    // flags passed through unchanged — the loop is owned here, the satellite
+    // stays single-file.
     if (args[0] === "claimcheck") {
-        process.argv = [process.argv[0], "lemmascript-claimcheck", ...args.slice(1)];
-        import("lemmascript-claimcheck/cli").catch((err) => {
-            const code = err?.code;
-            if (code === "ERR_MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
-                console.error("`lsc claimcheck` needs lemmascript-claimcheck >= 0.2.0; reinstall with: npm i -g lemmascript");
-            }
-            else {
+        const rest = args.slice(1);
+        const missing = () => {
+            console.error("`lsc claimcheck` needs lemmascript-claimcheck >= 0.2.0; reinstall with: npm i -g lemmascript");
+            process.exit(1);
+        };
+        if (rest[0] && !rest[0].startsWith("-")) {
+            process.argv = [process.argv[0], "lemmascript-claimcheck", ...rest];
+            import("lemmascript-claimcheck/cli").catch((err) => {
+                const code = err?.code;
+                if (code === "ERR_MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED")
+                    missing();
                 console.error(err instanceof Error ? err.message : String(err));
+                process.exit(1);
+            });
+            return;
+        }
+        let cli;
+        try {
+            cli = createRequire(import.meta.url).resolve("lemmascript-claimcheck/cli");
+        }
+        catch {
+            missing();
+            return;
+        }
+        for (const e of readEntries()) {
+            try {
+                execFileSync(process.execPath, [cli, e.file, ...rest], { stdio: "inherit" });
             }
-            process.exit(1);
-        });
+            catch {
+                process.exit(1);
+            }
+        }
         return;
     }
     const backendIdx = args.findIndex(a => a.startsWith("--backend="));
@@ -59,12 +85,63 @@ function main() {
         extraFlags = args[extraFlagsIdx].split("=").slice(1).join("=");
         args.splice(extraFlagsIdx, 1);
     }
+    // --slow (batch mode only): verify every entry with its own timeout instead
+    // of degrading slow ones to gen-check.
+    let slow = false;
+    const slowIdx = args.indexOf("--slow");
+    if (slowIdx >= 0) {
+        slow = true;
+        args.splice(slowIdx, 1);
+    }
     const [cmd, filePath] = args;
-    if (!cmd || !filePath) {
+    if (!cmd) {
         console.error("Usage: lsc <gen|check|regen|extract|info> [--backend=lean|dafny] <file.ts>");
-        console.error("       lsc claimcheck <file.ts> [flags…]   (forwards to lemmascript-claimcheck)");
+        console.error("       lsc <gen|gen-check|check> [--backend=…] [--slow]   (no file: batch over LemmaScript-files.txt)");
+        console.error("       lsc claimcheck [<file.ts>] [flags…]   (forwards to lemmascript-claimcheck)");
         process.exit(1);
     }
+    if (!filePath) {
+        runBatch(cmd, backend, slow);
+        return;
+    }
+    runFile(cmd, filePath, backend, timeLimit, extraFlags);
+}
+// LemmaScript-files.txt, parsed: `filepath [timeout_in_seconds] [extra dafny
+// flags…]` per line; no timeout = Dafny default. Exits if the file is absent.
+function readEntries() {
+    if (!existsSync("LemmaScript-files.txt")) {
+        console.error("No file given and no LemmaScript-files.txt found.");
+        process.exit(1);
+    }
+    return readFileSync("LemmaScript-files.txt", "utf8")
+        .split("\n").map(s => s.trim()).filter(Boolean)
+        .map(entry => {
+        const [file, second, ...rest] = entry.split(/\s+/);
+        const timeout = second && /^[1-9]\d*$/.test(second) ? parseInt(second) : undefined;
+        const flags = (timeout === undefined ? [second, ...rest] : rest).filter(Boolean).join(" ") || undefined;
+        return { file, timeout, flags };
+    });
+}
+// Batch over LemmaScript-files.txt. `check` entries with a timeout above 60s
+// (the CI limit) are gen-check only, unless --slow. Fail-fast: the first
+// failing entry exits. tools/check.sh drives this from source;
+// installed-package consumers run `lsc check`.
+function runBatch(cmd, backend, slow) {
+    if (cmd !== "gen" && cmd !== "gen-check" && cmd !== "check") {
+        console.error(`No file given, and batch mode supports gen|gen-check|check (not ${cmd}).`);
+        process.exit(1);
+    }
+    for (const e of readEntries()) {
+        if (cmd === "check" && backend === "dafny" && !slow && e.timeout !== undefined && e.timeout > 60) {
+            console.log(`=== ${path.basename(e.file)} (timeout ${e.timeout}s > 60s, gen-check only) ===`);
+            runFile("gen-check", e.file, backend, undefined, undefined);
+        }
+        else {
+            runFile(cmd, e.file, backend, e.timeout, e.flags);
+        }
+    }
+}
+function runFile(cmd, filePath, backend, timeLimit, extraFlags) {
     const absPath = path.resolve(filePath);
     if (!existsSync(absPath)) {
         console.error(`File not found: ${absPath}`);