@hazeljs/cli 0.2.0-rc.7 → 0.2.0

package/dist/commands/generate-middleware.js

@@ -1,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMiddleware = runMiddleware;
 exports.generateMiddleware = generateMiddleware;
 const generator_1 = require("../utils/generator");
-const chalk_1 = __importDefault(require("chalk"));
 const MIDDLEWARE_TEMPLATE = `import { Injectable, type MiddlewareHandler, type Request, type Response, type NextFunction } from '@hazeljs/core';
 
 @Injectable()
@@ -28,6 +25,13 @@ class MiddlewareGenerator extends generator_1.Generator {
         return MIDDLEWARE_TEMPLATE;
     }
 }
+async function runMiddleware(name, options) {
+    const generator = new MiddlewareGenerator();
+    const result = await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    result.nextSteps = result.nextSteps ?? [];
+    result.nextSteps.push('Import the middleware in your module or apply it globally.');
+    return result;
+}
 function generateMiddleware(command) {
     command
         .command('middleware <name>')
@@ -35,12 +39,9 @@ function generateMiddleware(command) {
         .description('Generate a middleware')
         .option('-p, --path <path>', 'Specify the path', 'src/middleware')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new MiddlewareGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
-        if (!options.dryRun) {
-            console.log(chalk_1.default.gray('\nUsage:'));
-            console.log(chalk_1.default.gray(`  Import the middleware in your module or apply it globally.`));
-        }
+        const result = await runMiddleware(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+export declare function runModule(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
 export declare function generateModule(program: Command): void;

package/dist/commands/generate-module.js

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runModule = runModule;
 exports.generateModule = generateModule;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const chalk_1 = __importDefault(require("chalk"));
 const generator_1 = require("../utils/generator");
 const MODULE_TEMPLATE = `import { HazelModule } from '@hazeljs/core';
 import { {{className}}Controller } from './{{fileName}}.controller';
@@ -64,6 +64,37 @@ const UPDATE_DTO_TEMPLATE = `export class Update{{className}}Dto {
   name?: string;
 }
 `;
+async function runModule(name, options) {
+    const className = (0, generator_1.toPascalCase)(name);
+    const fileName = (0, generator_1.toKebabCase)(name);
+    const camelName = fileName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    const baseDir = path_1.default.join(process.cwd(), options.path || 'src', fileName);
+    const data = { className, fileName, camelName };
+    const files = [
+        { file: `${fileName}.module.ts`, template: MODULE_TEMPLATE },
+        { file: `${fileName}.controller.ts`, template: CONTROLLER_TEMPLATE },
+        { file: `${fileName}.service.ts`, template: SERVICE_TEMPLATE },
+        { file: `dto/create-${fileName}.dto.ts`, template: CREATE_DTO_TEMPLATE },
+        { file: `dto/update-${fileName}.dto.ts`, template: UPDATE_DTO_TEMPLATE },
+    ];
+    const created = [];
+    for (const { file, template } of files) {
+        const filePath = path_1.default.join(baseDir, file);
+        created.push(filePath);
+        if (options.dryRun)
+            continue;
+        const dir = path_1.default.dirname(filePath);
+        if (!fs_1.default.existsSync(dir))
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(filePath, (0, generator_1.renderTemplate)(template, data));
+    }
+    return {
+        ok: true,
+        created,
+        dryRun: options.dryRun,
+        nextSteps: [`Import ${className}Module in your app module.`],
+    };
+}
 function generateModule(program) {
     program
         .command('module <name>')
@@ -71,36 +102,9 @@ function generateModule(program) {
         .alias('m')
         .option('-p, --path <path>', 'Path where the module should be generated')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const className = (0, generator_1.toPascalCase)(name);
-        const fileName = (0, generator_1.toKebabCase)(name);
-        const camelName = fileName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-        const baseDir = path_1.default.join(process.cwd(), options.path || 'src', fileName);
-        const data = { className, fileName, camelName };
-        const files = [
-            { file: `${fileName}.module.ts`, template: MODULE_TEMPLATE },
-            { file: `${fileName}.controller.ts`, template: CONTROLLER_TEMPLATE },
-            { file: `${fileName}.service.ts`, template: SERVICE_TEMPLATE },
-            { file: `dto/create-${fileName}.dto.ts`, template: CREATE_DTO_TEMPLATE },
-            { file: `dto/update-${fileName}.dto.ts`, template: UPDATE_DTO_TEMPLATE },
-        ];
-        for (const { file, template } of files) {
-            const filePath = path_1.default.join(baseDir, file);
-            if (options.dryRun) {
-                console.log(chalk_1.default.blue(`[dry-run] Would create ${filePath}`));
-                continue;
-            }
-            const dir = path_1.default.dirname(filePath);
-            if (!fs_1.default.existsSync(dir)) {
-                fs_1.default.mkdirSync(dir, { recursive: true });
-            }
-            fs_1.default.writeFileSync(filePath, (0, generator_1.renderTemplate)(template, data));
-            console.log(chalk_1.default.green(`✓ Generated ${filePath}`));
-        }
-        if (!options.dryRun) {
-            console.log(chalk_1.default.blue(`\n📦 Module generated in ${baseDir}`));
-            console.log(chalk_1.default.gray(`\nNext steps:`));
-            console.log(chalk_1.default.gray(`  Import ${className}Module in your app module.`));
-        }
+        const result = await runModule(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+export declare function runPipe(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
 export declare function generatePipe(program: Command): void;

package/dist/commands/generate-pipe.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPipe = runPipe;
 exports.generatePipe = generatePipe;
 const generator_1 = require("../utils/generator");
 const PIPE_TEMPLATE = `import { type PipeTransform, type RequestContext } from '@hazeljs/core';
@@ -20,14 +21,19 @@ class PipeGenerator extends generator_1.Generator {
         return PIPE_TEMPLATE;
     }
 }
+async function runPipe(name, options) {
+    const generator = new PipeGenerator();
+    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
+}
 function generatePipe(program) {
     program
         .command('pipe <name>')
         .description('Generate a new pipe')
         .option('-p, --path <path>', 'Path where the pipe should be generated')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new PipeGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        const result = await runPipe(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+export declare function runRag(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
 export declare function generateRag(command: Command): void;

package/dist/commands/generate-rag.js

@@ -1,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRag = runRag;
 exports.generateRag = generateRag;
 const generator_1 = require("../utils/generator");
-const chalk_1 = __importDefault(require("chalk"));
 const RAG_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
 import { RAGPipeline, MemoryVectorStore } from '@hazeljs/rag';
 
@@ -47,20 +44,25 @@ class RagServiceGenerator extends generator_1.Generator {
         return RAG_SERVICE_TEMPLATE;
     }
 }
+async function runRag(name, options) {
+    const generator = new RagServiceGenerator();
+    const result = await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    result.nextSteps = [
+        'npm install @hazeljs/rag',
+        'Register this service as a provider in your module',
+        'Configure your embedding provider and vector store',
+    ];
+    return result;
+}
 function generateRag(command) {
     command
         .command('rag <name>')
         .description('Generate a RAG (Retrieval-Augmented Generation) service')
         .option('-p, --path <path>', 'Specify the path')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new RagServiceGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
-        if (!options.dryRun) {
-            console.log(chalk_1.default.gray('\nNext steps:'));
-            console.log(chalk_1.default.gray('  1. npm install @hazeljs/rag'));
-            console.log(chalk_1.default.gray('  2. Register this service as a provider in your module'));
-            console.log(chalk_1.default.gray('  3. Configure your embedding provider and vector store'));
-        }
+        const result = await runRag(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+export declare function runRepository(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
 export declare function generateRepository(program: Command): void;

package/dist/commands/generate-repository.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRepository = runRepository;
 exports.generateRepository = generateRepository;
 const generator_1 = require("../utils/generator");
 const REPOSITORY_TEMPLATE = `import { Repository, BaseRepository, PrismaService } from '@hazeljs/prisma';
@@ -26,6 +27,10 @@ class RepositoryGenerator extends generator_1.Generator {
         return REPOSITORY_TEMPLATE;
     }
 }
+async function runRepository(name, options) {
+    const generator = new RepositoryGenerator();
+    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
+}
 function generateRepository(program) {
     program
         .command('repository <name>')
@@ -33,8 +38,9 @@ function generateRepository(program) {
         .alias('repo')
         .option('-p, --path <path>', 'Path where the repository should be generated')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new RepositoryGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        const result = await runRepository(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

package/dist/commands/generate-serverless-handler.d.ts

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+export declare function runServerlessHandler(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
 export declare function generateServerlessHandler(program: Command): void;

package/dist/commands/generate-serverless-handler.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runServerlessHandler = runServerlessHandler;
 exports.generateServerlessHandler = generateServerlessHandler;
 const generator_1 = require("../utils/generator");
 const SERVERLESS_LAMBDA_TEMPLATE = `import { createLambdaHandler } from '@hazeljs/serverless';
@@ -25,12 +26,21 @@ class ServerlessHandlerGenerator extends generator_1.Generator {
         const template = platform === 'lambda'
             ? SERVERLESS_LAMBDA_TEMPLATE
             : SERVERLESS_CLOUD_FUNCTION_TEMPLATE;
-        await super.generate({
+        return super.generate({
             ...restOptions,
             template,
         });
     }
 }
+async function runServerlessHandler(name, options) {
+    const generator = new ServerlessHandlerGenerator();
+    return generator.generate({
+        name,
+        path: options.path,
+        platform: options.platform,
+        dryRun: options.dryRun,
+    });
+}
 function generateServerlessHandler(program) {
     program
         .command('serverless <name>')
@@ -39,8 +49,9 @@ function generateServerlessHandler(program) {
         .option('-p, --path <path>', 'Path where the handler should be generated', 'src')
         .option('--platform <platform>', 'Platform: lambda or cloud-function', 'lambda')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new ServerlessHandlerGenerator();
-        await generator.generate({ name, path: options.path, platform: options.platform, dryRun: options.dryRun });
+        const result = await runServerlessHandler(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+export declare function runService(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
 export declare function generateService(program: Command): void;

package/dist/commands/generate-service.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runService = runService;
 exports.generateService = generateService;
 const generator_1 = require("../utils/generator");
 const SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
@@ -38,6 +39,10 @@ class ServiceGenerator extends generator_1.Generator {
         return SERVICE_TEMPLATE;
     }
 }
+async function runService(name, options) {
+    const generator = new ServiceGenerator();
+    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
+}
 function generateService(program) {
     program
         .command('service <name>')
@@ -45,8 +50,9 @@ function generateService(program) {
         .alias('s')
         .option('-p, --path <path>', 'Path where the service should be generated')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new ServiceGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        const result = await runService(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import { GenerateCLIOptions, GenerateResult } from '../utils/generator';
+export declare function runSetup(pkg: string, options: GenerateCLIOptions): Promise<GenerateResult>;
+export declare function generateSetup(program: Command): void;

package/dist/commands/generate-setup.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSetup = runSetup;
+exports.generateSetup = generateSetup;
+const generator_1 = require("../utils/generator");
+function packageToNpmName(input) {
+    if (input.startsWith('@hazeljs/'))
+        return input;
+    return `@hazeljs/${input}`;
+}
+function packageToTemplate(pkg) {
+    const npmName = packageToNpmName(pkg);
+    const short = npmName.replace('@hazeljs/', '');
+    // Keep these templates intentionally minimal: a real import + a tiny “hello usage”
+    // so users can immediately search/expand, without forcing a specific app structure.
+    switch (short) {
+        case 'swagger':
+            return `import { SwaggerModule } from '@hazeljs/swagger';
+import { AppModule } from './app.module';
+
+// Setup Swagger once before creating your app:
+SwaggerModule.setRootModule(AppModule);
+`;
+        case 'prisma':
+            return `import { PrismaModule } from '@hazeljs/prisma';
+
+// Add PrismaModule to your HazelModule imports.
+export const prismaImports = [PrismaModule];
+`;
+        case 'typeorm':
+            return `import { TypeOrmModule } from '@hazeljs/typeorm';
+
+// Add TypeOrmModule to your HazelModule imports.
+export const typeormImports = [TypeOrmModule];
+`;
+        case 'oauth':
+            return `import { OAuthModule } from '@hazeljs/oauth';
+
+// Example (Google). Put secrets in env vars:
+// GOOGLE_CLIENT_ID=...
+// GOOGLE_CLIENT_SECRET=...
+// OAUTH_REDIRECT_URI=...
+export const oauthImports = [
+  OAuthModule.forRoot({
+    providers: {
+      google: {
+        clientId: process.env.GOOGLE_CLIENT_ID!,
+        clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+        redirectUri: process.env.OAUTH_REDIRECT_URI!,
+      },
+    },
+  }),
+];
+`;
+        case 'kafka':
+            return `import { KafkaModule } from '@hazeljs/kafka';
+
+// Add KafkaModule to your HazelModule imports and configure brokers via env/config.
+export const kafkaImports = [KafkaModule];
+`;
+        case 'grpc':
+            return `import { GrpcModule } from '@hazeljs/grpc';
+
+// Add GrpcModule to your HazelModule imports. Define services in your module.
+export const grpcImports = [GrpcModule];
+`;
+        case 'graphql':
+            return `import { GraphQLModule } from '@hazeljs/graphql';
+
+// Add GraphQLModule to your HazelModule imports.
+export const graphqlImports = [GraphQLModule];
+`;
+        case 'gateway':
+            return `import { GatewayModule } from '@hazeljs/gateway';
+
+// Add GatewayModule to your HazelModule imports.
+export const gatewayImports = [GatewayModule];
+`;
+        case 'event-emitter':
+            return `import { EventEmitterModule } from '@hazeljs/event-emitter';
+
+// Add EventEmitterModule.forRoot() to your HazelModule imports.
+export const eventEmitterImports = [EventEmitterModule.forRoot()];
+`;
+        case 'audit':
+            return `import { AuditModule, ConsoleAuditTransport } from '@hazeljs/audit';
+
+// Add AuditModule.forRoot(...) to your HazelModule imports.
+export const auditImports = [AuditModule.forRoot({ transports: [new ConsoleAuditTransport()] })];
+`;
+        case 'queue':
+            return `import { QueueModule } from '@hazeljs/queue';
+
+// Add QueueModule to your HazelModule imports. Configure Redis / BullMQ via env/config.
+export const queueImports = [QueueModule];
+`;
+        case 'messaging':
+            return `import { MessagingModule } from '@hazeljs/messaging';
+
+// Add MessagingModule to your HazelModule imports. Configure channels (WhatsApp/Telegram) via env/config.
+export const messagingImports = [MessagingModule];
+`;
+        case 'mcp':
+            return `import { createMcpServer } from '@hazeljs/mcp';
+
+// Minimal MCP server example:
+const server = createMcpServer({ name: 'hazel-mcp', version: '0.1.0' });
+server.start();
+`;
+        case 'prompts':
+            return `import { PromptTemplate } from '@hazeljs/prompts';
+
+export const helloPrompt = new PromptTemplate({
+  name: 'hello',
+  template: 'Hello {{name}}',
+});
+`;
+        case 'data':
+            return `import { DataModule } from '@hazeljs/data';
+
+// Add DataModule.forRoot() to your HazelModule imports.
+export const dataImports = [DataModule.forRoot()];
+`;
+        case 'ml':
+            return `import { MLModule } from '@hazeljs/ml';
+
+// Add MLModule.forRoot() to your HazelModule imports.
+export const mlImports = [MLModule.forRoot()];
+`;
+        case 'resilience':
+            return `import { CircuitBreaker, WithRetry } from '@hazeljs/resilience';
+
+export class ExampleResilienceService {
+  @WithRetry({ retries: 3 })
+  @CircuitBreaker({ failureThreshold: 5, resetTimeoutMs: 10000 })
+  async callRemote(): Promise<string> {
+    return 'ok';
+  }
+}
+`;
+        case 'pdf-to-audio':
+            return `import { PdfToAudioModule } from '@hazeljs/pdf-to-audio';
+
+// Add PdfToAudioModule to your HazelModule imports.
+export const pdfToAudioImports = [PdfToAudioModule];
+`;
+        default:
+            return `import '${npmName}';
+
+// Starter file generated for ${npmName}.
+// Tip: check the package README for setup details and examples.
+`;
+    }
+}
+class SetupGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'setup';
+    }
+}
+async function runSetup(pkg, options) {
+    const npmName = packageToNpmName(pkg);
+    const template = packageToTemplate(pkg);
+    const generator = new SetupGenerator();
+    const result = await generator.generate({
+        name: pkg,
+        path: options.path,
+        template,
+        dryRun: options.dryRun,
+    });
+    result.nextSteps = result.nextSteps ?? [];
+    result.nextSteps.push(`npm install ${npmName}`);
+    return result;
+}
+function generateSetup(program) {
+    program
+        .command('setup <package>')
+        .description('Generate a minimal setup starter file for a HazelJS package')
+        .alias('st')
+        .option('-p, --path <path>', 'Path where the setup file should be generated', 'src')
+        .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
+        .action(async (pkg, options) => {
+        const result = await runSetup(pkg, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
+    });
+}

package/dist/commands/generate-setup.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,50 @@
+"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 path_1 = __importDefault(require("path"));
+const generate_setup_1 = require("./generate-setup");
+const commander_1 = require("commander");
+jest.mock('fs');
+describe('generateSetup', () => {
+    const mockFs = fs_1.default;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        mockFs.mkdirSync.mockImplementation(() => undefined);
+    });
+    it('should register setup command with alias', () => {
+        const program = new commander_1.Command();
+        (0, generate_setup_1.generateSetup)(program);
+        const cmd = program.commands.find((c) => c.name() === 'setup');
+        expect(cmd).toBeTruthy();
+        expect(cmd?.aliases()).toContain('st');
+    });
+    it('runSetup should generate a setup file and include npm install in next steps', async () => {
+        const result = await (0, generate_setup_1.runSetup)('swagger', { path: 'src', dryRun: false });
+        expect(result.ok).toBe(true);
+        expect(result.created).toHaveLength(1);
+        expect(result.created[0]).toBe(path_1.default.join(process.cwd(), 'src', 'swagger.setup.ts'));
+        expect(result.nextSteps?.some((s) => s.includes('npm install @hazeljs/swagger'))).toBe(true);
+    });
+    it('runSetup should accept package names with and without @hazeljs prefix', async () => {
+        const r1 = await (0, generate_setup_1.runSetup)('oauth', { path: 'src', dryRun: true });
+        expect(r1.ok).toBe(true);
+        expect(r1.dryRun).toBe(true);
+        expect(r1.nextSteps?.some((s) => s.includes('npm install @hazeljs/oauth'))).toBe(true);
+        const r2 = await (0, generate_setup_1.runSetup)('@hazeljs/oauth', { path: 'src', dryRun: true });
+        expect(r2.ok).toBe(true);
+        expect(r2.nextSteps?.some((s) => s.includes('npm install @hazeljs/oauth'))).toBe(true);
+    });
+    it('covers several common setup templates', async () => {
+        const pkgs = ['grpc', 'graphql', 'kafka', 'resilience', 'mcp', 'pdf-to-audio'];
+        for (const p of pkgs) {
+            const result = await (0, generate_setup_1.runSetup)(p, { path: 'src', dryRun: true });
+            expect(result.ok).toBe(true);
+            expect(result.created[0]).toContain(`${p}.setup.ts`);
+        }
+    });
+});

package/dist/commands/generate-websocket-gateway.d.ts

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+export declare function runWebSocketGateway(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
 export declare function generateWebSocketGateway(program: Command): void;

package/dist/commands/generate-websocket-gateway.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWebSocketGateway = runWebSocketGateway;
 exports.generateWebSocketGateway = generateWebSocketGateway;
 const generator_1 = require("../utils/generator");
 const WEBSOCKET_GATEWAY_TEMPLATE = `import { Realtime, OnConnect, OnDisconnect, OnMessage, Subscribe, Client, Data, WebSocketClient } from '@hazeljs/websocket';
@@ -33,6 +34,10 @@ class WebSocketGatewayGenerator extends generator_1.Generator {
         return WEBSOCKET_GATEWAY_TEMPLATE;
     }
 }
+async function runWebSocketGateway(name, options) {
+    const generator = new WebSocketGatewayGenerator();
+    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
+}
 function generateWebSocketGateway(program) {
     program
         .command('gateway <name>')
@@ -40,8 +45,9 @@ function generateWebSocketGateway(program) {
         .alias('ws')
         .option('-p, --path <path>', 'Path where the gateway should be generated')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new WebSocketGatewayGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        const result = await runWebSocketGateway(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

package/dist/commands/info.test.d.ts

@@ -0,0 +1 @@
+export {};