agentic-dev 0.1.0 → 0.2.0

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

@@ -0,0 +1,29 @@
+from pydantic import BaseModel
+
+
+class AlertItem(BaseModel):
+    id: str
+    source: str
+    title: str
+    message: str
+    tone: str
+    created_at: str
+    read: bool
+
+
+class AlertRecord(AlertItem):
+    pass
+
+
+class AlertReadResult(AlertItem):
+    pass
+
+
+class AlertsPayload(BaseModel):
+    unread_count: int
+    items: list[AlertItem]
+
+
+class AlertsReadAllResult(BaseModel):
+    updated_count: int
+    unread_count: int

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

@@ -0,0 +1,11 @@
+from .repository import (
+    list_seed_alerts,
+    mark_all_seed_alerts_read,
+    mark_seed_alert_read,
+)
+
+__all__ = [
+    "list_seed_alerts",
+    "mark_all_seed_alerts_read",
+    "mark_seed_alert_read",
+]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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