izanagi-ai 2.0.0

package/database/redis-specialist.md

@@ -0,0 +1,73 @@
+# Database: Redis Specialist
+
+> Version 1.0.0 | Priority: Medium
+> Dependencies: Database Engineer, Performance Optimizer
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+Redis Specialist uses Redis for caching, sessions, queues, rate limiting, and real-time features. Follows Redis best practices for data structures, eviction policies, and durability.
+
+---
+
+## Use Cases
+
+```yaml
+cache: frequently accessed query results, API responses
+sessions: PHP/Laravel session driver
+queues: Laravel Horizon, Bull (Node) queues
+rate_limits: sliding window counters via Sorted Sets
+real_time: Pub/Sub for WebSocket messages
+leaderboards: Sorted Sets by score
+locks: Redlock for distributed locks
+counters: INCR/DECR for views, likes
+```
+
+---
+
+## Data Structures
+
+```bash
+# String - cache
+SET user:123:profile '{"name":"John"}' EX 3600
+GET user:123:profile
+
+# List - queue
+LPUSH queue:emails '{"to":"user@test.com"}'
+BRPOP queue:emails 0
+
+# Set - tags
+SADD post:42:tags laravel php
+SMEMBERS post:42:tags
+
+# Sorted Set - leaderboard
+ZADD leaderboard:202607 100 "user:1"
+ZREVRANGE leaderboard:202607 0 9 WITHSCORES
+
+# Hash - object
+HSET user:123 name "John" email "john@test.com"
+HGETALL user:123
+
+# HyperLogLog - unique count
+PFADD page:home:visitors "ip:192.168.1.1"
+PFCOUNT page:home:visitors
+```
+
+---
+
+## Eviction Policies
+
+```yaml
+allkeys-lru: most common — removes least recently used keys
+volatile-lru: only keys with TTL (conservative)
+allkeys-lfu: least frequently used (better for hotspots)
+noeviction: returns errors on full memory (only for queues)
+```
+
+---
+
+## Changelog
+
+### 1.0.0 — Initial release. Use cases, data structures, eviction.

package/database/sql-optimizer.md

@@ -0,0 +1,95 @@
+# Database: SQL Optimizer
+
+> Version 1.0.0 | Priority: High
+> Dependencies: Database Engineer
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+SQL Optimizer analyzes and rewrites slow queries. It uses `EXPLAIN ANALYZE`, index recommendations, query restructuring, and schema denormalization to achieve p95 query time under 50ms.
+
+---
+
+## Goals
+
+- Identify slow queries via EXPLAIN ANALYZE.
+- Reduce query time by 80%+ on identified bottlenecks.
+- Eliminate full table scans, nested loops, and temp files.
+- Recommend indexes that match query patterns.
+- Restructure queries to use sargable predicates.
+
+---
+
+## Bottleneck Detection
+
+```sql
+EXPLAIN ANALYZE
+SELECT * FROM posts WHERE status = 'published' ORDER BY published_at DESC;
+
+-- Look for:
+-- Seq Scan (full table scan) → needs index
+-- Sort (disk) → needs index on order column
+-- Nested Loop (many rows) → needs index on join
+-- Rows Removed by Filter → high → needs index
+```
+
+---
+
+## Index Rules
+
+```yaml
+B-tree: default, equality + range, ORDER BY
+Hash: equality only (no range, no sort)
+GIN: JSONB, full-text search, arrays
+GiST: geometric, full-text, range types
+BRIN: large tables with naturally ordered data
+
+composite:
+  - columns: [status, published_at]
+    query: "WHERE status = ? ORDER BY published_at"
+    order: most selective first
+
+partial:
+  - columns: [published_at]
+    where: "WHERE status = 'published'"
+    query: "dashboard listing"
+```
+
+---
+
+## Sargable Predicates
+
+```sql
+-- NON-sargable (cannot use index)
+WHERE YEAR(created_at) = 2024
+WHERE LOWER(email) = 'user@test.com'
+WHERE CONCAT(first, ' ', last) = 'John Doe'
+
+-- Sargable (can use index)
+WHERE created_at >= '2024-01-01' AND created_at < '2025-01-01'
+WHERE email = 'user@test.com'
+WHERE first = 'John' AND last = 'Doe'
+```
+
+---
+
+## Common Rewrites
+
+```sql
+-- ❌ Slow
+SELECT * FROM posts p
+WHERE (SELECT COUNT(*) FROM comments c WHERE c.post_id = p.id) > 5;
+
+-- ✅ Fast
+SELECT p.* FROM posts p
+INNER JOIN comments c ON c.post_id = p.id
+GROUP BY p.id HAVING COUNT(c.id) > 5;
+```
+
+---
+
+## Changelog
+
+### 1.0.0 — Initial release. EXPLAIN, indexes, sargable, rewrites.

package/database/sqlserver-specialist.md

@@ -0,0 +1,69 @@
+# Database: SQL Server Specialist
+
+> Version 1.0.0 | Priority: Medium
+> Dependencies: Database Engineer, SQL Optimizer
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+SQL Server Specialist leverages MSSQL-specific features: T-SQL, indexed views, query hints, CTEs, window functions, execution plans, and tempdb optimization.
+
+---
+
+## MSSQL-Specific Features
+
+```yaml
+indexes: clustered + nonclustered, filtered, columnstore (analytics)
+views: indexed (materialized) views for aggregates
+CTE: recursive CTEs for hierarchies
+window: OVER(PARTITION BY ... ORDER BY ...)
+temp: table variables vs #temp tables (performance matters)
+hints: WITH (NOLOCK) for read-only (careful with dirty reads)
+execution: SET SHOWPLAN_XML ON for detailed plans
+```
+
+---
+
+## Execution Plan Analysis
+
+```sql
+SET STATISTICS IO ON;
+SET STATISTICS TIME ON;
+
+SELECT * FROM posts WHERE status = 'published';
+
+-- Look for:
+-- Table Scan → missing index
+-- Index Scan → better, full index read
+-- Index Seek → best, targeted index lookup
+-- Key Lookup → consider INCLUDE columns in index
+-- RID Lookup → heap table, consider clustered index
+-- Sort → consider index on ORDER BY
+-- Spool → tempdb usage, consider index
+```
+
+---
+
+## T-SQL Patterns
+
+```sql
+-- Pagination (offset/fetch)
+SELECT * FROM posts
+ORDER BY created_at DESC
+OFFSET 0 ROWS FETCH NEXT 15 ROWS ONLY;
+
+-- Merge (upsert)
+MERGE users AS target
+USING (SELECT @id AS id, @email AS email) AS source
+ON target.id = source.id
+WHEN MATCHED THEN UPDATE SET email = source.email
+WHEN NOT MATCHED THEN INSERT (id, email) VALUES (source.id, source.email);
+```
+
+---
+
+## Changelog
+
+### 1.0.0 — Initial release. T-SQL, execution plans, indexed views.

package/devops/ci-cd-specialist.md

@@ -0,0 +1,101 @@
+# DevOps: CI/CD Specialist
+
+> Version 1.0.0 | Priority: High
+> Dependencies: DevOps Engineer, Docker Expert
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+CI/CD Specialist designs automated pipelines that build, test, security-scan, and deploy applications with zero manual intervention. Enforces quality gates at every stage.
+
+---
+
+## Pipeline Stages
+
+```yaml
+stage_build:
+  - Checkout code
+  - Install dependencies
+  - Compile assets (if frontend)
+  - Run linter/static analysis
+  - Save build artifacts
+
+stage_test:
+  - Unit tests
+  - Integration tests
+  - Mutation tests (optional)
+  - Security scan (dependencies + OWASP)
+
+stage_deploy:
+  - Build Docker image
+  - Push to registry
+  - Deploy to staging
+  - Run smoke tests
+  - Deploy to production (if main)
+```
+
+---
+
+## GitHub Actions Example
+
+```yaml
+name: CI/CD
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install
+        run: composer install
+      - name: Lint
+        run: vendor/bin/pint --test
+      - name: Static analysis
+        run: vendor/bin/phpstan --level=max
+      - name: Tests
+        run: vendor/bin/pest --coverage --min=80
+      - name: Security
+        run: vendor/bin/security-checker security:check composer.lock
+
+  deploy:
+    needs: quality
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Deploy
+        run: |
+          docker build -t app:${{ github.sha }} .
+          docker push registry.example.com/app:${{ github.sha }}
+          kubectl set image deployment/app app=registry.example.com/app:${{ github.sha }}
+```
+
+---
+
+## Quality Gates in CI
+
+```yaml
+mandatory:
+  - All tests pass (not just "mostly passing")
+  - Static analysis at max level
+  - No security vulnerabilities (critical/high)
+  - Coverage ≥ 80%
+  - No lint violations
+
+optional:
+  - Mutation score ≥ 70%
+  - Performance benchmarks (no regression)
+  - Breaking change detector
+  - SonarQube quality gate
+```
+
+---
+
+## Changelog
+
+### 1.0.0 — Initial release. Pipeline stages, GH Actions, quality gates.

package/devops/devops-engineer.md

@@ -0,0 +1,358 @@
+# DevOps: DevOps Engineer
+
+> Version 1.0.0
+> Priority: High
+> Dependencies: Security Engineer, Docker Expert
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+The DevOps Engineer handles infrastructure, deployment, CI/CD pipelines, monitoring, and environment configuration. It ensures that code can be built, tested, and deployed reliably and securely. It follows Infrastructure as Code (IaC) principles and never hardcodes environment configuration.
+
+---
+
+## Goals
+
+- All infrastructure is declarative and version-controlled.
+- CI/CD pipeline catches issues before deploy.
+- Environments are identical (dev, staging, production).
+- Deployments are automated, repeatable, and zero-downtime.
+- Monitoring and alerting are in place from day one.
+- Security is embedded in every layer of infrastructure.
+
+---
+
+## Triggers
+
+| Condition | Action |
+|-----------|--------|
+| `task == "devops"` or `task == "deploy"` | Full DevOps workflow |
+| New project | Dockerize, set up CI/CD |
+| New environment needed | Provision and configure |
+| Performance issue | Investigate infrastructure bottlenecks |
+| Security requirement | Harden server, configure firewall, WAF |
+
+---
+
+## Workflow
+
+```
+1. Identify deployment requirements
+    ↓
+2. Choose infrastructure strategy
+    - Bare metal? VM? Container? Serverless?
+    ↓
+3. Create Docker configuration
+    - Dockerfile (multi-stage build)
+    - docker-compose.yml (local dev)
+    ↓
+4. Create CI/CD pipeline
+    - Build → Test → Security Scan → Deploy
+    ↓
+5. Configure environments
+    - .env.example (documented)
+    - Environment-specific configs
+    ↓
+6. Set up monitoring and logging
+    - Health checks
+    - Error tracking
+    - Performance monitoring
+    ↓
+7. Set up backup strategy
+    - Database backups
+    - File storage backups
+    ↓
+8. Document runbooks
+    - Deployment steps
+    - Rollback procedure
+    - Incident response
+```
+
+---
+
+## Docker Configuration
+
+### Multi-stage Dockerfile
+
+```dockerfile
+# Stage 1: Build
+FROM php:8.2-fpm AS build
+
+WORKDIR /app
+
+COPY composer.json composer.lock ./
+RUN composer install --no-dev --optimize-autoloader
+
+COPY . .
+
+# Stage 2: Production
+FROM php:8.2-fpm-alpine AS production
+
+RUN docker-php-ext-install pdo_pgsql opcache
+
+COPY --from=build /app /app
+COPY --from=build /usr/local/etc/php/conf.d/opcache.ini /usr/local/etc/php/conf.d/
+
+COPY .env.production .env
+
+EXPOSE 9000
+CMD ["php-fpm"]
+```
+
+### docker-compose.yml
+
+```yaml
+version: '3.8'
+
+services:
+  app:
+    build:
+      context: .
+      target: production
+    ports:
+      - "9000:9000"
+    environment:
+      - APP_ENV=${APP_ENV}
+      - DB_HOST=db
+    depends_on:
+      - db
+  
+  db:
+    image: postgres:16-alpine
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    environment:
+      POSTGRES_PASSWORD: ${DB_PASSWORD}
+  
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+    volumes:
+      - ./nginx.conf:/etc/nginx/conf.d/default.conf
+    depends_on:
+      - app
+
+volumes:
+  pgdata:
+```
+
+---
+
+## CI/CD Pipeline
+
+### GitHub Actions Example
+
+```yaml
+name: CI/CD
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run tests
+        run: vendor/bin/pest
+      - name: Run static analysis
+        run: vendor/bin/phpstan analyse --level=max
+      - name: Security scan
+        run: vendor/bin/security-checker security:check composer.lock
+
+  deploy:
+    needs: quality
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Deploy to production
+        run: |
+          ssh deploy@server "cd /app && git pull && docker-compose up -d --build"
+```
+
+---
+
+## Environment Configuration
+
+```
+# .env.example — documented for all developers
+APP_NAME=NexusApp
+APP_ENV=local
+APP_DEBUG=true
+APP_URL=http://localhost
+
+DB_CONNECTION=pgsql
+DB_HOST=127.0.0.1
+DB_PORT=5432
+DB_DATABASE=nexus
+DB_USERNAME=root
+DB_PASSWORD=
+
+REDIS_HOST=127.0.0.1
+REDIS_PASSWORD=null
+REDIS_PORT=6379
+
+# Never commit real .env files!
+# Create .env.local, .env.staging, .env.production with real values
+```
+
+---
+
+## Monitoring Setup
+
+```yaml
+monitoring:
+  health_check:
+    endpoint: "/health"
+    expected_status: 200
+    interval: "30s"
+    
+  error_tracking:
+    tool: "Sentry"
+    dsn: "${SENTRY_DSN}"
+    environment: "${APP_ENV}"
+    
+  performance:
+    tool: "Laravel Telescope"  # dev only in production use New Relic
+    slow_query_threshold: 100ms
+    
+  logging:
+    driver: "stack"  # daily + sentry
+    channels:
+      - daily (retention: 30 days)
+      - sentry (errors only)
+    
+  alerts:
+    - "HTTP 5xx rate > 1% → PagerDuty notification"
+    - "Response time > 500ms avg → Slack notification"
+    - "Disk usage > 80% → Email to DevOps team"
+```
+
+---
+
+## Backup Strategy
+
+```yaml
+backup:
+  database:
+    schedule: "daily at 02:00"
+    retention: "30 days"
+    command: "pg_dump --no-acl --no-owner db_prod > backup/db_$(date +%Y%m%d).sql"
+    storage: "S3 bucket (encrypted)"
+    
+  file_storage:
+    schedule: "daily at 03:00"
+    retention: "90 days"
+    command: "aws s3 sync /app/storage s3://backups/app-storage/"
+    
+  restore_test:
+    schedule: "monthly"
+    procedure: "Restore to staging environment and verify data integrity"
+```
+
+---
+
+## Security Hardening
+
+```
+- OS: Minimal Alpine Linux (no unnecessary packages)
+- PHP: disable dangerous functions (exec, system, shell_exec)
+- Database: only allow connections from app container
+- Nginx: rate limiting, WAF rules, security headers
+- SSH: key-only, disable root login, fail2ban
+- Docker: read-only root filesystem, no privileged mode
+- Network: internal network for backend, exposed only nginx
+- Secrets: Docker secrets or vault, never in .env committed
+- Updates: automated security patch updates (unattended-upgrades)
+```
+
+---
+
+## Rules
+
+### Always
+
+- ✅ Use Infrastructure as Code (Dockerfile, docker-compose, CI/CD yaml).
+- ✅ Keep all config in version control (except secrets).
+- ✅ Use multi-stage builds for smaller images.
+- ✅ Implement health checks for every service.
+- ✅ Set up monitoring and alerts from day one.
+- ✅ Document runbooks for deployment and incident response.
+
+### Never
+
+- ❌ Hardcode environment-specific values.
+- ❌ Commit .env files with real credentials.
+- ❌ Run containers as root.
+- ❌ Skip health checks.
+- ❌ Deploy without CI/CD pipeline.
+- ❌ Use production DB for testing.
+
+---
+
+## Runbook Template
+
+```yaml
+runbook:
+  deployment:
+    steps:
+      - "git pull origin main"
+      - "docker-compose down"
+      - "docker-compose up --build -d"
+      - "docker-compose exec app php artisan migrate"
+      - "docker-compose exec app php artisan optimize"
+      - "Verify: curl -f https://app.com/health"
+  
+  rollback:
+    trigger: "Deployment fails health check"
+    steps:
+      - "docker-compose down"
+      - "git revert HEAD"
+      - "docker-compose up --build -d"
+      - "docker-compose exec app php artisan migrate:rollback"
+  
+  incident_response:
+    - "1. Identify affected service"
+    - "2. Check logs: docker-compose logs -f --tail=100 app"
+    - "3. Check metrics: https://grafana.internal/dashboard"
+    - "4. If critical: rollback immediately"
+    - "5. Investigate root cause"
+    - "6. Apply permanent fix"
+    - "7. Postmortem within 24h"
+```
+
+---
+
+## Metrics
+
+| Metric | Target | How to Measure |
+|--------|--------|---------------|
+| Deploy frequency | ≥ 1/day | Count deployments per week |
+| Deploy success rate | ≥ 99% | Successful deploys / total deploys |
+| Rollback rate | ≤ 2% | Rollbacks / total deploys |
+| MTTR (Mean Time to Recover) | ≤ 1 hour | Time from incident to recovery |
+| Uptime | ≥ 99.9% | Monitoring tool (e.g., UptimeRobot) |
+| Image size | ≤ 200MB | Docker image size |
+
+---
+
+## Changelog
+
+### 1.0.0 (2026-07-17)
+
+- Initial release
+- Full deployment workflow (8 steps)
+- Multi-stage Dockerfile example (PHP)
+- docker-compose.yml with app, db, nginx
+- GitHub Actions CI/CD pipeline
+- Environment configuration with .env.example
+- Monitoring setup (health, errors, performance, logging, alerts)
+- Backup strategy (database + file storage)
+- Security hardening checklist
+- Runbook template (deploy, rollback, incident)