@hazeljs/cli 0.5.4 → 0.6.0

package/dist/commands/generate-simple.js

@@ -0,0 +1,448 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIMPLE_GENERATORS = void 0;
+exports.runSimpleGenerator = runSimpleGenerator;
+exports.registerSimpleGenerators = registerSimpleGenerators;
+exports.findSimpleGenerator = findSimpleGenerator;
+const generator_1 = require("../utils/generator");
+// ── Templates ────────────────────────────────────────────────────────────────
+const CONTROLLER_TEMPLATE = `import { Controller, Get, Post, Body, Param, Delete, Put } from '@hazeljs/core';
+import { {{className}}Service } from './{{fileName}}.service';
+import { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';
+import { Update{{className}}Dto } from './dto/update-{{fileName}}.dto';
+
+@Controller('{{fileName}}')
+export class {{className}}Controller {
+  constructor(private readonly {{camelName}}Service: {{className}}Service) {}
+
+  @Get()
+  findAll() {
+    return this.{{camelName}}Service.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.{{camelName}}Service.findOne(id);
+  }
+
+  @Post()
+  create(@Body(Create{{className}}Dto) createDto: Create{{className}}Dto) {
+    return this.{{camelName}}Service.create(createDto);
+  }
+
+  @Put(':id')
+  update(@Param('id') id: string, @Body(Update{{className}}Dto) updateDto: Update{{className}}Dto) {
+    return this.{{camelName}}Service.update(id, updateDto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.{{camelName}}Service.remove(id);
+  }
+}
+`;
+const SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+
+@Service()
+export class {{className}}Service {
+  constructor() {}
+
+  async findAll() {
+    return [];
+  }
+
+  async findOne(id: string) {
+    return { id };
+  }
+
+  async create(createDto: any) {
+    return createDto;
+  }
+
+  async update(id: string, updateDto: any) {
+    return { id, ...updateDto };
+  }
+
+  async remove(id: string) {
+    return { id };
+  }
+}
+`;
+const GUARD_TEMPLATE = `import { Injectable, type CanActivate, type ExecutionContext } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Guard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    // Add your guard logic here
+    return true;
+  }
+}
+`;
+const INTERCEPTOR_TEMPLATE = `import { Injectable, Interceptor, type ExecutionContext } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Interceptor implements Interceptor {
+  async intercept(context: ExecutionContext, next: () => Promise<unknown>): Promise<unknown> {
+    // Pre-processing logic here (before handler execution)
+    const result = await next();
+    // Post-processing logic here (after handler execution)
+    return result;
+  }
+}
+`;
+const MIDDLEWARE_TEMPLATE = `import { Injectable, type MiddlewareHandler, type Request, type Response, type NextFunction } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Middleware implements MiddlewareHandler {
+  use(req: Request, res: Response, next: NextFunction) {
+    // Add your middleware logic here
+    console.log(\`[{{className}}Middleware] \${req.method} \${req.url}\`);
+    
+    // Continue to next middleware
+    next();
+  }
+}
+`;
+const PIPE_TEMPLATE = `import { type PipeTransform, type RequestContext } from '@hazeljs/core';
+
+export class {{className}}Pipe implements PipeTransform {
+  transform(value: unknown, context: RequestContext): unknown {
+    // Transform logic here
+    return value;
+  }
+}
+`;
+const EXCEPTION_FILTER_TEMPLATE = `import { Catch, type ExceptionFilter, type ArgumentsHost, HttpError, logger } from '@hazeljs/core';
+
+@Catch(HttpError)
+export class {{className}}ExceptionFilter implements ExceptionFilter<HttpError> {
+  catch(exception: HttpError, host: ArgumentsHost): void {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+
+    const status = exception.statusCode || 500;
+    const message = exception.message || 'Internal server error';
+
+    logger.error(\`[\${request.method}] \${request.url} - \${message} (\${status})\`);
+
+    response.status(status).json({
+      statusCode: status,
+      message,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+    });
+  }
+}
+`;
+const REPOSITORY_TEMPLATE = `import { Repository, BaseRepository, PrismaService } from '@hazeljs/prisma';
+
+// @Repository implies @Injectable() — no need for both decorators
+@Repository({ model: '{{modelName}}' })
+export class {{className}}Repository extends BaseRepository<any> {
+  constructor(prisma: PrismaService) {
+    super(prisma, '{{modelName}}');
+  }
+
+  // Add custom repository methods here
+  async findByName(name: string) {
+    return this.findMany({ where: { name } });
+  }
+}
+`;
+const WEBSOCKET_GATEWAY_TEMPLATE = `import { Realtime, OnConnect, OnDisconnect, OnMessage, Subscribe, Client, Data, WebSocketClient } from '@hazeljs/websocket';
+
+@Realtime('/{{fileName}}')
+export class {{className}}Gateway {
+  @OnConnect()
+  handleConnection(@Client() client: WebSocketClient) {
+    console.log('Client connected:', client.id);
+  }
+
+  @OnDisconnect()
+  handleDisconnect(@Client() client: WebSocketClient) {
+    console.log('Client disconnected:', client.id);
+  }
+
+  @Subscribe('message')
+  @OnMessage('message')
+  handleMessage(@Client() client: WebSocketClient, @Data() data: unknown) {
+    console.log('Message received from', client.id, ':', data);
+    // Handle message logic here
+  }
+}
+`;
+const AI_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { AIService, AIFunction, AIPrompt } from '@hazeljs/ai';
+
+@Service()
+export class {{className}}AIService {
+  constructor(private readonly aiService: AIService) {}
+
+  @AIFunction({
+    provider: 'openai',
+    model: 'gpt-4',
+    streaming: false,
+  })
+  async {{camelName}}Task(@AIPrompt() prompt: string): Promise<unknown> {
+    const result = await this.aiService.complete({
+      provider: 'openai',
+      model: 'gpt-4',
+      messages: [{ role: 'user', content: prompt }],
+    });
+
+    return result;
+  }
+}
+`;
+const AGENT_TEMPLATE = `import { Agent, Tool } from '@hazeljs/agent';
+
+@Agent({
+  name: '{{fileName}}',
+  description: '{{description}}',
+  systemPrompt: 'You are a helpful {{className}} agent.',
+  enableMemory: true,
+  enableRAG: true,
+})
+export class {{className}}Agent {
+  @Tool({
+    description: 'Example tool for {{fileName}}',
+    parameters: [
+      {
+        name: 'input',
+        type: 'string',
+        description: 'Input parameter',
+        required: true,
+      },
+    ],
+  })
+  async exampleTool(input: { input: string }): Promise<{ result: string }> {
+    // Implement your tool logic here
+    return {
+      result: \`Processed: \${input.input}\`,
+    };
+  }
+}
+`;
+const CACHE_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { CacheService, Cacheable, CacheEvict } from '@hazeljs/cache';
+
+@Service()
+export class {{className}}CacheService {
+  constructor(private readonly cacheService: CacheService) {}
+
+  @Cacheable({ key: '{{fileName}}:all', ttl: 60 })
+  async findAll() {
+    // This result will be cached for 60 seconds
+    return [];
+  }
+
+  @Cacheable({ key: '{{fileName}}:{{=<% %>=}}#{id}<%={{ }}=%>', ttl: 300 })
+  async findOne(id: string) {
+    // This result will be cached for 5 minutes
+    return { id };
+  }
+
+  @CacheEvict({ key: '{{fileName}}:all' })
+  async create(data: any) {
+    // Creating a new item evicts the list cache
+    return data;
+  }
+
+  async clearAll() {
+    await this.cacheService.clear();
+  }
+}
+`;
+const CRON_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { Cron, CronExpression } from '@hazeljs/cron';
+
+@Service()
+export class {{className}}CronService {
+  @Cron(CronExpression.EVERY_MINUTE)
+  handleEveryMinute() {
+    console.log('[{{className}}Cron] Running every minute...');
+    // Add your cron job logic here
+  }
+
+  @Cron('0 0 * * *')  // Every day at midnight
+  handleDaily() {
+    console.log('[{{className}}Cron] Running daily task...');
+    // Add your daily task logic here
+  }
+
+  @Cron(CronExpression.EVERY_HOUR)
+  handleHourly() {
+    console.log('[{{className}}Cron] Running hourly cleanup...');
+    // Add your hourly task logic here
+  }
+}
+`;
+const RAG_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { RAGPipeline, MemoryVectorStore } from '@hazeljs/rag';
+
+@Service()
+export class {{className}}RagService {
+  private pipeline: RAGPipeline;
+
+  constructor() {
+    // Initialize with a memory vector store (swap for Pinecone, Qdrant, etc. in production)
+    const vectorStore = new MemoryVectorStore();
+
+    this.pipeline = new RAGPipeline({
+      vectorStore,
+      topK: 5,
+    });
+  }
+
+  async addDocument(content: string, metadata?: Record<string, unknown>) {
+    // Add a document to the vector store for retrieval
+    await this.pipeline.addDocument({
+      content,
+      metadata: metadata || {},
+    });
+  }
+
+  async query(question: string) {
+    // Retrieve relevant documents and generate a response
+    const results = await this.pipeline.query(question);
+    return results;
+  }
+}
+`;
+const DISCOVERY_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { ServiceRegistry, DiscoveryClient } from '@hazeljs/discovery';
+
+@Service()
+export class {{className}}DiscoveryService {
+  constructor(
+    private readonly registry: ServiceRegistry,
+    private readonly client: DiscoveryClient,
+  ) {}
+
+  async registerService() {
+    await this.registry.register({
+      name: '{{fileName}}-service',
+      host: 'localhost',
+      port: 3000,
+      metadata: {
+        version: '1.0.0',
+      },
+    });
+  }
+
+  async discoverService(serviceName: string) {
+    const instances = await this.client.getInstances(serviceName);
+    return instances;
+  }
+}
+`;
+const CONFIG_TEMPLATE = `import { HazelModule } from '@hazeljs/core';
+import { ConfigModule, ConfigService } from '@hazeljs/config';
+
+// Import ConfigModule.forRoot() in your app module:
+//
+// @HazelModule({
+//   imports: [
+//     ConfigModule.forRoot({
+//       envFilePath: '.env',
+//     }),
+//   ],
+// })
+//
+// Then inject ConfigService wherever you need it:
+//
+// constructor(private readonly config: ConfigService) {}
+//
+// Usage:
+//   this.config.get('DATABASE_URL');
+//   this.config.get('PORT', '3000');  // with default value
+
+export { ConfigModule, ConfigService };
+`;
+const SERVERLESS_LAMBDA_TEMPLATE = `import { createLambdaHandler } from '@hazeljs/serverless';
+import { AppModule } from './app.module';
+
+export const handler = createLambdaHandler(AppModule);
+`;
+const SERVERLESS_CLOUD_FUNCTION_TEMPLATE = `import { createCloudFunctionHandler } from '@hazeljs/serverless';
+import { AppModule } from './app.module';
+
+export const handler = createCloudFunctionHandler(AppModule);
+`;
+exports.SIMPLE_GENERATORS = [
+    { type: 'controller', description: 'REST controller', suffix: 'controller', template: CONTROLLER_TEMPLATE, alias: 'c', nameRequired: true },
+    { type: 'service', description: 'Service class', suffix: 'service', template: SERVICE_TEMPLATE, alias: 's', nameRequired: true },
+    { type: 'guard', description: 'Guard (e.g. auth)', suffix: 'guard', template: GUARD_TEMPLATE, alias: 'gu', nameRequired: true },
+    { type: 'interceptor', description: 'Interceptor', suffix: 'interceptor', template: INTERCEPTOR_TEMPLATE, alias: 'i', nameRequired: true },
+    { type: 'middleware', description: 'Middleware', suffix: 'middleware', template: MIDDLEWARE_TEMPLATE, alias: 'mw', defaultPath: 'src/middleware', nameRequired: true, nextSteps: ['Import the middleware in your module or apply it globally.'] },
+    { type: 'pipe', description: 'Validation/transform pipe', suffix: 'pipe', template: PIPE_TEMPLATE, nameRequired: true },
+    { type: 'filter', description: 'Exception filter', suffix: 'filter', template: EXCEPTION_FILTER_TEMPLATE, alias: 'f', nameRequired: true },
+    { type: 'repository', description: 'Prisma repository', suffix: 'repository', template: REPOSITORY_TEMPLATE, alias: 'repo', nameRequired: true },
+    { type: 'gateway', description: 'WebSocket gateway', suffix: 'gateway', template: WEBSOCKET_GATEWAY_TEMPLATE, alias: 'ws', nameRequired: true },
+    { type: 'ai-service', description: 'AI service with decorators', suffix: 'ai-service', template: AI_SERVICE_TEMPLATE, alias: 'ai', nameRequired: true },
+    { type: 'agent', description: 'AI agent with @Agent and @Tool', suffix: 'agent', template: AGENT_TEMPLATE, nameRequired: true, extraData: (name) => ({ description: `A ${name} agent` }) },
+    { type: 'cache', description: 'Cache service with decorators', suffix: 'cache', template: CACHE_SERVICE_TEMPLATE, nameRequired: true, nextSteps: ['npm install @hazeljs/cache', 'Add CacheModule to your module imports', 'Configure the cache strategy (memory, redis, or multi-tier)'] },
+    { type: 'cron', description: 'Cron/scheduled job service', suffix: 'cron', template: CRON_SERVICE_TEMPLATE, alias: 'job', nameRequired: true, nextSteps: ['npm install @hazeljs/cron', 'Add CronModule to your module imports', 'Register this service as a provider'] },
+    { type: 'rag', description: 'RAG (Retrieval-Augmented Generation) service', suffix: 'rag', template: RAG_SERVICE_TEMPLATE, nameRequired: true, nextSteps: ['npm install @hazeljs/rag', 'Register this service as a provider in your module', 'Configure your embedding provider and vector store'] },
+    { type: 'discovery', description: 'Service discovery setup', suffix: 'discovery', template: DISCOVERY_TEMPLATE, nameRequired: true, nextSteps: ['npm install @hazeljs/discovery', 'Register this service as a provider in your module', 'Configure your discovery backend (memory, redis, consul, or kubernetes)'] },
+    { type: 'config', description: 'Config module setup', suffix: 'config', template: CONFIG_TEMPLATE, nameRequired: false, nextSteps: ['npm install @hazeljs/config', 'Add ConfigModule.forRoot({ envFilePath: ".env" }) to your app module imports', 'Create a .env file in your project root'] },
+    { type: 'serverless', description: 'Serverless handler (Lambda or Cloud Function)', suffix: 'handler', template: SERVERLESS_LAMBDA_TEMPLATE, alias: 'sls', nameRequired: true, extraOptions: ['platform'] },
+];
+// ── Runner factory ───────────────────────────────────────────────────────────
+class SimpleGenerator extends generator_1.Generator {
+    constructor(_suffix, _template) {
+        super();
+        this._suffix = _suffix;
+        this._template = _template;
+        this.suffix = _suffix;
+    }
+    getDefaultTemplate() {
+        return this._template;
+    }
+}
+async function runSimpleGenerator(config, name, options) {
+    // Handle serverless platform option
+    let template = config.template;
+    if (config.type === 'serverless' && options.platform === 'cloud-function') {
+        template = SERVERLESS_CLOUD_FUNCTION_TEMPLATE;
+    }
+    const generator = new SimpleGenerator(config.suffix, template);
+    const effectiveName = config.nameRequired ? name : (name || 'app');
+    const result = await generator.generate({
+        name: effectiveName,
+        path: options.path || config.defaultPath,
+        dryRun: options.dryRun,
+        data: config.extraData ? config.extraData(effectiveName) : undefined,
+    });
+    if (config.nextSteps) {
+        result.nextSteps = [...(result.nextSteps ?? []), ...config.nextSteps];
+    }
+    return result;
+}
+/** Register all simple generators as sub-commands of the generate command */
+function registerSimpleGenerators(generateCommand) {
+    for (const config of exports.SIMPLE_GENERATORS) {
+        const cmdStr = config.nameRequired ? `${config.type} <name>` : config.type;
+        const cmd = generateCommand.command(cmdStr).description(config.description);
+        if (config.alias)
+            cmd.alias(config.alias);
+        cmd.option('-p, --path <path>', 'Path where the file should be generated', config.defaultPath);
+        cmd.option('--dry-run', 'Preview files without writing them');
+        cmd.option('--json', 'Output result as JSON');
+        if (config.extraOptions?.includes('platform')) {
+            cmd.option('--platform <platform>', 'Platform: lambda or cloud-function', 'lambda');
+        }
+        cmd.action(async (nameOrOptions, maybeOptions) => {
+            const name = typeof nameOrOptions === 'string' ? nameOrOptions : '';
+            const opts = typeof nameOrOptions === 'string' ? (maybeOptions || {}) : nameOrOptions;
+            const result = await runSimpleGenerator(config, name, opts);
+            (0, generator_1.printGenerateResult)(result, { json: opts.json });
+        });
+    }
+}
+/** Lookup a simple generator config by type */
+function findSimpleGenerator(type) {
+    return exports.SIMPLE_GENERATORS.find((g) => g.type === type);
+}

package/dist/commands/generate-simple.test.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const commander_1 = require("commander");
+const generate_simple_1 = require("./generate-simple");
+jest.mock('fs');
+describe('generate-simple', () => {
+    const mockFs = fs_1.default;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+    });
+    describe('SIMPLE_GENERATORS', () => {
+        it('should have at least 15 generator configs', () => {
+            expect(generate_simple_1.SIMPLE_GENERATORS.length).toBeGreaterThanOrEqual(15);
+        });
+        it('should have unique types', () => {
+            const types = generate_simple_1.SIMPLE_GENERATORS.map((g) => g.type);
+            expect(new Set(types).size).toBe(types.length);
+        });
+        it('should all have non-empty templates', () => {
+            for (const g of generate_simple_1.SIMPLE_GENERATORS) {
+                expect(g.template.length).toBeGreaterThan(0);
+            }
+        });
+    });
+    describe('findSimpleGenerator', () => {
+        it('finds by type', () => {
+            const config = (0, generate_simple_1.findSimpleGenerator)('controller');
+            expect(config).toBeDefined();
+            expect(config.type).toBe('controller');
+        });
+        it('returns undefined for unknown type', () => {
+            expect((0, generate_simple_1.findSimpleGenerator)('nope')).toBeUndefined();
+        });
+    });
+    describe('runSimpleGenerator', () => {
+        it('generates a controller file in dry-run', async () => {
+            const config = (0, generate_simple_1.findSimpleGenerator)('controller');
+            const result = await (0, generate_simple_1.runSimpleGenerator)(config, 'users', { dryRun: true });
+            expect(result.ok).toBe(true);
+            expect(result.dryRun).toBe(true);
+            expect(result.created[0]).toContain('users.controller.ts');
+        });
+        it('generates a guard file', async () => {
+            const config = (0, generate_simple_1.findSimpleGenerator)('guard');
+            const result = await (0, generate_simple_1.runSimpleGenerator)(config, 'auth', {});
+            expect(result.ok).toBe(true);
+            expect(result.created[0]).toContain('auth.guard.ts');
+            expect(mockFs.writeFileSync).toHaveBeenCalled();
+        });
+        it('generates agent with extra data', async () => {
+            const config = (0, generate_simple_1.findSimpleGenerator)('agent');
+            const result = await (0, generate_simple_1.runSimpleGenerator)(config, 'weather', { dryRun: true });
+            expect(result.ok).toBe(true);
+            expect(result.created[0]).toContain('weather.agent.ts');
+        });
+        it('appends nextSteps for cache generator', async () => {
+            const config = (0, generate_simple_1.findSimpleGenerator)('cache');
+            const result = await (0, generate_simple_1.runSimpleGenerator)(config, 'product', { dryRun: true });
+            expect(result.nextSteps).toBeDefined();
+            expect(result.nextSteps.some((s) => s.includes('@hazeljs/cache'))).toBe(true);
+        });
+        it('handles config generator (no name required)', async () => {
+            const config = (0, generate_simple_1.findSimpleGenerator)('config');
+            const result = await (0, generate_simple_1.runSimpleGenerator)(config, '', { dryRun: true });
+            expect(result.ok).toBe(true);
+            expect(result.created[0]).toContain('app.config.ts');
+        });
+        it('handles serverless with cloud-function platform', async () => {
+            const config = (0, generate_simple_1.findSimpleGenerator)('serverless');
+            const result = await (0, generate_simple_1.runSimpleGenerator)(config, 'api', { dryRun: true, platform: 'cloud-function' });
+            expect(result.ok).toBe(true);
+            expect(result.created[0]).toContain('api.handler.ts');
+        });
+        it('generates with custom path', async () => {
+            const config = (0, generate_simple_1.findSimpleGenerator)('service');
+            const result = await (0, generate_simple_1.runSimpleGenerator)(config, 'order', { path: 'src/orders', dryRun: true });
+            expect(result.ok).toBe(true);
+            expect(result.created[0]).toContain('src/orders');
+        });
+    });
+    describe('registerSimpleGenerators', () => {
+        it('registers all simple generators as sub-commands', () => {
+            const program = new commander_1.Command();
+            (0, generate_simple_1.registerSimpleGenerators)(program);
+            const commandNames = program.commands.map((c) => c.name());
+            expect(commandNames).toContain('controller');
+            expect(commandNames).toContain('guard');
+            expect(commandNames).toContain('agent');
+            expect(commandNames).toContain('serverless');
+            expect(commandNames).toContain('config');
+            expect(commandNames.length).toBe(generate_simple_1.SIMPLE_GENERATORS.length);
+        });
+    });
+});

package/dist/index.js

@@ -2,36 +2,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const generate_module_1 = require("./commands/generate-module");
 const generate_app_1 = require("./commands/generate-app");
-const generate_controller_1 = require("./commands/generate-controller");
-const generate_service_1 = require("./commands/generate-service");
+const generate_module_1 = require("./commands/generate-module");
 const generate_dto_1 = require("./commands/generate-dto");
-const generate_guard_1 = require("./commands/generate-guard");
-const generate_interceptor_1 = require("./commands/generate-interceptor");
-const generate_websocket_gateway_1 = require("./commands/generate-websocket-gateway");
-const generate_exception_filter_1 = require("./commands/generate-exception-filter");
-const generate_pipe_1 = require("./commands/generate-pipe");
-const generate_repository_1 = require("./commands/generate-repository");
-const generate_ai_service_1 = require("./commands/generate-ai-service");
-const generate_agent_1 = require("./commands/generate-agent");
-const generate_serverless_handler_1 = require("./commands/generate-serverless-handler");
 const generate_crud_1 = require("./commands/generate-crud");
-const generate_middleware_1 = require("./commands/generate-middleware");
 const generate_auth_1 = require("./commands/generate-auth");
-const generate_config_1 = require("./commands/generate-config");
-const generate_cache_1 = require("./commands/generate-cache");
-const generate_cron_1 = require("./commands/generate-cron");
-const generate_rag_1 = require("./commands/generate-rag");
-const generate_discovery_1 = require("./commands/generate-discovery");
-const generate_setup_1 = require("./commands/generate-setup");
+const generate_simple_1 = require("./commands/generate-simple");
 const generator_registry_1 = require("./utils/generator-registry");
 const info_1 = require("./commands/info");
 const add_1 = require("./commands/add");
-const build_1 = require("./commands/build");
-const pdf_to_audio_1 = require("./commands/pdf-to-audio");
-const start_1 = require("./commands/start");
-const test_1 = require("./commands/test");
 const program = new commander_1.Command();
 program
     .name('hazel')
@@ -42,10 +21,6 @@ program
 // Utility commands
 (0, info_1.infoCommand)(program);
 (0, add_1.addCommand)(program);
-(0, build_1.buildCommand)(program);
-(0, pdf_to_audio_1.pdfToAudioCommand)(program);
-(0, start_1.startCommand)(program);
-(0, test_1.testCommand)(program);
 // Generate command group (unified: hazel g <type> <name> [--path] [--dry-run] [--json], or hazel g --list)
 const generateCommand = program
     .command('generate')
@@ -77,28 +52,11 @@ const generateCommand = program
 });
 // Skeleton app
 (0, generate_app_1.registerGenerateApp)(generateCommand);
-// Core components
-(0, generate_controller_1.generateController)(generateCommand);
-(0, generate_service_1.generateService)(generateCommand);
+// Complex generators (multi-file output)
 (0, generate_module_1.generateModule)(generateCommand);
 (0, generate_dto_1.generateDto)(generateCommand);
-(0, generate_guard_1.generateGuard)(generateCommand);
-(0, generate_interceptor_1.generateInterceptor)(generateCommand);
-(0, generate_middleware_1.generateMiddleware)(generateCommand);
-// Advanced generators
 (0, generate_crud_1.generateCrud)(generateCommand);
 (0, generate_auth_1.generateAuth)(generateCommand);
-(0, generate_websocket_gateway_1.generateWebSocketGateway)(generateCommand);
-(0, generate_exception_filter_1.generateExceptionFilter)(generateCommand);
-(0, generate_pipe_1.generatePipe)(generateCommand);
-(0, generate_repository_1.generateRepository)(generateCommand);
-(0, generate_ai_service_1.generateAIService)(generateCommand);
-(0, generate_agent_1.generateAgent)(generateCommand);
-(0, generate_serverless_handler_1.generateServerlessHandler)(generateCommand);
-(0, generate_config_1.generateConfig)(generateCommand);
-(0, generate_cache_1.generateCache)(generateCommand);
-(0, generate_cron_1.generateCron)(generateCommand);
-(0, generate_rag_1.generateRag)(generateCommand);
-(0, generate_discovery_1.generateDiscovery)(generateCommand);
-(0, generate_setup_1.generateSetup)(generateCommand);
+// Simple generators (config-driven single-file output)
+(0, generate_simple_1.registerSimpleGenerators)(generateCommand);
 program.parse(process.argv);

package/dist/index.list.test.js

@@ -4,34 +4,20 @@ jest.mock('./commands/generate-app', () => ({
     generateApp: jest.fn(),
     registerGenerateApp: jest.fn(),
 }));
-jest.mock('./commands/generate-controller', () => ({ generateController: jest.fn() }));
-jest.mock('./commands/generate-service', () => ({ generateService: jest.fn() }));
 jest.mock('./commands/generate-module', () => ({ generateModule: jest.fn() }));
 jest.mock('./commands/generate-dto', () => ({ generateDto: jest.fn() }));
-jest.mock('./commands/generate-guard', () => ({ generateGuard: jest.fn() }));
-jest.mock('./commands/generate-interceptor', () => ({ generateInterceptor: jest.fn() }));
-jest.mock('./commands/generate-middleware', () => ({ generateMiddleware: jest.fn() }));
 jest.mock('./commands/generate-crud', () => ({ generateCrud: jest.fn() }));
 jest.mock('./commands/generate-auth', () => ({ generateAuth: jest.fn() }));
-jest.mock('./commands/generate-websocket-gateway', () => ({ generateWebSocketGateway: jest.fn() }));
-jest.mock('./commands/generate-exception-filter', () => ({ generateExceptionFilter: jest.fn() }));
-jest.mock('./commands/generate-pipe', () => ({ generatePipe: jest.fn() }));
-jest.mock('./commands/generate-repository', () => ({ generateRepository: jest.fn() }));
-jest.mock('./commands/generate-ai-service', () => ({ generateAIService: jest.fn() }));
-jest.mock('./commands/generate-agent', () => ({ generateAgent: jest.fn() }));
-jest.mock('./commands/generate-serverless-handler', () => ({ generateServerlessHandler: jest.fn() }));
-jest.mock('./commands/generate-config', () => ({ generateConfig: jest.fn() }));
-jest.mock('./commands/generate-cache', () => ({ generateCache: jest.fn() }));
-jest.mock('./commands/generate-cron', () => ({ generateCron: jest.fn() }));
-jest.mock('./commands/generate-rag', () => ({ generateRag: jest.fn() }));
-jest.mock('./commands/generate-discovery', () => ({ generateDiscovery: jest.fn() }));
-jest.mock('./commands/generate-setup', () => ({ generateSetup: jest.fn() }));
+jest.mock('./commands/generate-simple', () => ({
+    registerSimpleGenerators: jest.fn(),
+    SIMPLE_GENERATORS: [
+        { type: 'controller', description: 'REST controller', suffix: 'controller', template: '', nameRequired: true },
+    ],
+    findSimpleGenerator: jest.fn(),
+    runSimpleGenerator: jest.fn(),
+}));
 jest.mock('./commands/info', () => ({ infoCommand: jest.fn() }));
 jest.mock('./commands/add', () => ({ addCommand: jest.fn() }));
-jest.mock('./commands/build', () => ({ buildCommand: jest.fn() }));
-jest.mock('./commands/pdf-to-audio', () => ({ pdfToAudioCommand: jest.fn() }));
-jest.mock('./commands/start', () => ({ startCommand: jest.fn() }));
-jest.mock('./commands/test', () => ({ testCommand: jest.fn() }));
 describe('CLI generate --list', () => {
     let logSpy;
     beforeAll(() => {