@secondlayer/cli 0.1.1 → 0.2.0

package/dist/cli.cjs

@@ -1,897 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// node_modules/tsup/assets/cjs_shims.js
-var getImportMetaUrl, importMetaUrl;
-var init_cjs_shims = __esm({
-  "node_modules/tsup/assets/cjs_shims.js"() {
-    "use strict";
-    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
-    importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
-  }
-});
-
-// src/commands/init.ts
-var init_exports = {};
-__export(init_exports, {
-  init: () => init
-});
-async function init() {
-  const spinner = (0, import_ora2.default)("Initializing").start();
-  const configPath = import_path3.default.join(process.cwd(), "stacks.config.ts");
-  try {
-    await import_fs3.promises.access(configPath);
-    spinner.warn("stacks.config.ts already exists");
-    return;
-  } catch {
-  }
-  const hasClarinetProject = await fileExists("./Clarinet.toml");
-  let config;
-  if (hasClarinetProject) {
-    config = `import { defineConfig } from '@secondlayer/cli';
-import { clarinet } from '@secondlayer/cli/plugins';
-
-export default defineConfig({
-  out: './src/generated/contracts.ts',
-  plugins: [
-    clarinet() // Found Clarinet.toml in current directory
-  ]
-});`;
-  } else {
-    config = `import { defineConfig } from '@secondlayer/cli';
-
-export default defineConfig({
-  out: './src/generated/contracts.ts',
-  plugins: [],
-});`;
-  }
-  await import_fs3.promises.writeFile(configPath, config);
-  spinner.succeed("Created `stacks.config.ts`");
-  console.log(
-    "\nRun `secondlayer generate` to generate type-safe interfaces, functions, and hooks!"
-  );
-}
-async function fileExists(filePath) {
-  try {
-    await import_fs3.promises.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var import_fs3, import_path3, import_ora2;
-var init_init = __esm({
-  "src/commands/init.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_fs3 = require("fs");
-    import_path3 = __toESM(require("path"), 1);
-    import_ora2 = __toESM(require("ora"), 1);
-  }
-});
-
-// src/cli.ts
-init_cjs_shims();
-var import_commander = require("commander");
-
-// src/commands/generate.ts
-init_cjs_shims();
-var import_chalk = __toESM(require("chalk"), 1);
-var import_ora = __toESM(require("ora"), 1);
-
-// src/utils/config.ts
-init_cjs_shims();
-var import_fs2 = require("fs");
-var import_path2 = __toESM(require("path"), 1);
-var import_url = require("url");
-var import_module = require("module");
-var import_esbuild = require("esbuild");
-
-// src/core/plugin-manager.ts
-init_cjs_shims();
-var import_prettier = require("prettier");
-var import_fs = require("fs");
-var import_path = __toESM(require("path"), 1);
-var import_transactions = require("@stacks/transactions");
-var PluginManager = class {
-  constructor() {
-    this.plugins = [];
-    this.logger = this.createLogger();
-    this.utils = this.createUtils();
-    this.executionContext = {
-      phase: "config",
-      startTime: Date.now(),
-      results: /* @__PURE__ */ new Map()
-    };
-  }
-  /**
-   * Register a plugin
-   */
-  register(plugin) {
-    if (!plugin.name || !plugin.version) {
-      throw new Error("Plugin must have a name and version");
-    }
-    const existing = this.plugins.find((p) => p.name === plugin.name);
-    if (existing) {
-      throw new Error(
-        `Plugin "${plugin.name}" is already registered (version ${existing.version})`
-      );
-    }
-    this.plugins.push(plugin);
-    this.logger.debug(`Registered plugin: ${plugin.name}@${plugin.version}`);
-  }
-  /**
-   * Get all registered plugins
-   */
-  getPlugins() {
-    return [...this.plugins];
-  }
-  /**
-   * Transform user config through all plugins
-   */
-  async transformConfig(config) {
-    this.executionContext.phase = "config";
-    let transformedConfig = { ...config };
-    for (const plugin of this.plugins) {
-      if (plugin.transformConfig) {
-        this.executionContext.currentPlugin = plugin;
-        try {
-          const result = await plugin.transformConfig(transformedConfig);
-          transformedConfig = result;
-          this.recordHookResult(plugin.name, "transformConfig", {
-            success: true
-          });
-        } catch (error) {
-          const err = error;
-          this.recordHookResult(plugin.name, "transformConfig", {
-            success: false,
-            error: err
-          });
-          throw new Error(
-            `Plugin "${plugin.name}" failed during config transformation: ${err.message}`
-          );
-        }
-      }
-    }
-    const resolvedConfig = {
-      ...transformedConfig,
-      plugins: this.plugins
-    };
-    return resolvedConfig;
-  }
-  /**
-   * Transform contracts through all plugins
-   */
-  async transformContracts(contracts, _config) {
-    const processedContracts = [];
-    for (let contract of contracts) {
-      if (contract._clarinetSource && contract.abi) {
-        const address = typeof contract.address === "string" ? contract.address : "";
-        const [contractAddress, contractName] = address.split(".");
-        const processed = {
-          name: contract.name || contractName,
-          address: contractAddress,
-          contractName,
-          abi: contract.abi,
-          source: "local",
-          metadata: { source: "clarinet" }
-        };
-        processedContracts.push(processed);
-        continue;
-      }
-      for (const plugin of this.plugins) {
-        if (plugin.transformContract) {
-          this.executionContext.currentPlugin = plugin;
-          try {
-            contract = await plugin.transformContract(contract);
-            this.recordHookResult(plugin.name, "transformContract", {
-              success: true
-            });
-          } catch (error) {
-            const err = error;
-            this.recordHookResult(plugin.name, "transformContract", {
-              success: false,
-              error: err
-            });
-            this.logger.warn(
-              `Plugin "${plugin.name}" failed to transform contract: ${err.message}`
-            );
-          }
-        }
-      }
-      if (contract.abi) {
-        const processed = {
-          name: contract.name || "unknown",
-          address: typeof contract.address === "string" ? contract.address.split(".")[0] : "unknown",
-          contractName: contract.name || "unknown",
-          abi: contract.abi,
-          source: "api",
-          // Use "api" as default for plugin-processed contracts
-          metadata: contract.metadata
-        };
-        processedContracts.push(processed);
-      }
-    }
-    return processedContracts;
-  }
-  /**
-   * Execute lifecycle hooks
-   */
-  async executeHook(hookName, context) {
-    for (const plugin of this.plugins) {
-      const hook = plugin[hookName];
-      if (typeof hook === "function") {
-        this.executionContext.currentPlugin = plugin;
-        try {
-          await hook.call(plugin, context);
-          this.recordHookResult(plugin.name, hookName, {
-            success: true
-          });
-        } catch (error) {
-          const err = error;
-          this.recordHookResult(plugin.name, hookName, {
-            success: false,
-            error: err
-          });
-          this.logger.error(
-            `Plugin "${plugin.name}" failed during ${hookName}: ${err.message}`
-          );
-        }
-      }
-    }
-  }
-  /**
-   * Execute generation phase with full context
-   */
-  async executeGeneration(contracts, config) {
-    this.executionContext.phase = "generate";
-    const outputs = /* @__PURE__ */ new Map();
-    const context = {
-      config,
-      logger: this.logger,
-      utils: this.utils,
-      contracts,
-      outputs,
-      augment: (outputKey, contractName, content) => {
-        this.augmentOutput(outputs, outputKey, contractName, content);
-      },
-      addOutput: (key, output) => {
-        outputs.set(key, output);
-      }
-    };
-    await this.executeHook("beforeGenerate", context);
-    await this.executeHook("generate", context);
-    await this.executeHook("afterGenerate", context);
-    return outputs;
-  }
-  /**
-   * Transform outputs through plugins
-   */
-  async transformOutputs(outputs) {
-    this.executionContext.phase = "output";
-    const transformedOutputs = /* @__PURE__ */ new Map();
-    for (const [key, output] of outputs) {
-      let transformedContent = output.content;
-      for (const plugin of this.plugins) {
-        if (plugin.transformOutput) {
-          this.executionContext.currentPlugin = plugin;
-          try {
-            transformedContent = await plugin.transformOutput(
-              transformedContent,
-              output.type || "other"
-            );
-            this.recordHookResult(plugin.name, "transformOutput", {
-              success: true
-            });
-          } catch (error) {
-            const err = error;
-            this.recordHookResult(plugin.name, "transformOutput", {
-              success: false,
-              error: err
-            });
-            this.logger.warn(
-              `Plugin "${plugin.name}" failed to transform output: ${err.message}`
-            );
-          }
-        }
-      }
-      transformedOutputs.set(key, {
-        ...output,
-        content: transformedContent
-      });
-    }
-    return transformedOutputs;
-  }
-  /**
-   * Write outputs to disk
-   */
-  async writeOutputs(outputs) {
-    for (const [, output] of outputs) {
-      try {
-        const resolvedPath = import_path.default.resolve(process.cwd(), output.path);
-        await this.utils.ensureDir(import_path.default.dirname(resolvedPath));
-        await this.utils.writeFile(resolvedPath, output.content);
-      } catch (error) {
-        const err = error;
-        this.logger.error(`Failed to write ${output.path}: ${err.message}`);
-        throw err;
-      }
-    }
-  }
-  /**
-   * Get execution results for debugging
-   */
-  getExecutionResults() {
-    return new Map(this.executionContext.results);
-  }
-  /**
-   * Augment existing output with additional content
-   */
-  augmentOutput(outputs, outputKey, contractName, content) {
-    const existing = outputs.get(outputKey);
-    if (!existing) {
-      this.logger.warn(`Cannot augment non-existent output: ${outputKey}`);
-      return;
-    }
-    const augmentedContent = `${existing.content}
-
-// Augmented by plugin for ${contractName}
-${JSON.stringify(content, null, 2)}`;
-    outputs.set(outputKey, {
-      ...existing,
-      content: augmentedContent
-    });
-  }
-  /**
-   * Record hook execution result
-   */
-  recordHookResult(pluginName, hookName, result) {
-    const key = `${pluginName}:${hookName}`;
-    const existing = this.executionContext.results.get(key) || [];
-    existing.push({ ...result, plugin: pluginName });
-    this.executionContext.results.set(key, existing);
-  }
-  /**
-   * Create logger instance
-   */
-  createLogger() {
-    return {
-      info: (message) => console.log(`\u2139\uFE0F  ${message}`),
-      warn: (message) => console.warn(`\u26A0\uFE0F  ${message}`),
-      error: (message) => console.error(`\u274C ${message}`),
-      debug: (message) => {
-        if (process.env.DEBUG) {
-          console.log(`\u{1F41B} ${message}`);
-        }
-      },
-      success: (message) => console.log(`\u2705 ${message}`)
-    };
-  }
-  /**
-   * Create utils instance
-   */
-  createUtils() {
-    return {
-      toCamelCase: (str) => {
-        return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-      },
-      toKebabCase: (str) => {
-        return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-      },
-      validateAddress: (address) => {
-        return (0, import_transactions.validateStacksAddress)(address.split(".")[0]);
-      },
-      parseContractId: (contractId) => {
-        const [address, contractName] = contractId.split(".");
-        return { address, contractName };
-      },
-      formatCode: async (code) => {
-        return (0, import_prettier.format)(code, {
-          parser: "typescript",
-          singleQuote: true,
-          semi: true,
-          printWidth: 100,
-          trailingComma: "es5"
-        });
-      },
-      resolvePath: (relativePath) => {
-        return import_path.default.resolve(process.cwd(), relativePath);
-      },
-      fileExists: async (filePath) => {
-        try {
-          await import_fs.promises.access(filePath);
-          return true;
-        } catch {
-          return false;
-        }
-      },
-      readFile: async (filePath) => {
-        return import_fs.promises.readFile(filePath, "utf-8");
-      },
-      writeFile: async (filePath, content) => {
-        await import_fs.promises.writeFile(filePath, content, "utf-8");
-      },
-      ensureDir: async (dirPath) => {
-        await import_fs.promises.mkdir(dirPath, { recursive: true });
-      }
-    };
-  }
-};
-
-// src/utils/config.ts
-var CONFIG_FILE_NAMES = [
-  "stacks.config.ts",
-  "stacks.config.js",
-  "stacks.config.mjs"
-];
-async function findConfigFile(cwd) {
-  for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = import_path2.default.join(cwd, fileName);
-    try {
-      await import_fs2.promises.access(filePath);
-      return filePath;
-    } catch {
-    }
-  }
-  return null;
-}
-async function loadConfig(configPath) {
-  const cwd = process.cwd();
-  const resolvedPath = configPath ? import_path2.default.resolve(cwd, configPath) : await findConfigFile(cwd);
-  if (!resolvedPath) {
-    throw new Error(
-      "No config file found. Create a stacks.config.ts file or specify a path with --config"
-    );
-  }
-  let config;
-  if (resolvedPath.endsWith(".ts")) {
-    const code = await import_fs2.promises.readFile(resolvedPath, "utf-8");
-    let replacementPath;
-    try {
-      const require2 = (0, import_module.createRequire)(importMetaUrl);
-      const packagePath = require2.resolve("@secondlayer/cli");
-      replacementPath = (0, import_url.pathToFileURL)(packagePath).href;
-    } catch {
-      const currentModuleDir = import_path2.default.dirname(new URL(importMetaUrl).pathname);
-      const indexPath = import_path2.default.resolve(currentModuleDir, "../index.js");
-      replacementPath = (0, import_url.pathToFileURL)(indexPath).href;
-    }
-    const transformedCode = code.replace(
-      /from\s+["']@stacks\/cli["']/g,
-      `from '${replacementPath}'`
-    );
-    const result = (0, import_esbuild.transformSync)(transformedCode, {
-      format: "esm",
-      target: "node18",
-      loader: "ts"
-    });
-    const tempPath = resolvedPath.replace(/\.ts$/, ".mjs");
-    await import_fs2.promises.writeFile(tempPath, result.code);
-    try {
-      const fileUrl = (0, import_url.pathToFileURL)(tempPath).href;
-      const module2 = await import(fileUrl);
-      config = module2.default;
-    } finally {
-      await import_fs2.promises.unlink(tempPath).catch(() => {
-      });
-    }
-  } else {
-    const fileUrl = (0, import_url.pathToFileURL)(resolvedPath).href;
-    const module2 = await import(fileUrl);
-    config = module2.default;
-  }
-  if (!config) {
-    throw new Error("Config file must export a default configuration");
-  }
-  if (typeof config === "function") {
-    config = config({});
-  }
-  validateConfig(config);
-  const pluginManager = new PluginManager();
-  if (config.plugins && Array.isArray(config.plugins)) {
-    for (const plugin of config.plugins) {
-      pluginManager.register(plugin);
-    }
-  }
-  const resolvedConfig = await pluginManager.transformConfig(config);
-  return resolvedConfig;
-}
-function validateConfig(config) {
-  if (!config || typeof config !== "object") {
-    throw new Error("Config must be an object");
-  }
-  const c = config;
-  if (c.contracts && !Array.isArray(c.contracts)) {
-    throw new Error("Config contracts must be an array");
-  }
-  if (!c.out || typeof c.out !== "string") {
-    throw new Error("Config out must be a string path");
-  }
-  if (c.contracts) {
-    for (const contract of c.contracts) {
-      if (!contract.address && !contract.source) {
-        throw new Error("Each contract must have either an address or source");
-      }
-    }
-  }
-  if (c.plugins && !Array.isArray(c.plugins)) {
-    throw new Error("Config plugins must be an array");
-  }
-}
-
-// src/utils/api.ts
-init_cjs_shims();
-var import_got = __toESM(require("got"), 1);
-
-// src/parsers/clarity.ts
-init_cjs_shims();
-
-// src/generators/contract.ts
-init_cjs_shims();
-var import_prettier2 = require("prettier");
-async function generateContractInterface(contracts) {
-  const imports = `import { Cl, validateStacksAddress } from '@stacks/transactions'`;
-  const header = `/**
- * Generated by @secondlayer/cli
- * DO NOT EDIT MANUALLY
- */`;
-  const contractsCode = contracts.map((contract) => generateContract(contract)).join("\n\n");
-  const code = `${imports}
-
-${header}
-
-${contractsCode}`;
-  const formatted = await (0, import_prettier2.format)(code, {
-    parser: "typescript",
-    singleQuote: true,
-    semi: true,
-    printWidth: 100,
-    trailingComma: "es5"
-  });
-  return formatted;
-}
-function generateContract(contract) {
-  const { name, address, contractName, abi } = contract;
-  const abiCode = generateAbiConstant(name, abi);
-  const methods = abi.functions.filter((func) => func.access !== "private").map((func) => generateMethod(func, address, contractName)).join(",\n\n  ");
-  const contractCode = `export const ${name} = {
-  address: '${address}',
-  contractAddress: '${address}',
-  contractName: '${contractName}',
-  
-  ${methods}
-} as const`;
-  return `${abiCode}
-
-${contractCode}`;
-}
-function generateAbiConstant(name, abi) {
-  const abiJson = JSON.stringify(abi, null, 2).replace(/"([a-zA-Z_$][a-zA-Z0-9_$]*)":/g, "$1:").replace(/"/g, "'");
-  return `export const ${name}Abi = ${abiJson} as const`;
-}
-function generateMethod(func, address, contractName) {
-  const methodName = toCamelCase(func.name);
-  if (func.args.length === 0) {
-    return `${methodName}() {
-    return {
-      contractAddress: '${address}',
-      contractName: '${contractName}',
-      functionName: '${func.name}',
-      functionArgs: []
-    }
-  }`;
-  }
-  if (func.args.length === 1) {
-    const originalArgName = func.args[0].name;
-    const argName = toCamelCase(originalArgName);
-    const argType = getTypeForArg(func.args[0]);
-    const clarityConversion = generateClarityConversion(argName, func.args[0]);
-    return `${methodName}(...args: [{ ${argName}: ${argType} }] | [${argType}]) {
-    const ${argName} = args.length === 1 && typeof args[0] === 'object' && args[0] !== null && '${argName}' in args[0]
-      ? args[0].${argName}
-      : args[0] as ${argType}
-    
-    return {
-      contractAddress: '${address}',
-      contractName: '${contractName}',
-      functionName: '${func.name}',
-      functionArgs: [${clarityConversion}]
-    }
-  }`;
-  }
-  const argsList = func.args.map((arg) => toCamelCase(arg.name)).join(", ");
-  const argsTypes = func.args.map((arg) => {
-    const camelName = toCamelCase(arg.name);
-    return `${camelName}: ${getTypeForArg(arg)}`;
-  }).join("; ");
-  const argsArray = func.args.map((arg) => {
-    const argName = toCamelCase(arg.name);
-    return generateClarityConversion(argName, arg);
-  }).join(", ");
-  const objectAccess = func.args.map((arg) => {
-    const camelName = toCamelCase(arg.name);
-    return `args[0].${camelName}`;
-  }).join(", ");
-  const positionTypes = func.args.map((arg) => getTypeForArg(arg)).join(", ");
-  return `${methodName}(...args: [{ ${argsTypes} }] | [${positionTypes}]) {
-    const [${argsList}] = args.length === 1 && typeof args[0] === 'object' && args[0] !== null
-      ? [${objectAccess}]
-      : args as [${positionTypes}]
-    
-    return {
-      contractAddress: '${address}',
-      contractName: '${contractName}',
-      functionName: '${func.name}',
-      functionArgs: [${argsArray}]
-    }
-  }`;
-}
-function getTypeForArg(arg) {
-  const type = arg.type;
-  if (typeof type === "string") {
-    switch (type) {
-      case "uint128":
-      case "int128":
-        return "bigint";
-      case "bool":
-        return "boolean";
-      case "principal":
-      case "trait_reference":
-        return "string";
-      default:
-        return "any";
-    }
-  }
-  if (type["string-ascii"] || type["string-utf8"]) {
-    return "string";
-  }
-  if (type.buff) {
-    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
-  }
-  if (type.optional) {
-    const innerType = getTypeForArg({ type: type.optional });
-    return `${innerType} | null`;
-  }
-  if (type.list) {
-    const innerType = getTypeForArg({ type: type.list.type });
-    return `${innerType}[]`;
-  }
-  if (type.tuple) {
-    const fields = type.tuple.map(
-      (field) => `${toCamelCase(field.name)}: ${getTypeForArg({ type: field.type })}`
-    ).join("; ");
-    return `{ ${fields} }`;
-  }
-  if (type.response) {
-    const okType = getTypeForArg({ type: type.response.ok });
-    const errType = getTypeForArg({ type: type.response.error });
-    return `{ ok: ${okType} } | { err: ${errType} }`;
-  }
-  return "any";
-}
-function toCamelCase(str) {
-  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "");
-}
-function generateClarityConversion(argName, argType) {
-  const type = argType.type;
-  if (typeof type === "string") {
-    switch (type) {
-      case "uint128":
-        return `Cl.uint(${argName})`;
-      case "int128":
-        return `Cl.int(${argName})`;
-      case "bool":
-        return `Cl.bool(${argName})`;
-      case "principal":
-      case "trait_reference":
-        return `(() => {
-          const [address, contractName] = ${argName}.split(".") as [string, string];
-          if (!validateStacksAddress(address)) {
-            throw new Error("Invalid Stacks address format");
-          }
-          if (${argName}.includes(".")) {
-            return Cl.contractPrincipal(address, contractName);
-          } else {
-            return Cl.standardPrincipal(${argName});
-          }
-        })()`;
-      default:
-        return `${argName}`;
-    }
-  }
-  if (type["string-ascii"]) {
-    return `Cl.stringAscii(${argName})`;
-  }
-  if (type["string-utf8"]) {
-    return `Cl.stringUtf8(${argName})`;
-  }
-  if (type.buff) {
-    return `(() => {
-      const value = ${argName};
-      // Direct Uint8Array
-      if (value instanceof Uint8Array) {
-        return Cl.buffer(value);
-      }
-      // Object notation with explicit type
-      if (typeof value === 'object' && value !== null && value.type && value.value) {
-        switch (value.type) {
-          case 'ascii':
-            return Cl.bufferFromAscii(value.value);
-          case 'utf8':
-            return Cl.bufferFromUtf8(value.value);
-          case 'hex':
-            return Cl.bufferFromHex(value.value);
-          default:
-            throw new Error(\`Unsupported buffer type: \${value.type}\`);
-        }
-      }
-      // Auto-detect string type
-      if (typeof value === 'string') {
-        // Check for hex (0x prefix or pure hex pattern)
-        if (value.startsWith('0x') || /^[0-9a-fA-F]+$/.test(value)) {
-          return Cl.bufferFromHex(value);
-        }
-        // Check for non-ASCII characters (UTF-8)
-        if (!/^[\\x00-\\x7F]*$/.test(value)) {
-          return Cl.bufferFromUtf8(value);
-        }
-        // Default to ASCII for simple ASCII strings
-        return Cl.bufferFromAscii(value);
-      }
-      throw new Error(\`Invalid buffer value: \${value}\`);
-    })()`;
-  }
-  if (type.optional) {
-    const innerConversion = generateClarityConversion(argName, {
-      type: type.optional
-    });
-    return `${argName} !== null ? Cl.some(${innerConversion.replace(argName, `${argName}`)}) : Cl.none()`;
-  }
-  if (type.list) {
-    const innerConversion = generateClarityConversion("item", {
-      type: type.list.type
-    });
-    return `Cl.list(${argName}.map(item => ${innerConversion}))`;
-  }
-  if (type.tuple) {
-    const fields = type.tuple.map((field) => {
-      const camelFieldName = toCamelCase(field.name);
-      const fieldConversion = generateClarityConversion(
-        `${argName}.${camelFieldName}`,
-        { type: field.type }
-      );
-      return `"${field.name}": ${fieldConversion}`;
-    }).join(", ");
-    return `Cl.tuple({ ${fields} })`;
-  }
-  if (type.response) {
-    const okConversion = generateClarityConversion(`${argName}.ok`, {
-      type: type.response.ok
-    });
-    const errConversion = generateClarityConversion(`${argName}.err`, {
-      type: type.response.error
-    });
-    return `'ok' in ${argName} ? Cl.ok(${okConversion.replace(`${argName}.ok`, `${argName}.ok`)}) : Cl.error(${errConversion.replace(`${argName}.err`, `${argName}.err`)})`;
-  }
-  return `${argName}`;
-}
-
-// src/commands/generate.ts
-async function generate(options) {
-  const spinner = (0, import_ora.default)("Processing contracts").start();
-  try {
-    const config = await loadConfig(options.config);
-    const pluginManager = new PluginManager();
-    if (config.plugins) {
-      for (const plugin of config.plugins) {
-        pluginManager.register(plugin);
-      }
-    }
-    await pluginManager.executeHook("configResolved", config);
-    const contractConfigs = (config.contracts || []).map(
-      (contract) => ({
-        name: contract.name,
-        address: contract.address,
-        source: contract.source,
-        abi: contract.abi,
-        // Include ABI if it exists (from plugins)
-        _clarinetSource: contract._clarinetSource
-        // Include plugin flags
-      })
-    );
-    const processedContracts = await pluginManager.transformContracts(
-      contractConfigs,
-      config
-    );
-    if (processedContracts.length === 0) {
-      spinner.warn("No contracts found to generate");
-      console.log("\nTo get started:");
-      console.log("  \u2022 Add contracts to your config file, or");
-      console.log("  \u2022 Use plugins like clarinet() for local contracts");
-      return;
-    }
-    const outputs = await pluginManager.executeGeneration(
-      processedContracts,
-      config
-    );
-    if (!outputs.has("contracts") && processedContracts.length > 0) {
-      const contractsCode = await generateContractInterface(processedContracts);
-      outputs.set("contracts", {
-        path: config.out,
-        content: contractsCode,
-        type: "contracts"
-      });
-    }
-    const transformedOutputs = await pluginManager.transformOutputs(outputs);
-    await pluginManager.writeOutputs(transformedOutputs);
-    const contractCount = processedContracts.length;
-    const contractWord = contractCount === 1 ? "contract" : "contracts";
-    spinner.succeed(`Generation complete for ${contractCount} ${contractWord}`);
-    console.log(`
-\u{1F4C4} ${config.out}`);
-    console.log(`
-\u{1F4A1} Import your contracts:`);
-    if (processedContracts.length > 0) {
-      const exampleContract = processedContracts[0];
-      console.log(
-        import_chalk.default.gray(
-          `   import { ${exampleContract.name} } from '${config.out.replace(/\.ts$/, "")}'`
-        )
-      );
-      if (processedContracts.length > 1) {
-        console.log(
-          import_chalk.default.gray(
-            `   // Also available: ${processedContracts.slice(1).map((c) => c.name).join(", ")}`
-          )
-        );
-      }
-    }
-  } catch (error) {
-    spinner.fail("Generation failed");
-    console.error(import_chalk.default.red(`
-${error.message}`));
-    if (process.env.DEBUG) {
-      console.error(error.stack);
-    }
-    process.exit(1);
-  }
-}
-
-// src/cli.ts
-import_commander.program.name("stacks").description("CLI tool for generating type-safe Stacks contract interfaces").version("0.1.0");
-import_commander.program.command("generate").alias("gen").description("Generate TypeScript interfaces from Clarity contracts").option("-c, --config <path>", "Path to config file").option("-w, --watch", "Watch for changes").action(generate);
-import_commander.program.command("init").description("Initialize a new stacks.config.ts file").action(async () => {
-  const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-  await init2();
-});
-import_commander.program.parse();
-//# sourceMappingURL=cli.cjs.map