create-fluxstack 1.4.0 → 1.4.1

package/core/cli/generators/index.ts

@@ -3,6 +3,7 @@ import { ControllerGenerator } from "./controller.js"
 import { RouteGenerator } from "./route.js"
 import { ComponentGenerator } from "./component.js"
 import { ServiceGenerator } from "./service.js"
+import { PluginGenerator } from "./plugin.js"
 import type { GeneratorContext, GeneratorOptions } from "./types.js"
 
 export interface Generator {
@@ -23,6 +24,7 @@ export class GeneratorRegistry {
     this.register(new RouteGenerator())
     this.register(new ComponentGenerator())
     this.register(new ServiceGenerator())
+    this.register(new PluginGenerator())
   }
 
   register(generator: Generator): void {
@@ -58,7 +60,8 @@ export const generateCommand: CliCommand = {
     'flux generate controller user',
     'flux generate component UserCard',
     'flux generate service auth',
-    'flux generate route api/users'
+    'flux generate route api/users',
+    'flux generate plugin my-plugin'
   ],
   arguments: [
     {
@@ -66,7 +69,7 @@ export const generateCommand: CliCommand = {
       description: 'Type of code to generate',
       required: true,
       type: 'string',
-      choices: ['controller', 'route', 'component', 'service']
+      choices: ['controller', 'route', 'component', 'service', 'plugin']
     },
     {
       name: 'name',

package/core/cli/generators/plugin.ts

@@ -0,0 +1,290 @@
+import type { Generator } from "./index.js"
+import type { GeneratorContext, GeneratorOptions, Template } from "./types.js"
+import { templateEngine } from "./template-engine.js"
+import { join } from "path"
+
+export class PluginGenerator implements Generator {
+    name = 'plugin'
+    description = 'Generate a new FluxStack plugin'
+
+    async generate(context: GeneratorContext, options: GeneratorOptions): Promise<void> {
+        const template = this.getTemplate(options.template)
+
+        if (template.hooks?.beforeGenerate) {
+            await template.hooks.beforeGenerate(context, options)
+        }
+
+        const files = await templateEngine.processTemplate(template, context, options)
+
+        if (options.dryRun) {
+            console.log(`\n📋 Would generate plugin '${options.name}':\n`)
+            for (const file of files) {
+                console.log(`${file.action === 'create' ? '📄' : '✏️'} ${file.path}`)
+            }
+            return
+        }
+
+        await templateEngine.generateFiles(files, options.dryRun)
+
+        if (template.hooks?.afterGenerate) {
+            const filePaths = files.map(f => f.path)
+            await template.hooks.afterGenerate(context, options, filePaths)
+        }
+
+        console.log(`\n✅ Generated plugin '${options.name}' with ${files.length} files`)
+        console.log(`\n📦 Next steps:`)
+        console.log(`   1. Edit plugins/${options.name}/plugin.json with your plugin metadata`)
+        console.log(`   2. Implement your plugin logic in plugins/${options.name}/index.ts`)
+        console.log(`   3. Add server-side code in plugins/${options.name}/server/ (optional)`)
+        console.log(`   4. Add client-side code in plugins/${options.name}/client/ (optional)`)
+        console.log(`   5. Run: bun run cli plugin:deps install`)
+    }
+
+    private getTemplate(templateName?: string): Template {
+        switch (templateName) {
+            case 'full':
+                return this.getFullTemplate()
+            case 'server':
+                return this.getServerOnlyTemplate()
+            case 'client':
+                return this.getClientOnlyTemplate()
+            default:
+                return this.getBasicTemplate()
+        }
+    }
+
+    private getBasicTemplate(): Template {
+        return {
+            name: 'basic-plugin',
+            description: 'Basic plugin template with essential files',
+            files: [
+                {
+                    path: 'plugins/{{name}}/plugin.json',
+                    content: `{
+  "name": "{{name}}",
+  "version": "1.0.0",
+  "description": "{{description}}",
+  "author": "Your Name",
+  "type": "fluxstack-plugin",
+  "main": "index.ts",
+  "dependencies": {},
+  "fluxstack": {
+    "minVersion": "1.4.0"
+  },
+  "hooks": {
+    "setup": true,
+    "onServerStart": false,
+    "onRequest": false,
+    "onResponse": false,
+    "onError": false
+  }
+}
+`
+                },
+                {
+                    path: 'plugins/{{name}}/index.ts',
+                    content: `import type { FluxStackPlugin, PluginContext } from '@/core/types/plugin'
+
+/**
+ * {{pascalName}} Plugin
+ * {{description}}
+ */
+export class {{pascalName}}Plugin implements FluxStackPlugin {
+  name = '{{name}}'
+  version = '1.0.0'
+
+  /**
+   * Setup hook - called when plugin is loaded
+   */
+  async setup(context: PluginContext): Promise<void> {
+    console.log(\`[{{name}}] Plugin initialized\`)
+
+    // Add your initialization logic here
+    // Example: Register middleware, setup database connections, etc.
+  }
+
+  /**
+   * Server start hook - called when server starts
+   */
+  async onServerStart?(context: PluginContext): Promise<void> {
+    console.log(\`[{{name}}] Server started\`)
+
+    // Add logic to run when server starts
+  }
+
+  /**
+   * Request hook - called on each request
+   */
+  async onRequest?(context: PluginContext, request: Request): Promise<void> {
+    // Add request processing logic
+  }
+
+  /**
+   * Response hook - called on each response
+   */
+  async onResponse?(context: PluginContext, response: Response): Promise<void> {
+    // Add response processing logic
+  }
+
+  /**
+   * Error hook - called when errors occur
+   */
+  async onError?(context: PluginContext, error: Error): Promise<void> {
+    console.error(\`[{{name}}] Error:\`, error)
+
+    // Add error handling logic
+  }
+}
+
+// Export plugin instance
+export default new {{pascalName}}Plugin()
+`
+                },
+                {
+                    path: 'plugins/{{name}}/README.md',
+                    content: `# {{pascalName}} Plugin
+
+{{description}}
+
+## Installation
+
+This plugin is already in your FluxStack project. To use it:
+
+1. Make sure the plugin is enabled in your configuration
+2. Install any additional dependencies (if needed):
+   \`\`\`bash
+   bun run cli plugin:deps install
+   \`\`\`
+
+## Usage
+
+\`\`\`typescript
+// The plugin is automatically loaded by FluxStack
+// Configure it in your app/server/index.ts if needed
+\`\`\`
+
+## Configuration
+
+Add configuration options here.
+
+## API
+
+Document your plugin's API here.
+
+## Hooks
+
+This plugin uses the following hooks:
+- \`setup\`: Initialize plugin resources
+- \`onServerStart\`: Run when server starts (optional)
+- \`onRequest\`: Process incoming requests (optional)
+- \`onResponse\`: Process outgoing responses (optional)
+- \`onError\`: Handle errors (optional)
+
+## Development
+
+To modify this plugin:
+
+1. Edit \`index.ts\` with your logic
+2. Update \`plugin.json\` with metadata
+3. Test with: \`bun run dev\`
+
+## License
+
+MIT
+`
+                }
+            ]
+        }
+    }
+
+    private getServerOnlyTemplate(): Template {
+        const basic = this.getBasicTemplate()
+        return {
+            ...basic,
+            name: 'server-plugin',
+            description: 'Plugin with server-side code',
+            files: [
+                ...basic.files,
+                {
+                    path: 'plugins/{{name}}/server/index.ts',
+                    content: `/**
+ * Server-side logic for {{pascalName}} plugin
+ */
+
+export class {{pascalName}}Service {
+  async initialize() {
+    console.log(\`[{{name}}] Server service initialized\`)
+  }
+
+  // Add your server-side methods here
+}
+
+export const {{camelName}}Service = new {{pascalName}}Service()
+`
+                }
+            ]
+        }
+    }
+
+    private getClientOnlyTemplate(): Template {
+        const basic = this.getBasicTemplate()
+        return {
+            ...basic,
+            name: 'client-plugin',
+            description: 'Plugin with client-side code',
+            files: [
+                ...basic.files,
+                {
+                    path: 'plugins/{{name}}/client/index.ts',
+                    content: `/**
+ * Client-side logic for {{pascalName}} plugin
+ */
+
+export class {{pascalName}}Client {
+  initialize() {
+    console.log(\`[{{name}}] Client initialized\`)
+  }
+
+  // Add your client-side methods here
+}
+
+export const {{camelName}}Client = new {{pascalName}}Client()
+`
+                }
+            ]
+        }
+    }
+
+    private getFullTemplate(): Template {
+        const basic = this.getBasicTemplate()
+        const server = this.getServerOnlyTemplate()
+        const client = this.getClientOnlyTemplate()
+
+        return {
+            ...basic,
+            name: 'full-plugin',
+            description: 'Complete plugin with server and client code',
+            files: [
+                ...basic.files,
+                ...server.files.slice(basic.files.length), // Add server files
+                ...client.files.slice(basic.files.length), // Add client files
+                {
+                    path: 'plugins/{{name}}/types.ts',
+                    content: `/**
+ * Type definitions for {{pascalName}} plugin
+ */
+
+export interface {{pascalName}}Config {
+  // Add your configuration types here
+  enabled: boolean
+}
+
+export interface {{pascalName}}Options {
+  // Add your options types here
+}
+`
+                }
+            ]
+        }
+    }
+}

package/core/cli/index.ts

@@ -224,7 +224,7 @@ Examples:
     }
   })
 
-  // Create command  
+  // Create command
   cliRegistry.register({
     name: 'create',
     description: 'Create a new FluxStack project',
@@ -252,7 +252,7 @@ Examples:
     ],
     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
@@ -263,7 +263,7 @@ Examples:
           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))
@@ -271,6 +271,91 @@ Examples:
       }
     }
   })
+
+  // Make:plugin command (shortcut for generate plugin)
+  cliRegistry.register({
+    name: 'make:plugin',
+    description: 'Create a new FluxStack plugin',
+    category: 'Plugins',
+    usage: 'flux make:plugin <name> [options]',
+    aliases: ['create:plugin'],
+    examples: [
+      'flux make:plugin my-plugin              # Create basic plugin',
+      'flux make:plugin my-plugin --template full    # Create full plugin with server/client',
+      'flux make:plugin auth --template server       # Create server-only plugin'
+    ],
+    arguments: [
+      {
+        name: 'name',
+        description: 'Name of the plugin to create',
+        required: true,
+        type: 'string'
+      }
+    ],
+    options: [
+      {
+        name: 'template',
+        short: 't',
+        description: 'Plugin template to use',
+        type: 'string',
+        choices: ['basic', 'full', 'server', 'client'],
+        default: 'basic'
+      },
+      {
+        name: 'description',
+        short: 'd',
+        description: 'Plugin description',
+        type: 'string',
+        default: 'A FluxStack plugin'
+      },
+      {
+        name: 'force',
+        short: 'f',
+        description: 'Overwrite existing plugin',
+        type: 'boolean',
+        default: false
+      }
+    ],
+    handler: async (args, options, context) => {
+      const [name] = args
+
+      if (!/^[a-zA-Z0-9-_]+$/.test(name)) {
+        console.error("❌ Plugin name can only contain letters, numbers, hyphens, and underscores")
+        return
+      }
+
+      // Use the plugin generator
+      const { generatorRegistry } = await import('./generators/index.js')
+      const pluginGenerator = generatorRegistry.get('plugin')
+
+      if (!pluginGenerator) {
+        console.error("❌ Plugin generator not found")
+        return
+      }
+
+      const generatorContext = {
+        workingDir: context.workingDir,
+        config: context.config,
+        logger: context.logger,
+        utils: context.utils
+      }
+
+      const generatorOptions = {
+        name,
+        template: options.template,
+        force: options.force,
+        dryRun: false,
+        description: options.description
+      }
+
+      try {
+        await pluginGenerator.generate(generatorContext, generatorOptions)
+      } catch (error) {
+        console.error("❌ Failed to create plugin:", error instanceof Error ? error.message : String(error))
+        throw error
+      }
+    }
+  })
 }
 
 // Main CLI logic

package/core/utils/version.ts

@@ -2,4 +2,4 @@
  * FluxStack Framework Version
  * Single source of truth for version number
  */
-export const FLUXSTACK_VERSION = '1.4.0'
+export const FLUXSTACK_VERSION = '1.4.1'

package/create-fluxstack.ts

@@ -5,16 +5,17 @@ import { resolve, join } from 'path'
 import { existsSync, mkdirSync, cpSync, writeFileSync, readFileSync } from 'fs'
 import chalk from 'chalk'
 import ora from 'ora'
+import { FLUXSTACK_VERSION } from './core/utils/version'
 
 const logo = `
-⚡ ███████ ██      ██    ██ ██   ██ ███████ ████████  █████   ██████ ██   ██ 
-   ██      ██      ██    ██  ██ ██  ██         ██    ██   ██ ██      ██  ██  
-   █████   ██      ██    ██   ███   ███████    ██    ███████ ██      █████   
-   ██      ██      ██    ██  ██ ██       ██    ██    ██   ██ ██      ██  ██  
-   ██      ███████  ██████  ██   ██ ███████    ██    ██   ██  ██████ ██   ██ 
+⚡ ███████ ██      ██    ██ ██   ██ ███████ ████████  █████   ██████ ██   ██
+   ██      ██      ██    ██  ██ ██  ██         ██    ██   ██ ██      ██  ██
+   █████   ██      ██    ██   ███   ███████    ██    ███████ ██      █████
+   ██      ██      ██    ██  ██ ██       ██    ██    ██   ██ ██      ██  ██
+   ██      ███████  ██████  ██   ██ ███████    ██    ██   ██  ██████ ██   ██
 
 ${chalk.cyan('💫 Powered by Bun - The Divine Runtime ⚡')}
-${chalk.gray('Creates FluxStack apps by copying the working framework')}
+${chalk.gray(`FluxStack v${FLUXSTACK_VERSION} - Creates full-stack TypeScript apps`)}
 `
 
 program
@@ -58,6 +59,7 @@ 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
         'bun.lock',       // ✅ CRITICAL: Copy lockfile to maintain working versions
         'package.json',   // ✅ Copy real package.json from framework
@@ -67,15 +69,122 @@ program
         'CLAUDE.md',      // ✅ Project instructions for AI assistants
         'README.md'
       ]
-      
+
       for (const file of filesToCopy) {
         const sourcePath = join(frameworkDir, file)
         const destPath = join(projectPath, file)
-        
+
         if (existsSync(sourcePath)) {
           cpSync(sourcePath, destPath, { recursive: true })
         }
       }
+
+      // Create empty plugins directory for user plugins
+      const pluginsDir = join(projectPath, 'plugins')
+      mkdirSync(pluginsDir, { recursive: true })
+
+      // Create a README in plugins folder
+      const pluginsReadme = `# Plugins
+
+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
+
+## 📦 Available CLI Commands
+
+\`\`\`bash
+# Create a new plugin
+bun run cli make:plugin my-plugin                    # Basic plugin
+bun run cli make:plugin my-plugin --template full    # Full plugin (server + client)
+bun run cli make:plugin my-plugin --template server  # Server-only plugin
+
+# Manage plugin dependencies
+bun run cli plugin:deps install    # Install plugin dependencies
+bun run cli plugin:deps list       # List plugin dependencies
+bun run cli plugin:deps check      # Check for conflicts
+bun run cli plugin:deps clean      # Clean unused dependencies
+\`\`\`
+
+## 🔌 Plugin Structure
+
+\`\`\`
+plugins/
+├── my-plugin/
+│   ├── plugin.json       # Plugin metadata (name, version, dependencies)
+│   ├── index.ts          # Plugin entry point (server-side hooks)
+│   ├── server/           # Server-side code (optional)
+│   └── client/           # Client-side code (optional)
+\`\`\`
+
+## ⚡ Quick Start
+
+1. Create your plugin folder: \`plugins/my-plugin/\`
+2. Create \`plugin.json\` with metadata
+3. Create \`index.ts\` with your plugin logic
+4. Use \`bun run cli plugin:deps install\` if you need extra dependencies
+
+## 🔌 Intercepting Requests
+
+Plugins can intercept and modify requests using hooks:
+
+\`\`\`typescript
+// plugins/my-plugin/index.ts
+import type { FluxStackPlugin, PluginContext } from '@/core/types/plugin'
+
+export class MyPlugin implements FluxStackPlugin {
+  name = 'my-plugin'
+  version = '1.0.0'
+
+  // Intercept every request
+  async onRequest(context: PluginContext, request: Request): Promise<void> {
+    // Example: Add custom headers
+    const url = new URL(request.url)
+    console.log(\`[\${this.name}] Request to: \${url.pathname}\`)
+
+    // Example: Validate authentication
+    const token = request.headers.get('Authorization')
+    if (!token && url.pathname.startsWith('/api/protected')) {
+      throw new Error('Unauthorized')
+    }
+  }
+
+  // Intercept every response
+  async onResponse(context: PluginContext, response: Response): Promise<void> {
+    console.log(\`[\${this.name}] Response status: \${response.status}\`)
+  }
+
+  // Handle errors
+  async onError(context: PluginContext, error: Error): Promise<void> {
+    console.error(\`[\${this.name}] Error:\`, error.message)
+    // Example: Send to error tracking service
+  }
+}
+\`\`\`
+
+## 📋 Available Hooks
+
+- **\`setup\`**: Initialize plugin resources (called once at startup)
+- **\`onServerStart\`**: Run when server starts
+- **\`onRequest\`**: Intercept incoming requests (before route handlers)
+- **\`onResponse\`**: Intercept outgoing responses (after route handlers)
+- **\`onError\`**: Handle errors globally
+
+## 💡 Common Use Cases
+
+- **Authentication**: Validate tokens in \`onRequest\`
+- **Logging**: Log requests/responses for analytics
+- **Rate Limiting**: Track request counts per IP
+- **CORS**: Add headers in \`onResponse\`
+- **Request Transformation**: Modify request body/headers
+- **Response Transformation**: Add custom headers, compress responses
+
+See the documentation for detailed examples and best practices.
+`
+      writeFileSync(join(pluginsDir, 'README.md'), pluginsReadme)
       
       // Generate .gitignore using template (instead of copying)
       const gitignoreContent = `# Dependencies

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-fluxstack",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "⚡ Revolutionary full-stack TypeScript framework with Declarative Config System, Elysia + React + Bun",
   "keywords": [
     "framework",