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/main.py

@@ -1,22 +1,84 @@
+"""Application entry point with DDD architecture."""
+
 from contextlib import asynccontextmanager
 from typing import AsyncGenerator
 
 import uvicorn
+from dishka import make_async_container
+from dishka.integrations.fastapi import setup_dishka
 from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.infrastructure import close_db, init_db, register_exception_handlers, settings
+from app.infrastructure.di.providers import (
+    DatabaseProvider,
+    RepositoryProvider,
+    TransactionManagerProvider,
+    UseCaseProvider,
+)
+from app.presentation import router
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Application lifespan manager."""
+    # Startup
+    await init_db()
     yield
+    # Shutdown
+    await close_db()
 
 
 def app_factory() -> FastAPI:
-    app = FastAPI(lifespan=lifespan)
+    """Create and configure FastAPI application."""
+    app = FastAPI(
+        title=settings.app_name,
+        debug=settings.debug,
+        lifespan=lifespan,
+        docs_url="/docs" if settings.debug else None,
+        redoc_url="/redoc" if settings.debug else None,
+    )
+
+    # Setup Dishka DI container
+    container = make_async_container(
+        DatabaseProvider(),
+        RepositoryProvider(),
+        TransactionManagerProvider(),
+        UseCaseProvider(),
+    )
+    setup_dishka(container, app)
+
+    # Register exception handlers
+    register_exception_handlers(app)
+
+    # CORS middleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include API routes
+    app.include_router(router, prefix="/api")
+
+    # Health check endpoint
+    @app.get("/health", tags=["health"])
+    async def health_check() -> dict[str, str]:
+        return {"status": "ok", "app": settings.app_name}
+
     return app
 
 
 def main() -> None:
-    uvicorn.run(app_factory, factory=True, host="0.0.0.0", port=8000)
+    """Run the application."""
+    uvicorn.run(
+        app_factory,
+        factory=True,
+        host=settings.host,
+        port=settings.port,
+    )
 
 
 if __name__ == "__main__":