omgkit 2.1.1 → 2.3.0

package/plugin/skills/frameworks/django/SKILL.md

@@ -1,47 +1,181 @@
 ---
-name: django
-description: Django development. Use for Django projects, ORM, admin, templates.
+name: building-django-apps
+description: Builds enterprise Django applications with DRF, ORM optimization, async views, and Celery tasks. Use when creating Python web apps, REST APIs, or full-stack Django projects.
 ---
 
-# Django Skill
+# Django
 
-## Patterns
+## Quick Start
 
-### Model
 ```python
-from django.db import models
+# views.py
+from rest_framework import viewsets
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
 
-class User(models.Model):
-    email = models.EmailField(unique=True)
-    created_at = models.DateTimeField(auto_now_add=True)
+@api_view(['GET'])
+def health_check(request):
+    return Response({'status': 'ok'})
 
-    class Meta:
-        ordering = ['-created_at']
+class UserViewSet(viewsets.ModelViewSet):
+    queryset = User.objects.all()
+    serializer_class = UserSerializer
 ```
 
-### View
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Models | ORM, relationships, managers | [MODELS.md](MODELS.md) |
+| Views | ViewSets, APIView, async views | [VIEWS.md](VIEWS.md) |
+| Serializers | Validation, nested data | [SERIALIZERS.md](SERIALIZERS.md) |
+| Auth | JWT, permissions, policies | [AUTH.md](AUTH.md) |
+| Queries | select_related, prefetch, N+1 | [QUERIES.md](QUERIES.md) |
+| Testing | pytest-django, fixtures | [TESTING.md](TESTING.md) |
+
+## Common Patterns
+
+### Model with Relationships
+
 ```python
-from django.views import View
-from django.http import JsonResponse
+from django.db import models
+from uuid import uuid4
+
+class User(AbstractUser):
+    id = models.UUIDField(primary_key=True, default=uuid4, editable=False)
+    email = models.EmailField(unique=True)
+
+    USERNAME_FIELD = 'email'
 
-class UserView(View):
-    def get(self, request, id):
-        user = User.objects.get(id=id)
-        return JsonResponse({'email': user.email})
+    class Meta:
+        db_table = 'users'
+        indexes = [models.Index(fields=['email'])]
+
+class Organization(models.Model):
+    id = models.UUIDField(primary_key=True, default=uuid4, editable=False)
+    name = models.CharField(max_length=255)
+    slug = models.SlugField(unique=True)
+    owner = models.ForeignKey(User, on_delete=models.PROTECT, related_name='owned_orgs')
+    members = models.ManyToManyField(User, through='Membership', related_name='organizations')
 ```
 
-### Serializer (DRF)
+### DRF Serializers
+
 ```python
 from rest_framework import serializers
 
 class UserSerializer(serializers.ModelSerializer):
+    full_name = serializers.SerializerMethodField()
+
     class Meta:
         model = User
-        fields = ['id', 'email', 'created_at']
+        fields = ['id', 'email', 'full_name', 'created_at']
+        read_only_fields = ['id', 'created_at']
+
+    def get_full_name(self, obj):
+        return f"{obj.first_name} {obj.last_name}".strip()
+
+class UserCreateSerializer(serializers.ModelSerializer):
+    password = serializers.CharField(write_only=True, min_length=8)
+    password_confirm = serializers.CharField(write_only=True)
+
+    class Meta:
+        model = User
+        fields = ['email', 'password', 'password_confirm']
+
+    def validate(self, attrs):
+        if attrs['password'] != attrs['password_confirm']:
+            raise serializers.ValidationError({'password_confirm': 'Passwords must match'})
+        return attrs
+
+    def create(self, validated_data):
+        validated_data.pop('password_confirm')
+        return User.objects.create_user(**validated_data)
+```
+
+### ViewSet with Permissions
+
+```python
+from rest_framework import viewsets, permissions
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+class UserViewSet(viewsets.ModelViewSet):
+    permission_classes = [permissions.IsAuthenticated]
+
+    def get_queryset(self):
+        return User.objects.select_related('profile').prefetch_related('organizations')
+
+    def get_serializer_class(self):
+        if self.action == 'create':
+            return UserCreateSerializer
+        return UserSerializer
+
+    @action(detail=False, methods=['get', 'patch'])
+    def me(self, request):
+        if request.method == 'GET':
+            return Response(UserSerializer(request.user).data)
+        serializer = UserSerializer(request.user, data=request.data, partial=True)
+        serializer.is_valid(raise_exception=True)
+        serializer.save()
+        return Response(serializer.data)
+```
+
+## Workflows
+
+### API Development
+
+1. Create model and migration
+2. Create serializer with validation
+3. Create ViewSet or APIView
+4. Configure URL routing
+5. Write tests with pytest-django
+
+### Query Optimization
+
+```python
+# Avoid N+1 queries
+users = User.objects.select_related('profile').prefetch_related(
+    Prefetch('organizations', queryset=Organization.objects.only('id', 'name'))
+)
+
+# Use values() for lightweight queries
+User.objects.values('id', 'email', 'created_at')
+
+# Annotate for aggregations
+Organization.objects.annotate(member_count=Count('members'))
 ```
 
 ## Best Practices
-- Use class-based views
-- Use Django REST Framework
-- Use migrations
-- Use signals sparingly
+
+| Do | Avoid |
+|----|-------|
+| Use `select_related`/`prefetch_related` | N+1 queries |
+| Use serializers for validation | Manual validation |
+| Use custom managers | Query logic in views |
+| Use signals sparingly | Overusing signals |
+| Use Celery for heavy tasks | Sync operations for I/O |
+
+## Project Structure
+
+```
+project/
+├── manage.py
+├── config/
+│   ├── settings/
+│   ├── urls.py
+│   └── wsgi.py
+├── apps/
+│   ├── users/
+│   │   ├── models.py
+│   │   ├── serializers.py
+│   │   ├── views.py
+│   │   └── tests/
+│   └── organizations/
+├── common/
+│   ├── permissions.py
+│   └── pagination.py
+└── tests/
+```
+
+For detailed examples and patterns, see reference files above.

package/plugin/skills/frameworks/express/SKILL.md

@@ -1,55 +1,175 @@
 ---
-name: express
-description: Express.js development. Use for Express APIs, middleware, routing.
+name: building-express-apis
+description: Builds production Express.js APIs with TypeScript, middleware patterns, authentication, and error handling. Use when creating Node.js backends, REST APIs, or Express applications.
 ---
 
-# Express.js Skill
+# Express.js
 
-## Patterns
+## Quick Start
 
-### Basic Setup
-```javascript
+```typescript
 import express from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
 
 const app = express();
+
+app.use(helmet());
+app.use(cors());
 app.use(express.json());
-```
 
-### Routes
-```javascript
-app.get('/users', async (req, res) => {
-  const users = await db.users.findMany();
-  res.json(users);
+app.get('/api/health', (req, res) => {
+  res.json({ status: 'ok' });
 });
 
-app.post('/users', async (req, res) => {
-  const user = await db.users.create(req.body);
-  res.status(201).json(user);
-});
+app.listen(3000);
 ```
 
-### Middleware
-```javascript
-function authMiddleware(req, res, next) {
-  const token = req.headers.authorization;
-  if (!token) return res.status(401).json({ error: 'Unauthorized' });
-  req.user = verifyToken(token);
-  next();
-}
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Project Setup | TypeScript config, middleware stack | [SETUP.md](SETUP.md) |
+| Routing | Controllers, validation, async handlers | [ROUTING.md](ROUTING.md) |
+| Middleware | Auth, validation, error handling | [MIDDLEWARE.md](MIDDLEWARE.md) |
+| Database | Prisma/TypeORM integration | [DATABASE.md](DATABASE.md) |
+| Testing | Jest, supertest patterns | [TESTING.md](TESTING.md) |
+| Deployment | Docker, PM2, production config | [DEPLOYMENT.md](DEPLOYMENT.md) |
+
+## Common Patterns
+
+### Controller Pattern
+
+```typescript
+// controllers/users.ts
+import { Request, Response, NextFunction } from 'express';
+import { UserService } from '../services/UserService';
+
+export class UserController {
+  constructor(private userService: UserService) {}
+
+  getAll = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const users = await this.userService.findAll();
+      res.json(users);
+    } catch (error) {
+      next(error);
+    }
+  };
 
-app.use('/api', authMiddleware);
+  getById = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const user = await this.userService.findById(req.params.id);
+      if (!user) return res.status(404).json({ error: 'Not found' });
+      res.json(user);
+    } catch (error) {
+      next(error);
+    }
+  };
+}
 ```
 
 ### Error Handler
-```javascript
-app.use((err, req, res, next) => {
+
+```typescript
+// middleware/errorHandler.ts
+import { Request, Response, NextFunction } from 'express';
+
+export class AppError extends Error {
+  constructor(
+    public statusCode: number,
+    message: string,
+    public isOperational = true
+  ) {
+    super(message);
+  }
+}
+
+export function errorHandler(
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) {
+  if (err instanceof AppError) {
+    return res.status(err.statusCode).json({ error: err.message });
+  }
+
   console.error(err);
-  res.status(500).json({ error: 'Internal Server Error' });
-});
+  res.status(500).json({ error: 'Internal server error' });
+}
+```
+
+### Validation Middleware
+
+```typescript
+// middleware/validate.ts
+import { Request, Response, NextFunction } from 'express';
+import { ZodSchema } from 'zod';
+
+export function validate(schema: ZodSchema) {
+  return (req: Request, res: Response, next: NextFunction) => {
+    const result = schema.safeParse({
+      body: req.body,
+      query: req.query,
+      params: req.params,
+    });
+
+    if (!result.success) {
+      return res.status(400).json({ errors: result.error.issues });
+    }
+
+    next();
+  };
+}
+```
+
+## Workflows
+
+### API Development Workflow
+
+1. Define routes in `routes/index.ts`
+2. Create controller with business logic
+3. Add validation schemas with Zod
+4. Write tests with supertest
+5. Document with OpenAPI/Swagger
+
+### Middleware Order
+
+```
+1. Security (helmet, cors)
+2. Rate limiting
+3. Body parsing
+4. Logging
+5. Authentication
+6. Routes
+7. 404 handler
+8. Error handler
 ```
 
 ## Best Practices
-- Use async/await with try/catch
-- Use middleware for cross-cutting concerns
-- Validate input
-- Use proper status codes
+
+| Do | Avoid |
+|----|-------|
+| Use async/await with try-catch | Callback patterns |
+| Validate all inputs | Trusting client data |
+| Use typed request/response | `any` types |
+| Centralize error handling | Scattered try-catch |
+| Use dependency injection | Direct imports in controllers |
+
+## Project Structure
+
+```
+src/
+├── app.ts              # Express setup
+├── server.ts           # Server entry
+├── config/             # Environment config
+├── controllers/        # Route handlers
+├── middleware/         # Custom middleware
+├── routes/             # Route definitions
+├── services/           # Business logic
+├── utils/              # Helpers
+└── types/              # TypeScript types
+```
+
+For detailed examples and patterns, see reference files above.

package/plugin/skills/frameworks/fastapi/SKILL.md

@@ -1,58 +1,177 @@
 ---
-name: fastapi
-description: FastAPI development. Use for FastAPI projects, async APIs, Pydantic models.
+name: building-fastapi-apis
+description: Builds high-performance FastAPI applications with async/await, Pydantic v2, dependency injection, and SQLAlchemy. Use when creating Python REST APIs, async backends, or microservices.
 ---
 
-# FastAPI Skill
+# FastAPI
+
+## Quick Start
 
-## Setup
 ```python
-from fastapi import FastAPI, HTTPException, Depends
-from pydantic import BaseModel
+from fastapi import FastAPI
 
 app = FastAPI()
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok"}
+
+@app.get("/users/{user_id}")
+async def get_user(user_id: int):
+    return {"user_id": user_id}
 ```
 
-## Patterns
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Routing | Path params, query params, body | [ROUTING.md](ROUTING.md) |
+| Pydantic | Schemas, validation, serialization | [SCHEMAS.md](SCHEMAS.md) |
+| Dependencies | Injection, database sessions | [DEPENDENCIES.md](DEPENDENCIES.md) |
+| Auth | JWT, OAuth2, security utils | [AUTH.md](AUTH.md) |
+| Database | SQLAlchemy async, migrations | [DATABASE.md](DATABASE.md) |
+| Testing | pytest, AsyncClient | [TESTING.md](TESTING.md) |
+
+## Common Patterns
+
+### Pydantic Schemas
 
-### Route with Pydantic
 ```python
+from pydantic import BaseModel, EmailStr, Field, field_validator
+
 class UserCreate(BaseModel):
-    email: str
-    password: str
+    email: EmailStr
+    name: str = Field(..., min_length=2, max_length=100)
+    password: str = Field(..., min_length=8)
+
+    @field_validator("password")
+    @classmethod
+    def validate_password(cls, v: str) -> str:
+        if not any(c.isupper() for c in v):
+            raise ValueError("Must contain uppercase")
+        if not any(c.isdigit() for c in v):
+            raise ValueError("Must contain digit")
+        return v
 
-class User(BaseModel):
-    id: str
-    email: str
+class UserResponse(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
 
-@app.post("/users", response_model=User)
-async def create_user(user: UserCreate):
-    return await db.create_user(user)
+    id: UUID
+    email: EmailStr
+    name: str
+    created_at: datetime
 ```
 
 ### Dependency Injection
+
 ```python
-async def get_db():
-    db = Database()
-    try:
-        yield db
-    finally:
-        await db.close()
-
-@app.get("/users/{id}")
-async def get_user(id: str, db: Database = Depends(get_db)):
-    return await db.get_user(id)
+from fastapi import Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    async with async_session_maker() as session:
+        yield session
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: AsyncSession = Depends(get_db),
+) -> User:
+    payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
+    user = await db.get(User, payload["sub"])
+    if not user:
+        raise HTTPException(status_code=401)
+    return user
+
+# Type aliases for cleaner signatures
+DB = Annotated[AsyncSession, Depends(get_db)]
+CurrentUser = Annotated[User, Depends(get_current_user)]
 ```
 
-### Error Handling
+### Route with Service Layer
+
 ```python
-@app.exception_handler(ValueError)
-async def value_error_handler(request, exc):
-    return JSONResponse(status_code=400, content={"error": str(exc)})
+@router.get("/", response_model=PaginatedResponse[UserResponse])
+async def list_users(
+    db: DB,
+    current_user: CurrentUser,
+    page: int = Query(1, ge=1),
+    limit: int = Query(20, ge=1, le=100),
+):
+    service = UserService(db)
+    users, total = await service.list(offset=(page - 1) * limit, limit=limit)
+    return PaginatedResponse.create(data=users, total=total, page=page, limit=limit)
+
+@router.post("/", response_model=UserResponse, status_code=201)
+async def create_user(db: DB, user_in: UserCreate):
+    service = UserService(db)
+    if await service.get_by_email(user_in.email):
+        raise HTTPException(status_code=409, detail="Email exists")
+    return await service.create(user_in)
+```
+
+## Workflows
+
+### API Development
+
+1. Define Pydantic schemas for request/response
+2. Create service layer for business logic
+3. Add route with dependency injection
+4. Write tests with pytest-asyncio
+5. Document with OpenAPI (automatic)
+
+### Service Pattern
+
+```python
+class UserService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get_by_id(self, user_id: UUID) -> User | None:
+        result = await self.db.execute(
+            select(User).where(User.id == user_id)
+        )
+        return result.scalar_one_or_none()
+
+    async def create(self, data: UserCreate) -> User:
+        user = User(**data.model_dump(), hashed_password=hash_password(data.password))
+        self.db.add(user)
+        await self.db.commit()
+        return user
 ```
 
 ## Best Practices
-- Use Pydantic for validation
-- Use async/await
-- Use dependency injection
-- Document with OpenAPI
+
+| Do | Avoid |
+|----|-------|
+| Use async/await everywhere | Sync operations in async code |
+| Validate with Pydantic v2 | Manual validation |
+| Use dependency injection | Direct imports |
+| Handle errors with HTTPException | Generic exceptions |
+| Use type hints | `Any` types |
+
+## Project Structure
+
+```
+app/
+├── main.py
+├── core/
+│   ├── config.py
+│   ├── security.py
+│   └── deps.py
+├── api/
+│   └── v1/
+│       ├── __init__.py
+│       ├── users.py
+│       └── auth.py
+├── models/
+├── schemas/
+├── services/
+└── db/
+    ├── base.py
+    └── session.py
+tests/
+├── conftest.py
+└── test_users.py
+```
+
+For detailed examples and patterns, see reference files above.