@wipal/agent-team 1.0.0

package/.claude/skills/domain/backend/testing-be/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: testing-be
+description: |
+  Backend testing patterns with Jest, Vitest, and integration testing. Use when:
+  writing unit tests, integration tests, API tests, or when user mentions "test",
+  "unit test", "integration test", "API test", "mock", "fixture". Test behavior,
+  not implementation.
+version: 1.0.0
+category: backend
+tags:
+  - testing
+  - unit-test
+  - integration-test
+  - api-test
+depends_on:
+  - code-review
+  - api-design
+recommends: []
+used_by: []
+---
+
+# Skill: Testing BE
+
+## Core Principle
+**Test behavior, not implementation.** Good tests survive refactors. They document expected behavior.
+
+## Testing Pyramid
+
+```
+         ▲
+        /E2E\         Few, slow
+       /─────\
+      /  API  \       Some, medium
+     /─────────\
+    /  Unit     \     Many, fast
+   /─────────────\
+```
+
+## Hard Rules
+
+1. **NEVER test implementation** - Test behavior/output
+2. **NEVER share state between tests** - Each test is isolated
+3. **ALWAYS clean up resources** - Close connections, delete data
+4. **ALWAYS use descriptive names** - `should_..._when_...`
+5. **ALWAYS mock external services** - No real API calls
+
+## Unit Tests
+
+```typescript
+// userService.test.ts
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { UserService } from './userService';
+import { UserRepository } from './userRepository';
+
+describe('UserService', () => {
+  let service: UserService;
+  let mockRepo: UserRepository;
+
+  beforeEach(() => {
+    mockRepo = {
+      findById: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+    };
+    service = new UserService(mockRepo);
+  });
+
+  describe('getUser', () => {
+    it('should return user when found', async () => {
+      const mockUser = { id: '1', name: 'John' };
+      vi.mocked(mockRepo.findById).mockResolvedValue(mockUser);
+
+      const result = await service.getUser('1');
+
+      expect(result).toEqual(mockUser);
+      expect(mockRepo.findById).toHaveBeenCalledWith('1');
+    });
+
+    it('should throw NotFoundError when user not found', async () => {
+      vi.mocked(mockRepo.findById).mockResolvedValue(null);
+
+      await expect(service.getUser('999')).rejects.toThrow(NotFoundError);
+    });
+  });
+});
+```
+
+## Integration Tests
+
+```typescript
+// api.test.ts
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { FastifyInstance } from 'fastify';
+import { buildApp } from './app';
+import { prisma } from './db';
+
+describe('User API', () => {
+  let app: FastifyInstance;
+
+  beforeAll(async () => {
+    app = await buildApp();
+    await app.ready();
+  });
+
+  afterAll(async () => {
+    await app.close();
+    await prisma.$disconnect();
+  });
+
+  describe('GET /users/:id', () => {
+    it('should return user', async () => {
+      const user = await prisma.user.create({
+        data: { name: 'Test User', email: 'test@example.com' },
+      });
+
+      const response = await app.inject({
+        method: 'GET',
+        url: `/users/${user.id}`,
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(response.json()).toMatchObject({
+        id: user.id,
+        name: 'Test User',
+      });
+    });
+  });
+});
+```
+
+## Test Database
+
+```typescript
+// test/setup.ts
+import { PrismaClient } from '@prisma/client';
+import { execSync } from 'child_process';
+
+const prisma = new PrismaClient();
+
+beforeAll(async () => {
+  // Use test database
+  process.env.DATABASE_URL = 'postgresql://test:test@localhost:5432/test_db';
+
+  // Run migrations
+  execSync('npx prisma migrate deploy');
+});
+
+afterEach(async () => {
+  // Clean up between tests
+  const tables = ['User', 'Order', 'Product'];
+  for (const table of tables) {
+    await prisma.$executeRawUnsafe(`TRUNCATE TABLE "${table}" CASCADE`);
+  }
+});
+
+afterAll(async () => {
+  await prisma.$disconnect();
+});
+```
+
+## Common Mistakes
+
+| ❌ Mistake | ✅ Fix |
+|------------|--------|
+| Testing private methods | Test public interface |
+| Shared mutable state | Isolated test data |
+| Real external APIs | Mock them |
+| Slow tests | Use in-memory DB |
+| Flaky tests | Fix or delete |
+
+## Mocking Patterns
+
+```typescript
+// Mock module
+vi.mock('./emailService', () => ({
+  sendEmail: vi.fn().mockResolvedValue({ success: true }),
+}));
+
+// Mock environment
+vi.stubEnv('NODE_ENV', 'test');
+
+// Mock time
+vi.useFakeTimers();
+vi.setSystemTime(new Date('2024-01-01'));
+```
+
+## Test Naming
+
+```typescript
+// Pattern: should_[expected]_when_[condition]
+it('should_return_empty_list_when_no_users_exist')
+it('should_throw_ValidationError_when_email_invalid')
+it('should_create_order_when_valid_request')
+```
+
+## Quick Checklist
+
+- [ ] Each test is isolated
+- [ ] External services mocked
+- [ ] Database cleaned between tests
+- [ ] Descriptive test names
+- [ ] Fast test execution
+- [ ] CI integration

package/.claude/skills/domain/devops/ci-cd/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: ci-cd
+description: |
+  CI/CD pipeline design and implementation for GitHub Actions, GitLab CI.
+  Use when: setting up pipelines, automating builds, running tests automatically,
+  deploying code, or when user mentions "CI", "CD", "pipeline", "GitHub Actions",
+  "GitLab CI", "build", "deploy", "automation". Ensures reliable, fast pipelines.
+version: 1.0.0
+category: devops
+tags:
+  - ci-cd
+  - github-actions
+  - gitlab-ci
+  - automation
+  - pipeline
+depends_on:
+  - git-automation
+recommends:
+  - containerization
+  - deployment
+used_by:
+  - deployment
+---
+
+# Skill: CI/CD
+
+## Core Principle
+**Fast, reliable, automated pipelines.** Every commit should be tested. Every merge should be deployable.
+
+## Hard Rules
+
+1. **NEVER skip tests in CI** - Tests are mandatory
+2. **NEVER store secrets in code** - Use secrets management
+3. **ALWAYS fail fast** - Run fastest tests first
+4. **ALWAYS cache dependencies** - Speed matters
+5. **ALWAYS use specific action versions** - Not `@main` or `@latest`
+
+## Pipeline Stages
+
+```
+┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐
+│  Lint   │──▶│  Build  │──▶│  Test   │──▶│ Deploy  │
+└─────────┘   └─────────┘   └─────────┘   └─────────┘
+   (1 min)      (3 min)       (5 min)      (2 min)
+```
+
+## GitHub Actions Template
+
+```yaml
+# .github/workflows/ci.yml
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  NODE_VERSION: '20'
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          cache: 'npm'
+      - run: npm ci
+      - run: npm run lint
+
+  test:
+    runs-on: ubuntu-latest
+    needs: lint
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          cache: 'npm'
+      - run: npm ci
+      - run: npm run test:coverage
+      - uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+
+  build:
+    runs-on: ubuntu-latest
+    needs: test
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          cache: 'npm'
+      - run: npm ci
+      - run: npm run build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: build
+          path: dist/
+```
+
+## GitLab CI Template
+
+```yaml
+# .gitlab-ci.yml
+stages:
+  - lint
+  - test
+  - build
+  - deploy
+
+variables:
+  NODE_VERSION: '20'
+
+.node_template:
+  image: node:${NODE_VERSION}
+  cache:
+    paths:
+      - node_modules/
+
+lint:
+  extends: .node_template
+  stage: lint
+  script:
+    - npm ci
+    - npm run lint
+
+test:
+  extends: .node_template
+  stage: test
+  script:
+    - npm ci
+    - npm run test:coverage
+  coverage: '/Lines\s*:\s*(\d+.\d+)%/'
+
+build:
+  extends: .node_template
+  stage: build
+  script:
+    - npm ci
+    - npm run build
+  artifacts:
+    paths:
+      - dist/
+```
+
+## Common Mistakes
+
+| ❌ Mistake | ✅ Fix |
+|------------|--------|
+| Using `@main` for actions | Pin to version: `@v4.0.0` |
+| No caching | Add `cache: 'npm'` |
+| Running all tests at once | Parallelize, matrix strategy |
+| Secrets in code | Use GitHub/GitLab secrets |
+| Long pipelines | Fail fast, cache, parallelize |
+
+## Performance Optimization
+
+```yaml
+# Matrix strategy for parallel tests
+strategy:
+  matrix:
+    shard: [1/4, 2/4, 3/4, 4/4]
+steps:
+  - run: npm run test -- --shard=${{ matrix.shard }}
+```
+
+## Security Best Practices
+
+- Use `SECRETS` for sensitive data
+- Limit `GITHUB_TOKEN` permissions
+- Pin action versions
+- Scan for vulnerabilities
+- Use OIDC for cloud auth
+
+## Quick Checklist
+
+- [ ] Tests run on every PR
+- [ ] Dependencies cached
+- [ ] Actions pinned to versions
+- [ ] Secrets properly managed
+- [ ] Pipeline fails fast
+- [ ] Build artifacts uploaded
+- [ ] Coverage reported

package/.claude/skills/domain/devops/containerization/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: containerization
+description: |
+  Docker containerization patterns and best practices. Use when: creating
+  Dockerfiles, building images, optimizing container size, multi-stage builds,
+  or when user mentions "Docker", "container", "image", "Dockerfile", "Compose".
+  Ensures efficient, secure, production-ready containers.
+version: 1.0.0
+category: devops
+tags:
+  - docker
+  - containers
+  - containerization
+  - images
+depends_on: []
+recommends:
+  - ci-cd
+  - deployment
+used_by:
+  - deployment
+  - ci-cd
+---
+
+# Skill: Containerization
+
+## Core Principle
+**Small, secure, immutable containers.** Every byte matters. Every layer counts.
+
+## Hard Rules
+
+1. **NEVER run as root** - Use non-root user
+2. **NEVER store secrets in images** - Use environment variables
+3. **ALWAYS use multi-stage builds** - Separate build from runtime
+4. **ALWAYS pin base image versions** - Not `:latest`
+5. **ALWAYS minimize layers** - Combine RUN commands
+
+## Multi-Stage Dockerfile
+
+```dockerfile
+# Build stage
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+
+# Runtime stage
+FROM node:20-alpine AS runtime
+
+# Security: non-root user
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S nextjs -u 1001
+
+WORKDIR /app
+
+# Copy only production dependencies
+COPY --from=builder --chown=nextjs:nodejs /app/node_modules ./node_modules
+COPY --chown=nextjs:nodejs . .
+
+USER nextjs
+
+EXPOSE 3000
+
+HEALTHCHECK --interval=30s --timeout=3s \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
+
+CMD ["node", "server.js"]
+```
+
+## Docker Compose Template
+
+```yaml
+# docker-compose.yml
+version: '3.8'
+
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: runtime
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - DATABASE_URL=${DATABASE_URL}
+    depends_on:
+      - db
+    healthcheck:
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+
+  db:
+    image: postgres:16-alpine
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    environment:
+      - POSTGRES_USER=${DB_USER}
+      - POSTGRES_PASSWORD=${DB_PASSWORD}
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${DB_USER}"]
+      interval: 10s
+      timeout: 3s
+
+volumes:
+  postgres_data:
+```
+
+## Common Mistakes
+
+| ❌ Mistake | ✅ Fix |
+|------------|--------|
+| `FROM node:latest` | `FROM node:20-alpine` |
+| Running as root | Add non-root user |
+| No health check | Add HEALTHCHECK |
+| Large images | Multi-stage builds |
+| Secrets in ENV | Use Docker secrets |
+| Single layer | Combine RUN commands |
+
+## Image Size Optimization
+
+```dockerfile
+# ❌ Bad: Multiple layers, large image
+RUN npm install
+RUN npm run build
+RUN npm prune
+
+# ✅ Good: Single layer, smaller image
+RUN npm ci --only=production && \
+    npm cache clean --force
+```
+
+## Security Checklist
+
+```dockerfile
+# 1. Non-root user
+USER appuser
+
+# 2. Read-only filesystem
+COPY --chown=appuser:appgroup . .
+
+# 3. No secrets
+# Use docker secrets or environment
+
+# 4. Minimal base image
+FROM alpine:3.19
+
+# 5. Health check
+HEALTHCHECK CMD curl -f http://localhost/health || exit 1
+```
+
+## Quick Commands
+
+```bash
+# Build
+docker build -t myapp:v1.0.0 .
+
+# Run
+docker run -d -p 3000:3000 --env-file .env myapp:v1.0.0
+
+# Debug
+docker exec -it <container> sh
+
+# Clean up
+docker system prune -af
+```
+
+## Quick Checklist
+
+- [ ] Multi-stage build used
+- [ ] Base image pinned to version
+- [ ] Non-root user configured
+- [ ] Health check added
+- [ ] Secrets not in image
+- [ ] Layers minimized
+- [ ] .dockerignore present