@hazeljs/cli 0.5.4 → 0.6.5

package/dist/commands/generate-module.d.ts

@@ -1,4 +1,16 @@
 import { Command } from 'commander';
 import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+/**
+ * Generate a complete feature module (5 files: module, controller, service, 2 DTOs).
+ *
+ * @param name    - Feature name (e.g. 'users') — determines file and class names
+ * @param options - Standard CLI options (--path, --dry-run, --json)
+ * @returns GenerateResult with paths of all created files
+ */
 export declare function runModule(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
+/**
+ * Register `hazel g module <name>` as a sub-command of the generate command.
+ *
+ * @param program - The Commander `generate` parent command
+ */
 export declare function generateModule(program: Command): void;

package/dist/commands/generate-module.js

@@ -64,6 +64,13 @@ const UPDATE_DTO_TEMPLATE = `export class Update{{className}}Dto {
   name?: string;
 }
 `;
+/**
+ * Generate a complete feature module (5 files: module, controller, service, 2 DTOs).
+ *
+ * @param name    - Feature name (e.g. 'users') — determines file and class names
+ * @param options - Standard CLI options (--path, --dry-run, --json)
+ * @returns GenerateResult with paths of all created files
+ */
 async function runModule(name, options) {
     const className = (0, generator_1.toPascalCase)(name);
     const fileName = (0, generator_1.toKebabCase)(name);
@@ -95,6 +102,11 @@ async function runModule(name, options) {
         nextSteps: [`Import ${className}Module in your app module.`],
     };
 }
+/**
+ * Register `hazel g module <name>` as a sub-command of the generate command.
+ *
+ * @param program - The Commander `generate` parent command
+ */
 function generateModule(program) {
     program
         .command('module <name>')

package/dist/commands/generate-simple.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Config-driven generator factory for simple single-file generators.
+ *
+ * Architecture:
+ *   1. Templates live in ./templates.ts (Mustache strings, one per generator type).
+ *   2. SIMPLE_GENERATORS is a declarative config array — each entry maps a CLI
+ *      sub-command to a template, suffix, alias, and optional next-steps.
+ *   3. registerSimpleGenerators() loops over the config and registers each one
+ *      as a Commander sub-command of `hazel generate`.
+ *   4. runSimpleGenerator() instantiates a lightweight SimpleGenerator (extends
+ *      the base Generator class) and renders the template with the user's name.
+ *
+ * To add a new single-file generator:
+ *   1. Add a Mustache template in ./templates.ts
+ *   2. Add a SimpleGeneratorConfig entry to SIMPLE_GENERATORS below
+ *   — that's it; the CLI, --list, --json, and --dry-run support are automatic.
+ */
+import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+/**
+ * Declarative configuration for a single-file generator.
+ *
+ * Each entry in SIMPLE_GENERATORS produces one CLI sub-command under
+ * `hazel generate` (e.g. `hazel g controller <name>`).
+ */
+export interface SimpleGeneratorConfig {
+    /** Generator type used as the sub-command name (e.g. 'controller', 'agent') */
+    type: string;
+    /** Human-readable description shown in `hazel g --list` and `--help` */
+    description: string;
+    /** File suffix before .ts — e.g. 'controller' produces `name.controller.ts` */
+    suffix: string;
+    /** Mustache template string (imported from ./templates.ts) */
+    template: string;
+    /** Short alias for the sub-command (e.g. 'c' for controller) */
+    alias?: string;
+    /** Default output directory if --path is not provided (defaults to 'src') */
+    defaultPath?: string;
+    /** Whether the generator requires a <name> argument (false for config, etc.) */
+    nameRequired: boolean;
+    /** Factory function returning extra Mustache data merged into the template context */
+    extraData?: (name: string) => Record<string, string>;
+    /** Post-generation instructions printed to the user (e.g. 'npm install ...') */
+    nextSteps?: string[];
+    /** Additional CLI options beyond the standard --path, --dry-run, --json */
+    extraOptions?: string[];
+}
+export declare const SIMPLE_GENERATORS: SimpleGeneratorConfig[];
+/**
+ * Execute a simple generator given its config, a name, and CLI options.
+ *
+ * @param config  - The SimpleGeneratorConfig entry (from SIMPLE_GENERATORS)
+ * @param name    - User-provided name (e.g. 'users') — used for file and class names
+ * @param options - Standard CLI options (--path, --dry-run, --json, --platform)
+ * @returns A GenerateResult with created file paths and optional next steps
+ */
+export declare function runSimpleGenerator(config: SimpleGeneratorConfig, name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
+/**
+ * Register all simple generators as sub-commands of the `hazel generate` command.
+ *
+ * Iterates over SIMPLE_GENERATORS and creates a Commander sub-command for each,
+ * wiring up aliases, options (--path, --dry-run, --json, plus any extraOptions),
+ * and the action handler that calls runSimpleGenerator.
+ *
+ * @param generateCommand - The Commander `generate` parent command to attach sub-commands to
+ */
+export declare function registerSimpleGenerators(generateCommand: Command): void;
+/**
+ * Look up a SimpleGeneratorConfig by its type name (e.g. 'controller', 'agent').
+ *
+ * @param type - The generator type to find
+ * @returns The matching config, or undefined if no simple generator matches
+ */
+export declare function findSimpleGenerator(type: string): SimpleGeneratorConfig | undefined;

package/dist/commands/generate-simple.js

@@ -0,0 +1,104 @@
+"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");
+const templates_1 = require("./templates");
+exports.SIMPLE_GENERATORS = [
+    { type: 'controller', description: 'REST controller', suffix: 'controller', template: templates_1.CONTROLLER_TEMPLATE, alias: 'c', nameRequired: true },
+    { type: 'service', description: 'Service class', suffix: 'service', template: templates_1.SERVICE_TEMPLATE, alias: 's', nameRequired: true },
+    { type: 'guard', description: 'Guard (e.g. auth)', suffix: 'guard', template: templates_1.GUARD_TEMPLATE, alias: 'gu', nameRequired: true },
+    { type: 'interceptor', description: 'Interceptor', suffix: 'interceptor', template: templates_1.INTERCEPTOR_TEMPLATE, alias: 'i', nameRequired: true },
+    { type: 'middleware', description: 'Middleware', suffix: 'middleware', template: templates_1.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: templates_1.PIPE_TEMPLATE, nameRequired: true },
+    { type: 'filter', description: 'Exception filter', suffix: 'filter', template: templates_1.EXCEPTION_FILTER_TEMPLATE, alias: 'f', nameRequired: true },
+    { type: 'repository', description: 'Prisma repository', suffix: 'repository', template: templates_1.REPOSITORY_TEMPLATE, alias: 'repo', nameRequired: true },
+    { type: 'gateway', description: 'WebSocket gateway', suffix: 'gateway', template: templates_1.WEBSOCKET_GATEWAY_TEMPLATE, alias: 'ws', nameRequired: true },
+    { type: 'ai-service', description: 'AI service with decorators', suffix: 'ai-service', template: templates_1.AI_SERVICE_TEMPLATE, alias: 'ai', nameRequired: true },
+    { type: 'agent', description: 'AI agent with @Agent and @Tool', suffix: 'agent', template: templates_1.AGENT_TEMPLATE, nameRequired: true, extraData: (name) => ({ description: `A ${name} agent` }) },
+    { type: 'cache', description: 'Cache service with decorators', suffix: 'cache', template: templates_1.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: templates_1.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: templates_1.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: templates_1.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: templates_1.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: templates_1.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;
+    }
+}
+/**
+ * Execute a simple generator given its config, a name, and CLI options.
+ *
+ * @param config  - The SimpleGeneratorConfig entry (from SIMPLE_GENERATORS)
+ * @param name    - User-provided name (e.g. 'users') — used for file and class names
+ * @param options - Standard CLI options (--path, --dry-run, --json, --platform)
+ * @returns A GenerateResult with created file paths and optional next steps
+ */
+async function runSimpleGenerator(config, name, options) {
+    // Handle serverless platform option
+    let template = config.template;
+    if (config.type === 'serverless' && options.platform === 'cloud-function') {
+        template = templates_1.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 `hazel generate` command.
+ *
+ * Iterates over SIMPLE_GENERATORS and creates a Commander sub-command for each,
+ * wiring up aliases, options (--path, --dry-run, --json, plus any extraOptions),
+ * and the action handler that calls runSimpleGenerator.
+ *
+ * @param generateCommand - The Commander `generate` parent command to attach sub-commands to
+ */
+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 });
+        });
+    }
+}
+/**
+ * Look up a SimpleGeneratorConfig by its type name (e.g. 'controller', 'agent').
+ *
+ * @param type - The generator type to find
+ * @returns The matching config, or undefined if no simple generator matches
+ */
+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/commands/info.d.ts

@@ -1,2 +1,14 @@
 import { Command } from 'commander';
+/**
+ * Register the `hazel info` command.
+ *
+ * Reads the current directory's package.json and displays:
+ * - Project name, version, description
+ * - Installed @hazeljs/* packages with versions
+ * - src/ directory listing
+ * - Node.js version, platform, architecture
+ * - Detected configuration files (tsconfig, .env, eslint, etc.)
+ *
+ * @param program - The root Commander program instance
+ */
 export declare function infoCommand(program: Command): void;

package/dist/commands/info.js

@@ -7,6 +7,18 @@ exports.infoCommand = infoCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Register the `hazel info` command.
+ *
+ * Reads the current directory's package.json and displays:
+ * - Project name, version, description
+ * - Installed @hazeljs/* packages with versions
+ * - src/ directory listing
+ * - Node.js version, platform, architecture
+ * - Detected configuration files (tsconfig, .env, eslint, etc.)
+ *
+ * @param program - The root Commander program instance
+ */
 function infoCommand(program) {
     program
         .command('info')

package/dist/commands/templates.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ */
+export declare const CONTROLLER_TEMPLATE = "import { Controller, Get, Post, Body, Param, Delete, Put } from '@hazeljs/core';\nimport { {{className}}Service } from './{{fileName}}.service';\nimport { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';\nimport { Update{{className}}Dto } from './dto/update-{{fileName}}.dto';\n\n@Controller('{{fileName}}')\nexport class {{className}}Controller {\n  constructor(private readonly {{camelName}}Service: {{className}}Service) {}\n\n  @Get()\n  findAll() {\n    return this.{{camelName}}Service.findAll();\n  }\n\n  @Get(':id')\n  findOne(@Param('id') id: string) {\n    return this.{{camelName}}Service.findOne(id);\n  }\n\n  @Post()\n  create(@Body(Create{{className}}Dto) createDto: Create{{className}}Dto) {\n    return this.{{camelName}}Service.create(createDto);\n  }\n\n  @Put(':id')\n  update(@Param('id') id: string, @Body(Update{{className}}Dto) updateDto: Update{{className}}Dto) {\n    return this.{{camelName}}Service.update(id, updateDto);\n  }\n\n  @Delete(':id')\n  remove(@Param('id') id: string) {\n    return this.{{camelName}}Service.remove(id);\n  }\n}\n";
+export declare const SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\n\n@Service()\nexport class {{className}}Service {\n  constructor() {}\n\n  async findAll() {\n    return [];\n  }\n\n  async findOne(id: string) {\n    return { id };\n  }\n\n  async create(createDto: any) {\n    return createDto;\n  }\n\n  async update(id: string, updateDto: any) {\n    return { id, ...updateDto };\n  }\n\n  async remove(id: string) {\n    return { id };\n  }\n}\n";
+export declare const GUARD_TEMPLATE = "import { Injectable, type CanActivate, type ExecutionContext } from '@hazeljs/core';\n\n@Injectable()\nexport class {{className}}Guard implements CanActivate {\n  canActivate(context: ExecutionContext): boolean {\n    const request = context.switchToHttp().getRequest();\n    // Add your guard logic here\n    return true;\n  }\n}\n";
+export declare const INTERCEPTOR_TEMPLATE = "import { Injectable, Interceptor, type ExecutionContext } from '@hazeljs/core';\n\n@Injectable()\nexport class {{className}}Interceptor implements Interceptor {\n  async intercept(context: ExecutionContext, next: () => Promise<unknown>): Promise<unknown> {\n    // Pre-processing logic here (before handler execution)\n    const result = await next();\n    // Post-processing logic here (after handler execution)\n    return result;\n  }\n}\n";
+export declare const MIDDLEWARE_TEMPLATE = "import { Injectable, type MiddlewareHandler, type Request, type Response, type NextFunction } from '@hazeljs/core';\n\n@Injectable()\nexport class {{className}}Middleware implements MiddlewareHandler {\n  use(req: Request, res: Response, next: NextFunction) {\n    // Add your middleware logic here\n    console.log(`[{{className}}Middleware] ${req.method} ${req.url}`);\n    \n    // Continue to next middleware\n    next();\n  }\n}\n";
+export declare const PIPE_TEMPLATE = "import { type PipeTransform, type RequestContext } from '@hazeljs/core';\n\nexport class {{className}}Pipe implements PipeTransform {\n  transform(value: unknown, context: RequestContext): unknown {\n    // Transform logic here\n    return value;\n  }\n}\n";
+export declare const EXCEPTION_FILTER_TEMPLATE = "import { Catch, type ExceptionFilter, type ArgumentsHost, HttpError, logger } from '@hazeljs/core';\n\n@Catch(HttpError)\nexport class {{className}}ExceptionFilter implements ExceptionFilter<HttpError> {\n  catch(exception: HttpError, host: ArgumentsHost): void {\n    const ctx = host.switchToHttp();\n    const response = ctx.getResponse();\n    const request = ctx.getRequest();\n\n    const status = exception.statusCode || 500;\n    const message = exception.message || 'Internal server error';\n\n    logger.error(`[${request.method}] ${request.url} - ${message} (${status})`);\n\n    response.status(status).json({\n      statusCode: status,\n      message,\n      timestamp: new Date().toISOString(),\n      path: request.url,\n    });\n  }\n}\n";
+export declare const REPOSITORY_TEMPLATE = "import { Repository, BaseRepository, PrismaService } from '@hazeljs/prisma';\n\n// @Repository implies @Injectable() \u2014 no need for both decorators\n@Repository({ model: '{{modelName}}' })\nexport class {{className}}Repository extends BaseRepository<any> {\n  constructor(prisma: PrismaService) {\n    super(prisma, '{{modelName}}');\n  }\n\n  // Add custom repository methods here\n  async findByName(name: string) {\n    return this.findMany({ where: { name } });\n  }\n}\n";
+export declare const WEBSOCKET_GATEWAY_TEMPLATE = "import { Realtime, OnConnect, OnDisconnect, OnMessage, Subscribe, Client, Data, WebSocketClient } from '@hazeljs/websocket';\n\n@Realtime('/{{fileName}}')\nexport class {{className}}Gateway {\n  @OnConnect()\n  handleConnection(@Client() client: WebSocketClient) {\n    console.log('Client connected:', client.id);\n  }\n\n  @OnDisconnect()\n  handleDisconnect(@Client() client: WebSocketClient) {\n    console.log('Client disconnected:', client.id);\n  }\n\n  @Subscribe('message')\n  @OnMessage('message')\n  handleMessage(@Client() client: WebSocketClient, @Data() data: unknown) {\n    console.log('Message received from', client.id, ':', data);\n    // Handle message logic here\n  }\n}\n";
+export declare const AI_SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { AIService, AIFunction, AIPrompt } from '@hazeljs/ai';\n\n@Service()\nexport class {{className}}AIService {\n  constructor(private readonly aiService: AIService) {}\n\n  @AIFunction({\n    provider: 'openai',\n    model: 'gpt-4',\n    streaming: false,\n  })\n  async {{camelName}}Task(@AIPrompt() prompt: string): Promise<unknown> {\n    const result = await this.aiService.complete({\n      provider: 'openai',\n      model: 'gpt-4',\n      messages: [{ role: 'user', content: prompt }],\n    });\n\n    return result;\n  }\n}\n";
+export declare const AGENT_TEMPLATE = "import { Agent, Tool } from '@hazeljs/agent';\n\n@Agent({\n  name: '{{fileName}}',\n  description: '{{description}}',\n  systemPrompt: 'You are a helpful {{className}} agent.',\n  enableMemory: true,\n  enableRAG: true,\n})\nexport class {{className}}Agent {\n  @Tool({\n    description: 'Example tool for {{fileName}}',\n    parameters: [\n      {\n        name: 'input',\n        type: 'string',\n        description: 'Input parameter',\n        required: true,\n      },\n    ],\n  })\n  async exampleTool(input: { input: string }): Promise<{ result: string }> {\n    // Implement your tool logic here\n    return {\n      result: `Processed: ${input.input}`,\n    };\n  }\n}\n";
+export declare const CACHE_SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { CacheService, Cacheable, CacheEvict } from '@hazeljs/cache';\n\n@Service()\nexport class {{className}}CacheService {\n  constructor(private readonly cacheService: CacheService) {}\n\n  @Cacheable({ key: '{{fileName}}:all', ttl: 60 })\n  async findAll() {\n    // This result will be cached for 60 seconds\n    return [];\n  }\n\n  @Cacheable({ key: '{{fileName}}:{{=<% %>=}}#{id}<%={{ }}=%>', ttl: 300 })\n  async findOne(id: string) {\n    // This result will be cached for 5 minutes\n    return { id };\n  }\n\n  @CacheEvict({ key: '{{fileName}}:all' })\n  async create(data: any) {\n    // Creating a new item evicts the list cache\n    return data;\n  }\n\n  async clearAll() {\n    await this.cacheService.clear();\n  }\n}\n";
+export declare const CRON_SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { Cron, CronExpression } from '@hazeljs/cron';\n\n@Service()\nexport class {{className}}CronService {\n  @Cron(CronExpression.EVERY_MINUTE)\n  handleEveryMinute() {\n    console.log('[{{className}}Cron] Running every minute...');\n    // Add your cron job logic here\n  }\n\n  @Cron('0 0 * * *')  // Every day at midnight\n  handleDaily() {\n    console.log('[{{className}}Cron] Running daily task...');\n    // Add your daily task logic here\n  }\n\n  @Cron(CronExpression.EVERY_HOUR)\n  handleHourly() {\n    console.log('[{{className}}Cron] Running hourly cleanup...');\n    // Add your hourly task logic here\n  }\n}\n";
+export declare const RAG_SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { RAGPipeline, MemoryVectorStore } from '@hazeljs/rag';\n\n@Service()\nexport class {{className}}RagService {\n  private pipeline: RAGPipeline;\n\n  constructor() {\n    // Initialize with a memory vector store (swap for Pinecone, Qdrant, etc. in production)\n    const vectorStore = new MemoryVectorStore();\n\n    this.pipeline = new RAGPipeline({\n      vectorStore,\n      topK: 5,\n    });\n  }\n\n  async addDocument(content: string, metadata?: Record<string, unknown>) {\n    // Add a document to the vector store for retrieval\n    await this.pipeline.addDocument({\n      content,\n      metadata: metadata || {},\n    });\n  }\n\n  async query(question: string) {\n    // Retrieve relevant documents and generate a response\n    const results = await this.pipeline.query(question);\n    return results;\n  }\n}\n";
+export declare const DISCOVERY_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { ServiceRegistry, DiscoveryClient } from '@hazeljs/discovery';\n\n@Service()\nexport class {{className}}DiscoveryService {\n  constructor(\n    private readonly registry: ServiceRegistry,\n    private readonly client: DiscoveryClient,\n  ) {}\n\n  async registerService() {\n    await this.registry.register({\n      name: '{{fileName}}-service',\n      host: 'localhost',\n      port: 3000,\n      metadata: {\n        version: '1.0.0',\n      },\n    });\n  }\n\n  async discoverService(serviceName: string) {\n    const instances = await this.client.getInstances(serviceName);\n    return instances;\n  }\n}\n";
+export declare const CONFIG_TEMPLATE = "import { HazelModule } from '@hazeljs/core';\nimport { ConfigModule, ConfigService } from '@hazeljs/config';\n\n// Import ConfigModule.forRoot() in your app module:\n//\n// @HazelModule({\n//   imports: [\n//     ConfigModule.forRoot({\n//       envFilePath: '.env',\n//     }),\n//   ],\n// })\n//\n// Then inject ConfigService wherever you need it:\n//\n// constructor(private readonly config: ConfigService) {}\n//\n// Usage:\n//   this.config.get('DATABASE_URL');\n//   this.config.get('PORT', '3000');  // with default value\n\nexport { ConfigModule, ConfigService };\n";
+export declare const SERVERLESS_LAMBDA_TEMPLATE = "import { createLambdaHandler } from '@hazeljs/serverless';\nimport { AppModule } from './app.module';\n\nexport const handler = createLambdaHandler(AppModule);\n";
+export declare const SERVERLESS_CLOUD_FUNCTION_TEMPLATE = "import { createCloudFunctionHandler } from '@hazeljs/serverless';\nimport { AppModule } from './app.module';\n\nexport const handler = createCloudFunctionHandler(AppModule);\n";