@hazeljs/cli 0.5.4 → 0.6.0

package/README.md

@@ -2,7 +2,7 @@
 
 **From zero to AI-powered apps in one command.**
 
-Generate controllers, services, modules, AI agents, RAG systems — or create a complete AI-Native application with PostgreSQL, Redis, and Docker. Interactive project setup, package management, and code that follows best practices. Stop copy-pasting, start shipping intelligent applications.
+Generate controllers, services, modules, AI agents, RAG systems — or create a complete AI-Native application with PostgreSQL, Redis, and Docker. Interactive project setup, package management, and code that follows best practices.
 
 [![npm version](https://img.shields.io/npm/v/@hazeljs/cli.svg)](https://www.npmjs.com/package/@hazeljs/cli)
 [![npm downloads](https://img.shields.io/npm/dm/@hazeljs/cli)](https://www.npmjs.com/package/@hazeljs/cli)
@@ -12,17 +12,11 @@ Generate controllers, services, modules, AI agents, RAG systems — or create a
 
 - 🤖 **AI-Native Templates** - Create complete AI applications with agents, RAG, PostgreSQL, and Docker
 - 🚀 **Project Scaffolding** - Create new HazelJS applications instantly with interactive setup
-- 🎨 **Code Generation** - Generate controllers, services, AI agents, RAG systems, and more
+- 🎨 **Code Generation** - Generate controllers, services, AI agents, RAG systems, and 20+ component types
+- 📦 **Package Management** - Add HazelJS packages interactively with optional setup file generation
 - 🏗️ **Best Practices** - Generated code follows HazelJS conventions and AI patterns
-- 🔧 **Customizable** - Specify paths and options for generated files
-- 📦 **Multiple Templates** - Support for various component types including AI components
+- 🎯 **TypeScript First** - All generated code is fully typed
 - ⚡ **Fast Development** - Reduce boilerplate and speed up development
-- 🎯 **TypeScript First** - All generated code is fully typed with AI safety
-- 🛠️ **Utility Commands** - Build, start, test, and manage your project
-- 📊 **Project Info** - Display comprehensive project information
-- ➕ **Package Management** - Add HazelJS packages interactively
-- 🎭 **CRUD Generator** - Generate complete CRUD resources in one command
-- 🧠 **AI Components** - Generate agents, tools, RAG pipelines, and AI services
 
 ## Installation
 
@@ -38,672 +32,228 @@ npm install -g @hazeljs/cli
 npm install --save-dev @hazeljs/cli
 ```
 
-## Usage
-
-The CLI provides commands to generate various HazelJS components, create new applications, and manage your project.
-
 ## Commands
 
-### Project Management
+### Create a New Application
 
-#### Create new application
-
-**🤖 AI-Native Application (Recommended for AI Projects):**
+**AI-Native Application (Recommended for AI Projects):**
 ```bash
-hazel g app <appName> --template=ai-native
-# Then: cd <appName> && npm install && cp .env.example .env && docker-compose up -d && npm run dev
+hazel g app my-ai-app --template=ai-native
+cd my-ai-app && npm install && cp .env.example .env && docker-compose up -d && npm run dev
 ```
 
-Creates a complete AI-powered application with:
-- 🤖 AI Agents with tools and memory
-- 📚 RAG System with PostgreSQL + pgvector
-- 🗄️ Database Setup (PostgreSQL, Redis)
-- 🐳 Docker Configuration for production
-- 📊 Complete API endpoints ready to use
+Creates a complete AI-powered application with agents, RAG (PostgreSQL + pgvector), Redis, and Docker.
 
-**Skeleton app (quick start, like create-next-app):**
+**Skeleton app (quick start):**
 ```bash
-hazel g app <appName>
-# Then: cd <appName> && npm install && npm run dev
+hazel g app my-app
+cd my-app && npm install && npm run dev
 ```
 
 **Full setup with interactive package selection:**
 ```bash
-hazel new <appName> [options]
+hazel new my-app -i
 ```
 
-Creates a new HazelJS application. Use `hazel g app <name> --template=ai-native` for AI applications; `hazel g app <name>` for a minimal skeleton; use `hazel new <name> -i` for interactive setup with optional packages.
-
 **Options:**
 - `-d, --dest <path>` - Destination path (default: current directory)
 - `-i, --interactive` - Interactive setup with package selection
+- `--template <template>` - Template to use (`ai-native` or `default`)
 - `--skip-install` - Skip npm install
 - `--skip-git` - Skip git initialization
 
-**Examples:**
-```bash
-# AI-Native application (recommended for AI projects)
-hazel g app my-ai-app --template=ai-native
-
-# Basic project creation
-hazel new my-app
-
-# Interactive setup with package selection
-hazel new my-app -i
-
-# Create without installing dependencies
-hazel new my-app --skip-install
-```
-
-#### Project Information
+### Project Info
 
 ```bash
 hazel info
 ```
 
-Display comprehensive information about your HazelJS project including:
-- Project name, version, and description
-- Installed HazelJS packages
-- Project structure
-- Environment details
-- Configuration files
+Display project name, version, installed HazelJS packages, project structure, and environment details.
 
-#### Add Packages
+### Add Packages
 
 ```bash
-hazel add [package]
+hazel add [package] [--setup] [--dev]
 ```
 
-Add HazelJS packages to your project interactively.
+Install a HazelJS package and show usage hints. Use `--setup` to also generate a minimal starter file.
 
 **Examples:**
 ```bash
-# Interactive package selection
-hazel add
-
-# Add specific package
-hazel add ai
-hazel add auth
-hazel add prisma
+hazel add                  # Interactive package selection
+hazel add ai               # Install @hazeljs/ai
+hazel add auth --setup     # Install @hazeljs/auth + generate auth.setup.ts
+hazel add prisma --dev     # Install as devDependency
 ```
 
-**Available packages:**
-- `ai` - AI Integration (@hazeljs/ai)
-- `agent` - AI Agents (@hazeljs/agent)
-- `audit` - Audit Logging (@hazeljs/audit)
-- `auth` - Authentication (@hazeljs/auth)
-- `cache` - Caching (@hazeljs/cache)
-- `config` - Configuration (@hazeljs/config)
-- `cron` - Cron Jobs (@hazeljs/cron)
-- `data` - Data/ETL (@hazeljs/data)
-- `mcp` - Model Context Protocol (@hazeljs/mcp)
-- `ml` - Machine Learning (@hazeljs/ml)
-- `prisma` - Prisma ORM (@hazeljs/prisma)
-- `prompts` - Typed prompt templates (@hazeljs/prompts)
-- `rag` - RAG/Vector Search (@hazeljs/rag)
-- `serverless` - Serverless (@hazeljs/serverless)
-- `swagger` - Swagger/OpenAPI (@hazeljs/swagger)
-- `typeorm` - TypeORM (@hazeljs/typeorm)
-- `websocket` - WebSocket (@hazeljs/websocket)
-
-#### Build Project
-
-```bash
-hazel build [options]
-```
-
-Build your HazelJS project.
-
-**Options:**
-- `-w, --watch` - Watch mode
-- `-p, --production` - Production build
-
-**Examples:**
-```bash
-# Standard build
-hazel build
-
-# Watch mode
-hazel build -w
-
-# Production build
-hazel build -p
-```
-
-#### Start Application
-
-```bash
-hazel start [options]
-```
-
-Start your HazelJS application.
-
-**Options:**
-- `-d, --dev` - Start in development mode
-- `-p, --port <port>` - Specify port
-
-**Examples:**
-```bash
-# Start in production mode
-hazel start
-
-# Start in development mode with hot reload
-hazel start -d
-
-# Start on specific port
-hazel start -p 8080
-```
-
-#### Run Tests
-
-```bash
-hazel test [pattern] [options]
-```
-
-Run tests for your HazelJS project.
-
-**Options:**
-- `-w, --watch` - Watch mode
-- `-c, --coverage` - Generate coverage report
-- `--ci` - Run in CI mode
-
-**Examples:**
-```bash
-# Run all tests
-hazel test
-
-# Run specific test file
-hazel test user.test
-
-# Watch mode
-hazel test -w
-
-# Generate coverage
-hazel test -c
-```
+**Available packages:** `ai`, `agent`, `audit`, `auth`, `oauth`, `cache`, `config`, `cron`, `data`, `discovery`, `event-emitter`, `gateway`, `graphql`, `grpc`, `guardrails`, `kafka`, `mcp`, `messaging`, `ml`, `prisma`, `prompts`, `queue`, `rag`, `resilience`, `pdf-to-audio`, `serverless`, `swagger`, `typeorm`, `websocket`
 
 ### Code Generation
 
 ```bash
-hazel generate <component> <name> [options]
+hazel g <type> <name> [--path <path>] [--dry-run] [--json]
 ```
 
-Or using the shorter alias:
-
+**Discover generators:**
 ```bash
-hazel g <component> <name> [options]
-```
-
-#### Generation options
-
-- **One pattern:** `hazel g <type> <name> [--path <path>] [--dry-run] [--json]`
-- **List types:** `hazel g --list` — list all generator types
-- **List as JSON:** `hazel g --list --list-json` — output `{ "generators": [ ... ] }`
-- **Result as JSON:** add `--json` to any generator to get `{ "ok", "created", "nextSteps" }` on stdout
-- **Stable options:** `-p, --path`, `--dry-run`, and `--json` work the same for every generator.
-
-```bash
-# See what you can generate
-hazel g --list
-hazel g --list --list-json
-
-# Generate with JSON result
-hazel g controller users --json
-hazel g crud product --path src/products --json
-
-# Dry run (no files written)
-hazel g module orders --dry-run
+hazel g --list              # Human-readable list
+hazel g --list --list-json  # JSON output
 ```
 
-### Available Generators
-
-#### Application Templates
-- `app` - Generate a HazelJS application. Use `hazel g app my-app --template=ai-native` for AI applications or `hazel g app my-app` for minimal template.
-
-**Available Templates:**
-- `ai-native` - Complete AI application with agents, RAG, PostgreSQL, Redis, and Docker
-- `default` - Minimal HazelJS application (like create-next-app)
-
-#### Package setup
-- `setup` / `st` - Generate a minimal setup starter file for a HazelJS package (e.g. `hazel g setup swagger`).
-
-#### Core Components
-- `controller` / `c` - Generate a new controller
-- `service` / `s` - Generate a new service
-- `module` / `m` - Generate a new module
-- `dto` - Generate create and update DTOs
-- `guard` - Generate a new guard
-- `interceptor` / `i` - Generate a new interceptor
-- `middleware` / `mw` - Generate a new middleware
-
-#### Advanced Generators
-- **`crud`** - Generate complete CRUD resource (controller + service + module + DTOs)
-- `gateway` / `ws` - Generate a WebSocket gateway
-- `filter` / `f` - Generate an exception filter
-- `pipe` / `p` - Generate a transformation pipe
-- `repository` / `repo` - Generate a Prisma repository
-- `ai-service` / `ai` - Generate an AI service with decorators
-- `agent` - Generate an AI agent with tools and memory
-- `rag-controller` - Generate a RAG controller with document ingestion and search
-- `tool` - Generate an AI tool for agents
-- `serverless` / `sls` - Generate a serverless handler (Lambda/Cloud Function)
-
-### Generator Options
-
-- `-p, --path <path>` - Specify the path where the component should be generated (default: 'src')
+**Common options** (work the same for every generator):
+- `-p, --path <path>` - Where to generate (default: `src`)
 - `--dry-run` - Preview files without writing them
-- `--json` - Output result as JSON (created paths and next steps)
-- `-r, --route <route>` - Specify the route path (for CRUD generator)
-- `--platform <platform>` - For serverless, specify platform: `lambda` or `cloud-function` (default: 'lambda')
+- `--json` - Output result as JSON (`{ ok, created, nextSteps }`)
+
+#### Multi-File Generators
+
+| Generator | Alias | Description | Creates |
+|-----------|-------|-------------|---------|
+| `crud <name>` | — | Complete CRUD resource | controller + service + module + DTOs |
+| `module <name>` | `m` | Feature module | module + controller + service + DTOs |
+| `dto <name>` | `d` | Create & update DTOs | two DTO files |
+| `auth` | — | Auth module | JWT guard + service + controller + DTOs |
+
+#### Single-File Generators
+
+| Generator | Alias | Description |
+|-----------|-------|-------------|
+| `controller <name>` | `c` | REST controller with CRUD methods |
+| `service <name>` | `s` | Injectable service class |
+| `guard <name>` | `gu` | Route guard (e.g. auth) |
+| `interceptor <name>` | `i` | Request/response interceptor |
+| `middleware <name>` | `mw` | Express-style middleware |
+| `pipe <name>` | — | Validation/transform pipe |
+| `filter <name>` | `f` | Exception filter |
+| `repository <name>` | `repo` | Prisma repository |
+| `gateway <name>` | `ws` | WebSocket gateway |
+| `ai-service <name>` | `ai` | AI service with decorators |
+| `agent <name>` | — | AI agent with @Agent and @Tool |
+| `cache <name>` | — | Cache service with decorators |
+| `cron <name>` | `job` | Cron/scheduled job service |
+| `rag <name>` | — | RAG service |
+| `discovery <name>` | — | Service discovery setup |
+| `config` | — | Config module setup |
+| `serverless <name>` | `sls` | Serverless handler (Lambda/Cloud Function) |
+
+**Serverless** also accepts `--platform <lambda|cloud-function>` (default: `lambda`).
 
 ### Generator Examples
 
-#### CRUD Generator (Recommended)
-
-Generate a complete CRUD resource with controller, service, module, and DTOs:
 ```bash
+# CRUD resource (recommended for new features)
 hazel g crud user
+hazel g crud product -p src/products -r /api/products
 
-# With custom path
-hazel g crud product -p src/products
-
-# With custom route
-hazel g crud article -r /api/articles
-```
-
-This creates:
-- `user.controller.ts` - Full CRUD controller
-- `user.service.ts` - Service with all CRUD methods
-- `user.module.ts` - Module configuration
-- `dto/user.dto.ts` - Create and Update DTOs
-
-#### Core Components
-
-Generate a new user controller:
-```bash
+# Core components
 hazel g controller user
-```
-
-Generate a new auth service in a specific path:
-```bash
 hazel g service auth -p src/auth
-```
-
-Generate create and update DTOs for a product:
-```bash
+hazel g module orders
 hazel g dto product
-```
 
-Generate a new authentication guard:
-```bash
+# Infrastructure
 hazel g guard auth
-```
-
-Generate a new logging interceptor:
-```bash
 hazel g interceptor logging
-```
-
-Generate a new middleware:
-```bash
-hazel g middleware logging
-# or
-hazel g mw cors -p src/middleware
-```
-
-#### Advanced Generators
-
-Generate a WebSocket gateway:
-```bash
-hazel g gateway notifications
-# or
-hazel g ws notifications
-```
-
-Generate an exception filter:
-```bash
+hazel g middleware cors -p src/middleware
 hazel g filter http-exception
-# or
-hazel g f http-exception
-```
 
-Generate a validation pipe:
-```bash
-hazel g pipe validation
-# or
-hazel g p validation
-```
-
-Generate an AI service with decorators:
-```bash
+# AI components
 hazel g ai-service chat
-# or
-hazel g ai chat
-```
-
-Generate an AI agent with tools and memory:
-```bash
 hazel g agent support
-```
-
-Generate a RAG controller with document ingestion and search:
-```bash
-hazel g rag-controller knowledge
-```
-
-Generate an AI tool for agents:
-```bash
-hazel g tool weather
-```
-
-Generate a Prisma repository:
-```bash
-hazel g repository user
-# or
-hazel g repo user
-```
+hazel g rag knowledge
 
-Generate an AI service:
-```bash
-hazel g ai-service chat
-# or
-hazel g ai chat
-```
-
-Generate a Lambda handler:
-```bash
+# Serverless
 hazel g serverless handler --platform lambda
-# or
-hazel g sls handler
-```
-
-Generate a Cloud Function handler:
-```bash
-hazel g serverless handler --platform cloud-function
-```
-
-## Generated File Structure
-
-### Controller
-
-```typescript
-import { Controller, Get, Post, Put, Delete, Body, Param } from '@hazeljs/core';
-import { UserService } from './user.service';
-
-@Controller('/users')
-export class UserController {
-  constructor(private userService: UserService) {}
-
-  @Get()
-  findAll() {
-    return this.userService.findAll();
-  }
-
-  @Get('/:id')
-  findOne(@Param('id') id: string) {
-    return this.userService.findOne(id);
-  }
-
-  @Post()
-  create(@Body() createDto: any) {
-    return this.userService.create(createDto);
-  }
-
-  @Put('/:id')
-  update(@Param('id') id: string, @Body() updateDto: any) {
-    return this.userService.update(id, updateDto);
-  }
-
-  @Delete('/:id')
-  delete(@Param('id') id: string) {
-    return this.userService.delete(id);
-  }
-}
-```
-
-### Service
-
-```typescript
-import { Injectable } from '@hazeljs/core';
-
-@Injectable()
-export class UserService {
-  findAll() {
-    return [];
-  }
-
-  findOne(id: string) {
-    return { id };
-  }
-
-  create(data: any) {
-    return { id: '1', ...data };
-  }
-
-  update(id: string, data: any) {
-    return { id, ...data };
-  }
-
-  delete(id: string) {
-    return { id };
-  }
-}
+hazel g sls api --platform cloud-function
 ```
 
-### Module
-
-```typescript
-import { HazelModule } from '@hazeljs/core';
-import { UserController } from './user.controller';
-import { UserService } from './user.service';
-
-@HazelModule({
-  controllers: [UserController],
-  providers: [UserService],
-})
-export class UserModule {}
-```
-
-### DTO
-
-```typescript
-import { IsString, IsEmail, MinLength } from 'class-validator';
-
-export class CreateUserDto {
-  @IsEmail()
-  email: string;
-
-  @IsString()
-  @MinLength(8)
-  password: string;
-
-  @IsString()
-  name: string;
-}
-
-export class UpdateUserDto {
-  @IsEmail()
-  email?: string;
-
-  @IsString()
-  name?: string;
-}
-```
-
-## Best Practices
-
-1. **Organize by Feature** - Group related components in feature modules
-2. **Use DTOs** - Always generate and use DTOs for validation
-3. **Follow Naming Conventions** - Use singular names for entities (User, not Users)
-4. **Specify Paths** - Use `-p` flag to organize files properly
-5. **Generate Complete Features** - Generate controller, service, module, and DTOs together
-
 ## Common Workflows
 
 ### Create a Complete CRUD Feature
 
-**Option 1: Using CRUD Generator (Recommended)**
 ```bash
-# Generate everything in one command
+# One command — generates controller, service, module, and DTOs
 hazel g crud user -p src/user
 ```
 
-**Option 2: Manual Generation**
-```bash
-# Generate all components separately
-hazel g module user -p src/user
-hazel g controller user -p src/user
-hazel g service user -p src/user
-hazel g dto user -p src/user
-```
-
 ### Create a Microservice
 
 ```bash
-# Create new app with interactive setup
-hazel new my-microservice -i
-
-# Navigate to project
-cd my-microservice
-
-# Generate CRUD resources
+hazel new my-service -i       # Interactive setup with package selection
+cd my-service
 hazel g crud user
 hazel g crud product
-hazel g crud order
-
-# Add additional packages
 hazel add swagger
-hazel add auth
-
-# Start development
-hazel start -d
+npm run dev
 ```
 
-### Add WebSocket Support
+### Add AI Integration
 
 ```bash
-# Generate WebSocket gateway
-hazel g gateway chat -p src/chat
-hazel g service chat -p src/chat
+hazel add ai --setup
+hazel g ai-service assistant -p src/ai
+hazel g agent support
 ```
 
-### Add AI Integration
+### Add WebSocket Support
 
 ```bash
-# Generate AI service
-hazel g ai-service assistant -p src/ai
+hazel g gateway chat -p src/chat
+hazel g service chat -p src/chat
 ```
 
 ### Prepare for Serverless
 
 ```bash
-# Generate Lambda handler
 hazel g serverless handler --platform lambda
 ```
 
 ## Quick Reference
 
-### All Available Commands
-
 ```bash
 # Project Management
-hazel new <name> [-i]              # Create new project
-hazel info                         # Show project info
-hazel add [package]                # Add HazelJS packages
-hazel build [-w] [-p]              # Build project
-hazel start [-d] [-p <port>]       # Start application
-hazel test [pattern] [-w] [-c]     # Run tests
+hazel new <name> [-i]                # Create new project
+hazel info                           # Show project info
+hazel add [package] [--setup]        # Add HazelJS package
 
 # Code Generation (alias: g)
-hazel g app <name>                # Skeleton application
-hazel g crud <name>               # Complete CRUD resource
-hazel g controller <name>          # Controller
-hazel g service <name>             # Service
-hazel g module <name>              # Module
-hazel g middleware <name>          # Middleware
-hazel g guard <name>               # Guard
-hazel g interceptor <name>         # Interceptor
-hazel g filter <name>              # Exception filter
-hazel g pipe <name>                # Pipe
-hazel g dto <name>                 # DTOs
-hazel g repository <name>          # Prisma repository
-hazel g ai-service <name>          # AI service
-hazel g gateway <name>             # WebSocket gateway
-hazel g serverless <name>          # Serverless handler
-```
-
-## Configuration
-
-Create a `.hazelrc.json` file in your project root for custom configuration:
-
-```json
-{
-  "defaultPath": "src",
-  "typescript": true,
-  "generateTests": true,
-  "styleGuide": "airbnb"
-}
-```
-
-## Tips & Tricks
-
-### Use Aliases
-
-```bash
-# These are equivalent
-hazel generate controller user
-hazel g c user
-
-# CRUD generator is the fastest way
-hazel g crud user
-```
-
-### Interactive Setup
-
-```bash
-# Use interactive mode for new projects
-hazel new my-app -i
-
-# Select packages interactively
-hazel add
-```
-
-### Batch Generation
-
-```bash
-# Use CRUD generator instead of multiple commands
-hazel g crud user  # Better than:
-# hazel g controller user && hazel g service user && hazel g module user && hazel g dto user
-```
-
-### Custom Paths
-
-```bash
-# Organize by feature
-hazel g crud user -p src/features/user
-hazel g middleware logging -p src/common/middleware
+hazel g app <name>                   # Application template
+hazel g crud <name>                  # Complete CRUD resource
+hazel g controller <name>            # Controller
+hazel g service <name>               # Service
+hazel g module <name>                # Module (+ controller, service, DTOs)
+hazel g guard <name>                 # Guard
+hazel g interceptor <name>           # Interceptor
+hazel g middleware <name>            # Middleware
+hazel g filter <name>                # Exception filter
+hazel g pipe <name>                  # Pipe
+hazel g dto <name>                   # DTOs
+hazel g repository <name>            # Prisma repository
+hazel g ai-service <name>            # AI service
+hazel g agent <name>                 # AI agent
+hazel g gateway <name>               # WebSocket gateway
+hazel g cache <name>                 # Cache service
+hazel g cron <name>                  # Cron service
+hazel g rag <name>                   # RAG service
+hazel g discovery <name>             # Service discovery
+hazel g config                       # Config module
+hazel g serverless <name>            # Serverless handler
+hazel g auth                         # Auth module
+hazel g --list                       # List all generators
 ```
 
-### Development Workflow
+## Best Practices
 
-```bash
-# Quick development cycle
-hazel new my-app -i          # Create with interactive setup
-cd my-app
-hazel g crud user            # Generate CRUD resource
-hazel add swagger            # Add API documentation
-hazel start -d               # Start in dev mode
-
-# In another terminal
-hazel test -w                # Run tests in watch mode
-```
+1. **Organize by Feature** - Group related components in feature modules
+2. **Use DTOs** - Always generate and use DTOs for validation
+3. **Follow Naming Conventions** - Use singular names for entities (User, not Users)
+4. **Specify Paths** - Use `-p` flag to organize files properly
+5. **Use CRUD Generator** - For new features, `hazel g crud` is the fastest path
 
 ## Troubleshooting
 
 ### Command Not Found
 
-If `hazel` command is not found after global installation:
-
 ```bash
 # Check npm global bin path
 npm config get prefix
@@ -718,10 +268,7 @@ npm install -g @hazeljs/cli
 ### Permission Errors
 
 ```bash
-# Use sudo (not recommended)
-sudo npm install -g @hazeljs/cli
-
-# Or fix npm permissions
+# Fix npm permissions (recommended)
 mkdir ~/.npm-global
 npm config set prefix '~/.npm-global'
 export PATH=~/.npm-global/bin:$PATH
@@ -729,28 +276,12 @@ export PATH=~/.npm-global/bin:$PATH
 
 ## Development
 
-### Building
-
-```bash
-npm run build
-```
-
-### Testing
-
 ```bash
-npm test
+npm run build    # Build
+npm test         # Run tests
+npm run lint     # Lint
 ```
 
-### Linting
-
-```bash
-npm run lint
-```
-
-## Examples
-
-See the [examples](../../example) directory for complete working examples of generated code.
-
 ## Contributing
 
 Contributions are welcome! Please read our [Contributing Guide](../../CONTRIBUTING.md) for details.
@@ -764,4 +295,4 @@ Apache 2.0 © [HazelJS](https://hazeljs.ai)
 - [Documentation](https://hazeljs.ai/docs/packages/cli)
 - [GitHub](https://github.com/hazel-js/hazeljs)
 - [Issues](https://github.com/hazel-js/hazeljs/issues)
-- [Discord](https://discord.gg/xe495BvE)
+- [Discord](https://discord.com/channels/1448263814238965833/1448263814859456575)