refactor: migrate to DDD architecture with Dishka DI

Complete architectural refactoring from simple MVC to Clean Architecture/DDD pattern:

Domain Layer:

- Add entities (Post, BaseEntity) with business logic

- Add value objects (Title, Content, Slug) with validation

- Add repository interfaces (PostRepository)

- Add domain exceptions

Application Layer:

- Add use cases (CreatePost, GetPost, UpdatePost, DeletePost, ListPosts, PublishPost)

- Add DTOs for data transfer

- Add TransactionManager interface

Infrastructure Layer:

- Add SQLAlchemy models and async database connection

- Add SQLAlchemyPostRepository implementation

- Add Dishka DI container with providers

- Add error handlers and middleware

Presentation Layer:

- Add FastAPI routes with Dishka integration

- Add Pydantic schemas

- Add dependency injection using FromDishka[T]

Other Changes:

- Remove old flat structure (api/, common/, core/, modules/)

- Add hatchling build system for package scripts

- Add blog CLI command

- Update AGENTS.md with new architecture docs

- All 48 tests passing, mypy clean, ruff clean

app/infrastructure/database/__init__.py

@@ -0,0 +1,22 @@
+"""Database infrastructure."""
+
+from app.infrastructure.database.connection import (
+    AsyncSessionLocal,
+    close_db,
+    engine,
+    get_session,
+    get_session_context,
+    init_db,
+)
+from app.infrastructure.database.models import Base, PostORM
+
+__all__ = [
+    "Base",
+    "PostORM",
+    "engine",
+    "AsyncSessionLocal",
+    "get_session",
+    "get_session_context",
+    "init_db",
+    "close_db",
+]

app/infrastructure/database/connection.py

@@ -0,0 +1,70 @@
+"""Database connection and session management."""
+
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+
+from app.infrastructure.config import settings
+
+
+# Convert SQLite URL to async format if needed
+def _get_database_url() -> str:
+    url = settings.database_url
+    if url.startswith("sqlite:///") and not url.startswith("sqlite+aiosqlite:///"):
+        return url.replace("sqlite:///", "sqlite+aiosqlite:///")
+    return url
+
+
+# Create async engine
+engine: AsyncEngine = create_async_engine(
+    _get_database_url(),
+    echo=settings.database_echo,
+    future=True,
+)
+
+# Create session factory
+AsyncSessionLocal = async_sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autoflush=False,
+    autocommit=False,
+)
+
+
+async def get_session() -> AsyncGenerator[AsyncSession, None]:
+    """Get database session."""
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        finally:
+            await session.close()
+
+
+@asynccontextmanager
+async def get_session_context() -> AsyncGenerator[AsyncSession, None]:
+    """Get database session as context manager."""
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        finally:
+            await session.close()
+
+
+async def init_db() -> None:
+    """Initialize database tables."""
+    from app.infrastructure.database.models import Base
+
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def close_db() -> None:
+    """Close database connections."""
+    await engine.dispose()

app/infrastructure/database/models.py

@@ -0,0 +1,40 @@
+"""SQLAlchemy ORM models."""
+
+from datetime import datetime, timezone
+from uuid import uuid4
+
+from sqlalchemy import JSON, Boolean, DateTime, String, Text
+from sqlalchemy.orm import Mapped, declarative_base, mapped_column
+
+Base = declarative_base()
+
+
+class PostORM(Base):  # type: ignore[valid-type,misc]
+    """SQLAlchemy model for Blog Post."""
+
+    __tablename__ = "posts"
+
+    id: Mapped[str] = mapped_column(
+        String(36), primary_key=True, default=lambda: str(uuid4())
+    )
+    title: Mapped[str] = mapped_column(String(200), nullable=False)
+    content: Mapped[str] = mapped_column(Text, nullable=False)
+    slug: Mapped[str] = mapped_column(
+        String(200), nullable=False, unique=True, index=True
+    )
+    author_id: Mapped[str] = mapped_column(String(100), nullable=False, index=True)
+    published: Mapped[bool] = mapped_column(
+        Boolean, default=False, nullable=False, index=True
+    )
+    tags: Mapped[list[str]] = mapped_column(JSON, default=list)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: datetime.now(timezone.utc),
+        nullable=False,
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+        nullable=False,
+    )