@clarigen/cli 1.0.0-next.9 → 2.0.1

package/dist/run-cli.js

@@ -0,0 +1,1455 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/run-cli.ts
+import { Cli, Builtins } from "clipanion";
+
+// src/commands/session-info.ts
+import { Command as Command2, Option as Option2 } from "clipanion";
+
+// src/config.ts
+import { z as z2 } from "zod";
+
+// src/logger.ts
+import { pino } from "pino";
+import pinoPretty from "pino-pretty";
+var colorizedClarigen = `\x1B[33m[Clarigen]\x1B[0m`;
+var logger = pino(pinoPretty({
+  colorize: true,
+  ignore: "pid,hostname,time",
+  messageFormat: `${colorizedClarigen} {msg}`,
+  minimumLevel: "debug"
+}));
+logger.level = "info";
+var log = logger;
+
+// src/utils.ts
+import { getContractName, toCamelCase } from "@clarigen/core";
+import { stat, mkdir, writeFile as fsWriteFile } from "fs/promises";
+import { dirname, relative } from "path";
+function encodeVariableName(name) {
+  if (/^[A-Z\-_]*$/.test(name))
+    return name.replaceAll("-", "_");
+  return toCamelCase(name);
+}
+async function fileExists(filename) {
+  try {
+    await stat(filename);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+async function writeFile(path, contents) {
+  const dir = dirname(path);
+  await mkdir(dir, { recursive: true });
+  await fsWriteFile(path, contents, "utf-8");
+  return path;
+}
+function sortContracts(contracts) {
+  const nameSorted = [...contracts].sort((a, b) => {
+    if (getContractName(a.contract_id, false) < getContractName(b.contract_id, false)) {
+      return -1;
+    }
+    return 1;
+  });
+  return nameSorted;
+}
+
+// src/clarinet-config.ts
+import { z } from "zod";
+import { readFile } from "fs/promises";
+import { parse } from "@iarna/toml";
+var ClarinetConfigSchema = z.object({
+  project: z.object({
+    requirements: z.array(z.object({ contract_id: z.string() })).optional(),
+    cache_location: z.object({ path: z.string() }).optional()
+  }),
+  contracts: z.record(z.string(), z.object({ path: z.string() })).optional()
+});
+async function getClarinetConfig(path) {
+  const file = await readFile(path, "utf-8");
+  const config = ClarinetConfigSchema.parse(parse(file));
+  return config;
+}
+
+// src/config.ts
+import { dirname as dirname2, join, relative as relative2, resolve as resolve2 } from "path";
+import { stringify, parse as parse2 } from "@iarna/toml";
+import { readFile as readFile2 } from "fs/promises";
+var CONFIG_FILE = "Clarigen.toml";
+var typesSchema = z2.object({
+  output: z2.string().optional(),
+  outputs: z2.array(z2.string()).optional(),
+  include_accounts: z2.boolean().optional(),
+  after: z2.string().optional()
+}).optional();
+var ConfigFileSchema = z2.object({
+  clarinet: z2.string(),
+  ["types" /* ESM */]: typesSchema,
+  ["esm" /* ESM_OLD */]: typesSchema,
+  ["docs" /* Docs */]: z2.object({
+    output: z2.string().optional(),
+    outputs: z2.array(z2.string()).optional(),
+    exclude: z2.array(z2.string()).optional(),
+    after: z2.string().optional()
+  }).optional()
+});
+var defaultConfigFile = {
+  clarinet: "./Clarinet.toml"
+};
+var Config = class {
+  configFile;
+  clarinet;
+  cwd;
+  constructor(config, clarinet, cwd) {
+    this.configFile = config;
+    this.clarinet = clarinet;
+    this.cwd = cwd ?? process.cwd();
+  }
+  static async load(cwd) {
+    const config = await getConfig(cwd);
+    if (config["esm" /* ESM_OLD */]) {
+      config["types" /* ESM */] = config["esm" /* ESM_OLD */];
+      delete config["esm" /* ESM_OLD */];
+    }
+    const clarinet = await getClarinetConfig(resolve2(cwd ?? "", config.clarinet));
+    return new this(config, clarinet, cwd);
+  }
+  getOutputs(type) {
+    var _a, _b;
+    const singlePath = (_a = this.configFile[type]) == null ? void 0 : _a.output;
+    const multiPath = ((_b = this.configFile[type]) == null ? void 0 : _b.outputs) || [];
+    if (singlePath !== void 0)
+      return [singlePath];
+    return multiPath;
+  }
+  outputResolve(type, filePath) {
+    const outputs = this.getOutputs(type);
+    if (!this.supports(type))
+      return null;
+    return outputs.map((path) => {
+      return resolve2(this.cwd, path, filePath || "");
+    });
+  }
+  async writeOutput(type, contents, filePath) {
+    const paths = this.outputResolve(type, filePath);
+    if (paths === null)
+      return null;
+    await Promise.all(paths.map(async (path) => {
+      await writeFile(path, contents);
+      log.debug(`Generated ${type} file at ${relative2(this.cwd, path)}`);
+    }));
+    return paths;
+  }
+  supports(type) {
+    return this.getOutputs(type).length > 0;
+  }
+  type(type) {
+    return this.configFile[type];
+  }
+  get esm() {
+    return this.configFile["types" /* ESM */];
+  }
+  get docs() {
+    return this.configFile["docs" /* Docs */];
+  }
+  clarinetFile() {
+    return resolve2(this.cwd, this.configFile.clarinet);
+  }
+  joinFromClarinet(filePath) {
+    const baseDir = dirname2(this.clarinetFile());
+    return join(baseDir, filePath);
+  }
+};
+function configFilePath(cwd) {
+  return resolve2(cwd ?? process.cwd(), CONFIG_FILE);
+}
+var sessionConfig;
+async function getConfig(cwd) {
+  if (typeof sessionConfig !== "undefined")
+    return sessionConfig;
+  const path = configFilePath(cwd);
+  if (await fileExists(path)) {
+    const toml = await readFile2(path, "utf-8");
+    const parsedToml = parse2(toml);
+    const parseResult = ConfigFileSchema.safeParse(parsedToml);
+    if (parseResult.success) {
+      sessionConfig = parseResult.data;
+    } else {
+      logger.error("Error parsing Clarigen.toml:");
+      parseResult.error.errors.forEach((e) => {
+        logger.error(`${e.path.join(".")}: ${e.message}`);
+      });
+      throw new Error("Error parsing Clarigen.toml");
+    }
+  } else {
+    sessionConfig = defaultConfigFile;
+  }
+  return sessionConfig;
+}
+
+// src/commands/base-command.ts
+import { Command, Option } from "clipanion";
+import { ZodError } from "zod";
+var BaseCommand = class extends Command {
+  verbose = Option.Boolean("-v,--verbose", false, {
+    description: "Enable verbose logging"
+  });
+  preexecute() {
+    if (this.verbose) {
+      logger.level = "debug";
+    }
+  }
+  async catch(error) {
+    if (error instanceof ZodError) {
+      logger.error(error.issues, "Your configuration file is invalid.");
+      return;
+    }
+    logger.error(error);
+    if (error instanceof Error) {
+      logger.error(error.stack);
+    }
+    throw error;
+  }
+};
+
+// src/commands/session-info.ts
+var SessionInfoCommand = class extends BaseCommand {
+  cwd = Option2.String({ required: false });
+  async execute() {
+    this.preexecute();
+    const config = await Config.load(this.cwd);
+    logger.info(config);
+  }
+};
+__publicField(SessionInfoCommand, "paths", [["session-info"]]);
+__publicField(SessionInfoCommand, "usage", Command2.Usage({
+  description: "Log info about this project's Clarinet session"
+}));
+
+// src/commands/default-command.ts
+import { Command as Command3, Option as Option3 } from "clipanion";
+
+// src/clarinet-sdk.ts
+import { initSimnet } from "@hirosystems/clarinet-sdk";
+import {
+  MAINNET_BURN_ADDRESS,
+  TESTNET_BURN_ADDRESS,
+  getContractName as getContractName4
+} from "@clarigen/core";
+import { ClarityType } from "@stacks/transactions";
+import { readFile as readFile3 } from "fs/promises";
+
+// src/files/variables.ts
+import {
+  cvToValue,
+  getContractName as getContractName3
+} from "@clarigen/core";
+
+// src/declaration.ts
+import {
+  isClarityAbiBuffer,
+  isClarityAbiList,
+  isClarityAbiOptional,
+  isClarityAbiPrimitive,
+  isClarityAbiResponse,
+  isClarityAbiStringAscii,
+  isClarityAbiStringUtf8,
+  isClarityAbiTuple,
+  isClarityAbiTraitReference
+} from "@clarigen/core";
+import { toCamelCase as toCamelCase2 } from "@clarigen/core";
+var jsTypeFromAbiType = (val, isArgument = false) => {
+  if (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 (isClarityAbiBuffer(val)) {
+    return "Uint8Array";
+  } else if (isClarityAbiResponse(val)) {
+    const ok = jsTypeFromAbiType(val.response.ok, isArgument);
+    const err = jsTypeFromAbiType(val.response.error, isArgument);
+    return `Response<${ok}, ${err}>`;
+  } else if (isClarityAbiOptional(val)) {
+    const innerType = jsTypeFromAbiType(val.optional, isArgument);
+    return `${innerType} | null`;
+  } else if (isClarityAbiTuple(val)) {
+    const tupleDefs = [];
+    val.tuple.forEach(({ name, type }) => {
+      const camelName = toCamelCase2(name);
+      const innerType = jsTypeFromAbiType(type, isArgument);
+      tupleDefs.push(`"${camelName}": ${innerType};`);
+    });
+    return `{
+  ${tupleDefs.join("\n  ")}
+}`;
+  } else if (isClarityAbiList(val)) {
+    const innerType = jsTypeFromAbiType(val.list.type, isArgument);
+    return `${innerType}[]`;
+  } else if (isClarityAbiStringAscii(val)) {
+    return "string";
+  } else if (isClarityAbiStringUtf8(val)) {
+    return "string";
+  } else if (isClarityAbiTraitReference(val)) {
+    return "string";
+  } else {
+    throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);
+  }
+};
+function abiArgType(arg) {
+  const nativeType = jsTypeFromAbiType(arg.type, true);
+  const argName = getArgName(arg.name);
+  return `${argName}: TypedAbiArg<${nativeType}, "${argName}">`;
+}
+function abiFunctionType(abiFunction) {
+  const args2 = abiFunction.args.map(abiArgType);
+  const retType = jsTypeFromAbiType(abiFunction.outputs.type);
+  const argsTuple = `[${args2.join(", ")}]`;
+  return `TypedAbiFunction<${argsTuple}, ${retType}>`;
+}
+function getArgName(name) {
+  const camel = toCamelCase2(name);
+  const prefix = RESERVED[camel] ? "_" : "";
+  return `${prefix}${camel}`;
+}
+function _hash(...words) {
+  const h = {};
+  for (const word of words) {
+    h[word] = true;
+  }
+  return h;
+}
+var RESERVED = _hash("break", "do", "in", "typeof", "case", "else", "instanceof", "var", "catch", "export", "new", "void", "class", "extends", "return", "while", "const", "finally", "super", "with", "continue", "for", "switch", "yield", "debugger", "function", "this", "default", "if", "throw", "delete", "import", "try", "enum", "await", "null", "true", "false");
+
+// src/files/base.ts
+import { toCamelCase as toCamelCase3 } from "@clarigen/core";
+
+// src/files/accounts.ts
+function generateAccountsCode(session) {
+  const accounts = Object.fromEntries(session.accounts.map((account) => {
+    const _a = account, { name } = _a, rest = __objRest(_a, ["name"]);
+    return [name, rest];
+  }));
+  return `export const accounts = ${JSON.stringify(accounts)} as const;`;
+}
+
+// src/files/identifiers.ts
+import { getContractName as getContractName2 } from "@clarigen/core";
+function generateIdentifiers(session) {
+  const identifiers = Object.fromEntries(sortContracts(session.contracts).map((c) => {
+    const contractName = getContractName2(c.contract_id);
+    return [contractName, c.contract_id];
+  }));
+  return identifiers;
+}
+function generateIdentifiersCode(session) {
+  const identifiers = generateIdentifiers(session);
+  return `export const identifiers = ${JSON.stringify(identifiers)} as const`;
+}
+
+// src/files/base.ts
+import { inspect } from "util";
+function generateContractMeta(contract, constants) {
+  const abi = contract.contract_interface;
+  const functionLines = [];
+  const _a = abi, { functions, maps, variables, non_fungible_tokens } = _a, rest = __objRest(_a, ["functions", "maps", "variables", "non_fungible_tokens"]);
+  functions.forEach((func) => {
+    let functionLine = `${toCamelCase3(func.name)}: `;
+    const funcDef = JSON.stringify(func);
+    functionLine += funcDef;
+    const functionType = abiFunctionType(func);
+    functionLine += ` as ${functionType}`;
+    functionLines.push(functionLine);
+  });
+  const mapLines = maps.map((map) => {
+    let mapLine = `${toCamelCase3(map.name)}: `;
+    const keyType = jsTypeFromAbiType(map.key, true);
+    const valType = jsTypeFromAbiType(map.value);
+    mapLine += JSON.stringify(map);
+    mapLine += ` as TypedAbiMap<${keyType}, ${valType}>`;
+    return mapLine;
+  });
+  const otherAbi = JSON.stringify(rest);
+  const contractName = contract.contract_id.split(".")[1];
+  const variableLines = encodeVariables(variables);
+  const nftLines = non_fungible_tokens.map((nft) => {
+    return JSON.stringify(nft);
+  });
+  return `{
+  ${serializeLines("functions", functionLines)}
+  ${serializeLines("maps", mapLines)}
+  ${serializeLines("variables", variableLines)}
+  constants: ${constants},
+  ${serializeArray("non_fungible_tokens", nftLines)}
+  ${otherAbi.slice(1, -1)},
+  contractName: '${contractName}',
+  }`;
+}
+var TYPE_IMPORTS = `import type { TypedAbiArg, TypedAbiFunction, TypedAbiMap, TypedAbiVariable, Response } from '@clarigen/core';`;
+function generateBaseFile(session) {
+  const combined = session.contracts.map((c, i) => __spreadProps(__spreadValues({}, c), {
+    constants: session.variables[i]
+  }));
+  const contractDefs = sortContracts(combined).map((contract) => {
+    const meta = generateContractMeta(contract, contract.constants);
+    const id = contract.contract_id.split(".")[1];
+    const keyName = toCamelCase3(id);
+    return `${keyName}: ${meta}`;
+  });
+  const file = `
+${TYPE_IMPORTS}
+
+export const contracts = {
+  ${contractDefs.join(",\n")}
+} as const;
+
+${generateAccountsCode(session)}
+
+${generateIdentifiersCode(session)}
+
+export const simnet = {
+  accounts,
+  contracts,
+  identifiers,
+} as const;
+
+`;
+  return file;
+}
+function encodeVariables(variables) {
+  return variables.map((v) => {
+    let varLine = `${encodeVariableName(v.name)}: `;
+    const type = jsTypeFromAbiType(v.type);
+    const varJSON = serialize(v);
+    varLine += `${varJSON} as TypedAbiVariable<${type}>`;
+    return varLine;
+  });
+}
+Uint8Array.prototype[inspect.custom] = function(depth, options) {
+  return `Uint8Array.from([${this.join(",")}])`;
+};
+function serialize(obj) {
+  return inspect(obj, {
+    showHidden: false,
+    compact: false,
+    depth: 100,
+    colors: false,
+    maxArrayLength: Infinity,
+    maxStringLength: Infinity,
+    breakLength: Infinity,
+    numericSeparator: true
+  });
+}
+function serializeLines(key, lines) {
+  return `"${key}": {
+    ${lines.join(",\n    ")}
+  },`;
+}
+function serializeArray(key, lines) {
+  return `"${key}": [
+    ${lines.join(",\n    ")}
+  ],`;
+}
+
+// src/files/variables.ts
+function getVariablesV2(contract, simnet, verbose) {
+  const [deployer] = contract.contract_id.split(".");
+  const fakeId = `${getContractName3(contract.contract_id)}-vars`;
+  logger.debug(`Deploying ${contract.contract_id} for variables.`);
+  if (!contract.source) {
+    logger.debug(`Contract ${getContractName3(contract.contract_id)} has no source. Skipping variables.`);
+    return {};
+  }
+  if (contract.contract_interface.variables.length === 0) {
+    logger.info(`Contract ${getContractName3(contract.contract_id, false)} has no variables`);
+    return {};
+  }
+  let varFn = `{
+`;
+  const varLines = contract.contract_interface.variables.map((variable) => {
+    let varLine = `${variable.name}: `;
+    if (variable.access === "constant") {
+      varLine += `${variable.name}`;
+    } else {
+      varLine += `(var-get ${variable.name})`;
+    }
+    return varLine;
+  });
+  varFn += varLines.map((l) => ` ${l},`).join("\n");
+  varFn += "\n}";
+  const fullSrc = contract.source + `
+
+${varFn}`;
+  try {
+    const receipt = simnet.deployContract(fakeId, fullSrc, {
+      clarityVersion: 2
+    }, deployer);
+    const result = receipt.result;
+    const varsAbi = {
+      tuple: []
+    };
+    contract.contract_interface.variables.forEach((v) => {
+      const _v = v;
+      varsAbi.tuple.push({
+        type: _v.type,
+        name: _v.name
+      });
+    });
+    if (verbose) {
+      logger.info(cvToValue(result, true));
+    }
+    return cvToValue(result, true);
+  } catch (error) {
+    logger.error(`Error getting variables for ${getContractName3(contract.contract_id, false)}`);
+    logger.error(`Source code: ${contract.source} with type ${String(typeof contract.source)}`);
+    logger.error(error);
+    logger.error(fullSrc);
+    return {};
+  }
+}
+function mapVariables(session, simnet) {
+  return session.contracts.map((contract) => {
+    const vars = getVariablesV2(contract, simnet);
+    return serialize(vars);
+  });
+}
+
+// src/clarinet-sdk.ts
+async function getSession(config) {
+  const simnet = await initSimnet(config.clarinetFile());
+  const interfaces = simnet.getContractsInterfaces();
+  const accounts = simnet.getAccounts();
+  const allAccounts = [...accounts.entries()].map(([name, address]) => {
+    const result = simnet.runSnippet(`(stx-get-balance '${address})`);
+    if (result.type !== ClarityType.UInt) {
+      throw new Error(`Unexpected result type for \`(stx-get-balance \``);
+    }
+    return {
+      name,
+      address,
+      balance: result.value.toString()
+    };
+  });
+  const contracts = (await Promise.all([...interfaces.entries()].map(async ([contract_id, contract_interface]) => {
+    var _a, _b;
+    if (contract_id.startsWith(MAINNET_BURN_ADDRESS) || contract_id.startsWith(TESTNET_BURN_ADDRESS)) {
+      return void 0;
+    }
+    const name = getContractName4(contract_id, false);
+    const contractPathDef = (_b = (_a = config.clarinet.contracts) == null ? void 0 : _a[name]) == null ? void 0 : _b.path;
+    let source;
+    if (contractPathDef) {
+      const contractPathFull = config.joinFromClarinet(contractPathDef);
+      source = await readFile3(contractPathFull, "utf-8");
+    }
+    return {
+      contract_id,
+      contract_interface,
+      source: source ?? ""
+    };
+  }))).filter((x) => x !== void 0);
+  const session = {
+    session_id: 0,
+    accounts: allAccounts,
+    contracts
+  };
+  const variables = mapVariables(session, simnet);
+  return {
+    session_id: 0,
+    accounts: allAccounts,
+    contracts,
+    variables
+  };
+}
+
+// src/files/esm.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join2, dirname as dirname3, relative as relative3 } from "path";
+import { parse as parse3 } from "yaml";
+
+// src/deployments.ts
+function flatBatch(batches) {
+  const txs = [];
+  batches.forEach((batch) => txs.push(...batch.transactions));
+  return txs;
+}
+function getContractTxs(batches) {
+  const txs = flatBatch(batches);
+  return txs.filter(isContractTx);
+}
+function getDeploymentContract(contractName, deployment) {
+  const txs = flatBatch(deployment.plan.batches);
+  for (const tx of txs) {
+    if (!isContractTx(tx))
+      continue;
+    if ("requirement-publish" in tx) {
+      const [_, name] = tx["requirement-publish"]["contract-id"].split(".");
+      if (name === contractName) {
+        return tx;
+      }
+    } else if ("emulated-contract-publish" in tx) {
+      if (tx["emulated-contract-publish"]["contract-name"] === contractName) {
+        return tx;
+      }
+    } else if ("contract-publish" in tx) {
+      const contract = tx["contract-publish"];
+      if (contract["contract-name"] === contractName) {
+        return tx;
+      }
+    }
+  }
+  throw new Error(`Unable to find deployment tx for contract '${contractName}'`);
+}
+function getDeploymentTxPath(tx) {
+  if (!isContractTx(tx)) {
+    throw new Error("Unable to get path for tx type.");
+  }
+  if ("requirement-publish" in tx) {
+    return tx["requirement-publish"].path;
+  } else if ("emulated-contract-publish" in tx) {
+    const contract = tx["emulated-contract-publish"];
+    return contract.path;
+  } else if ("contract-publish" in tx) {
+    const contract = tx["contract-publish"];
+    return contract.path;
+  }
+  throw new Error("Couldnt get path for deployment tx.");
+}
+function getIdentifier(tx) {
+  if (!isContractTx(tx)) {
+    throw new Error("Unable to get ID for tx type.");
+  }
+  if ("requirement-publish" in tx) {
+    const spec = tx["requirement-publish"];
+    const [_, name] = spec["contract-id"].split(".");
+    return `${spec["remap-sender"]}.${name}`;
+  } else if ("emulated-contract-publish" in tx) {
+    const contract = tx["emulated-contract-publish"];
+    return `${contract["emulated-sender"]}.${contract["contract-name"]}`;
+  } else if ("contract-publish" in tx) {
+    const contract = tx["contract-publish"];
+    return `${contract["expected-sender"]}.${contract["contract-name"]}`;
+  }
+  throw new Error(`Unable to find ID for contract.`);
+}
+function isContractTx(tx) {
+  if ("contract-call" in tx)
+    return false;
+  if ("btc-transfer" in tx)
+    return false;
+  if ("emulated-contract-call" in tx)
+    return false;
+  return true;
+}
+
+// src/files/esm.ts
+import { getContractName as getContractName5 } from "@clarigen/core";
+import { spawn } from "child_process";
+async function parseDeployment(path) {
+  const contents = await readFile4(path, "utf-8");
+  const parsed = parse3(contents);
+  return parsed;
+}
+var DEPLOYMENT_NETWORKS = ["devnet", "simnet", "testnet", "mainnet"];
+async function getDeployments(config) {
+  const entries = await Promise.all(DEPLOYMENT_NETWORKS.map(async (network) => {
+    const file = `default.${network}-plan.yaml`;
+    const path = join2(dirname3(config.clarinetFile()), "deployments", file);
+    let plan;
+    try {
+      plan = await parseDeployment(path);
+    } catch (_) {
+    }
+    return [network, plan];
+  }));
+  return Object.fromEntries(entries);
+}
+async function generateESMFile({
+  baseFile,
+  session,
+  config
+}) {
+  const deployments = await getDeployments(config);
+  const contractDeployments = collectContractDeployments(session, deployments, config);
+  const simnet = generateSimnetCode(config, deployments, session);
+  return `${baseFile}
+export const deployments = ${JSON.stringify(contractDeployments)} as const;
+${simnet}
+export const project = {
+  contracts,
+  deployments,
+} as const;
+  `;
+}
+function insertNetworkId(deployments, identifier, network) {
+  const name = getContractName5(identifier);
+  if (!deployments[name]) {
+    return;
+  }
+  if (deployments[name][network] === null) {
+    deployments[name][network] = identifier;
+  }
+}
+function collectContractDeployments(session, deployments, config) {
+  var _a;
+  const full = Object.fromEntries(sortContracts(session.contracts).map((contract) => {
+    const contractName = getContractName5(contract.contract_id);
+    const contractDeployments = Object.fromEntries(DEPLOYMENT_NETWORKS.map((network) => {
+      const deployment = deployments[network];
+      if (typeof deployment === "undefined") {
+        return [network, null];
+      }
+      try {
+        const contractName2 = contract.contract_id.split(".")[1];
+        const tx = getDeploymentContract(contractName2, deployment);
+        const id = getIdentifier(tx);
+        return [network, id];
+      } catch (_) {
+        return [network, null];
+      }
+    }));
+    return [contractName, contractDeployments];
+  }));
+  const deployer = session.accounts.find((a) => a.name === "deployer");
+  (_a = config.clarinet.project.requirements) == null ? void 0 : _a.forEach(({ contract_id }) => {
+    insertNetworkId(full, contract_id, "mainnet");
+    const contractName = contract_id.split(".")[1];
+    if (deployer) {
+      const devnetId = `${deployer.address}.${contractName}`;
+      insertNetworkId(full, devnetId, "devnet");
+    }
+  });
+  session.contracts.forEach((contract) => {
+    insertNetworkId(full, contract.contract_id, "devnet");
+    insertNetworkId(full, contract.contract_id, "simnet");
+  });
+  return full;
+}
+function collectDeploymentFiles(deployments, clarinetFolder, cwd) {
+  if (!deployments.simnet)
+    return [];
+  const simnet = deployments.simnet;
+  const txs = getContractTxs(simnet.plan.batches);
+  const entries = txs.map((tx) => {
+    const id = getIdentifier(tx);
+    const contractFile = getDeploymentTxPath(tx);
+    return {
+      identifier: id,
+      file: relative3(cwd, join2(clarinetFolder, contractFile))
+    };
+  });
+  return entries;
+}
+function generateSimnetCode(config, deployments, _session) {
+  var _a;
+  if (!((_a = config.esm) == null ? void 0 : _a.include_accounts))
+    return "";
+  const clarinetFolder = dirname3(config.clarinetFile());
+  const files = collectDeploymentFiles(deployments, clarinetFolder, config.cwd);
+  return `
+export const simnetDeployment = ${JSON.stringify(files)};
+`;
+}
+async function afterESM(config) {
+  var _a;
+  const command = (_a = config.esm) == null ? void 0 : _a.after;
+  if (!command)
+    return;
+  logger.debug(`Running after ESM command: ${command}`);
+  const parts = command.split(" ");
+  const [cmd, ...args2] = parts;
+  return new Promise((resolve3, reject) => {
+    const child = spawn(cmd, args2, {
+      cwd: config.cwd,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(new Error(`Command failed with code ${code ?? "unknown"}`));
+      }
+    });
+  });
+}
+
+// src/commands/default-command.ts
+import chokidar from "chokidar";
+import { dirname as dirname4, join as join3, relative as relative4 } from "path";
+async function generate(config) {
+  const session = await getSession(config);
+  const baseFile = generateBaseFile(session);
+  if (config.supports("types" /* ESM */)) {
+    const esmFile = await generateESMFile({
+      baseFile,
+      session,
+      config
+    });
+    await config.writeOutput("types" /* ESM */, esmFile);
+    await afterESM(config);
+  }
+  if (!config.supports("types" /* ESM */)) {
+    logger.warn("no config for ESM outputs. Not outputting any generated types.");
+  }
+  logger.info("Types generated!");
+}
+async function watch(config, cwd) {
+  return new Promise((resolve3, reject) => {
+    const clarinetFolder = dirname4(config.clarinetFile());
+    const contractsFolder = join3(clarinetFolder, "/contracts/**/*.clar");
+    const relativeFolder = relative4(cwd || process.cwd(), contractsFolder);
+    logger.info(`Watching for changes in ${relativeFolder}`);
+    const watcher = chokidar.watch(contractsFolder, { persistent: true, cwd: clarinetFolder });
+    let running = false;
+    let start = 0;
+    const isVerbose = logger.level !== "info";
+    watcher.on("change", (path) => {
+      if (!running) {
+        start = Date.now();
+        logger.info(`File ${path} has been changed. Generating types.`);
+        running = true;
+        void generate(config).then(() => {
+          setTimeout(() => {
+            process.stdout.moveCursor(0, -1);
+            process.stdout.clearLine(1);
+            const elapsed = Date.now() - start;
+            logger.info(`Types generated (${(elapsed / 1e3).toFixed(2)}s). Watching for changes...`);
+            running = false;
+          });
+        });
+      }
+    });
+  });
+}
+var DefaultCommand = class extends BaseCommand {
+  cwd = Option3.String({
+    required: false
+  });
+  watch = Option3.Boolean("-w,--watch", {
+    description: "Watch for changes and regenerate types",
+    required: false
+  });
+  async execute() {
+    this.preexecute();
+    const config = await Config.load(this.cwd);
+    if (this.watch) {
+      await watch(config, this.cwd);
+    } else {
+      await generate(config);
+    }
+  }
+};
+__publicField(DefaultCommand, "paths", [Command3.Default, ["generate"]]);
+__publicField(DefaultCommand, "usage", Command3.Usage({
+  description: "Generate types for your Clarity contracts",
+  examples: [
+    ["Basic usage:", "clarigen"],
+    ["When your `Clarigen.toml` is in a different directory:", "clarigen /path/to/your/project"],
+    ["Watch for changes and regenerate types:", "clarigen --watch"]
+  ]
+}));
+
+// src/commands/docs-command.ts
+import { Option as Option4 } from "clipanion";
+
+// src/files/docs.ts
+import { getContractName as getContractName7 } from "@clarigen/core";
+import { relative as relative5, extname } from "path";
+
+// src/docs/markdown.ts
+import { getContractName as getContractName6 } from "@clarigen/core";
+
+// src/docs/index.ts
+import { spawn as spawn2 } from "child_process";
+var FN_TYPES = ["read-only", "public", "private"];
+var VAR_TYPES = ["map", "data-var", "constant"];
+function createContractDocInfo({
+  contractSrc,
+  abi
+}) {
+  const lines = contractSrc.split("\n");
+  let comments = [];
+  let parensCount = 0;
+  let currentFn;
+  const contract = {
+    comments: [],
+    functions: [],
+    variables: [],
+    maps: []
+  };
+  lines.forEach((line, lineNumber) => {
+    if (currentFn) {
+      currentFn.source.push(line);
+      parensCount = traceParens(line, parensCount);
+      if (parensCount === 0) {
+        pushItem(contract, currentFn);
+        currentFn = void 0;
+      }
+      return;
+    }
+    if (isComment(line)) {
+      const comment = line.replace(/^\s*;;\s*/g, "");
+      if (contract.comments.length === lineNumber) {
+        contract.comments.push(comment);
+      } else {
+        comments.push(comment);
+      }
+      return;
+    }
+    const name = findItemNameFromLine(line);
+    if (typeof name === "undefined") {
+      comments = [];
+    } else {
+      const abiFn = findAbiItemByName(abi, name);
+      if (!abiFn) {
+        console.debug(`[claridoc]: Unable to find ABI for function \`${name}\`. Probably a bug.`);
+        return;
+      }
+      parensCount = traceParens(line, 0);
+      const metaComments = parseComments(comments, abiFn);
+      currentFn = {
+        abi: abiFn,
+        comments: metaComments,
+        startLine: lineNumber,
+        source: [line]
+      };
+      if (parensCount === 0) {
+        pushItem(contract, currentFn);
+        currentFn = void 0;
+      }
+      comments = [];
+    }
+  });
+  return contract;
+}
+function pushItem(contract, item) {
+  if ("args" in item.abi) {
+    contract.functions.push(item);
+  } else if ("key" in item.abi) {
+    contract.maps.push(item);
+  } else if ("access" in item.abi) {
+    contract.variables.push(item);
+  }
+}
+function clarityNameMatcher(line) {
+  return /[\w|\-|\?|\!]+/.exec(line);
+}
+function findItemNameFromLine(line) {
+  const fnType = FN_TYPES.find((type) => {
+    return line.startsWith(`(define-${type}`);
+  });
+  if (fnType) {
+    const prefix = `(define-${fnType} (`;
+    const startString = line.slice(prefix.length);
+    const match = clarityNameMatcher(startString);
+    if (!match) {
+      console.debug(`[claridocs]: Unable to determine function name from line:
+  \`${line}\``);
+      return;
+    }
+    return match[0];
+  }
+  for (const type of VAR_TYPES) {
+    const prefix = `(define-${type} `;
+    if (!line.startsWith(prefix))
+      continue;
+    const startString = line.slice(prefix.length);
+    const match = clarityNameMatcher(startString);
+    if (!match) {
+      console.debug(`[claridocs]: Unable to determine ${type} name from line:
+  \`${line}\``);
+      return;
+    }
+    return match[0];
+  }
+  return void 0;
+}
+function findAbiItemByName(abi, name) {
+  const fn = abi.functions.find((fn2) => {
+    return fn2.name === name;
+  });
+  if (fn)
+    return fn;
+  const map = abi.maps.find((m) => m.name === name);
+  if (map)
+    return map;
+  const v = abi.variables.find((v2) => v2.name === name);
+  return v;
+}
+function isComment(line) {
+  return line.startsWith(";;");
+}
+function traceParens(line, count) {
+  let newCount = count;
+  line.split("").forEach((char) => {
+    if (char === "(")
+      newCount++;
+    if (char === ")")
+      newCount--;
+  });
+  return newCount;
+}
+function parseComments(comments, abi) {
+  let curParam;
+  const parsed = {
+    text: [],
+    params: {}
+  };
+  comments.forEach((line) => {
+    const paramMatches = /\s*@param\s([\w|\-]+)([;|-|\s]*)(.*)/.exec(line);
+    if (paramMatches === null) {
+      if (!curParam || line.trim() === "") {
+        curParam = void 0;
+        parsed.text.push(line);
+      } else {
+        parsed.params[curParam].comments.push(line);
+      }
+      return;
+    }
+    if (!("args" in abi))
+      return;
+    const [_full, name, _separator, rest] = paramMatches;
+    const arg = abi.args.find((arg2) => arg2.name === name);
+    if (!arg) {
+      console.debug(`[claridocs]: Unable to find ABI for @param ${name}`);
+      return;
+    }
+    curParam = name;
+    parsed.params[curParam] = {
+      abi: arg,
+      comments: [rest]
+    };
+  });
+  if ("args" in abi) {
+    abi.args.forEach((arg) => {
+      if (!parsed.params[arg.name]) {
+        parsed.params[arg.name] = {
+          abi: arg,
+          comments: []
+        };
+      }
+    });
+  }
+  return parsed;
+}
+async function afterDocs(config) {
+  var _a;
+  const command = (_a = config.docs) == null ? void 0 : _a.after;
+  if (!command)
+    return;
+  logger.debug(`Running after docs command: ${command}`);
+  const parts = command.split(" ");
+  const [cmd, ...args2] = parts;
+  return new Promise((resolve3, reject) => {
+    const child = spawn2(cmd, args2, {
+      cwd: config.cwd,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(new Error(`Command failed with code ${code ?? "unknown"}`));
+      }
+    });
+  });
+}
+
+// src/docs/markdown.ts
+import { basename } from "path";
+import { getTypeString } from "@stacks/transactions";
+function generateMarkdown({
+  contract,
+  contractFile,
+  withToc = true
+}) {
+  const contractName = getContractName6(contract.contract_id, false);
+  const doc = createContractDocInfo({
+    contractSrc: contract.source,
+    abi: contract.contract_interface
+  });
+  const functions = doc.functions.map((fn) => markdownFunction(fn, contractFile));
+  const maps = doc.maps.map((map) => markdownMap(map, contractFile));
+  const vars = doc.variables.filter((v) => v.abi.access === "variable").map((v) => markdownVar(v, contractFile));
+  const constants = doc.variables.filter((v) => v.abi.access === "constant").map((v) => markdownVar(v, contractFile));
+  let fileLine = "";
+  if (contractFile) {
+    const fileName = basename(contractFile);
+    fileLine = `
+[\`${fileName}\`](${contractFile})`;
+  }
+  return `
+# ${contractName}
+${fileLine}
+
+${doc.comments.join("\n\n")}
+
+${withToc ? markdownTOC(doc) : ""}
+
+## Functions
+
+${functions.join("\n\n")}
+
+## Maps
+
+${maps.join("\n\n")}
+
+## Variables
+
+${vars.join("\n\n")}
+
+## Constants
+
+${constants.join("\n\n")}
+  `;
+}
+function markdownFunction(fn, contractFile) {
+  const params = mdParams(fn);
+  const returnType = getTypeString(fn.abi.outputs.type);
+  const paramSigs = fn.abi.args.map((arg) => {
+    return `(${arg.name} ${getTypeString(arg.type)})`;
+  });
+  const startLine = fn.startLine + 1;
+  let link = "";
+  if (contractFile) {
+    link = `[View in file](${contractFile}#L${startLine})`;
+  }
+  const source = `<details>
+  <summary>Source code:</summary>
+
+\`\`\`clarity
+${fn.source.join("\n")}
+\`\`\`
+</details>
+`;
+  const sig = `(define-${fn.abi.access.replace("_", "-")} (${fn.abi.name} (${paramSigs.join(" ")}) ${returnType})`;
+  return `### ${fn.abi.name}
+
+${link}
+
+\`${sig}\`
+
+${fn.comments.text.join("\n")}
+
+${source}
+
+${params}`;
+}
+function mdParams(fn) {
+  if (fn.abi.args.length === 0)
+    return "";
+  const hasDescription = Object.values(fn.comments.params).some((p) => p.comments.length > 0);
+  const params = Object.values(fn.comments.params).map((p) => markdownParam(p, hasDescription));
+  return `**Parameters:**
+
+| Name | Type | ${hasDescription ? "Description |" : ""}
+| --- | --- | ${hasDescription ? "--- |" : ""}
+${params.join("\n")}`;
+}
+function markdownParam(param, withDescription) {
+  const typeString = getTypeString(param.abi.type);
+  const base = `| ${param.abi.name} | ${typeString} |`;
+  if (!withDescription)
+    return base;
+  return `${base} ${param.comments.join(" ")} |`;
+}
+function markdownMap(map, contractFile) {
+  const startLine = map.startLine + 1;
+  let link = "";
+  if (contractFile) {
+    link = `[View in file](${contractFile}#L${startLine})`;
+  }
+  return `### ${map.abi.name}
+
+${map.comments.text.join("\n")}
+
+\`\`\`clarity
+${map.source.join("\n")}
+\`\`\`
+
+${link}`;
+}
+function markdownVar(variable, contractFile) {
+  const startLine = variable.startLine + 1;
+  let link = "";
+  if (contractFile) {
+    link = `[View in file](${contractFile}#L${startLine})`;
+  }
+  const sig = variable.abi.access === "variable" ? getTypeString(variable.abi.type) : "";
+  return `### ${variable.abi.name}
+
+${sig}
+
+${variable.comments.text.join("\n")}
+
+\`\`\`clarity
+${variable.source.join("\n")}
+\`\`\`
+
+${link}`;
+}
+function markdownTOC(contract) {
+  const publics = contract.functions.filter((fn) => fn.abi.access === "public");
+  const readOnly = contract.functions.filter((fn) => fn.abi.access === "read_only");
+  const privates = contract.functions.filter((fn) => fn.abi.access === "private");
+  const maps = contract.maps;
+  const constants = contract.variables.filter((v) => v.abi.access === "constant");
+  const vars = contract.variables.filter((v) => v.abi.access === "variable");
+  function tocLine(fn) {
+    const name = fn.abi.name;
+    return `- [\`${name}\`](#${name.toLowerCase().replaceAll("?", "")})`;
+  }
+  return `**Public functions:**
+
+${publics.map(tocLine).join("\n")}
+
+**Read-only functions:**
+
+${readOnly.map(tocLine).join("\n")}
+
+**Private functions:**
+
+${privates.map(tocLine).join("\n")}
+
+**Maps**
+
+${maps.map(tocLine).join("\n")}
+
+**Variables**
+
+${vars.map(tocLine).join("\n")}
+
+**Constants**
+
+${constants.map(tocLine).join("\n")}
+`;
+}
+function generateReadme(session, excluded) {
+  const contractLines = [];
+  sortContracts(session.contracts).forEach((contract) => {
+    const name = getContractName6(contract.contract_id, false);
+    if (excluded[name])
+      return;
+    const fileName = `${name}.md`;
+    const line = `- [\`${name}\`](${fileName})`;
+    contractLines.push(line);
+  });
+  const fileContents = `# Contracts
+  
+  ${contractLines.join("\n")}
+  `;
+  return fileContents;
+}
+
+// src/files/docs.ts
+async function generateDocs({
+  session,
+  config
+}) {
+  const docs = config.configFile["docs" /* Docs */];
+  const docsBase = docs == null ? void 0 : docs.output;
+  if (!docsBase) {
+    warnNoDocs();
+    return;
+  }
+  const docsPathExt = extname(docsBase);
+  if (docsPathExt) {
+    log.warn(`Docs output path ('${docsBase}') looks like a file - it needs to be a directory.`);
+  }
+  const excluded = Object.fromEntries((docs.exclude || []).map((e) => {
+    return [e, true];
+  }));
+  log.debug(`Generating docs at path \`${docsBase}\``);
+  const docsBaseFolder = config.outputResolve("docs" /* Docs */, "./")[0];
+  const paths = await Promise.all(session.contracts.map(async (contract) => {
+    var _a, _b;
+    const name = getContractName7(contract.contract_id, false);
+    if (excluded[name])
+      return null;
+    const docFile = `${name}.md`;
+    const contractPathDef = (_b = (_a = config.clarinet.contracts) == null ? void 0 : _a[name]) == null ? void 0 : _b.path;
+    let contractFile;
+    if (contractPathDef) {
+      const contractPathFull = config.joinFromClarinet(contractPathDef);
+      contractFile = relative5(docsBaseFolder, contractPathFull);
+    } else {
+      log.debug(`Couldn't find contract file from Clarinet.toml for contract ${name}`);
+    }
+    const md = generateMarkdown({ contract, contractFile });
+    const path = await config.writeOutput("docs" /* Docs */, md, docFile);
+    return path[0];
+  }));
+  const readme = generateReadme(session, excluded);
+  paths.push((await config.writeOutput("docs" /* Docs */, readme, "README.md"))[0]);
+  await afterDocs(config);
+}
+function warnNoDocs() {
+  log.warn(`
+Clarigen config file doesn't include an output directory for docs.
+
+To generate docs, specify 'docs.output' in your config file:
+
+[docs]
+output = "docs/"
+  `.trimEnd());
+}
+
+// src/commands/docs-command.ts
+var DocsCommand = class extends BaseCommand {
+  cwd = Option4.String({ required: false });
+  async execute() {
+    this.preexecute();
+    const config = await Config.load(this.cwd);
+    const session = await getSession(config);
+    await generateDocs({
+      session: __spreadProps(__spreadValues({}, session), {
+        variables: []
+      }),
+      config
+    });
+  }
+};
+__publicField(DocsCommand, "paths", [["docs"]]);
+__publicField(DocsCommand, "usage", BaseCommand.Usage({
+  description: "Generate markdown documentation for your Clarity contracts"
+}));
+
+// src/commands/init-config-command.ts
+import { Option as Option5 } from "clipanion";
+import { writeFile as writeFile2 } from "fs/promises";
+
+// src/generated/init-config.ts
+var tomlInit = `
+# Set to your project's Clarinet config file
+clarinet = "./Clarinet.toml"
+
+# Set where you'd like TypeScript types output.
+# Comment or remove section to skip TypeScript types
+[types]
+# \`output\` should be a path to a single file
+output = "src/clarigen-types.ts"
+
+# You can also specify multiple output paths:
+# outputs = [
+#   "src/clarigen-types.ts",
+#   "test/clarigen-types.ts"
+# ]
+
+# \`types.after\` - script to run after TypeScript types are generated.
+# examples:
+# after = "npm run prettier -w ./src/clarigen-types.ts"
+# after = "echo 'yay'"
+
+# Set where you'd like generated contract docs
+# Generate docs by running \`clarigen docs\`
+[docs]
+# \`output\` should be a folder
+output = "docs"
+
+# \`docs.after\` - script to run after docs are generated.
+# examples:
+# after = "npm run prettier -w ./docs"
+`;
+
+// src/commands/init-config-command.ts
+var InitConfigCommand = class extends BaseCommand {
+  cwd = Option5.String({ required: false });
+  overwrite = Option5.Boolean("--overwrite", false, {
+    description: "Overwrite the configuration file if it already exists"
+  });
+  async execute() {
+    this.preexecute();
+    const path = configFilePath(this.cwd);
+    const configExists = await fileExists(path);
+    if (configExists && !this.overwrite) {
+      logger.warn("Configuration file already exists. Use --overwrite to overwrite it.");
+      return 1;
+    }
+    logger.debug(`Writing configuration file to ${path}`);
+    await writeFile2(path, tomlInit, "utf-8");
+  }
+};
+__publicField(InitConfigCommand, "paths", [["init-config"], ["init"]]);
+__publicField(InitConfigCommand, "usage", {
+  description: "Initialize a Clarigen configuration file"
+});
+
+// src/generated/version.ts
+var version = "2.0.1";
+
+// src/run-cli.ts
+var [node, script, ...args] = process.argv;
+var cli = new Cli({
+  binaryLabel: "Clarigen",
+  binaryName: "clarigen",
+  binaryVersion: version
+});
+cli.register(Builtins.HelpCommand);
+cli.register(Builtins.VersionCommand);
+cli.register(DefaultCommand);
+cli.register(DocsCommand);
+cli.register(InitConfigCommand);
+cli.register(SessionInfoCommand);
+async function run() {
+  await cli.runExit(args, Cli.defaultContext);
+}
+process.on("SIGINT", () => {
+  logger.info("Bye! \u{1F44B}");
+  process.exit();
+});
+run().catch(console.error).finally(() => {
+  process.exit();
+});
+//# sourceMappingURL=run-cli.js.map