@secondlayer/cli 0.1.0

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

@@ -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 };