@smicolon/ai-kit 0.3.2 → 0.4.0

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

@@ -1,369 +0,0 @@
----
-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

@@ -1,92 +0,0 @@
----
-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

@@ -1,124 +0,0 @@
----
-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

@@ -1,102 +0,0 @@
----
-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