@neyugn/agent-kits 0.1.0

package/kits/coder/skills/database-design/scripts/schema_validator.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""
+Schema Validator - Database schema validation for AGT-Kit
+==========================================================
+
+Validates Prisma, Drizzle, TypeORM schemas and checks for common issues.
+
+Usage:
+    python3 .agent/skills/database-design/scripts/schema_validator.py <project_path>
+
+Checks:
+    - Prisma schema syntax and conventions
+    - Missing relations and indexes
+    - Naming conventions (PascalCase models, camelCase fields)
+    - Required fields (id, createdAt, updatedAt)
+"""
+
+import sys
+import json
+import re
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Any
+
+# Fix console encoding
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+except:
+    pass
+
+
+def find_schema_files(project_path: Path) -> List[tuple]:
+    """Find database schema files."""
+    schemas = []
+    
+    # Prisma
+    for f in project_path.glob('**/prisma/schema.prisma'):
+        if 'node_modules' not in str(f):
+            schemas.append(('prisma', f))
+    
+    # Drizzle
+    for pattern in ['**/drizzle/*.ts', '**/db/schema*.ts', '**/schema/*.ts']:
+        for f in project_path.glob(pattern):
+            if 'node_modules' not in str(f) and ('schema' in f.name.lower() or 'table' in f.name.lower()):
+                schemas.append(('drizzle', f))
+    
+    # TypeORM entities
+    for f in project_path.glob('**/entities/*.ts'):
+        if 'node_modules' not in str(f):
+            schemas.append(('typeorm', f))
+    
+    return schemas[:15]  # Limit
+
+
+def validate_prisma_schema(file_path: Path) -> Dict[str, Any]:
+    """Validate Prisma schema file."""
+    issues = []
+    passed = []
+    
+    try:
+        content = file_path.read_text(encoding='utf-8', errors='ignore')
+        
+        # Find all models
+        models = re.findall(r'model\s+(\w+)\s*{([^}]+)}', content, re.DOTALL)
+        
+        if models:
+            passed.append(f"Found {len(models)} models")
+        else:
+            issues.append("No models found in schema")
+            return {"passed": passed, "issues": issues}
+        
+        for model_name, model_body in models:
+            # Check PascalCase naming
+            if not model_name[0].isupper():
+                issues.append(f"Model '{model_name}' should be PascalCase")
+            
+            # Check for id field
+            if '@id' not in model_body:
+                issues.append(f"Model '{model_name}' missing @id field")
+            
+            # Check for timestamps
+            has_created = 'createdAt' in model_body or 'created_at' in model_body
+            has_updated = 'updatedAt' in model_body or 'updated_at' in model_body
+            
+            if not has_created:
+                issues.append(f"Model '{model_name}' missing createdAt (recommended)")
+            if not has_updated:
+                issues.append(f"Model '{model_name}' missing updatedAt (recommended)")
+            
+            # Check for index on foreign keys
+            fk_fields = re.findall(r'(\w+Id)\s+\w+', model_body)
+            for fk in fk_fields:
+                if f'@@index([{fk}])' not in content and f'@@index(["{fk}"])' not in content:
+                    issues.append(f"Consider @@index([{fk}]) in {model_name}")
+        
+        # Check for enums
+        enums = re.findall(r'enum\s+(\w+)\s*{', content)
+        if enums:
+            passed.append(f"Found {len(enums)} enums")
+            for enum_name in enums:
+                if not enum_name[0].isupper():
+                    issues.append(f"Enum '{enum_name}' should be PascalCase")
+        
+        # Check for datasource
+        if 'datasource' in content:
+            passed.append("Datasource configured")
+        else:
+            issues.append("Missing datasource configuration")
+        
+        # Check for generator
+        if 'generator' in content:
+            passed.append("Generator configured")
+        
+    except Exception as e:
+        issues.append(f"Parse error: {str(e)[:50]}")
+    
+    return {"passed": passed, "issues": issues}
+
+
+def validate_drizzle_schema(file_path: Path) -> Dict[str, Any]:
+    """Validate Drizzle schema file."""
+    issues = []
+    passed = []
+    
+    try:
+        content = file_path.read_text(encoding='utf-8', errors='ignore')
+        
+        # Check for table definitions
+        tables = re.findall(r'(?:export\s+const|const)\s+(\w+)\s*=\s*(?:pgTable|mysqlTable|sqliteTable)', content)
+        
+        if tables:
+            passed.append(f"Found {len(tables)} tables")
+        else:
+            issues.append("No table definitions found")
+        
+        # Check for id columns
+        if 'primaryKey' in content or '.primaryKey()' in content:
+            passed.append("Primary keys defined")
+        else:
+            issues.append("Missing primary key definitions")
+        
+        # Check for timestamps
+        if 'timestamp' in content.lower() or 'createdAt' in content:
+            passed.append("Timestamp fields found")
+        
+        # Check for relations
+        if 'relations' in content:
+            passed.append("Relations defined")
+        
+    except Exception as e:
+        issues.append(f"Parse error: {str(e)[:50]}")
+    
+    return {"passed": passed, "issues": issues}
+
+
+def validate_typeorm_entity(file_path: Path) -> Dict[str, Any]:
+    """Validate TypeORM entity file."""
+    issues = []
+    passed = []
+    
+    try:
+        content = file_path.read_text(encoding='utf-8', errors='ignore')
+        
+        # Check for @Entity decorator
+        if '@Entity' in content:
+            passed.append("@Entity decorator found")
+        else:
+            issues.append("Missing @Entity decorator")
+        
+        # Check for @PrimaryGeneratedColumn or @PrimaryColumn
+        if '@PrimaryGeneratedColumn' in content or '@PrimaryColumn' in content:
+            passed.append("Primary key defined")
+        else:
+            issues.append("Missing primary key column")
+        
+        # Check for @CreateDateColumn
+        if '@CreateDateColumn' in content:
+            passed.append("CreateDateColumn found")
+        else:
+            issues.append("Consider adding @CreateDateColumn")
+        
+    except Exception as e:
+        issues.append(f"Parse error: {str(e)[:50]}")
+    
+    return {"passed": passed, "issues": issues}
+
+
+def main():
+    project_path = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
+    
+    print(f"\n{'='*60}")
+    print(f"[AGT-KIT SCHEMA VALIDATOR] Database Schema Check")
+    print(f"{'='*60}")
+    print(f"Project: {project_path}")
+    print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("-"*60)
+    
+    schemas = find_schema_files(project_path)
+    print(f"Found {len(schemas)} schema files")
+    
+    if not schemas:
+        output = {
+            "script": "schema_validator",
+            "skill": "database-design",
+            "project": str(project_path),
+            "schemas_checked": 0,
+            "passed": True,
+            "message": "No schema files found"
+        }
+        print(json.dumps(output, indent=2))
+        sys.exit(0)
+    
+    all_results = []
+    total_issues = 0
+    
+    for schema_type, file_path in schemas:
+        print(f"\n📄 {file_path.name} ({schema_type})")
+        
+        if schema_type == 'prisma':
+            result = validate_prisma_schema(file_path)
+        elif schema_type == 'drizzle':
+            result = validate_drizzle_schema(file_path)
+        elif schema_type == 'typeorm':
+            result = validate_typeorm_entity(file_path)
+        else:
+            result = {"passed": [], "issues": []}
+        
+        # Print results
+        for item in result["passed"]:
+            print(f"  ✅ {item}")
+        for item in result["issues"][:5]:
+            print(f"  ⚠️  {item}")
+        
+        if len(result["issues"]) > 5:
+            print(f"  ... and {len(result['issues']) - 5} more issues")
+        
+        all_results.append({
+            "file": str(file_path.name),
+            "type": schema_type,
+            **result
+        })
+        total_issues += len(result["issues"])
+    
+    # Summary
+    print("\n" + "="*60)
+    print("SUMMARY")
+    print("="*60)
+    
+    # Schema issues are warnings, not failures
+    passed = total_issues < 10
+    
+    if passed:
+        print(f"✅ Schema validation passed ({total_issues} minor issues)")
+    else:
+        print(f"⚠️  Schema needs review ({total_issues} issues)")
+    
+    output = {
+        "script": "schema_validator",
+        "skill": "database-design",
+        "project": str(project_path),
+        "schemas_checked": len(schemas),
+        "total_issues": total_issues,
+        "passed": passed,
+        "results": all_results
+    }
+    
+    print("\n" + json.dumps(output, indent=2))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/kits/coder/skills/database-design/scripts/validate.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Example validator for database-design
+
+Usage:
+    python validate.py <project_path>
+"""
+
+import sys
+from pathlib import Path
+
+
+def validate(project_path: str) -> dict:
+    """Main validation logic"""
+    results = {
+        'errors': [],
+        'warnings': [],
+        'passed': []
+    }
+    
+    # TODO: Add validation logic
+    results['passed'].append('Placeholder validation passed')
+    
+    return results
+
+
+def print_results(results: dict):
+    """Pretty print results"""
+    print("\n🔍 Validation Results\n")
+    
+    if results['errors']:
+        print(f"❌ Errors ({len(results['errors'])})")
+        for error in results['errors']:
+            print(f"  - {error}")
+    
+    if results['warnings']:
+        print(f"\n⚠️  Warnings ({len(results['warnings'])})")
+        for warning in results['warnings']:
+            print(f"  - {warning}")
+    
+    if results['passed']:
+        print(f"\n✅ Passed ({len(results['passed'])})")
+        for passed in results['passed']:
+            print(f"  - {passed}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python validate.py <project_path>")
+        sys.exit(1)
+    
+    project_path = sys.argv[1]
+    results = validate(project_path)
+    print_results(results)
+    
+    sys.exit(1 if results['errors'] else 0)

package/kits/coder/skills/docker-patterns/SKILL.md

@@ -0,0 +1,240 @@
+---
+name: docker-patterns
+description: Docker containerization principles and decision-making. Use when writing Dockerfiles, optimizing image size, configuring Docker Compose, securing containers, or troubleshooting container issues. Covers multi-stage builds, security hardening, orchestration patterns.
+allowed-tools: Read, Write, Edit, Bash
+version: 1.0
+priority: HIGH
+---
+
+# Docker Patterns - Container Excellence
+
+> **Philosophy:** Containers should be **small, secure, and consistent** across all environments. Optimize for production from day one.
+
+---
+
+## Core Principles
+
+| Principle        | Rule                                                  |
+| ---------------- | ----------------------------------------------------- |
+| **Immutable**    | Build once, run anywhere - no runtime modifications   |
+| **Minimal**      | Only include what's needed - smaller = faster + safer |
+| **Secure**       | Non-root by default, no secrets in layers             |
+| **Reproducible** | Pin versions, multi-stage for consistent builds       |
+| **Observable**   | Health checks, structured logs, metrics endpoints     |
+
+---
+
+## Image Base Selection
+
+| Use Case                  | Recommended Base          | Size   |
+| ------------------------- | ------------------------- | ------ |
+| **Node.js production**    | `node:20-alpine`          | ~50MB  |
+| **Minimal static binary** | `scratch` or `distroless` | <10MB  |
+| **Python production**     | `python:3.12-slim`        | ~45MB  |
+| **General purpose**       | `alpine:3.19`             | ~5MB   |
+| **Debugging needed**      | `*-slim` variants         | ~100MB |
+
+> 🔴 **Avoid:** Full `node:20`, `python:3.12`, `ubuntu:latest` in production.
+
+---
+
+## Multi-Stage Build Pattern
+
+```dockerfile
+# Stage 1: Dependencies (cached aggressively)
+FROM node:20-alpine AS deps
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production && npm cache clean --force
+
+# Stage 2: Build (includes dev dependencies)
+FROM node:20-alpine AS build
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build && npm prune --production
+
+# Stage 3: Runtime (minimal)
+FROM node:20-alpine AS runtime
+RUN addgroup -g 1001 -S app && adduser -S app -u 1001
+WORKDIR /app
+COPY --from=deps --chown=app:app /app/node_modules ./node_modules
+COPY --from=build --chown=app:app /app/dist ./dist
+USER app
+EXPOSE 3000
+HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
+  CMD curl -f http://localhost:3000/health || exit 1
+CMD ["node", "dist/index.js"]
+```
+
+---
+
+## Layer Optimization Rules
+
+| Rule                          | Why                                      |
+| ----------------------------- | ---------------------------------------- |
+| **COPY package.json first**   | Deps layer cached until deps change      |
+| **Combine RUN commands**      | Fewer layers = smaller image             |
+| **Clean in same RUN**         | `npm ci && npm cache clean` not separate |
+| **Order by change frequency** | Least changing → Most changing           |
+| **.dockerignore complete**    | Exclude node_modules, .git, logs         |
+
+---
+
+## Security Hardening Checklist
+
+| Security Rule                | Implementation                      |
+| ---------------------------- | ----------------------------------- |
+| **Non-root user**            | `adduser` + `USER 1001`             |
+| **Pin base image versions**  | `node:20.10.0-alpine`, not `latest` |
+| **No secrets in Dockerfile** | Use build secrets or runtime env    |
+| **Minimal packages**         | No vim, curl unless needed          |
+| **Read-only filesystem**     | `--read-only` runtime flag          |
+| **Scan for vulnerabilities** | `docker scout`, `trivy`             |
+
+### Build Secrets Pattern (BuildKit)
+
+```dockerfile
+# syntax=docker/dockerfile:1
+FROM alpine
+RUN --mount=type=secret,id=api_key \
+    API_KEY=$(cat /run/secrets/api_key) && \
+    # Use API_KEY - it won't be in final layer
+```
+
+---
+
+## Docker Compose Patterns
+
+### Production-Ready Service
+
+```yaml
+services:
+  app:
+    build:
+      context: .
+      target: runtime
+    depends_on:
+      db:
+        condition: service_healthy
+    deploy:
+      resources:
+        limits:
+          cpus: "1.0"
+          memory: 512M
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    networks:
+      - backend
+    restart: unless-stopped
+
+  db:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
+    secrets:
+      - db_password
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD", "pg_isready"]
+      interval: 10s
+
+networks:
+  backend:
+    driver: bridge
+
+volumes:
+  postgres_data:
+
+secrets:
+  db_password:
+    file: ./secrets/db_password.txt
+```
+
+---
+
+## Decision Trees
+
+### When to Use Multi-Stage?
+
+```
+Is build output smaller than source?
+├── Yes → Use multi-stage (most apps)
+└── No → Single stage might be OK
+    └── Still need build tools at runtime?
+        ├── Yes → Single stage
+        └── No → Multi-stage anyway for security
+```
+
+### Which Base Image?
+
+```
+Need shell for debugging?
+├── Yes → alpine or slim variants
+└── No → Do you need libc?
+    ├── Yes → distroless
+    └── No → scratch (Go, Rust static binaries)
+```
+
+---
+
+## Anti-Patterns (DON'T)
+
+| ❌ Anti-Pattern                | ✅ Correct Approach                       |
+| ------------------------------ | ----------------------------------------- |
+| `FROM node:latest`             | `FROM node:20.10.0-alpine`                |
+| `RUN npm install` (not ci)     | `RUN npm ci --only=production`            |
+| Running as root                | Create user, `USER 1001`                  |
+| Secrets in ENV                 | Build secrets or external secrets manager |
+| `COPY . .` before package.json | Copy package.json first for caching       |
+| Separate RUN for cleanup       | Clean in same RUN command                 |
+| No .dockerignore               | Comprehensive .dockerignore               |
+| No health checks               | HEALTHCHECK instruction                   |
+| 1GB+ images                    | Multi-stage + alpine base                 |
+
+---
+
+## Common Issues & Fixes
+
+| Issue                      | Cause                    | Fix                                     |
+| -------------------------- | ------------------------ | --------------------------------------- |
+| **Slow builds**            | Cache invalidation       | COPY package.json before source         |
+| **Large images**           | Build tools in prod      | Multi-stage, distroless                 |
+| **Permission errors**      | Root ownership           | `--chown` in COPY, proper USER          |
+| **Container won't start**  | CMD syntax error         | Use exec form `["node", "app.js"]`      |
+| **Can't connect services** | Network misconfiguration | Custom networks, service names as hosts |
+| **Data lost on restart**   | No volume                | Named volumes for persistence           |
+
+---
+
+## 🔴 Self-Check Before Completing
+
+| Check                   | Question                                   |
+| ----------------------- | ------------------------------------------ |
+| ✅ **Multi-stage?**     | Is build separated from runtime?           |
+| ✅ **Non-root?**        | Container runs as non-root user?           |
+| ✅ **Pinned versions?** | Base image and deps have explicit version? |
+| ✅ **Health check?**    | HEALTHCHECK or compose healthcheck?        |
+| ✅ **Secrets safe?**    | No secrets in layers or ENV?               |
+| ✅ **Image size?**      | Under 500MB for typical apps?              |
+| ✅ **.dockerignore?**   | Excludes node_modules, .git, logs?         |
+
+---
+
+## Related Skills
+
+| Need                  | Skill                     |
+| --------------------- | ------------------------- |
+| CI/CD pipelines       | `github-actions` (future) |
+| Kubernetes deployment | `kubernetes-patterns`     |
+| Server management     | `server-management`       |
+| Deployment workflows  | `deployment-procedures`   |
+
+---
+
+> **Remember:** A well-built container is invisible infrastructure. If you're debugging container issues in production, something went wrong at build time.