aigroup-workflow 2.1.1 → 2.2.0

package/skills/fastapi-expert/references/pydantic-v2.md

@@ -1,135 +0,0 @@
-# Pydantic V2 Schemas
-
-## Schema Patterns
-
-```python
-from pydantic import BaseModel, EmailStr, Field, field_validator, model_validator
-from typing import Self
-
-class UserCreate(BaseModel):
-    email: EmailStr
-    password: str = Field(min_length=8)
-    username: str = Field(min_length=3, max_length=50)
-    age: int = Field(ge=18, le=120)
-
-    @field_validator('password')
-    @classmethod
-    def validate_password(cls, v: str) -> str:
-        if not any(c.isupper() for c in v):
-            raise ValueError('Password must contain uppercase')
-        if not any(c.isdigit() for c in v):
-            raise ValueError('Password must contain digit')
-        return v
-
-    @field_validator('username')
-    @classmethod
-    def validate_username(cls, v: str) -> str:
-        if not v.isalnum():
-            raise ValueError('Username must be alphanumeric')
-        return v.lower()
-
-class UserUpdate(BaseModel):
-    email: EmailStr | None = None
-    username: str | None = Field(None, min_length=3, max_length=50)
-```
-
-## ORM Mode (from_attributes)
-
-```python
-class UserResponse(BaseModel):
-    model_config = {"from_attributes": True}
-
-    id: int
-    email: EmailStr
-    username: str
-    is_active: bool = True
-    created_at: datetime
-
-# Usage with SQLAlchemy model
-user_response = UserResponse.model_validate(db_user)
-```
-
-## Model Validator
-
-```python
-class OrderCreate(BaseModel):
-    items: list[OrderItem]
-    discount_code: str | None = None
-    total: float
-
-    @model_validator(mode='after')
-    def validate_order(self) -> Self:
-        calculated = sum(item.price * item.quantity for item in self.items)
-        if abs(self.total - calculated) > 0.01:
-            raise ValueError('Total does not match items')
-        return self
-```
-
-## Nested Models
-
-```python
-class Address(BaseModel):
-    street: str
-    city: str
-    country: str = Field(default="US")
-
-class UserWithAddress(BaseModel):
-    name: str
-    addresses: list[Address] = Field(default_factory=list)
-```
-
-## Serialization Control
-
-```python
-class User(BaseModel):
-    model_config = {
-        "from_attributes": True,
-        "json_schema_extra": {
-            "example": {"email": "user@example.com", "username": "johndoe"}
-        }
-    }
-
-    id: int
-    email: EmailStr
-    password: str = Field(exclude=True)  # Never serialize
-    internal_id: str = Field(repr=False)  # Hide from repr
-
-# Serialize with aliases
-class ApiResponse(BaseModel):
-    model_config = {"populate_by_name": True}
-
-    user_id: int = Field(alias="userId", serialization_alias="user_id")
-```
-
-## Settings (Pydantic V2)
-
-```python
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-class Settings(BaseSettings):
-    model_config = SettingsConfigDict(
-        env_file=".env",
-        env_file_encoding="utf-8",
-        case_sensitive=True,
-    )
-
-    DATABASE_URL: str
-    SECRET_KEY: str
-    DEBUG: bool = False
-    CORS_ORIGINS: list[str] = ["http://localhost:3000"]
-    API_V1_PREFIX: str = "/api/v1"
-
-settings = Settings()
-```
-
-## Quick Reference
-
-| V1 Syntax | V2 Syntax |
-|-----------|-----------|
-| `@validator` | `@field_validator` |
-| `@root_validator` | `@model_validator` |
-| `class Config` | `model_config = {}` |
-| `orm_mode = True` | `from_attributes = True` |
-| `Optional[X]` | `X \| None` |
-| `.dict()` | `.model_dump()` |
-| `.parse_obj()` | `.model_validate()` |

package/skills/fastapi-expert/references/testing-async.md

@@ -1,159 +0,0 @@
-# Async Testing
-
-## Test Setup
-
-```python
-import pytest
-from httpx import AsyncClient, ASGITransport
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
-
-from app.main import app
-from app.core.deps import get_db
-from app.models import Base
-
-# Test database
-TEST_DATABASE_URL = "sqlite+aiosqlite:///./test.db"
-test_engine = create_async_engine(TEST_DATABASE_URL, echo=True)
-test_session = async_sessionmaker(test_engine, expire_on_commit=False)
-
-@pytest.fixture(scope="session")
-def anyio_backend():
-    return "asyncio"
-
-@pytest.fixture(scope="function")
-async def db():
-    async with test_engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-    async with test_session() as session:
-        yield session
-    async with test_engine.begin() as conn:
-        await conn.run_sync(Base.metadata.drop_all)
-
-@pytest.fixture
-async def client(db: AsyncSession):
-    def override_get_db():
-        return db
-
-    app.dependency_overrides[get_db] = override_get_db
-    async with AsyncClient(
-        transport=ASGITransport(app=app),
-        base_url="http://test"
-    ) as ac:
-        yield ac
-    app.dependency_overrides.clear()
-```
-
-## Endpoint Tests
-
-```python
-@pytest.mark.asyncio
-async def test_create_user(client: AsyncClient):
-    response = await client.post("/api/v1/users/", json={
-        "email": "test@example.com",
-        "username": "testuser",
-        "password": "Test1234"
-    })
-    assert response.status_code == 201
-    data = response.json()
-    assert data["email"] == "test@example.com"
-    assert "password" not in data
-
-@pytest.mark.asyncio
-async def test_get_user_not_found(client: AsyncClient):
-    response = await client.get("/api/v1/users/999")
-    assert response.status_code == 404
-
-@pytest.mark.asyncio
-async def test_list_users(client: AsyncClient, auth_headers: dict):
-    response = await client.get("/api/v1/users/", headers=auth_headers)
-    assert response.status_code == 200
-    assert isinstance(response.json(), list)
-```
-
-## Auth Helper Fixture
-
-```python
-@pytest.fixture
-async def test_user(db: AsyncSession) -> User:
-    user = User(
-        email="auth@test.com",
-        username="authuser",
-        hashed_password=hash_password("Test1234"),
-    )
-    db.add(user)
-    await db.commit()
-    await db.refresh(user)
-    return user
-
-@pytest.fixture
-async def auth_headers(test_user: User) -> dict:
-    token = create_access_token(sub=str(test_user.id))
-    return {"Authorization": f"Bearer {token}"}
-
-@pytest.mark.asyncio
-async def test_protected_endpoint(client: AsyncClient, auth_headers: dict):
-    response = await client.get("/api/v1/users/me", headers=auth_headers)
-    assert response.status_code == 200
-
-@pytest.mark.asyncio
-async def test_protected_endpoint_no_auth(client: AsyncClient):
-    response = await client.get("/api/v1/users/me")
-    assert response.status_code == 401
-```
-
-## Service Tests
-
-```python
-@pytest.mark.asyncio
-async def test_create_user_service(db: AsyncSession):
-    user_in = UserCreate(
-        email="service@test.com",
-        username="serviceuser",
-        password="Test1234"
-    )
-    user = await create_user_db(db, user_in)
-
-    assert user.id is not None
-    assert user.email == "service@test.com"
-
-@pytest.mark.asyncio
-async def test_get_user_not_found_service(db: AsyncSession):
-    user = await get_user_db(db, 999)
-    assert user is None
-
-@pytest.mark.asyncio
-async def test_duplicate_email(db: AsyncSession):
-    user_in = UserCreate(email="dup@test.com", username="user1", password="Test1234")
-    await create_user_db(db, user_in)
-
-    with pytest.raises(IntegrityError):
-        user_in2 = UserCreate(email="dup@test.com", username="user2", password="Test1234")
-        await create_user_db(db, user_in2)
-```
-
-## Mocking Dependencies
-
-```python
-from unittest.mock import AsyncMock, patch
-
-@pytest.mark.asyncio
-async def test_with_mock_service(client: AsyncClient):
-    mock_user = User(id=1, email="mock@test.com", username="mock")
-
-    with patch("app.api.v1.users.get_user_db", new_callable=AsyncMock) as mock:
-        mock.return_value = mock_user
-        response = await client.get("/api/v1/users/1")
-        assert response.status_code == 200
-        assert response.json()["email"] == "mock@test.com"
-```
-
-## Quick Reference
-
-| Component | Purpose |
-|-----------|---------|
-| `@pytest.mark.asyncio` | Mark async test |
-| `AsyncClient` | HTTP client |
-| `ASGITransport(app=app)` | Test transport |
-| `app.dependency_overrides` | Override deps |
-| `AsyncMock` | Mock async functions |
-| `pytest.raises()` | Assert exception |

package/skills/feature-forge/SKILL.md

@@ -1,98 +0,0 @@
----
-name: feature-forge
-description: Conducts structured requirements workshops to produce feature specifications, user stories, EARS-format functional requirements, acceptance criteria, and implementation checklists. Use when defining new features, gathering requirements, or writing specifications. Invoke for feature definition, requirements gathering, user stories, EARS format specs, PRDs, acceptance criteria, or requirement matrices.
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: workflow
-  triggers: requirements, specification, feature definition, user stories, EARS, planning
-  role: specialist
-  scope: design
-  output-format: document
-  related-skills: fullstack-guardian, spec-miner, test-master
----
-
-# Feature Forge
-
-Requirements specialist conducting structured workshops to define comprehensive feature specifications.
-
-## Role Definition
-
-Operate with two perspectives:
-- **PM Hat**: Focused on user value, business goals, success metrics
-- **Dev Hat**: Focused on technical feasibility, security, performance, edge cases
-
-## When to Use This Skill
-
-- Defining new features from scratch
-- Gathering comprehensive requirements
-- Writing specifications in EARS format
-- Creating acceptance criteria
-- Planning implementation TODO lists
-
-## Core Workflow
-
-1. **Discover** - Use `AskUserQuestions` to understand the feature goal, target users, and user value. Present structured choices where possible (e.g., user types, priority level).
-2. **Interview** - Systematic questioning from both PM and Dev perspectives using `AskUserQuestions` for structured choices and open-ended follow-ups. Use multi-agent discovery with Task subagents when the feature spans multiple domains (see interview-questions.md for guidance).
-3. **Document** - Write EARS-format requirements
-4. **Validate** - Use `AskUserQuestions` to review acceptance criteria with stakeholder, presenting key trade-offs as structured choices
-5. **Plan** - Create implementation checklist
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| EARS Syntax | `references/ears-syntax.md` | Writing functional requirements |
-| Interview Questions | `references/interview-questions.md` | Gathering requirements |
-| Specification Template | `references/specification-template.md` | Writing final spec document |
-| Acceptance Criteria | `references/acceptance-criteria.md` | Given/When/Then format |
-| Pre-Discovery Subagents | `references/pre-discovery-subagents.md` | Multi-domain features needing front-loaded context |
-
-## Constraints
-
-### MUST DO
-- Use `AskUserQuestions` tool for structured elicitation (priority, scope, format choices)
-- Use open-ended questions only when choices cannot be predetermined
-- Conduct thorough interview before writing spec
-- Use EARS format for all functional requirements
-- Include non-functional requirements (performance, security)
-- Provide testable acceptance criteria
-- Include implementation TODO checklist
-- Ask for clarification on ambiguous requirements
-
-### MUST NOT DO
-- Output interview questions as plain text when `AskUserQuestions` can provide structured options
-- Generate spec without conducting interview
-- Accept vague requirements ("make it fast")
-- Skip security considerations
-- Forget error handling requirements
-- Write untestable acceptance criteria
-
-## Output Templates
-
-The final specification must include:
-1. Overview and user value
-2. Functional requirements (EARS format)
-3. Non-functional requirements
-4. Acceptance criteria (Given/When/Then)
-5. Error handling table
-6. Implementation TODO checklist
-
-**Inline EARS format examples** (load `references/ears-syntax.md` for full syntax):
-```
-When <trigger>, the <system> shall <response>.
-Where <feature> is active, the <system> shall <behaviour>.
-The <system> shall <action> within <measure>.
-```
-
-**Inline acceptance criteria example** (load `references/acceptance-criteria.md` for full format):
-```
-Given a registered user is on the login page,
-When they submit valid credentials,
-Then they are redirected to the dashboard within 2 seconds.
-```
-
-Save as: `specs/{feature_name}.spec.md`

package/skills/feature-forge/references/acceptance-criteria.md

@@ -1,104 +0,0 @@
-# Acceptance Criteria
-
-## Given-When-Then Format
-
-```markdown
-### AC-001: [Scenario Name]
-Given [context/precondition]
-When [action taken]
-Then [expected result]
-```
-
-## Examples by Type
-
-### Happy Path
-
-```markdown
-### AC-001: Successful Login
-Given a registered user with valid credentials
-When they submit the login form
-Then they are redirected to the dashboard
-And a success message is displayed
-And their session is created
-
-### AC-002: Add Item to Cart
-Given a logged-in user viewing a product
-When they click "Add to Cart"
-Then the item appears in their cart
-And the cart badge updates with the count
-And a confirmation toast is shown
-```
-
-### Error Cases
-
-```markdown
-### AC-003: Invalid Login
-Given a user with incorrect password
-When they submit the login form
-Then an error message "Invalid credentials" is displayed
-And the password field is cleared
-And they remain on the login page
-
-### AC-004: Duplicate Email Registration
-Given an email already exists in the system
-When a new user tries to register with that email
-Then an error message "Email already registered" is displayed
-And the form is not submitted
-```
-
-### Edge Cases
-
-```markdown
-### AC-005: Empty Cart Checkout
-Given a user with an empty cart
-When they navigate to checkout
-Then they see "Your cart is empty" message
-And a "Continue Shopping" button is displayed
-
-### AC-006: Session Expiry
-Given a user whose session has expired
-When they try to perform any authenticated action
-Then they are redirected to login
-And a message "Session expired, please log in again" is shown
-And their intended action is preserved for after login
-```
-
-### Authorization
-
-```markdown
-### AC-007: Admin-Only Access
-Given a regular user (non-admin)
-When they try to access /admin/users
-Then they receive a 403 Forbidden response
-And are redirected to the home page
-And an "Access denied" message is shown
-
-### AC-008: Own Resource Only
-Given a user viewing another user's profile
-When they try to edit the profile
-Then the edit button is not visible
-And direct URL access returns 403
-```
-
-## INVEST Criteria
-
-Good acceptance criteria follow INVEST:
-
-| Criterion | Description | Check |
-|-----------|-------------|-------|
-| **I**ndependent | Can be tested alone | No dependencies on other ACs |
-| **N**egotiable | Details can be discussed | Not over-specified |
-| **V**aluable | Delivers user value | Ties to requirement |
-| **E**stimable | Effort can be estimated | Clear scope |
-| **S**mall | Testable in one session | Not too broad |
-| **T**estable | Pass/fail is clear | Objective criteria |
-
-## Quick Reference
-
-| Scenario Type | Given | When | Then |
-|---------------|-------|------|------|
-| Happy path | Valid state | Valid action | Success result |
-| Error | Invalid state/input | Action | Error message |
-| Edge case | Boundary condition | Action | Graceful handling |
-| Authorization | User role | Protected action | Appropriate access |
-| Concurrency | Multiple actors | Simultaneous action | Consistent state |

package/skills/feature-forge/references/ears-syntax.md

@@ -1,99 +0,0 @@
-# EARS Syntax
-
-## EARS Format
-
-Easy Approach to Requirements Syntax for clear, unambiguous requirements.
-
-### Basic Pattern
-
-```
-While <precondition>, when <trigger>, the system shall <response>.
-```
-
-### Pattern Types
-
-**Ubiquitous (Always True)**
-```
-The system shall [action].
-```
-Example: The system shall encrypt all passwords using bcrypt.
-
-**Event-Driven**
-```
-When [trigger], the system shall [action].
-```
-Example: When the user clicks "Submit", the system shall save the form data.
-
-**State-Driven**
-```
-While [state], the system shall [action].
-```
-Example: While the user is logged in, the system shall display the dashboard.
-
-**Conditional (Most Common)**
-```
-While [state], when [trigger], the system shall [action].
-```
-Example: While the cart contains items, when the user clicks "Checkout", the system shall navigate to the payment page.
-
-**Optional**
-```
-Where [feature enabled], the system shall [action].
-```
-Example: Where two-factor authentication is enabled, the system shall require a verification code.
-
-## Examples by Domain
-
-### Authentication
-
-```markdown
-**FR-AUTH-001**: Login
-While credentials are valid, when POST /auth/login is called,
-the system shall return JWT access token (15min) and refresh token (7d).
-
-**FR-AUTH-002**: Invalid Login
-When invalid credentials are provided,
-the system shall return 401 and increment failed login counter.
-
-**FR-AUTH-003**: Account Lockout
-While failed login count exceeds 5, when login is attempted,
-the system shall reject the attempt and require password reset.
-```
-
-### E-commerce
-
-```markdown
-**FR-CART-001**: Add to Cart
-While user is logged in, when they click "Add to Cart",
-the system shall add the item and update the cart badge count.
-
-**FR-CART-002**: Apply Coupon
-While the cart contains items, when a valid coupon code is applied,
-the system shall reduce the total by the discount amount.
-
-**FR-ORDER-001**: Checkout
-While payment method is valid, when user confirms order,
-the system shall create order, charge payment, and send confirmation email.
-```
-
-### Data Management
-
-```markdown
-**FR-EXPORT-001**: CSV Export
-While user has data access permission, when they click "Export",
-the system shall generate a CSV file and initiate download.
-
-**FR-DELETE-001**: Soft Delete
-When a resource is deleted,
-the system shall set deleted_at timestamp instead of removing the record.
-```
-
-## Quick Reference
-
-| Type | Structure | Use When |
-|------|-----------|----------|
-| Ubiquitous | shall [action] | Always applies |
-| Event | When [X], shall | On trigger |
-| State | While [X], shall | Continuous state |
-| Conditional | While [X], when [Y], shall | State + trigger |
-| Optional | Where [X], shall | Feature flag |