@nockdev/awf 6.2.0

package/.agent/skills/languages/python/data/fastapi.yaml

@@ -0,0 +1,296 @@
+# =============================================================================
+# Python FastAPI Patterns (Feb 2026)
+# Version: FastAPI 0.115+ / Pydantic V2
+# =============================================================================
+
+metadata:
+  skill: python
+  domain: fastapi
+  version: "0.115"
+  updated: "2026-02-05"
+  patterns_count: 4
+
+patterns:
+  - id: py201
+    name: Dependency Injection
+    category: architecture
+    version: "fastapi"
+    description: |
+      FastAPI's Depends() for clean dependency injection.
+      Database sessions, auth, services.
+    text: dependency injection depends di services database session
+    example: |
+      from typing import Annotated
+      from fastapi import Depends, HTTPException, status
+      from sqlalchemy.ext.asyncio import AsyncSession
+
+      # ✅ Database session dependency
+      async def get_db() -> AsyncGenerator[AsyncSession, None]:
+          async with async_session_maker() as session:
+              try:
+                  yield session
+                  await session.commit()
+              except Exception:
+                  await session.rollback()
+                  raise
+
+      # Type alias for cleaner signatures
+      DbSession = Annotated[AsyncSession, Depends(get_db)]
+
+      # ✅ Service dependency
+      class UserService:
+          def __init__(self, db: DbSession) -> None:
+              self.db = db
+          
+          async def get_user(self, user_id: int) -> User | None:
+              return await self.db.get(User, user_id)
+
+      async def get_user_service(db: DbSession) -> UserService:
+          return UserService(db)
+
+      UserServiceDep = Annotated[UserService, Depends(get_user_service)]
+
+      # ✅ Auth dependency
+      async def get_current_user(
+          token: Annotated[str, Depends(oauth2_scheme)],
+          db: DbSession,
+      ) -> User:
+          payload = decode_token(token)
+          user = await db.get(User, payload["sub"])
+          if not user:
+              raise HTTPException(status_code=401)
+          return user
+
+      CurrentUser = Annotated[User, Depends(get_current_user)]
+
+      # ✅ Using in route
+      @router.get("/users/{user_id}")
+      async def get_user(
+          user_id: int,
+          service: UserServiceDep,
+          current_user: CurrentUser,
+      ) -> UserResponse:
+          user = await service.get_user(user_id)
+          if not user:
+              raise HTTPException(status_code=404)
+          return UserResponse.model_validate(user)
+    severity: HIGH
+    docs_url: https://fastapi.tiangolo.com/tutorial/dependencies/
+
+  - id: py202
+    name: Pydantic V2 Models
+    category: validation
+    version: "pydantic 2.0+"
+    description: |
+      Pydantic V2 schema patterns with model_config.
+      Validation, serialization, computed fields.
+    text: pydantic schema validation model v2 field validator
+    example: |
+      from datetime import datetime
+      from pydantic import (
+          BaseModel, 
+          ConfigDict, 
+          Field, 
+          field_validator,
+          model_validator,
+          computed_field,
+          EmailStr,
+      )
+      from typing import Annotated, Self
+
+      # ✅ Input schema (strict validation)
+      class UserCreate(BaseModel):
+          model_config = ConfigDict(
+              strict=True,
+              str_strip_whitespace=True,
+          )
+          
+          email: EmailStr
+          password: Annotated[str, Field(min_length=8, max_length=100)]
+          name: str = Field(max_length=100)
+          
+          @field_validator("password")
+          @classmethod
+          def password_strength(cls, v: str) -> str:
+              if not any(c.isupper() for c in v):
+                  raise ValueError("Password must have uppercase")
+              return v
+
+      # ✅ Response schema (from ORM)
+      class UserResponse(BaseModel):
+          model_config = ConfigDict(from_attributes=True)
+          
+          id: int
+          email: EmailStr
+          name: str
+          created_at: datetime
+          
+          @computed_field
+          @property
+          def display_name(self) -> str:
+              return self.name or self.email.split("@")[0]
+
+      # ✅ Model-level validation
+      class DateRange(BaseModel):
+          start: datetime
+          end: datetime
+          
+          @model_validator(mode="after")
+          def validate_range(self) -> Self:
+              if self.end <= self.start:
+                  raise ValueError("end must be after start")
+              return self
+
+      # ✅ Nested models
+      class OrderItem(BaseModel):
+          product_id: int
+          quantity: int = Field(gt=0)
+          
+      class Order(BaseModel):
+          items: list[OrderItem] = Field(min_length=1)
+          
+          @computed_field
+          @property
+          def total_items(self) -> int:
+              return sum(item.quantity for item in self.items)
+    severity: HIGH
+    docs_url: https://docs.pydantic.dev/latest/
+
+  - id: py203
+    name: Background Tasks
+    category: async
+    version: "fastapi"
+    description: |
+      FastAPI BackgroundTasks for fire-and-forget operations.
+      Use for emails, notifications, logging.
+    text: background tasks async fire forget email notification
+    example: |
+      from fastapi import BackgroundTasks, Depends
+      from typing import Annotated
+
+      # ✅ Simple background task
+      async def send_welcome_email(email: str, name: str) -> None:
+          await email_service.send(
+              to=email,
+              subject="Welcome!",
+              body=f"Hello {name}, welcome to our platform!"
+          )
+
+      @router.post("/users")
+      async def create_user(
+          data: UserCreate,
+          background_tasks: BackgroundTasks,
+          db: DbSession,
+      ) -> UserResponse:
+          user = await create_user_in_db(db, data)
+          
+          # ✅ Add task (runs after response)
+          background_tasks.add_task(
+              send_welcome_email,
+              email=user.email,
+              name=user.name,
+          )
+          
+          return UserResponse.model_validate(user)
+
+      # ✅ Dependency with background tasks
+      async def log_request(
+          request: Request,
+          background_tasks: BackgroundTasks,
+      ):
+          async def _log():
+              await audit_log.create(
+                  path=str(request.url),
+                  method=request.method,
+              )
+          background_tasks.add_task(_log)
+          return None
+
+      # ✅ For heavy tasks, use Celery/ARQ instead
+      # background_tasks is for lightweight, fire-and-forget
+
+      # Heavy task → use task queue
+      @router.post("/reports")
+      async def generate_report(data: ReportRequest) -> dict:
+          # Enqueue to Celery/ARQ
+          task = celery_app.send_task(
+              "generate_report",
+              args=[data.model_dump()],
+          )
+          return {"task_id": task.id, "status": "queued"}
+    severity: MEDIUM
+    docs_url: https://fastapi.tiangolo.com/tutorial/background-tasks/
+
+  - id: py204
+    name: Error Handling
+    category: errors
+    version: "fastapi"
+    description: |
+      Structured error handling with HTTPException and custom handlers.
+      Consistent API error responses.
+    text: error handling exception http status validation error
+    example: |
+      from fastapi import FastAPI, HTTPException, Request, status
+      from fastapi.responses import JSONResponse
+      from fastapi.exceptions import RequestValidationError
+      from pydantic import BaseModel
+
+      # ✅ Custom error schema
+      class ErrorResponse(BaseModel):
+          error: str
+          detail: str | None = None
+          code: str | None = None
+
+      # ✅ Custom exception
+      class AppError(Exception):
+          def __init__(
+              self,
+              message: str,
+              code: str = "INTERNAL_ERROR",
+              status_code: int = 500,
+          ):
+              self.message = message
+              self.code = code
+              self.status_code = status_code
+
+      class NotFoundError(AppError):
+          def __init__(self, resource: str, id: int | str):
+              super().__init__(
+                  message=f"{resource} with id {id} not found",
+                  code="NOT_FOUND",
+                  status_code=404,
+              )
+
+      # ✅ Exception handlers
+      app = FastAPI()
+
+      @app.exception_handler(AppError)
+      async def app_error_handler(request: Request, exc: AppError):
+          return JSONResponse(
+              status_code=exc.status_code,
+              content=ErrorResponse(
+                  error=exc.message,
+                  code=exc.code,
+              ).model_dump(),
+          )
+
+      @app.exception_handler(RequestValidationError)
+      async def validation_handler(request: Request, exc: RequestValidationError):
+          return JSONResponse(
+              status_code=422,
+              content=ErrorResponse(
+                  error="Validation error",
+                  detail=str(exc.errors()),
+                  code="VALIDATION_ERROR",
+              ).model_dump(),
+          )
+
+      # ✅ Usage in routes
+      @router.get("/users/{user_id}")
+      async def get_user(user_id: int, service: UserServiceDep) -> UserResponse:
+          user = await service.get_user(user_id)
+          if not user:
+              raise NotFoundError("User", user_id)
+          return UserResponse.model_validate(user)
+    severity: HIGH
+    docs_url: https://fastapi.tiangolo.com/tutorial/handling-errors/

package/.agent/skills/languages/python/data/testing.yaml

@@ -0,0 +1,226 @@
+# =============================================================================
+# Python Testing Patterns (Feb 2026)
+# Version: pytest 8.x / pytest-asyncio
+# =============================================================================
+
+metadata:
+  skill: python
+  domain: testing
+  version: "8.0"
+  updated: "2026-02-05"
+  patterns_count: 3
+
+patterns:
+  - id: py301
+    name: pytest-asyncio
+    category: testing
+    version: "pytest-asyncio"
+    description: |
+      Async test patterns with pytest-asyncio.
+      Fixtures, markers, and async test functions.
+    text: pytest asyncio async test fixture marker
+    example: |
+      import pytest
+      from httpx import AsyncClient, ASGITransport
+      from sqlalchemy.ext.asyncio import AsyncSession
+
+      # ✅ Configure pytest-asyncio mode
+      # pyproject.toml:
+      # [tool.pytest.ini_options]
+      # asyncio_mode = "auto"
+
+      # ✅ Async fixture
+      @pytest.fixture
+      async def db_session() -> AsyncGenerator[AsyncSession, None]:
+          async with async_session_maker() as session:
+              yield session
+              await session.rollback()
+
+      # ✅ FastAPI test client fixture
+      @pytest.fixture
+      async def client(db_session: AsyncSession) -> AsyncGenerator[AsyncClient, None]:
+          app.dependency_overrides[get_db] = lambda: db_session
+          
+          async with AsyncClient(
+              transport=ASGITransport(app=app),
+              base_url="http://test",
+          ) as client:
+              yield client
+          
+          app.dependency_overrides.clear()
+
+      # ✅ Async test function
+      async def test_create_user(client: AsyncClient):
+          response = await client.post("/users", json={
+              "email": "test@example.com",
+              "password": "SecurePass123",
+              "name": "Test User",
+          })
+          
+          assert response.status_code == 201
+          data = response.json()
+          assert data["email"] == "test@example.com"
+
+      # ✅ Parametrized async test
+      @pytest.mark.parametrize("email,expected", [
+          ("valid@example.com", 201),
+          ("invalid-email", 422),
+          ("", 422),
+      ])
+      async def test_user_email_validation(
+          client: AsyncClient,
+          email: str,
+          expected: int,
+      ):
+          response = await client.post("/users", json={
+              "email": email,
+              "password": "SecurePass123",
+              "name": "Test",
+          })
+          assert response.status_code == expected
+    severity: HIGH
+    docs_url: https://pytest-asyncio.readthedocs.io/
+
+  - id: py302
+    name: Fixtures and Factories
+    category: testing
+    version: "pytest"
+    description: |
+      Test data factories with factory_boy or manual factories.
+      Reusable, composable test data.
+    text: fixture factory test data factory_boy builder
+    example: |
+      import pytest
+      from datetime import datetime, timezone
+      from typing import Any
+      from dataclasses import dataclass, field
+
+      # ✅ Manual factory pattern
+      @dataclass
+      class UserFactory:
+          email: str = "test@example.com"
+          name: str = "Test User"
+          is_active: bool = True
+          
+          def build(self, **overrides: Any) -> dict:
+              data = {
+                  "email": self.email,
+                  "name": self.name,
+                  "is_active": self.is_active,
+              }
+              data.update(overrides)
+              return data
+          
+          async def create(self, db: AsyncSession, **overrides: Any) -> User:
+              data = self.build(**overrides)
+              user = User(**data)
+              db.add(user)
+              await db.flush()
+              return user
+
+      # ✅ Factory fixture
+      @pytest.fixture
+      def user_factory():
+          return UserFactory()
+
+      # ✅ Using factory_boy
+      import factory
+      from factory.alchemy import SQLAlchemyModelFactory
+
+      class UserFactory(SQLAlchemyModelFactory):
+          class Meta:
+              model = User
+              sqlalchemy_session_persistence = "commit"
+          
+          email = factory.Sequence(lambda n: f"user{n}@example.com")
+          name = factory.Faker("name")
+          created_at = factory.LazyFunction(
+              lambda: datetime.now(timezone.utc)
+          )
+
+      # ✅ Fixture with factory
+      @pytest.fixture
+      async def user(db_session: AsyncSession) -> User:
+          UserFactory._meta.sqlalchemy_session = db_session
+          return UserFactory.create()
+
+      # ✅ Test using factory
+      async def test_user_service(
+          db_session: AsyncSession,
+          user_factory: UserFactory,
+      ):
+          user = await user_factory.create(db_session, is_active=False)
+          
+          service = UserService(db_session)
+          result = await service.get_active_users()
+          
+          assert user not in result
+    severity: MEDIUM
+    docs_url: https://factoryboy.readthedocs.io/
+
+  - id: py303
+    name: Mocking and Patching
+    category: testing
+    version: "pytest"
+    description: |
+      unittest.mock and pytest-mock for test doubles.
+      Mock external services, time, I/O.
+    text: mock patch unittest pytest-mock spy stub
+    example: |
+      from unittest.mock import AsyncMock, MagicMock, patch
+      import pytest
+      from pytest_mock import MockerFixture
+
+      # ✅ Mocking async functions
+      async def test_external_api_call(mocker: MockerFixture):
+          mock_response = {"id": 1, "name": "Test"}
+          
+          mocker.patch(
+              "app.services.external.fetch_user",
+              new=AsyncMock(return_value=mock_response),
+          )
+          
+          result = await my_service.get_user(1)
+          assert result == mock_response
+
+      # ✅ Patch decorator
+      @patch("app.services.email.send_email", new=AsyncMock())
+      async def test_user_creation_sends_email():
+          from app.services.email import send_email
+          
+          await create_user({"email": "test@example.com"})
+          
+          send_email.assert_called_once()
+          call_args = send_email.call_args
+          assert call_args.kwargs["to"] == "test@example.com"
+
+      # ✅ Mock context manager
+      async def test_with_mock_context():
+          with patch("app.external.client.get") as mock_get:
+              mock_get.return_value = AsyncMock(
+                  json=AsyncMock(return_value={"data": "test"})
+              )
+              
+              result = await fetch_data()
+              assert result["data"] == "test"
+
+      # ✅ Spy (track calls without replacing)
+      async def test_spy_on_method(mocker: MockerFixture):
+          spy = mocker.spy(UserService, "get_user")
+          
+          service = UserService(db)
+          await service.get_user(1)
+          await service.get_user(2)
+          
+          assert spy.call_count == 2
+          spy.assert_any_call(service, 1)
+
+      # ✅ Time mocking with freezegun
+      from freezegun import freeze_time
+
+      @freeze_time("2026-01-15 12:00:00")
+      async def test_time_dependent_logic():
+          result = await get_greeting()
+          assert result == "Good afternoon"
+    severity: MEDIUM
+    docs_url: https://docs.python.org/3/library/unittest.mock.html

package/.agent/skills/languages/r/META.yaml

@@ -0,0 +1,16 @@
+name: r
+version: "6.2.0"
+category: data
+tier: 3
+
+domains:
+  core: 5
+
+desc: "R development patterns for R 4.4+. Covers Tidyverse, ggplot2, Shiny, statistical modeling."
+
+related_skills:
+  - python
+  - database
+
+prevent_confusion_with:
+  - python: "R uses <- for assignment, Python uses ="