mobilestacks 0.1.0

package/Clarinet.toml

@@ -0,0 +1,7 @@
+[project]
+name = "mobilestacks"
+requirements = []
+
+[contracts.sample-contract]
+path = "contracts/sample-contract.clar"
+clarity_version = 1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mobilestacks contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,188 @@
+# mobilestacks
+
+A Hardhat-style development framework for Stacks. Write, test, and deploy Clarity smart contracts with a task-based CLI, local Simnet testing, and a pluggable runtime.
+
+## Install
+
+```bash
+npm install mobilestacks
+```
+
+## Quick Start
+
+Scaffold a new project:
+
+```bash
+npx mobilestacks init
+```
+
+This generates a config file, a sample Clarity contract, and an example task.
+
+## Configuration
+
+All config lives in `mobilestacks.config.ts`:
+
+```ts
+export default {
+  networks: {
+    mainnet: { url: "https://stacks-node-api.mainnet.stacks.co", name: "mainnet" },
+    testnet: { url: "https://stacks-node-api.testnet.stacks.co", name: "testnet" },
+  },
+  defaultNetwork: "testnet",
+  wallet: {
+    privateKey: process.env.STACKS_PRIVATE_KEY,
+  },
+};
+```
+
+Secrets can live in `.env` — they override config values automatically.
+
+## CLI
+
+```bash
+npx mobilestacks                    # list all tasks
+npx mobilestacks deploy-contract    # deploy a contract
+npx mobilestacks get-balance        # check STX balance
+npx mobilestacks send-stx           # send STX
+npx mobilestacks faucet-request     # get testnet tokens
+```
+
+Missing params are prompted interactively. Run any task with `--help` for options.
+
+### Built-in Tasks
+
+| Task | What it does |
+| ---- | ------------ |
+| `deploy-contract` | Deploy a `.clar` file to mainnet/testnet |
+| `send-stx` | Transfer STX to an address |
+| `get-balance` | Check STX balance for any address |
+| `faucet-request` | Request testnet STX from the faucet |
+| `list-accounts` | List derived wallet accounts |
+| `get-tx-history` | Fetch recent transactions |
+| `call-contract-function` | Call a read-only contract function |
+| `get-contract-info` | Fetch deployed contract metadata |
+| `verify-contract` | Diff on-chain source against a local file |
+
+## Writing Tasks
+
+Drop a file in `src/tasks/` — it's auto-discovered:
+
+```ts
+import { task } from "mobilestacks";
+import { z } from "zod";
+
+task("greet", "Say hello")
+  .addParam("name", "Who to greet", { schema: z.string().min(1) })
+  .setAction(async (args, env) => {
+    return `Hello, ${args.name}! (network: ${env.config.defaultNetwork})`;
+  });
+```
+
+Subtasks and workflows are also supported:
+
+```ts
+import { subtask, runWorkflow } from "mobilestacks";
+
+// subtask tied to a parent
+subtask("deploy:validate", "Pre-deploy check", "deploy-contract")
+  .setAction(async (args, env) => { /* ... */ });
+
+// run tasks in sequence
+await runWorkflow([
+  { taskName: "deploy-contract", args: { /* ... */ } },
+  { taskName: "verify-contract", args: { /* ... */ } },
+], env);
+```
+
+## Extending the Runtime
+
+Add custom properties to the runtime environment, available in every task:
+
+```ts
+import { extendEnvironment } from "mobilestacks";
+
+extendEnvironment((env) => {
+  env.formatSTX = (micro: number) => `${(micro / 1e6).toFixed(6)} STX`;
+});
+```
+
+## Testing with Simnet
+
+Test contracts locally using the Clarinet SDK — no devnet needed:
+
+```ts
+import { describe, it, expect, beforeAll } from "vitest";
+import { Simnet } from "mobilestacks";
+import { Cl } from "@stacks/transactions";
+
+describe("My Contract", () => {
+  let simnet: Simnet;
+
+  beforeAll(async () => {
+    simnet = await Simnet.init();
+  });
+
+  it("calls hello-world", () => {
+    const deployer = simnet.getDeployer();
+    const { result } = simnet.callPublic("sample-contract", "hello-world", [], deployer);
+    expect(result).toStrictEqual(Cl.ok(Cl.stringAscii("Hello, Stacks!")));
+  });
+});
+```
+
+### Setup
+
+Contract tests need a `Clarinet.toml` and test accounts. Run the setup script once:
+
+```bash
+npm run setup:simnet
+```
+
+Then run tests:
+
+```bash
+npm test
+```
+
+## Programmatic API
+
+Use mobilestacks as a library:
+
+```ts
+import { task, subtask, extendEnvironment, Simnet, RuntimeEnvironment } from "mobilestacks";
+```
+
+## Project Structure
+
+```
+├── src/
+│   ├── cli/           # CLI entry point + init scaffolding
+│   ├── core/          # DSL, Simnet, RuntimeEnvironment, task registry
+│   ├── tasks/         # Built-in tasks (auto-loaded)
+│   ├── types/         # Zod schemas + TypeScript types
+│   └── index.ts       # Public API
+├── tests/             # Vitest test files
+├── contracts/         # Clarity contracts
+├── Clarinet.toml      # Clarinet project manifest
+└── mobilestacks.config.ts
+```
+
+## Contributing
+
+```bash
+git clone https://github.com/Wizbisy/mobilestacks.git
+cd mobilestacks
+npm install
+npm run setup:simnet   # generate test accounts
+npm test               # run all tests
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+
+## Security
+
+Private keys and seed phrases are never logged. Output is scanned for secrets and masked automatically. Keep your `.env` out of version control.
+
+## License
+
+MIT

package/contracts/sample-contract.clar

@@ -0,0 +1,2 @@
+(define-public (hello-world)
+  (ok "Hello, Stacks!"))

package/dist/mobilestacks.config.d.ts

@@ -0,0 +1,20 @@
+declare const _default: {
+    networks: {
+        mainnet: {
+            url: string;
+            name: string;
+            explorerUrl: string;
+            faucetUrl: null;
+        };
+        testnet: {
+            url: string;
+            name: string;
+            explorerUrl: string;
+            faucetUrl: string;
+        };
+    };
+    defaultNetwork: string;
+    wallet: {};
+};
+export default _default;
+//# sourceMappingURL=mobilestacks.config.d.ts.map

package/dist/mobilestacks.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobilestacks.config.d.ts","sourceRoot":"","sources":["../mobilestacks.config.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AACA,wBAqBE"}

package/dist/mobilestacks.config.js

@@ -0,0 +1,23 @@
+// Example mobilestacks.config.ts for testing
+export default {
+    networks: {
+        mainnet: {
+            url: "https://stacks-node-api.mainnet.stacks.co",
+            name: "mainnet",
+            explorerUrl: "https://explorer.stacks.co",
+            faucetUrl: null
+        },
+        testnet: {
+            url: "https://stacks-node-api.testnet.stacks.co",
+            name: "testnet",
+            explorerUrl: "https://explorer.stacks.co?chain=testnet",
+            faucetUrl: "https://stacks-node-api.testnet.stacks.co/extended/v1/faucet/stx"
+        }
+    },
+    defaultNetwork: "testnet",
+    wallet: {
+    // privateKey: "YOUR_PRIVATE_KEY_HERE",
+    // seedPhrase: "your twelve word phrase here",
+    // derivationPath: "m/44'/5757'/0'/0/0"
+    }
+};

package/dist/src/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/src/cli/index.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { loadConfig } from '../config/config-loading';
+import { RuntimeEnvironment } from '../core/runtime-environment';
+import { TaskDefinitions } from '../core/tasks-definitions';
+import { runInit } from './init';
+import inquirer from 'inquirer';
+// Import all user tasks
+import fs from 'fs';
+import path from 'path';
+// Auto-load all tasks in src/tasks
+const tasksDir = path.join(__dirname, '../tasks');
+fs.readdirSync(tasksDir)
+    .filter(f => f.endsWith('.ts') || f.endsWith('.js'))
+    .forEach(f => {
+    require(path.join(tasksDir, f));
+});
+const program = new Command();
+program
+    .name('mobilestacks')
+    .description('Professional Task Runner for Stacks')
+    .version('0.1.0');
+// Init command for project scaffolding
+program
+    .command('init')
+    .description('Scaffold a new mobilestacks project and config')
+    .action(async () => {
+    await runInit();
+    process.exit(0);
+});
+// List all tasks if no command is given
+program.action(() => {
+    console.log(chalk.bold.blue('\nMobilestacks - Professional Task Runner for Stacks\n'));
+    console.log(chalk.white('USAGE: ') + chalk.green('mobilestacks <task> [options]\n'));
+    console.log(chalk.bold('Available tasks:'));
+    TaskDefinitions.getInstance().getAllTasks().forEach(task => {
+        const params = task.params.map(p => chalk.yellow(`--${p.name}`)).join(' ');
+        console.log('  ' + chalk.cyan(task.name) + ' ' + params);
+        console.log('    ' + chalk.gray(task.description));
+    });
+    console.log('\n' + chalk.white('Use ') + chalk.green('mobilestacks <task> --help') + chalk.white(' for more info on a task.'));
+    console.log(chalk.white('\nExample:'));
+    console.log('  ' + chalk.green('mobilestacks deploy-contract --contractName my-contract --file ./contracts/my-contract.clar --network testnet'));
+    console.log(chalk.white('\nDocs: ') + chalk.underline('https://github.com/your-org/mobilestacks#readme'));
+    program.help({ error: false });
+});
+// Dynamically add all registered tasks
+TaskDefinitions.getInstance().getAllTasks().forEach(task => {
+    const cmd = program.command(task.name)
+        .description(task.description);
+    task.params.forEach(param => {
+        const optStr = `--${param.name} <value>`;
+        if (param.required !== false) {
+            cmd.option(optStr, param.description);
+        }
+        else {
+            cmd.option(optStr, param.description, param.defaultValue);
+        }
+    });
+    cmd.action(async (opts) => {
+        try {
+            // Prompt for missing required params
+            const missing = task.params.filter(p => p.required !== false && !opts[p.name]);
+            if (missing.length > 0) {
+                const answers = await inquirer.prompt(missing.map(p => ({
+                    type: p.type === 'boolean' ? 'confirm' : 'input',
+                    name: p.name,
+                    message: p.description,
+                    default: p.defaultValue
+                })));
+                Object.assign(opts, answers);
+            }
+            // Type conversion
+            task.params.forEach(p => {
+                if (opts[p.name] && p.type === 'number')
+                    opts[p.name] = Number(opts[p.name]);
+                if (opts[p.name] && p.type === 'boolean')
+                    opts[p.name] = Boolean(opts[p.name]);
+            });
+            const config = loadConfig();
+            const env = new RuntimeEnvironment(config);
+            const result = await task.action(opts, env);
+            if (typeof result === 'object') {
+                console.log(chalk.greenBright('Success!'));
+                console.dir(result, { depth: null, colors: true });
+            }
+            else {
+                console.log(chalk.greenBright(result));
+            }
+        }
+        catch (err) {
+            const error = err;
+            console.error(chalk.redBright('Task failed:'), error.message || error);
+            if (error && typeof error === 'object' && 'stack' in error && error.stack) {
+                console.error(chalk.gray(error.stack));
+            }
+            process.exit(1);
+        }
+    });
+});
+program.parse(process.argv);

package/dist/src/cli/init.d.ts

@@ -0,0 +1,2 @@
+export declare function runInit(): Promise<void>;
+//# sourceMappingURL=init.d.ts.map

package/dist/src/cli/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/cli/init.ts"],"names":[],"mappings":"AAIA,wBAAsB,OAAO,kBAoD5B"}

package/dist/src/cli/init.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import path from 'path';
+import inquirer from 'inquirer';
+export async function runInit() {
+    console.log('Welcome to mobilestacks project initialization!');
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: 'Project name:',
+            default: path.basename(process.cwd()),
+        },
+        {
+            type: 'input',
+            name: 'mainnetUrl',
+            message: 'Stacks mainnet node URL:',
+            default: 'https://stacks-node-api.mainnet.stacks.co',
+        },
+        {
+            type: 'input',
+            name: 'testnetUrl',
+            message: 'Stacks testnet node URL:',
+            default: 'https://stacks-node-api.testnet.stacks.co',
+        },
+        {
+            type: 'input',
+            name: 'privateKey',
+            message: 'Your wallet private key (leave blank to use seed phrase):',
+        },
+        {
+            type: 'input',
+            name: 'seedPhrase',
+            message: 'Your wallet seed phrase (leave blank if using private key):',
+        },
+        {
+            type: 'input',
+            name: 'derivationPath',
+            message: 'Derivation path (default: m/44\'/5757\'/0\'/0/0):',
+            default: "m/44'/5757'/0'/0/0",
+        },
+    ]);
+    const config = `export default {\n  networks: {\n    mainnet: { url: '${answers.mainnetUrl}', name: 'mainnet' },\n    testnet: { url: '${answers.testnetUrl}', name: 'testnet' }\n  },\n  defaultNetwork: 'testnet',\n  wallet: {\n    ${answers.privateKey ? `privateKey: '${answers.privateKey}',` : ''}\n    ${answers.seedPhrase ? `seedPhrase: '${answers.seedPhrase}',` : ''}\n    derivationPath: '${answers.derivationPath}'\n  }\n};\n`;
+    fs.writeFileSync(path.join(process.cwd(), 'mobilestacks.config.ts'), config);
+    // Scaffold example contract
+    const contractsDir = path.join(process.cwd(), 'contracts');
+    if (!fs.existsSync(contractsDir))
+        fs.mkdirSync(contractsDir);
+    fs.writeFileSync(path.join(contractsDir, 'sample-contract.clar'), '(define-public (hello-world)\n  (ok "Hello, Stacks!"))\n');
+    // Scaffold example user task
+    const tasksDir = path.join(process.cwd(), 'src', 'tasks');
+    if (!fs.existsSync(tasksDir))
+        fs.mkdirSync(tasksDir, { recursive: true });
+    fs.writeFileSync(path.join(tasksDir, 'example-task.ts'), "import { task } from '../core/dsl';\n\ntask('example', 'An example user task for onboarding')\n  .addParam('name', 'Your name', { type: 'string', required: false, defaultValue: 'World' })\n  .setAction(async (args) => {\n    return `Hello, ${args.name}! Welcome to mobilestacks.`;\n  });\n");
+    console.log('Created mobilestacks.config.ts, contracts/sample-contract.clar, and src/tasks/example-task.ts!');
+}

package/dist/src/config/config-loading.d.ts

@@ -0,0 +1,3 @@
+import { MobilestacksConfig } from '../types/config';
+export declare function loadConfig(configPath?: string, cliOverrides?: Record<string, unknown>): MobilestacksConfig;
+//# sourceMappingURL=config-loading.d.ts.map

package/dist/src/config/config-loading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loading.d.ts","sourceRoot":"","sources":["../../../src/config/config-loading.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAK/E,wBAAgB,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,kBAAkB,CAyB9G"}

package/dist/src/config/config-loading.js

@@ -0,0 +1,29 @@
+import { MobilestacksConfigSchema } from '../types/config';
+import path from 'path';
+import fs from 'fs';
+import { env } from '../core/env';
+export function loadConfig(configPath, cliOverrides = {}) {
+    const configFile = configPath || path.resolve(process.cwd(), 'mobilestacks.config.ts');
+    if (!fs.existsSync(configFile)) {
+        throw new Error(`Config file not found: ${configFile}`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+    require('ts-node').register();
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+    const userConfig = require(configFile);
+    let config = userConfig.default || userConfig;
+    // .env override
+    if (env.privateKey)
+        config.wallet.privateKey = env.privateKey;
+    if (env.mainnetUrl)
+        config.networks.mainnet.url = env.mainnetUrl;
+    if (env.testnetUrl)
+        config.networks.testnet.url = env.testnetUrl;
+    // CLI overrides
+    config = { ...config, ...cliOverrides };
+    const parsed = MobilestacksConfigSchema.safeParse(config);
+    if (!parsed.success) {
+        throw new Error('Invalid mobilestacks.config.ts: ' + JSON.stringify(parsed.error.format(), null, 2));
+    }
+    return parsed.data;
+}

package/dist/src/core/dsl.d.ts

@@ -0,0 +1,30 @@
+import { TaskDefinition, TaskParamType } from './tasks-definitions';
+import { ZodSchema } from 'zod';
+import { RuntimeEnvironment } from './runtime-environment';
+import { extendEnvironment } from './extender';
+declare function task(name: string, description: string): {
+    addParam(paramName: string, paramDesc: string, options?: {
+        type?: TaskParamType;
+        required?: boolean;
+        defaultValue?: unknown;
+        schema?: ZodSchema;
+    }): /*elided*/ any;
+    setAction(action: (args: Record<string, unknown>, env: RuntimeEnvironment) => Promise<unknown>): TaskDefinition;
+};
+declare function subtask(name: string, description: string, parentTaskName?: string): {
+    addParam(paramName: string, paramDesc: string, options?: {
+        type?: TaskParamType;
+        required?: boolean;
+        defaultValue?: unknown;
+        schema?: ZodSchema;
+    }): /*elided*/ any;
+    setAction(action: (args: Record<string, unknown>, env: RuntimeEnvironment) => Promise<unknown>): TaskDefinition;
+};
+export type WorkflowStep = {
+    taskName: string;
+    args?: Record<string, unknown>;
+};
+export type Workflow = WorkflowStep[];
+export declare function runWorkflow(workflow: Workflow, env: RuntimeEnvironment): Promise<void>;
+export { task, subtask, extendEnvironment };
+//# sourceMappingURL=dsl.d.ts.map

package/dist/src/core/dsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsl.d.ts","sourceRoot":"","sources":["../../../src/core/dsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,cAAc,EAAa,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAChG,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,iBAAS,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;wBAI9B,MAAM,aACN,MAAM,YACP;QAAE,IAAI,CAAC,EAAE,aAAa,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,SAAS,CAAA;KAAE;sBAYlF,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,kBAAkB,KAAK,OAAO,CAAC,OAAO,CAAC;EAuBjG;AAED,iBAAS,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM;wBAvC1D,MAAM,aACN,MAAM,YACP;QAAE,IAAI,CAAC,EAAE,aAAa,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,SAAS,CAAA;KAAE;sBAYlF,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,kBAAkB,KAAK,OAAO,CAAC,OAAO,CAAC;EAkCjG;AAGD,MAAM,MAAM,YAAY,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC;AAChF,MAAM,MAAM,QAAQ,GAAG,YAAY,EAAE,CAAC;AAEtC,wBAAsB,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,kBAAkB,iBAO5E;AAED,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/src/core/dsl.js

@@ -0,0 +1,62 @@
+import { TaskDefinitions } from './tasks-definitions';
+import { extendEnvironment } from './extender';
+function task(name, description) {
+    const params = [];
+    return {
+        addParam(paramName, paramDesc, options) {
+            params.push({
+                name: paramName,
+                description: paramDesc,
+                type: options?.type || 'string',
+                required: options?.required !== false, // default true
+                defaultValue: options?.defaultValue,
+                schema: options?.schema,
+            });
+            return this;
+        },
+        setAction(action) {
+            const def = {
+                name,
+                description,
+                params,
+                action: async (args, env) => {
+                    // Validate args against schemas if present
+                    for (const param of params) {
+                        if (param.schema && args[param.name] !== undefined) {
+                            try {
+                                param.schema.parse(args[param.name]);
+                            }
+                            catch (error) {
+                                throw new Error(`Invalid value for parameter '${param.name}': ${error}`);
+                            }
+                        }
+                    }
+                    return action(args, env);
+                },
+            };
+            TaskDefinitions.getInstance().addTask(def);
+            return def;
+        },
+    };
+}
+function subtask(name, description, parentTaskName) {
+    // Register as a subtask with a parent if provided
+    const sub = task(name, description);
+    if (parentTaskName) {
+        // Attach parent info for future use (e.g., dependency graph, CLI grouping)
+        const def = TaskDefinitions.getInstance().getTask(name);
+        if (def)
+            def.parent = parentTaskName;
+    }
+    return sub;
+}
+export async function runWorkflow(workflow, env) {
+    for (const step of workflow) {
+        const def = TaskDefinitions.getInstance().getTask(step.taskName);
+        if (!def)
+            throw new Error(`Task not found: ${step.taskName}`);
+        // eslint-disable-next-line no-await-in-loop
+        await def.action(step.args || {}, env);
+    }
+}
+export { task, subtask, extendEnvironment };

package/dist/src/core/dsl.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dsl.test.d.ts.map

package/dist/src/core/dsl.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsl.test.d.ts","sourceRoot":"","sources":["../../../src/core/dsl.test.ts"],"names":[],"mappings":""}

package/dist/src/core/dsl.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { task } from './dsl';
+import { TaskDefinitions } from './tasks-definitions';
+import { z } from 'zod';
+import { extendEnvironment, Extender } from './extender';
+describe('DSL', () => {
+    beforeEach(() => {
+        // Clear tasks before each test
+        TaskDefinitions.getInstance()._tasks = [];
+    });
+    it('should register a task with generic parameters', () => {
+        task('test-task', 'A test task')
+            .addParam('p1', 'param 1')
+            .setAction(async () => { return 'done'; });
+        const def = TaskDefinitions.getInstance().getTask('test-task');
+        expect(def).toBeDefined();
+        expect(def?.name).toBe('test-task');
+        expect(def?.params.length).toBe(1);
+    });
+    it('should validate Zod schema', async () => {
+        task('zod-task', 'Task with validation')
+            .addParam('age', 'Age param', { schema: z.number().min(18) })
+            .setAction(async (args) => {
+            return args.age;
+        });
+        const def = TaskDefinitions.getInstance().getTask('zod-task');
+        expect(def).toBeDefined();
+        // Mock environment
+        const env = {};
+        // Valid call
+        const result = await def?.action({ age: 20 }, env);
+        expect(result).toBe(20);
+        // Invalid call
+        await expect(def?.action({ age: 10 }, env)).rejects.toThrow('Invalid value for parameter \'age\'');
+    });
+    it('should support environment extensions', () => {
+        // Clear extensions
+        Extender.getInstance()._extensions = [];
+        extendEnvironment((env) => {
+            env['foo'] = 'bar';
+        });
+        const extensions = Extender.getInstance().getExtensions();
+        expect(extensions.length).toBe(1);
+        const mockEnv = {};
+        extensions[0](mockEnv);
+        expect(mockEnv['foo']).toBe('bar');
+    });
+});

package/dist/src/core/env.d.ts

@@ -0,0 +1,6 @@
+export declare const env: {
+    privateKey: string | undefined;
+    mainnetUrl: string | undefined;
+    testnetUrl: string | undefined;
+};
+//# sourceMappingURL=env.d.ts.map

package/dist/src/core/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/core/env.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,GAAG;;;;CAIf,CAAC"}

package/dist/src/core/env.js

@@ -0,0 +1,7 @@
+import dotenv from 'dotenv';
+dotenv.config();
+export const env = {
+    privateKey: process.env.STACKS_PRIVATE_KEY,
+    mainnetUrl: process.env.STACKS_MAINNET_URL,
+    testnetUrl: process.env.STACKS_TESTNET_URL,
+};