@hazeljs/cli 0.6.0 → 0.6.5

package/dist/commands/templates.js

@@ -0,0 +1,387 @@
+"use strict";
+/**
+ * Mustache templates for all simple (single-file) generators.
+ *
+ * Each template uses three standard variables provided by the Generator base class:
+ *   - {{className}}  — PascalCase name (e.g. "Users")
+ *   - {{fileName}}   — kebab-case name (e.g. "users")
+ *   - {{camelName}}  — camelCase name (e.g. "users")
+ *
+ * Some templates accept additional data via `extraData` in SimpleGeneratorConfig:
+ *   - AGENT_TEMPLATE       — {{description}}
+ *   - REPOSITORY_TEMPLATE  — {{modelName}} (defaults to fileName)
+ *
+ * Templates are imported by generate-simple.ts and referenced in the
+ * SIMPLE_GENERATORS config array. To add a new generator, create a template
+ * here and add a config entry in generate-simple.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVERLESS_CLOUD_FUNCTION_TEMPLATE = exports.SERVERLESS_LAMBDA_TEMPLATE = exports.CONFIG_TEMPLATE = exports.DISCOVERY_TEMPLATE = exports.RAG_SERVICE_TEMPLATE = exports.CRON_SERVICE_TEMPLATE = exports.CACHE_SERVICE_TEMPLATE = exports.AGENT_TEMPLATE = exports.AI_SERVICE_TEMPLATE = exports.WEBSOCKET_GATEWAY_TEMPLATE = exports.REPOSITORY_TEMPLATE = exports.EXCEPTION_FILTER_TEMPLATE = exports.PIPE_TEMPLATE = exports.MIDDLEWARE_TEMPLATE = exports.INTERCEPTOR_TEMPLATE = exports.GUARD_TEMPLATE = exports.SERVICE_TEMPLATE = exports.CONTROLLER_TEMPLATE = void 0;
+// ── Core framework generators ────────────────────────────────────────────────
+exports.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 {{camelName}}Service: {{className}}Service) {}
+
+  @Get()
+  findAll() {
+    return this.{{camelName}}Service.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.{{camelName}}Service.findOne(id);
+  }
+
+  @Post()
+  create(@Body(Create{{className}}Dto) createDto: Create{{className}}Dto) {
+    return this.{{camelName}}Service.create(createDto);
+  }
+
+  @Put(':id')
+  update(@Param('id') id: string, @Body(Update{{className}}Dto) updateDto: Update{{className}}Dto) {
+    return this.{{camelName}}Service.update(id, updateDto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.{{camelName}}Service.remove(id);
+  }
+}
+`;
+exports.SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+
+@Service()
+export class {{className}}Service {
+  constructor() {}
+
+  async findAll() {
+    return [];
+  }
+
+  async findOne(id: string) {
+    return { id };
+  }
+
+  async create(createDto: any) {
+    return createDto;
+  }
+
+  async update(id: string, updateDto: any) {
+    return { id, ...updateDto };
+  }
+
+  async remove(id: string) {
+    return { id };
+  }
+}
+`;
+exports.GUARD_TEMPLATE = `import { Injectable, type CanActivate, type ExecutionContext } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Guard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    // Add your guard logic here
+    return true;
+  }
+}
+`;
+exports.INTERCEPTOR_TEMPLATE = `import { Injectable, Interceptor, type ExecutionContext } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Interceptor implements Interceptor {
+  async intercept(context: ExecutionContext, next: () => Promise<unknown>): Promise<unknown> {
+    // Pre-processing logic here (before handler execution)
+    const result = await next();
+    // Post-processing logic here (after handler execution)
+    return result;
+  }
+}
+`;
+exports.MIDDLEWARE_TEMPLATE = `import { Injectable, type MiddlewareHandler, type Request, type Response, type NextFunction } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Middleware implements MiddlewareHandler {
+  use(req: Request, res: Response, next: NextFunction) {
+    // Add your middleware logic here
+    console.log(\`[{{className}}Middleware] \${req.method} \${req.url}\`);
+    
+    // Continue to next middleware
+    next();
+  }
+}
+`;
+exports.PIPE_TEMPLATE = `import { type PipeTransform, type RequestContext } from '@hazeljs/core';
+
+export class {{className}}Pipe implements PipeTransform {
+  transform(value: unknown, context: RequestContext): unknown {
+    // Transform logic here
+    return value;
+  }
+}
+`;
+exports.EXCEPTION_FILTER_TEMPLATE = `import { Catch, type ExceptionFilter, type ArgumentsHost, HttpError, logger } from '@hazeljs/core';
+
+@Catch(HttpError)
+export class {{className}}ExceptionFilter implements ExceptionFilter<HttpError> {
+  catch(exception: HttpError, host: ArgumentsHost): void {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+
+    const status = exception.statusCode || 500;
+    const message = exception.message || 'Internal server error';
+
+    logger.error(\`[\${request.method}] \${request.url} - \${message} (\${status})\`);
+
+    response.status(status).json({
+      statusCode: status,
+      message,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+    });
+  }
+}
+`;
+// ── Package-specific generators ──────────────────────────────────────────────
+exports.REPOSITORY_TEMPLATE = `import { Repository, BaseRepository, PrismaService } from '@hazeljs/prisma';
+
+// @Repository implies @Injectable() — no need for both decorators
+@Repository({ model: '{{modelName}}' })
+export class {{className}}Repository extends BaseRepository<any> {
+  constructor(prisma: PrismaService) {
+    super(prisma, '{{modelName}}');
+  }
+
+  // Add custom repository methods here
+  async findByName(name: string) {
+    return this.findMany({ where: { name } });
+  }
+}
+`;
+exports.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
+  }
+}
+`;
+exports.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;
+  }
+}
+`;
+exports.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}\`,
+    };
+  }
+}
+`;
+exports.CACHE_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { CacheService, Cacheable, CacheEvict } from '@hazeljs/cache';
+
+@Service()
+export class {{className}}CacheService {
+  constructor(private readonly cacheService: CacheService) {}
+
+  @Cacheable({ key: '{{fileName}}:all', ttl: 60 })
+  async findAll() {
+    // This result will be cached for 60 seconds
+    return [];
+  }
+
+  @Cacheable({ key: '{{fileName}}:{{=<% %>=}}#{id}<%={{ }}=%>', ttl: 300 })
+  async findOne(id: string) {
+    // This result will be cached for 5 minutes
+    return { id };
+  }
+
+  @CacheEvict({ key: '{{fileName}}:all' })
+  async create(data: any) {
+    // Creating a new item evicts the list cache
+    return data;
+  }
+
+  async clearAll() {
+    await this.cacheService.clear();
+  }
+}
+`;
+exports.CRON_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { Cron, CronExpression } from '@hazeljs/cron';
+
+@Service()
+export class {{className}}CronService {
+  @Cron(CronExpression.EVERY_MINUTE)
+  handleEveryMinute() {
+    console.log('[{{className}}Cron] Running every minute...');
+    // Add your cron job logic here
+  }
+
+  @Cron('0 0 * * *')  // Every day at midnight
+  handleDaily() {
+    console.log('[{{className}}Cron] Running daily task...');
+    // Add your daily task logic here
+  }
+
+  @Cron(CronExpression.EVERY_HOUR)
+  handleHourly() {
+    console.log('[{{className}}Cron] Running hourly cleanup...');
+    // Add your hourly task logic here
+  }
+}
+`;
+exports.RAG_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { RAGPipeline, MemoryVectorStore } from '@hazeljs/rag';
+
+@Service()
+export class {{className}}RagService {
+  private pipeline: RAGPipeline;
+
+  constructor() {
+    // Initialize with a memory vector store (swap for Pinecone, Qdrant, etc. in production)
+    const vectorStore = new MemoryVectorStore();
+
+    this.pipeline = new RAGPipeline({
+      vectorStore,
+      topK: 5,
+    });
+  }
+
+  async addDocument(content: string, metadata?: Record<string, unknown>) {
+    // Add a document to the vector store for retrieval
+    await this.pipeline.addDocument({
+      content,
+      metadata: metadata || {},
+    });
+  }
+
+  async query(question: string) {
+    // Retrieve relevant documents and generate a response
+    const results = await this.pipeline.query(question);
+    return results;
+  }
+}
+`;
+exports.DISCOVERY_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { ServiceRegistry, DiscoveryClient } from '@hazeljs/discovery';
+
+@Service()
+export class {{className}}DiscoveryService {
+  constructor(
+    private readonly registry: ServiceRegistry,
+    private readonly client: DiscoveryClient,
+  ) {}
+
+  async registerService() {
+    await this.registry.register({
+      name: '{{fileName}}-service',
+      host: 'localhost',
+      port: 3000,
+      metadata: {
+        version: '1.0.0',
+      },
+    });
+  }
+
+  async discoverService(serviceName: string) {
+    const instances = await this.client.getInstances(serviceName);
+    return instances;
+  }
+}
+`;
+exports.CONFIG_TEMPLATE = `import { HazelModule } from '@hazeljs/core';
+import { ConfigModule, ConfigService } from '@hazeljs/config';
+
+// Import ConfigModule.forRoot() in your app module:
+//
+// @HazelModule({
+//   imports: [
+//     ConfigModule.forRoot({
+//       envFilePath: '.env',
+//     }),
+//   ],
+// })
+//
+// Then inject ConfigService wherever you need it:
+//
+// constructor(private readonly config: ConfigService) {}
+//
+// Usage:
+//   this.config.get('DATABASE_URL');
+//   this.config.get('PORT', '3000');  // with default value
+
+export { ConfigModule, ConfigService };
+`;
+// ── Serverless generators ────────────────────────────────────────────────────
+exports.SERVERLESS_LAMBDA_TEMPLATE = `import { createLambdaHandler } from '@hazeljs/serverless';
+import { AppModule } from './app.module';
+
+export const handler = createLambdaHandler(AppModule);
+`;
+exports.SERVERLESS_CLOUD_FUNCTION_TEMPLATE = `import { createCloudFunctionHandler } from '@hazeljs/serverless';
+import { AppModule } from './app.module';
+
+export const handler = createCloudFunctionHandler(AppModule);
+`;

package/dist/index.d.ts

@@ -1,2 +1,42 @@
 #!/usr/bin/env node
+/**
+ * HazelJS CLI — Entry point and command registration
+ *
+ * Architecture Overview:
+ * =====================
+ *
+ * index.ts                 — Entry point, registers all commands with Commander
+ *   ├─ commands/
+ * │   ├─ generate-app.ts   — `hazel new` (full scaffolding) and `hazel g app` (skeleton)
+ * │   ├─ add.ts            — `hazel add [pkg]` with --setup flag (replaces generate-setup)
+ * │   ├─ info.ts           — `hazel info` (project diagnostics)
+ * │   ├─ generate-simple.ts — Config-driven single-file generators (18 types)
+ * │   ├─ generate-module.ts — Multi-file module generator
+ * │   ├─ generate-dto.ts   — DTO pair generator
+ * │   ├─ generate-crud.ts  — Full CRUD resource generator
+ * │   ├─ generate-auth.ts  — Auth module with JWT guard
+ * │   └─ templates.ts      — Mustache templates for all simple generators
+ * └─ utils/
+ *     ├─ generator.ts      — Base Generator class, shared types, string utils
+ *     ├─ generator-registry.ts — Unified registry + runGenerator dispatcher
+ *     └─ packages-registry.ts  — All HazelJS package metadata (single source of truth)
+ *
+ * Command Structure:
+ * =================
+ *
+ * hazel new <app>           — Full interactive scaffolding (packages, git, install)
+ * hazel g app <name>        — Minimal skeleton app (no install/git)
+ * hazel g <type> <name>      — Unified generator for 23+ types (see --list)
+ * hazel add <pkg> [--setup]  — Install HazelJS packages + optional setup file
+ * hazel info                 — Project diagnostics
+ *
+ * Design Principles:
+ * ===================
+ *
+ * 1. Config-driven generators: SIMPLE_GENERATORS array defines 18+ single-file generators
+ * 2. Centralized package registry: HAZEL_PACKAGES drives `hazel add` and `hazel new -i`
+ * 3. Machine-readable output: --json and --list --list-json for LLM tool-use
+ * 4. Consistent CLI options: --path, --dry-run, --json available everywhere
+ * 5. Separation of concerns: Templates live separately from logic; registry is data-driven
+ */
 export {};

package/dist/index.js

@@ -1,7 +1,49 @@
 #!/usr/bin/env node
 "use strict";
+/**
+ * HazelJS CLI — Entry point and command registration
+ *
+ * Architecture Overview:
+ * =====================
+ *
+ * index.ts                 — Entry point, registers all commands with Commander
+ *   ├─ commands/
+ * │   ├─ generate-app.ts   — `hazel new` (full scaffolding) and `hazel g app` (skeleton)
+ * │   ├─ add.ts            — `hazel add [pkg]` with --setup flag (replaces generate-setup)
+ * │   ├─ info.ts           — `hazel info` (project diagnostics)
+ * │   ├─ generate-simple.ts — Config-driven single-file generators (18 types)
+ * │   ├─ generate-module.ts — Multi-file module generator
+ * │   ├─ generate-dto.ts   — DTO pair generator
+ * │   ├─ generate-crud.ts  — Full CRUD resource generator
+ * │   ├─ generate-auth.ts  — Auth module with JWT guard
+ * │   └─ templates.ts      — Mustache templates for all simple generators
+ * └─ utils/
+ *     ├─ generator.ts      — Base Generator class, shared types, string utils
+ *     ├─ generator-registry.ts — Unified registry + runGenerator dispatcher
+ *     └─ packages-registry.ts  — All HazelJS package metadata (single source of truth)
+ *
+ * Command Structure:
+ * =================
+ *
+ * hazel new <app>           — Full interactive scaffolding (packages, git, install)
+ * hazel g app <name>        — Minimal skeleton app (no install/git)
+ * hazel g <type> <name>      — Unified generator for 23+ types (see --list)
+ * hazel add <pkg> [--setup]  — Install HazelJS packages + optional setup file
+ * hazel info                 — Project diagnostics
+ *
+ * Design Principles:
+ * ===================
+ *
+ * 1. Config-driven generators: SIMPLE_GENERATORS array defines 18+ single-file generators
+ * 2. Centralized package registry: HAZEL_PACKAGES drives `hazel add` and `hazel new -i`
+ * 3. Machine-readable output: --json and --list --list-json for LLM tool-use
+ * 4. Consistent CLI options: --path, --dry-run, --json available everywhere
+ * 5. Separation of concerns: Templates live separately from logic; registry is data-driven
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
+const fs_1 = require("fs");
+const path_1 = require("path");
 const generate_app_1 = require("./commands/generate-app");
 const generate_module_1 = require("./commands/generate-module");
 const generate_dto_1 = require("./commands/generate-dto");
@@ -11,11 +53,13 @@ const generate_simple_1 = require("./commands/generate-simple");
 const generator_registry_1 = require("./utils/generator-registry");
 const info_1 = require("./commands/info");
 const add_1 = require("./commands/add");
+// Read version from package.json to ensure consistency
+const packageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../package.json'), 'utf8'));
 const program = new commander_1.Command();
 program
     .name('hazel')
     .description('CLI for generating HazelJS components and applications')
-    .version('0.2.0');
+    .version(packageJson.version);
 // New app command
 (0, generate_app_1.generateApp)(program);
 // Utility commands

package/dist/utils/generator-registry.d.ts

@@ -12,4 +12,9 @@ export declare const GENERATOR_LIST: GeneratorMeta[];
  * For types that don't require a name (auth, config), pass a placeholder (e.g. 'auth').
  */
 export declare function runGenerator(type: string, name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
+/**
+ * Get an array of all available generator type names.
+ *
+ * @returns Array of generator types (e.g. ['controller', 'service', 'module', ...])
+ */
 export declare function getGeneratorTypes(): string[];

package/dist/utils/generator-registry.js

@@ -56,6 +56,11 @@ async function runGenerator(type, name, options) {
         error: `Unknown generator type: "${type}". Use "hazel generate --list" to see available types.`,
     };
 }
+/**
+ * Get an array of all available generator type names.
+ *
+ * @returns Array of generator types (e.g. ['controller', 'service', 'module', ...])
+ */
 function getGeneratorTypes() {
     return exports.GENERATOR_LIST.map((g) => g.type);
 }

package/dist/utils/packages-registry.d.ts

@@ -19,7 +19,16 @@ export interface HazelPackageMeta {
     setupTemplate: string | null;
 }
 export declare const HAZEL_PACKAGES: HazelPackageMeta[];
-/** Lookup by short name (e.g. 'ai') or full npm name (e.g. '@hazeljs/ai') */
+/**
+ * Look up a HazelJS package by its short CLI name or full npm package name.
+ *
+ * @param nameOrNpm - Either the short name ('ai', 'auth') or full npm name ('@hazeljs/ai')
+ * @returns The matching package metadata, or undefined if not found
+ */
 export declare function findPackage(nameOrNpm: string): HazelPackageMeta | undefined;
-/** Map of shortName → HazelPackageMeta for quick lookup */
+/**
+ * Map of short CLI name → HazelPackageMeta for O(1) lookups.
+ *
+ * Example: PACKAGES_BY_NAME['ai'] returns the @hazeljs/ai package metadata.
+ */
 export declare const PACKAGES_BY_NAME: Record<string, HazelPackageMeta>;

package/dist/utils/packages-registry.js

@@ -363,9 +363,18 @@ SwaggerModule.setRootModule(AppModule);
         setupTemplate: null,
     },
 ];
-/** Lookup by short name (e.g. 'ai') or full npm name (e.g. '@hazeljs/ai') */
+/**
+ * Look up a HazelJS package by its short CLI name or full npm package name.
+ *
+ * @param nameOrNpm - Either the short name ('ai', 'auth') or full npm name ('@hazeljs/ai')
+ * @returns The matching package metadata, or undefined if not found
+ */
 function findPackage(nameOrNpm) {
     return exports.HAZEL_PACKAGES.find((p) => p.shortName === nameOrNpm || p.npm === nameOrNpm);
 }
-/** Map of shortName → HazelPackageMeta for quick lookup */
+/**
+ * Map of short CLI name → HazelPackageMeta for O(1) lookups.
+ *
+ * Example: PACKAGES_BY_NAME['ai'] returns the @hazeljs/ai package metadata.
+ */
 exports.PACKAGES_BY_NAME = Object.fromEntries(exports.HAZEL_PACKAGES.map((p) => [p.shortName, p]));

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "@hazeljs/cli",
-  "version": "0.6.0",
+  "version": "0.6.5",
   "description": "Command-line interface for scaffolding and generating HazelJS applications and components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist",
     "@template",
-    "@template-ai-native"
+    "@template-ai-native",
+    "cli-manifest.json"
   ],
   "bin": {
     "hazel": "./dist/index.js"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node scripts/generate-manifest.js",
+    "build:types": "tsc",
     "test": "jest",
     "lint": "eslint src --ext .ts",
     "format": "prettier --write \"src/**/*.ts\"",
@@ -68,5 +70,5 @@
     "type": "opencollective",
     "url": "https://opencollective.com/hazeljs"
   },
-  "gitHead": "27bc86031befce190871d3f07be4156544f37f94"
+  "gitHead": "58872147a05275f470b563d4d4784c7efd53596e"
 }