@hazeljs/cli 0.2.0-beta.1

package/src/commands/add.ts

@@ -0,0 +1,101 @@
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import inquirer from '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',
+};
+
+export function addCommand(program: Command) {
+  program
+    .command('add [package]')
+    .description('Add a HazelJS package to your project')
+    .option('--dev', 'Install as dev dependency')
+    .action(async (packageName?: string, options?: { dev?: boolean }) => {
+      try {
+        let selectedPackage = packageName;
+
+        // If no package specified, show interactive selection
+        if (!selectedPackage) {
+          const { package: pkg } = await inquirer.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 as keyof typeof HAZEL_PACKAGES]}`,
+                value: key,
+              })),
+            },
+          ]);
+          selectedPackage = pkg;
+        }
+
+        // Get the full package name
+        const fullPackageName =
+          HAZEL_PACKAGES[selectedPackage as keyof typeof HAZEL_PACKAGES];
+
+        if (!fullPackageName) {
+          console.log(chalk.yellow(`Unknown package: ${selectedPackage}`));
+          console.log(chalk.gray('\nAvailable packages:'));
+          Object.keys(HAZEL_PACKAGES).forEach((key) => {
+            console.log(
+              chalk.gray(`  - ${key}: ${HAZEL_PACKAGES[key as keyof typeof HAZEL_PACKAGES]}`)
+            );
+          });
+          return;
+        }
+
+        console.log(
+          chalk.blue(`\n📦 Installing ${fullPackageName}...`)
+        );
+
+        const devFlag = options?.dev ? '--save-dev' : '';
+        const command = `npm install ${fullPackageName} ${devFlag}`.trim();
+
+        execSync(command, { stdio: 'inherit' });
+
+        console.log(chalk.green(`\n✓ Successfully installed ${fullPackageName}`));
+
+        // Show usage hints
+        console.log(chalk.gray('\nNext steps:'));
+        switch (selectedPackage) {
+          case 'ai':
+            console.log(chalk.gray('  import { AIModule } from "@hazeljs/ai";'));
+            break;
+          case 'auth':
+            console.log(chalk.gray('  import { AuthModule } from "@hazeljs/auth";'));
+            break;
+          case 'cache':
+            console.log(chalk.gray('  import { CacheModule } from "@hazeljs/cache";'));
+            break;
+          case 'prisma':
+            console.log(chalk.gray('  import { PrismaModule } from "@hazeljs/prisma";'));
+            break;
+          case 'swagger':
+            console.log(chalk.gray('  import { SwaggerModule } from "@hazeljs/swagger";'));
+            break;
+          case 'websocket':
+            console.log(chalk.gray('  import { WebSocketModule } from "@hazeljs/websocket";'));
+            break;
+        }
+        console.log(
+          chalk.gray(`\nDocumentation: https://hazeljs.com/docs/packages/${selectedPackage}`)
+        );
+      } catch (error) {
+        console.error(chalk.red('Error installing package:'), error);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/build.ts

@@ -0,0 +1,56 @@
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+
+export function buildCommand(program: Command) {
+  program
+    .command('build')
+    .description('Build the HazelJS project')
+    .option('-w, --watch', 'Watch mode')
+    .option('-p, --production', 'Production build')
+    .action((options: { watch?: boolean; production?: boolean }) => {
+      try {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+        if (!fs.existsSync(packageJsonPath)) {
+          console.log(chalk.red('✗ No package.json found'));
+          console.log(chalk.gray('Run this command from your project root'));
+          process.exit(1);
+        }
+
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+        if (!packageJson.scripts?.build) {
+          console.log(chalk.yellow('⚠ No build script found in package.json'));
+          console.log(chalk.gray('\nAdd a build script to your package.json:'));
+          console.log(chalk.gray('  "scripts": {'));
+          console.log(chalk.gray('    "build": "tsc"'));
+          console.log(chalk.gray('  }'));
+          process.exit(1);
+        }
+
+        console.log(chalk.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';
+        }
+
+        execSync(command, { stdio: 'inherit' });
+
+        if (!options.watch) {
+          console.log(chalk.green('\n✓ Build completed successfully'));
+        }
+      } catch {
+        console.error(chalk.red('\n✗ Build failed'));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/generate-agent.ts

@@ -0,0 +1,58 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../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 {
+  protected getDefaultTemplate(): string {
+    return AGENT_TEMPLATE;
+  }
+}
+
+export function generateAgent(program: Command): void {
+  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: string, options: { path?: string }) => {
+      const generator = new AgentGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+        data: {
+          description: `A ${name} agent`,
+        },
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate(finalOptions);
+    });
+}

package/src/commands/generate-ai-service.ts

@@ -0,0 +1,52 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../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 {
+  protected getDefaultTemplate(): string {
+    return AI_SERVICE_TEMPLATE;
+  }
+}
+
+export function generateAIService(program: Command): void {
+  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: string, options: { path?: string }) => {
+      const generator = new AIServiceGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate(finalOptions);
+    });
+}
+

package/src/commands/generate-app.ts

@@ -0,0 +1,270 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+function copyRecursiveSync(src: string, dest: string) {
+  if (fs.existsSync(src)) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      const srcPath = path.join(src, entry);
+      const destPath = path.join(dest, entry);
+      if (fs.lstatSync(srcPath).isDirectory()) {
+        copyRecursiveSync(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}
+
+function updatePackageJson(destPath: string, appName: string, description: string) {
+  const packageJsonPath = path.join(destPath, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    packageJson.name = appName;
+    packageJson.description = description;
+    packageJson.version = '0.1.0';
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  }
+}
+
+export function generateApp(program: Command) {
+  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: string, options: { dest?: string; skipInstall?: boolean; skipGit?: boolean; interactive?: boolean }) => {
+      try {
+        let projectConfig = {
+          name: appName,
+          description: `A HazelJS application`,
+          author: '',
+          license: 'MIT',
+          packages: [] as string[],
+        };
+
+        // Interactive setup
+        if (options.interactive) {
+          console.log(chalk.blue('\n🚀 Welcome to HazelJS project setup!\n'));
+          
+          const answers = await inquirer.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.join(process.cwd(), options.dest || '.', appName);
+        
+        console.log(chalk.blue('\n📦 Creating new HazelJS project...\n'));
+        console.log(chalk.gray(`Project: ${projectConfig.name}`));
+        console.log(chalk.gray(`Location: ${destPath}\n`));
+
+        // Check if destination exists
+        if (fs.existsSync(destPath)) {
+          console.error(chalk.red(`✗ Destination already exists: ${destPath}`));
+          process.exit(1);
+        }
+
+        // Use local template
+        const templatePath = path.join(__dirname, '../../@template');
+        
+        if (fs.existsSync(templatePath)) {
+          console.log(chalk.blue('📋 Copying template files...'));
+          copyRecursiveSync(templatePath, destPath);
+          
+          // Update package.json
+          updatePackageJson(destPath, projectConfig.name, projectConfig.description);
+          
+          console.log(chalk.green('✓ Template files copied'));
+        } else {
+          console.log(chalk.yellow('⚠ Local template not found, creating basic structure...'));
+          
+          // Create basic structure
+          fs.mkdirSync(destPath, { recursive: true });
+          fs.mkdirSync(path.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.writeFileSync(
+            path.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.writeFileSync(path.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.writeFileSync(
+            path.join(destPath, 'tsconfig.json'),
+            JSON.stringify(tsConfig, null, 2)
+          );
+          
+          console.log(chalk.green('✓ Basic structure created'));
+        }
+
+        // Initialize git
+        if (!options.skipGit) {
+          try {
+            console.log(chalk.blue('\n📝 Initializing git repository...'));
+            execSync('git init', { cwd: destPath, stdio: 'ignore' });
+            
+            // Create .gitignore
+            const gitignore = `node_modules/
+dist/
+.env
+.DS_Store
+coverage/
+*.log
+`;
+            fs.writeFileSync(path.join(destPath, '.gitignore'), gitignore);
+            console.log(chalk.green('✓ Git initialized'));
+          } catch {
+            console.log(chalk.yellow('⚠ Git initialization skipped'));
+          }
+        }
+
+        // Install dependencies
+        if (!options.skipInstall) {
+          console.log(chalk.blue('\n📦 Installing dependencies...\n'));
+          
+          try {
+            execSync('npm install', { cwd: destPath, stdio: 'inherit' });
+            
+            // Install additional packages
+            if (projectConfig.packages.length > 0) {
+              console.log(chalk.blue('\n📦 Installing additional packages...\n'));
+              execSync(`npm install ${projectConfig.packages.join(' ')}`, {
+                cwd: destPath,
+                stdio: 'inherit',
+              });
+            }
+            
+            console.log(chalk.green('\n✓ Dependencies installed'));
+          } catch {
+            console.log(chalk.yellow('\n⚠ Dependency installation failed'));
+            console.log(chalk.gray('You can install them manually with: npm install'));
+          }
+        }
+
+        // Success message
+        console.log(chalk.green.bold('\n✨ Project created successfully!\n'));
+        console.log(chalk.gray('Next steps:'));
+        console.log(chalk.gray(`  cd ${appName}`));
+        if (options.skipInstall) {
+          console.log(chalk.gray('  npm install'));
+        }
+        console.log(chalk.gray('  npm run dev'));
+        console.log(chalk.gray('\nDocumentation: https://hazeljs.com/docs'));
+        console.log(chalk.gray('Discord: https://discord.gg/hazeljs\n'));
+        
+      } catch (error) {
+        console.error(chalk.red('\n✗ Failed to create project:'), error);
+        process.exit(1);
+      }
+    });
+} 

package/src/commands/generate-controller.ts

@@ -0,0 +1,61 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../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 {
+  protected getDefaultTemplate(): string {
+    return CONTROLLER_TEMPLATE;
+  }
+}
+
+export function generateController(program: Command): void {
+  program
+    .command('controller <name>')
+    .description('Generate a new controller')
+    .option('-p, --path <path>', 'Path where the controller should be generated')
+    .action(async (name: string, options: { path?: string }) => {
+      const generator = new ControllerGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate(finalOptions);
+    });
+}