chore: wip

Author: chrisbbreuer

storage/framework/core/buddy/src/config.ts

@@ -3,6 +3,31 @@ import { existsSync } from 'node:fs'
 import { log } from '@stacksjs/cli'
 import { path as p } from '@stacksjs/path'
 
+export interface BuddyPlugin {
+  /**
+   * Plugin name
+   */
+  name: string
+
+  /**
+   * Plugin version
+   */
+  version?: string
+
+  /**
+   * Plugin setup function
+   */
+  setup: (cli: CLI) => void | Promise<void>
+
+  /**
+   * Plugin hooks
+   */
+  hooks?: {
+    beforeCommand?: (context: any) => void | Promise<void>
+    afterCommand?: (context: any) => void | Promise<void>
+  }
+}
+
 export interface BuddyConfig {
   /**
    * CLI theme to use (default, dracula, nord, solarized, monokai)
@@ -32,6 +57,192 @@ export interface BuddyConfig {
    * Aliases for commands
    */
   aliases?: Record<string, string>
+
+  /**
+   * Plugins to load
+   */
+  plugins?: Array<BuddyPlugin | string>
+}
+
+interface ValidationError {
+  path: string
+  message: string
+  value?: any
+}
+
+/**
+ * Validate the buddy config structure
+ */
+export function validateConfig(config: any): ValidationError[] {
+  const errors: ValidationError[] = []
+
+  if (typeof config !== 'object' || config === null) {
+    errors.push({
+      path: 'config',
+      message: 'Config must be an object',
+      value: config,
+    })
+    return errors
+  }
+
+  // Validate theme
+  if (config.theme !== undefined) {
+    const validThemes = ['default', 'dracula', 'nord', 'solarized', 'monokai']
+    if (typeof config.theme !== 'string' || !validThemes.includes(config.theme)) {
+      errors.push({
+        path: 'theme',
+        message: `Theme must be one of: ${validThemes.join(', ')}`,
+        value: config.theme,
+      })
+    }
+  }
+
+  // Validate emoji
+  if (config.emoji !== undefined && typeof config.emoji !== 'boolean') {
+    errors.push({
+      path: 'emoji',
+      message: 'Emoji must be a boolean',
+      value: config.emoji,
+    })
+  }
+
+  // Validate commands
+  if (config.commands !== undefined) {
+    if (!Array.isArray(config.commands)) {
+      errors.push({
+        path: 'commands',
+        message: 'Commands must be an array',
+        value: config.commands,
+      })
+    }
+    else {
+      config.commands.forEach((cmd: any, index: number) => {
+        if (typeof cmd !== 'function') {
+          errors.push({
+            path: `commands[${index}]`,
+            message: 'Each command must be a function',
+            value: cmd,
+          })
+        }
+      })
+    }
+  }
+
+  // Validate defaultFlags
+  if (config.defaultFlags !== undefined) {
+    if (typeof config.defaultFlags !== 'object' || config.defaultFlags === null) {
+      errors.push({
+        path: 'defaultFlags',
+        message: 'Default flags must be an object',
+        value: config.defaultFlags,
+      })
+    }
+    else {
+      const flagKeys = ['verbose', 'quiet', 'debug']
+      for (const key of Object.keys(config.defaultFlags)) {
+        if (!flagKeys.includes(key)) {
+          errors.push({
+            path: `defaultFlags.${key}`,
+            message: `Unknown flag. Valid flags are: ${flagKeys.join(', ')}`,
+            value: config.defaultFlags[key],
+          })
+        }
+        else if (typeof config.defaultFlags[key] !== 'boolean') {
+          errors.push({
+            path: `defaultFlags.${key}`,
+            message: 'Flag value must be a boolean',
+            value: config.defaultFlags[key],
+          })
+        }
+      }
+    }
+  }
+
+  // Validate aliases
+  if (config.aliases !== undefined) {
+    if (typeof config.aliases !== 'object' || config.aliases === null || Array.isArray(config.aliases)) {
+      errors.push({
+        path: 'aliases',
+        message: 'Aliases must be an object mapping alias names to command names',
+        value: config.aliases,
+      })
+    }
+    else {
+      for (const [alias, command] of Object.entries(config.aliases)) {
+        if (typeof command !== 'string') {
+          errors.push({
+            path: `aliases.${alias}`,
+            message: 'Alias target must be a string',
+            value: command,
+          })
+        }
+      }
+    }
+  }
+
+  // Validate plugins
+  if (config.plugins !== undefined) {
+    if (!Array.isArray(config.plugins)) {
+      errors.push({
+        path: 'plugins',
+        message: 'Plugins must be an array',
+        value: config.plugins,
+      })
+    }
+    else {
+      config.plugins.forEach((plugin: any, index: number) => {
+        if (typeof plugin === 'string') {
+          // String plugins are module paths, which is valid
+          return
+        }
+        if (typeof plugin !== 'object' || plugin === null) {
+          errors.push({
+            path: `plugins[${index}]`,
+            message: 'Each plugin must be an object or a string (module path)',
+            value: plugin,
+          })
+          return
+        }
+        if (!plugin.name || typeof plugin.name !== 'string') {
+          errors.push({
+            path: `plugins[${index}].name`,
+            message: 'Plugin must have a name property of type string',
+            value: plugin.name,
+          })
+        }
+        if (!plugin.setup || typeof plugin.setup !== 'function') {
+          errors.push({
+            path: `plugins[${index}].setup`,
+            message: 'Plugin must have a setup function',
+            value: plugin.setup,
+          })
+        }
+        if (plugin.hooks !== undefined) {
+          if (typeof plugin.hooks !== 'object' || plugin.hooks === null) {
+            errors.push({
+              path: `plugins[${index}].hooks`,
+              message: 'Plugin hooks must be an object',
+              value: plugin.hooks,
+            })
+          }
+        }
+      })
+    }
+  }
+
+  // Check for unknown keys
+  const validKeys = ['theme', 'emoji', 'commands', 'defaultFlags', 'aliases', 'plugins']
+  for (const key of Object.keys(config)) {
+    if (!validKeys.includes(key)) {
+      errors.push({
+        path: key,
+        message: `Unknown configuration key. Valid keys are: ${validKeys.join(', ')}`,
+        value: config[key],
+      })
+    }
+  }
+
+  return errors
 }
 
 let cachedConfig: BuddyConfig | null = null
@@ -56,7 +267,19 @@ export async function loadBuddyConfig(): Promise<BuddyConfig> {
       try {
         log.debug(`Loading buddy config from ${configPath}`)
         const configModule = await import(configPath)
-        cachedConfig = configModule.default || configModule
+        const config = configModule.default || configModule
+
+        // Validate config
+        const validationErrors = validateConfig(config)
+        if (validationErrors.length > 0) {
+          log.error('Invalid buddy.config.ts:')
+          for (const error of validationErrors) {
+            log.error(`  - ${error.path}: ${error.message}`)
+          }
+          throw new Error('Configuration validation failed')
+        }
+
+        cachedConfig = config
         return cachedConfig
       }
       catch (error) {
@@ -70,6 +293,65 @@ export async function loadBuddyConfig(): Promise<BuddyConfig> {
   return cachedConfig
 }
 
+/**
+ * Load and initialize plugins
+ */
+export async function loadPlugins(cli: CLI, config: BuddyConfig): Promise<void> {
+  if (!config.plugins || config.plugins.length === 0) {
+    return
+  }
+
+  log.debug(`Loading ${config.plugins.length} plugin(s)`)
+
+  for (const pluginConfig of config.plugins) {
+    let plugin: BuddyPlugin
+
+    // If plugin is a string, it's a module path
+    if (typeof pluginConfig === 'string') {
+      try {
+        const pluginModule = await import(pluginConfig)
+        plugin = pluginModule.default || pluginModule
+      }
+      catch (error) {
+        log.error(`Failed to load plugin from ${pluginConfig}:`, error)
+        continue
+      }
+    }
+    else {
+      plugin = pluginConfig
+    }
+
+    // Run plugin setup
+    try {
+      log.debug(`Initializing plugin: ${plugin.name}${plugin.version ? ` v${plugin.version}` : ''}`)
+      await plugin.setup(cli)
+
+      // Register plugin hooks if provided
+      if (plugin.hooks) {
+        if (plugin.hooks.beforeCommand) {
+          cli.on('command:*', async (command) => {
+            if (plugin.hooks?.beforeCommand) {
+              await plugin.hooks.beforeCommand({ command })
+            }
+          })
+        }
+        if (plugin.hooks.afterCommand) {
+          cli.on('command:*', async (command) => {
+            if (plugin.hooks?.afterCommand) {
+              await plugin.hooks.afterCommand({ command })
+            }
+          })
+        }
+      }
+
+      log.debug(`Plugin ${plugin.name} initialized successfully`)
+    }
+    catch (error) {
+      log.error(`Failed to initialize plugin ${plugin.name}:`, error)
+    }
+  }
+}
+
 /**
  * Apply buddy config to CLI instance
  */