agentic-dev 0.2.10 → 0.2.12

package/server/contexts/alerts/infrastructure/repository.py

@@ -1,41 +0,0 @@
-from contexts.alerts.domain import AlertRecord
-from data.bootstrap_loader import load_bootstrap_json
-
-_alert_store: list[AlertRecord] | None = None
-
-
-def _get_alert_store() -> list[AlertRecord]:
-    global _alert_store
-    if _alert_store is None:
-        _alert_store = [
-            AlertRecord(**entry) for entry in load_bootstrap_json("alerts.json")
-        ]
-    return _alert_store
-
-
-def list_seed_alerts() -> list[AlertRecord]:
-    return [record.model_copy(deep=True) for record in _get_alert_store()]
-
-
-def mark_seed_alert_read(alert_id: str) -> AlertRecord:
-    records = _get_alert_store()
-    for index, record in enumerate(records):
-        if record.id != alert_id:
-            continue
-
-        updated_record = record.model_copy(update={"read": True})
-        records[index] = updated_record
-        return updated_record.model_copy(deep=True)
-
-    raise LookupError(f"Alert {alert_id} not found")
-
-
-def mark_all_seed_alerts_read() -> int:
-    records = _get_alert_store()
-    updated_count = 0
-    for index, record in enumerate(records):
-        if record.read:
-            continue
-        records[index] = record.model_copy(update={"read": True})
-        updated_count += 1
-    return updated_count

package/server/contexts/auth/__init__.py

@@ -1 +0,0 @@
-__all__ = ["contracts", "application", "domain", "infrastructure"]

package/server/contexts/auth/application/__init__.py

@@ -1,3 +0,0 @@
-from .services import authenticate_user, prepare_auth_store, resolve_current_user
-
-__all__ = ["authenticate_user", "resolve_current_user", "prepare_auth_store"]

package/server/contexts/auth/application/ports.py

@@ -1,10 +0,0 @@
-from typing import Protocol
-
-from contexts.auth.domain import AuthAccountRecord
-
-
-class AuthAccountRepository(Protocol):
-    def initialize(self) -> None: ...
-    def seed_accounts(self, accounts: list[AuthAccountRecord]) -> None: ...
-    def get_by_email(self, email: str) -> AuthAccountRecord | None: ...
-    def get_by_id(self, user_id: str) -> AuthAccountRecord | None: ...

package/server/contexts/auth/application/services.py

@@ -1,64 +0,0 @@
-from functools import lru_cache
-
-from fastapi import HTTPException, status
-
-from config import get_settings
-from contexts.auth.domain import AuthAccountRecord, AuthenticatedUser, AuthToken, LoginCommand
-from contexts.auth.infrastructure import (
-    decode_access_token,
-    get_auth_repository,
-    issue_access_token,
-    verify_password,
-)
-from data.bootstrap_loader import load_bootstrap_json
-from shared.infrastructure import hash_password
-
-
-def authenticate_user(command: LoginCommand) -> AuthToken:
-    prepare_auth_store()
-    repository = get_auth_repository()
-    account = repository.get_by_email(str(command.email))
-    if account is None or not verify_password(command.password, account.password_hash):
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
-
-    return AuthToken(access_token=issue_access_token(account.id), user_id=account.id)
-
-
-def resolve_current_user(bearer_token: str) -> AuthenticatedUser:
-    prepare_auth_store()
-    subject = decode_access_token(bearer_token)
-    if subject is None:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token")
-
-    repository = get_auth_repository()
-    account = repository.get_by_id(subject)
-    if account is None:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token")
-    return AuthenticatedUser(**account.model_dump(exclude={"password_hash"}))
-
-
-def prepare_auth_store() -> None:
-    _seed_auth_store()
-
-
-@lru_cache
-def _seed_auth_store() -> None:
-    settings = get_settings()
-    repository = get_auth_repository()
-    repository.initialize()
-    password_lookup = {
-        "bootstrap_admin_password": settings.bootstrap_admin_password,
-        "bootstrap_operator_password": settings.bootstrap_operator_password,
-    }
-    accounts = [
-        AuthAccountRecord(
-            id=entry["id"],
-            name=entry["name"],
-            email=entry["email"],
-            role=entry["role"],
-            status=entry["status"],
-            password_hash=hash_password(password_lookup[entry["password_source"]]),
-        )
-        for entry in load_bootstrap_json("auth_accounts.json")
-    ]
-    repository.seed_accounts(accounts)

package/server/contexts/auth/contracts/__init__.py

@@ -1,4 +0,0 @@
-from .http.dependencies import require_admin_user, require_authenticated_user
-from .http.router import router
-
-__all__ = ["require_admin_user", "require_authenticated_user", "router"]

package/server/contexts/auth/contracts/http/__init__.py

@@ -1,4 +0,0 @@
-from .dependencies import require_admin_user, require_authenticated_user
-from .router import router
-
-__all__ = ["require_admin_user", "require_authenticated_user", "router"]

package/server/contexts/auth/contracts/http/dependencies.py

@@ -1,37 +0,0 @@
-from fastapi import Depends, Header, HTTPException, status
-
-from contexts.auth.application import resolve_current_user
-from contexts.auth.domain import AuthenticatedUser
-
-
-def _extract_bearer_token(authorization: str | None) -> str:
-    if authorization is None:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Missing authorization header",
-        )
-
-    scheme, _, token = authorization.partition(" ")
-    if scheme.casefold() != "bearer" or not token.strip():
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid authorization header",
-        )
-    return token.strip()
-
-
-def require_authenticated_user(
-    authorization: str | None = Header(default=None),
-) -> AuthenticatedUser:
-    return resolve_current_user(_extract_bearer_token(authorization))
-
-
-def require_admin_user(
-    current_user: AuthenticatedUser = Depends(require_authenticated_user),
-) -> AuthenticatedUser:
-    if current_user.role != "admin":
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Admin access required",
-        )
-    return current_user

package/server/contexts/auth/contracts/http/router.py

@@ -1,19 +0,0 @@
-from fastapi import APIRouter, Depends
-
-from contexts.auth.application import authenticate_user
-from contexts.auth.contracts.http.dependencies import require_authenticated_user
-from contexts.auth.domain import AuthToken, AuthenticatedUser, LoginCommand
-
-router = APIRouter(prefix="/auth", tags=["auth"])
-
-
-@router.post("/login", response_model=AuthToken)
-def login(command: LoginCommand) -> AuthToken:
-    return authenticate_user(command)
-
-
-@router.get("/me", response_model=AuthenticatedUser)
-def me(
-    current_user: AuthenticatedUser = Depends(require_authenticated_user),
-) -> AuthenticatedUser:
-    return current_user

package/server/contexts/auth/domain/__init__.py

@@ -1,3 +0,0 @@
-from .models import AuthAccountRecord, AuthenticatedUser, AuthToken, LoginCommand
-
-__all__ = ["AuthToken", "LoginCommand", "AuthenticatedUser", "AuthAccountRecord"]

package/server/contexts/auth/domain/models.py

@@ -1,24 +0,0 @@
-from pydantic import BaseModel, EmailStr
-
-
-class LoginCommand(BaseModel):
-    email: EmailStr
-    password: str
-
-
-class AuthToken(BaseModel):
-    access_token: str
-    token_type: str = "bearer"
-    user_id: str
-
-
-class AuthenticatedUser(BaseModel):
-    id: str
-    name: str
-    email: EmailStr
-    role: str
-    status: str
-
-
-class AuthAccountRecord(AuthenticatedUser):
-    password_hash: str

package/server/contexts/auth/infrastructure/__init__.py

@@ -1,4 +0,0 @@
-from .repository import get_auth_repository
-from shared.infrastructure import decode_access_token, issue_access_token, verify_password
-
-__all__ = ["decode_access_token", "get_auth_repository", "issue_access_token", "verify_password"]

package/server/contexts/auth/infrastructure/adapters/memory.py

@@ -1,19 +0,0 @@
-from contexts.auth.domain import AuthAccountRecord
-
-
-class MemoryAuthAccountRepository:
-    def __init__(self) -> None:
-        self._accounts: dict[str, AuthAccountRecord] = {}
-
-    def initialize(self) -> None:
-        return None
-
-    def seed_accounts(self, accounts: list[AuthAccountRecord]) -> None:
-        for account in accounts:
-            self._accounts[account.id] = account
-
-    def get_by_email(self, email: str) -> AuthAccountRecord | None:
-        return next((account for account in self._accounts.values() if account.email == email), None)
-
-    def get_by_id(self, user_id: str) -> AuthAccountRecord | None:
-        return self._accounts.get(user_id)

package/server/contexts/auth/infrastructure/adapters/mongodb.py

@@ -1,24 +0,0 @@
-from pymongo import ASCENDING, MongoClient
-
-from contexts.auth.domain import AuthAccountRecord
-
-
-class MongoAuthAccountRepository:
-    def __init__(self, mongodb_url: str, database_name: str) -> None:
-        self.client = MongoClient(mongodb_url)
-        self.collection = self.client[database_name]["auth_accounts"]
-
-    def initialize(self) -> None:
-        self.collection.create_index([("email", ASCENDING)], unique=True)
-
-    def seed_accounts(self, accounts: list[AuthAccountRecord]) -> None:
-        for account in accounts:
-            self.collection.update_one({"id": account.id}, {"$set": account.model_dump()}, upsert=True)
-
-    def get_by_email(self, email: str) -> AuthAccountRecord | None:
-        record = self.collection.find_one({"email": email}, {"_id": 0})
-        return AuthAccountRecord(**record) if record else None
-
-    def get_by_id(self, user_id: str) -> AuthAccountRecord | None:
-        record = self.collection.find_one({"id": user_id}, {"_id": 0})
-        return AuthAccountRecord(**record) if record else None

package/server/contexts/auth/infrastructure/adapters/sqlalchemy.py

@@ -1,74 +0,0 @@
-from sqlalchemy import String, create_engine, select
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, sessionmaker
-
-from contexts.auth.domain import AuthAccountRecord
-
-
-class Base(DeclarativeBase):
-    pass
-
-
-class AuthAccountTable(Base):
-    __tablename__ = "auth_accounts"
-
-    id: Mapped[str] = mapped_column(String(64), primary_key=True)
-    name: Mapped[str] = mapped_column(String(128))
-    email: Mapped[str] = mapped_column(String(255), unique=True, index=True)
-    role: Mapped[str] = mapped_column(String(64))
-    status: Mapped[str] = mapped_column(String(32))
-    password_hash: Mapped[str] = mapped_column(String(255))
-
-
-class SqlAlchemyAuthAccountRepository:
-    def __init__(self, database_url: str) -> None:
-        self.engine = create_engine(database_url, future=True)
-        self.session_factory = sessionmaker(bind=self.engine, expire_on_commit=False)
-
-    def initialize(self) -> None:
-        Base.metadata.create_all(self.engine)
-
-    def seed_accounts(self, accounts: list[AuthAccountRecord]) -> None:
-        with self.session_factory() as session:
-            for account in accounts:
-                existing = session.get(AuthAccountTable, account.id)
-                if existing is None:
-                    session.add(AuthAccountTable(**account.model_dump()))
-                    continue
-                for field, value in account.model_dump().items():
-                    setattr(existing, field, value)
-            session.commit()
-
-    def get_by_email(self, email: str) -> AuthAccountRecord | None:
-        with self.session_factory() as session:
-            record = session.scalar(select(AuthAccountTable).where(AuthAccountTable.email == email))
-            return self._to_record(record)
-
-    def get_by_id(self, user_id: str) -> AuthAccountRecord | None:
-        with self.session_factory() as session:
-            record = session.get(AuthAccountTable, user_id)
-            return self._to_record(record)
-
-    @staticmethod
-    def _to_record(record: AuthAccountTable | None) -> AuthAccountRecord | None:
-        if record is None:
-            return None
-        return AuthAccountRecord(
-            id=record.id,
-            name=record.name,
-            email=record.email,
-            role=record.role,
-            status=record.status,
-            password_hash=record.password_hash,
-        )
-
-
-class PostgresAuthAccountRepository(SqlAlchemyAuthAccountRepository):
-    pass
-
-
-class MySqlAuthAccountRepository(SqlAlchemyAuthAccountRepository):
-    pass
-
-
-class MariaDbAuthAccountRepository(SqlAlchemyAuthAccountRepository):
-    pass

package/server/contexts/auth/infrastructure/repository.py

@@ -1,28 +0,0 @@
-from functools import lru_cache
-from typing import TYPE_CHECKING
-
-from config import get_settings
-from contexts.auth.infrastructure.adapters.memory import MemoryAuthAccountRepository
-from contexts.auth.infrastructure.adapters.mongodb import MongoAuthAccountRepository
-from contexts.auth.infrastructure.adapters.sqlalchemy import (
-    MariaDbAuthAccountRepository,
-    MySqlAuthAccountRepository,
-    PostgresAuthAccountRepository,
-)
-
-if TYPE_CHECKING:
-    from contexts.auth.application.ports import AuthAccountRepository
-
-
-@lru_cache
-def get_auth_repository() -> "AuthAccountRepository":
-    settings = get_settings()
-    if settings.database_backend == "postgres":
-        return PostgresAuthAccountRepository(settings.postgres_url)
-    if settings.database_backend == "mysql":
-        return MySqlAuthAccountRepository(settings.mysql_url)
-    if settings.database_backend == "mariadb":
-        return MariaDbAuthAccountRepository(settings.mariadb_url)
-    if settings.database_backend == "mongodb":
-        return MongoAuthAccountRepository(settings.mongodb_url, settings.mongodb_database)
-    return MemoryAuthAccountRepository()

package/server/contexts/catalog/__init__.py

@@ -1 +0,0 @@
-__all__ = ["application", "contracts", "domain", "infrastructure"]

package/server/contexts/catalog/application/__init__.py

@@ -1,28 +0,0 @@
-from .services import (
-    create_product,
-    get_product_or_404,
-    list_product_summaries,
-    prepare_catalog_store,
-    update_product_or_404,
-    update_product_status_or_404,
-)
-
-create_catalog_product = create_product
-get_catalog_product_or_404 = get_product_or_404
-list_catalog_products = list_product_summaries
-update_catalog_product = update_product_or_404
-update_catalog_product_status = update_product_status_or_404
-
-__all__ = [
-    "create_catalog_product",
-    "create_product",
-    "get_catalog_product_or_404",
-    "get_product_or_404",
-    "list_catalog_products",
-    "list_product_summaries",
-    "prepare_catalog_store",
-    "update_catalog_product",
-    "update_catalog_product_status",
-    "update_product_or_404",
-    "update_product_status_or_404",
-]

package/server/contexts/catalog/application/ports.py

@@ -1,15 +0,0 @@
-from typing import Protocol
-
-from contexts.catalog.domain import ProductRecord, ProductStatus, ProductSummary
-
-
-class CatalogRepository(Protocol):
-    def initialize(self) -> None: ...
-    def seed_products(self, products: list[ProductRecord]) -> None: ...
-    def list_products(self) -> list[ProductRecord]: ...
-    def list_summaries(self) -> list[ProductSummary]: ...
-    def get_by_id(self, product_id: str) -> ProductRecord | None: ...
-    def get_by_slug(self, slug: str) -> ProductRecord | None: ...
-    def create_product(self, product: ProductRecord) -> ProductRecord: ...
-    def update_product(self, product: ProductRecord) -> ProductRecord: ...
-    def update_status(self, product_id: str, status: ProductStatus) -> ProductRecord | None: ...

package/server/contexts/catalog/application/services.py

@@ -1,154 +0,0 @@
-from datetime import datetime, timezone
-from functools import lru_cache
-
-from fastapi import HTTPException, status as http_status
-
-from contexts.catalog.domain import (
-    CreateProductCommand,
-    ProductDetail,
-    ProductRecord,
-    ProductStatus,
-    ProductSummary,
-    UpdateProductCommand,
-    UpdateProductStatusCommand,
-)
-from contexts.catalog.infrastructure import get_catalog_repository
-from data.bootstrap_loader import load_bootstrap_json
-
-
-def list_product_summaries(
-    product_status: ProductStatus | None = None,
-    category: str | None = None,
-    search: str | None = None,
-) -> list[ProductSummary]:
-    prepare_catalog_store()
-    repository = get_catalog_repository()
-    products = repository.list_products()
-
-    if product_status is not None:
-        products = [product for product in products if product.status == product_status]
-    if category is not None:
-        normalized_category = category.strip().casefold()
-        products = [product for product in products if product.category.casefold() == normalized_category]
-    if search is not None:
-        normalized_search = search.strip().casefold()
-        products = [
-            product
-            for product in products
-            if normalized_search
-            in " ".join([product.name, product.brand, product.category, product.slug, *product.tags]).casefold()
-        ]
-
-    return [_to_summary(product) for product in products]
-
-
-def get_product_or_404(product_id: str) -> ProductDetail:
-    prepare_catalog_store()
-    repository = get_catalog_repository()
-    product = repository.get_by_id(product_id)
-    if product is None:
-        raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND, detail="Catalog product not found")
-    return ProductDetail(**product.model_dump())
-
-
-def create_product(command: CreateProductCommand) -> ProductDetail:
-    prepare_catalog_store()
-    repository = get_catalog_repository()
-    if repository.get_by_slug(command.slug) is not None:
-        raise HTTPException(status_code=http_status.HTTP_409_CONFLICT, detail="Catalog product slug already exists")
-
-    next_id = _next_product_id(repository.list_products())
-    timestamp = _now_iso()
-    product = ProductRecord(
-        id=next_id,
-        slug=command.slug,
-        name=command.name,
-        brand=command.brand,
-        category=command.category,
-        status=command.status,
-        short_description=command.short_description,
-        description=command.description,
-        hero_image=command.hero_image,
-        gallery=command.gallery,
-        price=command.price,
-        compare_at_price=command.compare_at_price,
-        tags=command.tags,
-        attributes=command.attributes,
-        variants=command.variants,
-        created_at=timestamp,
-        updated_at=timestamp,
-    )
-    return ProductDetail(**repository.create_product(product).model_dump())
-
-
-def update_product_or_404(product_id: str, command: UpdateProductCommand) -> ProductDetail:
-    prepare_catalog_store()
-    repository = get_catalog_repository()
-    current = repository.get_by_id(product_id)
-    if current is None:
-        raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND, detail="Catalog product not found")
-
-    updates = command.model_dump(exclude_none=True, exclude_unset=True)
-    if not updates:
-        raise HTTPException(status_code=http_status.HTTP_400_BAD_REQUEST, detail="No catalog product fields provided")
-
-    if "slug" in updates:
-        existing = repository.get_by_slug(updates["slug"])
-        if existing is not None and existing.id != product_id:
-            raise HTTPException(status_code=http_status.HTTP_409_CONFLICT, detail="Catalog product slug already exists")
-
-    updated = current.model_copy(update={**updates, "updated_at": _now_iso()})
-    return ProductDetail(**repository.update_product(updated).model_dump())
-
-
-def update_product_status_or_404(product_id: str, command: UpdateProductStatusCommand) -> ProductDetail:
-    prepare_catalog_store()
-    repository = get_catalog_repository()
-    current = repository.get_by_id(product_id)
-    if current is None:
-        raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND, detail="Catalog product not found")
-    updated = current.model_copy(update={"status": command.status, "updated_at": _now_iso()})
-    return ProductDetail(**repository.update_product(updated).model_dump())
-
-
-def prepare_catalog_store() -> None:
-    _seed_catalog_store()
-
-
-@lru_cache
-def _seed_catalog_store() -> None:
-    repository = get_catalog_repository()
-    repository.initialize()
-    records = [ProductRecord(**entry) for entry in load_bootstrap_json("catalog_products.json")]
-    repository.seed_products(records)
-
-
-def _to_summary(product: ProductRecord) -> ProductSummary:
-    return ProductSummary(
-        id=product.id,
-        slug=product.slug,
-        name=product.name,
-        brand=product.brand,
-        category=product.category,
-        status=product.status,
-        short_description=product.short_description,
-        hero_image=product.hero_image,
-        price=product.price,
-        compare_at_price=product.compare_at_price,
-        tags=product.tags,
-        variant_count=len(product.variants),
-    )
-
-
-def _next_product_id(products: list[ProductRecord]) -> str:
-    max_sequence = 1000
-    for product in products:
-        try:
-            max_sequence = max(max_sequence, int(product.id.split("-")[-1]))
-        except ValueError:
-            continue
-    return f"prd-{max_sequence + 1}"
-
-
-def _now_iso() -> str:
-    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()

package/server/contexts/catalog/contracts/__init__.py

@@ -1,3 +0,0 @@
-from .http.router import router
-
-__all__ = ["router"]

package/server/contexts/catalog/contracts/http/__init__.py

@@ -1,3 +0,0 @@
-from .router import router
-
-__all__ = ["router"]

package/server/contexts/catalog/contracts/http/router.py

@@ -1,60 +0,0 @@
-from fastapi import APIRouter, Depends, Query, status
-
-from contexts.auth.contracts.http.dependencies import require_admin_user
-from contexts.catalog.application import (
-    create_product,
-    get_product_or_404,
-    list_product_summaries,
-    update_product_or_404,
-    update_product_status_or_404,
-)
-from contexts.catalog.domain import (
-    CreateProductCommand,
-    ProductDetail,
-    ProductStatus,
-    ProductSummary,
-    UpdateProductCommand,
-    UpdateProductStatusCommand,
-)
-
-router = APIRouter(prefix="/catalog", tags=["catalog"])
-
-
-@router.get("/products", response_model=list[ProductSummary])
-def list_products(
-    product_status: ProductStatus | None = Query(default=None, alias="status"),
-    category: str | None = Query(default=None),
-    search: str | None = Query(default=None, alias="q"),
-) -> list[ProductSummary]:
-    return list_product_summaries(product_status=product_status, category=category, search=search)
-
-
-@router.get("/products/{product_id}", response_model=ProductDetail)
-def get_product(product_id: str) -> ProductDetail:
-    return get_product_or_404(product_id)
-
-
-@router.post("/products", response_model=ProductDetail, status_code=status.HTTP_201_CREATED)
-def post_product(
-    command: CreateProductCommand,
-    _: object = Depends(require_admin_user),
-) -> ProductDetail:
-    return create_product(command)
-
-
-@router.put("/products/{product_id}", response_model=ProductDetail)
-def put_product(
-    product_id: str,
-    command: UpdateProductCommand,
-    _: object = Depends(require_admin_user),
-) -> ProductDetail:
-    return update_product_or_404(product_id, command)
-
-
-@router.patch("/products/{product_id}/status", response_model=ProductDetail)
-def patch_product_status(
-    product_id: str,
-    command: UpdateProductStatusCommand,
-    _: object = Depends(require_admin_user),
-) -> ProductDetail:
-    return update_product_status_or_404(product_id, command)