@harmoniclabs/pebble-cli 0.1.0-dev1

package/dist/compile/compilePebbleProject.d.ts

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

package/dist/compile/compilePebbleProject.js

@@ -0,0 +1,76 @@
+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");
+        }
+    };
+}
+export async function compilePebbleProject(opts) {
+    const { root, entry, outDir, output, config } = opts;
+    const io = createFsIo(root);
+    const compiler = new Compiler(io, config);
+    // Mirror test behavior: pass overrides via compile()
+    await compiler.compile({
+        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);
+    }
+}
+export default compilePebbleProject;

package/dist/compile/completeCompileOptions.d.ts

@@ -0,0 +1,19 @@
+import { CompilerOptions } from "@harmoniclabs/pebble";
+export interface CliCompileFlags {
+    config?: string;
+    entry?: string;
+    output?: string;
+}
+export interface CliCompileOptions {
+    root: string;
+    entry: string;
+    outDir: string;
+    output?: string;
+    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

@@ -0,0 +1,50 @@
+import { defaultOptions } 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);
+}
+export function completeCompileOptions(flags) {
+    const root = normalizeRoot();
+    const configPath = path.resolve(root, flags.config ?? "./pebble.config.json");
+    let config = defaultOptions;
+    if (existsSync(configPath)) {
+        try {
+            const txt = readFileSync(configPath, "utf8");
+            const parsed = JSON.parse(txt);
+            if (isRecord(parsed))
+                config = {
+                    ...defaultOptions,
+                    ...parsed,
+                };
+        }
+        catch {
+            // ignore malformed config; proceed with flags/defaults
+        }
+    }
+    const cfgEntry = typeof config?.entry === "string" ? String(config.entry) : undefined;
+    const entry = cfgEntry ?? (flags.entry ?? "./src/index.pebble");
+    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,
+        outDir,
+        output: desiredOutput,
+        config,
+        configPath: existsSync(configPath) ? configPath : undefined,
+    };
+}
+export default completeCompileOptions;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node --max-old-space-size=8192
+import { Command } from "commander";
+import { PEBBLE_VERSION, PEBBLE_LIB_VERSION } from "./version.generated.js";
+import { initPebbleProject } from "./init/initPebbleProject.js";
+import { compilePebbleProject } from "./compile/compilePebbleProject.js";
+import { completeCompileOptions } from "./compile/completeCompileOptions.js";
+const program = new Command();
+const versionOutput = (`pebble-cli version:      ${PEBBLE_VERSION}
+pebble language version: ${PEBBLE_LIB_VERSION}`);
+program
+    .name("pebble")
+    .description("A simple, yet rock solid, functional language with an imperative bias, targeting UPLC")
+    .option("-v, --version", "show version number")
+    .action((opts) => {
+    if (opts.version) {
+        console.log(versionOutput);
+        process.exit(0);
+    }
+    program.help();
+});
+program.command("help")
+    .description("Display help for pebble commands")
+    .action(() => {
+    program.help();
+});
+program.command("version")
+    .description("Output the version number")
+    .action(() => {
+    console.log(versionOutput);
+    process.exit(0);
+});
+program.command("compile")
+    .description("Compiles a pebble project")
+    .option("-c, --config <string>", "The config file path", "./pebble.config.json")
+    .option("--entry <string>", "The entry file path .pebble file (used only if missing in the configuration)", "./index.pebble")
+    .option("-o, --output <string>", "The output file path (used only if missing in the configuration)", "./out.flat")
+    .action(async (opts) => {
+    await compilePebbleProject(completeCompileOptions(opts));
+});
+program.command("init")
+    .description("Creates a new directory with a fresh pebble project")
+    .action(initPebbleProject);
+/*
+// TODO
+defineVersionManager( program );
+
+program.command("repl");
+//*/
+program.parse();

package/dist/init/initPebbleProject.d.ts

@@ -0,0 +1 @@
+export declare function initPebbleProject(): Promise<void>;

package/dist/init/initPebbleProject.js

@@ -0,0 +1,236 @@
+/// @ts-ignore Cannot find module '@inquirer/prompts' or its corresponding type declarations.
+import { input, confirm, select, Separator } from "@inquirer/prompts";
+import chalk from "chalk";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+export async function initPebbleProject() {
+    const projectName = await input({
+        required: true,
+        message: "What is the name of your project?",
+        default: "my-pebble-project",
+    });
+    let offchain = undefined;
+    const includeOffchain = await confirm({
+        message: "Do you want to include offchain code using buildooor?",
+        default: false
+    });
+    if (includeOffchain) {
+        const network = await select({
+            message: "Which network would you like to target?",
+            default: "preprod",
+            choices: [
+                {
+                    name: "mainnet",
+                    value: "mainnet",
+                    description: "Cardano mainnet (transactions cost real ADA)."
+                },
+                {
+                    name: "preprod",
+                    value: "preprod",
+                    description: "pre-production testnet, closest to mainnet."
+                },
+                {
+                    name: "preview",
+                    value: "preview",
+                    description: "preview testnet, for quick prototyping."
+                },
+            ]
+        });
+        const provider = await select({
+            message: "Which provider would you like to use?",
+            default: "blockfrost",
+            choices: [
+                {
+                    name: "Blockfrost",
+                    value: "blockfrost",
+                    description: "Blockfrost is a popular Cardano API provider."
+                },
+                {
+                    name: "Koios",
+                    value: "koios",
+                    description: "Koios is a community-driven Cardano API provider."
+                },
+                {
+                    name: "Kupo + Ogmios (Kupmios)",
+                    value: "kupmios",
+                    description: "Use Kupo + Ogmios to index the chain yourself.",
+                },
+                new Separator(),
+                {
+                    name: "Local node",
+                    value: "local-node",
+                    description: "Connect to a local node using a unix socket.",
+                    disabled: "(coming soon)"
+                },
+                {
+                    name: "UTxO RPC",
+                    value: "utxo-rpc",
+                    description: "Connect to a UTxO RPC server.",
+                    disabled: "(coming soon)"
+                },
+                {
+                    name: "Maestro",
+                    value: "maestro",
+                    description: "Maestro is a managed Cardano API provider.",
+                    disabled: "(coming soon)"
+                }
+            ]
+        });
+        offchain = { network: network, provider: provider };
+    }
+    // paths
+    const projectRoot = path.resolve(process.cwd(), projectName);
+    const srcDir = path.join(projectRoot, "src");
+    const offchainDir = path.join(projectRoot, "offchain");
+    // check existing directory state
+    let shouldProceed = true;
+    if (existsSync(projectRoot)) {
+        let shouldProceed = false;
+        try {
+            const entries = await fs.readdir(projectRoot);
+            if (entries.length > 0) {
+                shouldProceed = await confirm({
+                    message: `Directory "${projectName}" already exists and is not empty. Continue and overwrite conflicting files?`,
+                    default: false
+                });
+            }
+        }
+        catch { /* ignore */ }
+    }
+    if (!shouldProceed) {
+        console.log(chalk.yellow("Aborted. No files were created."));
+        return;
+    }
+    // ensure directories
+    await fs.mkdir(srcDir, { recursive: true });
+    if (includeOffchain) {
+        await fs.mkdir(offchainDir, { recursive: true });
+    }
+    // write helpers
+    async function writeFile(filePath, content) {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, content, { encoding: "utf8" });
+    }
+    // .gitignore
+    const gitignorePath = path.join(projectRoot, ".gitignore");
+    const gitignore = [
+        "node_modules/",
+        "dist/",
+        "out/",
+        ".env",
+        ".DS_Store"
+    ].join("\n");
+    await writeFile(gitignorePath, gitignore + "\n");
+    // README
+    const readmePath = path.join(projectRoot, "README.md");
+    const readme = `# ${projectName}
+
+This is a starter project for a Pebble smart contract.
+
+Getting started:
+
+- Edit your contract in \`src/index.pebble\`.
+- Compile using the Pebble CLI (once \`pebble compile\` is implemented) or your tooling.
+
+Structure:
+
+- \`src/index.pebble\`: entry script
+- \`pebble.config.json\`: compiler options
+${includeOffchain ? "- `offchain/`: optional offchain scaffolding\n" : ""}
+`;
+    await writeFile(readmePath, readme);
+    // pebble config
+    const configPath = path.join(projectRoot, "pebble.config.json");
+    const pebbleConfig = {
+        entry: "./src/index.pebble",
+        outDir: "./out",
+        removeTraces: true,
+    };
+    await writeFile(configPath, JSON.stringify(pebbleConfig, null, 2) + "\n");
+    // package.json (optional helper scripts)
+    const pkgPath = path.join(projectRoot, "package.json");
+    const pkgJson = {
+        name: projectName,
+        private: true,
+        type: "module",
+        scripts: {
+            // placeholders until compile subcommand is wired
+            "compile": "pebble compile --config ./pebble.config.json"
+        }
+    };
+    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
+contract MyContract {
+
+    param owner: PubKeyHash;
+
+    spend ownerAllowsIt() {
+        const { tx } = context;
+
+        assert tx.signatories.includes( this.owner );
+    }
+
+    spend sendToOwner( amount: int ) {
+        const { tx } = context;
+
+        assert tx.outputs.length() === 1;
+
+        const output = tx.outputs[0];
+
+        assert output.address.credential.hash() == this.owner;
+        assert output.value.lovelaces() >= amount;
+    }
+
+    // mint mintOrBurnTokens() {}
+    
+    // cert validateCertificateSubmission() {}
+
+    // withdraw getStakingRewards() {}
+
+    // vote voteOnProposal() {}
+
+    // propose proposeGovernanceAction () {}
+}`);
+    await writeFile(indexPebblePath, indexPebble);
+    // optional offchain scaffolding
+    if (includeOffchain && offchain) {
+        const offchainReadme = `# Offchain
+
+This folder is intended for offchain code (e.g., using Buildooor).
+
+Selected network: ${offchain.network}
+Selected provider: ${offchain.provider}
+
+Configure environment by copying \`.env.example\` to \`.env\` and filling values.
+`;
+        await writeFile(path.join(offchainDir, "README.md"), offchainReadme);
+        const envLines = [];
+        envLines.push(`# Environment variables for ${offchain.provider} on ${offchain.network}`);
+        if (offchain.provider === "blockfrost") {
+            envLines.push(`BLOCKFROST_API_KEY="your_blockfrost_api_key"`);
+        }
+        else if (offchain.provider === "koios") {
+            envLines.push("KOIOS_URL=https://api.koios.rest/api/v1/");
+        }
+        else if (offchain.provider === "kupmios") {
+            envLines.push("OGMIOS_URL=ws://localhost:1337");
+            envLines.push("KUPO_URL=http://localhost:1442");
+        }
+        await writeFile(path.join(projectRoot, ".env"), envLines.join("\n") + "\n");
+    }
+    console.log();
+    console.log(chalk.green("Pebble project initialized!"));
+    console.log(chalk.gray(projectRoot));
+    console.log();
+    console.log(chalk.green("Next steps:"));
+    console.log(`  1. cd ${chalk.cyan(projectName)}`);
+    console.log("  2. Open src/index.pebble and start coding.");
+    if (includeOffchain) {
+        console.log("  3. Fill values for your provider in the .env file.");
+    }
+}

package/dist/version-manager/defineVersionManager.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function defineVersionManager(program: Command): void;

package/dist/version-manager/defineVersionManager.js

@@ -0,0 +1,33 @@
+export function defineVersionManager(program) {
+    const version_manager = program.command("version-manager");
+    version_manager.command("list")
+        .description("List available pebble versions")
+        .action(async () => {
+        console.log("Not implemented yet");
+        process.exit(0);
+    });
+    version_manager.command("install <version>")
+        .description("Install a specific version of pebble")
+        .action(async (version) => {
+        console.log("Not implemented yet");
+        process.exit(0);
+    });
+    version_manager.command("use <version>")
+        .description("Install and use a specific version of pebble")
+        .action(async (version) => {
+        console.log("Not implemented yet");
+        process.exit(0);
+    });
+    version_manager.command("remove-all")
+        .description("Remove all installed pebble versions")
+        .action(async () => {
+        console.log("Not implemented yet");
+        process.exit(0);
+    });
+    version_manager.command("select")
+        .description("Select a pebble version between the already installed ones")
+        .action(async () => {
+        console.log("Not implemented yet");
+        process.exit(0);
+    });
+}

package/dist/version.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const PEBBLE_VERSION = "0.1.0-dev1";
+export declare const PEBBLE_LIB_VERSION = "0.1.0-dev6";

package/dist/version.generated.js

@@ -0,0 +1,3 @@
+// This file is auto-generated by scripts/genVersions.js. Do not edit.
+export const PEBBLE_VERSION = "0.1.0-dev1";
+export const PEBBLE_LIB_VERSION = "0.1.0-dev6";

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@harmoniclabs/pebble-cli",
+  "version": "0.1.0-dev1",
+  "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
+  "bin": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "engines": {
+    "node": ">=22",
+    "bun": ">=1.2.0"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "buidl": "npm run build",
+    "build": "rm -rf ./dist && npm run build:light",
+    "genVersions": "node ./scripts/genVersions.js",
+    "build:light": "npm run --silent genVersions && 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"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "keywords": [
+    "cardano",
+    "plutus",
+    "smart contracts",
+    "transaction",
+    "blockchain",
+    "dApp"
+  ],
+  "author": "Michele Nuzzi",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HarmonicLabs/pebble.git"
+  },
+  "bugs": {
+    "url": "https://github.com/HarmonicLabs/pebble/issues"
+  },
+  "homepage": "https://github.com/HarmonicLabs/pebble#readme",
+  "dependencies": {
+    "@harmoniclabs/crypto": "^0.3.0",
+    "@harmoniclabs/obj-utils": "^1.0.0",
+    "@harmoniclabs/pebble": "^0.1.0-dev6",
+    "@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"
+  },
+  "devDependencies": {
+    "@types/jest": "^28.1.4",
+    "@types/node": "^18.14.6",
+    "tsc-alias": "^1.7.1",
+    "typescript": "^4.6.3"
+  },
+  "funding": "https://github.com/sponsors/HarmonicLabs"
+}