create-fluxstack 1.0.1 → 1.0.2

package/core/cli/index.ts

@@ -1,394 +0,0 @@
-#!/usr/bin/env bun
-
-import { FluxStackBuilder } from "../build"
-import { ProjectCreator } from "../templates/create-project"
-import { getConfigSync } from "../config"
-import { cliRegistry } from "./command-registry"
-import { pluginDiscovery } from "./plugin-discovery"
-
-const command = process.argv[2]
-const args = process.argv.slice(3)
-
-// Register built-in commands
-async function registerBuiltInCommands() {
-  // Help command
-  cliRegistry.register({
-    name: 'help',
-    description: 'Show help information',
-    category: 'General',
-    aliases: ['h', '--help', '-h'],
-    arguments: [
-      {
-        name: 'command',
-        description: 'Command to show help for',
-        required: false
-      }
-    ],
-    handler: async (args, options, context) => {
-      if (args[0]) {
-        const targetCommand = cliRegistry.get(args[0])
-        if (targetCommand) {
-          cliRegistry.showCommandHelp(targetCommand)
-        } else {
-          console.error(`❌ Unknown command: ${args[0]}`)
-          cliRegistry.showHelp()
-        }
-      } else {
-        cliRegistry.showHelp()
-      }
-    }
-  })
-
-  // Dev command
-  cliRegistry.register({
-    name: 'dev',
-    description: 'Start full-stack development server',
-    category: 'Development',
-    usage: 'flux dev [options]',
-    examples: [
-      'flux dev                    # Start development server',
-      'flux dev --port 4000        # Start on custom port'
-    ],
-    options: [
-      {
-        name: 'port',
-        short: 'p',
-        description: 'Port for backend server',
-        type: 'number',
-        default: 3000
-      },
-      {
-        name: 'frontend-port',
-        description: 'Port for frontend server',
-        type: 'number',
-        default: 5173
-      }
-    ],
-    handler: async (args, options, context) => {
-      console.log("⚡ FluxStack Full-Stack Development")
-      console.log(`🌐 Frontend: http://localhost:${options['frontend-port']}`)  
-      console.log(`🚀 Backend: http://localhost:${options.port}`)
-      console.log("🔄 Backend inicia Vite programaticamente - Zero órfãos!")
-      console.log("📦 Starting backend server...")
-      console.log()
-      
-      const { spawn } = await import("child_process")
-      const devProcess = spawn("bun", ["--watch", "app/server/index.ts"], {
-        stdio: "inherit",
-        cwd: process.cwd(),
-        env: {
-          ...process.env,
-          FRONTEND_PORT: options['frontend-port'].toString(),
-          BACKEND_PORT: options.port.toString()
-        }
-      })
-      
-      process.on('SIGINT', () => {
-        console.log('\n🛑 Shutting down gracefully...')
-        devProcess.kill('SIGTERM')
-        setTimeout(() => {
-          devProcess.kill('SIGKILL')
-          process.exit(0)
-        }, 5000)
-      })
-      
-      devProcess.on('close', (code) => {
-        process.exit(code || 0)
-      })
-      
-      // Keep the CLI running until the child process exits
-      return new Promise((resolve) => {
-        devProcess.on('exit', resolve)
-      })
-    }
-  })
-
-  // Build command
-  cliRegistry.register({
-    name: 'build',
-    description: 'Build the application for production',
-    category: 'Build',
-    usage: 'flux build [options]',
-    examples: [
-      'flux build                  # Build both frontend and backend',
-      'flux build --frontend-only  # Build only frontend',
-      'flux build --backend-only   # Build only backend'
-    ],
-    options: [
-      {
-        name: 'frontend-only',
-        description: 'Build only frontend',
-        type: 'boolean'
-      },
-      {
-        name: 'backend-only',
-        description: 'Build only backend',
-        type: 'boolean'
-      },
-      {
-        name: 'production',
-        description: 'Build for production (minified)',
-        type: 'boolean',
-        default: true
-      }
-    ],
-    handler: async (args, options, context) => {
-      const config = getConfigSync()
-      const builder = new FluxStackBuilder(config)
-      
-      if (options['frontend-only']) {
-        await builder.buildClient()
-      } else if (options['backend-only']) {
-        await builder.buildServer()
-      } else {
-        await builder.build()
-      }
-    }
-  })
-
-  // Create command  
-  cliRegistry.register({
-    name: 'create',
-    description: 'Create a new FluxStack project',
-    category: 'Project',
-    usage: 'flux create <project-name> [template]',
-    examples: [
-      'flux create my-app          # Create basic project',
-      'flux create my-app full     # Create full-featured project'
-    ],
-    arguments: [
-      {
-        name: 'project-name',
-        description: 'Name of the project to create',
-        required: true,
-        type: 'string'
-      },
-      {
-        name: 'template',
-        description: 'Project template to use',
-        required: false,
-        type: 'string',
-        default: 'basic',
-        choices: ['basic', 'full']
-      }
-    ],
-    handler: async (args, options, context) => {
-      const [projectName, template] = args
-      
-      if (!/^[a-zA-Z0-9-_]+$/.test(projectName)) {
-        console.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'
-        })
-        
-        await creator.create()
-      } catch (error) {
-        console.error("❌ Failed to create project:", error instanceof Error ? error.message : String(error))
-        throw error
-      }
-    }
-  })
-}
-
-// Main CLI logic
-async function main() {
-  // Register built-in commands
-  await registerBuiltInCommands()
-  
-  // Discover and register plugin commands
-  await pluginDiscovery.discoverAndRegisterCommands()
-  
-  // Handle special cases first
-  if (!command || command === 'help' || command === '--help' || command === '-h') {
-    await cliRegistry.execute('help', args)
-    return
-  }
-  
-  // Check if it's a registered command (built-in or plugin)
-  if (cliRegistry.has(command)) {
-    const exitCode = await cliRegistry.execute(command, args)
-    process.exit(exitCode)
-    return
-  }
-  
-  // Fallback to legacy command handling for backward compatibility
-  await handleLegacyCommands()
-}
-
-// Legacy command handling for backward compatibility
-async function handleLegacyCommands() {
-  switch (command) {
-  case "dev":
-    console.log("⚡ FluxStack Full-Stack Development")
-    console.log("🌐 Frontend: http://localhost:5173")  
-    console.log("🚀 Backend: http://localhost:3000")
-    console.log("🔄 Backend inicia Vite programaticamente - Zero órfãos!")
-    console.log("📦 Starting backend server...")
-    console.log()
-    
-    // Start only backend - it will start Vite programmatically
-    const { spawn } = await import("child_process")
-    const devProcess = spawn("bun", ["--watch", "app/server/index.ts"], {
-      stdio: "inherit",
-      cwd: process.cwd()
-    })
-    
-    // Handle process cleanup
-    process.on('SIGINT', () => {
-      console.log('\n🛑 Shutting down gracefully...')
-      devProcess.kill('SIGTERM')
-      setTimeout(() => {
-        devProcess.kill('SIGKILL')
-        process.exit(0)
-      }, 5000)
-    })
-    
-    devProcess.on('close', (code) => {
-      process.exit(code || 0)
-    })
-    
-    // Keep the CLI running until the child process exits
-    await new Promise((resolve) => {
-      devProcess.on('exit', resolve)
-    })
-    break
-
-  case "frontend":
-    console.log("🎨 FluxStack Frontend Development")
-    console.log("🌐 Frontend: http://localhost:5173")
-    console.log("📦 Starting Vite dev server...")
-    console.log()
-    
-    const { spawn: spawnFrontend } = await import("child_process")
-    const frontendProcess = spawnFrontend("vite", ["--config", "vite.config.ts"], {
-      stdio: "inherit",
-      cwd: process.cwd()
-    })
-    
-    process.on('SIGINT', () => {
-      frontendProcess.kill('SIGINT')
-      process.exit(0)
-    })
-    break
-
-  case "backend":
-    console.log("⚡ FluxStack Backend Development")
-    console.log("🚀 API Server: http://localhost:3001")
-    console.log("📦 Starting backend with hot reload...")
-    console.log()
-    
-    // Start backend with Bun watch for hot reload
-    const { spawn: spawnBackend } = await import("child_process")
-    const backendProcess = spawnBackend("bun", ["--watch", "app/server/backend-only.ts"], {
-      stdio: "inherit",
-      cwd: process.cwd()
-    })
-    
-    // Handle process cleanup
-    process.on('SIGINT', () => {
-      backendProcess.kill('SIGINT')
-      process.exit(0)
-    })
-    break
-
-  case "build":
-    const config = getConfigSync()
-    const builder = new FluxStackBuilder(config)
-    await builder.build()
-    break
-
-  case "build:frontend":
-    const frontendConfig = getConfigSync()
-    const frontendBuilder = new FluxStackBuilder(frontendConfig)
-    await frontendBuilder.buildClient()
-    break
-
-  case "build:backend":
-    const backendConfig = getConfigSync()
-    const backendBuilder = new FluxStackBuilder(backendConfig)
-    await backendBuilder.buildServer()
-    break
-
-  case "start":
-    console.log("🚀 Starting FluxStack production server...")
-    await import(process.cwd() + "/dist/index.js")
-    break
-
-  case "create":
-    const projectName = process.argv[3]
-    const template = process.argv[4]
-    
-    if (!projectName) {
-      console.error("❌ Please provide a project name: flux create my-app")
-      console.error()
-      console.error("Usage:")
-      console.error("  flux create <project-name> [template]")
-      console.error()
-      console.error("Templates:")
-      console.error("  basic    Basic FluxStack project (default)")
-      console.error("  full     Full-featured project with examples")
-      process.exit(1)
-    }
-
-    // Validate project name
-    if (!/^[a-zA-Z0-9-_]+$/.test(projectName)) {
-      console.error("❌ Project name can only contain letters, numbers, hyphens, and underscores")
-      process.exit(1)
-    }
-
-    try {
-      const creator = new ProjectCreator({
-        name: projectName,
-        template: template as 'basic' | 'full' || 'basic'
-      })
-      
-      await creator.create()
-    } catch (error) {
-      console.error("❌ Failed to create project:", error instanceof Error ? error.message : String(error))
-      process.exit(1)
-    }
-    break
-
-  default:
-    console.log(`
-⚡ FluxStack Framework CLI
-
-Usage:
-  flux dev             Start full-stack development server
-  flux frontend        Start frontend only (Vite dev server)
-  flux backend         Start backend only (API server)
-  flux build           Build both frontend and backend
-  flux build:frontend  Build frontend only
-  flux build:backend   Build backend only
-  flux start           Start production server
-  flux create          Create new project
-
-Examples:
-  flux dev                    # Full-stack development
-  flux frontend               # Frontend only (port 5173)
-  flux backend                # Backend only (port 3001)
-  flux create my-app          # Create new project
-
-Alternative commands:
-  fluxstack dev              # Same as flux dev
-  bun run dev:frontend       # Direct frontend start
-  bun run dev:backend        # Direct backend start
-
-Environment Variables:
-  FRONTEND_PORT=5173         # Frontend port
-  BACKEND_PORT=3001          # Backend port  
-  API_URL=http://localhost:3001  # API URL for frontend
-    `)
-  }
-}
-
-// Run main CLI
-main().catch(error => {
-  console.error('❌ CLI Error:', error instanceof Error ? error.message : String(error))
-  process.exit(1)
-})

package/core/cli/plugin-discovery.ts

@@ -1,200 +0,0 @@
-import { existsSync } from 'fs'
-import { join } from 'path'
-import type { Plugin } from '../plugins/types'
-import { cliRegistry } from './command-registry'
-import { logger } from '../utils/logger'
-
-export class CliPluginDiscovery {
-  private loadedPlugins = new Set<string>()
-
-  async discoverAndRegisterCommands(): Promise<void> {
-    // 1. Load built-in plugins with CLI commands
-    await this.loadBuiltInPlugins()
-    
-    // 2. Load external plugins from node_modules
-    await this.loadExternalPlugins()
-    
-    // 3. Load local plugins from project
-    await this.loadLocalPlugins()
-  }
-
-  private async loadBuiltInPlugins(): Promise<void> {
-    const builtInPluginsDir = join(__dirname, '../server/plugins')
-    
-    if (!existsSync(builtInPluginsDir)) {
-      return
-    }
-
-    try {
-      // For now, we'll manually list built-in plugins that might have CLI commands
-      const potentialPlugins = [
-        'logger',
-        'vite', 
-        'swagger',
-        'static',
-        'database'
-      ]
-
-      for (const pluginName of potentialPlugins) {
-        try {
-          const pluginPath = join(builtInPluginsDir, `${pluginName}.ts`)
-          if (existsSync(pluginPath)) {
-            const pluginModule = await import(pluginPath)
-            const plugin = pluginModule[`${pluginName}Plugin`] as Plugin
-            
-            if (plugin && plugin.commands) {
-              this.registerPluginCommands(plugin)
-            }
-          }
-        } catch (error) {
-          logger.debug(`Failed to load built-in plugin ${pluginName}:`, error)
-        }
-      }
-    } catch (error) {
-      logger.debug('Failed to scan built-in plugins:', error)
-    }
-  }
-
-  private async loadExternalPlugins(): Promise<void> {
-    const nodeModulesDir = join(process.cwd(), 'node_modules')
-    
-    if (!existsSync(nodeModulesDir)) {
-      return
-    }
-
-    try {
-      const fs = await import('fs')
-      const entries = fs.readdirSync(nodeModulesDir, { withFileTypes: true })
-      
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue
-        
-        // Check for FluxStack plugins (convention: fluxstack-plugin-*)
-        if (entry.name.startsWith('fluxstack-plugin-')) {
-          await this.loadExternalPlugin(entry.name)
-        }
-        
-        // Check for scoped packages (@fluxstack/plugin-*)
-        if (entry.name.startsWith('@fluxstack')) {
-          const scopedDir = join(nodeModulesDir, entry.name)
-          if (existsSync(scopedDir)) {
-            const scopedEntries = fs.readdirSync(scopedDir, { withFileTypes: true })
-            for (const scopedEntry of scopedEntries) {
-              if (scopedEntry.isDirectory() && scopedEntry.name.startsWith('plugin-')) {
-                await this.loadExternalPlugin(`${entry.name}/${scopedEntry.name}`)
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      logger.debug('Failed to scan external plugins:', error)
-    }
-  }
-
-  private async loadExternalPlugin(packageName: string): Promise<void> {
-    try {
-      const packagePath = join(process.cwd(), 'node_modules', packageName)
-      const packageJsonPath = join(packagePath, 'package.json')
-      
-      if (!existsSync(packageJsonPath)) {
-        return
-      }
-
-      const packageJson = JSON.parse(await import('fs').then(fs => 
-        fs.readFileSync(packageJsonPath, 'utf-8')
-      ))
-
-      // Check if this is a FluxStack plugin
-      if (packageJson.fluxstack?.plugin) {
-        const entryPoint = packageJson.main || 'index.js'
-        const pluginPath = join(packagePath, entryPoint)
-        
-        if (existsSync(pluginPath)) {
-          const pluginModule = await import(pluginPath)
-          const plugin = pluginModule.default || pluginModule[packageJson.fluxstack.plugin] as Plugin
-          
-          if (plugin && plugin.commands) {
-            this.registerPluginCommands(plugin)
-          }
-        }
-      }
-    } catch (error) {
-      logger.debug(`Failed to load external plugin ${packageName}:`, error)
-    }
-  }
-
-  private async loadLocalPlugins(): Promise<void> {
-    const localPluginsDir = join(process.cwd(), 'plugins')
-    
-    if (!existsSync(localPluginsDir)) {
-      return
-    }
-
-    try {
-      const fs = await import('fs')
-      const entries = fs.readdirSync(localPluginsDir, { withFileTypes: true })
-      
-      for (const entry of entries) {
-        if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.js'))) {
-          const pluginPath = join(localPluginsDir, entry.name)
-          
-          try {
-            const pluginModule = await import(pluginPath)
-            const plugin = pluginModule.default || Object.values(pluginModule).find(
-              (exp: any) => exp && typeof exp === 'object' && exp.name && exp.commands
-            ) as Plugin
-            
-            if (plugin && plugin.commands) {
-              this.registerPluginCommands(plugin)
-            }
-          } catch (error) {
-            logger.debug(`Failed to load local plugin ${entry.name}:`, error)
-          }
-        }
-      }
-    } catch (error) {
-      logger.debug('Failed to scan local plugins:', error)
-    }
-  }
-
-  private registerPluginCommands(plugin: Plugin): void {
-    if (!plugin.commands || this.loadedPlugins.has(plugin.name)) {
-      return
-    }
-
-    try {
-      for (const command of plugin.commands) {
-        // Prefix command with plugin name to avoid conflicts
-        const prefixedCommand = {
-          ...command,
-          name: `${plugin.name}:${command.name}`,
-          category: command.category || `Plugin: ${plugin.name}`,
-          aliases: command.aliases?.map(alias => `${plugin.name}:${alias}`)
-        }
-        
-        cliRegistry.register(prefixedCommand)
-        
-        // Also register without prefix if no conflict exists
-        if (!cliRegistry.has(command.name)) {
-          cliRegistry.register({
-            ...command,
-            category: command.category || `Plugin: ${plugin.name}`
-          })
-        }
-      }
-      
-      this.loadedPlugins.add(plugin.name)
-      logger.debug(`Registered ${plugin.commands.length} CLI commands from plugin: ${plugin.name}`)
-      
-    } catch (error) {
-      logger.error(`Failed to register CLI commands for plugin ${plugin.name}:`, error)
-    }
-  }
-
-  getLoadedPlugins(): string[] {
-    return Array.from(this.loadedPlugins)
-  }
-}
-
-export const pluginDiscovery = new CliPluginDiscovery()

package/core/client/standalone.ts

@@ -1,57 +0,0 @@
-// Standalone frontend development
-import { spawn } from "bun"
-import { join } from "path"
-
-export const startFrontendOnly = (config: any = {}) => {
-  const clientPath = config.clientPath || "app/client"
-  const port = config.vitePort || process.env.FRONTEND_PORT || 5173
-  const apiUrl = config.apiUrl || process.env.API_URL || 'http://localhost:3000/api'
-  
-  console.log(`⚛️  FluxStack Frontend`)
-  console.log(`🌐 http://${process.env.HOST || 'localhost'}:${port}`)
-  console.log(`🔗 API: ${apiUrl}`)
-  console.log()
-  
-  const viteProcess = spawn({
-    cmd: ["bun", "run", "dev"],
-    cwd: join(process.cwd(), clientPath),
-    stdout: "pipe",
-    stderr: "pipe",
-    env: {
-      ...process.env,
-      VITE_API_URL: apiUrl,
-      PORT: port.toString(),
-      HOST: process.env.HOST || 'localhost'
-    }
-  })
-
-  if (viteProcess.stdout) {
-    viteProcess.stdout.pipeTo(new WritableStream({
-      write(chunk) {
-        const output = new TextDecoder().decode(chunk)
-        // Filtrar mensagens desnecessárias do Vite
-        if (!output.includes("hmr update") && !output.includes("Local:")) {
-          console.log(output)
-        }
-      }
-    })).catch(() => {}) // Ignore pipe errors
-  }
-
-  if (viteProcess.stderr) {
-    viteProcess.stderr.pipeTo(new WritableStream({
-      write(chunk) {
-        const error = new TextDecoder().decode(chunk)
-        console.error(error)
-      }
-    })).catch(() => {}) // Ignore pipe errors
-  }
-
-  // Cleanup ao sair
-  process.on("SIGINT", () => {
-    console.log("\n🛑 Stopping frontend...")
-    viteProcess.kill()
-    process.exit(0)
-  })
-  
-  return viteProcess
-}