Add modular app structure for L1 server refactoring

Phase 2 of the full modernization:
- App factory pattern with create_app()
- Settings via dataclass with env vars
- Dependency injection container
- Router stubs for auth, storage, api, recipes, cache, runs
- Service layer stubs for run, recipe, cache
- Repository layer placeholder

Routes are stubs that import from legacy server.py during migration.
Next: Migrate each router fully with templates.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

app/dependencies.py

@@ -0,0 +1,135 @@
+"""
+FastAPI dependency injection container.
+
+Provides shared resources and services to route handlers.
+"""
+
+from functools import lru_cache
+from typing import Optional
+import asyncio
+
+from fastapi import Request, Depends, HTTPException
+from jinja2 import Environment
+
+from artdag_common.middleware.auth import UserContext, get_user_from_cookie, get_user_from_header
+
+from .config import settings
+
+
+# Lazy imports to avoid circular dependencies
+_redis_client = None
+_cache_manager = None
+_database = None
+
+
+def get_redis_client():
+    """Get the Redis client singleton."""
+    global _redis_client
+    if _redis_client is None:
+        import redis
+        _redis_client = redis.from_url(settings.redis_url, decode_responses=True)
+    return _redis_client
+
+
+def get_cache_manager():
+    """Get the cache manager singleton."""
+    global _cache_manager
+    if _cache_manager is None:
+        from cache_manager import get_cache_manager as _get_cache_manager
+        _cache_manager = _get_cache_manager()
+    return _cache_manager
+
+
+def get_database():
+    """Get the database singleton."""
+    global _database
+    if _database is None:
+        import database
+        _database = database
+    return _database
+
+
+def get_templates(request: Request) -> Environment:
+    """Get the Jinja2 environment from app state."""
+    return request.app.state.templates
+
+
+async def get_current_user(request: Request) -> Optional[UserContext]:
+    """
+    Get the current user from request (cookie or header).
+
+    This is a permissive dependency - returns None if not authenticated.
+    Use require_auth for routes that require authentication.
+    """
+    # Try header first (API clients)
+    ctx = get_user_from_header(request)
+    if ctx:
+        return ctx
+
+    # Fall back to cookie (browser)
+    return get_user_from_cookie(request)
+
+
+async def require_auth(request: Request) -> UserContext:
+    """
+    Require authentication for a route.
+
+    Raises:
+        HTTPException 401 if not authenticated
+        HTTPException 302 redirect to login for HTML requests
+    """
+    ctx = await get_current_user(request)
+    if ctx is None:
+        # Check if HTML request for redirect
+        accept = request.headers.get("accept", "")
+        if "text/html" in accept:
+            raise HTTPException(
+                status_code=302,
+                headers={"Location": "/login"}
+            )
+        raise HTTPException(status_code=401, detail="Authentication required")
+    return ctx
+
+
+async def get_user_context_from_cookie(request: Request) -> Optional[UserContext]:
+    """
+    Legacy compatibility: get user from cookie.
+
+    Validates token with L2 server if configured.
+    """
+    ctx = get_user_from_cookie(request)
+    if ctx is None:
+        return None
+
+    # If L2 server configured, could validate token here
+    # For now, trust the cookie
+    return ctx
+
+
+# Service dependencies (lazy loading)
+
+def get_run_service():
+    """Get the run service."""
+    from .services.run_service import RunService
+    return RunService(
+        redis=get_redis_client(),
+        cache=get_cache_manager(),
+    )
+
+
+def get_recipe_service():
+    """Get the recipe service."""
+    from .services.recipe_service import RecipeService
+    return RecipeService(
+        redis=get_redis_client(),
+        cache=get_cache_manager(),
+    )
+
+
+def get_cache_service():
+    """Get the cache service."""
+    from .services.cache_service import CacheService
+    return CacheService(
+        cache_manager=get_cache_manager(),
+        database=get_database(),
+    )