create-fluxstack 1.0.13 → 1.0.14

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

@@ -0,0 +1,263 @@
+/**
+ * Comando CLI para gerenciar dependências de plugins
+ */
+
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { PluginDependencyManager } from '../../plugins/dependency-manager'
+import { PluginRegistry } from '../../plugins/registry'
+import { existsSync, readFileSync } from 'fs'
+import { join } from 'path'
+
+export function createPluginDepsCommand(): Command {
+  const command = new Command('plugin:deps')
+    .description('Gerenciar dependências de plugins')
+    .addCommand(createInstallCommand())
+    .addCommand(createListCommand())
+    .addCommand(createCheckCommand())
+    .addCommand(createCleanCommand())
+
+  return command
+}
+
+function createInstallCommand(): Command {
+  return new Command('install')
+    .description('Instalar dependências de todos os plugins')
+    .option('--dry-run', 'Mostrar o que seria instalado sem executar')
+    .option('--package-manager <pm>', 'Package manager a usar (npm, yarn, pnpm, bun)', 'bun')
+    .action(async (options) => {
+      console.log(chalk.blue('🔧 Instalando dependências de plugins...\n'))
+
+      try {
+        const dependencyManager = new PluginDependencyManager({
+          autoInstall: !options.dryRun,
+          packageManager: options.packageManager,
+          logger: createConsoleLogger()
+        })
+
+        const registry = new PluginRegistry({
+          logger: createConsoleLogger()
+        })
+
+        // Descobrir plugins
+        const results = await registry.discoverPlugins({
+          directories: ['plugins', 'core/plugins/built-in']
+        })
+
+        const successfulPlugins = results.filter(r => r.success)
+        console.log(chalk.green(`✅ Encontrados ${successfulPlugins.length} plugins\n`))
+
+        // Resolver dependências
+        const resolutions = []
+        for (const result of successfulPlugins) {
+          if (result.plugin) {
+            const pluginDir = findPluginDirectory(result.plugin.name)
+            if (pluginDir) {
+              const resolution = await dependencyManager.resolvePluginDependencies(pluginDir)
+              resolutions.push(resolution)
+            }
+          }
+        }
+
+        // Mostrar resumo
+        let totalDeps = 0
+        let totalConflicts = 0
+        
+        for (const resolution of resolutions) {
+          totalDeps += resolution.dependencies.length
+          totalConflicts += resolution.conflicts.length
+          
+          if (resolution.dependencies.length > 0) {
+            console.log(chalk.cyan(`📦 ${resolution.plugin}:`))
+            for (const dep of resolution.dependencies) {
+              const typeColor = dep.type === 'peerDependency' ? chalk.yellow : chalk.white
+              console.log(`  ${typeColor(dep.name)}@${dep.version} (${dep.type})`)
+            }
+            console.log()
+          }
+        }
+
+        if (totalConflicts > 0) {
+          console.log(chalk.yellow(`⚠️  ${totalConflicts} conflitos de dependências detectados\n`))
+        }
+
+        if (options.dryRun) {
+          console.log(chalk.blue(`📋 Dry run: ${totalDeps} dependências seriam instaladas`))
+        } else {
+          await dependencyManager.installPluginDependencies(resolutions)
+          console.log(chalk.green(`✅ ${totalDeps} dependências instaladas com sucesso!`))
+        }
+
+      } catch (error) {
+        console.error(chalk.red('❌ Erro ao instalar dependências:'), error)
+        process.exit(1)
+      }
+    })
+}
+
+function createListCommand(): Command {
+  return new Command('list')
+    .description('Listar dependências de plugins')
+    .option('--plugin <name>', 'Mostrar apenas dependências de um plugin específico')
+    .action(async (options) => {
+      console.log(chalk.blue('📋 Dependências de plugins:\n'))
+
+      try {
+        const registry = new PluginRegistry({
+          logger: createConsoleLogger()
+        })
+
+        const results = await registry.discoverPlugins({
+          directories: ['plugins', 'core/plugins/built-in']
+        })
+
+        const dependencyManager = new PluginDependencyManager({
+          autoInstall: false,
+          logger: createConsoleLogger()
+        })
+
+        for (const result of results) {
+          if (result.success && result.plugin) {
+            if (options.plugin && result.plugin.name !== options.plugin) {
+              continue
+            }
+
+            const pluginDir = findPluginDirectory(result.plugin.name)
+            if (pluginDir) {
+              const resolution = await dependencyManager.resolvePluginDependencies(pluginDir)
+              
+              console.log(chalk.cyan(`📦 ${resolution.plugin}`))
+              
+              if (resolution.dependencies.length === 0) {
+                console.log(chalk.gray('  Nenhuma dependência'))
+              } else {
+                for (const dep of resolution.dependencies) {
+                  const typeColor = dep.type === 'peerDependency' ? chalk.yellow : chalk.white
+                  const optional = dep.optional ? chalk.gray(' (opcional)') : ''
+                  console.log(`  ${typeColor(dep.name)}@${dep.version} (${dep.type})${optional}`)
+                }
+              }
+
+              if (resolution.conflicts.length > 0) {
+                console.log(chalk.red(`  ⚠️  ${resolution.conflicts.length} conflitos`))
+              }
+
+              console.log()
+            }
+          }
+        }
+
+      } catch (error) {
+        console.error(chalk.red('❌ Erro ao listar dependências:'), error)
+        process.exit(1)
+      }
+    })
+}
+
+function createCheckCommand(): Command {
+  return new Command('check')
+    .description('Verificar conflitos de dependências')
+    .action(async () => {
+      console.log(chalk.blue('🔍 Verificando conflitos de dependências...\n'))
+
+      try {
+        const registry = new PluginRegistry({
+          logger: createConsoleLogger()
+        })
+
+        const results = await registry.discoverPlugins({
+          directories: ['plugins', 'core/plugins/built-in']
+        })
+
+        const dependencyManager = new PluginDependencyManager({
+          autoInstall: false,
+          logger: createConsoleLogger()
+        })
+
+        const resolutions = []
+        for (const result of results) {
+          if (result.success && result.plugin) {
+            const pluginDir = findPluginDirectory(result.plugin.name)
+            if (pluginDir) {
+              const resolution = await dependencyManager.resolvePluginDependencies(pluginDir)
+              resolutions.push(resolution)
+            }
+          }
+        }
+
+        const allConflicts = resolutions.flatMap(r => r.conflicts)
+        
+        if (allConflicts.length === 0) {
+          console.log(chalk.green('✅ Nenhum conflito de dependências encontrado!'))
+        } else {
+          console.log(chalk.red(`❌ ${allConflicts.length} conflitos encontrados:\n`))
+          
+          for (const conflict of allConflicts) {
+            console.log(chalk.yellow(`⚠️  ${conflict.package}:`))
+            for (const version of conflict.versions) {
+              console.log(`  ${version.plugin}: ${version.version}`)
+            }
+            if (conflict.resolution) {
+              console.log(chalk.green(`  Resolução: ${conflict.resolution}`))
+            }
+            console.log()
+          }
+        }
+
+      } catch (error) {
+        console.error(chalk.red('❌ Erro ao verificar conflitos:'), error)
+        process.exit(1)
+      }
+    })
+}
+
+function createCleanCommand(): Command {
+  return new Command('clean')
+    .description('Limpar dependências não utilizadas')
+    .option('--dry-run', 'Mostrar o que seria removido sem executar')
+    .action(async (options) => {
+      console.log(chalk.blue('🧹 Limpando dependências não utilizadas...\n'))
+
+      if (options.dryRun) {
+        console.log(chalk.blue('📋 Dry run: mostrando dependências que seriam removidas'))
+      }
+
+      // TODO: Implementar lógica de limpeza
+      console.log(chalk.yellow('⚠️  Funcionalidade ainda não implementada'))
+    })
+}
+
+function findPluginDirectory(pluginName: string): string | null {
+  const possiblePaths = [
+    `plugins/${pluginName}`,
+    `core/plugins/built-in/${pluginName}`
+  ]
+
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      return path
+    }
+  }
+
+  return null
+}
+
+function createConsoleLogger() {
+  return {
+    debug: (msg: string, meta?: any) => {
+      if (process.env.DEBUG) {
+        console.log(chalk.gray(`[DEBUG] ${msg}`), meta || '')
+      }
+    },
+    info: (msg: string, meta?: any) => {
+      console.log(chalk.blue(`[INFO] ${msg}`), meta || '')
+    },
+    warn: (msg: string, meta?: any) => {
+      console.log(chalk.yellow(`[WARN] ${msg}`), meta || '')
+    },
+    error: (msg: string, meta?: any) => {
+      console.log(chalk.red(`[ERROR] ${msg}`), meta || '')
+    },
+    child: () => createConsoleLogger()
+  }
+}

package/core/cli/generators/README.md

@@ -0,0 +1,339 @@
+# FluxStack Code Generation System
+
+The FluxStack code generation system provides powerful tools to quickly scaffold common code patterns, reducing boilerplate and ensuring consistency across your project.
+
+## Quick Start
+
+### Basic Usage
+
+```bash
+# Generate a CRUD controller
+flux generate controller user
+
+# Generate a React component
+flux generate component UserCard
+
+# Generate a service with repository pattern
+flux generate service auth
+
+# Generate API routes
+flux generate route user
+```
+
+### Interactive Mode
+
+For a guided experience with prompts:
+
+```bash
+flux generate:interactive
+# or
+flux gi
+```
+
+## Available Generators
+
+### 1. Controller Generator
+
+Generates backend controllers with CRUD operations.
+
+**Templates:**
+- `crud` (default) - Full CRUD controller with validation and error handling
+- `minimal` - Basic controller structure with TODO placeholders
+
+**Usage:**
+```bash
+flux generate controller user
+flux generate controller product --template minimal
+flux generate controller order --path custom/path
+```
+
+**Generated Files:**
+- `app/server/controllers/{name}.controller.ts` - Main controller class
+- `app/server/schemas/{name}.schema.ts` - Validation schemas (CRUD template only)
+
+### 2. Service Generator
+
+Generates business logic services with repository pattern.
+
+**Templates:**
+- `crud` (default) - Full service with validation, logging, and repository
+- `repository` - Service with repository pattern
+- `minimal` - Basic service structure
+
+**Usage:**
+```bash
+flux generate service user
+flux generate service auth --template repository
+```
+
+**Generated Files:**
+- `app/server/services/{name}.service.ts` - Main service class
+- `app/server/repositories/{name}.repository.ts` - Repository class (CRUD/repository templates)
+
+### 3. Component Generator
+
+Generates React components with TypeScript.
+
+**Templates:**
+- `basic` (default) - Simple React component with props interface
+- `functional` - Component with hooks and state management
+- `page` - Page component with layout and SEO
+- `form` - Form component with validation
+- `full` - Complete component with tests and Storybook stories
+
+**Usage:**
+```bash
+flux generate component UserCard
+flux generate component ContactForm --template form
+flux generate component HomePage --template page
+```
+
+**Generated Files:**
+- `app/client/src/components/{Name}/{Name}.tsx` - Main component
+- `app/client/src/components/{Name}/{Name}.css` - Component styles
+- `app/client/src/components/{Name}/index.ts` - Export file
+- `app/client/src/components/{Name}/{Name}.test.tsx` - Tests (full template)
+- `app/client/src/components/{Name}/{Name}.stories.tsx` - Storybook stories (full template)
+
+### 4. Route Generator
+
+Generates API routes with Elysia.js.
+
+**Templates:**
+- `crud` (default) - Full REST API with validation and documentation
+- `auth` - Authentication routes (login, register, etc.)
+- `minimal` - Basic route structure
+
+**Usage:**
+```bash
+flux generate route user
+flux generate route auth --template auth
+```
+
+**Generated Files:**
+- `app/server/routes/{name}.routes.ts` - Route definitions
+- `app/server/routes/index.ts` - Route registry (if doesn't exist)
+- `app/server/middleware/{name}.middleware.ts` - Middleware (auth template)
+
+## Command Options
+
+### Global Options
+
+- `--path, -p` - Custom path for generated files
+- `--template, -t` - Template variant to use
+- `--force, -f` - Overwrite existing files
+- `--dry-run` - Preview what would be generated without creating files
+
+### Examples
+
+```bash
+# Preview generation without creating files
+flux generate controller user --dry-run
+
+# Force overwrite existing files
+flux generate component Button --force
+
+# Use custom path
+flux generate service auth --path app/custom/services
+
+# Use specific template
+flux generate component Modal --template functional
+```
+
+## Template Variables
+
+All templates have access to these variables:
+
+- `{{name}}` - Original name as provided
+- `{{Name}}` - Capitalized name
+- `{{NAME}}` - Uppercase name
+- `{{kebabName}}` - kebab-case name (user-profile)
+- `{{camelName}}` - camelCase name (userProfile)
+- `{{pascalName}}` - PascalCase name (UserProfile)
+- `{{snakeName}}` - snake_case name (user_profile)
+- `{{timestamp}}` - ISO timestamp
+- `{{date}}` - Current date
+- `{{year}}` - Current year
+- `{{author}}` - Author from config
+- `{{projectName}}` - Project name from config
+
+## Creating Custom Templates
+
+### Template Structure
+
+Templates are defined as objects with the following structure:
+
+```typescript
+interface Template {
+  name: string
+  description: string
+  files: TemplateFile[]
+  variables?: TemplateVariable[]
+  hooks?: {
+    beforeGenerate?: (context: GeneratorContext, options: GeneratorOptions) => Promise<void>
+    afterGenerate?: (context: GeneratorContext, options: GeneratorOptions, files: string[]) => Promise<void>
+  }
+}
+```
+
+### Example Custom Generator
+
+```typescript
+import { Generator } from "./index"
+import { GeneratorContext, GeneratorOptions, Template } from "./types"
+import { templateEngine } from "./template-engine"
+
+export class CustomGenerator implements Generator {
+  name = 'custom'
+  description = 'Generate custom code'
+
+  async generate(context: GeneratorContext, options: GeneratorOptions): Promise<void> {
+    const template = this.getTemplate()
+    const files = await templateEngine.processTemplate(template, context, options)
+    
+    if (!options.dryRun) {
+      await templateEngine.generateFiles(files)
+    }
+  }
+
+  private getTemplate(): Template {
+    return {
+      name: 'custom-template',
+      description: 'Custom template',
+      files: [
+        {
+          path: 'custom/{{kebabName}}.ts',
+          content: `// Generated {{pascalName}} at {{timestamp}}
+export class {{pascalName}} {
+  constructor() {
+    console.log('{{pascalName}} created')
+  }
+}
+`
+        }
+      ]
+    }
+  }
+}
+```
+
+## Best Practices
+
+### 1. Naming Conventions
+
+- Use PascalCase for components: `UserCard`, `ContactForm`
+- Use camelCase for services and controllers: `userService`, `authController`
+- Use kebab-case for routes: `user-profile`, `auth-routes`
+
+### 2. Template Selection
+
+- Use `crud` templates for full-featured implementations
+- Use `minimal` templates when you need basic structure
+- Use `full` templates when you need tests and documentation
+
+### 3. File Organization
+
+- Keep related files together (controller + service + routes)
+- Use consistent directory structure
+- Follow the generated file patterns
+
+### 4. Customization
+
+- Always review generated code before committing
+- Customize templates for your specific needs
+- Add validation and error handling as needed
+
+## Integration with Development Workflow
+
+### 1. Generate Related Files
+
+When generating a controller, also generate:
+```bash
+flux generate controller user
+flux generate service user
+flux generate route user
+```
+
+### 2. Update Imports
+
+After generating routes, update your main server file:
+```typescript
+import { userRoutes } from './routes/user.routes'
+
+app.use(userRoutes)
+```
+
+### 3. Add to Navigation
+
+After generating components, add them to your routing:
+```typescript
+import { UserPage } from './components/UserPage'
+
+// Add to your router
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Files already exist**
+   - Use `--force` to overwrite
+   - Use `--dry-run` to preview first
+
+2. **Permission errors**
+   - Check file permissions
+   - Ensure directory is writable
+
+3. **Template not found**
+   - Check available templates with `flux generate --help`
+   - Verify template name spelling
+
+4. **Invalid names**
+   - Names must start with a letter
+   - Only letters, numbers, hyphens, and underscores allowed
+
+### Getting Help
+
+```bash
+# General help
+flux help
+
+# Generator help
+flux help generate
+
+# Interactive mode
+flux generate:interactive
+```
+
+## Advanced Usage
+
+### Batch Generation
+
+Generate multiple related files:
+```bash
+# Generate full stack for a feature
+flux generate controller user
+flux generate service user  
+flux generate route user
+flux generate component UserList
+flux generate component UserForm
+```
+
+### Custom Paths
+
+Organize files in custom directories:
+```bash
+flux generate controller admin/user --path app/admin/controllers
+flux generate component admin/UserPanel --path app/admin/components
+```
+
+### Environment-Specific Templates
+
+Use different templates for different environments:
+```bash
+# Development with full features
+flux generate controller user --template crud
+
+# Production with minimal features  
+flux generate controller user --template minimal
+```