@betterstart/cli 0.1.0

package/dist/logger-awLb347n.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Logger abstraction for the codegen package
+ * Replaces direct console.log calls to support library usage and testing
+ */
+/**
+ * Log levels
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/**
+ * Logger interface
+ */
+interface Logger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    success(message: string, ...args: unknown[]): void;
+    /**
+     * Log a step in a process (e.g., "1️⃣ Generating database schema...")
+     */
+    step(stepNumber: number, message: string): void;
+    /**
+     * Log a completed step
+     */
+    stepComplete(message: string): void;
+    /**
+     * Set the log level
+     */
+    setLevel(level: LogLevel): void;
+    /**
+     * Get the current log level
+     */
+    getLevel(): LogLevel;
+}
+/**
+ * Buffered logger that stores log messages for later retrieval
+ */
+interface LogEntry {
+    level: LogLevel | 'success' | 'step' | 'stepComplete';
+    message: string;
+    args: unknown[];
+    timestamp: Date;
+}
+/**
+ * Create a console logger
+ */
+declare function createConsoleLogger(level?: LogLevel): Logger;
+/**
+ * Create a silent logger (for testing or library usage)
+ */
+declare function createSilentLogger(): Logger;
+/**
+ * Create a buffered logger (for testing)
+ */
+declare function createBufferedLogger(level?: LogLevel): Logger & {
+    getEntries(): LogEntry[];
+    clear(): void;
+};
+/**
+ * Get the global logger
+ */
+declare function getLogger(): Logger;
+/**
+ * Set the global logger
+ */
+declare function setLogger(logger: Logger): void;
+/**
+ * Reset the global logger to the default console logger
+ */
+declare function resetLogger(): void;
+declare const logger: {
+    readonly debug: (message: string, ...args: unknown[]) => void;
+    readonly info: (message: string, ...args: unknown[]) => void;
+    readonly warn: (message: string, ...args: unknown[]) => void;
+    readonly error: (message: string, ...args: unknown[]) => void;
+    readonly success: (message: string, ...args: unknown[]) => void;
+    readonly step: (stepNumber: number, message: string) => void;
+    readonly stepComplete: (message: string) => void;
+};
+
+export { type LogLevel as L, type Logger as a, type LogEntry as b, createConsoleLogger as c, createSilentLogger as d, createBufferedLogger as e, getLogger as g, logger as l, resetLogger as r, setLogger as s };

package/dist/plugins/index.d.ts

@@ -0,0 +1,213 @@
+import { k as BetterstartPlugin, h as PluginContext, i as GeneratedFile, C as CustomGenerator, F as FieldTypeHandler, j as PluginCommand } from '../types-BouTOvVr.js';
+export { g as PluginHooks } from '../types-BouTOvVr.js';
+import '../logger-awLb347n.js';
+
+/**
+ * Plugin manager for @betterstart/cli
+ * Handles plugin registration, lifecycle, and execution
+ */
+
+/**
+ * Plugin manager for handling plugin lifecycle and registration
+ */
+declare class PluginManager {
+    private plugins;
+    private initialized;
+    /**
+     * Register a plugin
+     */
+    register(plugin: BetterstartPlugin): void;
+    /**
+     * Register multiple plugins
+     */
+    registerAll(plugins: BetterstartPlugin[]): void;
+    /**
+     * Unregister a plugin
+     */
+    unregister(pluginName: string): boolean;
+    /**
+     * Get a registered plugin by name
+     */
+    get(pluginName: string): BetterstartPlugin | undefined;
+    /**
+     * Get all registered plugins
+     */
+    getAll(): BetterstartPlugin[];
+    /**
+     * Check if a plugin is registered
+     */
+    has(pluginName: string): boolean;
+    /**
+     * Initialize all plugins
+     */
+    initialize(context: PluginContext): Promise<void>;
+    /**
+     * Run beforeGenerate hooks on all plugins
+     */
+    runBeforeGenerate(context: PluginContext, schema: unknown): Promise<void>;
+    /**
+     * Run afterGenerate hooks on all plugins
+     */
+    runAfterGenerate(context: PluginContext, files: GeneratedFile[]): Promise<void>;
+    /**
+     * Get a generator by name from any registered plugin
+     */
+    getGenerator(name: string): CustomGenerator | undefined;
+    /**
+     * Get all generators from all plugins
+     */
+    getAllGenerators(): Map<string, {
+        plugin: string;
+        generator: CustomGenerator;
+    }>;
+    /**
+     * Get all generator names
+     */
+    getGeneratorNames(): string[];
+    /**
+     * Get a field type handler by name from any registered plugin
+     */
+    getFieldType(name: string): FieldTypeHandler | undefined;
+    /**
+     * Get all field types from all plugins
+     */
+    getAllFieldTypes(): Map<string, {
+        plugin: string;
+        handler: FieldTypeHandler;
+    }>;
+    /**
+     * Get all field type names
+     */
+    getFieldTypeNames(): string[];
+    /**
+     * Get a command by name from any registered plugin
+     */
+    getCommand(name: string): PluginCommand | undefined;
+    /**
+     * Get all commands from all plugins
+     */
+    getAllCommands(): Map<string, {
+        plugin: string;
+        command: PluginCommand;
+    }>;
+    /**
+     * Get all command names
+     */
+    getCommandNames(): string[];
+    /**
+     * Get plugin summary
+     */
+    getSummary(): PluginSummary;
+    /**
+     * Clear all registered plugins
+     */
+    clear(): void;
+}
+interface PluginInfo {
+    name: string;
+    version: string;
+    description?: string;
+    generators: string[];
+    fieldTypes: string[];
+    commands: string[];
+}
+interface PluginSummary {
+    count: number;
+    plugins: PluginInfo[];
+}
+/**
+ * Get the global plugin manager instance
+ */
+declare function getPluginManager(): PluginManager;
+/**
+ * Create a new plugin manager instance
+ */
+declare function createPluginManager(): PluginManager;
+/**
+ * Reset the global plugin manager
+ */
+declare function resetPluginManager(): void;
+
+/**
+ * Plugin system types for @betterstart/cli
+ * Re-exports types from config and adds plugin-specific utilities
+ */
+
+/**
+ * Events emitted during plugin lifecycle
+ */
+type PluginEvent = 'init' | 'beforeGenerate' | 'afterGenerate' | 'beforeWrite' | 'afterWrite' | 'error';
+/**
+ * Event handler type
+ */
+type PluginEventHandler<T = unknown> = (context: PluginContext, data: T) => Promise<void>;
+/**
+ * Options for creating a plugin
+ */
+interface CreatePluginOptions {
+    name: string;
+    version: string;
+    description?: string;
+}
+/**
+ * Plugin builder for fluent API
+ */
+interface PluginBuilder {
+    /** Add an onInit hook */
+    onInit(handler: (context: PluginContext) => Promise<void>): PluginBuilder;
+    /** Add an onBeforeGenerate hook */
+    onBeforeGenerate(handler: (context: PluginContext, schema: unknown) => Promise<void>): PluginBuilder;
+    /** Add an onAfterGenerate hook */
+    onAfterGenerate(handler: (context: PluginContext, files: GeneratedFile[]) => Promise<void>): PluginBuilder;
+    /** Add a custom generator */
+    addGenerator(name: string, description: string, generate: (context: PluginContext, schema: unknown) => Promise<GeneratedFile[]>): PluginBuilder;
+    /** Add a custom field type */
+    addFieldType(name: string, handler: {
+        zodType: (field: unknown) => string;
+        drizzleType: (field: unknown, imports: Set<string>) => string;
+        typescriptType: (field: unknown, mode: 'input' | 'output') => string;
+        formComponent?: (field: unknown) => string;
+    }): PluginBuilder;
+    /** Add a CLI command */
+    addCommand(name: string, description: string, options: Array<{
+        flags: string;
+        description: string;
+        default?: unknown;
+    }>, handler: (options: Record<string, unknown>) => Promise<void>): PluginBuilder;
+    /** Build the plugin */
+    build(): BetterstartPlugin;
+}
+/**
+ * Create a plugin using the builder pattern
+ */
+declare function createPlugin(options: CreatePluginOptions): PluginBuilder;
+/**
+ * Check if a plugin has a specific hook
+ */
+declare function hasHook(plugin: BetterstartPlugin, hook: keyof NonNullable<BetterstartPlugin['hooks']>): boolean;
+/**
+ * Check if a plugin provides a specific generator
+ */
+declare function hasGenerator(plugin: BetterstartPlugin, generatorName: string): boolean;
+/**
+ * Check if a plugin provides a specific field type
+ */
+declare function hasFieldType(plugin: BetterstartPlugin, fieldTypeName: string): boolean;
+/**
+ * Check if a plugin provides a specific command
+ */
+declare function hasCommand(plugin: BetterstartPlugin, commandName: string): boolean;
+/**
+ * Get all generator names from a plugin
+ */
+declare function getGeneratorNames(plugin: BetterstartPlugin): string[];
+/**
+ * Get all field type names from a plugin
+ */
+declare function getFieldTypeNames(plugin: BetterstartPlugin): string[];
+/**
+ * Get all command names from a plugin
+ */
+declare function getCommandNames(plugin: BetterstartPlugin): string[];
+
+export { BetterstartPlugin, type CreatePluginOptions, CustomGenerator, FieldTypeHandler, GeneratedFile, type PluginBuilder, PluginCommand, PluginContext, type PluginEvent, type PluginEventHandler, type PluginInfo, PluginManager, type PluginSummary, createPlugin, createPluginManager, getCommandNames, getFieldTypeNames, getGeneratorNames, getPluginManager, hasCommand, hasFieldType, hasGenerator, hasHook, resetPluginManager };

package/dist/plugins/index.js

@@ -0,0 +1,365 @@
+import {
+  PluginError,
+  getLogger
+} from "../chunk-WY6BC55D.js";
+
+// src/plugins/types.ts
+function createPlugin(options) {
+  const plugin = {
+    name: options.name,
+    version: options.version,
+    description: options.description,
+    hooks: {},
+    generators: {},
+    fieldTypes: {},
+    commands: []
+  };
+  const builder = {
+    onInit(handler) {
+      plugin.hooks = plugin.hooks || {};
+      plugin.hooks.onInit = handler;
+      return builder;
+    },
+    onBeforeGenerate(handler) {
+      plugin.hooks = plugin.hooks || {};
+      plugin.hooks.onBeforeGenerate = handler;
+      return builder;
+    },
+    onAfterGenerate(handler) {
+      plugin.hooks = plugin.hooks || {};
+      plugin.hooks.onAfterGenerate = handler;
+      return builder;
+    },
+    addGenerator(name, description, generate) {
+      plugin.generators = plugin.generators || {};
+      plugin.generators[name] = { name, description, generate };
+      return builder;
+    },
+    addFieldType(name, handler) {
+      plugin.fieldTypes = plugin.fieldTypes || {};
+      plugin.fieldTypes[name] = handler;
+      return builder;
+    },
+    addCommand(name, description, options2, handler) {
+      plugin.commands = plugin.commands || [];
+      plugin.commands.push({ name, description, options: options2, handler });
+      return builder;
+    },
+    build() {
+      return plugin;
+    }
+  };
+  return builder;
+}
+function hasHook(plugin, hook) {
+  return plugin.hooks !== void 0 && typeof plugin.hooks[hook] === "function";
+}
+function hasGenerator(plugin, generatorName) {
+  return plugin.generators !== void 0 && generatorName in plugin.generators;
+}
+function hasFieldType(plugin, fieldTypeName) {
+  return plugin.fieldTypes !== void 0 && fieldTypeName in plugin.fieldTypes;
+}
+function hasCommand(plugin, commandName) {
+  return plugin.commands?.some((cmd) => cmd.name === commandName) ?? false;
+}
+function getGeneratorNames(plugin) {
+  return plugin.generators ? Object.keys(plugin.generators) : [];
+}
+function getFieldTypeNames(plugin) {
+  return plugin.fieldTypes ? Object.keys(plugin.fieldTypes) : [];
+}
+function getCommandNames(plugin) {
+  return plugin.commands ? plugin.commands.map((cmd) => cmd.name) : [];
+}
+
+// src/plugins/manager.ts
+var PluginManager = class {
+  plugins = /* @__PURE__ */ new Map();
+  initialized = false;
+  /**
+   * Register a plugin
+   */
+  register(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      throw new PluginError(`Plugin "${plugin.name}" is already registered`, plugin.name);
+    }
+    const logger = getLogger();
+    logger.debug(`Registering plugin: ${plugin.name}@${plugin.version}`);
+    this.plugins.set(plugin.name, plugin);
+  }
+  /**
+   * Register multiple plugins
+   */
+  registerAll(plugins) {
+    for (const plugin of plugins) {
+      this.register(plugin);
+    }
+  }
+  /**
+   * Unregister a plugin
+   */
+  unregister(pluginName) {
+    return this.plugins.delete(pluginName);
+  }
+  /**
+   * Get a registered plugin by name
+   */
+  get(pluginName) {
+    return this.plugins.get(pluginName);
+  }
+  /**
+   * Get all registered plugins
+   */
+  getAll() {
+    return Array.from(this.plugins.values());
+  }
+  /**
+   * Check if a plugin is registered
+   */
+  has(pluginName) {
+    return this.plugins.has(pluginName);
+  }
+  /**
+   * Initialize all plugins
+   */
+  async initialize(context) {
+    if (this.initialized) {
+      return;
+    }
+    const logger = getLogger();
+    for (const plugin of this.plugins.values()) {
+      if (hasHook(plugin, "onInit")) {
+        try {
+          logger.debug(`Initializing plugin: ${plugin.name}`);
+          await plugin.hooks.onInit(context);
+        } catch (error) {
+          throw new PluginError(
+            `Failed to initialize plugin "${plugin.name}": ${error instanceof Error ? error.message : String(error)}`,
+            plugin.name,
+            { originalError: error }
+          );
+        }
+      }
+    }
+    this.initialized = true;
+  }
+  /**
+   * Run beforeGenerate hooks on all plugins
+   */
+  async runBeforeGenerate(context, schema) {
+    const logger = getLogger();
+    for (const plugin of this.plugins.values()) {
+      if (hasHook(plugin, "onBeforeGenerate")) {
+        try {
+          logger.debug(`Running beforeGenerate for plugin: ${plugin.name}`);
+          await plugin.hooks.onBeforeGenerate(context, schema);
+        } catch (error) {
+          throw new PluginError(
+            `Plugin "${plugin.name}" failed in beforeGenerate: ${error instanceof Error ? error.message : String(error)}`,
+            plugin.name,
+            { originalError: error }
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Run afterGenerate hooks on all plugins
+   */
+  async runAfterGenerate(context, files) {
+    const logger = getLogger();
+    for (const plugin of this.plugins.values()) {
+      if (hasHook(plugin, "onAfterGenerate")) {
+        try {
+          logger.debug(`Running afterGenerate for plugin: ${plugin.name}`);
+          await plugin.hooks.onAfterGenerate(context, files);
+        } catch (error) {
+          throw new PluginError(
+            `Plugin "${plugin.name}" failed in afterGenerate: ${error instanceof Error ? error.message : String(error)}`,
+            plugin.name,
+            { originalError: error }
+          );
+        }
+      }
+    }
+  }
+  // ============================================================================
+  // Generator Access
+  // ============================================================================
+  /**
+   * Get a generator by name from any registered plugin
+   */
+  getGenerator(name) {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.generators && name in plugin.generators) {
+        return plugin.generators[name];
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get all generators from all plugins
+   */
+  getAllGenerators() {
+    const generators = /* @__PURE__ */ new Map();
+    for (const plugin of this.plugins.values()) {
+      if (plugin.generators) {
+        for (const [name, generator] of Object.entries(plugin.generators)) {
+          generators.set(name, { plugin: plugin.name, generator });
+        }
+      }
+    }
+    return generators;
+  }
+  /**
+   * Get all generator names
+   */
+  getGeneratorNames() {
+    const names = [];
+    for (const plugin of this.plugins.values()) {
+      names.push(...getGeneratorNames(plugin));
+    }
+    return names;
+  }
+  // ============================================================================
+  // Field Type Access
+  // ============================================================================
+  /**
+   * Get a field type handler by name from any registered plugin
+   */
+  getFieldType(name) {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.fieldTypes && name in plugin.fieldTypes) {
+        return plugin.fieldTypes[name];
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get all field types from all plugins
+   */
+  getAllFieldTypes() {
+    const fieldTypes = /* @__PURE__ */ new Map();
+    for (const plugin of this.plugins.values()) {
+      if (plugin.fieldTypes) {
+        for (const [name, handler] of Object.entries(plugin.fieldTypes)) {
+          fieldTypes.set(name, { plugin: plugin.name, handler });
+        }
+      }
+    }
+    return fieldTypes;
+  }
+  /**
+   * Get all field type names
+   */
+  getFieldTypeNames() {
+    const names = [];
+    for (const plugin of this.plugins.values()) {
+      names.push(...getFieldTypeNames(plugin));
+    }
+    return names;
+  }
+  // ============================================================================
+  // Command Access
+  // ============================================================================
+  /**
+   * Get a command by name from any registered plugin
+   */
+  getCommand(name) {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.commands) {
+        const command = plugin.commands.find((cmd) => cmd.name === name);
+        if (command) {
+          return command;
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get all commands from all plugins
+   */
+  getAllCommands() {
+    const commands = /* @__PURE__ */ new Map();
+    for (const plugin of this.plugins.values()) {
+      if (plugin.commands) {
+        for (const command of plugin.commands) {
+          commands.set(command.name, { plugin: plugin.name, command });
+        }
+      }
+    }
+    return commands;
+  }
+  /**
+   * Get all command names
+   */
+  getCommandNames() {
+    const names = [];
+    for (const plugin of this.plugins.values()) {
+      names.push(...getCommandNames(plugin));
+    }
+    return names;
+  }
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+  /**
+   * Get plugin summary
+   */
+  getSummary() {
+    const plugins = [];
+    for (const plugin of this.plugins.values()) {
+      plugins.push({
+        name: plugin.name,
+        version: plugin.version,
+        description: plugin.description,
+        generators: getGeneratorNames(plugin),
+        fieldTypes: getFieldTypeNames(plugin),
+        commands: getCommandNames(plugin)
+      });
+    }
+    return {
+      count: this.plugins.size,
+      plugins
+    };
+  }
+  /**
+   * Clear all registered plugins
+   */
+  clear() {
+    this.plugins.clear();
+    this.initialized = false;
+  }
+};
+var globalPluginManager = null;
+function getPluginManager() {
+  if (!globalPluginManager) {
+    globalPluginManager = new PluginManager();
+  }
+  return globalPluginManager;
+}
+function createPluginManager() {
+  return new PluginManager();
+}
+function resetPluginManager() {
+  if (globalPluginManager) {
+    globalPluginManager.clear();
+  }
+  globalPluginManager = null;
+}
+export {
+  PluginManager,
+  createPlugin,
+  createPluginManager,
+  getCommandNames,
+  getFieldTypeNames,
+  getGeneratorNames,
+  getPluginManager,
+  hasCommand,
+  hasFieldType,
+  hasGenerator,
+  hasHook,
+  resetPluginManager
+};
+//# sourceMappingURL=index.js.map