@clarigen/cli 0.2.4 → 0.3.1

package/README.md

@@ -7,20 +7,7 @@ Most of the time, you'll only need to run `clarigen` to automatically build your
 # Usage
 
 <!-- commands -->
-* [`clarigen `](#clarigen-)
 
-## `clarigen `
-
-Generate project files
-
-```
-USAGE
-  $ clarigen
-
-OPTIONS
-  -h, --help   show CLI help
-  -w, --watch  Watch for changes to your contracts
-```
 <!-- commandsstop -->
 
 ## Development

package/bin/run

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
+/* eslint-disable @typescript-eslint/no-var-requires */
 
-require('../dist')
+require('@oclif/command')
   .run()
   .then(require('@oclif/command/flush'))
   .catch(require('@oclif/errors/handle'));

package/dist/clarinet-config.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClarinetAccounts = exports.getContractsFromClarinet = exports.getClarinetConfig = exports.getClarinetDevConfig = void 0;
+const j_toml_1 = require("@ltd/j-toml");
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const wallet_sdk_1 = require("@stacks/wallet-sdk");
+async function getClarinetDevConfig(folder) {
+    const baseConfigPath = path_1.resolve(folder, 'settings', 'Devnet.toml');
+    const configContents = await promises_1.readFile(baseConfigPath, { encoding: 'utf-8' });
+    const config = j_toml_1.parse(configContents, 1.0, '\n', true, {
+        longer: true,
+    });
+    return config;
+}
+exports.getClarinetDevConfig = getClarinetDevConfig;
+async function getClarinetConfig(folder) {
+    const baseConfigPath = path_1.resolve(folder, 'Clarinet.toml');
+    const configContents = await promises_1.readFile(baseConfigPath, { encoding: 'utf-8' });
+    const config = j_toml_1.parse(configContents, 1.0, '\n', true);
+    return config;
+}
+exports.getClarinetConfig = getClarinetConfig;
+async function getContractsFromClarinet(folder, accounts) {
+    const clarinetConfig = await getClarinetConfig(folder);
+    const deployerAddress = accounts.deployer.address;
+    const contracts = Object.entries(clarinetConfig.contracts).map(([contractName, info]) => {
+        const file = info.path.replace(/^contracts\//, '');
+        return {
+            file,
+            address: deployerAddress,
+        };
+    });
+    return contracts;
+}
+exports.getContractsFromClarinet = getContractsFromClarinet;
+async function getClarinetAccounts(folder) {
+    const devConfig = await getClarinetDevConfig(folder);
+    const accountEntries = await Promise.all(Object.entries(devConfig.accounts).map(async ([key, info]) => {
+        const wallet = await wallet_sdk_1.generateWallet({
+            secretKey: info.mnemonic,
+            password: 'password',
+        });
+        const [account] = wallet.accounts;
+        const address = wallet_sdk_1.getStxAddress({ account });
+        return [
+            key,
+            {
+                ...info,
+                address,
+            },
+        ];
+    }));
+    const accounts = Object.fromEntries(accountEntries);
+    return accounts;
+}
+exports.getClarinetAccounts = getClarinetAccounts;

package/dist/commands/contract.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contract = void 0;
+const command_1 = require("@oclif/command");
+const utils_1 = require("../utils");
+class Contract extends command_1.Command {
+    async run() {
+        const { argv, flags } = this.parse(Contract);
+        const [contractFile] = argv;
+        await utils_1.generateFilesForContract({
+            contractFile,
+            outputFolder: flags.output,
+        });
+    }
+}
+exports.Contract = Contract;
+Contract.description = `Generate files for a single contract`;
+Contract.strict = true;
+Contract.hidden = true;
+Contract.flags = {
+    help: command_1.flags.help({ char: 'h' }),
+    output: command_1.flags.string({
+        char: 'o',
+        description: 'Output destination folder',
+        default: 'clarion',
+    }),
+};
+Contract.args = [
+    {
+        name: 'contract',
+        description: 'The file path for your contract',
+    },
+];

package/dist/commands/index.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Generate = void 0;
+const command_1 = require("@oclif/command");
+const utils_1 = require("../utils");
+const config_1 = require("../config");
+const chokidar_1 = require("chokidar");
+const path_1 = require("path");
+const chalk_1 = require("chalk");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const ora = require('ora');
+class Generate extends command_1.Command {
+    async run() {
+        const { flags } = this.parse(Generate);
+        const cwd = process.cwd();
+        if (flags.watch) {
+            const spinner = ora('Generating files').start();
+            const { contractsDir } = await config_1.getConfigFile(cwd);
+            const watcher = chokidar_1.watch([contractsDir], {
+                cwd,
+            });
+            try {
+                await utils_1.generateProject(cwd);
+                spinner.succeed(`Finished generating files. Watching for changes.`);
+            }
+            catch (error) {
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+                spinner.fail(`Error generating files.\n${error.message}`);
+            }
+            watcher.on('change', async (path) => {
+                const file = path_1.basename(path);
+                spinner.clear();
+                spinner.start(`Change detected for ${chalk_1.green(file)}, generating.`);
+                try {
+                    await utils_1.generateProject(cwd);
+                    spinner.succeed(`Finished generating files for ${chalk_1.green(file)}. Watching for changes.`);
+                }
+                catch (error) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+                    const msg = error.message;
+                    spinner.fail(`Error after saving ${chalk_1.red(file)}.\n${msg}`);
+                }
+            });
+            process.on('SIGINT', async () => {
+                await watcher.close();
+                process.exit();
+            });
+        }
+        else {
+            await utils_1.generateProject(cwd);
+        }
+    }
+}
+exports.Generate = Generate;
+Generate.description = `Generate project files`;
+Generate.strict = true;
+Generate.hidden = false;
+Generate.flags = {
+    help: command_1.flags.help({ char: 'h' }),
+    watch: command_1.flags.boolean({
+        char: 'w',
+        description: 'Watch for changes to your contracts',
+    }),
+};
+Generate.args = [];

package/dist/config.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigFile = void 0;
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const clarinet_config_1 = require("./clarinet-config");
+async function getConfigFile(rootPath) {
+    const fullPath = path_1.resolve(rootPath, 'clarigen.config.json');
+    const configContents = await promises_1.readFile(fullPath, { encoding: 'utf-8' });
+    const configFile = JSON.parse(configContents);
+    if (!configFile.outputDir)
+        throw new Error('Config file missing "outputDir"');
+    if ('clarinet' in configFile) {
+        const clarinetPath = path_1.resolve(rootPath, configFile.clarinet);
+        const accounts = await clarinet_config_1.getClarinetAccounts(clarinetPath);
+        const contracts = await clarinet_config_1.getContractsFromClarinet(clarinetPath, accounts);
+        const contractsDir = path_1.relative(process.cwd(), path_1.join(configFile.clarinet, 'contracts'));
+        return {
+            ...configFile,
+            contracts,
+            contractsDir,
+            accounts,
+        };
+    }
+    if (!configFile.contracts)
+        throw new Error('Config file missing "contracts"');
+    if (!configFile.contractsDir)
+        throw new Error('Config file missing "contractDir"');
+    return configFile;
+}
+exports.getConfigFile = getConfigFile;

package/dist/generate/declaration.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTypes = exports.jsTypeFromAbiType = exports.cvFromType = void 0;
+const transactions_1 = require("@stacks/transactions");
+const core_1 = require("@clarigen/core");
+const cvFromType = (val) => {
+    if (transactions_1.isClarityAbiPrimitive(val)) {
+        if (val === 'uint128') {
+            return 'ClarityTypes.UIntCV';
+        }
+        else if (val === 'int128') {
+            return 'ClarityTypes.IntCV';
+        }
+        else if (val === 'bool') {
+            return 'ClarityTypes.BooleanCV';
+        }
+        else if (val === 'principal') {
+            return 'ClarityTypes.PrincipalCV';
+        }
+        else if (val === 'none') {
+            return 'ClarityTypes.NoneCV';
+        }
+        else {
+            throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(val)}`);
+        }
+    }
+    else if (transactions_1.isClarityAbiBuffer(val)) {
+        return 'ClarityTypes.BufferCV';
+    }
+    else if (transactions_1.isClarityAbiResponse(val)) {
+        return 'ClarityTypes.ResponseCV';
+    }
+    else if (transactions_1.isClarityAbiOptional(val)) {
+        return 'ClarityTypes.OptionalCV';
+    }
+    else if (transactions_1.isClarityAbiTuple(val)) {
+        return 'ClarityTypes.TupleCV';
+    }
+    else if (transactions_1.isClarityAbiList(val)) {
+        return 'ClarityTypes.ListCV';
+    }
+    else if (transactions_1.isClarityAbiStringAscii(val)) {
+        return 'ClarityTypes.StringAsciiCV';
+    }
+    else if (transactions_1.isClarityAbiStringUtf8(val)) {
+        return 'ClarityTypes.StringUtf8CV';
+    }
+    else {
+        throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);
+    }
+};
+exports.cvFromType = cvFromType;
+const jsTypeFromAbiType = (val, isArgument = false) => {
+    if (transactions_1.isClarityAbiPrimitive(val)) {
+        if (val === 'uint128') {
+            if (isArgument)
+                return 'number | bigint';
+            return 'bigint';
+        }
+        else if (val === 'int128') {
+            if (isArgument)
+                return 'number | bigint';
+            return 'bigint';
+        }
+        else if (val === 'bool') {
+            return 'boolean';
+        }
+        else if (val === 'principal') {
+            return 'string';
+        }
+        else if (val === 'none') {
+            return 'null';
+        }
+        else if (val === 'trait_reference') {
+            return 'string';
+        }
+        else {
+            throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(val)}`);
+        }
+    }
+    else if (transactions_1.isClarityAbiBuffer(val)) {
+        return 'Buffer';
+    }
+    else if (transactions_1.isClarityAbiResponse(val)) {
+        const ok = exports.jsTypeFromAbiType(val.response.ok);
+        const err = exports.jsTypeFromAbiType(val.response.error);
+        return `ClarityTypes.Response<${ok}, ${err}>`;
+    }
+    else if (transactions_1.isClarityAbiOptional(val)) {
+        const innerType = exports.jsTypeFromAbiType(val.optional);
+        return `${innerType} | null`;
+    }
+    else if (transactions_1.isClarityAbiTuple(val)) {
+        const tupleDefs = [];
+        val.tuple.forEach(({ name, type }) => {
+            const innerType = exports.jsTypeFromAbiType(type);
+            tupleDefs.push(`"${name}": ${innerType}`);
+        });
+        return `{
+  ${tupleDefs.join(';\n  ')}
+    }`;
+    }
+    else if (transactions_1.isClarityAbiList(val)) {
+        const innerType = exports.jsTypeFromAbiType(val.list.type);
+        return `${innerType}[]`;
+    }
+    else if (transactions_1.isClarityAbiStringAscii(val)) {
+        return 'string';
+    }
+    else if (transactions_1.isClarityAbiStringUtf8(val)) {
+        return 'string';
+    }
+    else if (val === 'trait_reference') {
+        return 'string';
+    }
+    else {
+        throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);
+    }
+};
+exports.jsTypeFromAbiType = jsTypeFromAbiType;
+const makeTypes = (abi) => {
+    let typings = '';
+    abi.functions.forEach((func, index) => {
+        if (func.access === 'private')
+            return;
+        let functionLine = `${core_1.toCamelCase(func.name)}: `;
+        const args = func.args.map((arg) => {
+            return `${core_1.toCamelCase(arg.name)}: ${exports.jsTypeFromAbiType(arg.type, true)}`;
+        });
+        functionLine += `(${args.join(', ')}) => `;
+        if (func.access === 'public') {
+            const { type } = func.outputs;
+            if (!transactions_1.isClarityAbiResponse(type))
+                throw new Error('Expected response type for public function');
+            functionLine += 'Transaction';
+            const ok = exports.jsTypeFromAbiType(type.response.ok);
+            const err = exports.jsTypeFromAbiType(type.response.error);
+            functionLine += `<${ok}, ${err}>;`;
+        }
+        else {
+            const jsType = exports.jsTypeFromAbiType(func.outputs.type);
+            functionLine += `Promise<${jsType}>;`;
+            // const { type } = func.outputs;
+            // if (isClarityAbiResponse(type)) {
+            //   const ok = jsTypeFromAbiType(type.response.ok);
+            //   const err = jsTypeFromAbiType(type.response.error);
+            //   functionLine += `Promise<ClarityTypes.Response<${ok}, ${err}>>;`;
+            // } else {
+            //   const jsType = jsTypeFromAbiType(func.outputs.type);
+            //   functionLine += `Promise<${jsType}>;`;
+            // }
+        }
+        typings += `${index === 0 ? '' : '\n'}  ${functionLine}`;
+    });
+    return typings;
+};
+exports.makeTypes = makeTypes;

package/dist/generate/files.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProjectIndexFile = exports.generateTypesFile = exports.generateIndexFile = exports.generateInterfaceFile = exports.generateInterface = void 0;
+const native_bin_1 = require("@clarigen/native-bin");
+const core_1 = require("@clarigen/core");
+const declaration_1 = require("./declaration");
+const path_1 = require("path");
+const generateInterface = async ({ provider: _provider, contractFile, contractAddress = 'S1G2081040G2081040G2081040G208105NK8PE5', }) => {
+    const provider = _provider || (await native_bin_1.createClarityBin());
+    const contractName = core_1.getContractNameFromPath(contractFile);
+    const receipt = await provider.runCommand([
+        'launch',
+        `${contractAddress}.${contractName}`,
+        contractFile,
+        provider.dbFilePath,
+        '--output_analysis',
+        '--costs',
+        '--assets',
+    ]);
+    if (receipt.stderr &&
+        !receipt.stderr.includes('Used unimplemented cost function')) {
+        throw new Error(`Error on ${contractFile}:
+  ${receipt.stderr}
+    `);
+    }
+    const output = JSON.parse(receipt.stdout);
+    if (output.error) {
+        const { initialization } = output.error;
+        if (initialization?.includes('\nNear:\n')) {
+            const [error, trace] = initialization.split('\nNear:\n');
+            let startLine = '';
+            const matcher = /start_line: (\d+),/;
+            const matches = matcher.exec(trace);
+            if (matches)
+                startLine = matches[1];
+            throw new Error(`Error on ${contractFile}:
+    ${error}
+    ${startLine ? `Near line ${startLine}` : ''}
+    Raw trace:
+    ${trace}
+      `);
+        }
+        throw new Error(`Error on ${contractFile}:
+  ${JSON.stringify(output.error, null, 2)}
+    `);
+    }
+    const abi = output.analysis;
+    return abi;
+};
+exports.generateInterface = generateInterface;
+const generateInterfaceFile = ({ contractFile, abi, }) => {
+    const contractName = core_1.getContractNameFromPath(contractFile);
+    const variableName = core_1.toCamelCase(contractName, true);
+    const abiString = JSON.stringify(abi, null, 2);
+    const fileContents = `import { ClarityAbi } from '@clarigen/core';
+
+// prettier-ignore
+export const ${variableName}Interface: ClarityAbi = ${abiString};
+`;
+    return fileContents;
+};
+exports.generateInterfaceFile = generateInterfaceFile;
+const generateIndexFile = ({ contractFile, address, }) => {
+    const contractName = core_1.getContractNameFromPath(contractFile);
+    const contractTitle = core_1.toCamelCase(contractName, true);
+    const varName = core_1.toCamelCase(contractName);
+    const contractType = `${contractTitle}Contract`;
+    const fileContents = `import { proxy, BaseProvider, Contract } from '@clarigen/core';
+import type { ${contractType} } from './types';
+import { ${contractTitle}Interface } from './abi';
+export type { ${contractType} } from './types';
+
+export const ${varName}Contract = (provider: BaseProvider) => {
+  const contract = proxy<${contractType}>(${contractTitle}Interface, provider);
+  return contract;
+};
+
+export const ${varName}Info: Contract<${contractType}> = {
+  contract: ${varName}Contract,
+  address: '${address}',
+  contractFile: '${contractFile}',
+};
+`;
+    return fileContents;
+};
+exports.generateIndexFile = generateIndexFile;
+const generateTypesFile = (abi, contractName) => {
+    const name = core_1.toCamelCase(contractName, true);
+    const typings = declaration_1.makeTypes(abi);
+    const fileContents = `import { ClarityTypes, Transaction } from '@clarigen/core';
+
+// prettier-ignore
+export interface ${name}Contract {
+${typings}
+}
+`;
+    return fileContents;
+};
+exports.generateTypesFile = generateTypesFile;
+const generateProjectIndexFile = (config) => {
+    const imports = [];
+    const exports = [];
+    const contractMap = [];
+    let accounts = '';
+    if ('accounts' in config) {
+        const accountLines = Object.keys(config.accounts).map((key) => {
+            const account = config.accounts[key];
+            return `"${key}": {
+    mnemonic: "${account.mnemonic}",
+    balance: ${account.balance.toString()}n,
+    address: "${account.address}",
+  },`;
+        });
+        accounts = `\n\n// prettier-ignore
+export const accounts = {
+  ${accountLines.join('\n  ')}
+};`;
+    }
+    config.contracts.forEach((contract) => {
+        const contractName = core_1.getContractNameFromPath(contract.file);
+        const contractVar = core_1.toCamelCase(contractName);
+        const contractInfo = `${contractVar}Info`;
+        const contractInterface = `${core_1.toCamelCase(contractName, true)}Contract`;
+        const dirName = path_1.dirname(contract.file);
+        const importPath = `'./${path_1.join(dirName || '.', contractName)}'`;
+        const _import = `import { ${contractInfo} } from ${importPath};`;
+        imports.push(_import);
+        const _export = `export type { ${contractInterface} } from ${importPath};`;
+        exports.push(_export);
+        const map = `${contractVar}: ${contractInfo},`;
+        contractMap.push(map);
+    });
+    const file = `${imports.join('\n')}
+${exports.join('\n')}
+
+export const contracts = {
+  ${contractMap.join('\n  ')}
+};${accounts}
+`;
+    return file;
+};
+exports.generateProjectIndexFile = generateProjectIndexFile;

package/dist/index.js

@@ -1,8 +1,19 @@
-
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./cli.cjs.production.min.js')
-} else {
-  module.exports = require('./cli.cjs.development.js')
-}
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+var command_1 = require("@oclif/command");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return command_1.run; } });
+__exportStar(require("./config"), exports);
+__exportStar(require("./generate/declaration"), exports);
+__exportStar(require("./generate/files"), exports);
+__exportStar(require("./commands"), exports);

package/dist/start.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("@oclif/errors");
+const flush_1 = __importDefault(require("@oclif/command/flush"));
+const index_1 = require("./index");
+index_1.run().then(flush_1.default, errors_1.handle);

package/dist/utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProject = exports.generateFilesForContract = void 0;
+const files_1 = require("./generate/files");
+const core_1 = require("@clarigen/core");
+const native_bin_1 = require("@clarigen/native-bin");
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const config_1 = require("./config");
+const generateFilesForContract = async ({ contractFile: _contractFile, outputFolder, provider, contractAddress, dirName, }) => {
+    const contractFile = path_1.resolve(process.cwd(), _contractFile);
+    const contractName = core_1.getContractNameFromPath(contractFile);
+    const abi = await files_1.generateInterface({
+        contractFile,
+        provider,
+        contractAddress,
+    });
+    const typesFile = files_1.generateTypesFile(abi, contractName);
+    if (!contractAddress && process.env.NODE_ENV !== 'test') {
+        console.warn('Please provide an address with every contract.');
+    }
+    const indexFile = files_1.generateIndexFile({
+        contractFile: path_1.relative(process.cwd(), contractFile),
+        address: contractAddress || '',
+    });
+    const abiFile = files_1.generateInterfaceFile({ contractFile, abi });
+    const baseDir = outputFolder || path_1.resolve(process.cwd(), `tmp/${contractName}`);
+    const outputPath = path_1.resolve(baseDir, dirName || '.', contractName);
+    await promises_1.mkdir(outputPath, { recursive: true });
+    await promises_1.writeFile(path_1.resolve(outputPath, 'abi.ts'), abiFile);
+    await promises_1.writeFile(path_1.resolve(outputPath, 'index.ts'), indexFile);
+    await promises_1.writeFile(path_1.resolve(outputPath, 'types.ts'), typesFile);
+};
+exports.generateFilesForContract = generateFilesForContract;
+const generateProject = async (projectPath) => {
+    const configFile = await config_1.getConfigFile(projectPath);
+    const { contractsDir, outputDir, contracts } = configFile;
+    const outputFolder = path_1.resolve(projectPath, outputDir);
+    const provider = await native_bin_1.createClarityBin();
+    // this needs to be serial
+    for (const contract of contracts) {
+        const contractFile = path_1.resolve(projectPath, contractsDir, contract.file);
+        const dirName = path_1.dirname(contract.file);
+        await exports.generateFilesForContract({
+            contractFile,
+            outputFolder: outputFolder,
+            provider,
+            contractAddress: contract.address,
+            dirName,
+        });
+    }
+    const indexFile = files_1.generateProjectIndexFile(configFile);
+    const indexPath = path_1.resolve(outputFolder, 'index.ts');
+    await promises_1.writeFile(indexPath, indexFile);
+};
+exports.generateProject = generateProject;

package/package.json

@@ -2,13 +2,13 @@
   "name": "@clarigen/cli",
   "description": "A CLI for generating a Typescript interface for a Clarity contract.",
   "author": "Hank Stoever",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "license": "MIT",
   "main": "dist/index.js",
   "files": [
     "dist",
     "src",
-    "/oclif.manifest.json"
+    "oclif.manifest.json"
   ],
   "engines": {
     "node": ">=10"
@@ -18,10 +18,11 @@
     "start": "ts-node-script src/start.ts",
     "compile": "ncc build src/index.ts --no-source-map-register -e @oclif/command -e @oclif/errors",
     "build-single-file": "yarn compile && oclif-dev readme",
-    "build": "tsdx build && oclif-dev readme",
+    "build": "rm -rf dist && tsc -b",
     "test": "tsdx test",
     "lint": "tsdx lint",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "yarn build"
   },
   "bin": {
     "clarigen": "./bin/run"
@@ -37,25 +38,26 @@
     "trailingComma": "es5"
   },
   "devDependencies": {
-    "@oclif/config": "^1.17.0",
     "@oclif/dev-cli": "^1.26.0",
     "@oclif/errors": "^1.3.4",
     "@vercel/ncc": "0.27.0",
-    "chokidar": "3.5.1",
     "oclif": "^1.16.1",
     "ts-node": "^9.1.1"
   },
   "dependencies": {
-    "@clarigen/core": "0.2.3",
-    "@clarigen/native-bin": "0.2.3",
+    "@clarigen/core": "0.3.1",
+    "@clarigen/native-bin": "0.3.1",
     "@ltd/j-toml": "1.12.2",
     "@oclif/command": "^1.8.0",
+    "@oclif/config": "^1.17.0",
+    "@oclif/plugin-help": "3.2.3",
     "@stacks/wallet-sdk": "1.0.0-wallet-sdk.4",
     "chalk": "4.1.0",
+    "chokidar": "3.5.1",
     "ora": "5.4.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d5f5f508ece8cd70b88d23f4b27643c0ba990997"
+  "gitHead": "7fa176bead2d770807bbb77d86aae5f5d7543e2b"
 }