@hazeljs/cli 0.2.0-alpha.1

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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';
+
+@Realtime('/{{fileName}}')
+export class {{className}}Gateway {
+  @OnConnect()
+  handleConnection(@Client() client: WebSocketClient) {
+    console.log('Client connected:', client.id);
+  }
+
+  @OnDisconnect()
+  handleDisconnect(@Client() client: WebSocketClient) {
+    console.log('Client disconnected:', client.id);
+  }
+
+  @Subscribe('message')
+  @OnMessage('message')
+  handleMessage(@Client() client: WebSocketClient, @Data() data: unknown) {
+    console.log('Message received from', client.id, ':', data);
+    // Handle message logic here
+  }
+}
+`;
+class WebSocketGatewayGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'gateway';
+    }
+    getDefaultTemplate() {
+        return WEBSOCKET_GATEWAY_TEMPLATE;
+    }
+}
+function generateWebSocketGateway(program) {
+    program
+        .command('gateway <name>')
+        .description('Generate a new WebSocket gateway')
+        .alias('ws')
+        .option('-p, --path <path>', 'Path where the gateway should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new WebSocketGatewayGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    });
+}

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

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

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

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const commander_1 = require("commander");
+const generate_websocket_gateway_1 = require("./generate-websocket-gateway");
+jest.mock('fs');
+describe('generateWebSocketGateway', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should register the gateway command with alias', () => {
+        (0, generate_websocket_gateway_1.generateWebSocketGateway)(program);
+        const cmd = program.commands.find(c => c.name() === 'gateway');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('ws');
+    });
+    it('should generate a gateway file with correct suffix', async () => {
+        (0, generate_websocket_gateway_1.generateWebSocketGateway)(program);
+        await program.parseAsync(['node', 'test', 'gateway', 'chat']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('chat.gateway.ts'), expect.stringContaining('ChatGateway'));
+    });
+    it('should import from @hazeljs/websocket', async () => {
+        (0, generate_websocket_gateway_1.generateWebSocketGateway)(program);
+        await program.parseAsync(['node', 'test', 'gateway', 'chat']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/websocket'");
+        expect(writtenContent).toContain('@Realtime');
+    });
+});

package/dist/commands/info.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function infoCommand(program: Command): void;

package/dist/commands/info.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.infoCommand = infoCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+function infoCommand(program) {
+    program
+        .command('info')
+        .description('Display information about the current HazelJS project')
+        .action(() => {
+        try {
+            const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+            if (!fs_1.default.existsSync(packageJsonPath)) {
+                console.log(chalk_1.default.yellow('⚠ No package.json found in current directory'));
+                console.log(chalk_1.default.gray('This does not appear to be a Node.js project'));
+                return;
+            }
+            const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+            console.log(chalk_1.default.bold.blue('\n📦 Project Information\n'));
+            // Basic info
+            console.log(chalk_1.default.bold('Name:'), packageJson.name || 'N/A');
+            console.log(chalk_1.default.bold('Version:'), packageJson.version || 'N/A');
+            console.log(chalk_1.default.bold('Description:'), packageJson.description || 'N/A');
+            // HazelJS packages
+            const hazelPackages = [];
+            const allDeps = {
+                ...packageJson.dependencies,
+                ...packageJson.devDependencies,
+            };
+            Object.keys(allDeps).forEach((dep) => {
+                if (dep.startsWith('@hazeljs/')) {
+                    hazelPackages.push(`${dep}@${allDeps[dep]}`);
+                }
+            });
+            if (hazelPackages.length > 0) {
+                console.log(chalk_1.default.bold('\n🔧 HazelJS Packages:\n'));
+                hazelPackages.forEach((pkg) => {
+                    console.log(chalk_1.default.green('  ✓'), pkg);
+                });
+            }
+            else {
+                console.log(chalk_1.default.yellow('\n⚠ No HazelJS packages found'));
+                console.log(chalk_1.default.gray('Install HazelJS packages with: npm install @hazeljs/core'));
+            }
+            // Project structure
+            console.log(chalk_1.default.bold('\n📁 Project Structure:\n'));
+            const srcPath = path_1.default.join(process.cwd(), 'src');
+            if (fs_1.default.existsSync(srcPath)) {
+                const items = fs_1.default.readdirSync(srcPath);
+                items.forEach((item) => {
+                    const itemPath = path_1.default.join(srcPath, item);
+                    const stat = fs_1.default.statSync(itemPath);
+                    const icon = stat.isDirectory() ? '📁' : '📄';
+                    console.log(`  ${icon} ${item}`);
+                });
+            }
+            else {
+                console.log(chalk_1.default.gray('  No src directory found'));
+            }
+            // Environment
+            console.log(chalk_1.default.bold('\n🌍 Environment:\n'));
+            console.log(chalk_1.default.bold('Node:'), process.version);
+            console.log(chalk_1.default.bold('Platform:'), process.platform);
+            console.log(chalk_1.default.bold('Architecture:'), process.arch);
+            // Config files
+            console.log(chalk_1.default.bold('\n⚙️  Configuration Files:\n'));
+            const configFiles = [
+                'tsconfig.json',
+                '.env',
+                '.env.example',
+                '.eslintrc.js',
+                '.prettierrc',
+                'jest.config.js',
+            ];
+            configFiles.forEach((file) => {
+                const exists = fs_1.default.existsSync(path_1.default.join(process.cwd(), file));
+                const icon = exists ? chalk_1.default.green('✓') : chalk_1.default.gray('✗');
+                console.log(`  ${icon} ${file}`);
+            });
+            console.log('');
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error reading project information:'), error);
+            process.exit(1);
+        }
+    });
+}

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function pdfToAudioCommand(program: Command): void;

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

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pdfToAudioCommand = pdfToAudioCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const form_data_1 = __importDefault(require("form-data"));
+const DEFAULT_API_URL = process.env.HAZEL_API_URL || 'http://localhost:3000';
+async function submitJob(apiUrl, filePath, options) {
+    const formData = new form_data_1.default();
+    formData.append('file', fs_1.default.createReadStream(filePath), path_1.default.basename(filePath));
+    if (options.voice)
+        formData.append('voice', options.voice);
+    if (options.includeSummary === false)
+        formData.append('includeSummary', 'false');
+    if (options.summaryOnly === true)
+        formData.append('summaryOnly', 'true');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const res = await fetch(`${apiUrl}/api/pdf-to-audio/convert`, {
+        method: 'POST',
+        body: formData,
+        headers: formData.getHeaders(),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Submit failed (${res.status}): ${text}`);
+    }
+    const json = (await res.json());
+    if (!json.jobId)
+        throw new Error('No jobId in response');
+    return json.jobId;
+}
+async function getStatus(apiUrl, jobId) {
+    const res = await fetch(`${apiUrl}/api/pdf-to-audio/status/${encodeURIComponent(jobId)}`);
+    if (!res.ok) {
+        if (res.status === 404)
+            return null;
+        throw new Error(`Status failed (${res.status}): ${await res.text()}`);
+    }
+    return (await res.json());
+}
+async function downloadAudio(apiUrl, jobId) {
+    const res = await fetch(`${apiUrl}/api/pdf-to-audio/download/${encodeURIComponent(jobId)}`);
+    if (!res.ok)
+        throw new Error(`Download failed (${res.status}): ${await res.text()}`);
+    const arrayBuffer = await res.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+}
+function pdfToAudioCommand(program) {
+    const pdfToAudio = program
+        .command('pdf-to-audio')
+        .description('Convert PDF to audio via async job (submit, poll status, download)');
+    pdfToAudio
+        .command('convert <file.pdf>')
+        .description('Submit PDF for conversion, returns job ID')
+        .option('-o, --output <path>', 'Output MP3 path (used with --wait)')
+        .option('--voice <name>', 'TTS voice (alloy, echo, fable, onyx, nova, shimmer, ash, sage, coral)', 'alloy')
+        .option('--no-summary', 'Skip AI-generated document summary')
+        .option('--summary-only', 'Output only the summary, do not read the full document')
+        .option('--api-url <url>', 'API base URL', DEFAULT_API_URL)
+        .option('--wait', 'Poll until complete and download to --output')
+        .option('--poll-interval <ms>', 'Poll interval in ms', '3000')
+        .action(async (filePath, opts) => {
+        try {
+            if (!filePath?.toLowerCase().endsWith('.pdf')) {
+                console.log(chalk_1.default.red('✗ Please provide a PDF file path'));
+                process.exit(1);
+            }
+            const resolvedPath = path_1.default.isAbsolute(filePath) ? filePath : path_1.default.resolve(process.cwd(), filePath);
+            if (!fs_1.default.existsSync(resolvedPath)) {
+                console.log(chalk_1.default.red(`✗ File not found: ${resolvedPath}`));
+                process.exit(1);
+            }
+            const apiUrl = (opts.apiUrl || DEFAULT_API_URL).replace(/\/$/, '');
+            const includeSummary = opts.summary !== false;
+            const summaryOnly = opts.summaryOnly === true;
+            console.log(chalk_1.default.blue('📄 Submitting PDF for conversion...'));
+            console.log(chalk_1.default.gray(`  API:   ${apiUrl}`));
+            console.log(chalk_1.default.gray(`  File:  ${resolvedPath}`));
+            console.log(chalk_1.default.gray(`  Voice: ${opts.voice || 'alloy'}`));
+            if (summaryOnly)
+                console.log(chalk_1.default.gray(`  Mode:  summary only`));
+            const jobId = await submitJob(apiUrl, resolvedPath, {
+                voice: opts.voice,
+                includeSummary,
+                summaryOnly,
+            });
+            console.log(chalk_1.default.green(`\n✓ Job submitted: ${jobId}`));
+            if (opts.wait) {
+                const outputPath = opts.output ||
+                    path_1.default.join(path_1.default.dirname(resolvedPath), path_1.default.basename(resolvedPath, '.pdf') + '.mp3');
+                const interval = parseInt(opts.pollInterval || '3000', 10);
+                console.log(chalk_1.default.gray(`\nPolling every ${interval}ms...`));
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    const status = await getStatus(apiUrl, jobId);
+                    if (!status) {
+                        console.log(chalk_1.default.red('✗ Job not found or expired'));
+                        process.exit(1);
+                    }
+                    const pct = status.progress ?? 0;
+                    const msg = status.message ? ` - ${status.message}` : '';
+                    process.stdout.write(chalk_1.default.gray(`  Status: ${status.status} ${pct}%${msg}`));
+                    if (status.status === 'completed') {
+                        console.log(chalk_1.default.gray(' done'));
+                        const audio = await downloadAudio(apiUrl, jobId);
+                        fs_1.default.writeFileSync(outputPath, audio);
+                        console.log(chalk_1.default.green(`\n✓ Saved: ${outputPath}`));
+                        return;
+                    }
+                    if (status.status === 'failed') {
+                        console.log(chalk_1.default.red(`\n✗ Conversion failed: ${status.error || 'Unknown error'}`));
+                        process.exit(1);
+                    }
+                    console.log('');
+                    await new Promise((r) => setTimeout(r, interval));
+                }
+            }
+            console.log(chalk_1.default.gray('\nCheck status: hazel pdf-to-audio status ' + jobId + ' --api-url ' + apiUrl));
+            if (opts.output) {
+                console.log(chalk_1.default.gray('Download when ready: hazel pdf-to-audio status ' + jobId + ' -o ' + opts.output + ' --api-url ' + apiUrl));
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('\n✗ Error:'), error instanceof Error ? error.message : error);
+            process.exit(1);
+        }
+    });
+    pdfToAudio
+        .command('status <jobId>')
+        .description('Check job status and optionally download when ready')
+        .option('-o, --output <path>', 'Download audio to this path when completed')
+        .option('--api-url <url>', 'API base URL', DEFAULT_API_URL)
+        .action(async (jobId, opts) => {
+        try {
+            const apiUrl = (opts.apiUrl || DEFAULT_API_URL).replace(/\/$/, '');
+            const status = await getStatus(apiUrl, jobId);
+            if (!status) {
+                console.log(chalk_1.default.red('✗ Job not found or expired'));
+                process.exit(1);
+            }
+            console.log(chalk_1.default.blue('Job status:'));
+            console.log(chalk_1.default.gray(`  ID:       ${status.jobId}`));
+            console.log(chalk_1.default.gray(`  Status:   ${status.status}`));
+            console.log(chalk_1.default.gray(`  Progress: ${status.progress}%`));
+            if (status.message)
+                console.log(chalk_1.default.gray(`  Message:  ${status.message}`));
+            if (status.totalChunks != null) {
+                console.log(chalk_1.default.gray(`  Chunks:   ${status.completedChunks ?? 0}/${status.totalChunks}`));
+            }
+            if (status.error)
+                console.log(chalk_1.default.red(`  Error:    ${status.error}`));
+            if (status.status === 'completed' && opts.output) {
+                const audio = await downloadAudio(apiUrl, jobId);
+                fs_1.default.writeFileSync(opts.output, audio);
+                console.log(chalk_1.default.green(`\n✓ Downloaded: ${opts.output}`));
+            }
+            else if (status.status === 'completed' && !opts.output) {
+                console.log(chalk_1.default.gray('\nDownload: GET ' + apiUrl + '/api/pdf-to-audio/download/' + jobId));
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('\n✗ Error:'), error instanceof Error ? error.message : error);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/start.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function startCommand(program: Command): void;

package/dist/commands/start.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCommand = startCommand;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function startCommand(program) {
+    program
+        .command('start')
+        .description('Start the HazelJS application')
+        .option('-d, --dev', 'Start in development mode')
+        .option('-p, --port <port>', 'Specify port')
+        .action((options) => {
+        try {
+            const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+            if (!fs_1.default.existsSync(packageJsonPath)) {
+                console.log(chalk_1.default.red('✗ No package.json found'));
+                console.log(chalk_1.default.gray('Run this command from your project root'));
+                process.exit(1);
+            }
+            const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+            let command;
+            if (options.dev) {
+                if (!packageJson.scripts?.dev) {
+                    console.log(chalk_1.default.yellow('⚠ No dev script found in package.json'));
+                    console.log(chalk_1.default.gray('\nAdd a dev script to your package.json:'));
+                    console.log(chalk_1.default.gray('  "scripts": {'));
+                    console.log(chalk_1.default.gray('    "dev": "ts-node-dev --respawn src/index.ts"'));
+                    console.log(chalk_1.default.gray('  }'));
+                    process.exit(1);
+                }
+                command = 'npm run dev';
+                console.log(chalk_1.default.blue('🚀 Starting in development mode...\n'));
+            }
+            else {
+                if (!packageJson.scripts?.start) {
+                    console.log(chalk_1.default.yellow('⚠ No start script found in package.json'));
+                    console.log(chalk_1.default.gray('\nAdd a start script to your package.json:'));
+                    console.log(chalk_1.default.gray('  "scripts": {'));
+                    console.log(chalk_1.default.gray('    "start": "node dist/index.js"'));
+                    console.log(chalk_1.default.gray('  }'));
+                    process.exit(1);
+                }
+                command = 'npm start';
+                console.log(chalk_1.default.blue('🚀 Starting application...\n'));
+            }
+            if (options.port) {
+                process.env.PORT = options.port;
+            }
+            (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+        }
+        catch {
+            console.error(chalk_1.default.red('\n✗ Failed to start application'));
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/test.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function testCommand(program: Command): void;

package/dist/commands/test.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testCommand = testCommand;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function testCommand(program) {
+    program
+        .command('test [pattern]')
+        .description('Run tests')
+        .option('-w, --watch', 'Watch mode')
+        .option('-c, --coverage', 'Generate coverage report')
+        .option('--ci', 'Run in CI mode')
+        .action((pattern, options) => {
+        try {
+            const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+            if (!fs_1.default.existsSync(packageJsonPath)) {
+                console.log(chalk_1.default.red('✗ No package.json found'));
+                console.log(chalk_1.default.gray('Run this command from your project root'));
+                process.exit(1);
+            }
+            const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+            if (!packageJson.scripts?.test) {
+                console.log(chalk_1.default.yellow('⚠ No test script found in package.json'));
+                console.log(chalk_1.default.gray('\nAdd a test script to your package.json:'));
+                console.log(chalk_1.default.gray('  "scripts": {'));
+                console.log(chalk_1.default.gray('    "test": "jest"'));
+                console.log(chalk_1.default.gray('  }'));
+                process.exit(1);
+            }
+            console.log(chalk_1.default.blue('🧪 Running tests...\n'));
+            let command = 'npm test';
+            const args = [];
+            if (pattern) {
+                args.push(pattern);
+            }
+            if (options?.watch) {
+                args.push('--watch');
+            }
+            if (options?.coverage) {
+                args.push('--coverage');
+            }
+            if (options?.ci) {
+                command = packageJson.scripts['test:ci'] ? 'npm run test:ci' : 'npm test -- --ci';
+            }
+            if (args.length > 0 && !options?.ci) {
+                command += ' -- ' + args.join(' ');
+            }
+            (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+            if (!options?.watch) {
+                console.log(chalk_1.default.green('\n✓ Tests completed'));
+            }
+        }
+        catch {
+            console.error(chalk_1.default.red('\n✗ Tests failed'));
+            process.exit(1);
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const generate_module_1 = require("./commands/generate-module");
+const generate_app_1 = require("./commands/generate-app");
+const generate_controller_1 = require("./commands/generate-controller");
+const generate_service_1 = require("./commands/generate-service");
+const generate_dto_1 = require("./commands/generate-dto");
+const generate_guard_1 = require("./commands/generate-guard");
+const generate_interceptor_1 = require("./commands/generate-interceptor");
+const generate_websocket_gateway_1 = require("./commands/generate-websocket-gateway");
+const generate_exception_filter_1 = require("./commands/generate-exception-filter");
+const generate_pipe_1 = require("./commands/generate-pipe");
+const generate_repository_1 = require("./commands/generate-repository");
+const generate_ai_service_1 = require("./commands/generate-ai-service");
+const generate_agent_1 = require("./commands/generate-agent");
+const generate_serverless_handler_1 = require("./commands/generate-serverless-handler");
+const generate_crud_1 = require("./commands/generate-crud");
+const generate_middleware_1 = require("./commands/generate-middleware");
+const generate_auth_1 = require("./commands/generate-auth");
+const generate_config_1 = require("./commands/generate-config");
+const generate_cache_1 = require("./commands/generate-cache");
+const generate_cron_1 = require("./commands/generate-cron");
+const generate_rag_1 = require("./commands/generate-rag");
+const generate_discovery_1 = require("./commands/generate-discovery");
+const info_1 = require("./commands/info");
+const add_1 = require("./commands/add");
+const build_1 = require("./commands/build");
+const pdf_to_audio_1 = require("./commands/pdf-to-audio");
+const start_1 = require("./commands/start");
+const test_1 = require("./commands/test");
+const program = new commander_1.Command();
+program
+    .name('hazel')
+    .description('CLI for generating HazelJS components and applications')
+    .version('0.2.0');
+// New app command
+(0, generate_app_1.generateApp)(program);
+// Utility commands
+(0, info_1.infoCommand)(program);
+(0, add_1.addCommand)(program);
+(0, build_1.buildCommand)(program);
+(0, pdf_to_audio_1.pdfToAudioCommand)(program);
+(0, start_1.startCommand)(program);
+(0, test_1.testCommand)(program);
+// Generate command group
+const generateCommand = program
+    .command('generate')
+    .description('Generate HazelJS components')
+    .alias('g');
+// Core components
+(0, generate_controller_1.generateController)(generateCommand);
+(0, generate_service_1.generateService)(generateCommand);
+(0, generate_module_1.generateModule)(generateCommand);
+(0, generate_dto_1.generateDto)(generateCommand);
+(0, generate_guard_1.generateGuard)(generateCommand);
+(0, generate_interceptor_1.generateInterceptor)(generateCommand);
+(0, generate_middleware_1.generateMiddleware)(generateCommand);
+// Advanced generators
+(0, generate_crud_1.generateCrud)(generateCommand);
+(0, generate_auth_1.generateAuth)(generateCommand);
+(0, generate_websocket_gateway_1.generateWebSocketGateway)(generateCommand);
+(0, generate_exception_filter_1.generateExceptionFilter)(generateCommand);
+(0, generate_pipe_1.generatePipe)(generateCommand);
+(0, generate_repository_1.generateRepository)(generateCommand);
+(0, generate_ai_service_1.generateAIService)(generateCommand);
+(0, generate_agent_1.generateAgent)(generateCommand);
+(0, generate_serverless_handler_1.generateServerlessHandler)(generateCommand);
+(0, generate_config_1.generateConfig)(generateCommand);
+(0, generate_cache_1.generateCache)(generateCommand);
+(0, generate_cron_1.generateCron)(generateCommand);
+(0, generate_rag_1.generateRag)(generateCommand);
+(0, generate_discovery_1.generateDiscovery)(generateCommand);
+program.parse(process.argv);

package/dist/index.test.d.ts

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