@hazeljs/cli 0.2.0-alpha.1

package/dist/commands/add.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommand = addCommand;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const HAZEL_PACKAGES = {
+    ai: {
+        npm: '@hazeljs/ai',
+        hint: 'import { AIModule } from "@hazeljs/ai";',
+    },
+    agent: {
+        npm: '@hazeljs/agent',
+        hint: 'import { AgentModule } from "@hazeljs/agent";',
+    },
+    audit: {
+        npm: '@hazeljs/audit',
+        hint: 'import { AuditModule, ConsoleAuditTransport } from "@hazeljs/audit";\n  // AuditModule.forRoot({ transports: [new ConsoleAuditTransport()] })',
+    },
+    auth: {
+        npm: '@hazeljs/auth',
+        hint: 'import { JwtModule } from "@hazeljs/auth";\n  // JwtModule.forRoot({ secret: "your-secret", expiresIn: "1d" })',
+    },
+    oauth: {
+        npm: '@hazeljs/oauth',
+        hint: 'import { OAuthModule } from "@hazeljs/oauth";\n  // OAuthModule.forRoot({ providers: { google: {...}, microsoft: {...}, github: {...} } })',
+    },
+    cache: {
+        npm: '@hazeljs/cache',
+        hint: 'import { CacheModule } from "@hazeljs/cache";',
+    },
+    config: {
+        npm: '@hazeljs/config',
+        hint: 'import { ConfigModule } from "@hazeljs/config";\n  // ConfigModule.forRoot({ envFilePath: ".env" })',
+    },
+    cron: {
+        npm: '@hazeljs/cron',
+        hint: 'import { CronModule } from "@hazeljs/cron";',
+    },
+    data: {
+        npm: '@hazeljs/data',
+        hint: 'import { DataModule } from "@hazeljs/data";',
+    },
+    discovery: {
+        npm: '@hazeljs/discovery',
+        hint: 'import { ServiceRegistry, DiscoveryClient } from "@hazeljs/discovery";',
+    },
+    'event-emitter': {
+        npm: '@hazeljs/event-emitter',
+        hint: 'import { EventEmitterModule } from "@hazeljs/event-emitter";',
+    },
+    gateway: {
+        npm: '@hazeljs/gateway',
+        hint: 'import { GatewayModule } from "@hazeljs/gateway";',
+    },
+    guardrails: {
+        npm: '@hazeljs/guardrails',
+        hint: 'import { GuardrailsModule } from "@hazeljs/guardrails";\n  // GuardrailsModule.forRoot({ redactPIIByDefault: true })',
+    },
+    graphql: {
+        npm: '@hazeljs/graphql',
+        hint: 'import { GraphQLModule } from "@hazeljs/graphql";',
+    },
+    grpc: {
+        npm: '@hazeljs/grpc',
+        hint: 'import { GrpcModule } from "@hazeljs/grpc";',
+    },
+    kafka: {
+        npm: '@hazeljs/kafka',
+        hint: 'import { KafkaModule } from "@hazeljs/kafka";',
+    },
+    messaging: {
+        npm: '@hazeljs/messaging',
+        hint: 'import { MessagingModule } from "@hazeljs/messaging";',
+    },
+    mcp: {
+        npm: '@hazeljs/mcp',
+        hint: 'import { createMcpServer } from "@hazeljs/mcp";\n  // createMcpServer({ name, version, toolRegistry }).listenStdio();',
+    },
+    ml: {
+        npm: '@hazeljs/ml',
+        hint: 'import { MLModule } from "@hazeljs/ml";',
+    },
+    prompts: {
+        npm: '@hazeljs/prompts',
+        hint: 'import { PromptTemplate, PromptRegistry } from "@hazeljs/prompts";',
+    },
+    prisma: {
+        npm: '@hazeljs/prisma',
+        hint: 'import { PrismaModule } from "@hazeljs/prisma";',
+    },
+    typeorm: {
+        npm: '@hazeljs/typeorm',
+        hint: 'import { TypeOrmModule } from "@hazeljs/typeorm";',
+    },
+    queue: {
+        npm: '@hazeljs/queue',
+        hint: 'import { QueueModule } from "@hazeljs/queue";',
+    },
+    rag: {
+        npm: '@hazeljs/rag',
+        hint: 'import { RAGPipeline } from "@hazeljs/rag";',
+    },
+    resilience: {
+        npm: '@hazeljs/resilience',
+        hint: 'import { CircuitBreaker, WithRetry, WithTimeout } from "@hazeljs/resilience";',
+    },
+    'pdf-to-audio': {
+        npm: '@hazeljs/pdf-to-audio',
+        hint: 'import { PdfToAudioModule } from "@hazeljs/pdf-to-audio";\n  // PdfToAudioModule converts PDFs to audio via TTS',
+    },
+    serverless: {
+        npm: '@hazeljs/serverless',
+        hint: 'import { createLambdaHandler } from "@hazeljs/serverless";',
+    },
+    swagger: {
+        npm: '@hazeljs/swagger',
+        hint: 'import { SwaggerModule } from "@hazeljs/swagger";',
+    },
+    websocket: {
+        npm: '@hazeljs/websocket',
+        hint: 'import { WebSocketModule } from "@hazeljs/websocket";',
+    },
+};
+function addCommand(program) {
+    program
+        .command('add [package]')
+        .description('Add a HazelJS package to your project')
+        .option('--dev', 'Install as dev dependency')
+        .action(async (packageName, options) => {
+        try {
+            let selectedPackage = packageName;
+            // If no package specified, show interactive selection
+            if (!selectedPackage) {
+                const { package: pkg } = await inquirer_1.default.prompt([
+                    {
+                        type: 'list',
+                        name: 'package',
+                        message: 'Which HazelJS package would you like to add?',
+                        choices: Object.keys(HAZEL_PACKAGES).map((key) => ({
+                            name: `${key} - ${HAZEL_PACKAGES[key].npm}`,
+                            value: key,
+                        })),
+                    },
+                ]);
+                selectedPackage = pkg;
+            }
+            // Get the package info
+            const pkgInfo = HAZEL_PACKAGES[selectedPackage];
+            if (!pkgInfo) {
+                console.log(chalk_1.default.yellow(`Unknown package: ${selectedPackage}`));
+                console.log(chalk_1.default.gray('\nAvailable packages:'));
+                Object.keys(HAZEL_PACKAGES).forEach((key) => {
+                    console.log(chalk_1.default.gray(`  - ${key}: ${HAZEL_PACKAGES[key].npm}`));
+                });
+                return;
+            }
+            console.log(chalk_1.default.blue(`\n\uD83D\uDCE6 Installing ${pkgInfo.npm}...`));
+            const devFlag = options?.dev ? '--save-dev' : '';
+            const command = `npm install ${pkgInfo.npm} ${devFlag}`.trim();
+            (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+            console.log(chalk_1.default.green(`\n\u2713 Successfully installed ${pkgInfo.npm}`));
+            // Show usage hints
+            console.log(chalk_1.default.gray('\nUsage:'));
+            console.log(chalk_1.default.gray(`  ${pkgInfo.hint}`));
+            console.log(chalk_1.default.gray(`\nDocumentation: https://hazeljs.com/docs/packages/${selectedPackage}`));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error installing package:'), error);
+            process.exit(1);
+        }
+    });
+}

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

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

package/dist/commands/add.test.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const commander_1 = require("commander");
+const add_1 = require("./add");
+jest.mock('child_process');
+jest.mock('inquirer');
+describe('addCommand', () => {
+    const mockExecSync = child_process_1.execSync;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockExecSync.mockImplementation(() => Buffer.from(''));
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should register the add command', () => {
+        (0, add_1.addCommand)(program);
+        const cmd = program.commands.find(c => c.name() === 'add');
+        expect(cmd).toBeDefined();
+    });
+    it('should install a known package', async () => {
+        (0, add_1.addCommand)(program);
+        await program.parseAsync(['node', 'test', 'add', 'auth']);
+        expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('@hazeljs/auth'), expect.objectContaining({ stdio: 'inherit' }));
+    });
+    it('should handle unknown packages gracefully', async () => {
+        const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        (0, add_1.addCommand)(program);
+        await program.parseAsync(['node', 'test', 'add', 'unknown-package']);
+        expect(mockExecSync).not.toHaveBeenCalled();
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown package'));
+        consoleSpy.mockRestore();
+    });
+    it('should include all hazeljs packages', async () => {
+        (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'
+        ];
+        for (const pkg of expectedPackages) {
+            mockExecSync.mockClear();
+            await program.parseAsync(['node', 'test', 'add', pkg]);
+            expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining(`@hazeljs/${pkg}`), expect.any(Object));
+        }
+    });
+});

package/dist/commands/build.d.ts

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

package/dist/commands/build.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCommand = buildCommand;
+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 buildCommand(program) {
+    program
+        .command('build')
+        .description('Build the HazelJS project')
+        .option('-w, --watch', 'Watch mode')
+        .option('-p, --production', 'Production build')
+        .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'));
+            if (!packageJson.scripts?.build) {
+                console.log(chalk_1.default.yellow('⚠ No build script found in package.json'));
+                console.log(chalk_1.default.gray('\nAdd a build script to your package.json:'));
+                console.log(chalk_1.default.gray('  "scripts": {'));
+                console.log(chalk_1.default.gray('    "build": "tsc"'));
+                console.log(chalk_1.default.gray('  }'));
+                process.exit(1);
+            }
+            console.log(chalk_1.default.blue('🔨 Building project...\n'));
+            let command = 'npm run build';
+            if (options.watch) {
+                command = 'npm run build -- --watch';
+            }
+            if (options.production) {
+                process.env.NODE_ENV = 'production';
+            }
+            (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+            if (!options.watch) {
+                console.log(chalk_1.default.green('\n✓ Build completed successfully'));
+            }
+        }
+        catch {
+            console.error(chalk_1.default.red('\n✗ Build failed'));
+            process.exit(1);
+        }
+    });
+}

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

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

package/dist/commands/generate-agent.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAgent = generateAgent;
+const generator_1 = require("../utils/generator");
+const AGENT_TEMPLATE = `import { Agent, Tool } from '@hazeljs/agent';
+
+@Agent({
+  name: '{{fileName}}',
+  description: '{{description}}',
+  systemPrompt: 'You are a helpful {{className}} agent.',
+  enableMemory: true,
+  enableRAG: true,
+})
+export class {{className}}Agent {
+  @Tool({
+    description: 'Example tool for {{fileName}}',
+    parameters: [
+      {
+        name: 'input',
+        type: 'string',
+        description: 'Input parameter',
+        required: true,
+      },
+    ],
+  })
+  async exampleTool(input: { input: string }): Promise<{ result: string }> {
+    // Implement your tool logic here
+    return {
+      result: \`Processed: \${input.input}\`,
+    };
+  }
+}
+`;
+class AgentGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'agent';
+    }
+    getDefaultTemplate() {
+        return AGENT_TEMPLATE;
+    }
+}
+function generateAgent(program) {
+    program
+        .command('agent <name>')
+        .description('Generate a new AI agent with @Agent and @Tool decorators')
+        .option('-p, --path <path>', 'Path where the agent should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new AgentGenerator();
+        await generator.generate({
+            name,
+            path: options.path,
+            dryRun: options.dryRun,
+            data: { description: `A ${name} agent` },
+        });
+    });
+}

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

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

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

@@ -0,0 +1,36 @@
+"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_agent_1 = require("./generate-agent");
+jest.mock('fs');
+describe('generateAgent', () => {
+    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 generate an agent file with correct suffix', async () => {
+        (0, generate_agent_1.generateAgent)(program);
+        await program.parseAsync(['node', 'test', 'agent', 'research']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('research.agent.ts'), expect.stringContaining('ResearchAgent'));
+    });
+    it('should import from @hazeljs/agent', async () => {
+        (0, generate_agent_1.generateAgent)(program);
+        await program.parseAsync(['node', 'test', 'agent', 'research']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/agent'");
+        expect(writtenContent).toContain('@Agent');
+        expect(writtenContent).toContain('@Tool');
+    });
+});

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

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

package/dist/commands/generate-ai-service.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAIService = generateAIService;
+const generator_1 = require("../utils/generator");
+const AI_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { AIService, AIFunction, AIPrompt } from '@hazeljs/ai';
+
+@Service()
+export class {{className}}AIService {
+  constructor(private readonly aiService: AIService) {}
+
+  @AIFunction({
+    provider: 'openai',
+    model: 'gpt-4',
+    streaming: false,
+  })
+  async {{camelName}}Task(@AIPrompt() prompt: string): Promise<unknown> {
+    const result = await this.aiService.complete({
+      provider: 'openai',
+      model: 'gpt-4',
+      messages: [{ role: 'user', content: prompt }],
+    });
+
+    return result;
+  }
+}
+`;
+class AIServiceGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'ai-service';
+    }
+    getDefaultTemplate() {
+        return AI_SERVICE_TEMPLATE;
+    }
+}
+function generateAIService(program) {
+    program
+        .command('ai-service <name>')
+        .description('Generate a new AI service with decorators')
+        .alias('ai')
+        .option('-p, --path <path>', 'Path where the AI service should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new AIServiceGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    });
+}

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

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

package/dist/commands/generate-ai-service.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_ai_service_1 = require("./generate-ai-service");
+jest.mock('fs');
+describe('generateAIService', () => {
+    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 ai-service command with alias', () => {
+        (0, generate_ai_service_1.generateAIService)(program);
+        const cmd = program.commands.find(c => c.name() === 'ai-service');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('ai');
+    });
+    it('should generate an AI service file with correct suffix', async () => {
+        (0, generate_ai_service_1.generateAIService)(program);
+        await program.parseAsync(['node', 'test', 'ai-service', 'chat']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('chat.ai-service.ts'), expect.stringContaining('ChatAIService'));
+    });
+    it('should import from @hazeljs/ai', async () => {
+        (0, generate_ai_service_1.generateAIService)(program);
+        await program.parseAsync(['node', 'test', 'ai-service', 'chat']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/ai'");
+        expect(writtenContent).toContain('AIFunction');
+    });
+});

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

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