@hazeljs/cli 0.2.0-beta.1

package/dist/commands/add.js

@@ -0,0 +1,90 @@
+"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: '@hazeljs/ai',
+    auth: '@hazeljs/auth',
+    cache: '@hazeljs/cache',
+    config: '@hazeljs/config',
+    cron: '@hazeljs/cron',
+    prisma: '@hazeljs/prisma',
+    rag: '@hazeljs/rag',
+    serverless: '@hazeljs/serverless',
+    swagger: '@hazeljs/swagger',
+    websocket: '@hazeljs/websocket',
+    discovery: '@hazeljs/discovery',
+};
+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]}`,
+                            value: key,
+                        })),
+                    },
+                ]);
+                selectedPackage = pkg;
+            }
+            // Get the full package name
+            const fullPackageName = HAZEL_PACKAGES[selectedPackage];
+            if (!fullPackageName) {
+                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]}`));
+                });
+                return;
+            }
+            console.log(chalk_1.default.blue(`\n📦 Installing ${fullPackageName}...`));
+            const devFlag = options?.dev ? '--save-dev' : '';
+            const command = `npm install ${fullPackageName} ${devFlag}`.trim();
+            (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+            console.log(chalk_1.default.green(`\n✓ Successfully installed ${fullPackageName}`));
+            // Show usage hints
+            console.log(chalk_1.default.gray('\nNext steps:'));
+            switch (selectedPackage) {
+                case 'ai':
+                    console.log(chalk_1.default.gray('  import { AIModule } from "@hazeljs/ai";'));
+                    break;
+                case 'auth':
+                    console.log(chalk_1.default.gray('  import { AuthModule } from "@hazeljs/auth";'));
+                    break;
+                case 'cache':
+                    console.log(chalk_1.default.gray('  import { CacheModule } from "@hazeljs/cache";'));
+                    break;
+                case 'prisma':
+                    console.log(chalk_1.default.gray('  import { PrismaModule } from "@hazeljs/prisma";'));
+                    break;
+                case 'swagger':
+                    console.log(chalk_1.default.gray('  import { SwaggerModule } from "@hazeljs/swagger";'));
+                    break;
+                case 'websocket':
+                    console.log(chalk_1.default.gray('  import { WebSocketModule } from "@hazeljs/websocket";'));
+                    break;
+            }
+            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/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,56 @@
+"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 {
+    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')
+        .action(async (name, options) => {
+        const generator = new AgentGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+            data: {
+                description: `A ${name} agent`,
+            },
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate(finalOptions);
+    });
+}

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,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAIService = generateAIService;
+const generator_1 = require("../utils/generator");
+const AI_SERVICE_TEMPLATE = `import { Injectable } from '@hazeljs/core';
+import { AIService } from '@hazeljs/ai';
+import { AIFunction, AIPrompt } from '@hazeljs/ai';
+
+@Injectable()
+export class {{className}}AIService {
+  constructor(private readonly aiService: AIService) {}
+
+  @AIFunction({
+    provider: 'openai',
+    model: 'gpt-4',
+    streaming: false,
+  })
+  async {{fileName}}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 {
+    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')
+        .action(async (name, options) => {
+        const generator = new AIServiceGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate(finalOptions);
+    });
+}

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

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

package/dist/commands/generate-app.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApp = generateApp;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+function copyRecursiveSync(src, dest) {
+    if (fs_1.default.existsSync(src)) {
+        fs_1.default.mkdirSync(dest, { recursive: true });
+        for (const entry of fs_1.default.readdirSync(src)) {
+            const srcPath = path_1.default.join(src, entry);
+            const destPath = path_1.default.join(dest, entry);
+            if (fs_1.default.lstatSync(srcPath).isDirectory()) {
+                copyRecursiveSync(srcPath, destPath);
+            }
+            else {
+                fs_1.default.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+}
+function updatePackageJson(destPath, appName, description) {
+    const packageJsonPath = path_1.default.join(destPath, 'package.json');
+    if (fs_1.default.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        packageJson.name = appName;
+        packageJson.description = description;
+        packageJson.version = '0.1.0';
+        fs_1.default.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+}
+function generateApp(program) {
+    program
+        .command('new <appName>')
+        .description('Create a new HazelJS application')
+        .option('-d, --dest <destPath>', 'Destination path', '.')
+        .option('--skip-install', 'Skip npm install')
+        .option('--skip-git', 'Skip git initialization')
+        .option('-i, --interactive', 'Interactive setup')
+        .action(async (appName, options) => {
+        try {
+            let projectConfig = {
+                name: appName,
+                description: `A HazelJS application`,
+                author: '',
+                license: 'MIT',
+                packages: [],
+            };
+            // Interactive setup
+            if (options.interactive) {
+                console.log(chalk_1.default.blue('\n🚀 Welcome to HazelJS project setup!\n'));
+                const answers = await inquirer_1.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'description',
+                        message: 'Project description:',
+                        default: projectConfig.description,
+                    },
+                    {
+                        type: 'input',
+                        name: 'author',
+                        message: 'Author:',
+                    },
+                    {
+                        type: 'list',
+                        name: 'license',
+                        message: 'License:',
+                        choices: ['MIT', 'Apache-2.0', 'GPL-3.0', 'BSD-3-Clause', 'ISC'],
+                        default: 'MIT',
+                    },
+                    {
+                        type: 'checkbox',
+                        name: 'packages',
+                        message: 'Select additional HazelJS packages to install:',
+                        choices: [
+                            { name: 'AI Integration (@hazeljs/ai)', value: '@hazeljs/ai' },
+                            { name: 'Authentication (@hazeljs/auth)', value: '@hazeljs/auth' },
+                            { name: 'Caching (@hazeljs/cache)', value: '@hazeljs/cache' },
+                            { name: 'Configuration (@hazeljs/config)', value: '@hazeljs/config' },
+                            { name: 'Cron Jobs (@hazeljs/cron)', value: '@hazeljs/cron' },
+                            { name: 'Prisma ORM (@hazeljs/prisma)', value: '@hazeljs/prisma' },
+                            { name: 'RAG/Vector Search (@hazeljs/rag)', value: '@hazeljs/rag' },
+                            { name: 'Serverless (@hazeljs/serverless)', value: '@hazeljs/serverless' },
+                            { name: 'Swagger/OpenAPI (@hazeljs/swagger)', value: '@hazeljs/swagger' },
+                            { name: 'WebSocket (@hazeljs/websocket)', value: '@hazeljs/websocket' },
+                        ],
+                    },
+                ]);
+                projectConfig = { ...projectConfig, ...answers };
+            }
+            const destPath = path_1.default.join(process.cwd(), options.dest || '.', appName);
+            console.log(chalk_1.default.blue('\n📦 Creating new HazelJS project...\n'));
+            console.log(chalk_1.default.gray(`Project: ${projectConfig.name}`));
+            console.log(chalk_1.default.gray(`Location: ${destPath}\n`));
+            // Check if destination exists
+            if (fs_1.default.existsSync(destPath)) {
+                console.error(chalk_1.default.red(`✗ Destination already exists: ${destPath}`));
+                process.exit(1);
+            }
+            // Use local template
+            const templatePath = path_1.default.join(__dirname, '../../@template');
+            if (fs_1.default.existsSync(templatePath)) {
+                console.log(chalk_1.default.blue('📋 Copying template files...'));
+                copyRecursiveSync(templatePath, destPath);
+                // Update package.json
+                updatePackageJson(destPath, projectConfig.name, projectConfig.description);
+                console.log(chalk_1.default.green('✓ Template files copied'));
+            }
+            else {
+                console.log(chalk_1.default.yellow('⚠ Local template not found, creating basic structure...'));
+                // Create basic structure
+                fs_1.default.mkdirSync(destPath, { recursive: true });
+                fs_1.default.mkdirSync(path_1.default.join(destPath, 'src'), { recursive: true });
+                // Create package.json
+                const packageJson = {
+                    name: projectConfig.name,
+                    version: '0.1.0',
+                    description: projectConfig.description,
+                    main: 'dist/index.js',
+                    scripts: {
+                        build: 'tsc',
+                        start: 'node dist/index.js',
+                        dev: 'ts-node-dev --respawn --transpile-only src/index.ts',
+                        test: 'jest',
+                        lint: 'eslint "src/**/*.ts"',
+                    },
+                    dependencies: {
+                        '@hazeljs/core': '^0.2.0',
+                    },
+                    devDependencies: {
+                        '@types/node': '^20.0.0',
+                        'typescript': '^5.0.0',
+                        'ts-node-dev': '^2.0.0',
+                    },
+                    author: projectConfig.author,
+                    license: projectConfig.license,
+                };
+                fs_1.default.writeFileSync(path_1.default.join(destPath, 'package.json'), JSON.stringify(packageJson, null, 2));
+                // Create basic index.ts
+                const indexContent = `import { HazelApp, HazelModule, Controller, Get } from '@hazeljs/core';
+
+@Controller('/')
+export class AppController {
+  @Get()
+  hello() {
+    return { message: 'Hello from HazelJS!' };
+  }
+}
+
+@HazelModule({
+  controllers: [AppController],
+})
+export class AppModule {}
+
+async function bootstrap() {
+  const app = await HazelApp.create(AppModule);
+  await app.listen(3000);
+  console.log('🚀 Server running on http://localhost:3000');
+}
+
+bootstrap();
+`;
+                fs_1.default.writeFileSync(path_1.default.join(destPath, 'src', 'index.ts'), indexContent);
+                // Create tsconfig.json
+                const tsConfig = {
+                    compilerOptions: {
+                        target: 'ES2020',
+                        module: 'commonjs',
+                        lib: ['ES2020'],
+                        outDir: './dist',
+                        rootDir: './src',
+                        strict: true,
+                        esModuleInterop: true,
+                        skipLibCheck: true,
+                        forceConsistentCasingInFileNames: true,
+                        experimentalDecorators: true,
+                        emitDecoratorMetadata: true,
+                    },
+                    include: ['src/**/*'],
+                    exclude: ['node_modules', 'dist'],
+                };
+                fs_1.default.writeFileSync(path_1.default.join(destPath, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
+                console.log(chalk_1.default.green('✓ Basic structure created'));
+            }
+            // Initialize git
+            if (!options.skipGit) {
+                try {
+                    console.log(chalk_1.default.blue('\n📝 Initializing git repository...'));
+                    (0, child_process_1.execSync)('git init', { cwd: destPath, stdio: 'ignore' });
+                    // Create .gitignore
+                    const gitignore = `node_modules/
+dist/
+.env
+.DS_Store
+coverage/
+*.log
+`;
+                    fs_1.default.writeFileSync(path_1.default.join(destPath, '.gitignore'), gitignore);
+                    console.log(chalk_1.default.green('✓ Git initialized'));
+                }
+                catch {
+                    console.log(chalk_1.default.yellow('⚠ Git initialization skipped'));
+                }
+            }
+            // Install dependencies
+            if (!options.skipInstall) {
+                console.log(chalk_1.default.blue('\n📦 Installing dependencies...\n'));
+                try {
+                    (0, child_process_1.execSync)('npm install', { cwd: destPath, stdio: 'inherit' });
+                    // Install additional packages
+                    if (projectConfig.packages.length > 0) {
+                        console.log(chalk_1.default.blue('\n📦 Installing additional packages...\n'));
+                        (0, child_process_1.execSync)(`npm install ${projectConfig.packages.join(' ')}`, {
+                            cwd: destPath,
+                            stdio: 'inherit',
+                        });
+                    }
+                    console.log(chalk_1.default.green('\n✓ Dependencies installed'));
+                }
+                catch {
+                    console.log(chalk_1.default.yellow('\n⚠ Dependency installation failed'));
+                    console.log(chalk_1.default.gray('You can install them manually with: npm install'));
+                }
+            }
+            // Success message
+            console.log(chalk_1.default.green.bold('\n✨ Project created successfully!\n'));
+            console.log(chalk_1.default.gray('Next steps:'));
+            console.log(chalk_1.default.gray(`  cd ${appName}`));
+            if (options.skipInstall) {
+                console.log(chalk_1.default.gray('  npm install'));
+            }
+            console.log(chalk_1.default.gray('  npm run dev'));
+            console.log(chalk_1.default.gray('\nDocumentation: https://hazeljs.com/docs'));
+            console.log(chalk_1.default.gray('Discord: https://discord.gg/hazeljs\n'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('\n✗ Failed to create project:'), error);
+            process.exit(1);
+        }
+    });
+}

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

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

package/dist/commands/generate-controller.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateController = generateController;
+const generator_1 = require("../utils/generator");
+const CONTROLLER_TEMPLATE = `import { Controller, Get, Post, Body, Param, Delete, Put } from '@hazeljs/core';
+import { {{className}}Service } from './{{fileName}}.service';
+import { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';
+import { Update{{className}}Dto } from './dto/update-{{fileName}}.dto';
+
+@Controller('{{fileName}}')
+export class {{className}}Controller {
+  constructor(private readonly {{fileName}}Service: {{className}}Service) {}
+
+  @Get()
+  findAll() {
+    return this.{{fileName}}Service.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.{{fileName}}Service.findOne(id);
+  }
+
+  @Post()
+  create(@Body(Create{{className}}Dto) create{{className}}Dto: Create{{className}}Dto) {
+    return this.{{fileName}}Service.create(create{{className}}Dto);
+  }
+
+  @Put(':id')
+  update(@Param('id') id: string, @Body(Update{{className}}Dto) update{{className}}Dto: Update{{className}}Dto) {
+    return this.{{fileName}}Service.update(id, update{{className}}Dto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.{{fileName}}Service.remove(id);
+  }
+}
+`;
+class ControllerGenerator extends generator_1.Generator {
+    getDefaultTemplate() {
+        return CONTROLLER_TEMPLATE;
+    }
+}
+function generateController(program) {
+    program
+        .command('controller <name>')
+        .description('Generate a new controller')
+        .option('-p, --path <path>', 'Path where the controller should be generated')
+        .action(async (name, options) => {
+        const generator = new ControllerGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate(finalOptions);
+    });
+}

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

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