@hazeljs/cli 0.7.9 → 0.8.1

package/dist/commands/add.test.js

@@ -19,7 +19,7 @@ describe('addCommand', () => {
     });
     it('should register the add command', () => {
         (0, add_1.addCommand)(program);
-        const cmd = program.commands.find(c => c.name() === 'add');
+        const cmd = program.commands.find((c) => c.name() === 'add');
         expect(cmd).toBeDefined();
     });
     it('should install a known package', async () => {
@@ -39,8 +39,21 @@ describe('addCommand', () => {
         (0, add_1.addCommand)(program);
         // Test that all documented packages are available
         const expectedPackages = [
-            'ai', 'agent', 'auth', 'cache', 'config', 'cron',
-            'discovery', 'mcp', 'prompts', 'prisma', 'typeorm', 'rag', 'serverless', 'swagger', 'websocket'
+            'ai',
+            'agent',
+            'auth',
+            'cache',
+            'config',
+            'cron',
+            'discovery',
+            'mcp',
+            'prompts',
+            'prisma',
+            'typeorm',
+            'rag',
+            'serverless',
+            'swagger',
+            'websocket',
         ];
         for (const pkg of expectedPackages) {
             mockExecSync.mockClear();

package/dist/commands/eval.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+/**
+ * `hazel eval <dataset.json>` — load a golden dataset and run a placeholder pass-through runner.
+ * Wire your own runner in app code using @hazeljs/eval (see runGoldenDataset).
+ */
+export declare function registerEvalCommand(program: Command): void;

package/dist/commands/eval.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEvalCommand = registerEvalCommand;
+const path = __importStar(require("path"));
+/**
+ * `hazel eval <dataset.json>` — load a golden dataset and run a placeholder pass-through runner.
+ * Wire your own runner in app code using @hazeljs/eval (see runGoldenDataset).
+ */
+function registerEvalCommand(program) {
+    program
+        .command('eval')
+        .description('Run a golden dataset JSON through @hazeljs/eval (smoke check; supply your runner in code)')
+        .argument('<dataset>', 'Path to golden dataset JSON')
+        .option('--ci', 'Set exit code 1 when eval fails thresholds')
+        .action(async (dataset, opts) => {
+        try {
+            const { loadGoldenDatasetFromJson, runGoldenDataset, reportEvalForCi } = await Promise.resolve().then(() => __importStar(require('@hazeljs/eval')));
+            const ds = loadGoldenDatasetFromJson(path.resolve(process.cwd(), dataset));
+            const result = await runGoldenDataset(ds, async ({ input }) => ({
+                output: input,
+                toolCalls: [],
+                retrievedIds: [],
+            }), { minAverageScore: 0 });
+            reportEvalForCi(result, { exitOnFail: Boolean(opts.ci) });
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/generate-app.interactive-packages.test.js

@@ -68,7 +68,8 @@ describe('generateApp interactive package wiring', () => {
             const s = String(p);
             if (s.includes(path_1.default.join('@template')))
                 return true; // template exists
-            if (s.endsWith(path_1.default.join('.', 'my-app')) || s.endsWith(path_1.default.join(process.cwd(), '.', 'my-app')))
+            if (s.endsWith(path_1.default.join('.', 'my-app')) ||
+                s.endsWith(path_1.default.join(process.cwd(), '.', 'my-app')))
                 return false; // dest doesn't exist
             if (s.endsWith(path_1.default.join('my-app', 'package.json')))
                 return true; // updatePackageJson path

package/dist/commands/generate-app.js

@@ -151,9 +151,7 @@ function scaffoldPackageBoilerplate(destPath, packages) {
             moduleImports.push(meta.moduleExpression);
     }
     // Generate the enhanced app.module.ts
-    const importsSection = moduleImports.length > 0
-        ? `\n  imports: [\n    ${moduleImports.join(',\n    ')},\n  ],`
-        : '';
+    const importsSection = moduleImports.length > 0 ? `\n  imports: [\n    ${moduleImports.join(',\n    ')},\n  ],` : '';
     const appModule = `${imports.join('\n')}
 
 @HazelModule({${importsSection}
@@ -235,7 +233,10 @@ function generateApp(program) {
                         type: 'checkbox',
                         name: 'packages',
                         message: 'Select additional HazelJS packages to install:',
-                        choices: packages_registry_1.HAZEL_PACKAGES.map((p) => ({ name: p.label, value: p.npm })),
+                        choices: packages_registry_1.HAZEL_PACKAGES.map((p) => ({
+                            name: p.label,
+                            value: p.npm,
+                        })),
                     },
                 ]);
                 projectConfig = { ...projectConfig, ...answers };

package/dist/commands/generate-app.new-command.test.js

@@ -57,7 +57,9 @@ describe('generateApp (hazel new)', () => {
         });
         const program = new commander_1.Command();
         (0, generate_app_1.generateApp)(program);
-        await program.parseAsync(['new', 'my-app', '--dest', '.', '--skip-install', '--skip-git'], { from: 'user' });
+        await program.parseAsync(['new', 'my-app', '--dest', '.', '--skip-install', '--skip-git'], {
+            from: 'user',
+        });
         expect(mockFs.mkdirSync).toHaveBeenCalled();
         expect(mockFs.writeFileSync).toHaveBeenCalled();
         expect(mockExec).not.toHaveBeenCalled(); // skipped install + git

package/dist/commands/generate-app.skeleton.test.js

@@ -35,7 +35,8 @@ describe('runApp (skeleton app)', () => {
         // destPath doesn't exist; templatePath also doesn't exist -> fallback basic structure
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
-            if (s.endsWith(path_1.default.join('.', 'my-app')) || s.endsWith(path_1.default.join(process.cwd(), '.', 'my-app')))
+            if (s.endsWith(path_1.default.join('.', 'my-app')) ||
+                s.endsWith(path_1.default.join(process.cwd(), '.', 'my-app')))
                 return false;
             if (s.includes('@template'))
                 return false;

package/dist/commands/generate-auth.js

@@ -22,9 +22,13 @@ export class AuthModule {}
 `;
 const AUTH_SERVICE_TEMPLATE = `import { Service, BadRequestError, UnauthorizedError } from '@hazeljs/core';
 import { JwtService } from '@hazeljs/auth';
+import * as bcrypt from 'bcryptjs';
 import { RegisterDto } from './dto/register.dto';
 import { LoginDto } from './dto/login.dto';
 
+/** Replace with your DB / Prisma / TypeORM repository */
+const users = new Map<string, { id: string; name: string; email: string; passwordHash: string }>();
+
 @Service()
 export class AuthService {
   constructor(
@@ -32,38 +36,52 @@ export class AuthService {
   ) {}
 
   async register(registerDto: RegisterDto) {
-    // TODO: Check if user already exists in your database
-
-    // TODO: Hash the password (e.g., with bcryptjs)
-    // const hashedPassword = await bcrypt.hash(registerDto.password, 10);
+    const email = registerDto.email.toLowerCase();
+    if (users.has(email)) {
+      throw new BadRequestError('User already exists');
+    }
 
-    // TODO: Create the user in your database
+    const passwordHash = await bcrypt.hash(registerDto.password, 10);
     const user = {
       id: Date.now().toString(),
       name: registerDto.name,
-      email: registerDto.email,
+      email,
+      passwordHash,
     };
+    users.set(email, user);
 
     const accessToken = this.jwtService.sign({
       sub: user.id,
       email: user.email,
     });
 
-    return { user, accessToken };
+    return {
+      user: { id: user.id, name: user.name, email: user.email },
+      accessToken,
+    };
   }
 
   async login(loginDto: LoginDto) {
-    // TODO: Find user by email in your database
-    // TODO: Verify password with bcrypt.compare()
+    const email = loginDto.email.toLowerCase();
+    const row = users.get(email);
+    if (!row) {
+      throw new UnauthorizedError('Invalid credentials');
+    }
 
-    const user = { id: '1', name: 'User', email: loginDto.email };
+    const ok = await bcrypt.compare(loginDto.password, row.passwordHash);
+    if (!ok) {
+      throw new UnauthorizedError('Invalid credentials');
+    }
 
     const accessToken = this.jwtService.sign({
-      sub: user.id,
-      email: user.email,
+      sub: row.id,
+      email: row.email,
     });
 
-    return { user, accessToken };
+    return {
+      user: { id: row.id, name: row.name, email: row.email },
+      accessToken,
+    };
   }
 }
 `;

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

@@ -24,19 +24,18 @@ describe('generateAuth', () => {
     it('should generate all auth files', async () => {
         (0, generate_auth_1.generateAuth)(program);
         await program.parseAsync(['node', 'test', 'auth']);
-        const writtenFiles = mockFs.writeFileSync.mock.calls.map(call => call[0]);
-        expect(writtenFiles.some(f => f.includes('auth.module.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('auth.service.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('auth.controller.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('jwt-auth.guard.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('register.dto.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('login.dto.ts'))).toBe(true);
+        const writtenFiles = mockFs.writeFileSync.mock.calls.map((call) => call[0]);
+        expect(writtenFiles.some((f) => f.includes('auth.module.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('auth.service.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('auth.controller.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('jwt-auth.guard.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('register.dto.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('login.dto.ts'))).toBe(true);
     });
     it('should use @hazeljs/auth imports in guard', async () => {
         (0, generate_auth_1.generateAuth)(program);
         await program.parseAsync(['node', 'test', 'auth']);
-        const guardContent = mockFs.writeFileSync.mock.calls
-            .find(call => call[0].includes('jwt-auth.guard'))?.[1];
+        const guardContent = mockFs.writeFileSync.mock.calls.find((call) => call[0].includes('jwt-auth.guard'))?.[1];
         expect(guardContent).toContain("from '@hazeljs/auth'");
         expect(guardContent).toContain('JwtService');
     });

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

@@ -24,17 +24,16 @@ describe('generateCrud', () => {
     it('should generate all CRUD files', async () => {
         (0, generate_crud_1.generateCrud)(program);
         await program.parseAsync(['node', 'test', 'crud', 'product']);
-        const writtenFiles = mockFs.writeFileSync.mock.calls.map(call => call[0]);
-        expect(writtenFiles.some(f => f.includes('product.controller.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('product.service.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('product.dto.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('product.module.ts'))).toBe(true);
+        const writtenFiles = mockFs.writeFileSync.mock.calls.map((call) => call[0]);
+        expect(writtenFiles.some((f) => f.includes('product.controller.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('product.service.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('product.dto.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('product.module.ts'))).toBe(true);
     });
     it('should use @hazeljs/core imports', async () => {
         (0, generate_crud_1.generateCrud)(program);
         await program.parseAsync(['node', 'test', 'crud', 'product']);
-        const controllerContent = mockFs.writeFileSync.mock.calls
-            .find(call => call[0].includes('controller'))?.[1];
+        const controllerContent = mockFs.writeFileSync.mock.calls.find((call) => call[0].includes('controller'))?.[1];
         expect(controllerContent).toContain("from '@hazeljs/core'");
     });
     it('should support --dry-run flag', async () => {
@@ -45,8 +44,7 @@ describe('generateCrud', () => {
     it('should support custom route path', async () => {
         (0, generate_crud_1.generateCrud)(program);
         await program.parseAsync(['node', 'test', 'crud', 'product', '-r', 'api/products']);
-        const controllerContent = mockFs.writeFileSync.mock.calls
-            .find(call => call[0].includes('controller'))?.[1];
+        const controllerContent = mockFs.writeFileSync.mock.calls.find((call) => call[0].includes('controller'))?.[1];
         expect(controllerContent).toContain('api/products');
     });
 });

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

@@ -22,7 +22,7 @@ describe('generateDto', () => {
     });
     it('should register the dto command with alias', () => {
         (0, generate_dto_1.generateDto)(program);
-        const cmd = program.commands.find(c => c.name() === 'dto');
+        const cmd = program.commands.find((c) => c.name() === 'dto');
         expect(cmd).toBeDefined();
         expect(cmd?.alias()).toBe('d');
     });
@@ -30,9 +30,9 @@ describe('generateDto', () => {
         (0, generate_dto_1.generateDto)(program);
         await program.parseAsync(['node', 'test', 'dto', 'user']);
         expect(mockFs.writeFileSync).toHaveBeenCalledTimes(2);
-        const writtenFiles = mockFs.writeFileSync.mock.calls.map(call => call[0]);
-        expect(writtenFiles.some(f => f.includes('user.dto.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('update-user.dto.ts'))).toBe(true);
+        const writtenFiles = mockFs.writeFileSync.mock.calls.map((call) => call[0]);
+        expect(writtenFiles.some((f) => f.includes('user.dto.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('update-user.dto.ts'))).toBe(true);
     });
     it('should include class-validator decorators', async () => {
         (0, generate_dto_1.generateDto)(program);

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

@@ -23,27 +23,27 @@ describe('generateModule', () => {
     });
     it('should register the module command with alias', () => {
         (0, generate_module_1.generateModule)(program);
-        const cmd = program.commands.find(c => c.name() === 'module');
+        const cmd = program.commands.find((c) => c.name() === 'module');
         expect(cmd).toBeDefined();
         expect(cmd?.alias()).toBe('m');
     });
     it('should generate all module files', async () => {
         (0, generate_module_1.generateModule)(program);
         await program.parseAsync(['node', 'test', 'module', 'user']);
-        const writtenFiles = mockFs.writeFileSync.mock.calls.map(call => call[0]);
-        expect(writtenFiles.some(f => f.includes('user.module.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('user.controller.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('user.service.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('create-user.dto.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('update-user.dto.ts'))).toBe(true);
+        const writtenFiles = mockFs.writeFileSync.mock.calls.map((call) => call[0]);
+        expect(writtenFiles.some((f) => f.includes('user.module.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('user.controller.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('user.service.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('create-user.dto.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('update-user.dto.ts'))).toBe(true);
     });
     it('should use @hazeljs/core imports in all generated files', async () => {
         (0, generate_module_1.generateModule)(program);
         await program.parseAsync(['node', 'test', 'module', 'user']);
-        const writtenContents = mockFs.writeFileSync.mock.calls.map(call => call[1]);
-        const moduleContent = writtenContents.find(c => c.includes('HazelModule'));
+        const writtenContents = mockFs.writeFileSync.mock.calls.map((call) => call[1]);
+        const moduleContent = writtenContents.find((c) => c.includes('HazelModule'));
         expect(moduleContent).toContain("from '@hazeljs/core'");
-        const controllerContent = writtenContents.find(c => c.includes('Controller'));
+        const controllerContent = writtenContents.find((c) => c.includes('Controller'));
         expect(controllerContent).toContain("from '@hazeljs/core'");
     });
     it('should support --dry-run flag', async () => {

package/dist/commands/generate-simple.js

@@ -7,23 +7,177 @@ 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'] },
+    {
+        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: 'rag-pipeline',
+        description: 'RAG pipeline service (RAGPipeline.from + memory store)',
+        suffix: 'rag-pipeline',
+        template: templates_1.RAG_PIPELINE_TEMPLATE,
+        nameRequired: true,
+        nextSteps: [
+            'npm install @hazeljs/rag',
+            'Wire llm() to HazelAI or AIService',
+            'For production vectors, use HazelAI persistence.rag or construct RAGPipeline with your VectorStore',
+        ],
+    },
+    {
+        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 {
@@ -52,7 +206,7 @@ async function runSimpleGenerator(config, name, options) {
         template = templates_1.SERVERLESS_CLOUD_FUNCTION_TEMPLATE;
     }
     const generator = new SimpleGenerator(config.suffix, template);
-    const effectiveName = config.nameRequired ? name : (name || 'app');
+    const effectiveName = config.nameRequired ? name : name || 'app';
     const result = await generator.generate({
         name: effectiveName,
         path: options.path || config.defaultPath,
@@ -87,7 +241,7 @@ function registerSimpleGenerators(generateCommand) {
         }
         cmd.action(async (nameOrOptions, maybeOptions) => {
             const name = typeof nameOrOptions === 'string' ? nameOrOptions : '';
-            const opts = typeof nameOrOptions === 'string' ? (maybeOptions || {}) : nameOrOptions;
+            const opts = typeof nameOrOptions === 'string' ? maybeOptions || {} : nameOrOptions;
             const result = await runSimpleGenerator(config, name, opts);
             (0, generator_1.printGenerateResult)(result, { json: opts.json });
         });

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

@@ -73,13 +73,19 @@ describe('generate-simple', () => {
         });
         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' });
+            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 });
+            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');
         });

package/dist/commands/info.test.js

@@ -47,9 +47,7 @@ describe('infoCommand', () => {
         const program = new commander_1.Command();
         (0, info_1.infoCommand)(program);
         await program.parseAsync(['info'], { from: 'user' });
-        const out = logSpy.mock.calls
-            .map((c) => c.map((x) => String(x)).join(' '))
-            .join('\n');
+        const out = logSpy.mock.calls.map((c) => c.map((x) => String(x)).join(' ')).join('\n');
         expect(out).toContain('Project Information');
         expect(out).toContain('@hazeljs/core');
         expect(out).toContain('@hazeljs/swagger');

package/dist/commands/templates.d.ts

@@ -28,6 +28,7 @@ export declare const AGENT_TEMPLATE = "import { Agent, Tool } from '@hazeljs/age
 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 RAG_PIPELINE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { RAGPipeline } from '@hazeljs/rag';\n\n/**\n * RAG pipeline scaffold \u2014 uses {@link RAGPipeline.from} with in-memory vectors.\n * Swap persistence via HazelAI `persistence.rag` or construct {@link RAGPipeline} with Pinecone/Qdrant/Weaviate/Chroma.\n */\n@Service()\nexport class {{className}}RagPipelineService {\n  private pipeline: RAGPipeline | null = null;\n\n  async ensurePipeline(): Promise<RAGPipeline> {\n    if (this.pipeline) return this.pipeline;\n    this.pipeline = RAGPipeline.from({\n      provider: 'openai',\n      vectorStore: 'memory',\n      topK: 5,\n      chunkSize: 1000,\n      chunkOverlap: 200,\n      llm: async (prompt: string) => {\n        // Wire to your LLM (HazelAI, AIService, or HTTP)\n        return prompt;\n      },\n    });\n    await this.pipeline.initialize();\n    return this.pipeline;\n  }\n\n  async query(question: string) {\n    const p = await this.ensurePipeline();\n    return p.query(question);\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";