create-fluxstack 1.16.0 → 1.17.0

package/core/cli/commands/plugin-add.ts

@@ -7,7 +7,7 @@ import { Command } from 'commander'
 import { readFileSync, writeFileSync, existsSync } from 'fs'
 import { join } from 'path'
 import { $ } from 'bun'
-import chalk from 'chalk'
+import { buildLogger } from '@core/utils/build-logger'
 
 interface PluginAddOptions {
   skipAudit?: boolean
@@ -21,26 +21,29 @@ export function createPluginAddCommand(): Command {
     .option('--skip-audit', 'Skip npm audit check')
     .option('--skip-confirmation', 'Skip confirmation prompt')
     .action(async (pluginName: string, options: PluginAddOptions) => {
-      console.log(chalk.blue('\n🔌 FluxStack Plugin Installer\n'))
+      buildLogger.info('')
+      buildLogger.info('🔌 FluxStack Plugin Installer')
+      buildLogger.info('')
 
       try {
         // 1. Validate plugin name
         if (!isValidPluginName(pluginName)) {
-          console.error(chalk.red(`❌ Invalid plugin name: ${pluginName}`))
-          console.log(chalk.yellow('\n📝 Valid plugin names:'))
-          console.log('  - fluxstack-plugin-*')
-          console.log('  - fplugin-*')
-          console.log('  - @fluxstack/plugin-*')
-          console.log('  - @fplugin/*')
-          console.log('  - @org/fluxstack-plugin-*')
-          console.log('  - @org/fplugin-*')
+          buildLogger.error(`❌ Invalid plugin name: ${pluginName}`)
+          buildLogger.info('')
+          buildLogger.info('📝 Valid plugin names:')
+          buildLogger.info('  - fluxstack-plugin-*')
+          buildLogger.info('  - fplugin-*')
+          buildLogger.info('  - @fluxstack/plugin-*')
+          buildLogger.info('  - @fplugin/*')
+          buildLogger.info('  - @org/fluxstack-plugin-*')
+          buildLogger.info('  - @org/fplugin-*')
           process.exit(1)
         }
 
         // 2. Check if plugin already installed
         const packageJsonPath = join(process.cwd(), 'package.json')
         if (!existsSync(packageJsonPath)) {
-          console.error(chalk.red('❌ package.json not found'))
+          buildLogger.error('❌ package.json not found')
           process.exit(1)
         }
 
@@ -50,69 +53,83 @@ export function createPluginAddCommand(): Command {
           packageJson.devDependencies?.[pluginName]
 
         if (isAlreadyInstalled && !options.skipConfirmation) {
-          console.log(chalk.yellow(`⚠️  Plugin ${pluginName} is already installed`))
-          console.log(chalk.yellow('   Will only update whitelist\n'))
+          buildLogger.warn(`⚠️  Plugin ${pluginName} is already installed`)
+          buildLogger.warn('   Will only update whitelist')
+          buildLogger.info('')
         }
 
         // 3. Audit plugin (unless skipped)
         if (!options.skipAudit && !isAlreadyInstalled) {
-          console.log(chalk.blue('🔍 Auditing plugin security...\n'))
+          buildLogger.info('🔍 Auditing plugin security...')
+          buildLogger.info('')
 
           try {
             // Get plugin info
             const info = await $`npm view ${pluginName} repository homepage version description`.text()
-            console.log(chalk.gray(info))
+            buildLogger.info(info)
 
             // Run audit
-            console.log(chalk.blue('\n🛡️  Running npm audit...\n'))
+            buildLogger.info('')
+            buildLogger.info('🛡️  Running npm audit...')
+            buildLogger.info('')
             const auditResult = await $`npm audit ${pluginName}`.text()
-            console.log(chalk.gray(auditResult))
+            buildLogger.info(auditResult)
           } catch (error) {
-            console.warn(chalk.yellow(`⚠️  Could not audit plugin: ${error instanceof Error ? error.message : 'Unknown error'}`))
+            buildLogger.warn(`⚠️  Could not audit plugin: ${error instanceof Error ? error.message : 'Unknown error'}`)
           }
         }
 
         // 4. Confirmation prompt (unless skipped)
         if (!options.skipConfirmation) {
-          console.log(chalk.yellow('\n⚠️  Security Warning:'))
-          console.log(chalk.yellow('   NPM plugins can execute arbitrary code'))
-          console.log(chalk.yellow('   Only install plugins from trusted sources\n'))
+          buildLogger.warn('')
+          buildLogger.warn('⚠️  Security Warning:')
+          buildLogger.warn('   NPM plugins can execute arbitrary code')
+          buildLogger.warn('   Only install plugins from trusted sources')
+          buildLogger.info('')
 
-          const answer = prompt(chalk.blue('Continue with installation? (yes/no): '))
+          const answer = prompt('Continue with installation? (yes/no): ')
           if (answer?.toLowerCase() !== 'yes' && answer?.toLowerCase() !== 'y') {
-            console.log(chalk.red('❌ Installation cancelled'))
+            buildLogger.error('❌ Installation cancelled')
             process.exit(0)
           }
         }
 
         // 5. Install plugin
         if (!isAlreadyInstalled) {
-          console.log(chalk.blue(`\n📦 Installing ${pluginName}...\n`))
+          buildLogger.info('')
+          buildLogger.info(`📦 Installing ${pluginName}...`)
+          buildLogger.info('')
           await $`bun add ${pluginName}`.quiet()
-          console.log(chalk.green(`✅ Plugin installed successfully`))
+          buildLogger.success('✅ Plugin installed successfully')
         }
 
         // 6. Update .env file
-        console.log(chalk.blue('\n🔧 Updating configuration...\n'))
+        buildLogger.info('')
+        buildLogger.info('🔧 Updating configuration...')
+        buildLogger.info('')
         updateEnvFile(pluginName)
 
         // 7. Success message
-        console.log(chalk.green('\n✅ Plugin setup complete!\n'))
-        console.log(chalk.blue('📋 What was done:'))
+        buildLogger.success('')
+        buildLogger.success('✅ Plugin setup complete!')
+        buildLogger.info('')
+        buildLogger.info('📋 What was done:')
         if (!isAlreadyInstalled) {
-          console.log(chalk.gray(`   • Installed ${pluginName}`))
+          buildLogger.info(`   • Installed ${pluginName}`)
         }
-        console.log(chalk.gray('   • Enabled NPM plugin discovery (PLUGINS_DISCOVER_NPM=true)'))
-        console.log(chalk.gray(`   • Added ${pluginName} to whitelist (PLUGINS_ALLOWED)`))
+        buildLogger.info('   • Enabled NPM plugin discovery (PLUGINS_DISCOVER_NPM=true)')
+        buildLogger.info(`   • Added ${pluginName} to whitelist (PLUGINS_ALLOWED)`)
 
-        console.log(chalk.blue('\n🚀 Next steps:'))
-        console.log(chalk.gray('   1. Restart your dev server: bun run dev'))
-        console.log(chalk.gray('   2. Plugin will be auto-discovered and loaded'))
-        console.log(chalk.gray('   3. Check logs for plugin initialization'))
+        buildLogger.info('')
+        buildLogger.info('🚀 Next steps:')
+        buildLogger.info('   1. Restart your dev server: bun run dev')
+        buildLogger.info('   2. Plugin will be auto-discovered and loaded')
+        buildLogger.info('   3. Check logs for plugin initialization')
 
       } catch (error) {
-        console.error(chalk.red('\n❌ Failed to install plugin:'))
-        console.error(chalk.red(error instanceof Error ? error.message : String(error)))
+        buildLogger.error('')
+        buildLogger.error('❌ Failed to install plugin:')
+        buildLogger.error(error instanceof Error ? error.message : String(error))
         process.exit(1)
       }
     })
@@ -143,7 +160,7 @@ function updateEnvFile(pluginName: string): void {
   const envPath = join(process.cwd(), '.env')
 
   if (!existsSync(envPath)) {
-    console.warn(chalk.yellow('⚠️  .env file not found, creating...'))
+    buildLogger.warn('⚠️  .env file not found, creating...')
     writeFileSync(envPath, '', 'utf-8')
   }
 
@@ -157,11 +174,11 @@ function updateEnvFile(pluginName: string): void {
       'PLUGINS_DISCOVER_NPM=true'
     )
     updated = true
-    console.log(chalk.gray('   • Set PLUGINS_DISCOVER_NPM=true'))
+    buildLogger.info('   • Set PLUGINS_DISCOVER_NPM=true')
   } else if (!/^PLUGINS_DISCOVER_NPM=/m.test(envContent)) {
     envContent += '\n# Plugin Discovery\nPLUGINS_DISCOVER_NPM=true\n'
     updated = true
-    console.log(chalk.gray('   • Added PLUGINS_DISCOVER_NPM=true'))
+    buildLogger.info('   • Added PLUGINS_DISCOVER_NPM=true')
   }
 
   // 2. Add plugin to whitelist
@@ -181,14 +198,14 @@ function updateEnvFile(pluginName: string): void {
         `PLUGINS_ALLOWED=${newPlugins}`
       )
       updated = true
-      console.log(chalk.gray(`   • Added ${pluginName} to PLUGINS_ALLOWED`))
+      buildLogger.info(`   • Added ${pluginName} to PLUGINS_ALLOWED`)
     } else {
-      console.log(chalk.gray(`   • ${pluginName} already in PLUGINS_ALLOWED`))
+      buildLogger.info(`   • ${pluginName} already in PLUGINS_ALLOWED`)
     }
   } else {
     envContent += `PLUGINS_ALLOWED=${pluginName}\n`
     updated = true
-    console.log(chalk.gray(`   • Created PLUGINS_ALLOWED with ${pluginName}`))
+    buildLogger.info(`   • Created PLUGINS_ALLOWED with ${pluginName}`)
   }
 
   if (updated) {

package/core/cli/commands/plugin-deps.ts

@@ -3,7 +3,7 @@
  */
 
 import { Command } from 'commander'
-import chalk from 'chalk'
+import { buildLogger } from '@core/utils/build-logger'
 import { PluginDependencyManager } from '@core/plugins/dependency-manager'
 import { PluginRegistry } from '@core/plugins/registry'
 import { existsSync, readFileSync } from 'fs'
@@ -26,17 +26,18 @@ function createInstallCommand(): Command {
     .option('--dry-run', 'Mostrar o que seria instalado sem executar')
     .option('--package-manager <pm>', 'Package manager a usar (npm, yarn, pnpm, bun)', 'bun')
     .action(async (options) => {
-      console.log(chalk.blue('🔧 Instalando dependências de plugins...\n'))
+      buildLogger.info('🔧 Instalando dependências de plugins...')
+      buildLogger.info('')
 
       try {
         const dependencyManager = new PluginDependencyManager({
           autoInstall: !options.dryRun,
           packageManager: options.packageManager,
-          logger: createConsoleLogger() as any as any
+          logger: createConsoleLogger()
         })
 
         const registry = new PluginRegistry({
-          logger: createConsoleLogger() as any as any
+          logger: createConsoleLogger()
         })
 
         // Descobrir plugins
@@ -45,7 +46,8 @@ function createInstallCommand(): Command {
         })
 
         const successfulPlugins = results.filter(r => r.success)
-        console.log(chalk.green(`✅ Encontrados ${successfulPlugins.length} plugins\n`))
+        buildLogger.success(`✅ Encontrados ${successfulPlugins.length} plugins`)
+        buildLogger.info('')
 
         // Resolver dependências
         const resolutions = []
@@ -62,34 +64,34 @@ function createInstallCommand(): Command {
         // Mostrar resumo
         let totalDeps = 0
         let totalConflicts = 0
-        
+
         for (const resolution of resolutions) {
           totalDeps += resolution.dependencies.length
           totalConflicts += resolution.conflicts.length
-          
+
           if (resolution.dependencies.length > 0) {
-            console.log(chalk.cyan(`📦 ${resolution.plugin}:`))
+            buildLogger.info(`📦 ${resolution.plugin}:`)
             for (const dep of resolution.dependencies) {
-              const typeColor = dep.type === 'peerDependency' ? chalk.yellow : chalk.white
-              console.log(`  ${typeColor(dep.name)}@${dep.version} (${dep.type})`)
+              buildLogger.info(`  ${dep.name}@${dep.version} (${dep.type})`)
             }
-            console.log()
+            buildLogger.info('')
           }
         }
 
         if (totalConflicts > 0) {
-          console.log(chalk.yellow(`⚠️  ${totalConflicts} conflitos de dependências detectados\n`))
+          buildLogger.warn(`⚠️  ${totalConflicts} conflitos de dependências detectados`)
+          buildLogger.info('')
         }
 
         if (options.dryRun) {
-          console.log(chalk.blue(`📋 Dry run: ${totalDeps} dependências seriam instaladas`))
+          buildLogger.info(`📋 Dry run: ${totalDeps} dependências seriam instaladas`)
         } else {
           await dependencyManager.installPluginDependencies(resolutions)
-          console.log(chalk.green(`✅ ${totalDeps} dependências instaladas com sucesso!`))
+          buildLogger.success(`✅ ${totalDeps} dependências instaladas com sucesso!`)
         }
 
       } catch (error) {
-        console.error(chalk.red('❌ Erro ao instalar dependências:'), error)
+        buildLogger.error('❌ Erro ao instalar dependências:', error)
         process.exit(1)
       }
     })
@@ -100,11 +102,12 @@ function createListCommand(): Command {
     .description('Listar dependências de plugins')
     .option('--plugin <name>', 'Mostrar apenas dependências de um plugin específico')
     .action(async (options) => {
-      console.log(chalk.blue('📋 Dependências de plugins:\n'))
+      buildLogger.info('📋 Dependências de plugins:')
+      buildLogger.info('')
 
       try {
         const registry = new PluginRegistry({
-          logger: createConsoleLogger() as any
+          logger: createConsoleLogger()
         })
 
         const results = await registry.discoverPlugins({
@@ -113,7 +116,7 @@ function createListCommand(): Command {
 
         const dependencyManager = new PluginDependencyManager({
           autoInstall: false,
-          logger: createConsoleLogger() as any
+          logger: createConsoleLogger()
         })
 
         for (const result of results) {
@@ -125,30 +128,29 @@ function createListCommand(): Command {
             const pluginDir = findPluginDirectory(result.plugin.name)
             if (pluginDir) {
               const resolution = await dependencyManager.resolvePluginDependencies(pluginDir)
-              
-              console.log(chalk.cyan(`📦 ${resolution.plugin}`))
-              
+
+              buildLogger.info(`📦 ${resolution.plugin}`)
+
               if (resolution.dependencies.length === 0) {
-                console.log(chalk.gray('  Nenhuma dependência'))
+                buildLogger.info('  Nenhuma dependência')
               } else {
                 for (const dep of resolution.dependencies) {
-                  const typeColor = dep.type === 'peerDependency' ? chalk.yellow : chalk.white
-                  const optional = dep.optional ? chalk.gray(' (opcional)') : ''
-                  console.log(`  ${typeColor(dep.name)}@${dep.version} (${dep.type})${optional}`)
+                  const optional = dep.optional ? ' (opcional)' : ''
+                  buildLogger.info(`  ${dep.name}@${dep.version} (${dep.type})${optional}`)
                 }
               }
 
               if (resolution.conflicts.length > 0) {
-                console.log(chalk.red(`  ⚠️  ${resolution.conflicts.length} conflitos`))
+                buildLogger.error(`  ⚠️  ${resolution.conflicts.length} conflitos`)
               }
 
-              console.log()
+              buildLogger.info('')
             }
           }
         }
 
       } catch (error) {
-        console.error(chalk.red('❌ Erro ao listar dependências:'), error)
+        buildLogger.error('❌ Erro ao listar dependências:', error)
         process.exit(1)
       }
     })
@@ -158,11 +160,12 @@ function createCheckCommand(): Command {
   return new Command('check')
     .description('Verificar conflitos de dependências')
     .action(async () => {
-      console.log(chalk.blue('🔍 Verificando conflitos de dependências...\n'))
+      buildLogger.info('🔍 Verificando conflitos de dependências...')
+      buildLogger.info('')
 
       try {
         const registry = new PluginRegistry({
-          logger: createConsoleLogger() as any
+          logger: createConsoleLogger()
         })
 
         const results = await registry.discoverPlugins({
@@ -171,7 +174,7 @@ function createCheckCommand(): Command {
 
         const dependencyManager = new PluginDependencyManager({
           autoInstall: false,
-          logger: createConsoleLogger() as any
+          logger: createConsoleLogger()
         })
 
         const resolutions = []
@@ -186,26 +189,27 @@ function createCheckCommand(): Command {
         }
 
         const allConflicts = resolutions.flatMap(r => r.conflicts)
-        
+
         if (allConflicts.length === 0) {
-          console.log(chalk.green('✅ Nenhum conflito de dependências encontrado!'))
+          buildLogger.success('✅ Nenhum conflito de dependências encontrado!')
         } else {
-          console.log(chalk.red(`❌ ${allConflicts.length} conflitos encontrados:\n`))
-          
+          buildLogger.error(`❌ ${allConflicts.length} conflitos encontrados:`)
+          buildLogger.info('')
+
           for (const conflict of allConflicts) {
-            console.log(chalk.yellow(`⚠️  ${conflict.package}:`))
+            buildLogger.warn(`⚠️  ${conflict.package}:`)
             for (const version of conflict.versions) {
-              console.log(`  ${version.plugin}: ${version.version}`)
+              buildLogger.info(`  ${version.plugin}: ${version.version}`)
             }
             if (conflict.resolution) {
-              console.log(chalk.green(`  Resolução: ${conflict.resolution}`))
+              buildLogger.success(`  Resolução: ${conflict.resolution}`)
             }
-            console.log()
+            buildLogger.info('')
           }
         }
 
       } catch (error) {
-        console.error(chalk.red('❌ Erro ao verificar conflitos:'), error)
+        buildLogger.error('❌ Erro ao verificar conflitos:', error)
         process.exit(1)
       }
     })
@@ -216,14 +220,15 @@ function createCleanCommand(): Command {
     .description('Limpar dependências não utilizadas')
     .option('--dry-run', 'Mostrar o que seria removido sem executar')
     .action(async (options) => {
-      console.log(chalk.blue('🧹 Limpando dependências não utilizadas...\n'))
+      buildLogger.info('🧹 Limpando dependências não utilizadas...')
+      buildLogger.info('')
 
       if (options.dryRun) {
-        console.log(chalk.blue('📋 Dry run: mostrando dependências que seriam removidas'))
+        buildLogger.info('📋 Dry run: mostrando dependências que seriam removidas')
       }
 
       // TODO: Implementar lógica de limpeza
-      console.log(chalk.yellow('⚠️  Funcionalidade ainda não implementada'))
+      buildLogger.warn('⚠️  Funcionalidade ainda não implementada')
     })
 }
 
@@ -243,29 +248,40 @@ function findPluginDirectory(pluginName: string): string | null {
 }
 
 interface ConsoleLogger {
-  debug: (msg: string, meta?: unknown) => void
-  info: (msg: string, meta?: unknown) => void
-  warn: (msg: string, meta?: unknown) => void
-  error: (msg: string, meta?: unknown) => void
+  debug: (message: unknown, ...args: unknown[]) => void
+  info: (message: unknown, ...args: unknown[]) => void
+  warn: (message: unknown, ...args: unknown[]) => void
+  error: (message: unknown, ...args: unknown[]) => void
   child: () => ConsoleLogger
+  request: (method: string, path: string, status?: number, duration?: number, ip?: string) => void
+  plugin: (pluginName: string, message: string, meta?: unknown) => void
+  framework: (message: string, meta?: unknown) => void
+  time: (label: string) => void
+  timeEnd: (label: string) => void
 }
 
 function createConsoleLogger(): ConsoleLogger {
-  return {
-    debug: (msg: string, meta?: unknown) => {
+  const logger: ConsoleLogger = {
+    debug: (message: unknown, ...args: unknown[]) => {
       if (process.env.DEBUG) {
-        console.log(chalk.gray(`[DEBUG] ${msg}`), meta || '')
+        buildLogger.info(`[DEBUG] ${message}`, ...args)
       }
     },
-    info: (msg: string, meta?: unknown) => {
-      console.log(chalk.blue(`[INFO] ${msg}`), meta || '')
+    info: (message: unknown, ...args: unknown[]) => {
+      buildLogger.info(`[INFO] ${message}`, ...args)
     },
-    warn: (msg: string, meta?: unknown) => {
-      console.log(chalk.yellow(`[WARN] ${msg}`), meta || '')
+    warn: (message: unknown, ...args: unknown[]) => {
+      buildLogger.warn(`[WARN] ${message}`, ...args)
     },
-    error: (msg: string, meta?: unknown) => {
-      console.log(chalk.red(`[ERROR] ${msg}`), meta || '')
+    error: (message: unknown, ...args: unknown[]) => {
+      buildLogger.error(`[ERROR] ${message}`, ...args)
     },
-    child: () => createConsoleLogger()
+    child: () => createConsoleLogger(),
+    request: () => {},
+    plugin: () => {},
+    framework: () => {},
+    time: () => {},
+    timeEnd: () => {}
   }
+  return logger
 }

package/core/cli/commands/plugin-list.ts

@@ -6,7 +6,7 @@
 import { Command } from 'commander'
 import { readFileSync, existsSync } from 'fs'
 import { join } from 'path'
-import chalk from 'chalk'
+import { buildLogger } from '@core/utils/build-logger'
 
 export function createPluginListCommand(): Command {
   const command = new Command('plugin:list')
@@ -19,97 +19,100 @@ export function createPluginListCommand(): Command {
         const info = getPluginInfo()
 
         if (options.json) {
-          console.log(JSON.stringify(info, null, 2))
+          buildLogger.info(JSON.stringify(info, null, 2))
           return
         }
 
-        console.log(chalk.blue('\n🔌 FluxStack Plugin Status\n'))
+        buildLogger.info('')
+        buildLogger.info('🔌 FluxStack Plugin Status')
+        buildLogger.info('')
 
         // Configuration
-        console.log(chalk.bold('⚙️  Configuration:'))
-        console.log(chalk.gray(`   NPM Plugin Discovery: ${info.config.npmDiscoveryEnabled ? chalk.green('enabled') : chalk.red('disabled')}`))
-        console.log(chalk.gray(`   Project Plugin Discovery: ${info.config.projectDiscoveryEnabled ? chalk.green('enabled') : chalk.red('disabled')}`))
-        console.log()
+        buildLogger.info('⚙️  Configuration:')
+        buildLogger.info(`   NPM Plugin Discovery: ${info.config.npmDiscoveryEnabled ? 'enabled' : 'disabled'}`)
+        buildLogger.info(`   Project Plugin Discovery: ${info.config.projectDiscoveryEnabled ? 'enabled' : 'disabled'}`)
+        buildLogger.info('')
 
         // Whitelisted plugins
         if (!options.installed) {
-          console.log(chalk.bold('🛡️  Whitelisted NPM Plugins:'))
+          buildLogger.info('🛡️  Whitelisted NPM Plugins:')
           if (info.whitelisted.length === 0) {
-            console.log(chalk.gray('   (none)'))
+            buildLogger.info('   (none)')
           } else {
             info.whitelisted.forEach(plugin => {
               const isInstalled = info.installed.includes(plugin)
-              const status = isInstalled ? chalk.green('✓ installed') : chalk.yellow('⚠ not installed')
-              console.log(chalk.gray(`   • ${plugin} ${status}`))
+              const status = isInstalled ? '✓ installed' : '⚠ not installed'
+              buildLogger.info(`   • ${plugin} ${status}`)
             })
           }
-          console.log()
+          buildLogger.info('')
         }
 
         // Installed NPM plugins
         if (!options.whitelisted) {
-          console.log(chalk.bold('📦 Installed NPM Plugins:'))
+          buildLogger.info('📦 Installed NPM Plugins:')
           if (info.installed.length === 0) {
-            console.log(chalk.gray('   (none)'))
+            buildLogger.info('   (none)')
           } else {
             info.installed.forEach(plugin => {
               const isWhitelisted = info.whitelisted.includes(plugin)
               let status = ''
               if (!info.config.npmDiscoveryEnabled) {
-                status = chalk.red('✗ discovery disabled')
+                status = '✗ discovery disabled'
               } else if (!isWhitelisted) {
-                status = chalk.red('✗ not whitelisted (blocked)')
+                status = '✗ not whitelisted (blocked)'
               } else {
-                status = chalk.green('✓ whitelisted (loaded)')
+                status = '✓ whitelisted (loaded)'
               }
-              console.log(chalk.gray(`   • ${plugin} ${status}`))
+              buildLogger.info(`   • ${plugin} ${status}`)
             })
           }
-          console.log()
+          buildLogger.info('')
         }
 
         // Project plugins (from plugins/ directory)
-        console.log(chalk.bold('📁 Project Plugins (plugins/):'))
+        buildLogger.info('📁 Project Plugins (plugins/):')
         if (info.projectPlugins.length === 0) {
-          console.log(chalk.gray('   (none found)'))
+          buildLogger.info('   (none found)')
         } else {
           info.projectPlugins.forEach(plugin => {
             const status = info.config.projectDiscoveryEnabled
-              ? chalk.green('✓ auto-discovered')
-              : chalk.red('✗ discovery disabled')
-            console.log(chalk.gray(`   • ${plugin} ${status}`))
+              ? '✓ auto-discovered'
+              : '✗ discovery disabled'
+            buildLogger.info(`   • ${plugin} ${status}`)
           })
         }
-        console.log()
+        buildLogger.info('')
 
         // Summary
-        console.log(chalk.bold('📊 Summary:'))
-        console.log(chalk.gray(`   Total NPM plugins installed: ${info.installed.length}`))
-        console.log(chalk.gray(`   Total NPM plugins whitelisted: ${info.whitelisted.length}`))
-        console.log(chalk.gray(`   Total project plugins: ${info.projectPlugins.length}`))
+        buildLogger.info('📊 Summary:')
+        buildLogger.info(`   Total NPM plugins installed: ${info.installed.length}`)
+        buildLogger.info(`   Total NPM plugins whitelisted: ${info.whitelisted.length}`)
+        buildLogger.info(`   Total project plugins: ${info.projectPlugins.length}`)
 
         const blockedCount = info.installed.filter(p => !info.whitelisted.includes(p)).length
         if (blockedCount > 0) {
-          console.log(chalk.yellow(`   ⚠️  ${blockedCount} installed plugin(s) blocked (not whitelisted)`))
+          buildLogger.warn(`   ⚠️  ${blockedCount} installed plugin(s) blocked (not whitelisted)`)
         }
-        console.log()
+        buildLogger.info('')
 
         // Help
         if (info.installed.length > 0 && !info.config.npmDiscoveryEnabled) {
-          console.log(chalk.yellow('💡 Tip: Enable NPM plugin discovery with:'))
-          console.log(chalk.gray('   echo "PLUGINS_DISCOVER_NPM=true" >> .env'))
-          console.log()
+          buildLogger.warn('💡 Tip: Enable NPM plugin discovery with:')
+          buildLogger.info('   echo "PLUGINS_DISCOVER_NPM=true" >> .env')
+          buildLogger.info('')
         }
 
         if (blockedCount > 0 && info.config.npmDiscoveryEnabled) {
-          console.log(chalk.yellow('💡 Tip: Add blocked plugins to whitelist with:'))
-          console.log(chalk.gray('   bun run fluxstack plugin:add <plugin-name>'))
-          console.log()
+          buildLogger.warn('💡 Tip: Add blocked plugins to whitelist with:')
+          buildLogger.info('   bun run fluxstack plugin:add <plugin-name>')
+          buildLogger.info('')
         }
 
       } catch (error) {
-        console.error(chalk.red('\n❌ Failed to list plugins:'))
-        console.error(chalk.red(error instanceof Error ? error.message : String(error)))
+        buildLogger.error('')
+        buildLogger.error('❌ Failed to list plugins:')
+        buildLogger.error(error instanceof Error ? error.message : String(error))
         process.exit(1)
       }
     })
@@ -197,8 +200,8 @@ function getPluginInfo(): PluginInfo {
     try {
       const entries = fs.readdirSync(pluginsDir, { withFileTypes: true })
       info.projectPlugins = entries
-        .filter((entry: any) => entry.isDirectory())
-        .map((entry: any) => entry.name)
+        .filter((entry: { isDirectory(): boolean; name: string }) => entry.isDirectory())
+        .map((entry: { isDirectory(): boolean; name: string }) => entry.name)
     } catch (error) {
       // Ignore errors reading directory
     }