@hazeljs/cli 0.2.0-beta.1 → 0.2.0-beta.14

package/@template/.eslintrc.js

@@ -0,0 +1,36 @@
+module.exports = {
+  root: true,
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    project: './tsconfig.json',
+  },
+  plugins: ['@typescript-eslint', 'prettier'],
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended',
+  ],
+  env: {
+    node: true,
+    es6: true,
+    jest: true,
+  },
+  rules: {
+    '@typescript-eslint/explicit-function-return-type': 'error',
+    '@typescript-eslint/no-explicit-any': 'error',
+    '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+    'no-console': ['error', { allow: ['warn', 'error'] }],
+    'prettier/prettier': 'error',
+  },
+  overrides: [
+    {
+      files: ['**/*.test.ts'],
+      rules: {
+        '@typescript-eslint/no-explicit-any': 'off',
+        'no-console': 'off',
+      },
+    },
+  ],
+}; 

package/@template/.lintstagedrc

@@ -0,0 +1,6 @@
+{
+  "src/**/*.ts": [
+    "prettier --write",
+    "eslint --fix"
+  ]
+} 

package/@template/jest.config.js

@@ -0,0 +1,28 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/*.test.ts'],
+  transform: {
+    '^.+\\.tsx?$': 'ts-jest',
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/**/*.test.ts',
+    '!src/**/__tests__/**'
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 30,
+      functions: 30,
+      lines: 30,
+      statements: 30
+    }
+  },
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'clover'],
+  verbose: true,
+}; 

package/@template/jest.setup.js

@@ -0,0 +1,81 @@
+const winston = require('winston');
+
+// Create a custom logger for tests
+const logger = winston.createLogger({
+  level: 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.colorize(),
+    winston.format.printf(({ level, message, timestamp }) => {
+      const now = new Date();
+      return `[${now.toLocaleDateString()} ${now.toLocaleTimeString()}] ${level}: ${message}`;
+    })
+  ),
+  transports: [
+    new winston.transports.Console()
+  ]
+});
+
+// Add custom matchers
+expect.extend({
+  toBeWithinRange(received, floor, ceiling) {
+    const pass = received >= floor && received <= ceiling;
+    if (pass) {
+      return {
+        message: () =>
+          `expected ${received} not to be within range ${floor} - ${ceiling}`,
+        pass: true,
+      };
+    } else {
+      return {
+        message: () =>
+          `expected ${received} to be within range ${floor} - ${ceiling}`,
+        pass: false,
+      };
+    }
+  },
+});
+
+// Add custom test utilities
+global.testUtils = {
+  async waitFor(condition, timeout = 5000) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      if (await condition()) {
+        return true;
+      }
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    throw new Error(`Condition not met within ${timeout}ms`);
+  },
+};
+// Add test lifecycle hooks
+beforeAll(() => {
+  const now = new Date();
+  logger.info('\n' + '='.repeat(80));
+  logger.info(`Test Suite Started at: ${now.toLocaleString()}`);
+  logger.info(`Date: ${now.toLocaleDateString()}`);
+  logger.info(`Time: ${now.toLocaleTimeString()}`);
+  logger.info('='.repeat(80) + '\n');
+  logger.info('🚀 Starting test suite...');
+});
+
+afterAll(() => {
+  const now = new Date();
+  logger.info('\n' + '='.repeat(80));
+  logger.info(`Test Suite Completed at: ${now.toLocaleString()}`);
+  logger.info(`Date: ${now.toLocaleDateString()}`);
+  logger.info(`Time: ${now.toLocaleTimeString()}`);
+  logger.info('='.repeat(80) + '\n');
+  logger.info('✨ Test suite completed!');
+});
+
+beforeEach(() => {
+  const now = new Date();
+  logger.info(`\n[${now.toLocaleTimeString()}] 📝 Running test...`);
+});
+
+afterEach(() => {
+  const now = new Date();
+  logger.info(`[${now.toLocaleTimeString()}] ✅ Test completed!`);
+}); 

package/@template/package.json

@@ -1,48 +1,30 @@
 {
-  "name": "hazeljs-example",
-  "version": "1.0.0",
-  "description": "Example application using HazelJS",
+  "name": "hazeljs-app",
+  "version": "0.1.0",
+  "description": "A HazelJS application",
   "main": "dist/index.js",
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "ts-node-dev --respawn --transpile-only src/index.ts",
     "test": "jest",
-    "test:ci": "jest --coverage --coverageReporters=text --coverageReporters=lcov --coverageReporters=clover --no-coverage-threshold",
-    "lint": "eslint \"src/**/*.ts\" --max-warnings 0",
-    "lint:fix": "eslint \"src/**/*.ts\" --fix --max-warnings 0",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
     "format": "prettier --write \"src/**/*.ts\""
   },
   "dependencies": {
-    "@hazeljs/core": "file:..",
-    "bcryptjs": "^2.4.3",
-    "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.1",
-    "dotenv": "^16.4.5",
-    "jsonwebtoken": "^9.0.2",
-    "reflect-metadata": "^0.2.1",
-    "winston": "^3.12.0"
+    "@hazeljs/core": "^0.2.0",
+    "reflect-metadata": "^0.2.2"
   },
   "devDependencies": {
-    "@types/axios": "^0.9.36",
-    "@types/bcryptjs": "^2.4.6",
-    "@types/express": "^4.17.21",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.3",
+    "ts-node-dev": "^2.0.0",
     "@types/jest": "^29.5.12",
-    "@types/jsonwebtoken": "^9.0.6",
-    "@types/node": "^20.11.24",
-    "@types/swagger-ui-express": "^4.1.6",
-    "@typescript-eslint/eslint-plugin": "^7.0.0",
-    "@typescript-eslint/parser": "^7.0.0",
-    "axios": "^1.9.0",
-    "eslint": "^8.0.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-jest": "^27.0.0",
-    "eslint-plugin-prettier": "^5.0.0",
     "jest": "^29.7.0",
-    "prettier": "^3.0.0",
     "ts-jest": "^29.1.2",
-    "ts-node": "^10.9.2",
-    "ts-node-dev": "^2.0.0",
-    "typescript": "^5.3.3"
-  }
+    "prettier": "^3.2.5"
+  },
+  "author": "",
+  "license": "MIT"
 }

package/@template/src/hello.controller.ts

@@ -1,9 +1,9 @@
-import { Get, Controller } from '@hazeljs/core';
+import { Controller, Get } from '@hazeljs/core';
 
 @Controller('/hello')
 export class HelloController {
   @Get()
-  hello(): Promise<string> {
-    return Promise.resolve('Hello, World!');
+  hello() {
+    return { message: 'Hello from HazelJS!' };
   }
 }

package/@template/src/index.ts

@@ -1,10 +1,18 @@
-// Create a simple HTTP server
+import 'reflect-metadata';
 import { HazelApp } from '@hazeljs/core';
 import { AppModule } from './app.module';
 
 async function bootstrap(): Promise<void> {
   const app = new HazelApp(AppModule);
-  await app.listen(3000);
+
+  // Enable CORS
+  app.enableCors({
+    origin: '*',
+    methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+  });
+
+  const port = parseInt(process.env.PORT || '3000', 10);
+  await app.listen(port);
 }
 
 bootstrap();

package/@template/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "module": "commonjs",
+    "lib": ["ES2020", "DOM"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "..",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": false,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "resolveJsonModule": true,
+    "removeComments": true,
+    "sourceMap": true,
+    "baseUrl": "./",
+    "incremental": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "noFallthroughCasesInSwitch": false,
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+} 

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 HazelJS Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/commands/add.js

@@ -8,17 +8,54 @@ 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',
+    ai: {
+        npm: '@hazeljs/ai',
+        hint: 'import { AIModule } from "@hazeljs/ai";',
+    },
+    agent: {
+        npm: '@hazeljs/agent',
+        hint: 'import { AgentModule } from "@hazeljs/agent";',
+    },
+    auth: {
+        npm: '@hazeljs/auth',
+        hint: 'import { JwtModule } from "@hazeljs/auth";\n  // JwtModule.forRoot({ secret: "your-secret", expiresIn: "1d" })',
+    },
+    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";',
+    },
+    discovery: {
+        npm: '@hazeljs/discovery',
+        hint: 'import { ServiceRegistry, DiscoveryClient } from "@hazeljs/discovery";',
+    },
+    prisma: {
+        npm: '@hazeljs/prisma',
+        hint: 'import { PrismaModule } from "@hazeljs/prisma";',
+    },
+    rag: {
+        npm: '@hazeljs/rag',
+        hint: 'import { RAGPipeline } from "@hazeljs/rag";',
+    },
+    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
@@ -36,50 +73,31 @@ function addCommand(program) {
                         name: 'package',
                         message: 'Which HazelJS package would you like to add?',
                         choices: Object.keys(HAZEL_PACKAGES).map((key) => ({
-                            name: `${key} - ${HAZEL_PACKAGES[key]}`,
+                            name: `${key} - ${HAZEL_PACKAGES[key].npm}`,
                             value: key,
                         })),
                     },
                 ]);
                 selectedPackage = pkg;
             }
-            // Get the full package name
-            const fullPackageName = HAZEL_PACKAGES[selectedPackage];
-            if (!fullPackageName) {
+            // 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]}`));
+                    console.log(chalk_1.default.gray(`  - ${key}: ${HAZEL_PACKAGES[key].npm}`));
                 });
                 return;
             }
-            console.log(chalk_1.default.blue(`\n📦 Installing ${fullPackageName}...`));
+            console.log(chalk_1.default.blue(`\n\uD83D\uDCE6 Installing ${pkgInfo.npm}...`));
             const devFlag = options?.dev ? '--save-dev' : '';
-            const command = `npm install ${fullPackageName} ${devFlag}`.trim();
+            const command = `npm install ${pkgInfo.npm} ${devFlag}`.trim();
             (0, child_process_1.execSync)(command, { stdio: 'inherit' });
-            console.log(chalk_1.default.green(`\n✓ Successfully installed ${fullPackageName}`));
+            console.log(chalk_1.default.green(`\n\u2713 Successfully installed ${pkgInfo.npm}`));
             // 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('\nUsage:'));
+            console.log(chalk_1.default.gray(`  ${pkgInfo.hint}`));
             console.log(chalk_1.default.gray(`\nDocumentation: https://hazeljs.com/docs/packages/${selectedPackage}`));
         }
         catch (error) {

package/dist/commands/generate-agent.js

@@ -32,6 +32,10 @@ export class {{className}}Agent {
 }
 `;
 class AgentGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'agent';
+    }
     getDefaultTemplate() {
         return AGENT_TEMPLATE;
     }
@@ -41,16 +45,14 @@ function generateAgent(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();
-        const generatorOptions = {
+        await generator.generate({
             name,
             path: options.path,
-            data: {
-                description: `A ${name} agent`,
-            },
-        };
-        const finalOptions = await generator.promptForOptions(generatorOptions);
-        await generator.generate(finalOptions);
+            dryRun: options.dryRun,
+            data: { description: `A ${name} agent` },
+        });
     });
 }

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

@@ -3,8 +3,7 @@ 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';
+import { AIService, AIFunction, AIPrompt } from '@hazeljs/ai';
 
 @Injectable()
 export class {{className}}AIService {
@@ -15,7 +14,7 @@ export class {{className}}AIService {
     model: 'gpt-4',
     streaming: false,
   })
-  async {{fileName}}Task(@AIPrompt() prompt: string): Promise<unknown> {
+  async {{camelName}}Task(@AIPrompt() prompt: string): Promise<unknown> {
     const result = await this.aiService.complete({
       provider: 'openai',
       model: 'gpt-4',
@@ -27,6 +26,10 @@ export class {{className}}AIService {
 }
 `;
 class AIServiceGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'ai-service';
+    }
     getDefaultTemplate() {
         return AI_SERVICE_TEMPLATE;
     }
@@ -37,13 +40,9 @@ function generateAIService(program) {
         .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();
-        const generatorOptions = {
-            name,
-            path: options.path,
-        };
-        const finalOptions = await generator.promptForOptions(generatorOptions);
-        await generator.generate(finalOptions);
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
     });
 }