create-fluxstack 1.1.0 → 1.4.0

package/core/config/env.ts

@@ -3,6 +3,7 @@
  * Handles environment variable processing and precedence
  */
 
+import { env, helpers } from '../utils/env'
 import type { FluxStackConfig, LogLevel, BuildTarget, LogFormat } from './schema'
 
 export interface EnvironmentInfo {
@@ -24,8 +25,6 @@ export interface ConfigPrecedence {
  * Get current environment information
  */
 export function getEnvironmentInfo(): EnvironmentInfo {
-  // Import here to avoid circular dependency
-  const { env } = require('../utils/env-runtime-v2')
   const nodeEnv = env.NODE_ENV
 
   return {
@@ -99,117 +98,60 @@ export class EnvironmentProcessor {
     const config: any = {}
 
     // App configuration
-    this.setConfigValue(config, 'app.name',
-      process.env.FLUXSTACK_APP_NAME || process.env.APP_NAME, 'string')
-    this.setConfigValue(config, 'app.version',
-      process.env.FLUXSTACK_APP_VERSION || process.env.APP_VERSION, 'string')
-    this.setConfigValue(config, 'app.description',
-      process.env.FLUXSTACK_APP_DESCRIPTION || process.env.APP_DESCRIPTION, 'string')
+    this.setConfigValue(config, 'app.name', env.FLUXSTACK_APP_NAME, 'string')
+    this.setConfigValue(config, 'app.version', env.FLUXSTACK_APP_VERSION, 'string')
 
     // Server configuration
-    this.setConfigValue(config, 'server.port',
-      process.env.PORT || process.env.FLUXSTACK_PORT, 'number')
-    this.setConfigValue(config, 'server.host',
-      process.env.HOST || process.env.FLUXSTACK_HOST, 'string')
-    this.setConfigValue(config, 'server.apiPrefix',
-      process.env.FLUXSTACK_API_PREFIX || process.env.API_PREFIX, 'string')
+    this.setConfigValue(config, 'server.port', env.PORT?.toString(), 'number')
+    this.setConfigValue(config, 'server.host', env.HOST, 'string')
+    this.setConfigValue(config, 'server.apiPrefix', env.API_PREFIX, 'string')
 
     // CORS configuration
-    this.setConfigValue(config, 'server.cors.origins',
-      process.env.CORS_ORIGINS || process.env.FLUXSTACK_CORS_ORIGINS, 'array')
-    this.setConfigValue(config, 'server.cors.methods',
-      process.env.CORS_METHODS || process.env.FLUXSTACK_CORS_METHODS, 'array')
-    this.setConfigValue(config, 'server.cors.headers',
-      process.env.CORS_HEADERS || process.env.FLUXSTACK_CORS_HEADERS, 'array')
-    this.setConfigValue(config, 'server.cors.credentials',
-      process.env.CORS_CREDENTIALS || process.env.FLUXSTACK_CORS_CREDENTIALS, 'boolean')
-    this.setConfigValue(config, 'server.cors.maxAge',
-      process.env.CORS_MAX_AGE || process.env.FLUXSTACK_CORS_MAX_AGE, 'number')
+    const corsOriginsStr = env.has('CORS_ORIGINS') ? env.all().CORS_ORIGINS : undefined
+    const corsMethodsStr = env.has('CORS_METHODS') ? env.all().CORS_METHODS : undefined
+    const corsHeadersStr = env.has('CORS_HEADERS') ? env.all().CORS_HEADERS : undefined
+
+    this.setConfigValue(config, 'server.cors.origins', corsOriginsStr, 'array')
+    this.setConfigValue(config, 'server.cors.methods', corsMethodsStr, 'array')
+    this.setConfigValue(config, 'server.cors.headers', corsHeadersStr, 'array')
+    this.setConfigValue(config, 'server.cors.credentials', env.CORS_CREDENTIALS?.toString(), 'boolean')
+    this.setConfigValue(config, 'server.cors.maxAge', env.CORS_MAX_AGE?.toString(), 'number')
 
     // Client configuration
-    this.setConfigValue(config, 'client.port',
-      process.env.VITE_PORT || process.env.CLIENT_PORT || process.env.FLUXSTACK_CLIENT_PORT, 'number')
-    this.setConfigValue(config, 'client.proxy.target',
-      process.env.VITE_API_URL || process.env.API_URL || process.env.FLUXSTACK_PROXY_TARGET, 'string')
-    this.setConfigValue(config, 'client.build.sourceMaps',
-      process.env.FLUXSTACK_CLIENT_SOURCEMAPS, 'boolean')
-    this.setConfigValue(config, 'client.build.minify',
-      process.env.FLUXSTACK_CLIENT_MINIFY, 'boolean')
+    this.setConfigValue(config, 'client.port', env.VITE_PORT?.toString(), 'number')
 
     // Build configuration
-    this.setConfigValue(config, 'build.target',
-      process.env.BUILD_TARGET || process.env.FLUXSTACK_BUILD_TARGET, 'buildTarget')
-    this.setConfigValue(config, 'build.outDir',
-      process.env.BUILD_OUTDIR || process.env.FLUXSTACK_BUILD_OUTDIR, 'string')
-    this.setConfigValue(config, 'build.sourceMaps',
-      process.env.BUILD_SOURCEMAPS || process.env.FLUXSTACK_BUILD_SOURCEMAPS, 'boolean')
-    this.setConfigValue(config, 'build.clean',
-      process.env.BUILD_CLEAN || process.env.FLUXSTACK_BUILD_CLEAN, 'boolean')
-
-    // Build optimization
-    this.setConfigValue(config, 'build.optimization.minify',
-      process.env.BUILD_MINIFY || process.env.FLUXSTACK_BUILD_MINIFY, 'boolean')
-    this.setConfigValue(config, 'build.optimization.treeshake',
-      process.env.BUILD_TREESHAKE || process.env.FLUXSTACK_BUILD_TREESHAKE, 'boolean')
-    this.setConfigValue(config, 'build.optimization.compress',
-      process.env.BUILD_COMPRESS || process.env.FLUXSTACK_BUILD_COMPRESS, 'boolean')
-    this.setConfigValue(config, 'build.optimization.splitChunks',
-      process.env.BUILD_SPLIT_CHUNKS || process.env.FLUXSTACK_BUILD_SPLIT_CHUNKS, 'boolean')
-    this.setConfigValue(config, 'build.optimization.bundleAnalyzer',
-      process.env.BUILD_ANALYZER || process.env.FLUXSTACK_BUILD_ANALYZER, 'boolean')
+    const buildMinify = env.has('BUILD_MINIFY') ? env.all().BUILD_MINIFY : undefined
+    this.setConfigValue(config, 'build.optimization.minify', buildMinify, 'boolean')
 
     // Logging configuration
-    this.setConfigValue(config, 'logging.level',
-      process.env.LOG_LEVEL || process.env.FLUXSTACK_LOG_LEVEL, 'logLevel')
-    this.setConfigValue(config, 'logging.format',
-      process.env.LOG_FORMAT || process.env.FLUXSTACK_LOG_FORMAT, 'logFormat')
+    this.setConfigValue(config, 'logging.level', env.LOG_LEVEL, 'logLevel')
+    this.setConfigValue(config, 'logging.format', env.LOG_FORMAT, 'logFormat')
 
     // Monitoring configuration
-    this.setConfigValue(config, 'monitoring.enabled',
-      process.env.MONITORING_ENABLED || process.env.FLUXSTACK_MONITORING_ENABLED, 'boolean')
-    this.setConfigValue(config, 'monitoring.metrics.enabled',
-      process.env.METRICS_ENABLED || process.env.FLUXSTACK_METRICS_ENABLED, 'boolean')
-    this.setConfigValue(config, 'monitoring.metrics.collectInterval',
-      process.env.METRICS_INTERVAL || process.env.FLUXSTACK_METRICS_INTERVAL, 'number')
-    this.setConfigValue(config, 'monitoring.profiling.enabled',
-      process.env.PROFILING_ENABLED || process.env.FLUXSTACK_PROFILING_ENABLED, 'boolean')
-    this.setConfigValue(config, 'monitoring.profiling.sampleRate',
-      process.env.PROFILING_SAMPLE_RATE || process.env.FLUXSTACK_PROFILING_SAMPLE_RATE, 'number')
+    this.setConfigValue(config, 'monitoring.enabled', env.ENABLE_MONITORING?.toString(), 'boolean')
+    this.setConfigValue(config, 'monitoring.metrics.enabled', env.ENABLE_METRICS?.toString(), 'boolean')
 
     // Database configuration
-    this.setConfigValue(config, 'database.url', process.env.DATABASE_URL, 'string')
-    this.setConfigValue(config, 'database.host', process.env.DATABASE_HOST, 'string')
-    this.setConfigValue(config, 'database.port', process.env.DATABASE_PORT, 'number')
-    this.setConfigValue(config, 'database.database', process.env.DATABASE_NAME, 'string')
-    this.setConfigValue(config, 'database.user', process.env.DATABASE_USER, 'string')
-    this.setConfigValue(config, 'database.password', process.env.DATABASE_PASSWORD, 'string')
-    this.setConfigValue(config, 'database.ssl', process.env.DATABASE_SSL, 'boolean')
-    this.setConfigValue(config, 'database.poolSize', process.env.DATABASE_POOL_SIZE, 'number')
+    this.setConfigValue(config, 'database.url', env.DATABASE_URL, 'string')
+    this.setConfigValue(config, 'database.host', env.DB_HOST, 'string')
+    this.setConfigValue(config, 'database.port', env.DB_PORT?.toString(), 'number')
+    this.setConfigValue(config, 'database.database', env.DB_NAME, 'string')
+    this.setConfigValue(config, 'database.user', env.DB_USER, 'string')
+    this.setConfigValue(config, 'database.password', env.DB_PASSWORD, 'string')
+    this.setConfigValue(config, 'database.ssl', env.DB_SSL?.toString(), 'boolean')
 
     // Auth configuration
-    this.setConfigValue(config, 'auth.secret', process.env.JWT_SECRET, 'string')
-    this.setConfigValue(config, 'auth.expiresIn', process.env.JWT_EXPIRES_IN, 'string')
-    this.setConfigValue(config, 'auth.algorithm', process.env.JWT_ALGORITHM, 'string')
-    this.setConfigValue(config, 'auth.issuer', process.env.JWT_ISSUER, 'string')
+    this.setConfigValue(config, 'auth.secret', env.JWT_SECRET, 'string')
+    this.setConfigValue(config, 'auth.expiresIn', env.JWT_EXPIRES_IN, 'string')
+    this.setConfigValue(config, 'auth.algorithm', env.JWT_ALGORITHM, 'string')
 
     // Email configuration
-    this.setConfigValue(config, 'email.host', process.env.SMTP_HOST, 'string')
-    this.setConfigValue(config, 'email.port', process.env.SMTP_PORT, 'number')
-    this.setConfigValue(config, 'email.user', process.env.SMTP_USER, 'string')
-    this.setConfigValue(config, 'email.password', process.env.SMTP_PASSWORD, 'string')
-    this.setConfigValue(config, 'email.secure', process.env.SMTP_SECURE, 'boolean')
-    this.setConfigValue(config, 'email.from', process.env.SMTP_FROM, 'string')
-
-    // Storage configuration
-    this.setConfigValue(config, 'storage.uploadPath', process.env.UPLOAD_PATH, 'string')
-    this.setConfigValue(config, 'storage.maxFileSize', process.env.MAX_FILE_SIZE, 'number')
-    this.setConfigValue(config, 'storage.provider', process.env.STORAGE_PROVIDER, 'string')
-
-    // Plugin configuration
-    this.setConfigValue(config, 'plugins.enabled',
-      process.env.FLUXSTACK_PLUGINS_ENABLED, 'array')
-    this.setConfigValue(config, 'plugins.disabled',
-      process.env.FLUXSTACK_PLUGINS_DISABLED, 'array')
+    this.setConfigValue(config, 'email.host', env.SMTP_HOST, 'string')
+    this.setConfigValue(config, 'email.port', env.SMTP_PORT?.toString(), 'number')
+    this.setConfigValue(config, 'email.user', env.SMTP_USER, 'string')
+    this.setConfigValue(config, 'email.password', env.SMTP_PASSWORD, 'string')
+    this.setConfigValue(config, 'email.secure', env.SMTP_SECURE?.toString(), 'boolean')
 
     return this.cleanEmptyObjects(config)
   }

package/core/config/runtime-config.ts

@@ -1,18 +1,14 @@
 /**
  * Runtime Configuration System for FluxStack
- * Uses dynamic environment loading to solve Bun build issues
- * Drop-in replacement for process.env based configuration
+ * Uses declarative configuration system
  */
 
-import { env, createEnvNamespace, envValidation } from '../utils/env-runtime'
-import { 
-  dynamicEnvironmentProcessor, 
-  createDynamicConfig, 
-  validateProductionEnv,
-  getDynamicEnvironmentInfo 
-} from './env-dynamic'
+import { env, createNamespace } from '../utils/env'
 import type { FluxStackConfig } from './schema'
 import { defaultFluxStackConfig } from './schema'
+import { loggerConfig } from '../../config/logger.config'
+import { buildConfig } from '../../config/build.config'
+import { appConfig } from '../../config/app.config'
 
 /**
  * Runtime Configuration Builder
@@ -35,11 +31,21 @@ export class RuntimeConfigBuilder {
   }
 
   /**
-   * Load from dynamic environment variables
+   * Load from environment variables
    */
   private loadFromDynamicEnv(): this {
-    const envConfig = createDynamicConfig()
-    this.config = this.deepMerge(this.config, envConfig)
+    // Environment vars are loaded automatically by env loader
+    // Just merge common overrides here
+    const envOverrides: Partial<FluxStackConfig> = {}
+
+    if (env.has('PORT')) {
+      envOverrides.server = { ...this.config.server, port: env.PORT }
+    }
+    if (env.has('LOG_LEVEL')) {
+      envOverrides.logging = { ...this.config.logging, level: env.LOG_LEVEL }
+    }
+
+    this.config = this.deepMerge(this.config, envOverrides)
     return this
   }
 
@@ -64,8 +70,8 @@ export class RuntimeConfigBuilder {
    */
   build(): FluxStackConfig {
     // Validate production environment if needed
-    if (env.get('NODE_ENV') === 'production') {
-      validateProductionEnv()
+    if (env.NODE_ENV === 'production') {
+      env.require(['NODE_ENV'])
     }
 
     return this.config as FluxStackConfig
@@ -140,8 +146,8 @@ export const runtimeConfig = {
    */
   development(): FluxStackConfig {
     return new RuntimeConfigBuilder()
-      .override('logging.level', env.get('LOG_LEVEL', 'debug'))
-      .override('logging.format', env.get('LOG_FORMAT', 'pretty'))
+      .override('logging.level', loggerConfig.level)
+      .override('logging.format', 'pretty')
       .override('build.optimization.minify', false)
       .override('build.sourceMaps', true)
       .override('monitoring.enabled', false)
@@ -153,11 +159,11 @@ export const runtimeConfig = {
    */
   production(): FluxStackConfig {
     return new RuntimeConfigBuilder()
-      .override('logging.level', env.get('LOG_LEVEL', 'warn'))
-      .override('logging.format', env.get('LOG_FORMAT', 'json'))
+      .override('logging.level', loggerConfig.level)
+      .override('logging.format', 'json')
       .override('build.optimization.minify', true)
       .override('build.sourceMaps', false)
-      .override('monitoring.enabled', env.bool('MONITORING_ENABLED', true))
+      .override('monitoring.enabled', buildConfig.monitoringEnabled)
       .build()
   },
 
@@ -166,7 +172,7 @@ export const runtimeConfig = {
    */
   test(): FluxStackConfig {
     return new RuntimeConfigBuilder()
-      .override('logging.level', env.get('LOG_LEVEL', 'error'))
+      .override('logging.level', loggerConfig.level)
       .override('server.port', 0) // Random port for tests
       .override('client.port', 0)
       .override('monitoring.enabled', false)
@@ -177,7 +183,7 @@ export const runtimeConfig = {
    * Auto-detect environment and create appropriate config
    */
   auto(overrides?: Partial<FluxStackConfig>): FluxStackConfig {
-    const environment = env.get('NODE_ENV', 'development') as 'development' | 'production' | 'test'
+    const environment = appConfig.env
     
     let config: FluxStackConfig
     
@@ -214,27 +220,27 @@ export const envLoaders = {
   /**
    * Database environment loader
    */
-  database: createEnvNamespace('DATABASE_'),
-  
+  database: createNamespace('DATABASE_'),
+
   /**
    * JWT environment loader
    */
-  jwt: createEnvNamespace('JWT_'),
-  
+  jwt: createNamespace('JWT_'),
+
   /**
    * SMTP environment loader
    */
-  smtp: createEnvNamespace('SMTP_'),
-  
+  smtp: createNamespace('SMTP_'),
+
   /**
    * CORS environment loader
    */
-  cors: createEnvNamespace('CORS_'),
-  
+  cors: createNamespace('CORS_'),
+
   /**
    * FluxStack specific environment loader
    */
-  fluxstack: createEnvNamespace('FLUXSTACK_')
+  fluxstack: createNamespace('FLUXSTACK_')
 }
 
 /**
@@ -245,15 +251,12 @@ export const configHelpers = {
    * Get database URL with validation
    */
   getDatabaseUrl(): string | null {
-    const url = env.get('DATABASE_URL') as string | undefined
-    
-    if (url) {
-      envValidation.validate('DATABASE_URL', 
-        (value) => value.includes('://'),
-        'Must be a valid URL'
-      )
+    const url = env.DATABASE_URL
+
+    if (url && !url.includes('://')) {
+      throw new Error('DATABASE_URL must be a valid URL')
     }
-    
+
     return url || null
   },
 
@@ -261,18 +264,18 @@ export const configHelpers = {
    * Get CORS origins with proper defaults
    */
   getCorsOrigins(): string[] {
-    const origins = env.array('CORS_ORIGINS')
-    
-    if (origins.length === 0) {
-      const environment = env.get('NODE_ENV', 'development') as 'development' | 'production' | 'test'
-      
+    const origins = env.CORS_ORIGINS
+
+    if (origins.length === 0 || (origins.length === 1 && origins[0] === '*')) {
+      const environment = env.NODE_ENV
+
       if (environment === 'development') {
         return ['http://localhost:3000', 'http://localhost:5173']
       } else if (environment === 'production') {
         return [] // Must be explicitly configured in production
       }
     }
-    
+
     return origins
   },
 
@@ -281,15 +284,15 @@ export const configHelpers = {
    */
   getServerConfig() {
     return {
-      port: env.num('PORT', 3000),
-      host: env.get('HOST', 'localhost'),
-      apiPrefix: env.get('API_PREFIX', '/api'),
+      port: env.PORT,
+      host: env.HOST,
+      apiPrefix: env.API_PREFIX,
       cors: {
         origins: this.getCorsOrigins(),
-        methods: env.array('CORS_METHODS', ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']),
-        headers: env.array('CORS_HEADERS', ['Content-Type', 'Authorization']),
-        credentials: env.bool('CORS_CREDENTIALS', false),
-        maxAge: env.num('CORS_MAX_AGE', 86400)
+        methods: env.CORS_METHODS,
+        headers: env.CORS_HEADERS,
+        credentials: env.CORS_CREDENTIALS,
+        maxAge: env.CORS_MAX_AGE
       }
     }
   },
@@ -299,16 +302,16 @@ export const configHelpers = {
    */
   getClientConfig() {
     return {
-      port: env.num('VITE_PORT', 5173),
+      port: env.VITE_PORT,
       proxy: {
-        target: env.get('API_URL', 'http://localhost:3000'),
-        changeOrigin: env.bool('PROXY_CHANGE_ORIGIN', true)
+        target: buildConfig.apiUrl,
+        changeOrigin: buildConfig.proxyChangeOrigin
       },
       build: {
-        outDir: env.get('CLIENT_BUILD_DIR', 'dist/client'),
-        sourceMaps: env.bool('CLIENT_SOURCEMAPS', env.get('NODE_ENV') === 'development'),
-        minify: env.bool('CLIENT_MINIFY', env.get('NODE_ENV') === 'production'),
-        target: env.get('CLIENT_TARGET', 'es2020')
+        outDir: buildConfig.clientBuildDir,
+        sourceMaps: buildConfig.clientSourceMaps,
+        minify: buildConfig.clientMinify,
+        target: buildConfig.clientTarget
       }
     }
   }

package/core/config/schema.ts

@@ -35,6 +35,7 @@ export interface ServerConfig {
   apiPrefix: string
   cors: CorsConfig
   middleware: MiddlewareConfig[]
+  showBanner?: boolean // Show startup banner (default: true)
 }
 
 export interface ProxyConfig {
@@ -45,6 +46,7 @@ export interface ProxyConfig {
 
 export interface ClientBuildConfig {
   sourceMaps: boolean
+  minify: boolean
   target: string
   outDir: string
 }
@@ -56,6 +58,7 @@ export interface ClientConfig {
 }
 
 export interface OptimizationConfig {
+  minify: boolean
   treeshake: boolean
   compress: boolean
   splitChunks: boolean
@@ -68,6 +71,7 @@ export interface BuildConfig {
   outDir: string
   optimization: OptimizationConfig
   sourceMaps: boolean
+  minify: boolean
   treeshake: boolean
   compress?: boolean
   removeUnusedCSS?: boolean

package/core/framework/server.ts

@@ -5,6 +5,7 @@ import { PluginRegistry } from "../plugins/registry"
 import { PluginManager } from "../plugins/manager"
 import { getConfigSync, getEnvironmentInfo } from "../config"
 import { logger } from "../utils/logger"
+import { displayStartupBanner, type StartupInfo } from "../utils/logger/startup-banner"
 import { createErrorHandler } from "../utils/errors/handlers"
 import { createTimer, formatBytes, isProduction, isDevelopment } from "../utils/helpers"
 
@@ -99,7 +100,7 @@ export class FluxStackFramework {
     this.setupHooks()
     this.setupErrorHandling()
 
-    logger.framework('FluxStack framework initialized', {
+    logger.debug('FluxStack framework initialized', {
       environment: envInfo.name,
       port: fullConfig.server.port
     })
@@ -114,7 +115,7 @@ export class FluxStackFramework {
     try {
       await this.pluginManager.initialize()
       const stats = this.pluginManager.getRegistry().getStats()
-      logger.framework('Automatic plugins loaded successfully', {
+      logger.debug('Automatic plugins loaded successfully', {
         pluginCount: stats.totalPlugins,
         enabledPlugins: stats.enabledPlugins,
         disabledPlugins: stats.disabledPlugins
@@ -420,7 +421,7 @@ export class FluxStackFramework {
         ;(this.pluginRegistry as any).loadOrder = loadOrder
       }
       
-      logger.framework(`Plugin '${plugin.name}' registered`, {
+      logger.debug(`Plugin '${plugin.name}' registered`, {
         version: plugin.version,
         dependencies: plugin.dependencies
       })
@@ -478,7 +479,7 @@ export class FluxStackFramework {
       }
 
       this.isStarted = true
-      logger.framework('All plugins loaded successfully', {
+      logger.debug('All plugins loaded successfully', {
         pluginCount: loadOrder.length
       })
 
@@ -535,15 +536,26 @@ export class FluxStackFramework {
     const apiPrefix = this.context.config.server.apiPrefix
 
     this.app.listen(port, () => {
-      logger.framework(`Server started on port ${port}`, {
+      const showBanner = this.context.config.server.showBanner !== false // default: true
+      const vitePluginActive = this.pluginRegistry.has('vite')
+
+      // Prepare startup info for banner or callback
+      const startupInfo: StartupInfo = {
+        port,
         apiPrefix,
         environment: this.context.environment,
-        pluginCount: this.pluginRegistry.getAll().length
-      })
+        pluginCount: this.pluginRegistry.getAll().length,
+        vitePort: this.context.config.client?.port,
+        viteEmbedded: vitePluginActive, // Vite is embedded when plugin is active
+        swaggerPath: '/swagger' // TODO: Get from swagger plugin config
+      }
+
+      // Display banner if enabled
+      if (showBanner) {
+        displayStartupBanner(startupInfo)
+      }
 
-      console.log(`🚀 API ready at http://localhost:${port}${apiPrefix}`)
-      console.log(`📋 Health check: http://localhost:${port}${apiPrefix}/health`)
-      console.log()
+      // Call user callback with startup info
       callback?.()
     })
 

package/core/plugins/built-in/index.ts

@@ -1,17 +1,17 @@
 /**
  * Built-in Plugins for FluxStack
  * Core plugins that provide essential functionality
+ *
+ * Note: Logger is NOT a plugin - it's core infrastructure used by plugins
  */
 
 // Import all built-in plugins
-import { loggerPlugin } from './logger'
 import { swaggerPlugin } from './swagger'
 import { vitePlugin } from './vite'
 import { staticPlugin } from './static'
 import { monitoringPlugin } from './monitoring'
 
 // Export individual plugins
-export { loggerPlugin } from './logger'
 export { swaggerPlugin } from './swagger'
 export { vitePlugin } from './vite'
 export { staticPlugin } from './static'
@@ -19,7 +19,6 @@ export { monitoringPlugin } from './monitoring'
 
 // Export as a collection
 export const builtInPlugins = {
-  logger: loggerPlugin,
   swagger: swaggerPlugin,
   vite: vitePlugin,
   static: staticPlugin,
@@ -28,7 +27,6 @@ export const builtInPlugins = {
 
 // Export as an array for easy registration
 export const builtInPluginsList = [
-  loggerPlugin,
   swaggerPlugin,
   vitePlugin,
   staticPlugin,
@@ -37,22 +35,14 @@ export const builtInPluginsList = [
 
 // Plugin categories
 export const pluginCategories = {
-  core: [loggerPlugin, staticPlugin],
+  core: [staticPlugin],
   development: [vitePlugin],
   documentation: [swaggerPlugin],
-  monitoring: [loggerPlugin, monitoringPlugin]
+  monitoring: [monitoringPlugin]
 } as const
 
 // Default plugin configuration
 export const defaultPluginConfig = {
-  logger: {
-    logRequests: true,
-    logResponses: true,
-    logErrors: true,
-    includeHeaders: false,
-    includeBody: false,
-    slowRequestThreshold: 1000
-  },
   swagger: {
     enabled: true,
     path: '/swagger',
@@ -104,15 +94,15 @@ export const defaultPluginConfig = {
  * Get default plugins for a specific environment
  */
 export function getDefaultPlugins(environment: 'development' | 'production' | 'test' = 'development') {
-  const basePlugins = [loggerPlugin, staticPlugin]
-  
+  const basePlugins = [staticPlugin]
+
   switch (environment) {
     case 'development':
       return [...basePlugins, vitePlugin, swaggerPlugin, monitoringPlugin]
     case 'production':
       return [...basePlugins, monitoringPlugin]
     case 'test':
-      return [loggerPlugin] // Minimal plugins for testing
+      return [] // Minimal plugins for testing
     default:
       return basePlugins
   }