@secondlayer/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,342 @@
+// src/utils/config.ts
+import { transformSync } from "esbuild";
+
+// src/core/plugin-manager.ts
+import { format } from "prettier";
+import { promises as fs } from "fs";
+import path 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 = path.resolve(process.cwd(), output.path);
+        await this.utils.ensureDir(path.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 path.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
+function defineConfig(configOrDefiner) {
+  return configOrDefiner;
+}
+export {
+  PluginManager,
+  defineConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/config.ts","../src/core/plugin-manager.ts"],"sourcesContent":["import { promises as fs } from \"fs\";\nimport path from \"path\";\nimport { pathToFileURL } from \"url\";\nimport { createRequire } from \"module\";\nimport { transformSync } from \"esbuild\";\nimport type { StacksConfig, ConfigDefiner } from \"../types/config.js\";\nimport type { ResolvedConfig } from \"../types/plugin.js\";\nimport { PluginManager } from \"../core/plugin-manager.js\";\n\n/**\n * Config file utilities\n */\n\nconst CONFIG_FILE_NAMES = [\n  \"stacks.config.ts\",\n  \"stacks.config.js\",\n  \"stacks.config.mjs\",\n];\n\nexport async function findConfigFile(cwd: string): Promise<string | null> {\n  for (const fileName of CONFIG_FILE_NAMES) {\n    const filePath = path.join(cwd, fileName);\n    try {\n      await fs.access(filePath);\n      return filePath;\n    } catch {\n      // File doesn't exist, continue\n    }\n  }\n  return null;\n}\n\nexport async function loadConfig(configPath?: string): Promise<ResolvedConfig> {\n  const cwd = process.cwd();\n\n  const resolvedPath = configPath\n    ? path.resolve(cwd, configPath)\n    : await findConfigFile(cwd);\n\n  if (!resolvedPath) {\n    throw new Error(\n      \"No config file found. Create a stacks.config.ts file or specify a path with --config\"\n    );\n  }\n\n  let config: any;\n\n  if (resolvedPath.endsWith(\".ts\")) {\n    const code = await fs.readFile(resolvedPath, \"utf-8\");\n\n    // Transform TypeScript to JavaScript, replacing the @stacks/codegen import\n    // For development/linked packages, we need to resolve to the actual package location\n    // This will work both for published packages and local development\n    let replacementPath: string;\n\n    try {\n      // Try to resolve @stacks/codegen as if it were a normal package\n      const require = createRequire(import.meta.url);\n      const packagePath = require.resolve(\"@stacks/codegen\");\n      replacementPath = pathToFileURL(packagePath).href;\n    } catch {\n      // Fallback: resolve relative to current module (for development)\n      const currentModuleDir = path.dirname(new URL(import.meta.url).pathname);\n      const indexPath = path.resolve(currentModuleDir, \"../index.js\");\n      replacementPath = pathToFileURL(indexPath).href;\n    }\n\n    const transformedCode = code.replace(\n      /from\\s+[\"']@stacks\\/cli[\"']/g,\n      `from '${replacementPath}'`\n    );\n\n    const result = transformSync(transformedCode, {\n      format: \"esm\",\n      target: \"node18\",\n      loader: \"ts\",\n    });\n\n    const tempPath = resolvedPath.replace(/\\.ts$/, \".mjs\");\n    await fs.writeFile(tempPath, result.code);\n\n    try {\n      const fileUrl = pathToFileURL(tempPath).href;\n      const module = await import(fileUrl);\n      config = module.default;\n    } finally {\n      await fs.unlink(tempPath).catch(() => {});\n    }\n  } else {\n    const fileUrl = pathToFileURL(resolvedPath).href;\n    const module = await import(fileUrl);\n    config = module.default;\n  }\n\n  if (!config) {\n    throw new Error(\"Config file must export a default configuration\");\n  }\n\n  if (typeof config === \"function\") {\n    config = config({} as StacksConfig);\n  }\n\n  validateConfig(config);\n\n  // Process plugins if they exist\n  const pluginManager = new PluginManager();\n\n  if (config.plugins && Array.isArray(config.plugins)) {\n    for (const plugin of config.plugins) {\n      pluginManager.register(plugin);\n    }\n  }\n\n  // Transform config through plugins\n  const resolvedConfig = await pluginManager.transformConfig(config);\n\n  return resolvedConfig;\n}\n\nexport function validateConfig(\n  config: unknown\n): asserts config is StacksConfig {\n  if (!config || typeof config !== \"object\") {\n    throw new Error(\"Config must be an object\");\n  }\n\n  const c = config as any;\n\n  // Contracts are optional now since plugins can provide them\n  if (c.contracts && !Array.isArray(c.contracts)) {\n    throw new Error(\"Config contracts must be an array\");\n  }\n\n  if (!c.out || typeof c.out !== \"string\") {\n    throw new Error(\"Config out must be a string path\");\n  }\n\n  // Validate contracts if they exist\n  if (c.contracts) {\n    for (const contract of c.contracts) {\n      if (!contract.address && !contract.source) {\n        throw new Error(\"Each contract must have either an address or source\");\n      }\n    }\n  }\n\n  // Validate plugins if they exist\n  if (c.plugins && !Array.isArray(c.plugins)) {\n    throw new Error(\"Config plugins must be an array\");\n  }\n}\n\nexport function defineConfig(config: StacksConfig): StacksConfig;\nexport function defineConfig(definer: ConfigDefiner): ConfigDefiner;\nexport function defineConfig(configOrDefiner: StacksConfig | ConfigDefiner) {\n  return configOrDefiner;\n}\n","/**\n * Plugin Manager for @stacks/codegen\n * Handles plugin registration, lifecycle execution, and output management\n */\n\nimport { format } from \"prettier\";\nimport { promises as fs } from \"fs\";\nimport path from \"path\";\nimport { validateStacksAddress } from \"@stacks/transactions\";\nimport type {\n  StacksCodegenPlugin,\n  UserConfig,\n  ResolvedConfig,\n  GenerateContext,\n  Logger,\n  PluginUtils,\n  GeneratedOutput,\n  ProcessedContract,\n  ContractConfig,\n  HookResult,\n  PluginExecutionContext,\n} from \"../types/plugin.js\";\n\n/**\n * Core plugin manager that orchestrates plugin execution\n */\nexport class PluginManager {\n  private plugins: StacksCodegenPlugin[] = [];\n  private logger: Logger;\n  private utils: PluginUtils;\n  private executionContext: PluginExecutionContext;\n\n  constructor() {\n    this.logger = this.createLogger();\n    this.utils = this.createUtils();\n    this.executionContext = {\n      phase: \"config\",\n      startTime: Date.now(),\n      results: new Map(),\n    };\n  }\n\n  /**\n   * Register a plugin\n   */\n  register(plugin: StacksCodegenPlugin): void {\n    // Validate plugin\n    if (!plugin.name || !plugin.version) {\n      throw new Error(\"Plugin must have a name and version\");\n    }\n\n    // Check for duplicate plugin names\n    const existing = this.plugins.find((p) => p.name === plugin.name);\n    if (existing) {\n      throw new Error(\n        `Plugin \"${plugin.name}\" is already registered (version ${existing.version})`\n      );\n    }\n\n    this.plugins.push(plugin);\n    this.logger.debug(`Registered plugin: ${plugin.name}@${plugin.version}`);\n  }\n\n  /**\n   * Get all registered plugins\n   */\n  getPlugins(): StacksCodegenPlugin[] {\n    return [...this.plugins];\n  }\n\n  /**\n   * Transform user config through all plugins\n   */\n  async transformConfig(config: UserConfig): Promise<ResolvedConfig> {\n    this.executionContext.phase = \"config\";\n    let transformedConfig = { ...config };\n\n    for (const plugin of this.plugins) {\n      if (plugin.transformConfig) {\n        this.executionContext.currentPlugin = plugin;\n        try {\n          const result = await plugin.transformConfig(transformedConfig);\n          transformedConfig = result;\n          this.recordHookResult(plugin.name, \"transformConfig\", {\n            success: true,\n          });\n        } catch (error) {\n          const err = error as Error;\n          this.recordHookResult(plugin.name, \"transformConfig\", {\n            success: false,\n            error: err,\n          });\n          throw new Error(\n            `Plugin \"${plugin.name}\" failed during config transformation: ${err.message}`\n          );\n        }\n      }\n    }\n\n    // Add plugins array to resolved config\n    const resolvedConfig: ResolvedConfig = {\n      ...transformedConfig,\n      plugins: this.plugins,\n    };\n\n    return resolvedConfig;\n  }\n\n  /**\n   * Transform contracts through all plugins\n   */\n  async transformContracts(\n    contracts: ContractConfig[],\n    _config: ResolvedConfig\n  ): Promise<ProcessedContract[]> {\n    const processedContracts: ProcessedContract[] = [];\n\n    for (let contract of contracts) {\n      // Handle special case for Clarinet plugin contracts\n      if ((contract as any)._clarinetSource && contract.abi) {\n        // Convert Clarinet contracts directly to ProcessedContract format\n        const address =\n          typeof contract.address === \"string\" ? contract.address : \"\";\n        const [contractAddress, contractName] = address.split(\".\");\n        const processed: ProcessedContract = {\n          name: contract.name || contractName,\n          address: contractAddress,\n          contractName: contractName,\n          abi: contract.abi,\n          source: \"local\" as const,\n          metadata: { source: \"clarinet\" },\n        };\n        processedContracts.push(processed);\n        continue;\n      }\n\n      // Transform through each plugin\n      for (const plugin of this.plugins) {\n        if (plugin.transformContract) {\n          this.executionContext.currentPlugin = plugin;\n          try {\n            contract = await plugin.transformContract(contract);\n            this.recordHookResult(plugin.name, \"transformContract\", {\n              success: true,\n            });\n          } catch (error) {\n            const err = error as Error;\n            this.recordHookResult(plugin.name, \"transformContract\", {\n              success: false,\n              error: err,\n            });\n            this.logger.warn(\n              `Plugin \"${plugin.name}\" failed to transform contract: ${err.message}`\n            );\n          }\n        }\n      }\n\n      // Convert to ProcessedContract\n      if (contract.abi) {\n        const processed: ProcessedContract = {\n          name: contract.name || \"unknown\",\n          address:\n            typeof contract.address === \"string\"\n              ? contract.address.split(\".\")[0]\n              : \"unknown\",\n          contractName: contract.name || \"unknown\",\n          abi: contract.abi,\n          source: \"api\" as const, // Use \"api\" as default for plugin-processed contracts\n          metadata: contract.metadata,\n        };\n        processedContracts.push(processed);\n      }\n    }\n\n    return processedContracts;\n  }\n\n  /**\n   * Execute lifecycle hooks\n   */\n  async executeHook(\n    hookName: keyof StacksCodegenPlugin,\n    context: any\n  ): Promise<void> {\n    for (const plugin of this.plugins) {\n      const hook = plugin[hookName];\n      if (typeof hook === \"function\") {\n        this.executionContext.currentPlugin = plugin;\n        try {\n          await (hook as any).call(plugin, context);\n          this.recordHookResult(plugin.name, hookName as string, {\n            success: true,\n          });\n        } catch (error) {\n          const err = error as Error;\n          this.recordHookResult(plugin.name, hookName as string, {\n            success: false,\n            error: err,\n          });\n          this.logger.error(\n            `Plugin \"${plugin.name}\" failed during ${hookName as string}: ${err.message}`\n          );\n          // Don't throw - allow other plugins to continue\n        }\n      }\n    }\n  }\n\n  /**\n   * Execute generation phase with full context\n   */\n  async executeGeneration(\n    contracts: ProcessedContract[],\n    config: ResolvedConfig\n  ): Promise<Map<string, GeneratedOutput>> {\n    this.executionContext.phase = \"generate\";\n    const outputs = new Map<string, GeneratedOutput>();\n\n    // Create generation context\n    const context: GenerateContext = {\n      config,\n      logger: this.logger,\n      utils: this.utils,\n      contracts,\n      outputs,\n      augment: (outputKey: string, contractName: string, content: any) => {\n        this.augmentOutput(outputs, outputKey, contractName, content);\n      },\n      addOutput: (key: string, output: GeneratedOutput) => {\n        outputs.set(key, output);\n      },\n    };\n\n    // Execute beforeGenerate hooks\n    await this.executeHook(\"beforeGenerate\", context);\n\n    // Execute generate hooks\n    await this.executeHook(\"generate\", context);\n\n    // Execute afterGenerate hooks\n    await this.executeHook(\"afterGenerate\", context);\n\n    return outputs;\n  }\n\n  /**\n   * Transform outputs through plugins\n   */\n  async transformOutputs(\n    outputs: Map<string, GeneratedOutput>\n  ): Promise<Map<string, GeneratedOutput>> {\n    this.executionContext.phase = \"output\";\n    const transformedOutputs = new Map<string, GeneratedOutput>();\n\n    for (const [key, output] of outputs) {\n      let transformedContent = output.content;\n\n      for (const plugin of this.plugins) {\n        if (plugin.transformOutput) {\n          this.executionContext.currentPlugin = plugin;\n          try {\n            transformedContent = await plugin.transformOutput(\n              transformedContent,\n              output.type || \"other\"\n            );\n            this.recordHookResult(plugin.name, \"transformOutput\", {\n              success: true,\n            });\n          } catch (error) {\n            const err = error as Error;\n            this.recordHookResult(plugin.name, \"transformOutput\", {\n              success: false,\n              error: err,\n            });\n            this.logger.warn(\n              `Plugin \"${plugin.name}\" failed to transform output: ${err.message}`\n            );\n          }\n        }\n      }\n\n      transformedOutputs.set(key, {\n        ...output,\n        content: transformedContent,\n      });\n    }\n\n    return transformedOutputs;\n  }\n\n  /**\n   * Write outputs to disk\n   */\n  async writeOutputs(outputs: Map<string, GeneratedOutput>): Promise<void> {\n    for (const [, output] of outputs) {\n      try {\n        const resolvedPath = path.resolve(process.cwd(), output.path);\n        await this.utils.ensureDir(path.dirname(resolvedPath));\n        await this.utils.writeFile(resolvedPath, output.content);\n        // Don't log here - let the main command handle success messaging\n      } catch (error) {\n        const err = error as Error;\n        this.logger.error(`Failed to write ${output.path}: ${err.message}`);\n        throw err;\n      }\n    }\n  }\n\n  /**\n   * Get execution results for debugging\n   */\n  getExecutionResults(): Map<string, HookResult[]> {\n    return new Map(this.executionContext.results);\n  }\n\n  /**\n   * Augment existing output with additional content\n   */\n  private augmentOutput(\n    outputs: Map<string, GeneratedOutput>,\n    outputKey: string,\n    contractName: string,\n    content: any\n  ): void {\n    const existing = outputs.get(outputKey);\n    if (!existing) {\n      this.logger.warn(`Cannot augment non-existent output: ${outputKey}`);\n      return;\n    }\n\n    // Simple augmentation - append content\n    // In a real implementation, this would be more sophisticated\n    const augmentedContent = `${existing.content}\\n\\n// Augmented by plugin for ${contractName}\\n${JSON.stringify(content, null, 2)}`;\n\n    outputs.set(outputKey, {\n      ...existing,\n      content: augmentedContent,\n    });\n  }\n\n  /**\n   * Record hook execution result\n   */\n  private recordHookResult(\n    pluginName: string,\n    hookName: string,\n    result: Omit<HookResult, \"plugin\">\n  ): void {\n    const key = `${pluginName}:${hookName}`;\n    const existing = this.executionContext.results.get(key) || [];\n    existing.push({ ...result, plugin: pluginName });\n    this.executionContext.results.set(key, existing);\n  }\n\n  /**\n   * Create logger instance\n   */\n  private createLogger(): Logger {\n    return {\n      info: (message: string) => console.log(`ℹ️  ${message}`),\n      warn: (message: string) => console.warn(`⚠️  ${message}`),\n      error: (message: string) => console.error(`❌ ${message}`),\n      debug: (message: string) => {\n        if (process.env.DEBUG) {\n          console.log(`🐛 ${message}`);\n        }\n      },\n      success: (message: string) => console.log(`✅ ${message}`),\n    };\n  }\n\n  /**\n   * Create utils instance\n   */\n  private createUtils(): PluginUtils {\n    return {\n      toCamelCase: (str: string) => {\n        return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());\n      },\n\n      toKebabCase: (str: string) => {\n        return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);\n      },\n\n      validateAddress: (address: string) => {\n        return validateStacksAddress(address.split(\".\")[0]);\n      },\n\n      parseContractId: (contractId: string) => {\n        const [address, contractName] = contractId.split(\".\");\n        return { address, contractName };\n      },\n\n      formatCode: async (code: string) => {\n        return format(code, {\n          parser: \"typescript\",\n          singleQuote: true,\n          semi: true,\n          printWidth: 100,\n          trailingComma: \"es5\",\n        });\n      },\n\n      resolvePath: (relativePath: string) => {\n        return path.resolve(process.cwd(), relativePath);\n      },\n\n      fileExists: async (filePath: string) => {\n        try {\n          await fs.access(filePath);\n          return true;\n        } catch {\n          return false;\n        }\n      },\n\n      readFile: async (filePath: string) => {\n        return fs.readFile(filePath, \"utf-8\");\n      },\n\n      writeFile: async (filePath: string, content: string) => {\n        await fs.writeFile(filePath, content, \"utf-8\");\n      },\n\n      ensureDir: async (dirPath: string) => {\n        await fs.mkdir(dirPath, { recursive: true });\n      },\n    };\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/plugin-manager-DBXFfyFZ.d.cts

@@ -0,0 +1,285 @@
+/**
+ * Configuration types for @stacks/codegen
+ */
+type NetworkName = "mainnet" | "testnet" | "devnet";
+interface ContractSource {
+    /**
+     * Contract identifier (address.name) for deployed contracts
+     */
+    address?: string | Partial<Record<NetworkName, string>>;
+    /**
+     * Path to local Clarity file
+     */
+    source?: string;
+    /**
+     * Optional name to use in generated code
+     */
+    name?: string;
+}
+interface StacksConfig {
+    /**
+     * Contracts to generate interfaces for (optional - plugins can provide these)
+     */
+    contracts?: ContractSource[];
+    /**
+     * Output file path
+     */
+    out: string;
+    /**
+     * Plugins to use for generation
+     */
+    plugins?: any[];
+    /**
+     * Network to use for fetching contracts
+     */
+    network?: NetworkName;
+    /**
+     * API key for Stacks API (if required)
+     */
+    apiKey?: string;
+    /**
+     * Base URL for Stacks API (optional override)
+     */
+    apiUrl?: string;
+}
+interface ResolvedContract {
+    name: string;
+    address: string;
+    contractName: string;
+    abi: any;
+    source: "api" | "local";
+}
+type ConfigDefiner = (config: StacksConfig) => StacksConfig;
+
+/**
+ * Plugin system types for @stacks/codegen
+ */
+
+/**
+ * Core plugin interface that all plugins must implement
+ */
+interface StacksCodegenPlugin {
+    /** Plugin name (should be unique) */
+    name: string;
+    /** Plugin version */
+    version: string;
+    /** Called after config is resolved but before generation starts */
+    configResolved?: (config: ResolvedConfig) => void | Promise<void>;
+    /** Called before generation starts */
+    beforeGenerate?: (context: GenerateContext) => void | Promise<void>;
+    /** Called during generation phase - plugins can add their own outputs */
+    generate?: (context: GenerateContext) => void | Promise<void>;
+    /** Called after all generation is complete */
+    afterGenerate?: (context: GenerateContext) => void | Promise<void>;
+    /** Transform user config before resolution */
+    transformConfig?: (config: UserConfig) => UserConfig | Promise<UserConfig>;
+    /** Transform individual contracts during processing */
+    transformContract?: (contract: ContractConfig) => ContractConfig | Promise<ContractConfig>;
+    /** Transform generated output before writing to disk */
+    transformOutput?: (output: string, type: OutputType) => string | Promise<string>;
+}
+/**
+ * User configuration (before plugin transformations)
+ */
+type UserConfig = StacksConfig;
+/**
+ * Resolved configuration (after plugin transformations)
+ */
+interface ResolvedConfig extends StacksConfig {
+    /** Resolved plugins array */
+    plugins: StacksCodegenPlugin[];
+}
+/**
+ * Contract configuration that can be transformed by plugins
+ */
+interface ContractConfig {
+    name?: string;
+    address?: string | Partial<Record<NetworkName, string>>;
+    source?: string;
+    abi?: any;
+    metadata?: Record<string, any>;
+}
+/**
+ * Processed contract with resolved ABI and metadata
+ */
+interface ProcessedContract extends ResolvedContract {
+    /** Additional metadata added by plugins */
+    metadata?: Record<string, any>;
+}
+/**
+ * Generated output from plugins
+ */
+interface GeneratedOutput {
+    /** File path where output should be written */
+    path: string;
+    /** Generated content */
+    content: string;
+    /** Output type for transformation hooks */
+    type?: OutputType;
+    /** Whether this output should overwrite existing files */
+    overwrite?: boolean;
+}
+/**
+ * Types of outputs that can be generated
+ */
+type OutputType = "contracts" | "hooks" | "actions" | "types" | "utils" | "config" | "other";
+/**
+ * Base context available to all plugin hooks
+ */
+interface PluginContext {
+    /** Resolved configuration */
+    config: ResolvedConfig;
+    /** Logger for plugin output */
+    logger: Logger;
+    /** Utility functions for plugins */
+    utils: PluginUtils;
+}
+/**
+ * Context available during generation phase
+ */
+interface GenerateContext extends PluginContext {
+    /** Processed contracts ready for generation */
+    contracts: ProcessedContract[];
+    /** Map of output keys to generated content */
+    outputs: Map<string, GeneratedOutput>;
+    /** Function to augment existing outputs */
+    augment: (outputKey: string, contractName: string, content: any) => void;
+    /** Function to add new outputs */
+    addOutput: (key: string, output: GeneratedOutput) => void;
+}
+/**
+ * Logger interface for plugin output
+ */
+interface Logger {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+    debug: (message: string) => void;
+    success: (message: string) => void;
+}
+/**
+ * Utility functions available to plugins
+ */
+interface PluginUtils {
+    /** Convert kebab-case to camelCase */
+    toCamelCase: (str: string) => string;
+    /** Convert camelCase to kebab-case */
+    toKebabCase: (str: string) => string;
+    /** Validate Stacks address format */
+    validateAddress: (address: string) => boolean;
+    /** Parse contract identifier (address.contract-name) */
+    parseContractId: (contractId: string) => {
+        address: string;
+        contractName: string;
+    };
+    /** Format TypeScript code using prettier */
+    formatCode: (code: string) => Promise<string>;
+    /** Resolve file path relative to project root */
+    resolvePath: (relativePath: string) => string;
+    /** Check if file exists */
+    fileExists: (path: string) => Promise<boolean>;
+    /** Read file content */
+    readFile: (path: string) => Promise<string>;
+    /** Write file content */
+    writeFile: (path: string, content: string) => Promise<void>;
+    /** Create directory recursively */
+    ensureDir: (path: string) => Promise<void>;
+}
+/**
+ * Plugin factory function type for creating plugins with options
+ */
+type PluginFactory<TOptions = any> = (options?: TOptions) => StacksCodegenPlugin;
+/**
+ * Plugin options base interface
+ */
+interface PluginOptions {
+    /** Include only specific contracts/functions */
+    include?: string[];
+    /** Exclude specific contracts/functions */
+    exclude?: string[];
+    /** Enable debug output */
+    debug?: boolean;
+}
+/**
+ * Hook execution result
+ */
+interface HookResult<T = any> {
+    /** Whether the hook was successful */
+    success: boolean;
+    /** Result data from the hook */
+    data?: T;
+    /** Error if hook failed */
+    error?: Error;
+    /** Plugin that executed the hook */
+    plugin: string;
+}
+
+/**
+ * Plugin Manager for @stacks/codegen
+ * Handles plugin registration, lifecycle execution, and output management
+ */
+
+/**
+ * Core plugin manager that orchestrates plugin execution
+ */
+declare class PluginManager {
+    private plugins;
+    private logger;
+    private utils;
+    private executionContext;
+    constructor();
+    /**
+     * Register a plugin
+     */
+    register(plugin: StacksCodegenPlugin): void;
+    /**
+     * Get all registered plugins
+     */
+    getPlugins(): StacksCodegenPlugin[];
+    /**
+     * Transform user config through all plugins
+     */
+    transformConfig(config: UserConfig): Promise<ResolvedConfig>;
+    /**
+     * Transform contracts through all plugins
+     */
+    transformContracts(contracts: ContractConfig[], _config: ResolvedConfig): Promise<ProcessedContract[]>;
+    /**
+     * Execute lifecycle hooks
+     */
+    executeHook(hookName: keyof StacksCodegenPlugin, context: any): Promise<void>;
+    /**
+     * Execute generation phase with full context
+     */
+    executeGeneration(contracts: ProcessedContract[], config: ResolvedConfig): Promise<Map<string, GeneratedOutput>>;
+    /**
+     * Transform outputs through plugins
+     */
+    transformOutputs(outputs: Map<string, GeneratedOutput>): Promise<Map<string, GeneratedOutput>>;
+    /**
+     * Write outputs to disk
+     */
+    writeOutputs(outputs: Map<string, GeneratedOutput>): Promise<void>;
+    /**
+     * Get execution results for debugging
+     */
+    getExecutionResults(): Map<string, HookResult[]>;
+    /**
+     * Augment existing output with additional content
+     */
+    private augmentOutput;
+    /**
+     * Record hook execution result
+     */
+    private recordHookResult;
+    /**
+     * Create logger instance
+     */
+    private createLogger;
+    /**
+     * Create utils instance
+     */
+    private createUtils;
+}
+
+export { type ConfigDefiner as C, type GenerateContext as G, type Logger as L, type NetworkName as N, type OutputType as O, type PluginFactory as P, type ResolvedConfig as R, type StacksConfig as S, type UserConfig as U, type ContractSource as a, type StacksCodegenPlugin as b, type PluginOptions as c, type PluginContext as d, type PluginUtils as e, type GeneratedOutput as f, type ProcessedContract as g, type ContractConfig as h, PluginManager as i };