@harmoniclabs/pebble-cli 0.1.10 → 0.3.0

package/dist/compile/completeCompileOptions.js

@@ -5,6 +5,8 @@ import { normalizeRoot, isRecord } from "../utils/miscellaneous.js";
 export function completeCompileOptions(flags) {
     const root = normalizeRoot();
     const configPath = path.resolve(root, flags.config ?? "./pebble.config.json");
+    // compilerVersion is intentionally not set here — it must come from the
+    // user's pebble.config.json. If missing/invalid, the Compiler throws.
     let config = productionOptions;
     if (existsSync(configPath)) {
         try {

package/dist/export/completeExportOptions.js

@@ -8,6 +8,8 @@ export function completeExportOptions(flags) {
         throw new Error("exported function name must be provided via '--function-name <name>' flag");
     const functionName = flags.functionName.trim();
     const configPath = path.resolve(root, flags.config ?? "./pebble.config.json");
+    // compilerVersion is intentionally not set here — it must come from the
+    // user's pebble.config.json. If missing/invalid, the Compiler throws.
     let config = productionOptions;
     if (existsSync(configPath)) {
         try {

package/dist/index.js

@@ -8,6 +8,7 @@ import { completeExportOptions } from "./export/completeExportOptions.js";
 import { exportPebbleFunction } from "./export/exportPebbleFunction.js";
 import { prettyPrintUplcFromFile } from "./uplc/pretty/prettyPrintUplcFromFile.js";
 import { pebbleRepl } from "./repl/pebbleRepl.js";
+import { runTestsCommand } from "./test/runTestsCommand.js";
 const program = new Command();
 const versionOutput = (`pebble-cli version:      ${PEBBLE_VERSION}
 pebble language version: ${PEBBLE_LIB_VERSION}
@@ -78,4 +79,20 @@ defineVersionManager( program );
 program.command("repl")
     .description("Start an interactive Pebble REPL")
     .action(pebbleRepl);
+program.command("test [path]")
+    .description("Discover and run `test name() { ... }` blocks under [path] (default: current directory). Reports execution costs (cpu/mem) for each test. Property tests (params present) sample N iterations.")
+    .option("-c, --config <string>", "The config file path", "./pebble.config.json")
+    .option("--testPathPattern <regex>", "Run tests only in files whose path matches this regex")
+    .option("-t, --testNamePattern <regex>", "Run only tests whose name matches this regex")
+    .option("--property-runs <n>", "Number of iterations per property test (default 100)")
+    .option("--seed <int>", "Seed for the property-test PRNG (default 0)")
+    .action(async (target, opts) => {
+    await runTestsCommand(target, {
+        config: opts.config,
+        testPathPattern: opts.testPathPattern,
+        testNamePattern: opts.testNamePattern,
+        propertyRuns: opts.propertyRuns,
+        seed: opts.seed,
+    });
+});
 program.parse();

package/dist/init/initPebbleProject.js

@@ -150,6 +150,7 @@ ${includeOffchain ? "- `offchain/`: optional offchain scaffolding\n" : ""}
     // pebble config
     const configPath = path.join(projectRoot, "pebble.config.json");
     const pebbleConfig = {
+        compilerVersion: "^0.2.0",
         entry: "./src/index.pebble",
         outDir: "./out",
         removeTraces: true,

package/dist/repl/pebbleRepl.js

@@ -1,7 +1,7 @@
 import * as readline from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import chalk from "chalk";
-import { Compiler, createMemoryCompilerIoApi, defaultOptions, fromUtf8, toHex, ConstTyTag, constTypeToStirng, } from "@harmoniclabs/pebble";
+import { Compiler, COMPILER_VERSION, createMemoryCompilerIoApi, defaultOptions, fromUtf8, toHex, ConstTyTag, constTypeToStirng, } from "@harmoniclabs/pebble";
 function formatCEKValue(val) {
     if (val.tag === 5 /* CEKValueTag.Error */) {
         return chalk.red("error") + (val.msg ? `: ${val.msg}` : "");
@@ -264,6 +264,7 @@ export async function pebbleRepl() {
         });
         const compiler = new Compiler(ioApi, {
             ...defaultOptions,
+            compilerVersion: COMPILER_VERSION,
             silent: true,
         });
         try {

package/dist/test/discoverTestFiles.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Discover `.pebble` files to feed into `Compiler.test()`.
+ *
+ * @param target  Either a directory to walk recursively, or a single `.pebble`
+ *                file path. If omitted, walks `cwd`.
+ * @param testPathPattern  Optional regex filter over workspace-relative paths.
+ * @returns absolute paths of matching `.pebble` files.
+ */
+export declare function discoverTestFiles(target: string | undefined, testPathPattern: RegExp | undefined, cwd?: string): Promise<string[]>;

package/dist/test/discoverTestFiles.js

@@ -0,0 +1,47 @@
+import * as path from "node:path";
+import * as fsp from "node:fs/promises";
+import { existsSync, statSync } from "node:fs";
+/**
+ * Discover `.pebble` files to feed into `Compiler.test()`.
+ *
+ * @param target  Either a directory to walk recursively, or a single `.pebble`
+ *                file path. If omitted, walks `cwd`.
+ * @param testPathPattern  Optional regex filter over workspace-relative paths.
+ * @returns absolute paths of matching `.pebble` files.
+ */
+export async function discoverTestFiles(target, testPathPattern, cwd = process.cwd()) {
+    const resolved = path.resolve(cwd, target ?? ".");
+    if (!existsSync(resolved))
+        return [];
+    const stat = statSync(resolved);
+    const files = [];
+    if (stat.isFile()) {
+        if (resolved.endsWith(".pebble"))
+            files.push(resolved);
+    }
+    else if (stat.isDirectory()) {
+        await _walk(resolved, files);
+    }
+    if (testPathPattern) {
+        return files.filter(f => testPathPattern.test(path.relative(cwd, f)));
+    }
+    return files;
+}
+async function _walk(dir, out) {
+    let entries;
+    try {
+        entries = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (e.name === "node_modules" || e.name.startsWith("."))
+            continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory())
+            await _walk(full, out);
+        else if (e.isFile() && e.name.endsWith(".pebble"))
+            out.push(full);
+    }
+}

package/dist/test/formatTestResults.d.ts

@@ -0,0 +1,11 @@
+import { TestResult } from "@harmoniclabs/pebble";
+export interface FormattedSummary {
+    totalTests: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+}
+export declare function formatTestResults(resultsByFile: Map<string, TestResult[]>, cwd?: string): {
+    text: string;
+    summary: FormattedSummary;
+};

package/dist/test/formatTestResults.js

@@ -0,0 +1,79 @@
+import * as path from "node:path";
+export function formatTestResults(resultsByFile, cwd = process.cwd()) {
+    const lines = [];
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let total = 0;
+    const files = Array.from(resultsByFile.keys()).sort();
+    for (const file of files) {
+        const rel = path.relative(cwd, file);
+        const results = resultsByFile.get(file);
+        lines.push("");
+        lines.push(rel);
+        for (const r of results) {
+            total++;
+            if (r.skippedReason) {
+                skipped++;
+                lines.push(`  SKIP  ${r.name}  (${r.skippedReason})`);
+                continue;
+            }
+            const tag = r.passed ? "PASS" : "FAIL";
+            if (r.passed)
+                passed++;
+            else
+                failed++;
+            const cpu = r.totalBudget.cpu.toString();
+            const mem = r.totalBudget.mem.toString();
+            if (r.kind === "property") {
+                const ran = r.iterations.length;
+                const seedStr = `seed=${r.seed ?? 0}`;
+                if (r.passed) {
+                    lines.push(`  ${tag}  ${r.name}  (${ran} iterations, ${seedStr}, total cpu=${cpu}, mem=${mem})`);
+                }
+                else {
+                    const failedIter = r.iterations[r.iterations.length - 1];
+                    lines.push(`  ${tag}  ${r.name}  (failed at iteration ${ran}, ${seedStr})`);
+                    if (failedIter?.inputs && failedIter.inputs.length > 0) {
+                        const inp = failedIter.inputs
+                            .map(i => `${i.name}=${_renderValue(i.value)}`)
+                            .join(", ");
+                        lines.push(`        inputs: ${inp}`);
+                    }
+                    if (failedIter?.error?.msg)
+                        lines.push(`        error:  ${failedIter.error.msg}`);
+                    if (failedIter?.logs && failedIter.logs.length > 0) {
+                        for (const log of failedIter.logs)
+                            lines.push(`        trace:  ${log}`);
+                    }
+                }
+                continue;
+            }
+            // unit test rendering
+            lines.push(`  ${tag}  ${r.name}  [cpu: ${cpu}, mem: ${mem}]`);
+            for (const it of r.iterations) {
+                if (it.logs.length > 0) {
+                    for (const log of it.logs)
+                        lines.push(`        trace: ${log}`);
+                }
+                if (it.error?.msg)
+                    lines.push(`        error: ${it.error.msg}`);
+            }
+        }
+    }
+    lines.push("");
+    lines.push(`Tests: ${passed} passed, ${failed} failed, ${skipped} skipped, ${total} total`);
+    return {
+        text: lines.join("\n"),
+        summary: { totalTests: total, passed, failed, skipped }
+    };
+}
+function _renderValue(v) {
+    if (typeof v === "bigint")
+        return v.toString();
+    if (typeof v === "boolean")
+        return v ? "true" : "false";
+    if (v instanceof Uint8Array)
+        return "#" + Array.from(v).map(b => b.toString(16).padStart(2, "0")).join("");
+    return String(v);
+}

package/dist/test/runTestsCommand.d.ts

@@ -0,0 +1,8 @@
+export interface CliTestFlags {
+    config?: string;
+    testPathPattern?: string;
+    testNamePattern?: string;
+    propertyRuns?: string;
+    seed?: string;
+}
+export declare function runTestsCommand(target: string | undefined, flags: CliTestFlags): Promise<void>;

package/dist/test/runTestsCommand.js

@@ -0,0 +1,69 @@
+import * as path from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { Compiler, productionOptions } from "@harmoniclabs/pebble";
+import { createFsIo } from "../utils/crateFsIo.js";
+import { normalizeRoot, isRecord } from "../utils/miscellaneous.js";
+import { discoverTestFiles } from "./discoverTestFiles.js";
+import { formatTestResults } from "./formatTestResults.js";
+export async function runTestsCommand(target, flags) {
+    const root = normalizeRoot();
+    // load pebble.config.json if present, otherwise use defaults
+    const configPath = path.resolve(root, flags.config ?? "./pebble.config.json");
+    // compilerVersion is intentionally not set here — it must come from the
+    // user's pebble.config.json. If missing/invalid, the Compiler throws.
+    let baseConfig = productionOptions;
+    if (existsSync(configPath)) {
+        try {
+            const txt = readFileSync(configPath, "utf8");
+            const parsed = JSON.parse(txt);
+            if (isRecord(parsed))
+                baseConfig = {
+                    ...productionOptions,
+                    ...parsed,
+                    uplcOptimizations: {
+                        ...productionOptions.uplcOptimizations,
+                        ...parsed.uplcOptimizations
+                    }
+                };
+        }
+        catch {
+            // ignore malformed config
+        }
+    }
+    const testPathPattern = flags.testPathPattern ? new RegExp(flags.testPathPattern) : undefined;
+    const nameFilter = flags.testNamePattern ? new RegExp(flags.testNamePattern) : undefined;
+    const propertyIterations = flags.propertyRuns !== undefined ? Math.max(1, Number(flags.propertyRuns) | 0) : undefined;
+    const seed = flags.seed !== undefined ? (Number(flags.seed) | 0) : undefined;
+    const files = await discoverTestFiles(target, testPathPattern, root);
+    if (files.length === 0) {
+        process.stdout.write("no .pebble test files found\n");
+        return;
+    }
+    const io = createFsIo(root);
+    const resultsByFile = new Map();
+    for (const file of files) {
+        const compiler = new Compiler(io, {
+            ...baseConfig,
+            root,
+            entry: file,
+            silent: true,
+        });
+        try {
+            const results = await compiler.test({
+                nameFilter,
+                propertyIterations,
+                seed,
+            });
+            if (results.length > 0)
+                resultsByFile.set(file, results);
+        }
+        catch (err) {
+            process.stderr.write(`error running tests in ${path.relative(root, file)}: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exitCode = 1;
+        }
+    }
+    const { text, summary } = formatTestResults(resultsByFile, root);
+    process.stdout.write(text + "\n");
+    if (summary.failed > 0)
+        process.exitCode = 1;
+}

package/dist/version.generated.d.ts

@@ -1,3 +1,3 @@
-export declare const PEBBLE_VERSION = "0.1.10";
-export declare const PEBBLE_LIB_VERSION = "0.1.10";
-export declare const PEBBLE_COMMIT_HASH = "cd5e87c474bea32a9437f9ee81adc0dcca786d0d";
+export declare const PEBBLE_VERSION = "0.3.0";
+export declare const PEBBLE_LIB_VERSION = "0.3.0";
+export declare const PEBBLE_COMMIT_HASH = "a7fcaead80e58be72b0c18c877c668a7d630b57c";

package/dist/version.generated.js

@@ -1,4 +1,4 @@
 // This file is auto-generated by scripts/genVersions.js. Do not edit.
-export const PEBBLE_VERSION = "0.1.10";
-export const PEBBLE_LIB_VERSION = "0.1.10";
-export const PEBBLE_COMMIT_HASH = "cd5e87c474bea32a9437f9ee81adc0dcca786d0d";
+export const PEBBLE_VERSION = "0.3.0";
+export const PEBBLE_LIB_VERSION = "0.3.0";
+export const PEBBLE_COMMIT_HASH = "a7fcaead80e58be72b0c18c877c668a7d630b57c";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble-cli",
-  "version": "0.1.10",
+  "version": "0.3.0",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "bin": {
     "pebble": "./dist/index.js",
@@ -51,7 +51,7 @@
   "dependencies": {
     "@harmoniclabs/crypto": "^0.3.0",
     "@harmoniclabs/obj-utils": "^1.0.0",
-    "@harmoniclabs/pebble": "0.1.10",
+    "@harmoniclabs/pebble": "0.3.0",
     "@harmoniclabs/plutus-machine": "^3.0.0",
     "@harmoniclabs/uint8array-utils": "^1.0.4",
     "@harmoniclabs/uplc": "^2.0.5",