create-fluxstack 1.0.0

package/core/utils/logger/index.ts

@@ -0,0 +1,161 @@
+/**
+ * FluxStack Logger
+ * Environment-aware logging system
+ */
+
+// Environment info is handled via process.env directly
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+export interface Logger {
+  debug(message: string, meta?: any): void
+  info(message: string, meta?: any): void
+  warn(message: string, meta?: any): void
+  error(message: string, meta?: any): void
+  
+  // Contextual logging
+  child(context: any): Logger
+  
+  // Performance logging
+  time(label: string): void
+  timeEnd(label: string): void
+  
+  // Request logging
+  request(method: string, path: string, status?: number, duration?: number): void
+}
+
+class FluxStackLogger implements Logger {
+  private static instance: FluxStackLogger | null = null
+  private logLevel: LogLevel
+  private context: any = {}
+  private timers: Map<string, number> = new Map()
+
+  private constructor(context?: any) {
+    // Default to 'info' level, can be overridden by config
+    this.logLevel = (process.env.LOG_LEVEL as LogLevel) || 'info'
+    this.context = context || {}
+  }
+
+  static getInstance(): FluxStackLogger {
+    if (FluxStackLogger.instance === null) {
+      FluxStackLogger.instance = new FluxStackLogger()
+    }
+    return FluxStackLogger.instance
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    const levels: Record<LogLevel, number> = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    }
+
+    return levels[level] >= levels[this.logLevel]
+  }
+
+  private formatMessage(level: LogLevel, message: string, meta?: any): string {
+    const timestamp = new Date().toISOString()
+    const levelStr = level.toUpperCase().padEnd(5)
+    
+    let formatted = `[${timestamp}] ${levelStr}`
+    
+    // Add context if available
+    if (Object.keys(this.context).length > 0) {
+      const contextStr = Object.entries(this.context)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(' ')
+      formatted += ` [${contextStr}]`
+    }
+    
+    formatted += ` ${message}`
+    
+    if (meta && typeof meta === 'object') {
+      formatted += ` ${JSON.stringify(meta)}`
+    } else if (meta !== undefined) {
+      formatted += ` ${meta}`
+    }
+    
+    return formatted
+  }
+
+  debug(message: string, meta?: any): void {
+    if (this.shouldLog('debug')) {
+      console.debug(this.formatMessage('debug', message, meta))
+    }
+  }
+
+  info(message: string, meta?: any): void {
+    if (this.shouldLog('info')) {
+      console.info(this.formatMessage('info', message, meta))
+    }
+  }
+
+  warn(message: string, meta?: any): void {
+    if (this.shouldLog('warn')) {
+      console.warn(this.formatMessage('warn', message, meta))
+    }
+  }
+
+  error(message: string, meta?: any): void {
+    if (this.shouldLog('error')) {
+      console.error(this.formatMessage('error', message, meta))
+    }
+  }
+
+  // Contextual logging
+  child(context: any): FluxStackLogger {
+    return new FluxStackLogger({ ...this.context, ...context })
+  }
+
+  // Performance logging
+  time(label: string): void {
+    this.timers.set(label, Date.now())
+  }
+
+  timeEnd(label: string): void {
+    const startTime = this.timers.get(label)
+    if (startTime) {
+      const duration = Date.now() - startTime
+      this.info(`Timer ${label}: ${duration}ms`)
+      this.timers.delete(label)
+    }
+  }
+
+  // HTTP request logging
+  request(method: string, path: string, status?: number, duration?: number): void {
+    const statusStr = status ? ` ${status}` : ''
+    const durationStr = duration ? ` (${duration}ms)` : ''
+    this.info(`${method} ${path}${statusStr}${durationStr}`)
+  }
+
+  // Plugin logging
+  plugin(pluginName: string, message: string, meta?: any): void {
+    this.debug(`[${pluginName}] ${message}`, meta)
+  }
+
+  // Framework logging
+  framework(message: string, meta?: any): void {
+    this.info(`[FluxStack] ${message}`, meta)
+  }
+}
+
+// Export singleton instance
+export const logger = FluxStackLogger.getInstance()
+
+// Export convenience functions
+export const log = {
+  debug: (message: string, meta?: any) => logger.debug(message, meta),
+  info: (message: string, meta?: any) => logger.info(message, meta),
+  warn: (message: string, meta?: any) => logger.warn(message, meta),
+  error: (message: string, meta?: any) => logger.error(message, meta),
+  request: (method: string, path: string, status?: number, duration?: number) => 
+    logger.request(method, path, status, duration),
+  plugin: (pluginName: string, message: string, meta?: any) => 
+    logger.plugin(pluginName, message, meta),
+  framework: (message: string, meta?: any) => 
+    logger.framework(message, meta),
+  child: (context: any) => logger.child(context),
+  time: (label: string) => logger.time(label),
+  timeEnd: (label: string) => logger.timeEnd(label)
+}

package/core/utils/logger.ts

@@ -0,0 +1,106 @@
+/**
+ * FluxStack Logger
+ * Environment-aware logging system
+ */
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+class Logger {
+  private static instance: Logger | null = null
+  private logLevel: LogLevel
+
+  private constructor() {
+    this.logLevel = (process.env.LOG_LEVEL as LogLevel) || 'info'
+  }
+
+  static getInstance(): Logger {
+    if (Logger.instance === null) {
+      Logger.instance = new Logger()
+    }
+    return Logger.instance
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    const levels: Record<LogLevel, number> = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    }
+
+    return levels[level] >= levels[this.logLevel]
+  }
+
+  private formatMessage(level: LogLevel, message: string, meta?: any): string {
+    const timestamp = new Date().toISOString()
+    const levelStr = level.toUpperCase().padEnd(5)
+    
+    let formatted = `[${timestamp}] ${levelStr} ${message}`
+    
+    if (meta && typeof meta === 'object') {
+      formatted += ` ${JSON.stringify(meta)}`
+    } else if (meta !== undefined) {
+      formatted += ` ${meta}`
+    }
+    
+    return formatted
+  }
+
+  debug(message: string, meta?: any): void {
+    if (this.shouldLog('debug')) {
+      console.debug(this.formatMessage('debug', message, meta))
+    }
+  }
+
+  info(message: string, meta?: any): void {
+    if (this.shouldLog('info')) {
+      console.info(this.formatMessage('info', message, meta))
+    }
+  }
+
+  warn(message: string, meta?: any): void {
+    if (this.shouldLog('warn')) {
+      console.warn(this.formatMessage('warn', message, meta))
+    }
+  }
+
+  error(message: string, meta?: any): void {
+    if (this.shouldLog('error')) {
+      console.error(this.formatMessage('error', message, meta))
+    }
+  }
+
+  // HTTP request logging
+  request(method: string, path: string, status?: number, duration?: number): void {
+    const statusStr = status ? ` ${status}` : ''
+    const durationStr = duration ? ` (${duration}ms)` : ''
+    this.info(`${method} ${path}${statusStr}${durationStr}`)
+  }
+
+  // Plugin logging
+  plugin(pluginName: string, message: string, meta?: any): void {
+    this.debug(`[${pluginName}] ${message}`, meta)
+  }
+
+  // Framework logging
+  framework(message: string, meta?: any): void {
+    this.info(`[FluxStack] ${message}`, meta)
+  }
+}
+
+// Export singleton instance
+export const logger = Logger.getInstance()
+
+// Export convenience functions
+export const log = {
+  debug: (message: string, meta?: any) => logger.debug(message, meta),
+  info: (message: string, meta?: any) => logger.info(message, meta),
+  warn: (message: string, meta?: any) => logger.warn(message, meta),
+  error: (message: string, meta?: any) => logger.error(message, meta),
+  request: (method: string, path: string, status?: number, duration?: number) => 
+    logger.request(method, path, status, duration),
+  plugin: (pluginName: string, message: string, meta?: any) => 
+    logger.plugin(pluginName, message, meta),
+  framework: (message: string, meta?: any) => 
+    logger.framework(message, meta)
+}

package/core/utils/monitoring/index.ts

@@ -0,0 +1,212 @@
+export interface Metric {
+  name: string
+  type: 'counter' | 'gauge' | 'histogram'
+  help: string
+  labels?: string[]
+  value?: number
+  values?: number[]
+}
+
+export interface Counter extends Metric {
+  type: 'counter'
+  inc(value?: number, labels?: Record<string, string>): void
+}
+
+export interface Gauge extends Metric {
+  type: 'gauge'
+  set(value: number, labels?: Record<string, string>): void
+  inc(value?: number, labels?: Record<string, string>): void
+  dec(value?: number, labels?: Record<string, string>): void
+}
+
+export interface Histogram extends Metric {
+  type: 'histogram'
+  observe(value: number, labels?: Record<string, string>): void
+  buckets: number[]
+}
+
+export interface SystemMetrics {
+  memoryUsage: {
+    rss: number
+    heapTotal: number
+    heapUsed: number
+    external: number
+  }
+  cpuUsage: {
+    user: number
+    system: number
+  }
+  eventLoopLag: number
+  uptime: number
+}
+
+export interface HttpMetrics {
+  requestsTotal: number
+  requestDuration: number[]
+  requestSize: number[]
+  responseSize: number[]
+  errorRate: number
+}
+
+export class MetricsCollector {
+  private metrics: Map<string, Metric> = new Map()
+  private httpMetrics: HttpMetrics = {
+    requestsTotal: 0,
+    requestDuration: [],
+    requestSize: [],
+    responseSize: [],
+    errorRate: 0
+  }
+
+  // Create metrics
+  createCounter(name: string, help: string, labels?: string[]): Counter {
+    const counter: Counter = {
+      name,
+      type: 'counter',
+      help,
+      labels,
+      value: 0,
+      inc: (value = 1, _labels) => {
+        counter.value = (counter.value || 0) + value
+      }
+    }
+    
+    this.metrics.set(name, counter)
+    return counter
+  }
+
+  createGauge(name: string, help: string, labels?: string[]): Gauge {
+    const gauge: Gauge = {
+      name,
+      type: 'gauge',
+      help,
+      labels,
+      value: 0,
+      set: (value, _labels) => {
+        gauge.value = value
+      },
+      inc: (value = 1, _labels) => {
+        gauge.value = (gauge.value || 0) + value
+      },
+      dec: (value = 1, _labels) => {
+        gauge.value = (gauge.value || 0) - value
+      }
+    }
+    
+    this.metrics.set(name, gauge)
+    return gauge
+  }
+
+  createHistogram(name: string, help: string, buckets: number[] = [0.1, 0.5, 1, 2.5, 5, 10]): Histogram {
+    const histogram: Histogram = {
+      name,
+      type: 'histogram',
+      help,
+      buckets,
+      values: [],
+      observe: (value, _labels) => {
+        histogram.values = histogram.values || []
+        histogram.values.push(value)
+      }
+    }
+    
+    this.metrics.set(name, histogram)
+    return histogram
+  }
+
+  // HTTP metrics
+  recordHttpRequest(_method: string, _path: string, statusCode: number, duration: number, requestSize?: number, responseSize?: number): void {
+    this.httpMetrics.requestsTotal++
+    this.httpMetrics.requestDuration.push(duration)
+    
+    if (requestSize) {
+      this.httpMetrics.requestSize.push(requestSize)
+    }
+    
+    if (responseSize) {
+      this.httpMetrics.responseSize.push(responseSize)
+    }
+    
+    if (statusCode >= 400) {
+      this.httpMetrics.errorRate = this.calculateErrorRate()
+    }
+  }
+
+  // System metrics
+  getSystemMetrics(): SystemMetrics {
+    const memUsage = process.memoryUsage()
+    const cpuUsage = process.cpuUsage()
+    
+    return {
+      memoryUsage: {
+        rss: memUsage.rss,
+        heapTotal: memUsage.heapTotal,
+        heapUsed: memUsage.heapUsed,
+        external: memUsage.external
+      },
+      cpuUsage: {
+        user: cpuUsage.user,
+        system: cpuUsage.system
+      },
+      eventLoopLag: this.measureEventLoopLag(),
+      uptime: process.uptime()
+    }
+  }
+
+  // Get all metrics
+  getAllMetrics(): Map<string, Metric> {
+    return new Map(this.metrics)
+  }
+
+  getHttpMetrics(): HttpMetrics {
+    return { ...this.httpMetrics }
+  }
+
+  // Export metrics in Prometheus format
+  exportPrometheus(): string {
+    let output = ''
+    
+    for (const metric of this.metrics.values()) {
+      output += `# HELP ${metric.name} ${metric.help}\n`
+      output += `# TYPE ${metric.name} ${metric.type}\n`
+      
+      if (metric.type === 'counter' || metric.type === 'gauge') {
+        output += `${metric.name} ${metric.value || 0}\n`
+      } else if (metric.type === 'histogram' && metric.values) {
+        const values = metric.values.sort((a, b) => a - b)
+        const buckets = (metric as Histogram).buckets
+        
+        for (const bucket of buckets) {
+          const count = values.filter(v => v <= bucket).length
+          output += `${metric.name}_bucket{le="${bucket}"} ${count}\n`
+        }
+        
+        output += `${metric.name}_bucket{le="+Inf"} ${values.length}\n`
+        output += `${metric.name}_count ${values.length}\n`
+        output += `${metric.name}_sum ${values.reduce((sum, v) => sum + v, 0)}\n`
+      }
+      
+      output += '\n'
+    }
+    
+    return output
+  }
+
+  private calculateErrorRate(): number {
+    const totalRequests = this.httpMetrics.requestsTotal
+    if (totalRequests === 0) return 0
+    
+    // This is a simplified calculation - in a real implementation,
+    // you'd track error counts separately
+    return 0 // Placeholder
+  }
+
+  private measureEventLoopLag(): number {
+    const start = process.hrtime.bigint()
+    setImmediate(() => {
+      const lag = Number(process.hrtime.bigint() - start) / 1e6 // Convert to milliseconds
+      return lag
+    })
+    return 0 // Placeholder - actual implementation would be more complex
+  }
+}

package/create-fluxstack.ts

@@ -0,0 +1,231 @@
+#!/usr/bin/env bun
+
+import { program } from 'commander'
+import { resolve, join } from 'path'
+import { existsSync, mkdirSync, cpSync, writeFileSync, readFileSync } from 'fs'
+import chalk from 'chalk'
+import ora from 'ora'
+
+const logo = `
+⚡ ███████ ██      ██    ██ ██   ██ ███████ ████████  █████   ██████ ██   ██ 
+   ██      ██      ██    ██  ██ ██  ██         ██    ██   ██ ██      ██  ██  
+   █████   ██      ██    ██   ███   ███████    ██    ███████ ██      █████   
+   ██      ██      ██    ██  ██ ██       ██    ██    ██   ██ ██      ██  ██  
+   ██      ███████  ██████  ██   ██ ███████    ██    ██   ██  ██████ ██   ██ 
+
+${chalk.cyan('💫 Powered by Bun - The Divine Runtime ⚡')}
+${chalk.gray('Creates FluxStack apps by copying the working framework')}
+`
+
+program
+  .name('create-fluxstack')
+  .description('⚡ Create FluxStack apps with zero configuration')
+  .version('1.0.0')
+  .argument('[project-name]', 'Name of the project to create')
+  .option('--no-install', 'Skip dependency installation')
+  .option('--no-git', 'Skip git initialization')
+  .action(async (projectName, options) => {
+    console.clear()
+    console.log(chalk.magenta(logo))
+    
+    if (!projectName || projectName.trim().length === 0) {
+      console.log(chalk.red('❌ Project name is required'))
+      console.log(chalk.gray('Usage: ./create-fluxstack.ts my-app'))
+      process.exit(1)
+    }
+    
+    const currentDir = import.meta.dir
+    const projectPath = resolve(projectName)
+    
+    // Check if directory already exists
+    if (existsSync(projectPath)) {
+      console.log(chalk.red(`❌ Directory ${projectName} already exists`))
+      process.exit(1)
+    }
+    
+    console.log(chalk.cyan(`\\n🚀 Creating FluxStack project: ${chalk.bold(projectName)}`))
+    console.log(chalk.gray(`📁 Location: ${projectPath}`))
+    
+    // Create project directory
+    const spinner = ora('Creating project structure...').start()
+    
+    try {
+      mkdirSync(projectPath, { recursive: true })
+      
+      // Copy only essential FluxStack files (not node_modules, not test apps, etc.)
+      const filesToCopy = [
+        'core',
+        'app',
+        'package.json',
+        'bun.lock',  // ✅ CRITICAL: Copy lockfile to maintain working versions
+        'tsconfig.json',
+        'vite.config.ts',
+        '.env',
+        'README.md'
+      ]
+      
+      for (const file of filesToCopy) {
+        const sourcePath = join(currentDir, file)
+        const destPath = join(projectPath, file)
+        
+        if (existsSync(sourcePath)) {
+          cpSync(sourcePath, destPath, { recursive: true })
+        }
+      }
+      
+      // Customize package.json
+      const packageJsonPath = join(projectPath, 'package.json')
+      if (existsSync(packageJsonPath)) {
+        const packageContent = readFileSync(packageJsonPath, 'utf-8')
+        const packageJson = JSON.parse(packageContent)
+        
+        packageJson.name = projectName
+        packageJson.description = `${projectName} - FluxStack application`
+        
+        // Remove scripts that don't make sense for user projects
+        delete packageJson.scripts['test:watch']
+        delete packageJson.scripts['test:coverage']
+        delete packageJson.scripts['docs:build']
+        delete packageJson.scripts['docs:serve']
+        
+        writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
+      }
+      
+      // Customize .env for development mode
+      const envPath = join(projectPath, '.env')
+      if (existsSync(envPath)) {
+        const envContent = readFileSync(envPath, 'utf-8')
+        const devEnvContent = envContent.replace(
+          'NODE_ENV=production',
+          'NODE_ENV=development'
+        )
+        writeFileSync(envPath, devEnvContent)
+      }
+      
+      // Customize README.md
+      const readmePath = join(projectPath, 'README.md')
+      if (existsSync(readmePath)) {
+        const readmeContent = `# ${projectName}
+
+⚡ **FluxStack Application** - Modern full-stack TypeScript framework
+
+## 🚀 Getting Started
+
+\`\`\`bash
+# Start development
+bun run dev
+
+# Build for production  
+bun run build
+
+# Start production server
+bun run start
+\`\`\`
+
+## 📁 Project Structure
+
+\`\`\`
+${projectName}/
+├── core/          # FluxStack framework (don't modify)
+├── app/           # Your application code
+│   ├── server/    # Backend API routes
+│   ├── client/    # Frontend React app
+│   └── shared/    # Shared types and utilities
+└── package.json
+\`\`\`
+
+## 🔥 Features
+
+- **⚡ Bun Runtime** - 3x faster than Node.js
+- **🔒 Full Type Safety** - Eden Treaty + TypeScript
+- **🎨 Modern UI** - React 19 + Tailwind CSS v4
+- **📋 Auto Documentation** - Swagger UI generated
+- **🔄 Hot Reload** - Backend + Frontend
+
+## 📖 Learn More
+
+Visit the [FluxStack Documentation](https://fluxstack.dev) to learn more!
+
+---
+
+Built with ❤️ using FluxStack
+`
+        writeFileSync(readmePath, readmeContent)
+      }
+      
+      spinner.succeed('✅ Project structure created!')
+      
+      // Install dependencies with Bun (THE DIVINE RUNTIME)
+      if (options.install) {
+        const installSpinner = ora('📦 Installing dependencies with Bun...').start()
+        
+        try {
+          const proc = Bun.spawn(['bun', 'install'], {
+            cwd: projectPath,
+            stdio: ['ignore', 'pipe', 'pipe']
+          })
+          
+          await proc.exited
+          
+          if (proc.exitCode === 0) {
+            installSpinner.succeed('✅ Dependencies installed!')
+          } else {
+            installSpinner.fail('❌ Failed to install dependencies')
+            console.log(chalk.gray('You can install them manually with: bun install'))
+          }
+        } catch (error) {
+          installSpinner.fail('❌ Failed to install dependencies')
+          console.log(chalk.gray('You can install them manually with: bun install'))
+        }
+      }
+      
+      // Initialize git
+      if (options.git) {
+        const gitSpinner = ora('📝 Initializing git repository...').start()
+        
+        try {
+          const initProc = Bun.spawn(['git', 'init'], {
+            cwd: projectPath,
+            stdio: ['ignore', 'pipe', 'pipe']
+          })
+          await initProc.exited
+          
+          // Create initial commit
+          const addProc = Bun.spawn(['git', 'add', '.'], {
+            cwd: projectPath,
+            stdio: ['ignore', 'pipe', 'pipe']
+          })
+          await addProc.exited
+          
+          const commitProc = Bun.spawn(['git', 'commit', '-m', `feat: initial ${projectName} with FluxStack`], {
+            cwd: projectPath,
+            stdio: ['ignore', 'pipe', 'pipe']
+          })
+          await commitProc.exited
+          
+          gitSpinner.succeed('✅ Git repository initialized!')
+        } catch (error) {
+          gitSpinner.fail('❌ Failed to initialize git')
+          console.log(chalk.gray('You can initialize it manually with: git init'))
+        }
+      }
+      
+      // Success message
+      console.log(chalk.green('\\n🎉 Project created successfully!'))
+      console.log(chalk.cyan('\\nNext steps:'))
+      console.log(chalk.white(`  cd ${projectName}`))
+      if (!options.install) {
+        console.log(chalk.white(`  bun install`))
+      }
+      console.log(chalk.white(`  bun run dev`))
+      console.log(chalk.magenta('\\nHappy coding with the divine Bun runtime! ⚡🔥'))
+      console.log(chalk.gray('\\nVisit http://localhost:3000 when ready!'))
+      
+    } catch (error) {
+      spinner.fail('❌ Failed to create project')
+      console.error(error)
+      process.exit(1)
+    }
+  })
+
+program.parse()