create-fluxstack 1.16.0 → 1.17.0

package/core/build/index.ts

@@ -1,7 +1,7 @@
 import { copyFileSync, writeFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "fs"
 import { join } from "path"
 import type { FluxStackConfig } from "../config"
-import type { BuildResult, BuildManifest } from "../types/build"
+import type { BuildResult, BuildManifest, BundleResult, OptimizationResult } from "../types/build"
 import { Bundler } from "./bundler"
 import { Optimizer } from "./optimizer"
 import { FLUXSTACK_VERSION } from "../utils/version"
@@ -9,14 +9,69 @@ import { buildLogger } from "../utils/build-logger"
 import type { PluginRegistry } from "../plugins/registry"
 import type { BuildContext, BuildAssetContext, BuildErrorContext } from "../plugins/types"
 
+/**
+ * Runtime shape of config properties - the FluxStackConfig type uses
+ * complex conditional inference via defineConfig/defineNestedConfig
+ * which causes spread results to collapse to {} at the type level.
+ * We declare the actual runtime shapes explicitly.
+ */
+interface BuildConfigRuntime {
+  target: string
+  outDir: string
+  sourceMaps: boolean
+  clean: boolean
+  mode: string
+  external: string[]
+  optimize: boolean
+  optimization: {
+    minify: boolean
+    treeshake: boolean
+    compress: boolean
+    splitChunks: boolean
+    bundleAnalyzer: boolean
+    removeUnusedCSS: boolean
+    optimizeImages: boolean
+  }
+}
+
+interface OptimizationConfigRuntime {
+  minify: boolean
+  treeshake: boolean
+  compress: boolean
+  splitChunks: boolean
+  bundleAnalyzer: boolean
+  removeUnusedCSS: boolean
+  optimizeImages: boolean
+}
+
+interface AppConfigRuntime {
+  name: string
+  version: string
+  env: string
+  debug: boolean
+}
+
+interface ClientBuildRuntime {
+  outDir: string
+  sourceMaps: boolean
+}
+
+/** Augmented config type that resolves the spread-collapsed properties */
+type ResolvedFluxStackConfig = FluxStackConfig & {
+  build: BuildConfigRuntime
+  optimization: OptimizationConfigRuntime
+  app: AppConfigRuntime
+  clientBuild: ClientBuildRuntime
+}
+
 export class FluxStackBuilder {
-  private config: FluxStackConfig
+  private config: ResolvedFluxStackConfig
   private bundler: Bundler
   private optimizer: Optimizer
   private pluginRegistry?: PluginRegistry
 
   constructor(config: FluxStackConfig, pluginRegistry?: PluginRegistry) {
-    this.config = config
+    this.config = config as ResolvedFluxStackConfig
     this.pluginRegistry = pluginRegistry
 
     const optimization = this.config.optimization || {
@@ -28,22 +83,24 @@ export class FluxStackBuilder {
       bundleAnalyzer: false
     }
 
+    const buildCfg = this.config.build
+
     // Initialize bundler with configuration
     this.bundler = new Bundler({
-      target: config.build.target ?? 'bun',
-      outDir: config.build.outDir ?? 'dist',
-      sourceMaps: config.build.sourceMaps ?? false,
-      minify: optimization.minify,
-      external: config.build.external || []
+      target: (buildCfg.target ?? 'bun') as 'bun' | 'node' | 'docker',
+      outDir: buildCfg.outDir ?? 'dist',
+      sourceMaps: buildCfg.sourceMaps ?? false,
+      minify: optimization.minify as boolean ?? true,
+      external: buildCfg.external || []
     })
 
     // Initialize optimizer with configuration
     this.optimizer = new Optimizer({
-      treeshake: optimization.treeshake ?? true,
-      compress: optimization.compress || false,
-      removeUnusedCSS: optimization.removeUnusedCSS || false,
-      optimizeImages: optimization.optimizeImages || false,
-      bundleAnalysis: optimization.bundleAnalyzer || false
+      treeshake: Boolean(optimization.treeshake ?? true),
+      compress: Boolean(optimization.compress || false),
+      removeUnusedCSS: Boolean(optimization.removeUnusedCSS || false),
+      optimizeImages: Boolean(optimization.optimizeImages || false),
+      bundleAnalysis: Boolean(optimization.bundleAnalyzer || false)
     })
   }
 
@@ -429,19 +486,33 @@ MONITORING_ENABLED=true
   }
 
   private async generateManifest(
-    clientResult: any,
-    serverResult: any,
-    optimizationResult?: any
+    clientResult: BundleResult,
+    serverResult: BundleResult,
+    optimizationResult?: OptimizationResult
   ): Promise<BuildManifest> {
+    const target = (this.config.build.target ?? 'bun') as import("../types/build").BuildTarget
+    const mode = (this.config.build.mode ?? 'production') as import("../types/build").BuildMode
+
+    // Map string asset paths to AssetManifest objects
+    const clientAssets: import("../types/build").AssetManifest[] = (clientResult.assets || []).map(
+      (assetPath) => ({
+        name: assetPath.split('/').pop() || assetPath,
+        file: assetPath,
+        size: 0,
+        hash: '',
+        type: 'asset'
+      })
+    )
+
     return {
       version: this.config.app.version ?? '0.0.0',
       timestamp: new Date().toISOString(),
-      target: this.config.build.target ?? 'bun',
-      mode: this.config.build.mode ?? 'production',
+      target,
+      mode,
       client: {
         entryPoints: [],
         chunks: [],
-        assets: clientResult.assets || [],
+        assets: clientAssets,
         publicPath: '/'
       },
       server: {
@@ -473,7 +544,7 @@ MONITORING_ENABLED=true
   /**
    * Execute plugin hooks for build process
    */
-  private async executePluginHooks(hookName: string, context: any): Promise<void> {
+  private async executePluginHooks(hookName: string, context: unknown): Promise<void> {
     if (!this.pluginRegistry) return
 
     const loadOrder = this.pluginRegistry.getLoadOrder()
@@ -482,7 +553,7 @@ MONITORING_ENABLED=true
       const plugin = this.pluginRegistry.get(pluginName)
       if (!plugin) continue
 
-      const hookFn = (plugin as any)[hookName]
+      const hookFn = (plugin as unknown as Record<string, unknown>)[hookName]
       if (typeof hookFn === 'function') {
         try {
           await hookFn(context)

package/core/cli/command-registry.ts

@@ -1,7 +1,10 @@
-import type { CliCommand, CliContext, CliArgument, CliOption } from "../plugins/types"
+import type { CliCommand, CliContext, CliArgument, CliOption, PluginConfigSchema } from "../plugins/types"
 import { fluxStackConfig } from "@config"
 import { logger } from "@core/utils/logger"
+import { buildLogger } from "@core/utils/build-logger"
 import { createTimer, formatBytes, isProduction, isDevelopment } from "../utils/helpers"
+import { createHash } from "crypto"
+import { createPluginUtils } from "../plugins/config"
 
 export class CliCommandRegistry {
   private commands = new Map<string, CliCommand>()
@@ -13,7 +16,7 @@ export class CliCommandRegistry {
 
     this.context = {
       config,
-      logger: logger as any,
+      logger,
       utils: {
         createTimer,
         formatBytes,
@@ -21,8 +24,7 @@ export class CliCommandRegistry {
         isDevelopment,
         getEnvironment: () => process.env.NODE_ENV || 'development',
         createHash: (data: string) => {
-          const crypto = require('crypto')
-          return crypto.createHash('sha256').update(data).digest('hex')
+          return createHash('sha256').update(data).digest('hex')
         },
         deepMerge: (target: Record<string, unknown>, source: Record<string, unknown>) => {
           const result = { ...target }
@@ -35,12 +37,8 @@ export class CliCommandRegistry {
           }
           return result
         },
-        validateSchema: (_data: unknown, _schema: unknown) => {
-          try {
-            return { valid: true, errors: [] }
-          } catch (error) {
-            return { valid: false, errors: [error instanceof Error ? error.message : 'Validation failed'] }
-          }
+        validateSchema: (data: Record<string, unknown>, schema: PluginConfigSchema) => {
+          return createPluginUtils(logger).validateSchema(data, schema)
         }
       },
       workingDir: process.cwd(),
@@ -103,9 +101,9 @@ export class CliCommandRegistry {
 
   async execute(commandName: string, args: string[]): Promise<number> {
     const command = this.get(commandName)
-    
+
     if (!command) {
-      console.error(`❌ Unknown command: ${commandName}`)
+      buildLogger.error(`❌ Unknown command: ${commandName}`)
       this.showHelp()
       return 1
     }
@@ -113,24 +111,24 @@ export class CliCommandRegistry {
     try {
       // Parse arguments and options
       const { parsedArgs, parsedOptions } = this.parseArgs(command, args)
-      
+
       // Validate required arguments
       if (command.arguments) {
         for (let i = 0; i < command.arguments.length; i++) {
           const arg = command.arguments[i]
           if (arg.required && !parsedArgs[i]) {
-            console.error(`❌ Missing required argument: ${arg.name}`)
+            buildLogger.error(`❌ Missing required argument: ${arg.name}`)
             this.showCommandHelp(command)
             return 1
           }
         }
       }
-      
+
       // Validate required options
       if (command.options) {
         for (const option of command.options) {
           if (option.required && !(option.name in parsedOptions)) {
-            console.error(`❌ Missing required option: --${option.name}`)
+            buildLogger.error(`❌ Missing required option: --${option.name}`)
             this.showCommandHelp(command)
             return 1
           }
@@ -140,16 +138,16 @@ export class CliCommandRegistry {
       // Execute command
       await command.handler(parsedArgs, parsedOptions, this.context)
       return 0
-      
+
     } catch (error) {
-      console.error(`❌ Command failed:`, error instanceof Error ? error.message : String(error))
+      buildLogger.error('❌ Command failed:', error instanceof Error ? error.message : String(error))
       return 1
     }
   }
 
-  private parseArgs(command: CliCommand, args: string[]): { parsedArgs: any[], parsedOptions: any } {
-    const parsedArgs: any[] = []
-    const parsedOptions: any = {}
+  private parseArgs(command: CliCommand, args: string[]): { parsedArgs: unknown[], parsedOptions: Record<string, unknown> } {
+    const parsedArgs: unknown[] = []
+    const parsedOptions: Record<string, unknown> = {}
     
     let i = 0
     while (i < args.length) {
@@ -166,7 +164,7 @@ export class CliCommandRegistry {
           } else if (option.type === 'array') {
             parsedOptions[optionName] = parsedOptions[optionName] || []
             if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
-              parsedOptions[optionName].push(args[++i])
+              (parsedOptions[optionName] as unknown[]).push(args[++i])
             }
           } else {
             if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
@@ -225,7 +223,7 @@ export class CliCommandRegistry {
     return { parsedArgs, parsedOptions }
   }
 
-  private convertType(value: string, type?: 'string' | 'number' | 'boolean' | 'array'): any {
+  private convertType(value: string, type?: 'string' | 'number' | 'boolean' | 'array'): string | number | boolean | string[] {
     if (!type || type === 'string') return value
     if (type === 'number') return Number(value)
     if (type === 'boolean') return value.toLowerCase() === 'true'
@@ -234,7 +232,7 @@ export class CliCommandRegistry {
   }
 
   showHelp(): void {
-    console.log(`
+    buildLogger.info(`
 ⚡ FluxStack Framework CLI
 
 Usage:
@@ -244,16 +242,16 @@ Usage:
 Built-in Commands:`)
 
     const categories = this.getAllByCategory()
-    
+
     for (const [category, commands] of categories) {
-      console.log(`\n${category}:`)
+      buildLogger.info(`\n${category}:`)
       for (const command of commands) {
         const aliases = command.aliases?.length ? ` (${command.aliases.join(', ')})` : ''
-        console.log(`  ${command.name}${aliases.padEnd(20)} ${command.description}`)
+        buildLogger.info(`  ${command.name}${aliases.padEnd(20)} ${command.description}`)
       }
     }
 
-    console.log(`
+    buildLogger.info(`
 Examples:
   flux dev                    # Start development server
   flux build --production    # Build for production
@@ -264,13 +262,13 @@ Use "flux help <command>" for more information about a specific command.`)
   }
 
   showCommandHelp(command: CliCommand): void {
-    console.log(`\n${command.description}`)
-    
+    buildLogger.info(`\n${command.description}`)
+
     if (command.usage) {
-      console.log(`\nUsage:\n  ${command.usage}`)
+      buildLogger.info(`\nUsage:\n  ${command.usage}`)
     } else {
       let usage = `flux ${command.name}`
-      
+
       if (command.arguments) {
         for (const arg of command.arguments) {
           if (arg.required) {
@@ -280,42 +278,42 @@ Use "flux help <command>" for more information about a specific command.`)
           }
         }
       }
-      
+
       if (command.options?.length) {
         usage += ` [options]`
       }
-      
-      console.log(`\nUsage:\n  ${usage}`)
+
+      buildLogger.info(`\nUsage:\n  ${usage}`)
     }
-    
+
     if (command.arguments?.length) {
-      console.log(`\nArguments:`)
+      buildLogger.info(`\nArguments:`)
       for (const arg of command.arguments) {
         const required = arg.required ? ' (required)' : ''
         const defaultValue = arg.default !== undefined ? ` (default: ${arg.default})` : ''
-        console.log(`  ${arg.name.padEnd(15)} ${arg.description}${required}${defaultValue}`)
+        buildLogger.info(`  ${arg.name.padEnd(15)} ${arg.description}${required}${defaultValue}`)
       }
     }
-    
+
     if (command.options?.length) {
-      console.log(`\nOptions:`)
+      buildLogger.info(`\nOptions:`)
       for (const option of command.options) {
         const short = option.short ? `-${option.short}, ` : '    '
         const required = option.required ? ' (required)' : ''
         const defaultValue = option.default !== undefined ? ` (default: ${option.default})` : ''
-        console.log(`  ${short}--${option.name.padEnd(15)} ${option.description}${required}${defaultValue}`)
+        buildLogger.info(`  ${short}--${option.name.padEnd(15)} ${option.description}${required}${defaultValue}`)
       }
     }
-    
+
     if (command.examples?.length) {
-      console.log(`\nExamples:`)
+      buildLogger.info(`\nExamples:`)
       for (const example of command.examples) {
-        console.log(`  ${example}`)
+        buildLogger.info(`  ${example}`)
       }
     }
-    
+
     if (command.aliases?.length) {
-      console.log(`\nAliases: ${command.aliases.join(', ')}`)
+      buildLogger.info(`\nAliases: ${command.aliases.join(', ')}`)
     }
   }
 }

package/core/cli/commands/build.ts

@@ -48,19 +48,24 @@ export const buildCommand: CLICommand = {
       await pluginManager.initialize()
       // Sync plugins to registry (same as framework does)
       const discoveredPlugins = pluginManager.getRegistry().getAll()
+      const registryInternals = pluginRegistry as unknown as {
+        plugins: Map<string, import('@core/plugins/types').FluxStack.Plugin>
+        dependencies: Map<string, string[]>
+        loadOrder: string[]
+        updateLoadOrder(): void
+      }
       for (const plugin of discoveredPlugins) {
         if (!pluginRegistry.has(plugin.name)) {
-          (pluginRegistry as any).plugins.set(plugin.name, plugin)
+          registryInternals.plugins.set(plugin.name, plugin)
           if (plugin.dependencies) {
-            (pluginRegistry as any).dependencies.set(plugin.name, plugin.dependencies)
+            registryInternals.dependencies.set(plugin.name, plugin.dependencies)
           }
         }
       }
       try {
-        (pluginRegistry as any).updateLoadOrder()
-      } catch (error) {
-        const plugins = (pluginRegistry as any).plugins as Map<string, any>
-        ;(pluginRegistry as any).loadOrder = Array.from(plugins.keys())
+        registryInternals.updateLoadOrder()
+      } catch {
+        registryInternals.loadOrder = Array.from(registryInternals.plugins.keys())
       }
     } catch (error) {
       context.logger.warn('Failed to load plugins for build hooks', { error })

package/core/cli/commands/create.ts

@@ -5,6 +5,7 @@
 
 import type { CLICommand } from '../command-registry'
 import { ProjectCreator } from '@core/templates/create-project'
+import { buildLogger } from '@core/utils/build-logger'
 
 export const createCommand: CLICommand = {
   name: 'create',
@@ -32,22 +33,23 @@ export const createCommand: CLICommand = {
     }
   ],
   handler: async (args, options, context) => {
-    const [projectName, template] = args
+    const projectName = args[0] as string
+    const template = args[1] as string | undefined
 
     if (!/^[a-zA-Z0-9-_]+$/.test(projectName)) {
-      console.error("❌ Project name can only contain letters, numbers, hyphens, and underscores")
+      buildLogger.error("❌ Project name can only contain letters, numbers, hyphens, and underscores")
       return
     }
 
     try {
       const creator = new ProjectCreator({
-        name: projectName,
-        template: template as 'basic' | 'full' || 'basic'
+        name: projectName as string,
+        template: (template as 'basic' | 'full') || 'basic'
       })
 
       await creator.create()
     } catch (error) {
-      console.error("❌ Failed to create project:", error instanceof Error ? error.message : String(error))
+      buildLogger.error("❌ Failed to create project:", error instanceof Error ? error.message : String(error))
       throw error
     }
   }

package/core/cli/commands/dev.ts

@@ -5,6 +5,7 @@
 
 import type { CLICommand } from '../command-registry'
 import { serverConfig, clientConfig } from '@config'
+import { buildLogger } from '@core/utils/build-logger'
 
 export const devCommand: CLICommand = {
   name: 'dev',
@@ -53,7 +54,7 @@ export const devCommand: CLICommand = {
     const backendOnly = options['backend-only'] === true
 
     if (frontendOnly && backendOnly) {
-      console.error('❌ Cannot use --frontend-only and --backend-only together')
+      buildLogger.error('❌ Cannot use --frontend-only and --backend-only together')
       process.exit(1)
     }
 
@@ -67,21 +68,21 @@ export const devCommand: CLICommand = {
 
     const fluxstackMode = backendOnly ? 'backend-only' : 'full-stack'
 
-    console.log(`⚡ Starting ${mode} development server...`)
+    buildLogger.info(`⚡ Starting ${mode} development server...`)
 
     const devProcess = spawn("bun", ["--watch", entryPoint], {
       stdio: "inherit",
       cwd: process.cwd(),
       env: {
         ...process.env,
-        FRONTEND_PORT: options['frontend-port'].toString(),
-        BACKEND_PORT: options.port.toString(),
+        FRONTEND_PORT: String(options['frontend-port']),
+        BACKEND_PORT: String(options.port),
         FLUXSTACK_MODE: fluxstackMode
       }
     })
 
     process.on('SIGINT', () => {
-      console.log('\n🛑 Shutting down gracefully...')
+      buildLogger.info('\n🛑 Shutting down gracefully...')
       devProcess.kill('SIGTERM')
       setTimeout(() => {
         devProcess.kill('SIGKILL')

package/core/cli/commands/help.ts

@@ -5,6 +5,7 @@
 
 import type { CLICommand } from '../command-registry'
 import { cliRegistry } from '../command-registry'
+import { buildLogger } from '@core/utils/build-logger'
 
 export const helpCommand: CLICommand = {
   name: 'help',
@@ -20,11 +21,11 @@ export const helpCommand: CLICommand = {
   ],
   handler: async (args, options, context) => {
     if (args[0]) {
-      const targetCommand = cliRegistry.get(args[0])
+      const targetCommand = cliRegistry.get(args[0] as string)
       if (targetCommand) {
         cliRegistry.showCommandHelp(targetCommand)
       } else {
-        console.error(`❌ Unknown command: ${args[0]}`)
+        buildLogger.error(`❌ Unknown command: ${args[0]}`)
         cliRegistry.showHelp()
       }
     } else {

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

@@ -4,6 +4,7 @@
  */
 
 import type { CLICommand } from '../command-registry'
+import { buildLogger } from '@core/utils/build-logger'
 
 export const makePluginCommand: CLICommand = {
   name: 'make:plugin',
@@ -49,10 +50,10 @@ export const makePluginCommand: CLICommand = {
     }
   ],
   handler: async (args, options, context) => {
-    const [name] = args
+    const name = args[0] as string
 
     if (!/^[a-zA-Z0-9-_]+$/.test(name)) {
-      console.error("❌ Plugin name can only contain letters, numbers, hyphens, and underscores")
+      buildLogger.error("❌ Plugin name can only contain letters, numbers, hyphens, and underscores")
       return
     }
 
@@ -61,7 +62,7 @@ export const makePluginCommand: CLICommand = {
     const pluginGenerator = generatorRegistry.get('plugin')
 
     if (!pluginGenerator) {
-      console.error("❌ Plugin generator not found")
+      buildLogger.error("❌ Plugin generator not found")
       return
     }
 
@@ -74,16 +75,16 @@ export const makePluginCommand: CLICommand = {
 
     const generatorOptions = {
       name,
-      template: options.template,
-      force: options.force,
+      template: options.template as string | undefined,
+      force: options.force as boolean | undefined,
       dryRun: false,
-      description: options.description
+      description: options.description as string | undefined
     }
 
     try {
       await pluginGenerator.generate(generatorContext, generatorOptions)
     } catch (error) {
-      console.error("❌ Failed to create plugin:", error instanceof Error ? error.message : String(error))
+      buildLogger.error("❌ Failed to create plugin:", error instanceof Error ? error.message : String(error))
       throw error
     }
   }