@hazeljs/cli 0.2.0-rc.7 → 0.2.0

package/dist/commands/info.test.js

@@ -0,0 +1,58 @@
+"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 commander_1 = require("commander");
+const info_1 = require("./info");
+jest.mock('fs');
+describe('infoCommand', () => {
+    const mockFs = fs_1.default;
+    let logSpy;
+    beforeAll(() => {
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    });
+    afterAll(() => {
+        logSpy.mockRestore();
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.readdirSync.mockReturnValue(['a.ts', 'dir']);
+        mockFs.statSync.mockImplementation((p) => {
+            const s = String(p);
+            return { isDirectory: () => s.endsWith('dir') };
+        });
+        mockFs.readFileSync.mockReturnValue(JSON.stringify({
+            name: 'demo',
+            version: '1.0.0',
+            description: 'desc',
+            dependencies: { '@hazeljs/core': '^0.2.0', lodash: '^4.0.0' },
+            devDependencies: { '@hazeljs/swagger': '^0.2.0' },
+        }));
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s.endsWith(path_1.default.join(process.cwd(), 'package.json')))
+                return true;
+            if (s.endsWith(path_1.default.join(process.cwd(), 'src')))
+                return true;
+            // pretend some config files exist
+            if (s.endsWith('tsconfig.json'))
+                return true;
+            return false;
+        });
+    });
+    it('prints hazel packages and project structure', async () => {
+        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');
+        expect(out).toContain('Project Information');
+        expect(out).toContain('@hazeljs/core');
+        expect(out).toContain('@hazeljs/swagger');
+        expect(out).toContain('Project Structure');
+    });
+});

package/dist/commands/pdf-to-audio.test.d.ts

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

package/dist/commands/pdf-to-audio.test.js

@@ -0,0 +1,92 @@
+"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 form_data_1 = __importDefault(require("form-data"));
+const pdf_to_audio_1 = require("./pdf-to-audio");
+jest.mock('fs');
+jest.mock('form-data', () => {
+    return jest.fn().mockImplementation(() => ({
+        append: jest.fn(),
+        getHeaders: jest.fn(() => ({})),
+    }));
+});
+describe('pdf-to-audio', () => {
+    const mockFs = fs_1.default;
+    const MockFormData = form_data_1.default;
+    let exitSpy;
+    let logSpy;
+    let errSpy;
+    beforeAll(() => {
+        exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+        errSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+    });
+    afterAll(() => {
+        exitSpy.mockRestore();
+        logSpy.mockRestore();
+        errSpy.mockRestore();
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        global.fetch = jest.fn();
+        mockFs.createReadStream.mockReturnValue({});
+    });
+    it('convert: exits when file is not a PDF', async () => {
+        const program = new commander_1.Command();
+        (0, pdf_to_audio_1.pdfToAudioCommand)(program);
+        await program.parseAsync(['pdf-to-audio', 'convert', 'not-a-pdf.txt'], { from: 'user' });
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('convert: exits when file does not exist', async () => {
+        mockFs.existsSync.mockReturnValue(false);
+        const program = new commander_1.Command();
+        (0, pdf_to_audio_1.pdfToAudioCommand)(program);
+        await program.parseAsync(['pdf-to-audio', 'convert', 'file.pdf'], { from: 'user' });
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('convert: submits job and prints job id (no wait)', async () => {
+        mockFs.existsSync.mockReturnValue(true);
+        global.fetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ jobId: 'job-123' }),
+        });
+        const program = new commander_1.Command();
+        (0, pdf_to_audio_1.pdfToAudioCommand)(program);
+        await program.parseAsync(['pdf-to-audio', 'convert', 'file.pdf', '--api-url', 'http://x'], { from: 'user' });
+        expect(MockFormData).toHaveBeenCalled();
+        expect(global.fetch).toHaveBeenCalled();
+        const out = logSpy.mock.calls.map((c) => String(c[0])).join('\n');
+        expect(out).toContain('Job submitted: job-123');
+    });
+    it('status: prints download hint when completed without output', async () => {
+        global.fetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ jobId: 'job-1', status: 'completed', progress: 100 }),
+        });
+        const program = new commander_1.Command();
+        (0, pdf_to_audio_1.pdfToAudioCommand)(program);
+        await program.parseAsync(['pdf-to-audio', 'status', 'job-1', '--api-url', 'http://x'], { from: 'user' });
+        const out = logSpy.mock.calls.map((c) => String(c[0])).join('\n');
+        expect(out).toContain('Download: GET');
+    });
+    it('status: downloads audio when completed with output', async () => {
+        global.fetch
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ jobId: 'job-2', status: 'completed', progress: 100 }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            arrayBuffer: async () => new ArrayBuffer(3),
+            text: async () => '',
+        });
+        const program = new commander_1.Command();
+        (0, pdf_to_audio_1.pdfToAudioCommand)(program);
+        await program.parseAsync(['pdf-to-audio', 'status', 'job-2', '--api-url', 'http://x', '--output', 'out.mp3'], { from: 'user' });
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith('out.mp3', expect.any(Buffer));
+    });
+});

package/dist/commands/utility-commands.test.d.ts

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

package/dist/commands/utility-commands.test.js

@@ -0,0 +1,95 @@
+"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 child_process_1 = require("child_process");
+const commander_1 = require("commander");
+const build_1 = require("./build");
+const start_1 = require("./start");
+const test_1 = require("./test");
+const info_1 = require("./info");
+jest.mock('fs');
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+describe('utility commands', () => {
+    const mockFs = fs_1.default;
+    const mockExec = child_process_1.execSync;
+    let exitSpy;
+    let logSpy;
+    let errSpy;
+    beforeAll(() => {
+        exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+        errSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+    });
+    afterAll(() => {
+        exitSpy.mockRestore();
+        logSpy.mockRestore();
+        errSpy.mockRestore();
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockExec.mockImplementation(() => undefined);
+        exitSpy.mockClear();
+        logSpy.mockClear();
+        errSpy.mockClear();
+        delete process.env.PORT;
+    });
+    it('build: exits when package.json missing', async () => {
+        mockFs.existsSync.mockReturnValue(false);
+        const program = new commander_1.Command();
+        (0, build_1.buildCommand)(program);
+        await program.parseAsync(['build'], { from: 'user' });
+        expect(exitSpy).toHaveBeenCalled();
+    });
+    it('build: uses watch command when --watch is set', async () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(JSON.stringify({ scripts: { build: 'tsc' } }));
+        const program = new commander_1.Command();
+        (0, build_1.buildCommand)(program);
+        await program.parseAsync(['build', '--watch'], { from: 'user' });
+        expect(mockExec).toHaveBeenCalledWith('npm run build -- --watch', { stdio: 'inherit' });
+    });
+    it('start: dev mode exits when dev script missing', async () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(JSON.stringify({ scripts: { start: 'node dist/index.js' } }));
+        const program = new commander_1.Command();
+        (0, start_1.startCommand)(program);
+        await program.parseAsync(['start', '--dev'], { from: 'user' });
+        expect(exitSpy).toHaveBeenCalled();
+    });
+    it('start: sets PORT when provided', async () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(JSON.stringify({ scripts: { start: 'node dist/index.js' } }));
+        const program = new commander_1.Command();
+        (0, start_1.startCommand)(program);
+        await program.parseAsync(['start', '--port', '7777'], { from: 'user' });
+        expect(process.env.PORT).toBe('7777');
+        expect(mockExec).toHaveBeenCalledWith('npm start', { stdio: 'inherit' });
+    });
+    it('test: uses test:ci when present', async () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(JSON.stringify({ scripts: { test: 'jest', 'test:ci': 'jest --ci' } }));
+        const program = new commander_1.Command();
+        (0, test_1.testCommand)(program);
+        await program.parseAsync(['test', '--ci'], { from: 'user' });
+        expect(mockExec).toHaveBeenCalledWith('npm run test:ci', { stdio: 'inherit' });
+    });
+    it('test: adds pattern and coverage args when not in ci', async () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(JSON.stringify({ scripts: { test: 'jest' } }));
+        const program = new commander_1.Command();
+        (0, test_1.testCommand)(program);
+        await program.parseAsync(['test', 'user.test', '--coverage'], { from: 'user' });
+        expect(mockExec).toHaveBeenCalledWith('npm test -- user.test --coverage', { stdio: 'inherit' });
+    });
+    it('info: returns early when package.json missing', async () => {
+        mockFs.existsSync.mockReturnValue(false);
+        const program = new commander_1.Command();
+        (0, info_1.infoCommand)(program);
+        await program.parseAsync(['info'], { from: 'user' });
+        expect(exitSpy).not.toHaveBeenCalled();
+        expect(logSpy).toHaveBeenCalled();
+    });
+});

package/dist/index.js

@@ -24,6 +24,8 @@ const generate_cache_1 = require("./commands/generate-cache");
 const generate_cron_1 = require("./commands/generate-cron");
 const generate_rag_1 = require("./commands/generate-rag");
 const generate_discovery_1 = require("./commands/generate-discovery");
+const generate_setup_1 = require("./commands/generate-setup");
+const generator_registry_1 = require("./utils/generator-registry");
 const info_1 = require("./commands/info");
 const add_1 = require("./commands/add");
 const build_1 = require("./commands/build");
@@ -44,11 +46,37 @@ program
 (0, pdf_to_audio_1.pdfToAudioCommand)(program);
 (0, start_1.startCommand)(program);
 (0, test_1.testCommand)(program);
-// Generate command group
+// Generate command group (unified: hazel g <type> <name> [--path] [--dry-run] [--json], or hazel g --list)
 const generateCommand = program
     .command('generate')
-    .description('Generate HazelJS components')
-    .alias('g');
+    .description('Generate HazelJS components. Use: hazel g <type> <name> (e.g. hazel g controller users). Use --list to see all types.')
+    .alias('g')
+    .option('--list', 'List available generator types')
+    .option('--list-json', 'With --list: output list as JSON')
+    .action((options) => {
+    const outputJsonList = options.list && options.listJson;
+    if (options.list) {
+        if (outputJsonList) {
+            console.log(JSON.stringify({ generators: generator_registry_1.GENERATOR_LIST }));
+        }
+        else {
+            console.log('\nAvailable generator types:\n');
+            generator_registry_1.GENERATOR_LIST.forEach((g) => {
+                const nameNote = g.nameRequired ? ' <name>' : ' [name]';
+                console.log(`  ${g.type}${nameNote}  ${g.description}`);
+            });
+            console.log('\nExample: hazel g controller users\n');
+        }
+    }
+    else {
+        console.log('Usage: hazel g <type> <name> [--path <path>] [--dry-run] [--json]');
+        console.log('       hazel g --list         List all generator types');
+        console.log('       hazel g --list --list-json   List types as JSON');
+        console.log('Example: hazel g controller users\n');
+    }
+});
+// Skeleton app
+(0, generate_app_1.registerGenerateApp)(generateCommand);
 // Core components
 (0, generate_controller_1.generateController)(generateCommand);
 (0, generate_service_1.generateService)(generateCommand);
@@ -72,4 +100,5 @@ const generateCommand = program
 (0, generate_cron_1.generateCron)(generateCommand);
 (0, generate_rag_1.generateRag)(generateCommand);
 (0, generate_discovery_1.generateDiscovery)(generateCommand);
+(0, generate_setup_1.generateSetup)(generateCommand);
 program.parse(process.argv);

package/dist/index.list.test.js

@@ -0,0 +1,70 @@
+"use strict";
+// Mock generators so requiring ./index doesn't do real work
+jest.mock('./commands/generate-app', () => ({
+    generateApp: jest.fn(),
+    registerGenerateApp: jest.fn(),
+}));
+jest.mock('./commands/generate-controller', () => ({ generateController: jest.fn() }));
+jest.mock('./commands/generate-service', () => ({ generateService: jest.fn() }));
+jest.mock('./commands/generate-module', () => ({ generateModule: jest.fn() }));
+jest.mock('./commands/generate-dto', () => ({ generateDto: jest.fn() }));
+jest.mock('./commands/generate-guard', () => ({ generateGuard: jest.fn() }));
+jest.mock('./commands/generate-interceptor', () => ({ generateInterceptor: jest.fn() }));
+jest.mock('./commands/generate-middleware', () => ({ generateMiddleware: jest.fn() }));
+jest.mock('./commands/generate-crud', () => ({ generateCrud: jest.fn() }));
+jest.mock('./commands/generate-auth', () => ({ generateAuth: jest.fn() }));
+jest.mock('./commands/generate-websocket-gateway', () => ({ generateWebSocketGateway: jest.fn() }));
+jest.mock('./commands/generate-exception-filter', () => ({ generateExceptionFilter: jest.fn() }));
+jest.mock('./commands/generate-pipe', () => ({ generatePipe: jest.fn() }));
+jest.mock('./commands/generate-repository', () => ({ generateRepository: jest.fn() }));
+jest.mock('./commands/generate-ai-service', () => ({ generateAIService: jest.fn() }));
+jest.mock('./commands/generate-agent', () => ({ generateAgent: jest.fn() }));
+jest.mock('./commands/generate-serverless-handler', () => ({ generateServerlessHandler: jest.fn() }));
+jest.mock('./commands/generate-config', () => ({ generateConfig: jest.fn() }));
+jest.mock('./commands/generate-cache', () => ({ generateCache: jest.fn() }));
+jest.mock('./commands/generate-cron', () => ({ generateCron: jest.fn() }));
+jest.mock('./commands/generate-rag', () => ({ generateRag: jest.fn() }));
+jest.mock('./commands/generate-discovery', () => ({ generateDiscovery: jest.fn() }));
+jest.mock('./commands/generate-setup', () => ({ generateSetup: jest.fn() }));
+jest.mock('./commands/info', () => ({ infoCommand: jest.fn() }));
+jest.mock('./commands/add', () => ({ addCommand: jest.fn() }));
+jest.mock('./commands/build', () => ({ buildCommand: jest.fn() }));
+jest.mock('./commands/pdf-to-audio', () => ({ pdfToAudioCommand: jest.fn() }));
+jest.mock('./commands/start', () => ({ startCommand: jest.fn() }));
+jest.mock('./commands/test', () => ({ testCommand: jest.fn() }));
+describe('CLI generate --list', () => {
+    let logSpy;
+    beforeAll(() => {
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    });
+    afterAll(() => {
+        logSpy.mockRestore();
+    });
+    beforeEach(() => {
+        jest.resetModules();
+        jest.clearAllMocks();
+    });
+    it('prints a human list with --list', () => {
+        process.argv = ['node', 'hazel', 'g', '--list'];
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        require('./index');
+        expect(logSpy).toHaveBeenCalled();
+        const output = logSpy.mock.calls.map((c) => String(c[0])).join('\n');
+        expect(output).toContain('Available generator types');
+    });
+    it('prints JSON with --list --list-json', () => {
+        process.argv = ['node', 'hazel', 'g', '--list', '--list-json'];
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        require('./index');
+        const output = logSpy.mock.calls.map((c) => String(c[0])).join('\n');
+        expect(output).toContain('{"generators":');
+    });
+    it('prints usage when no args provided to generate', () => {
+        // this triggers the action handler for generate without --list
+        process.argv = ['node', 'hazel', 'g'];
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        require('./index');
+        const output = logSpy.mock.calls.map((c) => String(c[0])).join('\n');
+        expect(output).toContain('Usage: hazel g <type> <name>');
+    });
+});

package/dist/utils/generator-registry.d.ts

@@ -0,0 +1,15 @@
+import { GenerateResult, GenerateCLIOptions } from './generator';
+export interface GeneratorMeta {
+    type: string;
+    description: string;
+    nameRequired: boolean;
+    options?: string[];
+}
+/** All available generator types and their metadata (for --list). */
+export declare const GENERATOR_LIST: GeneratorMeta[];
+/**
+ * Run a generator by type and name. Use for unified `hazel generate <type> <name>`.
+ * For types that don't require a name (auth, config), pass a placeholder (e.g. 'auth').
+ */
+export declare function runGenerator(type: string, name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
+export declare function getGeneratorTypes(): string[];

package/dist/utils/generator-registry.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATOR_LIST = void 0;
+exports.runGenerator = runGenerator;
+exports.getGeneratorTypes = getGeneratorTypes;
+const generate_controller_1 = require("../commands/generate-controller");
+const generate_service_1 = require("../commands/generate-service");
+const generate_module_1 = require("../commands/generate-module");
+const generate_dto_1 = require("../commands/generate-dto");
+const generate_guard_1 = require("../commands/generate-guard");
+const generate_interceptor_1 = require("../commands/generate-interceptor");
+const generate_middleware_1 = require("../commands/generate-middleware");
+const generate_crud_1 = require("../commands/generate-crud");
+const generate_auth_1 = require("../commands/generate-auth");
+const generate_websocket_gateway_1 = require("../commands/generate-websocket-gateway");
+const generate_exception_filter_1 = require("../commands/generate-exception-filter");
+const generate_pipe_1 = require("../commands/generate-pipe");
+const generate_repository_1 = require("../commands/generate-repository");
+const generate_ai_service_1 = require("../commands/generate-ai-service");
+const generate_agent_1 = require("../commands/generate-agent");
+const generate_serverless_handler_1 = require("../commands/generate-serverless-handler");
+const generate_config_1 = require("../commands/generate-config");
+const generate_cache_1 = require("../commands/generate-cache");
+const generate_cron_1 = require("../commands/generate-cron");
+const generate_rag_1 = require("../commands/generate-rag");
+const generate_discovery_1 = require("../commands/generate-discovery");
+const generate_app_1 = require("../commands/generate-app");
+const generate_setup_1 = require("../commands/generate-setup");
+/** All available generator types and their metadata (for --list). */
+exports.GENERATOR_LIST = [
+    { type: 'app', description: 'Skeleton HazelJS application (minimal template)', nameRequired: true, options: ['path'] },
+    { type: 'setup', description: 'Minimal setup starter file for a HazelJS package', nameRequired: true, options: ['path'] },
+    { type: 'controller', description: 'REST controller', nameRequired: true },
+    { type: 'service', description: 'Service class', nameRequired: true },
+    { type: 'module', description: 'Module with controller, service, DTOs', nameRequired: true },
+    { type: 'dto', description: 'Create and update DTOs', nameRequired: true },
+    { type: 'guard', description: 'Guard (e.g. auth)', nameRequired: true },
+    { type: 'interceptor', description: 'Interceptor', nameRequired: true },
+    { type: 'middleware', description: 'Middleware', nameRequired: true },
+    { type: 'crud', description: 'Full CRUD resource (controller, service, module, DTOs)', nameRequired: true, options: ['route'] },
+    { type: 'auth', description: 'Auth module (JWT guard, service, controller, DTOs)', nameRequired: false },
+    { type: 'gateway', description: 'WebSocket gateway', nameRequired: true },
+    { type: 'filter', description: 'Exception filter', nameRequired: true },
+    { type: 'pipe', description: 'Validation/transform pipe', nameRequired: true },
+    { type: 'repository', description: 'Prisma repository', nameRequired: true },
+    { type: 'ai-service', description: 'AI service with decorators', nameRequired: true },
+    { type: 'agent', description: 'AI agent with @Agent and @Tool', nameRequired: true },
+    { type: 'serverless', description: 'Serverless handler (Lambda or Cloud Function)', nameRequired: true, options: ['platform'] },
+    { type: 'config', description: 'Config module setup', nameRequired: false },
+    { type: 'cache', description: 'Cache service with decorators', nameRequired: true },
+    { type: 'cron', description: 'Cron/scheduled job service', nameRequired: true },
+    { type: 'rag', description: 'RAG (Retrieval-Augmented Generation) service', nameRequired: true },
+    { type: 'discovery', description: 'Service discovery setup', nameRequired: true },
+];
+const RUNNERS = {
+    app: generate_app_1.runApp,
+    setup: generate_setup_1.runSetup,
+    controller: generate_controller_1.runController,
+    service: generate_service_1.runService,
+    module: generate_module_1.runModule,
+    dto: generate_dto_1.runDto,
+    guard: generate_guard_1.runGuard,
+    interceptor: generate_interceptor_1.runInterceptor,
+    middleware: generate_middleware_1.runMiddleware,
+    crud: generate_crud_1.runCrud,
+    auth: generate_auth_1.runAuth,
+    gateway: generate_websocket_gateway_1.runWebSocketGateway,
+    filter: generate_exception_filter_1.runExceptionFilter,
+    pipe: generate_pipe_1.runPipe,
+    repository: generate_repository_1.runRepository,
+    'ai-service': generate_ai_service_1.runAIService,
+    agent: generate_agent_1.runAgent,
+    serverless: generate_serverless_handler_1.runServerlessHandler,
+    config: generate_config_1.runConfig,
+    cache: generate_cache_1.runCache,
+    cron: generate_cron_1.runCron,
+    rag: generate_rag_1.runRag,
+    discovery: generate_discovery_1.runDiscovery,
+};
+/**
+ * Run a generator by type and name. Use for unified `hazel generate <type> <name>`.
+ * For types that don't require a name (auth, config), pass a placeholder (e.g. 'auth').
+ */
+async function runGenerator(type, name, options) {
+    const runner = RUNNERS[type];
+    if (!runner) {
+        return {
+            ok: false,
+            created: [],
+            error: `Unknown generator type: "${type}". Use "hazel generate --list" to see available types.`,
+        };
+    }
+    return runner(name, options);
+}
+function getGeneratorTypes() {
+    return exports.GENERATOR_LIST.map((g) => g.type);
+}

package/dist/utils/generator-registry.test.d.ts

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

package/dist/utils/generator-registry.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generator_registry_1 = require("./generator-registry");
+describe('generator-registry', () => {
+    it('returns a helpful error for unknown generator types', async () => {
+        const result = await (0, generator_registry_1.runGenerator)('nope', 'x', { dryRun: true });
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Unknown generator type');
+    });
+});

package/dist/utils/generator.d.ts

@@ -12,14 +12,34 @@ export interface GeneratorOptions {
     data?: Record<string, unknown>;
     dryRun?: boolean;
 }
+/** Result of a generation run for machine-readable output (e.g. --json) */
+export interface GenerateResult {
+    ok: boolean;
+    created: string[];
+    nextSteps?: string[];
+    dryRun?: boolean;
+    error?: string;
+}
+/** Common CLI options for all generate commands */
+export interface GenerateCLIOptions {
+    path?: string;
+    dryRun?: boolean;
+    json?: boolean;
+    route?: string;
+    platform?: string;
+}
 export declare class Generator {
     /**
      * File suffix appended before .ts (e.g. 'controller' -> name.controller.ts)
      * Override in subclasses.
      */
     protected suffix: string;
-    generate(options: GeneratorOptions): Promise<void>;
+    generate(options: GeneratorOptions): Promise<GenerateResult>;
     protected getFilePath(name: string, customPath?: string): string;
     protected getDefaultTemplate(): string;
     promptForOptions(options: Partial<GeneratorOptions>): Promise<GeneratorOptions>;
 }
+/** Output result for humans or as JSON. Use json: true to print a single JSON object to stdout. */
+export declare function printGenerateResult(result: GenerateResult, options: {
+    json?: boolean;
+}): void;

package/dist/utils/generator.js

@@ -8,6 +8,7 @@ exports.toPascalCase = toPascalCase;
 exports.toKebabCase = toKebabCase;
 exports.toCamelCase = toCamelCase;
 exports.renderTemplate = renderTemplate;
+exports.printGenerateResult = printGenerateResult;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
@@ -59,10 +60,9 @@ class Generator {
         const content = mustache_1.default.render(templateContent, templateData);
         // Determine the file path
         const filePath = this.getFilePath(name, customPath);
+        const created = [filePath];
         if (dryRun) {
-            console.log(chalk_1.default.blue(`[dry-run] Would create ${filePath}`));
-            console.log(chalk_1.default.gray(content));
-            return;
+            return { ok: true, created, dryRun: true };
         }
         // Create directory if it doesn't exist
         const dir = path_1.default.dirname(filePath);
@@ -71,7 +71,7 @@ class Generator {
         }
         // Write the file
         fs_1.default.writeFileSync(filePath, content);
-        console.log(chalk_1.default.green(`✓ Generated ${filePath}`));
+        return { ok: true, created };
     }
     getFilePath(name, customPath) {
         const fileName = toKebabCase(name);
@@ -105,3 +105,22 @@ class Generator {
     }
 }
 exports.Generator = Generator;
+/** Output result for humans or as JSON. Use json: true to print a single JSON object to stdout. */
+function printGenerateResult(result, options) {
+    if (options.json) {
+        console.log(JSON.stringify(result));
+        return;
+    }
+    if (!result.ok) {
+        console.error(chalk_1.default.red(result.error ?? 'Generation failed'));
+        return;
+    }
+    const prefix = result.dryRun ? chalk_1.default.blue('[dry-run] Would create ') : chalk_1.default.green('✓ Generated ');
+    for (const file of result.created) {
+        console.log(prefix + file);
+    }
+    if (result.nextSteps && result.nextSteps.length > 0) {
+        console.log(chalk_1.default.blue('\nNext steps:'));
+        result.nextSteps.forEach((step) => console.log(chalk_1.default.gray('  ' + step)));
+    }
+}

package/dist/utils/generator.test.js

@@ -98,15 +98,16 @@ describe('Generator class', () => {
             expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.any(String), 'MyWidget my-widget myWidget');
         });
         it('should not write files in dry-run mode', async () => {
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            await generator.generate({
+            const result = await generator.generate({
                 name: 'test',
                 template: 'content',
                 dryRun: true,
             });
             expect(mockFs.writeFileSync).not.toHaveBeenCalled();
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[dry-run]'));
-            consoleSpy.mockRestore();
+            expect(result.ok).toBe(true);
+            expect(result.dryRun).toBe(true);
+            expect(result.created).toHaveLength(1);
+            expect(result.created[0]).toContain('test.ts');
         });
     });
     describe('promptForOptions', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/cli",
-  "version": "0.2.0-rc.7",
+  "version": "0.2.0",
   "description": "Command-line interface for scaffolding and generating HazelJS applications and components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -69,5 +69,5 @@
     "type": "opencollective",
     "url": "https://opencollective.com/hazeljs"
   },
-  "gitHead": "0a2a8894e755b6cb7a5e3223dfbcd5d245dd2638"
+  "gitHead": "6f43ebe685dc190fbfd13f806976d58640197358"
 }