@mmerterden/multi-agent-pipeline 20.36.0 → 20.37.1

package/pipeline/skills/shared/external/tailwind-css/references/code-examples.md

@@ -0,0 +1,91 @@
+# Tailwind CSS Code Examples
+
+Full code samples for the SKILL.md sections that link here. The rules and the decision guidance stay in SKILL.md; each heading below matches the SKILL.md section the code belongs to.
+
+## Form
+
+```html
+<form class="space-y-6 max-w-md mx-auto">
+  <div>
+    <label for="email" class="block text-sm font-medium text-gray-700 dark:text-gray-300">
+      Email
+    </label>
+    <input
+      type="email"
+      id="email"
+      class="
+        mt-1 block w-full rounded-lg border border-gray-300
+        px-4 py-2.5 text-gray-900
+        shadow-sm
+        placeholder:text-gray-400
+        focus:border-brand focus:ring-2 focus:ring-brand/20 focus:outline-none
+        dark:border-gray-600 dark:bg-gray-800 dark:text-gray-100
+        dark:focus:border-brand-light
+      "
+      placeholder="you@example.com"
+    />
+  </div>
+
+  <div>
+    <label for="password" class="block text-sm font-medium text-gray-700 dark:text-gray-300">
+      Password
+    </label>
+    <input
+      type="password"
+      id="password"
+      class="
+        mt-1 block w-full rounded-lg border border-gray-300
+        px-4 py-2.5 text-gray-900
+        shadow-sm
+        focus:border-brand focus:ring-2 focus:ring-brand/20 focus:outline-none
+        dark:border-gray-600 dark:bg-gray-800 dark:text-gray-100
+      "
+    />
+    <p class="mt-1 text-xs text-gray-500">Must be at least 8 characters.</p>
+  </div>
+
+  <button
+    type="submit"
+    class="
+      w-full rounded-lg bg-brand px-4 py-2.5
+      text-sm font-semibold text-white
+      shadow-sm
+      hover:bg-brand-dark focus:ring-2 focus:ring-brand/50 focus:outline-none
+      disabled:opacity-50 disabled:cursor-not-allowed
+      transition-colors
+    "
+  >
+    Sign in
+  </button>
+</form>
+```
+
+## Navigation
+
+```html
+<nav class="bg-white dark:bg-gray-900 border-b border-gray-200 dark:border-gray-700">
+  <div class="mx-auto max-w-7xl px-4 sm:px-6 lg:px-8">
+    <div class="flex h-16 items-center justify-between">
+      <div class="flex items-center gap-8">
+        <a href="/" class="text-xl font-bold text-brand">Logo</a>
+        <div class="hidden md:flex gap-6">
+          <a href="#" class="text-sm font-medium text-gray-900 dark:text-gray-100 hover:text-brand">
+            Home
+          </a>
+          <a href="#" class="text-sm font-medium text-gray-500 dark:text-gray-400 hover:text-brand">
+            Products
+          </a>
+          <a href="#" class="text-sm font-medium text-gray-500 dark:text-gray-400 hover:text-brand">
+            About
+          </a>
+        </div>
+      </div>
+      <button class="md:hidden p-2 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-800">
+        <svg class="h-6 w-6" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+          <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 6h16M4 12h16M4 18h16" />
+        </svg>
+      </button>
+    </div>
+  </div>
+</nav>
+```

package/pipeline/skills/shared/external/testing-backend/SKILL.md

@@ -38,70 +38,7 @@ tests/
 
 ### Fixtures and Factories
 
-```python
-# tests/conftest.py
-import pytest
-from httpx import AsyncClient, ASGITransport
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
-from app.main import app
-from app.database import Base, get_db
-
-TEST_DB_URL = "postgresql+asyncpg://test:test@localhost:5432/test_db"
-
-@pytest.fixture(scope="session")
-def anyio_backend():
-    return "asyncio"
-
-@pytest.fixture(scope="session")
-async def engine():
-    engine = create_async_engine(TEST_DB_URL)
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-    yield engine
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.drop_all)
-    await engine.dispose()
-
-@pytest.fixture
-async def db_session(engine):
-    async with AsyncSession(engine) as session:
-        async with session.begin():
-            yield session
-            await session.rollback()  # Rollback after each test
-
-@pytest.fixture
-async def client(db_session):
-    async def override_get_db():
-        yield db_session
-
-    app.dependency_overrides[get_db] = override_get_db
-    transport = ASGITransport(app=app)
-    async with AsyncClient(transport=transport, base_url="http://test") as client:
-        yield client
-    app.dependency_overrides.clear()
-```
-
-```python
-# tests/factories.py
-from dataclasses import dataclass, field
-import uuid
-
-@dataclass
-class UserFactory:
-    id: str = field(default_factory=lambda: str(uuid.uuid4()))
-    name: str = "Test User"
-    email: str = field(default_factory=lambda: f"user-{uuid.uuid4().hex[:8]}@test.com")
-    role: str = "user"
-
-    def build(self) -> dict:
-        return {"id": self.id, "name": self.name, "email": self.email, "role": self.role}
-
-    async def create(self, db: AsyncSession) -> User:
-        user = User(**self.build())
-        db.add(user)
-        await db.flush()
-        return user
-```
+Code for this section: [Backend testing examples](references/testing-examples.md).
 
 ### Unit Tests
 
@@ -154,152 +91,11 @@ class TestUserService:
 
 ### Integration Tests
 
-```python
-# tests/integration/test_api.py
-import pytest
-from httpx import AsyncClient
-
-class TestUserAPI:
-    async def test_create_user(self, client: AsyncClient):
-        response = await client.post("/api/v1/users", json={
-            "name": "Alice",
-            "email": "alice@example.com",
-            "role": "user",
-        })
-
-        assert response.status_code == 201
-        data = response.json()["data"]
-        assert data["name"] == "Alice"
-        assert data["email"] == "alice@example.com"
-        assert "id" in data
-
-    async def test_create_user_duplicate_email(self, client: AsyncClient, db_session):
-        # Arrange: create existing user
-        from tests.factories import UserFactory
-        await UserFactory(email="taken@example.com").create(db_session)
-
-        # Act
-        response = await client.post("/api/v1/users", json={
-            "name": "Bob",
-            "email": "taken@example.com",
-        })
-
-        # Assert
-        assert response.status_code == 409
-        assert response.json()["error"]["code"] == "DUPLICATE_EMAIL"
-
-    async def test_list_users_pagination(self, client: AsyncClient, db_session):
-        from tests.factories import UserFactory
-        for i in range(25):
-            await UserFactory(name=f"User {i}").create(db_session)
-
-        response = await client.get("/api/v1/users?per_page=10&page=1")
-
-        assert response.status_code == 200
-        body = response.json()
-        assert len(body["data"]) == 10
-        assert body["meta"]["total"] == 25
-        assert body["meta"]["has_next"] is True
-
-    async def test_get_user_not_found(self, client: AsyncClient):
-        response = await client.get("/api/v1/users/nonexistent-id")
-        assert response.status_code == 404
-```
+Code for this section: [Backend testing examples](references/testing-examples.md).
 
 ## Jest Patterns (Node.js)
 
-```typescript
-// tests/setup.ts
-import { PrismaClient } from '@prisma/client';
-
-const prisma = new PrismaClient();
-
-beforeEach(async () => {
-  // Clean tables in correct order (respect foreign keys)
-  await prisma.$transaction([
-    prisma.postTag.deleteMany(),
-    prisma.post.deleteMany(),
-    prisma.user.deleteMany(),
-  ]);
-});
-
-afterAll(async () => {
-  await prisma.$disconnect();
-});
-
-export { prisma };
-```
-
-```typescript
-// tests/unit/user-service.test.ts
-import { UserService } from '@/services/user-service';
-import { UserRepository } from '@/repositories/user-repository';
-
-jest.mock('@/repositories/user-repository');
-
-describe('UserService', () => {
-  let service: UserService;
-  let mockRepo: jest.Mocked<UserRepository>;
-
-  beforeEach(() => {
-    mockRepo = new UserRepository() as jest.Mocked<UserRepository>;
-    service = new UserService(mockRepo);
-  });
-
-  describe('getUserById', () => {
-    it('returns user when found', async () => {
-      const expected = { id: '1', name: 'Alice', email: 'alice@test.com' };
-      mockRepo.findById.mockResolvedValue(expected);
-
-      const result = await service.getUserById('1');
-
-      expect(result).toEqual(expected);
-      expect(mockRepo.findById).toHaveBeenCalledWith('1');
-    });
-
-    it('throws NotFoundError when user does not exist', async () => {
-      mockRepo.findById.mockResolvedValue(null);
-
-      await expect(service.getUserById('999')).rejects.toThrow('User not found');
-    });
-  });
-});
-```
-
-```typescript
-// tests/integration/user-api.test.ts
-import request from 'supertest';
-import { app } from '@/app';
-import { prisma } from '../setup';
-
-describe('POST /api/v1/users', () => {
-  it('creates a user and returns 201', async () => {
-    const response = await request(app)
-      .post('/api/v1/users')
-      .send({ name: 'Alice', email: 'alice@example.com' })
-      .expect(201);
-
-    expect(response.body.data).toMatchObject({
-      name: 'Alice',
-      email: 'alice@example.com',
-    });
-    expect(response.body.data.id).toBeDefined();
-
-    // Verify in database
-    const user = await prisma.user.findUnique({ where: { email: 'alice@example.com' } });
-    expect(user).not.toBeNull();
-  });
-
-  it('returns 422 for invalid email', async () => {
-    const response = await request(app)
-      .post('/api/v1/users')
-      .send({ name: 'Bob', email: 'invalid' })
-      .expect(422);
-
-    expect(response.body.error.details[0].field).toBe('email');
-  });
-});
-```
+Code for this section: [Backend testing examples](references/testing-examples.md).
 
 ## Database Testing
 
@@ -394,3 +190,7 @@ describe('User API Contract', () => {
 | Factory creates duplicate data | Unique constraints violated | Use random values in factories (UUID, random email) |
 | Mock not applied | Wrong import path or scope | Verify mock target matches actual import path |
 | DB schema out of sync | Migrations not run in test DB | Run migrations before test suite in CI |
+
+## References
+
+- [Backend testing examples](references/testing-examples.md): open when writing pytest fixtures, integration tests against a real database, or Jest tests for a Node.js service.

package/pipeline/skills/shared/external/testing-backend/references/testing-examples.md

@@ -0,0 +1,225 @@
+# Backend testing examples
+
+<!-- toc -->
+- [Fixtures and Factories](#fixtures-and-factories)
+- [Integration Tests](#integration-tests)
+- [Jest Patterns (Node.js)](#jest-patterns-nodejs)
+<!-- /toc -->
+
+Full code for pytest fixtures and factories, integration tests and Jest patterns. SKILL.md keeps the pyramid, the rules and troubleshooting.
+
+## Fixtures and Factories
+
+```python
+# tests/conftest.py
+import pytest
+from httpx import AsyncClient, ASGITransport
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from app.main import app
+from app.database import Base, get_db
+
+TEST_DB_URL = "postgresql+asyncpg://test:test@localhost:5432/test_db"
+
+@pytest.fixture(scope="session")
+def anyio_backend():
+    return "asyncio"
+
+@pytest.fixture(scope="session")
+async def engine():
+    engine = create_async_engine(TEST_DB_URL)
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    yield engine
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.drop_all)
+    await engine.dispose()
+
+@pytest.fixture
+async def db_session(engine):
+    async with AsyncSession(engine) as session:
+        async with session.begin():
+            yield session
+            await session.rollback()  # Rollback after each test
+
+@pytest.fixture
+async def client(db_session):
+    async def override_get_db():
+        yield db_session
+
+    app.dependency_overrides[get_db] = override_get_db
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        yield client
+    app.dependency_overrides.clear()
+```
+
+```python
+# tests/factories.py
+from dataclasses import dataclass, field
+import uuid
+
+@dataclass
+class UserFactory:
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    name: str = "Test User"
+    email: str = field(default_factory=lambda: f"user-{uuid.uuid4().hex[:8]}@test.com")
+    role: str = "user"
+
+    def build(self) -> dict:
+        return {"id": self.id, "name": self.name, "email": self.email, "role": self.role}
+
+    async def create(self, db: AsyncSession) -> User:
+        user = User(**self.build())
+        db.add(user)
+        await db.flush()
+        return user
+```
+
+## Integration Tests
+
+```python
+# tests/integration/test_api.py
+import pytest
+from httpx import AsyncClient
+
+class TestUserAPI:
+    async def test_create_user(self, client: AsyncClient):
+        response = await client.post("/api/v1/users", json={
+            "name": "Alice",
+            "email": "alice@example.com",
+            "role": "user",
+        })
+
+        assert response.status_code == 201
+        data = response.json()["data"]
+        assert data["name"] == "Alice"
+        assert data["email"] == "alice@example.com"
+        assert "id" in data
+
+    async def test_create_user_duplicate_email(self, client: AsyncClient, db_session):
+        # Arrange: create existing user
+        from tests.factories import UserFactory
+        await UserFactory(email="taken@example.com").create(db_session)
+
+        # Act
+        response = await client.post("/api/v1/users", json={
+            "name": "Bob",
+            "email": "taken@example.com",
+        })
+
+        # Assert
+        assert response.status_code == 409
+        assert response.json()["error"]["code"] == "DUPLICATE_EMAIL"
+
+    async def test_list_users_pagination(self, client: AsyncClient, db_session):
+        from tests.factories import UserFactory
+        for i in range(25):
+            await UserFactory(name=f"User {i}").create(db_session)
+
+        response = await client.get("/api/v1/users?per_page=10&page=1")
+
+        assert response.status_code == 200
+        body = response.json()
+        assert len(body["data"]) == 10
+        assert body["meta"]["total"] == 25
+        assert body["meta"]["has_next"] is True
+
+    async def test_get_user_not_found(self, client: AsyncClient):
+        response = await client.get("/api/v1/users/nonexistent-id")
+        assert response.status_code == 404
+```
+
+## Jest Patterns (Node.js)
+
+```typescript
+// tests/setup.ts
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+beforeEach(async () => {
+  // Clean tables in correct order (respect foreign keys)
+  await prisma.$transaction([
+    prisma.postTag.deleteMany(),
+    prisma.post.deleteMany(),
+    prisma.user.deleteMany(),
+  ]);
+});
+
+afterAll(async () => {
+  await prisma.$disconnect();
+});
+
+export { prisma };
+```
+
+```typescript
+// tests/unit/user-service.test.ts
+import { UserService } from '@/services/user-service';
+import { UserRepository } from '@/repositories/user-repository';
+
+jest.mock('@/repositories/user-repository');
+
+describe('UserService', () => {
+  let service: UserService;
+  let mockRepo: jest.Mocked<UserRepository>;
+
+  beforeEach(() => {
+    mockRepo = new UserRepository() as jest.Mocked<UserRepository>;
+    service = new UserService(mockRepo);
+  });
+
+  describe('getUserById', () => {
+    it('returns user when found', async () => {
+      const expected = { id: '1', name: 'Alice', email: 'alice@test.com' };
+      mockRepo.findById.mockResolvedValue(expected);
+
+      const result = await service.getUserById('1');
+
+      expect(result).toEqual(expected);
+      expect(mockRepo.findById).toHaveBeenCalledWith('1');
+    });
+
+    it('throws NotFoundError when user does not exist', async () => {
+      mockRepo.findById.mockResolvedValue(null);
+
+      await expect(service.getUserById('999')).rejects.toThrow('User not found');
+    });
+  });
+});
+```
+
+```typescript
+// tests/integration/user-api.test.ts
+import request from 'supertest';
+import { app } from '@/app';
+import { prisma } from '../setup';
+
+describe('POST /api/v1/users', () => {
+  it('creates a user and returns 201', async () => {
+    const response = await request(app)
+      .post('/api/v1/users')
+      .send({ name: 'Alice', email: 'alice@example.com' })
+      .expect(201);
+
+    expect(response.body.data).toMatchObject({
+      name: 'Alice',
+      email: 'alice@example.com',
+    });
+    expect(response.body.data.id).toBeDefined();
+
+    // Verify in database
+    const user = await prisma.user.findUnique({ where: { email: 'alice@example.com' } });
+    expect(user).not.toBeNull();
+  });
+
+  it('returns 422 for invalid email', async () => {
+    const response = await request(app)
+      .post('/api/v1/users')
+      .send({ name: 'Bob', email: 'invalid' })
+      .expect(422);
+
+    expect(response.body.error.details[0].field).toBe('email');
+  });
+});
+```

package/pipeline/skills/shared/external/typescript-patterns/SKILL.md

@@ -211,100 +211,15 @@ function handleInput(input: string | number | { value: string }) {
 
 ## Discriminated Unions
 
-```typescript
-// API response pattern
-type ApiResult<T> =
-  | { status: 'success'; data: T }
-  | { status: 'error'; error: { code: string; message: string } }
-  | { status: 'loading' };
-
-function handleResult<T>(result: ApiResult<T>): string {
-  switch (result.status) {
-    case 'success':
-      return JSON.stringify(result.data);
-    case 'error':
-      return `Error ${result.error.code}: ${result.error.message}`;
-    case 'loading':
-      return 'Loading...';
-  }
-}
+Model API results and events as unions keyed on a literal field (`status`, `type`), switch on that field, and end the switch with an `exhaustiveCheck(value: never)` helper so a new variant fails to compile.
 
-// Event system
-type AppEvent =
-  | { type: 'USER_LOGIN'; payload: { userId: string } }
-  | { type: 'USER_LOGOUT' }
-  | { type: 'ITEM_ADDED'; payload: { itemId: string; quantity: number } }
-  | { type: 'ITEM_REMOVED'; payload: { itemId: string } };
-
-function handleEvent(event: AppEvent): void {
-  switch (event.type) {
-    case 'USER_LOGIN':
-      console.log(`User ${event.payload.userId} logged in`);
-      break;
-    case 'USER_LOGOUT':
-      console.log('User logged out');
-      break;
-    case 'ITEM_ADDED':
-      console.log(`Added ${event.payload.quantity} of ${event.payload.itemId}`);
-      break;
-    case 'ITEM_REMOVED':
-      console.log(`Removed ${event.payload.itemId}`);
-      break;
-  }
-}
-
-// Exhaustive check helper
-function exhaustiveCheck(value: never): never {
-  throw new Error(`Unhandled value: ${JSON.stringify(value)}`);
-}
-```
+Code: [Discriminated Unions](references/code-examples.md#discriminated-unions).
 
 ## Zod for Runtime Validation
 
-```typescript
-import { z } from 'zod';
-
-// Define schema
-const UserSchema = z.object({
-  id: z.string().uuid(),
-  name: z.string().min(1).max(100),
-  email: z.string().email(),
-  role: z.enum(['admin', 'user', 'viewer']),
-  age: z.number().int().min(0).max(150).optional(),
-  tags: z.array(z.string()).default([]),
-});
-
-// Infer TypeScript type from schema
-type User = z.infer<typeof UserSchema>;
-
-// Validate at runtime
-function createUser(input: unknown): User {
-  return UserSchema.parse(input); // throws ZodError on failure
-}
-
-// Safe parse (no throw)
-function validateUser(input: unknown): ApiResult<User> {
-  const result = UserSchema.safeParse(input);
-  if (result.success) {
-    return { status: 'success', data: result.data };
-  }
-  return {
-    status: 'error',
-    error: { code: 'VALIDATION', message: result.error.message },
-  };
-}
+Define a schema once, infer the type with `z.infer`, use `parse` where failure should throw and `safeParse` where it should return a result, and derive create/update schemas with `omit`, `partial` and `required`.
 
-// Schema composition
-const CreateUserSchema = UserSchema.omit({ id: true });
-const UpdateUserSchema = UserSchema.partial().required({ id: true });
-
-// API request validation
-const PaginationSchema = z.object({
-  page: z.coerce.number().int().min(1).default(1),
-  limit: z.coerce.number().int().min(1).max(100).default(20),
-  sort: z.enum(['asc', 'desc']).default('desc'),
-});
-```
+Code: [Zod for Runtime Validation](references/code-examples.md#zod-for-runtime-validation).
 
 ## Do's
 
@@ -337,3 +252,7 @@ const PaginationSchema = z.object({
 | "Argument of type 'string' is not assignable to parameter of type 'X'" | Widened literal type | Use `as const` or `satisfies` to preserve literals |
 | Circular type reference | Self-referencing generic | Use `interface` instead of `type` for recursive structures |
 | Slow TypeScript compiler | Complex conditional types | Simplify type computations; avoid deeply nested generics |
+
+## References
+
+- [Code examples](references/code-examples.md): open for the full code behind Discriminated Unions, Zod for Runtime Validation.