create-fluxstack 1.10.1 → 1.12.0

package/core/build/index.ts

@@ -19,30 +19,39 @@ export class FluxStackBuilder {
     this.config = config
     this.pluginRegistry = pluginRegistry
 
+    const optimization = this.config.optimization || {
+      minify: true,
+      treeshake: true,
+      compress: true,
+      removeUnusedCSS: false,
+      optimizeImages: false,
+      bundleAnalyzer: false
+    }
+
     // Initialize bundler with configuration
     this.bundler = new Bundler({
-      target: config.build.target,
-      outDir: config.build.outDir,
-      sourceMaps: config.build.sourceMaps,
-      minify: config.build.minify,
-      external: config.build.external
+      target: config.build.target ?? 'bun',
+      outDir: config.build.outDir ?? 'dist',
+      sourceMaps: config.build.sourceMaps ?? false,
+      minify: optimization.minify,
+      external: config.build.external || []
     })
 
     // Initialize optimizer with configuration
     this.optimizer = new Optimizer({
-      treeshake: config.build.treeshake,
-      compress: config.build.compress || false,
-      removeUnusedCSS: config.build.removeUnusedCSS || false,
-      optimizeImages: config.build.optimizeImages || false,
-      bundleAnalysis: config.build.bundleAnalysis || false
+      treeshake: optimization.treeshake ?? true,
+      compress: optimization.compress || false,
+      removeUnusedCSS: optimization.removeUnusedCSS || false,
+      optimizeImages: optimization.optimizeImages || false,
+      bundleAnalysis: optimization.bundleAnalyzer || false
     })
   }
 
   async buildClient() {
     return await this.bundler.bundleClient({
       env: {
-        VITE_BUILD_OUTDIR: this.config.client.build.outDir,
-        VITE_BUILD_SOURCEMAPS: this.config.client.build.sourceMaps.toString()
+        VITE_BUILD_OUTDIR: this.config.clientBuild.outDir ?? 'dist/client',
+        VITE_BUILD_SOURCEMAPS: (this.config.clientBuild.sourceMaps ?? false).toString()
       }
     })
   }
@@ -60,7 +69,7 @@ export class FluxStackBuilder {
   async createDockerFiles() {
     buildLogger.section('Docker Configuration', '🐳')
 
-    const distDir = this.config.build.outDir
+    const distDir = this.config.build.outDir ?? 'dist'
     buildLogger.step(`Output directory: ${distDir}`)
 
     // Ensure dist directory exists
@@ -72,9 +81,12 @@ export class FluxStackBuilder {
       buildLogger.success('Directory already exists')
     }
 
+    // Get current Bun version for Docker image
+    const bunVersion = typeof Bun !== 'undefined' ? Bun.version : '1.3'
+
     // Dockerfile optimizado para produção
     const dockerfile = `# FluxStack Production Docker Image
-FROM oven/bun:1.1-alpine AS production
+FROM oven/bun:${bunVersion}-alpine AS production
 
 WORKDIR /app
 
@@ -245,9 +257,9 @@ MONITORING_ENABLED=true
     const startTime = Date.now()
 
     const buildContext: BuildContext = {
-      target: this.config.build.target,
-      outDir: this.config.build.outDir,
-      mode: (this.config.build.mode || 'production') as 'development' | 'production',
+      target: this.config.build.target ?? 'bun',
+      outDir: this.config.build.outDir ?? 'dist',
+      mode: (this.config.build.mode ?? 'production') as 'development' | 'production',
       config: this.config
     }
 
@@ -307,12 +319,12 @@ MONITORING_ENABLED=true
       }
 
       // Process assets and execute onBuildAsset hooks
-      await this.processAssets(this.config.build.outDir)
+      await this.processAssets(this.config.build.outDir ?? 'dist')
 
       // Optimize build if enabled
       let optimizationResult
       if (this.config.build.optimize) {
-        optimizationResult = await this.optimizer.optimize(this.config.build.outDir)
+        optimizationResult = await this.optimizer.optimize(this.config.build.outDir ?? 'dist')
       }
 
       // Create Docker files
@@ -329,7 +341,7 @@ MONITORING_ENABLED=true
       // Print build summary
       buildLogger.summary('Build Completed Successfully', [
         { label: 'Build Time', value: buildLogger.formatDuration(duration), highlight: true },
-        { label: 'Output Directory', value: this.config.build.outDir },
+        { label: 'Output Directory', value: this.config.build.outDir ?? 'dist' },
         { label: 'Client Assets', value: clientResult.assets?.length || 0 },
         { label: 'Total Size', value: buildLogger.formatSize(optimizationResult?.optimizedSize || 0) },
         { label: 'Compression', value: optimizationResult?.compressionRatio ? `${optimizationResult.compressionRatio.toFixed(2)}%` : 'N/A' },
@@ -422,10 +434,10 @@ MONITORING_ENABLED=true
     optimizationResult?: any
   ): Promise<BuildManifest> {
     return {
-      version: this.config.app.version,
+      version: this.config.app.version ?? '0.0.0',
       timestamp: new Date().toISOString(),
-      target: this.config.build.target,
-      mode: this.config.build.mode || 'production',
+      target: this.config.build.target ?? 'bun',
+      mode: this.config.build.mode ?? 'production',
       client: {
         entryPoints: [],
         chunks: [],
@@ -439,9 +451,9 @@ MONITORING_ENABLED=true
       },
       assets: [],
       optimization: {
-        minified: this.config.build.minify,
-        treeshaken: this.config.build.treeshake,
-        compressed: this.config.build.compress || false,
+        minified: this.config.optimization?.minify ?? false,
+        treeshaken: this.config.optimization?.treeshake ?? false,
+        compressed: this.config.optimization?.compress ?? false,
         originalSize: optimizationResult?.originalSize || 0,
         optimizedSize: optimizationResult?.optimizedSize || 0,
         compressionRatio: optimizationResult?.compressionRatio || 0
@@ -533,4 +545,4 @@ MONITORING_ENABLED=true
 
     return 'other'
   }
-}
+}

package/core/build/live-components-generator.ts

@@ -18,7 +18,7 @@ export class LiveComponentsGenerator {
   private backupFilePath: string
   private entryPointPath: string
   private entryPointBackupPath: string
-  private readonly importLine = 'import "@/core/server/live/auto-generated-components"'
+  private readonly importLine = 'import "@core/server/live/auto-generated-components"'
 
   constructor() {
     // Scan components from app/ directory (user code)
@@ -75,7 +75,7 @@ export class LiveComponentsGenerator {
                 className,
                 componentName,
                 // Path relative to core/server/live/ where the generated file will be
-                filePath: `@/app/server/live/${fileName}`
+                filePath: `@app/server/live/${fileName}`
               })
 
               buildLogger.step(`Discovered component: ${className} → ${componentName}`)
@@ -116,7 +116,7 @@ export class LiveComponentsGenerator {
 // Generated at: ${new Date().toISOString()}
 
 ${imports}
-import { componentRegistry } from "@/core/server/live/ComponentRegistry"
+import { componentRegistry } from "@core/server/live/ComponentRegistry"
 
 // Register all components statically for production bundle
 function registerAllComponents() {

package/core/build/optimizer.ts

@@ -1,236 +1,236 @@
-import { readFileSync, writeFileSync, statSync, readdirSync } from "fs"
-import { join, extname } from "path"
-import { gzipSync } from "zlib"
-import type { OptimizationConfig, OptimizationResult } from "../types/build"
-import { buildLogger } from "../utils/build-logger"
-
-export interface OptimizerConfig {
-  treeshake: boolean
-  compress: boolean
-  removeUnusedCSS: boolean
-  optimizeImages: boolean
-  bundleAnalysis: boolean
-}
-
-export class Optimizer {
-  private config: OptimizerConfig
-
-  constructor(config: OptimizerConfig) {
-    this.config = config
-  }
-
-  async optimize(buildPath: string): Promise<OptimizationResult> {
-    buildLogger.section('Build Optimization', '🔧')
-
-    const startTime = Date.now()
-    const results: OptimizationResult = {
-      success: true,
-      duration: 0,
-      originalSize: 0,
-      optimizedSize: 0,
-      compressionRatio: 0,
-      optimizations: []
-    }
-
-    try {
-      // Get original size
-      results.originalSize = await this.calculateDirectorySize(buildPath)
-      buildLogger.step(`Original size: ${buildLogger.formatSize(results.originalSize)}`)
-
-      // Apply optimizations (minification removed for compatibility)
-
-      if (this.config.compress) {
-        await this.compressAssets(buildPath, results)
-      }
-
-      if (this.config.removeUnusedCSS) {
-        await this.removeUnusedCSS(buildPath, results)
-      }
-
-      if (this.config.optimizeImages) {
-        await this.optimizeImages(buildPath, results)
-      }
-
-      if (this.config.bundleAnalysis) {
-        await this.analyzeBundles(buildPath, results)
-      }
-
-      // Calculate final size and compression ratio
-      results.optimizedSize = await this.calculateDirectorySize(buildPath)
-      results.compressionRatio = results.originalSize > 0
-        ? ((results.originalSize - results.optimizedSize) / results.originalSize) * 100
-        : 0
-
-      results.duration = Date.now() - startTime
-
-      buildLogger.success(`Optimization completed in ${buildLogger.formatDuration(results.duration)}`)
-
-      // Create optimization summary table
-      const optimizationData = results.optimizations.map(opt => ({
-        type: opt.type,
-        description: opt.description,
-        saved: buildLogger.formatSize(opt.sizeSaved)
-      }))
-
-      if (optimizationData.length > 0) {
-        buildLogger.table(
-          [
-            { header: 'Optimization', key: 'type', width: 20, align: 'left', color: 'cyan' },
-            { header: 'Description', key: 'description', width: 35, align: 'left' },
-            { header: 'Size Saved', key: 'saved', width: 12, align: 'right', color: 'green' }
-          ],
-          optimizationData
-        )
-      }
-
-      return results
-
-    } catch (error) {
-      results.success = false
-      results.duration = Date.now() - startTime
-      results.error = error instanceof Error ? error.message : "Unknown optimization error"
-
-      buildLogger.error(`Optimization failed: ${results.error}`)
-      return results
-    }
-  }
-
-  // Minification methods removed for compatibility with Bun bundler
-
-  private async compressAssets(buildPath: string, results: OptimizationResult): Promise<void> {
-    buildLogger.step("Compressing assets...")
-
-    const files = this.getFilesRecursively(buildPath)
-    let compressedCount = 0
-
-    for (const file of files) {
-      const ext = extname(file).toLowerCase()
-      
-      if (['.js', '.css', '.html', '.json', '.svg'].includes(ext)) {
-        try {
-          const content = readFileSync(file)
-          const compressed = gzipSync(content)
-          
-          // Only create .gz file if it's significantly smaller
-          if (compressed.length < content.length * 0.9) {
-            writeFileSync(file + '.gz', compressed)
-            compressedCount++
-          }
-        } catch (error) {
-          // Silently skip files that can't be compressed
-        }
-      }
-    }
-
-    buildLogger.success(`Compressed ${compressedCount} files`)
-    results.optimizations.push({
-      type: 'compression',
-      description: `Created gzip versions for ${compressedCount} files`,
-      sizeSaved: 0
-    })
-  }
-
-  private async removeUnusedCSS(buildPath: string, results: OptimizationResult): Promise<void> {
-    buildLogger.step("Analyzing CSS...")
-
-    // This is a placeholder - real implementation would use PurgeCSS or similar
-    results.optimizations.push({
-      type: 'css-purging',
-      description: 'CSS purging not implemented yet',
-      sizeSaved: 0
-    })
-  }
-
-  private async optimizeImages(buildPath: string, results: OptimizationResult): Promise<void> {
-    buildLogger.step("Optimizing images...")
-
-    // This is a placeholder - real implementation would use imagemin or similar
-    results.optimizations.push({
-      type: 'image-optimization',
-      description: 'Image optimization not implemented yet',
-      sizeSaved: 0
-    })
-  }
-
-  private async analyzeBundles(buildPath: string, results: OptimizationResult): Promise<void> {
-    buildLogger.step("Analyzing bundles...")
-    
-    const files = this.getFilesRecursively(buildPath)
-    const jsFiles = files.filter(f => extname(f) === '.js')
-    
-    let totalJSSize = 0
-    for (const file of jsFiles) {
-      totalJSSize += statSync(file).size
-    }
-
-    results.optimizations.push({
-      type: 'bundle-analysis',
-      description: `Analyzed ${jsFiles.length} JS bundles (${(totalJSSize / 1024).toFixed(2)} KB total)`,
-      sizeSaved: 0
-    })
-  }
-
-  private async calculateDirectorySize(dirPath: string): Promise<number> {
-    const files = this.getFilesRecursively(dirPath)
-    let totalSize = 0
-    
-    for (const file of files) {
-      try {
-        totalSize += statSync(file).size
-      } catch (error) {
-        // Ignore files that can't be read
-      }
-    }
-    
-    return totalSize
-  }
-
-  private getFilesRecursively(dir: string): string[] {
-    const files: string[] = []
-    
-    try {
-      const items = readdirSync(dir, { withFileTypes: true })
-      
-      for (const item of items) {
-        const fullPath = join(dir, item.name)
-        
-        if (item.isDirectory()) {
-          files.push(...this.getFilesRecursively(fullPath))
-        } else {
-          files.push(fullPath)
-        }
-      }
-    } catch (error) {
-      // Ignore directories that can't be read
-    }
-    
-    return files
-  }
-
-  async createOptimizationReport(result: OptimizationResult): Promise<string> {
-    const report = `
-# Build Optimization Report
-
-## Summary
-- **Status**: ${result.success ? '✅ Success' : '❌ Failed'}
-- **Duration**: ${result.duration}ms
-- **Original Size**: ${(result.originalSize / 1024).toFixed(2)} KB
-- **Optimized Size**: ${(result.optimizedSize / 1024).toFixed(2)} KB
-- **Size Reduction**: ${result.compressionRatio.toFixed(2)}%
-
-## Optimizations Applied
-
-${result.optimizations.map(opt => 
-  `### ${opt.type.charAt(0).toUpperCase() + opt.type.slice(1)}
-- ${opt.description}
-- Size Saved: ${(opt.sizeSaved / 1024).toFixed(2)} KB`
-).join('\n\n')}
-
-${result.error ? `## Error\n${result.error}` : ''}
-
-Generated at: ${new Date().toISOString()}
-`
-
-    return report.trim()
-  }
+import { readFileSync, writeFileSync, statSync, readdirSync } from "fs"
+import { join, extname } from "path"
+import { gzipSync } from "zlib"
+import type { OptimizationConfig, OptimizationResult } from "../types/build"
+import { buildLogger } from "../utils/build-logger"
+
+export interface OptimizerConfig {
+  treeshake: boolean
+  compress: boolean
+  removeUnusedCSS: boolean
+  optimizeImages: boolean
+  bundleAnalysis: boolean
+}
+
+export class Optimizer {
+  private config: OptimizerConfig
+
+  constructor(config: OptimizerConfig) {
+    this.config = config
+  }
+
+  async optimize(buildPath: string): Promise<OptimizationResult> {
+    buildLogger.section('Build Optimization', '🔧')
+
+    const startTime = Date.now()
+    const results: OptimizationResult = {
+      success: true,
+      duration: 0,
+      originalSize: 0,
+      optimizedSize: 0,
+      compressionRatio: 0,
+      optimizations: []
+    }
+
+    try {
+      // Get original size
+      results.originalSize = await this.calculateDirectorySize(buildPath)
+      buildLogger.step(`Original size: ${buildLogger.formatSize(results.originalSize)}`)
+
+      // Apply optimizations (minification removed for compatibility)
+
+      if (this.config.compress) {
+        await this.compressAssets(buildPath, results)
+      }
+
+      if (this.config.removeUnusedCSS) {
+        await this.removeUnusedCSS(buildPath, results)
+      }
+
+      if (this.config.optimizeImages) {
+        await this.optimizeImages(buildPath, results)
+      }
+
+      if (this.config.bundleAnalysis) {
+        await this.analyzeBundles(buildPath, results)
+      }
+
+      // Calculate final size and compression ratio
+      results.optimizedSize = await this.calculateDirectorySize(buildPath)
+      results.compressionRatio = results.originalSize > 0
+        ? ((results.originalSize - results.optimizedSize) / results.originalSize) * 100
+        : 0
+
+      results.duration = Date.now() - startTime
+
+      buildLogger.success(`Optimization completed in ${buildLogger.formatDuration(results.duration)}`)
+
+      // Create optimization summary table
+      const optimizationData = results.optimizations.map(opt => ({
+        type: opt.type,
+        description: opt.description,
+        saved: buildLogger.formatSize(opt.sizeSaved)
+      }))
+
+      if (optimizationData.length > 0) {
+        buildLogger.table(
+          [
+            { header: 'Optimization', key: 'type', width: 20, align: 'left', color: 'cyan' },
+            { header: 'Description', key: 'description', width: 35, align: 'left' },
+            { header: 'Size Saved', key: 'saved', width: 12, align: 'right', color: 'green' }
+          ],
+          optimizationData
+        )
+      }
+
+      return results
+
+    } catch (error) {
+      results.success = false
+      results.duration = Date.now() - startTime
+      results.error = error instanceof Error ? error.message : "Unknown optimization error"
+
+      buildLogger.error(`Optimization failed: ${results.error}`)
+      return results
+    }
+  }
+
+  // Minification methods removed for compatibility with Bun bundler
+
+  private async compressAssets(buildPath: string, results: OptimizationResult): Promise<void> {
+    buildLogger.step("Compressing assets...")
+
+    const files = this.getFilesRecursively(buildPath)
+    let compressedCount = 0
+
+    for (const file of files) {
+      const ext = extname(file).toLowerCase()
+      
+      if (['.js', '.css', '.html', '.json', '.svg'].includes(ext)) {
+        try {
+          const content = readFileSync(file)
+          const compressed = gzipSync(content)
+          
+          // Only create .gz file if it's significantly smaller
+          if (compressed.length < content.length * 0.9) {
+            writeFileSync(file + '.gz', compressed)
+            compressedCount++
+          }
+        } catch (error) {
+          // Silently skip files that can't be compressed
+        }
+      }
+    }
+
+    buildLogger.success(`Compressed ${compressedCount} files`)
+    results.optimizations.push({
+      type: 'compression',
+      description: `Created gzip versions for ${compressedCount} files`,
+      sizeSaved: 0
+    })
+  }
+
+  private async removeUnusedCSS(buildPath: string, results: OptimizationResult): Promise<void> {
+    buildLogger.step("Analyzing CSS...")
+
+    // This is a placeholder - real implementation would use PurgeCSS or similar
+    results.optimizations.push({
+      type: 'css-purging',
+      description: 'CSS purging not implemented yet',
+      sizeSaved: 0
+    })
+  }
+
+  private async optimizeImages(buildPath: string, results: OptimizationResult): Promise<void> {
+    buildLogger.step("Optimizing images...")
+
+    // This is a placeholder - real implementation would use imagemin or similar
+    results.optimizations.push({
+      type: 'image-optimization',
+      description: 'Image optimization not implemented yet',
+      sizeSaved: 0
+    })
+  }
+
+  private async analyzeBundles(buildPath: string, results: OptimizationResult): Promise<void> {
+    buildLogger.step("Analyzing bundles...")
+    
+    const files = this.getFilesRecursively(buildPath)
+    const jsFiles = files.filter(f => extname(f) === '.js')
+    
+    let totalJSSize = 0
+    for (const file of jsFiles) {
+      totalJSSize += statSync(file).size
+    }
+
+    results.optimizations.push({
+      type: 'bundle-analysis',
+      description: `Analyzed ${jsFiles.length} JS bundles (${(totalJSSize / 1024).toFixed(2)} KB total)`,
+      sizeSaved: 0
+    })
+  }
+
+  private async calculateDirectorySize(dirPath: string): Promise<number> {
+    const files = this.getFilesRecursively(dirPath)
+    let totalSize = 0
+    
+    for (const file of files) {
+      try {
+        totalSize += statSync(file).size
+      } catch (error) {
+        // Ignore files that can't be read
+      }
+    }
+    
+    return totalSize
+  }
+
+  private getFilesRecursively(dir: string): string[] {
+    const files: string[] = []
+    
+    try {
+      const items = readdirSync(dir, { withFileTypes: true })
+      
+      for (const item of items) {
+        const fullPath = join(dir, item.name)
+        
+        if (item.isDirectory()) {
+          files.push(...this.getFilesRecursively(fullPath))
+        } else {
+          files.push(fullPath)
+        }
+      }
+    } catch (error) {
+      // Ignore directories that can't be read
+    }
+    
+    return files
+  }
+
+  async createOptimizationReport(result: OptimizationResult): Promise<string> {
+    const report = `
+# Build Optimization Report
+
+## Summary
+- **Status**: ${result.success ? '✅ Success' : '❌ Failed'}
+- **Duration**: ${result.duration}ms
+- **Original Size**: ${(result.originalSize / 1024).toFixed(2)} KB
+- **Optimized Size**: ${(result.optimizedSize / 1024).toFixed(2)} KB
+- **Size Reduction**: ${result.compressionRatio.toFixed(2)}%
+
+## Optimizations Applied
+
+${result.optimizations.map(opt => 
+  `### ${opt.type.charAt(0).toUpperCase() + opt.type.slice(1)}
+- ${opt.description}
+- Size Saved: ${(opt.sizeSaved / 1024).toFixed(2)} KB`
+).join('\n\n')}
+
+${result.error ? `## Error\n${result.error}` : ''}
+
+Generated at: ${new Date().toISOString()}
+`
+
+    return report.trim()
+  }
 }

package/core/cli/command-registry.ts

@@ -1,6 +1,6 @@
 import type { CliCommand, CliContext, CliArgument, CliOption } from "../plugins/types"
-import { getConfigSync } from "@/core/config"
-import { logger } from "@/core/utils/logger"
+import { fluxStackConfig } from "@config"
+import { logger } from "@core/utils/logger"
 import { createTimer, formatBytes, isProduction, isDevelopment } from "../utils/helpers"
 
 export class CliCommandRegistry {
@@ -9,7 +9,7 @@ export class CliCommandRegistry {
   private context: CliContext
 
   constructor() {
-    const config = getConfigSync()
+    const config = fluxStackConfig
 
     this.context = {
       config,
@@ -321,4 +321,6 @@ Use "flux help <command>" for more information about a specific command.`)
 }
 
 // Global registry instance
-export const cliRegistry = new CliCommandRegistry()
+export const cliRegistry = new CliCommandRegistry()
+
+export type CLICommand = CliCommand