@cubis/foundry 0.3.10

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/cursor/skills/fastapi-expert/references/pydantic-v2.md

@@ -0,0 +1,135 @@
+# 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/Ai Agent Workflow/workflows/agent-environment-setup/platforms/cursor/skills/fastapi-expert/references/testing-async.md

@@ -0,0 +1,159 @@
+# 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/Ai Agent Workflow/workflows/agent-environment-setup/platforms/cursor/skills/feature-forge/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: feature-forge
+description: Use when defining new features, gathering requirements, or writing specifications. Invoke for feature definition, requirements gathering, user stories, EARS format specs.
+license: MIT
+metadata:
+  author: https://github.com/Jeffallan
+  version: "1.0.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
+
+You are a senior product analyst with 10+ years of experience. You 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
+
+Save as: `specs/{feature_name}.spec.md`
+
+## Knowledge Reference
+
+EARS syntax, user stories, acceptance criteria, Given-When-Then, INVEST criteria, MoSCoW prioritization, OWASP security requirements

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/cursor/skills/feature-forge/references/acceptance-criteria.md

@@ -0,0 +1,104 @@
+# 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/Ai Agent Workflow/workflows/agent-environment-setup/platforms/cursor/skills/feature-forge/references/ears-syntax.md

@@ -0,0 +1,99 @@
+# 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 |