create-fluxstack 1.0.22 → 1.4.0

package/core/plugins/dependency-manager.ts

@@ -139,7 +139,7 @@ export class PluginDependencyManager {
    */
   async installPluginDependencies(resolutions: DependencyResolution[]): Promise<void> {
     if (!this.config.autoInstall) {
-      this.logger?.info('Auto-instalação desabilitada, pulando instalação de dependências')
+      this.logger?.debug('Auto-instalação desabilitada, pulando instalação de dependências')
       return
     }
 
@@ -164,17 +164,17 @@ export class PluginDependencyManager {
     })
 
     if (needsInstallation.length === 0) {
-      this.logger?.info('Todas as dependências de plugins já estão instaladas')
+      this.logger?.debug('Todas as dependências de plugins já estão instaladas')
       return
     }
 
-    this.logger?.info(`Instalando ${needsInstallation.length} dependências de plugins`, {
+    this.logger?.debug(`Instalando ${needsInstallation.length} dependências de plugins`, {
       dependencies: needsInstallation.map(d => `${d.name}@${d.version}`)
     })
 
     try {
       await this.installDependencies(needsInstallation)
-      this.logger?.info('Dependências de plugins instaladas com sucesso')
+      this.logger?.debug('Dependências de plugins instaladas com sucesso')
     } catch (error) {
       this.logger?.error('Erro ao instalar dependências de plugins', { error })
       throw error
@@ -239,7 +239,7 @@ export class PluginDependencyManager {
       const resolution = sortedVersions[0].version
       conflict.resolution = resolution
 
-      this.logger?.info(`Conflito resolvido para '${conflict.package}': usando versão ${resolution}`, {
+      this.logger?.debug(`Conflito resolvido para '${conflict.package}': usando versão ${resolution}`, {
         package: conflict.package,
         resolution,
         conflictingVersions: conflict.versions

package/core/plugins/manager.ts

@@ -60,24 +60,39 @@ export class PluginManager extends EventEmitter {
       return
     }
 
-    this.logger.info('Initializing plugin manager')
+    this.logger.debug('Initializing plugin manager')
 
     try {
       // Discover and load plugins
+      this.logger.debug('Starting plugin discovery...')
       await this.discoverPlugins()
-      
+      this.logger.debug('Plugin discovery completed')
+
       // Setup plugin contexts
+      this.logger.debug('Setting up plugin contexts...')
       this.setupPluginContexts()
-      
+      this.logger.debug('Plugin contexts setup completed')
+
       // Execute setup hooks
+      this.logger.debug('Executing setup hooks...')
       await this.executeHook('setup')
-      
+      this.logger.debug('Setup hooks execution completed')
+
       this.initialized = true
-      this.logger.info('Plugin manager initialized successfully', {
-        totalPlugins: this.registry.getStats().totalPlugins
+      const stats = this.registry.getStats()
+      this.logger.debug('Plugin manager initialized successfully', {
+        totalPlugins: stats.totalPlugins,
+        enabledPlugins: stats.enabledPlugins,
+        loadOrder: stats.loadOrder
       })
     } catch (error) {
-      this.logger.error('Failed to initialize plugin manager', { error })
+      this.logger.error('Failed to initialize plugin manager', { 
+        error: error instanceof Error ? {
+          message: error.message,
+          stack: error.stack,
+          name: error.name
+        } : error 
+      })
       throw error
     }
   }
@@ -396,13 +411,41 @@ export class PluginManager extends EventEmitter {
    */
   private async discoverPlugins(): Promise<void> {
     try {
-      this.logger.info('Discovering external plugins in directory: plugins')
-      const results = await this.registry.discoverPlugins({
-        directories: ['plugins'],
-        includeBuiltIn: false,
-        includeExternal: true
+      // Load built-in plugins first (handled by core system)
+      this.logger.debug('Loading built-in plugins...')
+      const builtInResults = await this.registry.discoverPlugins({
+        directories: [],
+        includeBuiltIn: true,
+        includeExternal: false
       })
 
+      // Try to use auto-generated registry for external plugins (if available from build)
+      let externalResults: any[] = []
+      try {
+        const autoRegistryModule = await import('./auto-registry')
+        if (autoRegistryModule.discoveredPlugins && autoRegistryModule.registerDiscoveredPlugins) {
+          this.logger.debug('🚀 Using auto-generated external plugins registry')
+          await autoRegistryModule.registerDiscoveredPlugins(this.registry)
+          externalResults = autoRegistryModule.discoveredPlugins.map((plugin: any) => ({
+            success: true,
+            plugin
+          }))
+        }
+      } catch (error) {
+        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')
+        externalResults = await this.registry.discoverPlugins({
+          directories: ['plugins'],
+          includeBuiltIn: false,
+          includeExternal: true
+        })
+      }
+
+      // Combine results
+      const results = [...builtInResults, ...externalResults]
+
       let loaded = 0
       let failed = 0
 
@@ -420,7 +463,7 @@ export class PluginManager extends EventEmitter {
         }
       }
 
-      this.logger.info('Plugin discovery completed', { loaded, failed })
+      this.logger.debug('Plugin discovery completed', { loaded, failed })
     } catch (error) {
       this.logger.error('Plugin discovery failed', { error })
       throw error
@@ -448,7 +491,7 @@ export class PluginManager extends EventEmitter {
 
     const context: PluginContext = {
       config: this.config,
-      logger: this.logger,
+      logger: this.logger.child ? this.logger.child({ plugin: plugin.name }) : this.logger,
       app: this.app,
       utils: createPluginUtils(this.logger),
       registry: this.registry

package/core/plugins/registry.ts

@@ -225,7 +225,7 @@ export class PluginRegistry {
 
     // Descobrir plugins
     for (const directory of directories) {
-      this.logger?.info(`Scanning directory: ${directory}`)
+      this.logger?.debug(`Scanning directory: ${directory}`)
       if (!existsSync(directory)) {
         this.logger?.warn(`Directory does not exist: ${directory}`)
         continue
@@ -233,7 +233,7 @@ export class PluginRegistry {
 
       try {
         const pluginResults = await this.discoverPluginsInDirectory(directory, _patterns)
-        this.logger?.info(`Found ${pluginResults.length} plugins in ${directory}`)
+        this.logger?.debug(`Found ${pluginResults.length} plugins in ${directory}`)
         results.push(...pluginResults)
       } catch (error) {
         this.logger?.warn(`Failed to discover plugins in directory '${directory}'`, { error })
@@ -487,7 +487,7 @@ export class PluginRegistry {
                                existsSync(join(pluginDir, 'plugin.js'))
           
           if (hasPluginFile) {
-            this.logger?.info(`Loading plugin from: ${pluginDir}`)
+            this.logger?.debug(`Loading plugin from: ${pluginDir}`)
             const result = await this.loadPlugin(pluginDir)
             results.push(result)
           }

package/core/server/index.ts

@@ -1,6 +1,5 @@
 // FluxStack framework exports
 export { FluxStackFramework } from "../framework/server"
-export { loggerPlugin } from "../plugins/built-in/logger"
 export { vitePlugin } from "../plugins/built-in/vite"
 export { staticPlugin } from "../plugins/built-in/static"
 export { swaggerPlugin } from "../plugins/built-in/swagger"

package/core/server/live/ComponentRegistry.ts

@@ -143,7 +143,7 @@ export class ComponentRegistry {
   // Register component class dynamically
   registerComponentClass(name: string, componentClass: any) {
     this.autoDiscoveredComponents.set(name, componentClass)
-    console.log(`🔍 Auto-discovered component: ${name}`)
+    // Logging is handled by autoDiscoverComponents
   }
 
   // Auto-discover components from directory
@@ -151,36 +151,62 @@ export class ComponentRegistry {
     try {
       const fs = await import('fs')
       const path = await import('path')
-      
+      const { startGroup, endGroup, logInGroup, groupSummary } = await import('../../utils/logger/group-logger')
+
       if (!fs.existsSync(componentsPath)) {
         console.log(`⚠️ Components path not found: ${componentsPath}`)
         return
       }
 
       const files = fs.readdirSync(componentsPath)
-      
+      let discoveredCount = 0
+
+      startGroup({
+        title: 'Live Components Auto-Discovery',
+        icon: '🔍',
+        color: 'blue',
+        collapsed: true
+      })
+
       for (const file of files) {
         if (file.endsWith('.ts') || file.endsWith('.js')) {
           try {
             const fullPath = path.join(componentsPath, file)
             const module = await import(/* @vite-ignore */ fullPath)
-            
+
             // Look for exported classes that extend LiveComponent
             Object.keys(module).forEach(exportName => {
               const exportedItem = module[exportName]
-              if (typeof exportedItem === 'function' && 
-                  exportedItem.prototype && 
+              if (typeof exportedItem === 'function' &&
+                  exportedItem.prototype &&
                   this.isLiveComponentClass(exportedItem)) {
-                
+
                 const componentName = exportName.replace(/Component$/, '')
                 this.registerComponentClass(componentName, exportedItem)
+                logInGroup(`${componentName} (from ${file})`, '📦')
+                discoveredCount++
               }
             })
+
+            // Check for integration hooks (like SystemMonitorIntegration)
+            if (module.default && typeof module.default === 'object' && module.default.setupIntegration) {
+              logInGroup('Integration hooks found', '🔗')
+            }
           } catch (error) {
-            console.warn(`⚠️ Failed to load component from ${file}:`, error)
+            logInGroup(`Failed to load ${file}`, '⚠️')
           }
         }
       }
+
+      if (discoveredCount > 0) {
+        const label = discoveredCount === 1 ? 'component discovered' : 'components discovered'
+        groupSummary(discoveredCount, label, '✓')
+      } else {
+        logInGroup('No components found', '⚠️')
+      }
+
+      endGroup()
+      console.log('') // Separator line
     } catch (error) {
       console.error('❌ Auto-discovery failed:', error)
     }

package/core/server/live/LiveComponentPerformanceMonitor.ts

@@ -180,7 +180,7 @@ export class LiveComponentPerformanceMonitor extends EventEmitter {
       })
       
       this.performanceObserver.observe({ entryTypes: ['measure', 'mark'] })
-      console.log('📊 Performance observer initialized')
+      // Performance observer ready (logged at DEBUG level to keep startup clean)
     } catch (error) {
       console.warn('⚠️ Performance observer not available:', error)
     }