@secondlayer/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,874 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  init: () => init
+});
+import { promises as fs3 } from "fs";
+import path4 from "path";
+import ora2 from "ora";
+async function init() {
+  const spinner = ora2("Initializing").start();
+  const configPath = path4.join(process.cwd(), "stacks.config.ts");
+  try {
+    await fs3.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 '@stacks/codegen';
+import { clarinet } from '@stacks/codegen/plugins';
+
+export default defineConfig({
+  out: './src/generated/contracts.ts',
+  plugins: [
+    clarinet() // Found Clarinet.toml in current directory
+  ]
+});`;
+  } else {
+    config = `import { defineConfig } from '@stacks/codegen';
+
+export default defineConfig({
+  out: './src/generated/contracts.ts',
+  plugins: [],
+});`;
+  }
+  await fs3.writeFile(configPath, config);
+  spinner.succeed("Created `stacks.config.ts`");
+  console.log(
+    "\nRun `codegen generate` to generate type-safe interfaces, functions, and hooks!"
+  );
+}
+async function fileExists(filePath) {
+  try {
+    await fs3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli.ts
+init_esm_shims();
+import { program } from "commander";
+
+// src/commands/generate.ts
+init_esm_shims();
+import chalk from "chalk";
+import ora from "ora";
+
+// src/utils/config.ts
+init_esm_shims();
+import { promises as fs2 } from "fs";
+import path3 from "path";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+import { transformSync } from "esbuild";
+
+// src/core/plugin-manager.ts
+init_esm_shims();
+import { format } from "prettier";
+import { promises as fs } from "fs";
+import path2 from "path";
+import { validateStacksAddress } from "@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 = path2.resolve(process.cwd(), output.path);
+        await this.utils.ensureDir(path2.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 validateStacksAddress(address.split(".")[0]);
+      },
+      parseContractId: (contractId) => {
+        const [address, contractName] = contractId.split(".");
+        return { address, contractName };
+      },
+      formatCode: async (code) => {
+        return format(code, {
+          parser: "typescript",
+          singleQuote: true,
+          semi: true,
+          printWidth: 100,
+          trailingComma: "es5"
+        });
+      },
+      resolvePath: (relativePath) => {
+        return path2.resolve(process.cwd(), relativePath);
+      },
+      fileExists: async (filePath) => {
+        try {
+          await fs.access(filePath);
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      readFile: async (filePath) => {
+        return fs.readFile(filePath, "utf-8");
+      },
+      writeFile: async (filePath, content) => {
+        await fs.writeFile(filePath, content, "utf-8");
+      },
+      ensureDir: async (dirPath) => {
+        await fs.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 = path3.join(cwd, fileName);
+    try {
+      await fs2.access(filePath);
+      return filePath;
+    } catch {
+    }
+  }
+  return null;
+}
+async function loadConfig(configPath) {
+  const cwd = process.cwd();
+  const resolvedPath = configPath ? path3.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 fs2.readFile(resolvedPath, "utf-8");
+    let replacementPath;
+    try {
+      const require2 = createRequire(import.meta.url);
+      const packagePath = require2.resolve("@stacks/codegen");
+      replacementPath = pathToFileURL(packagePath).href;
+    } catch {
+      const currentModuleDir = path3.dirname(new URL(import.meta.url).pathname);
+      const indexPath = path3.resolve(currentModuleDir, "../index.js");
+      replacementPath = pathToFileURL(indexPath).href;
+    }
+    const transformedCode = code.replace(
+      /from\s+["']@stacks\/cli["']/g,
+      `from '${replacementPath}'`
+    );
+    const result = transformSync(transformedCode, {
+      format: "esm",
+      target: "node18",
+      loader: "ts"
+    });
+    const tempPath = resolvedPath.replace(/\.ts$/, ".mjs");
+    await fs2.writeFile(tempPath, result.code);
+    try {
+      const fileUrl = pathToFileURL(tempPath).href;
+      const module = await import(fileUrl);
+      config = module.default;
+    } finally {
+      await fs2.unlink(tempPath).catch(() => {
+      });
+    }
+  } else {
+    const fileUrl = pathToFileURL(resolvedPath).href;
+    const module = await import(fileUrl);
+    config = module.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_esm_shims();
+import got from "got";
+
+// src/parsers/clarity.ts
+init_esm_shims();
+
+// src/generators/contract.ts
+init_esm_shims();
+import { format as format2 } from "prettier";
+async function generateContractInterface(contracts) {
+  const imports = `import { Cl, validateStacksAddress } from '@stacks/transactions'`;
+  const header = `/**
+ * Generated by @stacks/codegen
+ * DO NOT EDIT MANUALLY
+ */`;
+  const contractsCode = contracts.map((contract) => generateContract(contract)).join("\n\n");
+  const code = `${imports}
+
+${header}
+
+${contractsCode}`;
+  const formatted = await format2(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 = ora("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(
+        chalk.gray(
+          `   import { ${exampleContract.name} } from '${config.out.replace(/\.ts$/, "")}'`
+        )
+      );
+      if (processedContracts.length > 1) {
+        console.log(
+          chalk.gray(
+            `   // Also available: ${processedContracts.slice(1).map((c) => c.name).join(", ")}`
+          )
+        );
+      }
+    }
+  } catch (error) {
+    spinner.fail("Generation failed");
+    console.error(chalk.red(`
+${error.message}`));
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+program.name("stacks").description("CLI tool for generating type-safe Stacks contract interfaces").version("0.1.0");
+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);
+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();
+});
+program.parse();
+//# sourceMappingURL=cli.js.map