agentic-dev 0.2.10 → 0.2.11

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

@@ -1,37 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException
-
-from contexts.alerts.application import (
-    get_alerts,
-    mark_alert_read,
-    mark_all_alerts_read,
-)
-from contexts.alerts.domain import (
-    AlertReadResult,
-    AlertsPayload,
-    AlertsReadAllResult,
-)
-from contexts.auth.contracts.http.dependencies import require_admin_user
-
-router = APIRouter(
-    prefix="/alerts",
-    tags=["alerts"],
-    dependencies=[Depends(require_admin_user)],
-)
-
-
-@router.get("", response_model=AlertsPayload)
-def list_alerts() -> AlertsPayload:
-    return get_alerts()
-
-
-@router.post("/read-all", response_model=AlertsReadAllResult)
-def read_all_alerts() -> AlertsReadAllResult:
-    return mark_all_alerts_read()
-
-
-@router.post("/{alert_id}/read", response_model=AlertReadResult)
-def read_alert(alert_id: str) -> AlertReadResult:
-    try:
-        return mark_alert_read(alert_id)
-    except LookupError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc

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

@@ -1,15 +0,0 @@
-from .models import (
-    AlertItem,
-    AlertReadResult,
-    AlertRecord,
-    AlertsPayload,
-    AlertsReadAllResult,
-)
-
-__all__ = [
-    "AlertItem",
-    "AlertReadResult",
-    "AlertRecord",
-    "AlertsPayload",
-    "AlertsReadAllResult",
-]

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

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

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

@@ -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: ...