@hazeljs/cli 0.5.4 → 0.6.5

package/dist/commands/templates.js

@@ -0,0 +1,387 @@
+"use strict";
+/**
+ * Mustache templates for all simple (single-file) generators.
+ *
+ * Each template uses three standard variables provided by the Generator base class:
+ *   - {{className}}  — PascalCase name (e.g. "Users")
+ *   - {{fileName}}   — kebab-case name (e.g. "users")
+ *   - {{camelName}}  — camelCase name (e.g. "users")
+ *
+ * Some templates accept additional data via `extraData` in SimpleGeneratorConfig:
+ *   - AGENT_TEMPLATE       — {{description}}
+ *   - REPOSITORY_TEMPLATE  — {{modelName}} (defaults to fileName)
+ *
+ * Templates are imported by generate-simple.ts and referenced in the
+ * SIMPLE_GENERATORS config array. To add a new generator, create a template
+ * here and add a config entry in generate-simple.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVERLESS_CLOUD_FUNCTION_TEMPLATE = exports.SERVERLESS_LAMBDA_TEMPLATE = exports.CONFIG_TEMPLATE = exports.DISCOVERY_TEMPLATE = exports.RAG_SERVICE_TEMPLATE = exports.CRON_SERVICE_TEMPLATE = exports.CACHE_SERVICE_TEMPLATE = exports.AGENT_TEMPLATE = exports.AI_SERVICE_TEMPLATE = exports.WEBSOCKET_GATEWAY_TEMPLATE = exports.REPOSITORY_TEMPLATE = exports.EXCEPTION_FILTER_TEMPLATE = exports.PIPE_TEMPLATE = exports.MIDDLEWARE_TEMPLATE = exports.INTERCEPTOR_TEMPLATE = exports.GUARD_TEMPLATE = exports.SERVICE_TEMPLATE = exports.CONTROLLER_TEMPLATE = void 0;
+// ── Core framework generators ────────────────────────────────────────────────
+exports.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);
+  }
+}
+`;
+exports.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 };
+  }
+}
+`;
+exports.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;
+  }
+}
+`;
+exports.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;
+  }
+}
+`;
+exports.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();
+  }
+}
+`;
+exports.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;
+  }
+}
+`;
+exports.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,
+    });
+  }
+}
+`;
+// ── Package-specific generators ──────────────────────────────────────────────
+exports.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 } });
+  }
+}
+`;
+exports.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
+  }
+}
+`;
+exports.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;
+  }
+}
+`;
+exports.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}\`,
+    };
+  }
+}
+`;
+exports.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();
+  }
+}
+`;
+exports.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
+  }
+}
+`;
+exports.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;
+  }
+}
+`;
+exports.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;
+  }
+}
+`;
+exports.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 };
+`;
+// ── Serverless generators ────────────────────────────────────────────────────
+exports.SERVERLESS_LAMBDA_TEMPLATE = `import { createLambdaHandler } from '@hazeljs/serverless';
+import { AppModule } from './app.module';
+
+export const handler = createLambdaHandler(AppModule);
+`;
+exports.SERVERLESS_CLOUD_FUNCTION_TEMPLATE = `import { createCloudFunctionHandler } from '@hazeljs/serverless';
+import { AppModule } from './app.module';
+
+export const handler = createCloudFunctionHandler(AppModule);
+`;

package/dist/index.d.ts

@@ -1,2 +1,42 @@
 #!/usr/bin/env node
+/**
+ * HazelJS CLI — Entry point and command registration
+ *
+ * Architecture Overview:
+ * =====================
+ *
+ * index.ts                 — Entry point, registers all commands with Commander
+ *   ├─ commands/
+ * │   ├─ generate-app.ts   — `hazel new` (full scaffolding) and `hazel g app` (skeleton)
+ * │   ├─ add.ts            — `hazel add [pkg]` with --setup flag (replaces generate-setup)
+ * │   ├─ info.ts           — `hazel info` (project diagnostics)
+ * │   ├─ generate-simple.ts — Config-driven single-file generators (18 types)
+ * │   ├─ generate-module.ts — Multi-file module generator
+ * │   ├─ generate-dto.ts   — DTO pair generator
+ * │   ├─ generate-crud.ts  — Full CRUD resource generator
+ * │   ├─ generate-auth.ts  — Auth module with JWT guard
+ * │   └─ templates.ts      — Mustache templates for all simple generators
+ * └─ utils/
+ *     ├─ generator.ts      — Base Generator class, shared types, string utils
+ *     ├─ generator-registry.ts — Unified registry + runGenerator dispatcher
+ *     └─ packages-registry.ts  — All HazelJS package metadata (single source of truth)
+ *
+ * Command Structure:
+ * =================
+ *
+ * hazel new <app>           — Full interactive scaffolding (packages, git, install)
+ * hazel g app <name>        — Minimal skeleton app (no install/git)
+ * hazel g <type> <name>      — Unified generator for 23+ types (see --list)
+ * hazel add <pkg> [--setup]  — Install HazelJS packages + optional setup file
+ * hazel info                 — Project diagnostics
+ *
+ * Design Principles:
+ * ===================
+ *
+ * 1. Config-driven generators: SIMPLE_GENERATORS array defines 18+ single-file generators
+ * 2. Centralized package registry: HAZEL_PACKAGES drives `hazel add` and `hazel new -i`
+ * 3. Machine-readable output: --json and --list --list-json for LLM tool-use
+ * 4. Consistent CLI options: --path, --dry-run, --json available everywhere
+ * 5. Separation of concerns: Templates live separately from logic; registry is data-driven
+ */
 export {};

package/dist/index.js

@@ -1,51 +1,70 @@
 #!/usr/bin/env node
 "use strict";
+/**
+ * HazelJS CLI — Entry point and command registration
+ *
+ * Architecture Overview:
+ * =====================
+ *
+ * index.ts                 — Entry point, registers all commands with Commander
+ *   ├─ commands/
+ * │   ├─ generate-app.ts   — `hazel new` (full scaffolding) and `hazel g app` (skeleton)
+ * │   ├─ add.ts            — `hazel add [pkg]` with --setup flag (replaces generate-setup)
+ * │   ├─ info.ts           — `hazel info` (project diagnostics)
+ * │   ├─ generate-simple.ts — Config-driven single-file generators (18 types)
+ * │   ├─ generate-module.ts — Multi-file module generator
+ * │   ├─ generate-dto.ts   — DTO pair generator
+ * │   ├─ generate-crud.ts  — Full CRUD resource generator
+ * │   ├─ generate-auth.ts  — Auth module with JWT guard
+ * │   └─ templates.ts      — Mustache templates for all simple generators
+ * └─ utils/
+ *     ├─ generator.ts      — Base Generator class, shared types, string utils
+ *     ├─ generator-registry.ts — Unified registry + runGenerator dispatcher
+ *     └─ packages-registry.ts  — All HazelJS package metadata (single source of truth)
+ *
+ * Command Structure:
+ * =================
+ *
+ * hazel new <app>           — Full interactive scaffolding (packages, git, install)
+ * hazel g app <name>        — Minimal skeleton app (no install/git)
+ * hazel g <type> <name>      — Unified generator for 23+ types (see --list)
+ * hazel add <pkg> [--setup]  — Install HazelJS packages + optional setup file
+ * hazel info                 — Project diagnostics
+ *
+ * Design Principles:
+ * ===================
+ *
+ * 1. Config-driven generators: SIMPLE_GENERATORS array defines 18+ single-file generators
+ * 2. Centralized package registry: HAZEL_PACKAGES drives `hazel add` and `hazel new -i`
+ * 3. Machine-readable output: --json and --list --list-json for LLM tool-use
+ * 4. Consistent CLI options: --path, --dry-run, --json available everywhere
+ * 5. Separation of concerns: Templates live separately from logic; registry is data-driven
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const generate_module_1 = require("./commands/generate-module");
+const fs_1 = require("fs");
+const path_1 = require("path");
 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");
+// Read version from package.json to ensure consistency
+const packageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../package.json'), 'utf8'));
 const program = new commander_1.Command();
 program
     .name('hazel')
     .description('CLI for generating HazelJS components and applications')
-    .version('0.2.0');
+    .version(packageJson.version);
 // New app command
 (0, generate_app_1.generateApp)(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 +96,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(() => {