@hazeljs/cli 0.8.0 → 0.8.1

package/@template-ai-native/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hazeljs-ai-native-app",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "A HazelJS AI-native application with agents, RAG, and chat",
   "main": "dist/index.js",
   "scripts": {

package/cli-manifest.json

@@ -4,7 +4,7 @@
   "description": "Machine-readable manifest of all CLI commands and options for LLM agent tool-use",
   "cli": {
     "name": "hazel",
-    "version": "0.8.0",
+    "version": "0.8.1",
     "description": "CLI for generating HazelJS components and applications"
   },
   "commands": [

package/dist/commands/eval.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+/**
+ * `hazel eval <dataset.json>` — load a golden dataset and run a placeholder pass-through runner.
+ * Wire your own runner in app code using @hazeljs/eval (see runGoldenDataset).
+ */
+export declare function registerEvalCommand(program: Command): void;

package/dist/commands/eval.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEvalCommand = registerEvalCommand;
+const path = __importStar(require("path"));
+/**
+ * `hazel eval <dataset.json>` — load a golden dataset and run a placeholder pass-through runner.
+ * Wire your own runner in app code using @hazeljs/eval (see runGoldenDataset).
+ */
+function registerEvalCommand(program) {
+    program
+        .command('eval')
+        .description('Run a golden dataset JSON through @hazeljs/eval (smoke check; supply your runner in code)')
+        .argument('<dataset>', 'Path to golden dataset JSON')
+        .option('--ci', 'Set exit code 1 when eval fails thresholds')
+        .action(async (dataset, opts) => {
+        try {
+            const { loadGoldenDatasetFromJson, runGoldenDataset, reportEvalForCi } = await Promise.resolve().then(() => __importStar(require('@hazeljs/eval')));
+            const ds = loadGoldenDatasetFromJson(path.resolve(process.cwd(), dataset));
+            const result = await runGoldenDataset(ds, async ({ input }) => ({
+                output: input,
+                toolCalls: [],
+                retrievedIds: [],
+            }), { minAverageScore: 0 });
+            reportEvalForCi(result, { exitOnFail: Boolean(opts.ci) });
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/generate-auth.js

@@ -22,9 +22,13 @@ export class AuthModule {}
 `;
 const AUTH_SERVICE_TEMPLATE = `import { Service, BadRequestError, UnauthorizedError } from '@hazeljs/core';
 import { JwtService } from '@hazeljs/auth';
+import * as bcrypt from 'bcryptjs';
 import { RegisterDto } from './dto/register.dto';
 import { LoginDto } from './dto/login.dto';
 
+/** Replace with your DB / Prisma / TypeORM repository */
+const users = new Map<string, { id: string; name: string; email: string; passwordHash: string }>();
+
 @Service()
 export class AuthService {
   constructor(
@@ -32,38 +36,52 @@ export class AuthService {
   ) {}
 
   async register(registerDto: RegisterDto) {
-    // TODO: Check if user already exists in your database
-
-    // TODO: Hash the password (e.g., with bcryptjs)
-    // const hashedPassword = await bcrypt.hash(registerDto.password, 10);
+    const email = registerDto.email.toLowerCase();
+    if (users.has(email)) {
+      throw new BadRequestError('User already exists');
+    }
 
-    // TODO: Create the user in your database
+    const passwordHash = await bcrypt.hash(registerDto.password, 10);
     const user = {
       id: Date.now().toString(),
       name: registerDto.name,
-      email: registerDto.email,
+      email,
+      passwordHash,
     };
+    users.set(email, user);
 
     const accessToken = this.jwtService.sign({
       sub: user.id,
       email: user.email,
     });
 
-    return { user, accessToken };
+    return {
+      user: { id: user.id, name: user.name, email: user.email },
+      accessToken,
+    };
   }
 
   async login(loginDto: LoginDto) {
-    // TODO: Find user by email in your database
-    // TODO: Verify password with bcrypt.compare()
+    const email = loginDto.email.toLowerCase();
+    const row = users.get(email);
+    if (!row) {
+      throw new UnauthorizedError('Invalid credentials');
+    }
 
-    const user = { id: '1', name: 'User', email: loginDto.email };
+    const ok = await bcrypt.compare(loginDto.password, row.passwordHash);
+    if (!ok) {
+      throw new UnauthorizedError('Invalid credentials');
+    }
 
     const accessToken = this.jwtService.sign({
-      sub: user.id,
-      email: user.email,
+      sub: row.id,
+      email: row.email,
     });
 
-    return { user, accessToken };
+    return {
+      user: { id: row.id, name: row.name, email: row.email },
+      accessToken,
+    };
   }
 }
 `;

package/dist/commands/generate-simple.js

@@ -133,6 +133,18 @@ exports.SIMPLE_GENERATORS = [
             'Configure your embedding provider and vector store',
         ],
     },
+    {
+        type: 'rag-pipeline',
+        description: 'RAG pipeline service (RAGPipeline.from + memory store)',
+        suffix: 'rag-pipeline',
+        template: templates_1.RAG_PIPELINE_TEMPLATE,
+        nameRequired: true,
+        nextSteps: [
+            'npm install @hazeljs/rag',
+            'Wire llm() to HazelAI or AIService',
+            'For production vectors, use HazelAI persistence.rag or construct RAGPipeline with your VectorStore',
+        ],
+    },
     {
         type: 'discovery',
         description: 'Service discovery setup',

package/dist/commands/templates.d.ts

@@ -28,6 +28,7 @@ export declare const AGENT_TEMPLATE = "import { Agent, Tool } from '@hazeljs/age
 export declare const CACHE_SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { CacheService, Cacheable, CacheEvict } from '@hazeljs/cache';\n\n@Service()\nexport class {{className}}CacheService {\n  constructor(private readonly cacheService: CacheService) {}\n\n  @Cacheable({ key: '{{fileName}}:all', ttl: 60 })\n  async findAll() {\n    // This result will be cached for 60 seconds\n    return [];\n  }\n\n  @Cacheable({ key: '{{fileName}}:{{=<% %>=}}#{id}<%={{ }}=%>', ttl: 300 })\n  async findOne(id: string) {\n    // This result will be cached for 5 minutes\n    return { id };\n  }\n\n  @CacheEvict({ key: '{{fileName}}:all' })\n  async create(data: any) {\n    // Creating a new item evicts the list cache\n    return data;\n  }\n\n  async clearAll() {\n    await this.cacheService.clear();\n  }\n}\n";
 export declare const CRON_SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { Cron, CronExpression } from '@hazeljs/cron';\n\n@Service()\nexport class {{className}}CronService {\n  @Cron(CronExpression.EVERY_MINUTE)\n  handleEveryMinute() {\n    console.log('[{{className}}Cron] Running every minute...');\n    // Add your cron job logic here\n  }\n\n  @Cron('0 0 * * *')  // Every day at midnight\n  handleDaily() {\n    console.log('[{{className}}Cron] Running daily task...');\n    // Add your daily task logic here\n  }\n\n  @Cron(CronExpression.EVERY_HOUR)\n  handleHourly() {\n    console.log('[{{className}}Cron] Running hourly cleanup...');\n    // Add your hourly task logic here\n  }\n}\n";
 export declare const RAG_SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { RAGPipeline, MemoryVectorStore } from '@hazeljs/rag';\n\n@Service()\nexport class {{className}}RagService {\n  private pipeline: RAGPipeline;\n\n  constructor() {\n    // Initialize with a memory vector store (swap for Pinecone, Qdrant, etc. in production)\n    const vectorStore = new MemoryVectorStore();\n\n    this.pipeline = new RAGPipeline({\n      vectorStore,\n      topK: 5,\n    });\n  }\n\n  async addDocument(content: string, metadata?: Record<string, unknown>) {\n    // Add a document to the vector store for retrieval\n    await this.pipeline.addDocument({\n      content,\n      metadata: metadata || {},\n    });\n  }\n\n  async query(question: string) {\n    // Retrieve relevant documents and generate a response\n    const results = await this.pipeline.query(question);\n    return results;\n  }\n}\n";
+export declare const RAG_PIPELINE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { RAGPipeline } from '@hazeljs/rag';\n\n/**\n * RAG pipeline scaffold \u2014 uses {@link RAGPipeline.from} with in-memory vectors.\n * Swap persistence via HazelAI `persistence.rag` or construct {@link RAGPipeline} with Pinecone/Qdrant/Weaviate/Chroma.\n */\n@Service()\nexport class {{className}}RagPipelineService {\n  private pipeline: RAGPipeline | null = null;\n\n  async ensurePipeline(): Promise<RAGPipeline> {\n    if (this.pipeline) return this.pipeline;\n    this.pipeline = RAGPipeline.from({\n      provider: 'openai',\n      vectorStore: 'memory',\n      topK: 5,\n      chunkSize: 1000,\n      chunkOverlap: 200,\n      llm: async (prompt: string) => {\n        // Wire to your LLM (HazelAI, AIService, or HTTP)\n        return prompt;\n      },\n    });\n    await this.pipeline.initialize();\n    return this.pipeline;\n  }\n\n  async query(question: string) {\n    const p = await this.ensurePipeline();\n    return p.query(question);\n  }\n}\n";
 export declare const DISCOVERY_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { ServiceRegistry, DiscoveryClient } from '@hazeljs/discovery';\n\n@Service()\nexport class {{className}}DiscoveryService {\n  constructor(\n    private readonly registry: ServiceRegistry,\n    private readonly client: DiscoveryClient,\n  ) {}\n\n  async registerService() {\n    await this.registry.register({\n      name: '{{fileName}}-service',\n      host: 'localhost',\n      port: 3000,\n      metadata: {\n        version: '1.0.0',\n      },\n    });\n  }\n\n  async discoverService(serviceName: string) {\n    const instances = await this.client.getInstances(serviceName);\n    return instances;\n  }\n}\n";
 export declare const CONFIG_TEMPLATE = "import { HazelModule } from '@hazeljs/core';\nimport { ConfigModule, ConfigService } from '@hazeljs/config';\n\n// Import ConfigModule.forRoot() in your app module:\n//\n// @HazelModule({\n//   imports: [\n//     ConfigModule.forRoot({\n//       envFilePath: '.env',\n//     }),\n//   ],\n// })\n//\n// Then inject ConfigService wherever you need it:\n//\n// constructor(private readonly config: ConfigService) {}\n//\n// Usage:\n//   this.config.get('DATABASE_URL');\n//   this.config.get('PORT', '3000');  // with default value\n\nexport { ConfigModule, ConfigService };\n";
 export declare const SERVERLESS_LAMBDA_TEMPLATE = "import { createLambdaHandler } from '@hazeljs/serverless';\nimport { AppModule } from './app.module';\n\nexport const handler = createLambdaHandler(AppModule);\n";

package/dist/commands/templates.js

@@ -16,7 +16,7 @@
  * 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;
+exports.SERVERLESS_CLOUD_FUNCTION_TEMPLATE = exports.SERVERLESS_LAMBDA_TEMPLATE = exports.CONFIG_TEMPLATE = exports.DISCOVERY_TEMPLATE = exports.RAG_PIPELINE_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';
@@ -324,6 +324,40 @@ export class {{className}}RagService {
   }
 }
 `;
+exports.RAG_PIPELINE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { RAGPipeline } from '@hazeljs/rag';
+
+/**
+ * RAG pipeline scaffold — uses {@link RAGPipeline.from} with in-memory vectors.
+ * Swap persistence via HazelAI \`persistence.rag\` or construct {@link RAGPipeline} with Pinecone/Qdrant/Weaviate/Chroma.
+ */
+@Service()
+export class {{className}}RagPipelineService {
+  private pipeline: RAGPipeline | null = null;
+
+  async ensurePipeline(): Promise<RAGPipeline> {
+    if (this.pipeline) return this.pipeline;
+    this.pipeline = RAGPipeline.from({
+      provider: 'openai',
+      vectorStore: 'memory',
+      topK: 5,
+      chunkSize: 1000,
+      chunkOverlap: 200,
+      llm: async (prompt: string) => {
+        // Wire to your LLM (HazelAI, AIService, or HTTP)
+        return prompt;
+      },
+    });
+    await this.pipeline.initialize();
+    return this.pipeline;
+  }
+
+  async query(question: string) {
+    const p = await this.ensurePipeline();
+    return p.query(question);
+  }
+}
+`;
 exports.DISCOVERY_TEMPLATE = `import { Service } from '@hazeljs/core';
 import { ServiceRegistry, DiscoveryClient } from '@hazeljs/discovery';
 

package/dist/index.js

@@ -53,6 +53,7 @@ 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");
+const eval_1 = require("./commands/eval");
 // 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();
@@ -65,6 +66,7 @@ program
 // Utility commands
 (0, info_1.infoCommand)(program);
 (0, add_1.addCommand)(program);
+(0, eval_1.registerEvalCommand)(program);
 // Generate command group (unified: hazel g <type> <name> [--path] [--dry-run] [--json], or hazel g --list)
 const generateCommand = program
     .command('generate')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/cli",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Command-line interface for scaffolding and generating HazelJS applications and components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,14 +14,18 @@
     "hazel": "./dist/index.js"
   },
   "scripts": {
-    "build": "tsc && node scripts/generate-manifest.js",
-    "build:types": "tsc",
+    "build": "tsc -b && node scripts/generate-manifest.js",
+    "build:types": "tsc -b",
+    "typecheck": "tsc -b --noEmit",
     "test": "jest",
     "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
     "format": "prettier --write \"src/**/*.ts\"",
-    "prepare": "npm run build"
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@hazeljs/eval": "^0.8.1",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "inquirer": "^8.2.7",
@@ -70,5 +74,5 @@
     "type": "opencollective",
     "url": "https://opencollective.com/hazeljs"
   },
-  "gitHead": "e0ed98ca074dd4f7472816d3c32ef576900dcca6"
+  "gitHead": "8b7685d1250c4622f25d83992f58e13a59bb3dba"
 }