@harmoniclabs/pebble-cli 0.1.0-dev2 → 0.1.1-dev0

package/dist/compile/compilePebbleProject.d.ts

@@ -1,3 +1,2 @@
 import { CliCompileOptions } from "./completeCompileOptions.js";
 export declare function compilePebbleProject(opts: CliCompileOptions): Promise<void>;
-export default compilePebbleProject;

package/dist/compile/compilePebbleProject.js

@@ -1,61 +1,7 @@
 import * as path from "node:path";
 import * as fsp from "node:fs/promises";
-import { existsSync } from "node:fs";
 import { Compiler } from "@harmoniclabs/pebble";
-function resolvePath(filename, baseDir) {
-    if (!filename)
-        return baseDir;
-    if (path.isAbsolute(filename))
-        return filename;
-    return path.resolve(baseDir, filename.replace(/^\/+/, ""));
-}
-function createFsIo(root) {
-    const stdout = process.stdout;
-    const stderr = process.stderr;
-    return {
-        stdout,
-        stderr,
-        async readFile(filename, baseDir) {
-            const full = resolvePath(filename, typeof baseDir === "string" ? baseDir : root);
-            try {
-                const buf = await fsp.readFile(full);
-                return buf.toString("utf8");
-            }
-            catch {
-                return undefined;
-            }
-        },
-        async writeFile(filename, contents, baseDir) {
-            const full = resolvePath(filename, baseDir || root);
-            await fsp.mkdir(path.dirname(full), { recursive: true });
-            if (typeof contents === "string") {
-                await fsp.writeFile(full, contents, "utf8");
-            }
-            else {
-                await fsp.writeFile(full, Buffer.from(contents));
-            }
-        },
-        exsistSync(filename) {
-            const full = resolvePath(filename, root);
-            const exsists = existsSync(full);
-            console.log("checking exists:", full, filename, exsists);
-            return existsSync(full);
-        },
-        async listFiles(dirname, baseDir) {
-            const full = resolvePath(dirname, baseDir || root);
-            try {
-                const entries = await fsp.readdir(full, { withFileTypes: true });
-                return entries.map(e => e.name);
-            }
-            catch {
-                return undefined;
-            }
-        },
-        reportDiagnostic(d) {
-            stderr.write(String(d) + "\n");
-        }
-    };
-}
+import { createFsIo } from "../utils/crateFsIo.js";
 export async function compilePebbleProject(opts) {
     const { root, entry, outDir, output, config } = opts;
     const io = createFsIo(root);
@@ -73,4 +19,3 @@ export async function compilePebbleProject(opts) {
         await fsp.copyFile(generated, target);
     }
 }
-export default compilePebbleProject;

package/dist/compile/completeCompileOptions.d.ts

@@ -12,8 +12,4 @@ export interface CliCompileOptions {
     config: CompilerOptions;
     configPath?: string;
 }
-export declare function normalizeRoot(root?: string): string;
-export declare function isRecord(x: any): x is Record<string, unknown>;
-export declare function fromJsonMaybeBoolean<T>(value: any, fallback: T): T;
 export declare function completeCompileOptions(flags: CliCompileFlags): CliCompileOptions;
-export default completeCompileOptions;

package/dist/compile/completeCompileOptions.js

@@ -1,28 +1,23 @@
-import { defaultOptions } from "@harmoniclabs/pebble";
+import { productionOptions } from "@harmoniclabs/pebble";
 import { existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
-export function normalizeRoot(root) {
-    const r = root && root.trim().length > 0 ? root : process.cwd();
-    return path.resolve(r);
-}
-export function isRecord(x) {
-    return typeof x === "object" && x !== null && !Array.isArray(x);
-}
-export function fromJsonMaybeBoolean(value, fallback) {
-    return (typeof value === typeof fallback ? value : fallback);
-}
+import { normalizeRoot, isRecord } from "../utils/miscellaneous.js";
 export function completeCompileOptions(flags) {
     const root = normalizeRoot();
     const configPath = path.resolve(root, flags.config ?? "./pebble.config.json");
-    let config = defaultOptions;
+    let config = productionOptions;
     if (existsSync(configPath)) {
         try {
             const txt = readFileSync(configPath, "utf8");
             const parsed = JSON.parse(txt);
             if (isRecord(parsed))
                 config = {
-                    ...defaultOptions,
+                    ...productionOptions,
                     ...parsed,
+                    uplcOptimizations: {
+                        ...productionOptions.uplcOptimizations,
+                        ...parsed.uplcOptimizations
+                    }
                 };
         }
         catch {
@@ -47,4 +42,3 @@ export function completeCompileOptions(flags) {
         configPath: existsSync(configPath) ? configPath : undefined,
     };
 }
-export default completeCompileOptions;

package/dist/export/completeExportOptions.d.ts

@@ -0,0 +1,17 @@
+import { CompilerOptions } from "@harmoniclabs/pebble";
+export interface CliExportFlags {
+    config?: string;
+    entry?: string;
+    output?: string;
+    functionName?: string;
+}
+export interface CliExportOptions {
+    root: string;
+    entry: string;
+    functionName: string;
+    outDir: string;
+    output?: string;
+    config: CompilerOptions;
+    configPath?: string;
+}
+export declare function completeExportOptions(flags: CliExportFlags): CliExportOptions;

package/dist/export/completeExportOptions.js

@@ -0,0 +1,48 @@
+import { productionOptions } from "@harmoniclabs/pebble";
+import * as path from "node:path";
+import { normalizeRoot, isRecord } from "../utils/miscellaneous.js";
+import { existsSync, readFileSync } from "node:fs";
+export function completeExportOptions(flags) {
+    const root = normalizeRoot();
+    if (typeof flags.functionName !== "string")
+        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");
+    let config = productionOptions;
+    if (existsSync(configPath)) {
+        try {
+            const txt = readFileSync(configPath, "utf8");
+            const parsed = JSON.parse(txt);
+            if (isRecord(parsed))
+                config = {
+                    ...productionOptions,
+                    ...parsed,
+                    uplcOptimizations: {
+                        ...productionOptions.uplcOptimizations,
+                        ...parsed.uplcOptimizations
+                    }
+                };
+        }
+        catch {
+            // ignore malformed config; proceed with flags/defaults
+        }
+    }
+    const cfgEntry = typeof config?.entry === "string" ? String(config.entry) : undefined;
+    const entry = (flags.entry ?? (cfgEntry ?? "./src/index.pebble")).trim();
+    const desiredOutput = flags.output;
+    const cfgOutDir = typeof config?.outDir === "string" ? String(config.outDir) : undefined;
+    let outDir = cfgOutDir ?? (desiredOutput ? path.dirname(desiredOutput) : "./out");
+    if (desiredOutput === "./out.flat") {
+        // keep sane default when user didn't set anything explicitly
+        outDir = cfgOutDir ?? "./out";
+    }
+    return {
+        root,
+        entry,
+        functionName,
+        outDir,
+        output: desiredOutput,
+        config,
+        configPath: existsSync(configPath) ? configPath : undefined,
+    };
+}

package/dist/export/exportPebbleFunction.d.ts

@@ -0,0 +1,2 @@
+import { CliExportOptions } from "./completeExportOptions.js";
+export declare function exportPebbleFunction(opts: CliExportOptions): Promise<void>;

package/dist/export/exportPebbleFunction.js

@@ -0,0 +1,22 @@
+import * as path from "node:path";
+import * as fsp from "node:fs/promises";
+import { Compiler } from "@harmoniclabs/pebble";
+import { createFsIo } from "../utils/crateFsIo.js";
+export async function exportPebbleFunction(opts) {
+    const { root, entry, functionName, outDir, output, config } = opts;
+    const io = createFsIo(root);
+    const compiler = new Compiler(io, config);
+    // Mirror test behavior: pass overrides via compile()
+    await compiler.export({
+        functionName,
+        root,
+        entry,
+        outDir
+    });
+    if (output && output !== "./out.flat") {
+        const generated = path.resolve(root, outDir, "out.flat");
+        const target = path.isAbsolute(output) ? output : path.resolve(root, output);
+        await fsp.mkdir(path.dirname(target), { recursive: true });
+        await fsp.copyFile(generated, target);
+    }
+}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env node --max-old-space-size=8192
+#!/bin/sh
 export {};

package/dist/index.js

@@ -1,9 +1,13 @@
-#!/usr/bin/env node --max-old-space-size=8192
+#!/bin/sh
+':'; //# ; command -v bun >/dev/null 2>&1 && exec bun "$0" "$@" || exec node "$0" "$@"
 import { Command } from "commander";
 import { PEBBLE_VERSION, PEBBLE_LIB_VERSION, PEBBLE_COMMIT_HASH } from "./version.generated.js";
 import { initPebbleProject } from "./init/initPebbleProject.js";
 import { compilePebbleProject } from "./compile/compilePebbleProject.js";
 import { completeCompileOptions } from "./compile/completeCompileOptions.js";
+import { completeExportOptions } from "./export/completeExportOptions.js";
+import { exportPebbleFunction } from "./export/exportPebbleFunction.js";
+import { prettyPrintUplcFromFile } from "./uplc/pretty/prettyPrintUplcFromFile.js";
 const program = new Command();
 const versionOutput = (`pebble-cli version:      ${PEBBLE_VERSION}
 pebble language version: ${PEBBLE_LIB_VERSION}
@@ -38,6 +42,31 @@ program.command("compile")
     .action(async (opts) => {
     await compilePebbleProject(completeCompileOptions(opts));
 });
+program.command("export")
+    .description("Compiles and exports a single function from a pebble project")
+    .option("--function-name <string>", "The name of the function to export")
+    .option("-c, --config <string>", "The config file path", "./pebble.config.json")
+    .option("--entry <string>", "The entry file path .pebble file (will overwrite if present in the configuration)")
+    .option("-o, --output <string>", "The output file path (will overwrite if present in the configuration)")
+    .action(async (opts) => {
+    await exportPebbleFunction(completeExportOptions(opts));
+});
+const uplcSubcommand = program.command("uplc")
+    .description("Utilities for UPLC programs stored in flat-encoded files");
+uplcSubcommand.command("pretty")
+    .description("Pretty prints a UPLC program from a flat UPLC file")
+    .option("-i, --input <string>", "The input flat-encoded UPLC file path", "./out/out.flat")
+    .option("-o, --output <string>", "The output file path (extension: .uplc) (if missing, prints to console)")
+    .action(prettyPrintUplcFromFile);
+/*
+TODO:
+
+uplcSubcommand.command("apply")
+    .description("Applies arguments to a UPLC program from a flat-encoded UPLC file")
+
+uplcSubcommand.command("eval")
+    .description("Evaluates a UPLC program from a flat-encoded UPLC file")
+*/
 program.command("init")
     .description("Creates a new directory with a fresh pebble project")
     .action(initPebbleProject);

package/dist/init/initPebbleProject.js

@@ -162,9 +162,8 @@ ${includeOffchain ? "- `offchain/`: optional offchain scaffolding\n" : ""}
     await writeFile(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n");
     // src/index.pebble template
     const indexPebblePath = path.join(srcDir, "index.pebble");
-    const indexPebble = (`
-// if no methods are defined
-// a simple always failing contract is generated
+    const indexPebble = (`// if no methods are defined
+// the contract is interpreted as always failing
 contract MyContract {
 
     param owner: PubKeyHash;
@@ -172,7 +171,7 @@ contract MyContract {
     spend ownerAllowsIt() {
         const { tx } = context;
 
-        assert tx.signatories.includes( this.owner );
+        assert tx.requiredSigners.includes( this.owner );
     }
 
     spend sendToOwner( amount: int ) {
@@ -182,7 +181,7 @@ contract MyContract {
 
         const output = tx.outputs[0];
 
-        assert output.address.credential.hash() == this.owner;
+        assert output.address.payment.hash() == this.owner;
         assert output.value.lovelaces() >= amount;
     }
 

package/dist/uplc/pretty/prettyPrintUplcFromFile.d.ts

@@ -0,0 +1,5 @@
+export interface CliPrettyUplcFlags {
+    input: string;
+    output?: string;
+}
+export declare function prettyPrintUplcFromFile(opts: CliPrettyUplcFlags): Promise<void>;

package/dist/uplc/pretty/prettyPrintUplcFromFile.js

@@ -0,0 +1,17 @@
+import * as path from "node:path";
+import * as fsp from "node:fs/promises";
+import { parseUPLC, prettyUPLC } from "@harmoniclabs/uplc";
+export async function prettyPrintUplcFromFile(opts) {
+    const { input, output } = opts;
+    const inputPath = path.resolve(input.trim());
+    const uplcBytes = await fsp.readFile(inputPath);
+    const uplcProgram = parseUPLC(uplcBytes, "flat");
+    const result = "(program " + uplcProgram.version.toString() + "\n"
+        + prettyUPLC(uplcProgram.body, 2) + "\n)";
+    if (!output) {
+        console.log(result);
+        return;
+    }
+    const outputPath = path.resolve(output.trim());
+    await fsp.writeFile(outputPath, result);
+}

package/dist/utils/crateFsIo.d.ts

@@ -0,0 +1,2 @@
+import { CompilerIoApi } from "@harmoniclabs/pebble";
+export declare function createFsIo(root: string): CompilerIoApi;

package/dist/utils/crateFsIo.js

@@ -0,0 +1,57 @@
+import path from "node:path";
+import * as fsp from "node:fs/promises";
+import { existsSync } from "node:fs";
+function resolvePath(filename, baseDir) {
+    if (!filename)
+        return baseDir;
+    if (path.isAbsolute(filename))
+        return filename;
+    return path.resolve(baseDir, filename.replace(/^\/+/, ""));
+}
+export function createFsIo(root) {
+    const stdout = process.stdout;
+    const stderr = process.stderr;
+    return {
+        stdout,
+        stderr,
+        async readFile(filename, baseDir) {
+            const full = resolvePath(filename, typeof baseDir === "string" ? baseDir : root);
+            try {
+                const buf = await fsp.readFile(full);
+                return buf.toString("utf8");
+            }
+            catch {
+                return undefined;
+            }
+        },
+        async writeFile(filename, contents, baseDir) {
+            const full = resolvePath(filename, baseDir || root);
+            await fsp.mkdir(path.dirname(full), { recursive: true });
+            if (typeof contents === "string") {
+                await fsp.writeFile(full, contents, "utf8");
+            }
+            else {
+                await fsp.writeFile(full, Buffer.from(contents));
+            }
+        },
+        exsistSync(filename) {
+            const full = resolvePath(filename, root);
+            const exsists = existsSync(full);
+            // console.log("checking exists:", full, filename, exsists );
+            return existsSync(full);
+        },
+        async listFiles(dirname, baseDir) {
+            const full = resolvePath(dirname, baseDir || root);
+            try {
+                const entries = await fsp.readdir(full, { withFileTypes: true });
+                return entries.map(e => e.name);
+            }
+            catch {
+                return undefined;
+            }
+        },
+        reportDiagnostic(d) {
+            stderr.write(String(d) + "\n");
+        }
+    };
+}

package/dist/utils/miscellaneous.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeRoot(root?: string): string;
+export declare function isRecord(x: any): x is Record<string, unknown>;
+export declare function fromJsonMaybeBoolean<T>(value: any, fallback: T): T;

package/dist/utils/miscellaneous.js

@@ -0,0 +1,11 @@
+import * as path from "node:path";
+export function normalizeRoot(root) {
+    const r = root && root.trim().length > 0 ? root : process.cwd();
+    return path.resolve(r);
+}
+export function isRecord(x) {
+    return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+export function fromJsonMaybeBoolean(value, fallback) {
+    return (typeof value === typeof fallback ? value : fallback);
+}

package/dist/version.generated.d.ts

@@ -1,3 +1,3 @@
-export declare const PEBBLE_VERSION = "0.1.0-dev2";
-export declare const PEBBLE_LIB_VERSION = "0.1.0-dev7";
-export declare const PEBBLE_COMMIT_HASH = "df91965e1d3ebf2eeb0cda4c4a71ac5688197e2e";
+export declare const PEBBLE_VERSION = "0.1.1-dev0";
+export declare const PEBBLE_LIB_VERSION = "0.1.1";
+export declare const PEBBLE_COMMIT_HASH = "61b900fbd67de7283a60e45c9a98516fa4660d53";

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.0-dev2";
-export const PEBBLE_LIB_VERSION = "0.1.0-dev7";
-export const PEBBLE_COMMIT_HASH = "df91965e1d3ebf2eeb0cda4c4a71ac5688197e2e";
+export const PEBBLE_VERSION = "0.1.1-dev0";
+export const PEBBLE_LIB_VERSION = "0.1.1";
+export const PEBBLE_COMMIT_HASH = "61b900fbd67de7283a60e45c9a98516fa4660d53";

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@harmoniclabs/pebble-cli",
-  "version": "0.1.0-dev2",
+  "version": "0.1.1-dev0",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
-  "bin": "./dist/index.js",
+  "bin": {
+    "pebble": "./dist/index.js",
+    "pebble-cli": "./dist/index.js"
+  },
   "types": "./dist/index.d.ts",
   "engines": {
     "node": ">=22",
@@ -15,8 +18,10 @@
   "scripts": {
     "buidl": "npm run build",
     "build": "rm -rf ./dist && npm run build:light",
+    "test": "jest",
     "genVersions": "node ./scripts/genVersions.js",
     "build:light": "npm run --silent genVersions && tsc --project ./tsconfig.json && tsc-alias -p ./tsconfig.json",
+    "build:no-gen": "tsc --project ./tsconfig.json && tsc-alias -p ./tsconfig.json",
     "start:light": "node --max-old-space-size=8192 ./dist/index.js",
     "start": "npm run build && npm run start:light",
     "build-exe": "bun run genVersions && bun build src/index.ts --compile --production --target=node --outfile=out/pebble --packages=bundle"
@@ -45,13 +50,13 @@
   "dependencies": {
     "@harmoniclabs/crypto": "^0.3.0",
     "@harmoniclabs/obj-utils": "^1.0.0",
-    "@harmoniclabs/pebble": "^0.1.0-dev7",
+    "@harmoniclabs/pebble": "^0.1.1",
     "@harmoniclabs/plutus-machine": "^2.1.1",
     "@harmoniclabs/uint8array-utils": "^1.0.4",
     "@harmoniclabs/uplc": "^1.4.0",
-    "@inquirer/prompts": "^7.8.4",
-    "chalk": "^5.6.0",
-    "commander": "^14.0.0"
+    "@inquirer/prompts": "^7.9.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2"
   },
   "devDependencies": {
     "@types/jest": "^28.1.4",