create-fluxstack 1.1.0 → 1.4.1

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,27 +60,27 @@ 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
       const stats = this.registry.getStats()
-      this.logger.info('Plugin manager initialized successfully', {
+      this.logger.debug('Plugin manager initialized successfully', {
         totalPlugins: stats.totalPlugins,
         enabledPlugins: stats.enabledPlugins,
         loadOrder: stats.loadOrder
@@ -412,19 +412,19 @@ export class PluginManager extends EventEmitter {
   private async discoverPlugins(): Promise<void> {
     try {
       // Load built-in plugins first (handled by core system)
-      this.logger.info('Loading built-in plugins...')
+      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.info('🚀 Using auto-generated external plugins registry')
+          this.logger.debug('🚀 Using auto-generated external plugins registry')
           await autoRegistryModule.registerDiscoveredPlugins(this.registry)
           externalResults = autoRegistryModule.discoveredPlugins.map((plugin: any) => ({
             success: true,
@@ -433,16 +433,16 @@ export class PluginManager extends EventEmitter {
         }
       } 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.info('Discovering external plugins in directory: 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]
 
@@ -463,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

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)
     }