create-fluxstack 1.5.0 → 1.5.1

package/core/cli/plugin-discovery.ts

@@ -10,14 +10,14 @@ export class CliPluginDiscovery {
   async discoverAndRegisterCommands(): Promise<void> {
     // 1. Load built-in plugins with CLI commands
     await this.loadBuiltInPlugins()
-
+    
     // 2. Load local plugins from project
     await this.loadLocalPlugins()
   }
 
   private async loadBuiltInPlugins(): Promise<void> {
     const builtInPluginsDir = join(__dirname, '../plugins/built-in')
-
+    
     if (!existsSync(builtInPluginsDir)) {
       return
     }
@@ -33,7 +33,7 @@ export class CliPluginDiscovery {
           const pluginPath = join(builtInPluginsDir, pluginName, 'index.ts')
           if (existsSync(pluginPath)) {
             const pluginModule = await import(pluginPath)
-
+            
             if (pluginModule.commands) {
               for (const command of pluginModule.commands) {
                 cliRegistry.register(command)
@@ -57,7 +57,7 @@ export class CliPluginDiscovery {
 
   private async loadLocalPlugins(): Promise<void> {
     const localPluginsDir = join(process.cwd(), 'plugins')
-
+    
     if (!existsSync(localPluginsDir)) {
       return
     }
@@ -65,18 +65,17 @@ export class CliPluginDiscovery {
     try {
       const fs = await import('fs')
       const entries = fs.readdirSync(localPluginsDir, { withFileTypes: true })
-
+      
       for (const entry of entries) {
-        // Buscar arquivos .ts/.js diretamente
         if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.js'))) {
           const pluginPath = join(localPluginsDir, entry.name)
-
+          
           try {
             const pluginModule = await import(pluginPath)
             const plugin = pluginModule.default || Object.values(pluginModule).find(
               (exp: any) => exp && typeof exp === 'object' && exp.name && exp.commands
             ) as Plugin
-
+            
             if (plugin && plugin.commands) {
               this.registerPluginCommands(plugin)
             }
@@ -84,26 +83,6 @@ export class CliPluginDiscovery {
             logger.debug(`Failed to load local plugin ${entry.name}:`, error)
           }
         }
-
-        // ✅ Buscar em subdiretórios (plugins/nome-plugin/index.ts)
-        if (entry.isDirectory()) {
-          const pluginIndexPath = join(localPluginsDir, entry.name, 'index.ts')
-
-          if (existsSync(pluginIndexPath)) {
-            try {
-              const pluginModule = await import(pluginIndexPath)
-              const plugin = pluginModule.default || Object.values(pluginModule).find(
-                (exp: any) => exp && typeof exp === 'object' && exp.name && exp.commands
-              ) as Plugin
-
-              if (plugin && plugin.commands) {
-                this.registerPluginCommands(plugin)
-              }
-            } catch (error) {
-              logger.debug(`Failed to load local plugin ${entry.name}:`, error)
-            }
-          }
-        }
       }
     } catch (error) {
       logger.debug('Failed to scan local plugins:', error)
@@ -124,9 +103,9 @@ export class CliPluginDiscovery {
           category: command.category || `Plugin: ${plugin.name}`,
           aliases: command.aliases?.map(alias => `${plugin.name}:${alias}`)
         }
-
+        
         cliRegistry.register(prefixedCommand)
-
+        
         // Also register without prefix if no conflict exists
         if (!cliRegistry.has(command.name)) {
           cliRegistry.register({
@@ -135,10 +114,10 @@ export class CliPluginDiscovery {
           })
         }
       }
-
+      
       this.loadedPlugins.add(plugin.name)
       logger.debug(`Registered ${plugin.commands.length} CLI commands from plugin: ${plugin.name}`)
-
+      
     } catch (error) {
       logger.error(`Failed to register CLI commands for plugin ${plugin.name}:`, error)
     }
@@ -149,4 +128,4 @@ export class CliPluginDiscovery {
   }
 }
 
-export const pluginDiscovery = new CliPluginDiscovery()
+export const pluginDiscovery = new CliPluginDiscovery()

package/core/framework/server.ts

@@ -469,16 +469,6 @@ export class FluxStackFramework {
         }
       }
 
-      // Mount plugin routes if they have a plugin property
-      for (const pluginName of loadOrder) {
-        const plugin = this.pluginRegistry.get(pluginName)!
-
-        if ((plugin as any).plugin) {
-          this.app.use((plugin as any).plugin)
-          logger.debug(`Plugin '${pluginName}' routes mounted`)
-        }
-      }
-
       // Call onServerStart hooks
       for (const pluginName of loadOrder) {
         const plugin = this.pluginRegistry.get(pluginName)!

package/core/plugins/dependency-manager.ts

@@ -136,8 +136,6 @@ export class PluginDependencyManager {
 
   /**
    * Instalar dependências de plugins
-   * NOVA ESTRATÉGIA: Instala no node_modules local do plugin primeiro,
-   * com fallback para o projeto principal
    */
   async installPluginDependencies(resolutions: DependencyResolution[]): Promise<void> {
     if (!this.config.autoInstall) {
@@ -145,109 +143,44 @@ export class PluginDependencyManager {
       return
     }
 
-    // Instalar dependências para cada plugin individualmente
-    for (const resolution of resolutions) {
-      if (resolution.dependencies.length === 0) continue
-
-      const pluginPath = this.findPluginDirectory(resolution.plugin)
-      if (!pluginPath) {
-        this.logger?.warn(`Não foi possível encontrar diretório do plugin '${resolution.plugin}'`)
-        continue
-      }
-
-      this.logger?.debug(`📦 Instalando dependências localmente para plugin '${resolution.plugin}'`, {
-        plugin: resolution.plugin,
-        path: pluginPath,
-        dependencies: resolution.dependencies.length
-      })
-
-      try {
-        // Instalar APENAS no node_modules local do plugin
-        await this.installPluginDependenciesLocally(pluginPath, resolution.dependencies)
+    const toInstall: PluginDependency[] = []
+    const conflicts: DependencyConflict[] = []
 
-        this.logger?.debug(`✅ Dependências do plugin '${resolution.plugin}' instaladas localmente`)
-      } catch (error) {
-        this.logger?.error(`❌ Erro ao instalar dependências do plugin '${resolution.plugin}'`, { error })
-        // Continuar com outros plugins
-      }
+    // Coletar todas as dependências e conflitos
+    for (const resolution of resolutions) {
+      toInstall.push(...resolution.dependencies)
+      conflicts.push(...resolution.conflicts)
     }
-  }
-
-  /**
-   * Instalar dependências no diretório local do plugin
-   */
-  private async installPluginDependenciesLocally(pluginPath: string, dependencies: PluginDependency[]): Promise<void> {
-    if (dependencies.length === 0) return
-
-    const regularDeps = dependencies.filter(d => d.type === 'dependency')
-    const peerDeps = dependencies.filter(d => d.type === 'peerDependency' && !d.optional)
-
-    const allDeps = [...regularDeps, ...peerDeps]
-    if (allDeps.length === 0) return
 
-    // Verificar quais dependências já estão instaladas localmente
-    const toInstall = allDeps.filter(dep => {
-      const depPath = join(pluginPath, 'node_modules', dep.name, 'package.json')
-      if (!existsSync(depPath)) {
-        return true // Precisa instalar
-      }
-
-      try {
-        const installedPkg = JSON.parse(readFileSync(depPath, 'utf-8'))
-        const installedVersion = installedPkg.version
-
-        // Verificar se a versão é compatível
-        if (!this.isVersionCompatible(installedVersion, dep.version)) {
-          this.logger?.debug(`📦 Dependência '${dep.name}' está desatualizada (${installedVersion} → ${dep.version})`)
-          return true // Precisa atualizar
-        }
+    // Resolver conflitos primeiro
+    if (conflicts.length > 0) {
+      await this.resolveConflicts(conflicts)
+    }
 
-        return false // Já está instalado corretamente
-      } catch (error) {
-        return true // Erro ao ler, melhor reinstalar
-      }
+    // Filtrar dependências que já estão instaladas
+    const needsInstallation = toInstall.filter(dep => {
+      const installed = this.installedDependencies.get(dep.name)
+      return !installed || !this.isVersionCompatible(installed, dep.version)
     })
 
-    if (toInstall.length === 0) {
-      this.logger?.debug(`✅ Todas as dependências do plugin já estão instaladas`)
+    if (needsInstallation.length === 0) {
+      this.logger?.debug('Todas as dependências de plugins já estão instaladas')
       return
     }
 
-    const packages = toInstall.map(d => `${d.name}@${d.version}`).join(' ')
-    const command = this.getInstallCommand(packages, false)
-
-    this.logger?.debug(`🔧 Instalando ${toInstall.length} dependência(s): ${command}`, { cwd: pluginPath })
+    this.logger?.debug(`Instalando ${needsInstallation.length} dependências de plugins`, {
+      dependencies: needsInstallation.map(d => `${d.name}@${d.version}`)
+    })
 
     try {
-      execSync(command, {
-        cwd: pluginPath,
-        stdio: 'inherit'
-      })
-      this.logger?.debug(`✅ Pacotes instalados localmente em ${pluginPath}`)
+      await this.installDependencies(needsInstallation)
+      this.logger?.debug('Dependências de plugins instaladas com sucesso')
     } catch (error) {
-      this.logger?.error(`❌ Falha ao instalar dependências localmente`, { error, pluginPath })
+      this.logger?.error('Erro ao instalar dependências de plugins', { error })
       throw error
     }
   }
 
-  /**
-   * Encontrar diretório de um plugin pelo nome
-   */
-  private findPluginDirectory(pluginName: string): string | null {
-    const possiblePaths = [
-      `plugins/${pluginName}`,
-      `core/plugins/built-in/${pluginName}`
-    ]
-
-    for (const path of possiblePaths) {
-      if (existsSync(path)) {
-        return resolve(path)
-      }
-    }
-
-    return null
-  }
-
   /**
    * Detectar conflitos de versão
    */

package/core/plugins/index.ts

@@ -54,10 +54,6 @@ export {
 } from './manager'
 export type { PluginManagerConfig } from './manager'
 
-// Module resolver for plugins
-export { PluginModuleResolver } from './module-resolver'
-export type { ModuleResolverConfig } from './module-resolver'
-
 // Plugin executor
 export {
     PluginExecutor,

package/core/plugins/manager.ts

@@ -19,7 +19,7 @@ import type {
 
 type Plugin = FluxStack.Plugin
 import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger"
+import type { Logger } from "../utils/logger/index"
 import { PluginRegistry } from "./registry"
 import { createPluginUtils } from "./config"
 import { FluxStackError } from "../utils/errors"
@@ -422,7 +422,6 @@ export class PluginManager extends EventEmitter {
       // Try to use auto-generated registry for external plugins (if available from build)
       let externalResults: any[] = []
       try {
-        // @ts-expect-error - auto-registry is generated during build, may not exist in dev
         const autoRegistryModule = await import('./auto-registry')
         if (autoRegistryModule.discoveredPlugins && autoRegistryModule.registerDiscoveredPlugins) {
           this.logger.debug('🚀 Using auto-generated external plugins registry')
@@ -433,7 +432,7 @@ export class PluginManager extends EventEmitter {
           }))
         }
       } catch (error) {
-        this.logger.debug('Auto-generated external plugins registry not found, falling back to discovery', { error: (error as Error).message })
+        this.logger.debug('Auto-generated external plugins registry not found, falling back to discovery', { error: error.message })
 
         // Fallback to runtime discovery for external plugins
         this.logger.debug('Discovering external plugins in directory: plugins')

package/core/plugins/registry.ts

@@ -2,7 +2,7 @@ import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOption
 
 type FluxStackPlugin = FluxStack.Plugin
 import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger"
+import type { Logger } from "../utils/logger/index"
 import { FluxStackError } from "../utils/errors"
 import { PluginDependencyManager } from "./dependency-manager"
 import { readdir, readFile } from "fs/promises"
@@ -262,33 +262,6 @@ export class PluginRegistry {
       if (existsSync(manifestPath)) {
         const manifestContent = await readFile(manifestPath, 'utf-8')
         manifest = JSON.parse(manifestContent)
-      } else {
-        // Try package.json for npm plugins
-        const packagePath = join(pluginPath, 'package.json')
-        if (existsSync(packagePath)) {
-          try {
-            const packageContent = await readFile(packagePath, 'utf-8')
-            const packageJson = JSON.parse(packageContent)
-
-            if (packageJson.fluxstack) {
-              manifest = {
-                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 '${pluginPath}'`, { error })
-          }
-        }
       }
 
       // Try to import the plugin

package/core/utils/logger/index.ts

@@ -23,10 +23,6 @@ export { clearColorCache } from './colors'
 export { clearCallerCache } from './stack-trace'
 export { clearLoggerCache } from './winston-logger'
 
-// Export Logger type from winston
-import type winston from 'winston'
-export type Logger = winston.Logger
-
 // Re-export banner utilities for custom banners
 export { displayStartupBanner, type StartupInfo } from './startup-banner'