create-fluxstack 1.10.1 → 1.12.1

package/core/utils/monitoring/index.ts

@@ -1,212 +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
-  }
+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/core/utils/sync-version.ts

@@ -1,67 +1,67 @@
-#!/usr/bin/env bun
-
-/**
- * Version Synchronization Utility
- * Ensures version consistency between package.json and version.ts
- */
-
-import { readFileSync, writeFileSync } from 'fs'
-import { join } from 'path'
-
-interface PackageJson {
-  version: string
-  [key: string]: any
-}
-
-/**
- * Read version from package.json
- */
-function getPackageVersion(): string {
-  const packagePath = join(process.cwd(), 'package.json')
-  const packageContent = readFileSync(packagePath, 'utf-8')
-  const packageJson: PackageJson = JSON.parse(packageContent)
-  return packageJson.version
-}
-
-/**
- * Update version.ts with the version from package.json
- */
-function updateVersionFile(version: string, silent = false): void {
-  const versionPath = join(process.cwd(), 'core/utils/version.ts')
-  const versionContent = `/**
- * FluxStack Framework Version
- * Single source of truth for version number
- * Auto-synced with package.json
- */
-export const FLUXSTACK_VERSION = '${version}'
-`
-  writeFileSync(versionPath, versionContent)
-  if (!silent) {
-    console.log(`✅ Updated version.ts to v${version}`)
-  }
-}
-
-/**
- * Main sync function
- */
-function syncVersion(silent = false): void {
-  try {
-    const packageVersion = getPackageVersion()
-    updateVersionFile(packageVersion, silent)
-    if (!silent) {
-      console.log(`🔄 Version synchronized: v${packageVersion}`)
-    }
-  } catch (error) {
-    if (!silent) {
-      console.error('❌ Failed to sync version:', error)
-    }
-    process.exit(1)
-  }
-}
-
-// Run if called directly
-if (import.meta.main) {
-  syncVersion()
-}
-
+#!/usr/bin/env bun
+
+/**
+ * Version Synchronization Utility
+ * Ensures version consistency between package.json and version.ts
+ */
+
+import { readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+
+interface PackageJson {
+  version: string
+  [key: string]: any
+}
+
+/**
+ * Read version from package.json
+ */
+function getPackageVersion(): string {
+  const packagePath = join(process.cwd(), 'package.json')
+  const packageContent = readFileSync(packagePath, 'utf-8')
+  const packageJson: PackageJson = JSON.parse(packageContent)
+  return packageJson.version
+}
+
+/**
+ * Update version.ts with the version from package.json
+ */
+function updateVersionFile(version: string, silent = false): void {
+  const versionPath = join(process.cwd(), 'core/utils/version.ts')
+  const versionContent = `/**
+ * FluxStack Framework Version
+ * Single source of truth for version number
+ * Auto-synced with package.json
+ */
+export const FLUXSTACK_VERSION = '${version}'
+`
+  writeFileSync(versionPath, versionContent)
+  if (!silent) {
+    console.log(`✅ Updated version.ts to v${version}`)
+  }
+}
+
+/**
+ * Main sync function
+ */
+function syncVersion(silent = false): void {
+  try {
+    const packageVersion = getPackageVersion()
+    updateVersionFile(packageVersion, silent)
+    if (!silent) {
+      console.log(`🔄 Version synchronized: v${packageVersion}`)
+    }
+  } catch (error) {
+    if (!silent) {
+      console.error('❌ Failed to sync version:', error)
+    }
+    process.exit(1)
+  }
+}
+
+// Run if called directly
+if (import.meta.main) {
+  syncVersion()
+}
+
 export { syncVersion, getPackageVersion }

package/core/utils/version.ts

@@ -3,4 +3,4 @@
  * Single source of truth for version number
  * Auto-synced with package.json
  */
-export const FLUXSTACK_VERSION = '1.10.1'
+export const FLUXSTACK_VERSION = '1.11.0'

package/create-fluxstack.ts

@@ -91,8 +91,8 @@ program
         'core',
         'app',
         'config',         // ✅ CRITICAL: Copy config folder with declarative configs
-        'plugins',     // TODO: Copy when crypto-auth plugin is complete
-        'ai-context',     // ✅ CRITICAL: Copy AI documentation for users
+        'plugins',        // TODO: Copy when crypto-auth plugin is complete
+        'LLMD',           // ✅ CRITICAL: LLM-optimized documentation for AI assistants
         'bun.lock',       // ✅ CRITICAL: Copy lockfile to maintain working versions
         'package.json',   // ✅ Copy real package.json from framework
         'tsconfig.json',
@@ -123,8 +123,8 @@ This folder is for your custom FluxStack plugins.
 ## 📖 Documentation
 
 For complete plugin development guide, see:
-- \`ai-context/development/plugins-guide.md\` - Full plugin documentation
-- \`ai-context/examples/\` - Plugin examples
+- \`LLMD/resources/plugins-external.md\` - Full plugin documentation
+- \`LLMD/reference/plugin-hooks.md\` - All available hooks
 
 ## 📦 Available CLI Commands
 
@@ -165,7 +165,7 @@ Plugins can intercept and modify requests using hooks:
 
 \`\`\`typescript
 // plugins/my-plugin/index.ts
-import type { FluxStack, PluginContext, RequestContext, ResponseContext } from "@/core/plugins/types"
+import type { FluxStack, PluginContext, RequestContext, ResponseContext } from "@core/plugins/types"
 
 export class MyPlugin implements FluxStack.Plugin {
   name = 'my-plugin'
@@ -418,7 +418,7 @@ FluxStack includes several built-in plugins that are ready to use:
 
 \`\`\`typescript
 // app/server/index.ts
-import { loggerPlugin, swaggerPlugin, staticPlugin } from "@/core/server"
+import { loggerPlugin, swaggerPlugin, staticPlugin } from "@core/server"
 
 // Add built-in plugins
 app.use(loggerPlugin)
@@ -458,7 +458,8 @@ app.use(authPlugin)
 
 ## 📖 Learn More
 
-- **Plugin Guide**: Check \`ai-context/development/plugins-guide.md\`
+- **LLM Documentation**: Check \`LLMD/INDEX.md\` for AI-optimized docs
+- **Plugin Guide**: Check \`LLMD/resources/plugins-external.md\`
 - **FluxStack Docs**: Visit the [FluxStack Repository](https://github.com/MarcosBrendonDePaula/FluxStack)
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-fluxstack",
-  "version": "1.10.1",
+  "version": "1.12.1",
   "description": "⚡ Revolutionary full-stack TypeScript framework with Declarative Config System, Elysia + React + Bun",
   "keywords": [
     "framework",
@@ -25,23 +25,21 @@
   },
   "scripts": {
     "dev": "bun run core/cli/index.ts dev",
-    "dev:frontend": "bun run core/cli/index.ts frontend",
-    "dev:backend": "bun run core/cli/index.ts backend",
-    "sync-version": "bun run core/utils/sync-version.ts",
+    "dev:frontend": "bun run core/cli/index.ts dev --frontend-only",
+    "dev:backend": "bun run core/cli/index.ts dev --backend-only",
     "build": "cross-env NODE_ENV=production bun run core/cli/index.ts build",
-    "build:frontend": "bun run core/cli/index.ts build:frontend",
-    "build:backend": "bun run core/cli/index.ts build:backend",
+    "build:frontend": "cross-env NODE_ENV=production bun run core/cli/index.ts build --frontend-only",
+    "build:backend": "cross-env NODE_ENV=production bun run core/cli/index.ts build --backend-only",
     "build:exe": "cross-env NODE_ENV=production && bun run core/cli/index.ts build && bun run core/cli/index.ts build:exe",
-    "start": "bun run core/cli/index.ts start",
-    "start:frontend": "bun run app/client/frontend-only.ts",
-    "start:backend": "bun run app/server/backend-only.ts",
+    "start": "NODE_ENV=production bun dist/index.js",
     "create": "bun run core/cli/index.ts create",
     "cli": "bun run core/cli/index.ts",
     "make:component": "bun run core/cli/index.ts make:component",
-    "make:live": "bun run core/cli/index.ts make:component",
+    "sync-version": "bun run core/utils/sync-version.ts",
     "test": "vitest",
     "test:ui": "vitest --ui",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "typecheck:api": "tsc --noEmit -p tsconfig.api-strict.json"
   },
   "devDependencies": {
     "@eslint/js": "^9.30.1",
@@ -68,7 +66,8 @@
     "tailwindcss": "^4.1.13",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.35.1",
-    "vite-plugin-node-polyfills": "^0.24.0",
+    "vite-plugin-checker": "^0.12.0",
+    "vite-tsconfig-paths": "^6.0.5",
     "vitest": "^3.2.4"
   },
   "dependencies": {
@@ -88,7 +87,7 @@
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "react-icons": "^5.5.0",
-    "react-router-dom": "^7.9.3",
+    "react-router": "^7.9.3",
     "uuid": "^13.0.0",
     "vite": "^7.1.7",
     "winston": "^3.18.3",