create-fluxstack 1.0.4 → 1.0.6

package/my-final-test/core/plugins/discovery.ts

@@ -1,350 +0,0 @@
-/**
- * Plugin Discovery System
- * Handles automatic discovery and loading of plugins from various sources
- */
-
-import type { Plugin, PluginManifest, PluginLoadResult, PluginDiscoveryOptions } from "./types"
-import type { Logger } from "../utils/logger/index"
-import { readdir, readFile } from "fs/promises"
-import { join, resolve } from "path"
-import { existsSync } from "fs"
-
-export interface PluginDiscoveryConfig {
-  logger?: Logger
-  baseDir?: string
-  builtInDir?: string
-  externalDir?: string
-  nodeModulesDir?: string
-}
-
-export class PluginDiscovery {
-  private logger?: Logger
-  private baseDir: string
-  private builtInDir: string
-  private externalDir: string
-  private nodeModulesDir: string
-
-  constructor(config: PluginDiscoveryConfig = {}) {
-    this.logger = config.logger
-    this.baseDir = config.baseDir || process.cwd()
-    this.builtInDir = config.builtInDir || join(this.baseDir, 'core/plugins/built-in')
-    this.externalDir = config.externalDir || join(this.baseDir, 'plugins')
-    this.nodeModulesDir = config.nodeModulesDir || join(this.baseDir, 'node_modules')
-  }
-
-  /**
-   * Discover all available plugins
-   */
-  async discoverAll(options: PluginDiscoveryOptions = {}): Promise<PluginLoadResult[]> {
-    const results: PluginLoadResult[] = []
-    const {
-      includeBuiltIn = true,
-      includeExternal = true
-    } = options
-
-    // Discover built-in plugins
-    if (includeBuiltIn) {
-      const builtInResults = await this.discoverBuiltInPlugins()
-      results.push(...builtInResults)
-    }
-
-    // Discover external plugins
-    if (includeExternal) {
-      const externalResults = await this.discoverExternalPlugins()
-      results.push(...externalResults)
-      
-      const npmResults = await this.discoverNpmPlugins()
-      results.push(...npmResults)
-    }
-
-    return results
-  }
-
-  /**
-   * Discover built-in plugins
-   */
-  async discoverBuiltInPlugins(): Promise<PluginLoadResult[]> {
-    if (!existsSync(this.builtInDir)) {
-      this.logger?.debug('Built-in plugins directory not found', { dir: this.builtInDir })
-      return []
-    }
-
-    return this.discoverPluginsInDirectory(this.builtInDir, 'built-in')
-  }
-
-  /**
-   * Discover external plugins in the plugins directory
-   */
-  async discoverExternalPlugins(): Promise<PluginLoadResult[]> {
-    if (!existsSync(this.externalDir)) {
-      this.logger?.debug('External plugins directory not found', { dir: this.externalDir })
-      return []
-    }
-
-    return this.discoverPluginsInDirectory(this.externalDir, 'external')
-  }
-
-  /**
-   * Discover npm-installed plugins
-   */
-  async discoverNpmPlugins(): Promise<PluginLoadResult[]> {
-    if (!existsSync(this.nodeModulesDir)) {
-      this.logger?.debug('Node modules directory not found', { dir: this.nodeModulesDir })
-      return []
-    }
-
-    const results: PluginLoadResult[] = []
-
-    try {
-      const entries = await readdir(this.nodeModulesDir, { withFileTypes: true })
-      
-      for (const entry of entries) {
-        if (entry.isDirectory() && entry.name.startsWith('fluxstack-plugin-')) {
-          const pluginDir = join(this.nodeModulesDir, entry.name)
-          const result = await this.loadPluginFromDirectory(pluginDir, 'npm')
-          results.push(result)
-        }
-      }
-    } catch (error) {
-      this.logger?.error('Failed to discover npm plugins', { error })
-    }
-
-    return results
-  }
-
-  /**
-   * Load a specific plugin by name
-   */
-  async loadPlugin(name: string): Promise<PluginLoadResult> {
-    // Try built-in first
-    const builtInPath = join(this.builtInDir, name)
-    if (existsSync(builtInPath)) {
-      return this.loadPluginFromDirectory(builtInPath, 'built-in')
-    }
-
-    // Try external plugins
-    const externalPath = join(this.externalDir, name)
-    if (existsSync(externalPath)) {
-      return this.loadPluginFromDirectory(externalPath, 'external')
-    }
-
-    // Try npm plugins
-    const npmPath = join(this.nodeModulesDir, `fluxstack-plugin-${name}`)
-    if (existsSync(npmPath)) {
-      return this.loadPluginFromDirectory(npmPath, 'npm')
-    }
-
-    return {
-      success: false,
-      error: `Plugin '${name}' not found in any plugin directory`
-    }
-  }
-
-  /**
-   * Discover plugins in a specific directory
-   */
-  private async discoverPluginsInDirectory(
-    directory: string,
-    source: 'built-in' | 'external' | 'npm'
-  ): Promise<PluginLoadResult[]> {
-    const results: PluginLoadResult[] = []
-
-    try {
-      const entries = await readdir(directory, { withFileTypes: true })
-
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          const pluginDir = join(directory, entry.name)
-          const result = await this.loadPluginFromDirectory(pluginDir, source)
-          results.push(result)
-        }
-      }
-    } catch (error) {
-      this.logger?.error(`Failed to discover plugins in directory '${directory}'`, { error })
-      results.push({
-        success: false,
-        error: `Failed to scan directory: ${error instanceof Error ? error.message : String(error)}`
-      })
-    }
-
-    return results
-  }
-
-  /**
-   * Load a plugin from a specific directory
-   */
-  private async loadPluginFromDirectory(
-    pluginDir: string,
-    source: 'built-in' | 'external' | 'npm'
-  ): Promise<PluginLoadResult> {
-    try {
-      // Load manifest if it exists
-      const manifest = await this.loadPluginManifest(pluginDir)
-      
-      // Find the main plugin file
-      const pluginFile = await this.findPluginFile(pluginDir)
-      if (!pluginFile) {
-        return {
-          success: false,
-          error: 'No plugin entry point found (index.ts, index.js, plugin.ts, or plugin.js)'
-        }
-      }
-
-      // Import the plugin
-      const pluginModule = await import(resolve(pluginFile))
-      const plugin: Plugin = pluginModule.default || pluginModule
-
-      if (!this.isValidPlugin(plugin)) {
-        return {
-          success: false,
-          error: 'Invalid plugin: must export a plugin object with a name property'
-        }
-      }
-
-      // Validate manifest compatibility
-      const warnings: string[] = []
-      if (manifest) {
-        const manifestWarnings = this.validateManifestCompatibility(plugin, manifest)
-        warnings.push(...manifestWarnings)
-      } else {
-        warnings.push('No plugin manifest found')
-      }
-
-      this.logger?.debug(`Loaded plugin '${plugin.name}' from ${source}`, {
-        plugin: plugin.name,
-        version: plugin.version,
-        source,
-        path: pluginDir
-      })
-
-      return {
-        success: true,
-        plugin,
-        warnings
-      }
-    } catch (error) {
-      this.logger?.error(`Failed to load plugin from '${pluginDir}'`, { error })
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      }
-    }
-  }
-
-  /**
-   * Load plugin manifest from directory
-   */
-  private async loadPluginManifest(pluginDir: string): Promise<PluginManifest | undefined> {
-    const manifestPath = join(pluginDir, 'plugin.json')
-    
-    if (!existsSync(manifestPath)) {
-      // Try package.json for npm plugins
-      const packagePath = join(pluginDir, 'package.json')
-      if (existsSync(packagePath)) {
-        try {
-          const packageContent = await readFile(packagePath, 'utf-8')
-          const packageJson = JSON.parse(packageContent)
-          
-          if (packageJson.fluxstack) {
-            return {
-              name: packageJson.name,
-              version: packageJson.version,
-              description: packageJson.description || '',
-              author: packageJson.author || '',
-              license: packageJson.license || '',
-              homepage: packageJson.homepage,
-              repository: packageJson.repository,
-              keywords: packageJson.keywords || [],
-              dependencies: packageJson.dependencies || {},
-              peerDependencies: packageJson.peerDependencies,
-              fluxstack: packageJson.fluxstack
-            }
-          }
-        } catch (error) {
-          this.logger?.warn(`Failed to parse package.json in '${pluginDir}'`, { error })
-        }
-      }
-      return undefined
-    }
-
-    try {
-      const manifestContent = await readFile(manifestPath, 'utf-8')
-      return JSON.parse(manifestContent)
-    } catch (error) {
-      this.logger?.warn(`Failed to parse plugin manifest in '${pluginDir}'`, { error })
-      return undefined
-    }
-  }
-
-  /**
-   * Find the main plugin file in a directory
-   */
-  private async findPluginFile(pluginDir: string): Promise<string | null> {
-    const possibleFiles = [
-      'index.ts',
-      'index.js',
-      'plugin.ts',
-      'plugin.js',
-      'src/index.ts',
-      'src/index.js',
-      'dist/index.js'
-    ]
-
-    for (const file of possibleFiles) {
-      const filePath = join(pluginDir, file)
-      if (existsSync(filePath)) {
-        return filePath
-      }
-    }
-
-    return null
-  }
-
-  /**
-   * Validate if an object is a valid plugin
-   */
-  private isValidPlugin(plugin: any): plugin is Plugin {
-    return (
-      plugin &&
-      typeof plugin === 'object' &&
-      typeof plugin.name === 'string' &&
-      plugin.name.length > 0
-    )
-  }
-
-  /**
-   * Validate manifest compatibility with plugin
-   */
-  private validateManifestCompatibility(plugin: Plugin, manifest: PluginManifest): string[] {
-    const warnings: string[] = []
-
-    if (plugin.name !== manifest.name) {
-      warnings.push(`Plugin name mismatch: plugin exports '${plugin.name}' but manifest declares '${manifest.name}'`)
-    }
-
-    if (plugin.version && plugin.version !== manifest.version) {
-      warnings.push(`Plugin version mismatch: plugin exports '${plugin.version}' but manifest declares '${manifest.version}'`)
-    }
-
-    if (plugin.dependencies && manifest.fluxstack.hooks) {
-      // Check if plugin implements the hooks declared in manifest
-      const declaredHooks = manifest.fluxstack.hooks
-      const implementedHooks = Object.keys(plugin).filter(key => 
-        key.startsWith('on') || key === 'setup'
-      )
-      
-      for (const hook of declaredHooks) {
-        if (!implementedHooks.includes(hook)) {
-          warnings.push(`Plugin declares hook '${hook}' in manifest but doesn't implement it`)
-        }
-      }
-    }
-
-    return warnings
-  }
-}
-
-/**
- * Default plugin discovery instance
- */
-export const pluginDiscovery = new PluginDiscovery()

package/my-final-test/core/plugins/executor.ts

@@ -1,351 +0,0 @@
-/**
- * Plugin Executor
- * Handles plugin execution with priority and dependency resolution
- */
-
-import type { 
-  Plugin, 
-  PluginHook, 
-  PluginHookResult,
-  PluginPriority,
-  HookExecutionOptions
-} from "./types"
-import type { Logger } from "../utils/logger/index"
-import { FluxStackError } from "../utils/errors"
-
-export interface PluginExecutionPlan {
-  hook: PluginHook
-  plugins: PluginExecutionStep[]
-  parallel: boolean
-  totalPlugins: number
-}
-
-export interface PluginExecutionStep {
-  plugin: Plugin
-  priority: number
-  dependencies: string[]
-  dependents: string[]
-  canExecuteInParallel: boolean
-}
-
-export class PluginExecutor {
-  private logger: Logger
-
-  constructor(logger: Logger) {
-    this.logger = logger
-  }
-
-  /**
-   * Create execution plan for a hook
-   */
-  createExecutionPlan(
-    plugins: Plugin[],
-    hook: PluginHook,
-    options: HookExecutionOptions = {}
-  ): PluginExecutionPlan {
-    const { parallel = false } = options
-
-    // Filter plugins that implement this hook
-    const applicablePlugins = plugins.filter(plugin => {
-      const hookFunction = plugin[hook]
-      return hookFunction && typeof hookFunction === 'function'
-    })
-
-    // Create execution steps
-    const steps = applicablePlugins.map(plugin => this.createExecutionStep(plugin, plugins))
-
-    // Sort by priority and dependencies
-    const sortedSteps = this.sortExecutionSteps(steps, hook)
-
-    return {
-      hook,
-      plugins: sortedSteps,
-      parallel,
-      totalPlugins: applicablePlugins.length
-    }
-  }
-
-  /**
-   * Execute plugins according to plan
-   */
-  async executePlan(
-    plan: PluginExecutionPlan,
-    context: any,
-    executor: (plugin: Plugin, hook: PluginHook, context: any) => Promise<PluginHookResult>
-  ): Promise<PluginHookResult[]> {
-    const results: PluginHookResult[] = []
-
-    this.logger.debug(`Executing plan for hook '${plan.hook}'`, {
-      hook: plan.hook,
-      totalPlugins: plan.totalPlugins,
-      parallel: plan.parallel
-    })
-
-    if (plan.parallel) {
-      // Execute in parallel groups based on dependencies
-      const groups = this.createParallelGroups(plan.plugins)
-      
-      for (const group of groups) {
-        const groupPromises = group.map(step => 
-          executor(step.plugin, plan.hook, context)
-        )
-        
-        const groupResults = await Promise.allSettled(groupPromises)
-        
-        for (let i = 0; i < groupResults.length; i++) {
-          const result = groupResults[i]
-          if (result.status === 'fulfilled') {
-            results.push(result.value)
-          } else {
-            results.push({
-              success: false,
-              error: result.reason,
-              duration: 0,
-              plugin: group[i].plugin.name,
-              hook: plan.hook
-            })
-          }
-        }
-      }
-    } else {
-      // Execute sequentially
-      for (const step of plan.plugins) {
-        const result = await executor(step.plugin, plan.hook, context)
-        results.push(result)
-      }
-    }
-
-    return results
-  }
-
-  /**
-   * Validate execution plan
-   */
-  validateExecutionPlan(plan: PluginExecutionPlan): { valid: boolean; errors: string[] } {
-    const errors: string[] = []
-
-    // Check for circular dependencies
-    const visited = new Set<string>()
-    const visiting = new Set<string>()
-
-    const checkCircular = (step: PluginExecutionStep) => {
-      if (visiting.has(step.plugin.name)) {
-        errors.push(`Circular dependency detected involving plugin '${step.plugin.name}'`)
-        return
-      }
-
-      if (visited.has(step.plugin.name)) {
-        return
-      }
-
-      visiting.add(step.plugin.name)
-
-      for (const depName of step.dependencies) {
-        const depStep = plan.plugins.find(s => s.plugin.name === depName)
-        if (depStep) {
-          checkCircular(depStep)
-        }
-      }
-
-      visiting.delete(step.plugin.name)
-      visited.add(step.plugin.name)
-    }
-
-    for (const step of plan.plugins) {
-      checkCircular(step)
-    }
-
-    // Check for missing dependencies
-    for (const step of plan.plugins) {
-      for (const depName of step.dependencies) {
-        const depExists = plan.plugins.some(s => s.plugin.name === depName)
-        if (!depExists) {
-          errors.push(`Plugin '${step.plugin.name}' depends on '${depName}' which is not available`)
-        }
-      }
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors
-    }
-  }
-
-  /**
-   * Create execution step for a plugin
-   */
-  private createExecutionStep(plugin: Plugin, allPlugins: Plugin[]): PluginExecutionStep {
-    const priority = this.normalizePriority(plugin.priority)
-    const dependencies = plugin.dependencies || []
-    
-    // Find dependents
-    const dependents = allPlugins
-      .filter(p => p.dependencies?.includes(plugin.name))
-      .map(p => p.name)
-
-    // Determine if can execute in parallel
-    const canExecuteInParallel = dependencies.length === 0
-
-    return {
-      plugin,
-      priority,
-      dependencies,
-      dependents,
-      canExecuteInParallel
-    }
-  }
-
-  /**
-   * Sort execution steps by priority and dependencies
-   */
-  private sortExecutionSteps(steps: PluginExecutionStep[], hook: PluginHook): PluginExecutionStep[] {
-    // Topological sort with priority consideration
-    const sorted: PluginExecutionStep[] = []
-    const visited = new Set<string>()
-    const visiting = new Set<string>()
-
-    const visit = (step: PluginExecutionStep) => {
-      if (visiting.has(step.plugin.name)) {
-        throw new FluxStackError(
-          `Circular dependency detected involving plugin '${step.plugin.name}' for hook '${hook}'`,
-          'CIRCULAR_DEPENDENCY',
-          400
-        )
-      }
-
-      if (visited.has(step.plugin.name)) {
-        return
-      }
-
-      visiting.add(step.plugin.name)
-
-      // Visit dependencies first
-      for (const depName of step.dependencies) {
-        const depStep = steps.find(s => s.plugin.name === depName)
-        if (depStep) {
-          visit(depStep)
-        }
-      }
-
-      visiting.delete(step.plugin.name)
-      visited.add(step.plugin.name)
-      sorted.push(step)
-    }
-
-    // Sort by priority first, then visit
-    const prioritySorted = [...steps].sort((a, b) => b.priority - a.priority)
-    
-    for (const step of prioritySorted) {
-      visit(step)
-    }
-
-    return sorted
-  }
-
-  /**
-   * Create parallel execution groups
-   */
-  private createParallelGroups(steps: PluginExecutionStep[]): PluginExecutionStep[][] {
-    const groups: PluginExecutionStep[][] = []
-    const processed = new Set<string>()
-
-    while (processed.size < steps.length) {
-      const currentGroup: PluginExecutionStep[] = []
-
-      for (const step of steps) {
-        if (processed.has(step.plugin.name)) {
-          continue
-        }
-
-        // Check if all dependencies are already processed
-        const canExecute = step.dependencies.every(dep => processed.has(dep))
-        
-        if (canExecute) {
-          currentGroup.push(step)
-          processed.add(step.plugin.name)
-        }
-      }
-
-      if (currentGroup.length === 0) {
-        // This shouldn't happen if dependencies are valid
-        const remaining = steps.filter(s => !processed.has(s.plugin.name))
-        throw new FluxStackError(
-          `Unable to resolve dependencies for plugins: ${remaining.map(s => s.plugin.name).join(', ')}`,
-          'DEPENDENCY_RESOLUTION_ERROR',
-          400
-        )
-      }
-
-      // Sort group by priority
-      currentGroup.sort((a, b) => b.priority - a.priority)
-      groups.push(currentGroup)
-    }
-
-    return groups
-  }
-
-  /**
-   * Normalize plugin priority to numeric value
-   */
-  private normalizePriority(priority?: number | PluginPriority): number {
-    if (typeof priority === 'number') {
-      return priority
-    }
-
-    switch (priority) {
-      case 'highest': return 1000
-      case 'high': return 750
-      case 'normal': return 500
-      case 'low': return 250
-      case 'lowest': return 0
-      default: return 500 // default to normal
-    }
-  }
-}
-
-/**
- * Plugin execution statistics
- */
-export interface PluginExecutionStats {
-  totalPlugins: number
-  successfulPlugins: number
-  failedPlugins: number
-  totalDuration: number
-  averageDuration: number
-  slowestPlugin: { name: string; duration: number } | null
-  fastestPlugin: { name: string; duration: number } | null
-}
-
-/**
- * Calculate execution statistics
- */
-export function calculateExecutionStats(results: PluginHookResult[]): PluginExecutionStats {
-  const totalPlugins = results.length
-  const successfulPlugins = results.filter(r => r.success).length
-  const failedPlugins = totalPlugins - successfulPlugins
-  const totalDuration = results.reduce((sum, r) => sum + r.duration, 0)
-  const averageDuration = totalPlugins > 0 ? totalDuration / totalPlugins : 0
-
-  let slowestPlugin: { name: string; duration: number } | null = null
-  let fastestPlugin: { name: string; duration: number } | null = null
-
-  for (const result of results) {
-    if (!slowestPlugin || result.duration > slowestPlugin.duration) {
-      slowestPlugin = { name: result.plugin, duration: result.duration }
-    }
-    
-    if (!fastestPlugin || result.duration < fastestPlugin.duration) {
-      fastestPlugin = { name: result.plugin, duration: result.duration }
-    }
-  }
-
-  return {
-    totalPlugins,
-    successfulPlugins,
-    failedPlugins,
-    totalDuration,
-    averageDuration,
-    slowestPlugin,
-    fastestPlugin
-  }
-}