create-fluxstack 1.16.0 → 1.17.1

package/core/cli/generators/controller.ts

@@ -1,6 +1,7 @@
 import type { Generator } from "./index"
 import type { GeneratorContext, GeneratorOptions, Template } from "./types"
 import { templateEngine } from "./template-engine"
+import { buildLogger } from "@core/utils/build-logger"
 
 export class ControllerGenerator implements Generator {
   name = 'controller'
@@ -17,9 +18,9 @@ export class ControllerGenerator implements Generator {
     const files = await templateEngine.processTemplate(template, context, options)
     
     if (options.dryRun) {
-      console.log(`\n📋 Would generate controller '${options.name}':\n`)
+      buildLogger.info(`\n📋 Would generate controller '${options.name}':\n`)
       for (const file of files) {
-        console.log(`${file.action === 'create' ? '📄' : '✏️'} ${file.path}`)
+        buildLogger.info(`${file.action === 'create' ? '📄' : '✏️'} ${file.path}`)
       }
       return
     }
@@ -32,7 +33,7 @@ export class ControllerGenerator implements Generator {
       await template.hooks.afterGenerate(context, options, filePaths)
     }
 
-    console.log(`\n✅ Generated controller '${options.name}' with ${files.length} files`)
+    buildLogger.success(`Generated controller '${options.name}' with ${files.length} files`)
   }
 
   private getTemplate(templateName?: string): Template {
@@ -121,10 +122,10 @@ export class {{pascalName}}Controller {
     }
   }
 
-  async create({ body }: { body: any }) {
+  async create({ body }: { body: Record<string, unknown> }) {
     try {
       const {{camelName}} = await this.service.create(body)
-      
+
       return {
         success: true,
         data: {{camelName}},
@@ -138,7 +139,7 @@ export class {{pascalName}}Controller {
     }
   }
 
-  async update({ params, body }: { params: { id: string }, body: any }) {
+  async update({ params, body }: { params: { id: string }, body: Record<string, unknown> }) {
     try {
       const {{camelName}} = await this.service.update(params.id, body)
       
@@ -265,7 +266,7 @@ export class {{pascalName}}Controller {
     }
   }
 
-  async create({ body }: { body: any }) {
+  async create({ body }: { body: Record<string, unknown> }) {
     // TODO: Implement create logic
     return {
       success: true,
@@ -274,7 +275,7 @@ export class {{pascalName}}Controller {
     }
   }
 
-  async update({ params, body }: { params: { id: string }, body: any }) {
+  async update({ params, body }: { params: { id: string }, body: Record<string, unknown> }) {
     // TODO: Implement update logic
     return {
       success: true,

package/core/cli/generators/index.ts

@@ -1,147 +1,149 @@
-import type { CliCommand } from "../../plugins/types"
-import { ControllerGenerator } from "./controller"
-import { RouteGenerator } from "./route"
-import { ComponentGenerator } from "./component"
-import { ServiceGenerator } from "./service"
-import { PluginGenerator } from "./plugin"
-import type { GeneratorContext, GeneratorOptions } from "./types"
-
-export interface Generator {
-  name: string
-  description: string
-  generate(context: GeneratorContext, options: GeneratorOptions): Promise<void>
-}
-
-export class GeneratorRegistry {
-  private generators = new Map<string, Generator>()
-
-  constructor() {
-    this.registerBuiltInGenerators()
-  }
-
-  private registerBuiltInGenerators() {
-    this.register(new ControllerGenerator())
-    this.register(new RouteGenerator())
-    this.register(new ComponentGenerator())
-    this.register(new ServiceGenerator())
-    this.register(new PluginGenerator())
-  }
-
-  register(generator: Generator): void {
-    this.generators.set(generator.name, generator)
-  }
-
-  get(name: string): Generator | undefined {
-    return this.generators.get(name)
-  }
-
-  getAll(): Generator[] {
-    return Array.from(this.generators.values())
-  }
-
-  has(name: string): boolean {
-    return this.generators.has(name)
-  }
-}
-
-export const generatorRegistry = new GeneratorRegistry()
-
-// Export additional commands
-export { interactiveGenerateCommand } from "./interactive"
-
-// CLI command for code generation
-export const generateCommand: CliCommand = {
-  name: 'generate',
-  description: 'Generate code from templates',
-  usage: 'flux generate <type> <name> [options]',
-  aliases: ['g', 'gen'],
-  category: 'Development',
-  examples: [
-    'flux generate controller user',
-    'flux generate component UserCard',
-    'flux generate service auth',
-    'flux generate route api/users',
-    'flux generate plugin my-plugin'
-  ],
-  arguments: [
-    {
-      name: 'type',
-      description: 'Type of code to generate',
-      required: true,
-      type: 'string',
-      choices: ['controller', 'route', 'component', 'service', 'plugin']
-    },
-    {
-      name: 'name',
-      description: 'Name of the generated item',
-      required: true,
-      type: 'string'
-    }
-  ],
-  options: [
-    {
-      name: 'path',
-      short: 'p',
-      description: 'Custom path for generated files',
-      type: 'string'
-    },
-    {
-      name: 'template',
-      short: 't',
-      description: 'Template variant to use',
-      type: 'string'
-    },
-    {
-      name: 'force',
-      short: 'f',
-      description: 'Overwrite existing files',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'dry-run',
-      description: 'Show what would be generated without creating files',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  handler: async (args, options, context) => {
-    const [type, name] = args
-    
-    const generator = generatorRegistry.get(type)
-    if (!generator) {
-      console.error(`❌ Unknown generator type: ${type}`)
-      console.log('\nAvailable generators:')
-      for (const gen of generatorRegistry.getAll()) {
-        console.log(`  ${gen.name.padEnd(12)} ${gen.description}`)
-      }
-      return
-    }
-
-    const generatorContext: GeneratorContext = {
-      workingDir: context.workingDir,
-      config: context.config,
-      logger: context.logger,
-      utils: context.utils
-    }
-
-    const generatorOptions: GeneratorOptions = {
-      name,
-      path: options.path,
-      template: options.template,
-      force: options.force,
-      dryRun: options['dry-run']
-    }
-
-    try {
-      await generator.generate(generatorContext, generatorOptions)
-      
-      if (!options['dry-run']) {
-        console.log(`✅ Successfully generated ${type}: ${name}`)
-      }
-    } catch (error) {
-      console.error(`❌ Failed to generate ${type}:`, error instanceof Error ? error.message : String(error))
-      throw error
-    }
-  }
+import type { CliCommand } from "../../plugins/types"
+import { ControllerGenerator } from "./controller"
+import { RouteGenerator } from "./route"
+import { ComponentGenerator } from "./component"
+import { ServiceGenerator } from "./service"
+import { PluginGenerator } from "./plugin"
+import type { GeneratorContext, GeneratorOptions } from "./types"
+import { buildLogger } from "@core/utils/build-logger"
+
+export interface Generator {
+  name: string
+  description: string
+  generate(context: GeneratorContext, options: GeneratorOptions): Promise<void>
+}
+
+export class GeneratorRegistry {
+  private generators = new Map<string, Generator>()
+
+  constructor() {
+    this.registerBuiltInGenerators()
+  }
+
+  private registerBuiltInGenerators() {
+    this.register(new ControllerGenerator())
+    this.register(new RouteGenerator())
+    this.register(new ComponentGenerator())
+    this.register(new ServiceGenerator())
+    this.register(new PluginGenerator())
+  }
+
+  register(generator: Generator): void {
+    this.generators.set(generator.name, generator)
+  }
+
+  get(name: string): Generator | undefined {
+    return this.generators.get(name)
+  }
+
+  getAll(): Generator[] {
+    return Array.from(this.generators.values())
+  }
+
+  has(name: string): boolean {
+    return this.generators.has(name)
+  }
+}
+
+export const generatorRegistry = new GeneratorRegistry()
+
+// Export additional commands
+export { interactiveGenerateCommand } from "./interactive"
+
+// CLI command for code generation
+export const generateCommand: CliCommand = {
+  name: 'generate',
+  description: 'Generate code from templates',
+  usage: 'flux generate <type> <name> [options]',
+  aliases: ['g', 'gen'],
+  category: 'Development',
+  examples: [
+    'flux generate controller user',
+    'flux generate component UserCard',
+    'flux generate service auth',
+    'flux generate route api/users',
+    'flux generate plugin my-plugin'
+  ],
+  arguments: [
+    {
+      name: 'type',
+      description: 'Type of code to generate',
+      required: true,
+      type: 'string',
+      choices: ['controller', 'route', 'component', 'service', 'plugin']
+    },
+    {
+      name: 'name',
+      description: 'Name of the generated item',
+      required: true,
+      type: 'string'
+    }
+  ],
+  options: [
+    {
+      name: 'path',
+      short: 'p',
+      description: 'Custom path for generated files',
+      type: 'string'
+    },
+    {
+      name: 'template',
+      short: 't',
+      description: 'Template variant to use',
+      type: 'string'
+    },
+    {
+      name: 'force',
+      short: 'f',
+      description: 'Overwrite existing files',
+      type: 'boolean',
+      default: false
+    },
+    {
+      name: 'dry-run',
+      description: 'Show what would be generated without creating files',
+      type: 'boolean',
+      default: false
+    }
+  ],
+  handler: async (args, options, context) => {
+    const type = args[0] as string
+    const name = args[1] as string
+
+    const generator = generatorRegistry.get(type)
+    if (!generator) {
+      buildLogger.error(`Unknown generator type: ${type}`)
+      buildLogger.info('\nAvailable generators:')
+      for (const gen of generatorRegistry.getAll()) {
+        buildLogger.info(`  ${gen.name.padEnd(12)} ${gen.description}`)
+      }
+      return
+    }
+
+    const generatorContext: GeneratorContext = {
+      workingDir: context.workingDir,
+      config: context.config,
+      logger: context.logger,
+      utils: context.utils
+    }
+
+    const generatorOptions: GeneratorOptions = {
+      name,
+      path: options.path as string | undefined,
+      template: options.template as string | undefined,
+      force: options.force as boolean | undefined,
+      dryRun: options['dry-run'] as boolean | undefined
+    }
+
+    try {
+      await generator.generate(generatorContext, generatorOptions)
+      
+      if (!options['dry-run']) {
+        buildLogger.success(`Successfully generated ${type}: ${name}`)
+      }
+    } catch (error) {
+      buildLogger.error(`Failed to generate ${type}: ${error instanceof Error ? error.message : String(error)}`)
+      throw error
+    }
+  }
 }