@smicolon/ai-kit 0.1.0 → 0.2.0

package/packs/nestjs/commands/module-create.md

@@ -0,0 +1,369 @@
+---
+name: module-create
+description: Create a new NestJS module following Smicolon conventions
+---
+
+# NestJS Module Creation
+
+You are a NestJS module creation specialist. Your task is to create a complete NestJS module that strictly follows Smicolon company standards.
+
+## Core Requirements
+
+### Import Pattern (CRITICAL)
+ALWAYS use absolute imports from barrel exports:
+
+```typescript
+// ✅ CORRECT - Absolute imports from barrel exports
+import { User } from 'src/users/entities'
+import { UsersService } from 'src/users/services'
+import { CreateUserDto } from 'src/users/dto'
+
+// ❌ WRONG - Relative imports
+import { User } from './entities/user.entity'
+import { User } from '../entities'
+```
+
+### Standard Entity Fields (MANDATORY)
+Every entity MUST include:
+
+```typescript
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn
+} from 'typeorm'
+
+@Entity('table_name')
+export class YourEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @DeleteDateColumn()
+  deletedAt?: Date
+
+  // Your custom fields here
+}
+```
+
+### Module Structure
+Every module needs these files:
+```
+src/module-name/
+├── index.ts                 # Barrel export (REQUIRED)
+├── module-name.module.ts
+├── entities/
+│   ├── index.ts            # Barrel export
+│   └── entity-name.entity.ts
+├── dto/
+│   ├── index.ts            # Barrel export
+│   ├── create-entity.dto.ts
+│   └── update-entity.dto.ts
+├── services/
+│   ├── index.ts            # Barrel export
+│   └── module-name.service.ts
+├── controllers/
+│   ├── index.ts            # Barrel export
+│   └── module-name.controller.ts
+└── guards/ (if needed)
+    ├── index.ts
+    └── custom.guard.ts
+```
+
+## Workflow
+
+1. **Understand Requirements**: Ask user for:
+   - Module name and purpose
+   - Entity fields needed
+   - API endpoints (CRUD operations)
+   - Access control needs
+
+2. **Generate Files**: Create all necessary files with:
+   - Entity with standard fields
+   - DTOs with validation
+   - Service with business logic
+   - Controller with guards
+   - Module configuration
+   - Barrel exports
+
+## Example Output
+
+### Entity
+```typescript
+// src/products/entities/product.entity.ts
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  ManyToOne,
+  JoinColumn
+} from 'typeorm'
+import { User } from 'src/users/entities'
+
+@Entity('products')
+export class Product {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @DeleteDateColumn()
+  deletedAt?: Date
+
+  @Column({ length: 255 })
+  name: string
+
+  @Column({ unique: true, length: 255 })
+  slug: string
+
+  @Column('text')
+  description: string
+
+  @Column('decimal', { precision: 10, scale: 2 })
+  price: number
+
+  @Column('int', { default: 0 })
+  stock: number
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'created_by_id' })
+  createdBy: User
+}
+```
+
+### DTOs
+```typescript
+// src/products/dto/create-product.dto.ts
+import { IsString, IsNumber, IsNotEmpty, Min, MaxLength } from 'class-validator'
+import { ApiProperty } from '@nestjs/swagger'
+
+export class CreateProductDto {
+  @ApiProperty({ example: 'Laptop', description: 'Product name' })
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  name: string
+
+  @ApiProperty({ example: 'laptop-2024', description: 'URL-friendly slug' })
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  slug: string
+
+  @ApiProperty({ example: 'High-performance laptop', description: 'Product description' })
+  @IsString()
+  @IsNotEmpty()
+  description: string
+
+  @ApiProperty({ example: 999.99, description: 'Product price' })
+  @IsNumber()
+  @Min(0)
+  price: number
+
+  @ApiProperty({ example: 10, description: 'Stock quantity', required: false })
+  @IsNumber()
+  @Min(0)
+  stock?: number
+}
+
+// src/products/dto/update-product.dto.ts
+import { PartialType } from '@nestjs/mapped-types'
+import { CreateProductDto } from './create-product.dto'
+
+export class UpdateProductDto extends PartialType(CreateProductDto) {}
+
+// src/products/dto/index.ts
+export * from './create-product.dto'
+export * from './update-product.dto'
+```
+
+### Service
+```typescript
+// src/products/services/product.service.ts
+import { Injectable, NotFoundException } from '@nestjs/common'
+import { InjectRepository } from '@nestjs/typeorm'
+import { Repository } from 'typeorm'
+import { Product } from 'src/products/entities'
+import { CreateProductDto, UpdateProductDto } from 'src/products/dto'
+
+@Injectable()
+export class ProductService {
+  constructor(
+    @InjectRepository(Product)
+    private readonly productRepository: Repository<Product>,
+  ) {}
+
+  async create(createProductDto: CreateProductDto, userId: string): Promise<Product> {
+    const product = this.productRepository.create({
+      ...createProductDto,
+      createdBy: { id: userId } as any,
+    })
+
+    return await this.productRepository.save(product)
+  }
+
+  async findAll(): Promise<Product[]> {
+    return await this.productRepository.find({
+      relations: ['createdBy'],
+      order: { createdAt: 'DESC' },
+    })
+  }
+
+  async findOne(id: string): Promise<Product> {
+    const product = await this.productRepository.findOne({
+      where: { id },
+      relations: ['createdBy'],
+    })
+
+    if (!product) {
+      throw new NotFoundException(`Product with ID ${id} not found`)
+    }
+
+    return product
+  }
+
+  async update(id: string, updateProductDto: UpdateProductDto): Promise<Product> {
+    const product = await this.findOne(id)
+
+    Object.assign(product, updateProductDto)
+
+    return await this.productRepository.save(product)
+  }
+
+  async remove(id: string): Promise<void> {
+    const product = await this.findOne(id)
+    await this.productRepository.softRemove(product)
+  }
+
+  async restock(id: string, quantity: number): Promise<Product> {
+    const product = await this.findOne(id)
+    product.stock += quantity
+    return await this.productRepository.save(product)
+  }
+}
+
+// src/products/services/index.ts
+export * from './product.service'
+```
+
+### Controller
+```typescript
+// src/products/controllers/product.controller.ts
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Patch,
+  Param,
+  Delete,
+  UseGuards,
+  Request,
+} from '@nestjs/common'
+import { ApiBearerAuth, ApiTags, ApiOperation } from '@nestjs/swagger'
+import { JwtAuthGuard } from 'src/auth/guards'
+import { ProductService } from 'src/products/services'
+import { CreateProductDto, UpdateProductDto } from 'src/products/dto'
+
+@ApiTags('products')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+@Controller('products')
+export class ProductController {
+  constructor(private readonly productService: ProductService) {}
+
+  @Post()
+  @ApiOperation({ summary: 'Create a new product' })
+  create(@Body() createProductDto: CreateProductDto, @Request() req) {
+    return this.productService.create(createProductDto, req.user.id)
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'Get all products' })
+  findAll() {
+    return this.productService.findAll()
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get a product by ID' })
+  findOne(@Param('id') id: string) {
+    return this.productService.findOne(id)
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update a product' })
+  update(@Param('id') id: string, @Body() updateProductDto: UpdateProductDto) {
+    return this.productService.update(id, updateProductDto)
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Delete a product' })
+  remove(@Param('id') id: string) {
+    return this.productService.remove(id)
+  }
+
+  @Post(':id/restock')
+  @ApiOperation({ summary: 'Restock a product' })
+  restock(@Param('id') id: string, @Body('quantity') quantity: number) {
+    return this.productService.restock(id, quantity)
+  }
+}
+
+// src/products/controllers/index.ts
+export * from './product.controller'
+```
+
+### Module
+```typescript
+// src/products/products.module.ts
+import { Module } from '@nestjs/common'
+import { TypeOrmModule } from '@nestjs/typeorm'
+import { Product } from './entities'
+import { ProductService } from './services'
+import { ProductController } from './controllers'
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Product])],
+  controllers: [ProductController],
+  providers: [ProductService],
+  exports: [ProductService],
+})
+export class ProductsModule {}
+
+// src/products/index.ts (Barrel export)
+export * from './products.module'
+export * from './entities'
+export * from './dto'
+export * from './services'
+export * from './controllers'
+```
+
+## Quality Checklist
+
+- [ ] UUID primary keys
+- [ ] Timestamps (createdAt, updatedAt)
+- [ ] Soft deletes (deletedAt)
+- [ ] Absolute imports from barrel exports
+- [ ] DTOs with class-validator
+- [ ] Guards on protected routes
+- [ ] Swagger/OpenAPI documentation
+- [ ] Barrel exports (index.ts) in all folders
+- [ ] Service methods with proper error handling
+- [ ] Repository pattern with TypeORM
+
+Now, ask the user what module they want to create!

package/packs/nestjs/rules/controllers.md

@@ -0,0 +1,92 @@
+---
+paths:
+  - "**/*.controller.ts"
+---
+
+# NestJS Controller Standards
+
+## Structure
+
+```typescript
+import { Controller, Get, Post, Body, UseGuards } from '@nestjs/common'
+import { JwtAuthGuard } from 'src/auth/guards'
+import { User } from 'src/users/entities'
+import { UsersService } from 'src/users/services'
+import { CreateUserDto, UserResponseDto } from 'src/users/dto'
+
+@Controller('users')
+@UseGuards(JwtAuthGuard)  // REQUIRED
+export class UsersController {
+  constructor(private readonly usersService: UsersService) {}
+
+  @Post()
+  async create(@Body() dto: CreateUserDto): Promise<UserResponseDto> {
+    return this.usersService.create(dto)
+  }
+}
+```
+
+## Requirements
+
+- Guards on all protected routes (@UseGuards)
+- DTOs for all inputs
+- Response DTOs for outputs
+- Absolute imports from barrel exports
+- Constructor injection for dependencies
+
+## Import Pattern
+
+```typescript
+// CORRECT - Absolute imports from barrel exports
+import { UsersService } from 'src/users/services'
+import { CreateUserDto } from 'src/users/dto'
+import { User } from 'src/users/entities'
+
+// WRONG - Relative imports
+import { UsersService } from './users.service'
+import { CreateUserDto } from '../dto/create-user.dto'
+```
+
+## Method Decorators
+
+```typescript
+@Controller('users')
+@UseGuards(JwtAuthGuard)
+export class UsersController {
+  @Get()
+  findAll(): Promise<UserResponseDto[]> {
+    return this.usersService.findAll()
+  }
+
+  @Get(':id')
+  findOne(@Param('id', ParseUUIDPipe) id: string): Promise<UserResponseDto> {
+    return this.usersService.findOne(id)
+  }
+
+  @Post()
+  create(@Body() dto: CreateUserDto): Promise<UserResponseDto> {
+    return this.usersService.create(dto)
+  }
+
+  @Patch(':id')
+  update(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: UpdateUserDto,
+  ): Promise<UserResponseDto> {
+    return this.usersService.update(id, dto)
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseUUIDPipe) id: string): Promise<void> {
+    return this.usersService.remove(id)
+  }
+}
+```
+
+## Forbidden Patterns
+
+- Controllers without @UseGuards
+- Direct repository access (use services)
+- Business logic in controllers
+- Any type in parameters or return types

package/packs/nestjs/rules/dto.md

@@ -0,0 +1,124 @@
+---
+paths:
+  - "**/*.dto.ts"
+---
+
+# NestJS DTO Standards
+
+## Structure
+
+```typescript
+import { IsEmail, IsString, MinLength, IsOptional } from 'class-validator'
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger'
+
+export class CreateUserDto {
+  @ApiProperty({ description: 'User email address' })
+  @IsEmail()
+  email: string
+
+  @ApiProperty({ description: 'User password', minLength: 8 })
+  @IsString()
+  @MinLength(8)
+  password: string
+
+  @ApiPropertyOptional({ description: 'User first name' })
+  @IsOptional()
+  @IsString()
+  firstName?: string
+}
+```
+
+## Requirements
+
+- class-validator decorators for validation
+- @nestjs/swagger decorators for API documentation
+- Separate DTOs for create, update, response
+- Export from barrel (index.ts)
+
+## Naming Convention
+
+- Create DTOs: `Create{Entity}Dto`
+- Update DTOs: `Update{Entity}Dto`
+- Response DTOs: `{Entity}ResponseDto`
+- Query DTOs: `{Entity}QueryDto`
+
+## Update DTOs with PartialType
+
+```typescript
+import { PartialType } from '@nestjs/swagger'
+import { CreateUserDto } from './create-user.dto'
+
+export class UpdateUserDto extends PartialType(CreateUserDto) {}
+```
+
+## Response DTOs
+
+```typescript
+import { Exclude, Expose } from 'class-transformer'
+
+export class UserResponseDto {
+  @Expose()
+  id: string
+
+  @Expose()
+  email: string
+
+  @Expose()
+  firstName: string
+
+  @Expose()
+  createdAt: Date
+
+  @Exclude()
+  password: string  // Never expose
+}
+```
+
+## Validation Examples
+
+```typescript
+import {
+  IsEmail,
+  IsString,
+  MinLength,
+  MaxLength,
+  IsUUID,
+  IsEnum,
+  IsInt,
+  Min,
+  Max,
+  IsArray,
+  ValidateNested,
+} from 'class-validator'
+import { Type } from 'class-transformer'
+
+export class CreateOrderDto {
+  @IsUUID()
+  userId: string
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => OrderItemDto)
+  items: OrderItemDto[]
+
+  @IsEnum(PaymentMethod)
+  paymentMethod: PaymentMethod
+}
+
+export class OrderItemDto {
+  @IsUUID()
+  productId: string
+
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  quantity: number
+}
+```
+
+## Forbidden Patterns
+
+- DTOs without validation decorators
+- Exposing sensitive fields in response DTOs
+- Using `any` type
+- Missing Swagger documentation

package/packs/nestjs/rules/entities.md

@@ -0,0 +1,102 @@
+---
+paths:
+  - "**/*.entity.ts"
+---
+
+# NestJS Entity Standards
+
+## Structure
+
+```typescript
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+} from 'typeorm'
+
+@Entity('users')
+export class User {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @Column({ unique: true })
+  email: string
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @DeleteDateColumn()
+  deletedAt?: Date  // Soft delete
+}
+```
+
+## Requirements
+
+- UUID primary keys (@PrimaryGeneratedColumn('uuid'))
+- Timestamps (createdAt, updatedAt)
+- Soft delete (deletedAt with @DeleteDateColumn)
+- Explicit table name in @Entity()
+- Export from barrel (index.ts)
+
+## Relationships
+
+```typescript
+import { Entity, ManyToOne, OneToMany, JoinColumn } from 'typeorm'
+import { User } from 'src/users/entities'
+import { OrderItem } from 'src/orders/entities'
+
+@Entity('orders')
+export class Order {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(() => User, user => user.orders)
+  @JoinColumn({ name: 'user_id' })
+  user: User
+
+  @Column({ name: 'user_id' })
+  userId: string
+
+  @OneToMany(() => OrderItem, item => item.order)
+  items: OrderItem[]
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @DeleteDateColumn()
+  deletedAt?: Date
+}
+```
+
+## Column Options
+
+```typescript
+@Column({ length: 100 })
+firstName: string
+
+@Column({ type: 'decimal', precision: 10, scale: 2 })
+price: number
+
+@Column({ type: 'enum', enum: OrderStatus, default: OrderStatus.PENDING })
+status: OrderStatus
+
+@Column({ nullable: true })
+description?: string
+```
+
+## Forbidden Patterns
+
+- Auto-increment integer primary keys
+- Missing timestamps
+- Missing soft delete
+- No explicit table name
+- Relative imports