Polish UI, clean up backend, improve code quality

- Replace two-line header logo with single clean title; swap text buttons for icon buttons (theme, history, logout) to reduce header clutter
- Remove all redundant path/section comments from every file
- Fix focus rings missing on all form inputs across auth pages
- Restyle OutputPanel export buttons from underline-text links to proper bordered chips
- Improve InputForm: better placeholder copy, cleaner character count layout, consistent button label
- Clean up HistoryPanel: fix misplaced block comment in map, simpler empty state, tighter spacing
- PricingPage: remove 'coming soon' placeholder features; clean up copy
- Fix FastAPI startup: migrate from deprecated app.on_event to lifespan context manager
- Update default Claude model to claude-3-5-haiku-20241022
- Remove redundant init_db() calls in auth route handlers (already runs via lifespan)
- Add REVIEW_QUESTIONS.md with open decisions

app.py

@@ -1,13 +1,5 @@
-# backend/app.py
-"""
-Pseudogen V1 API
-----------------
-FastAPI backend for generating pseudocode using various LLM providers (OpenAI, Claude, Groq, etc.).
-This API receives a problem description, pseudocode style, and level of detail,
-then returns formatted pseudocode as Markdown text.
-"""
-
 import os
+from contextlib import asynccontextmanager
 from pathlib import Path
 
 from dotenv import load_dotenv
@@ -26,14 +18,9 @@ from database import init_db
 from auth import get_current_user
 from routers.auth import router as auth_router
 
-# -----------------------------------------------------------------------------
-# Environment setup
-# -----------------------------------------------------------------------------
-
 _BACKEND_DIR = Path(__file__).resolve().parent
 load_dotenv(dotenv_path=_BACKEND_DIR / ".env")
 
-# Required env vars for startup (PROVIDER + at least one API key for that provider)
 _REQUIRED_ENV = ["PROVIDER"]
 _PROVIDER_KEYS = {
     "openai": "OPENAI_API_KEY",
@@ -48,36 +35,34 @@ def _check_env() -> None:
         return
     missing = [k for k in _REQUIRED_ENV if not os.getenv(k)]
     if missing:
-        raise RuntimeError(f"Missing required env: {', '.join(missing)}. Set them in .env or environment.")
+        raise RuntimeError(f"Missing required env vars: {', '.join(missing)}")
     provider = (os.getenv("PROVIDER") or "").lower()
     key_var = _PROVIDER_KEYS.get(provider)
     if key_var and not os.getenv(key_var):
-        raise RuntimeError(f"PROVIDER={provider} requires {key_var}. Set it in .env or environment.")
+        raise RuntimeError(f"PROVIDER={provider} requires {key_var} to be set")
 
 
 _check_env()
 
-# -----------------------------------------------------------------------------
-# Logging configuration
-# -----------------------------------------------------------------------------
-_LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
 logging.basicConfig(
-    level=getattr(logging, _LOG_LEVEL, logging.INFO),
+    level=getattr(logging, os.getenv("LOG_LEVEL", "INFO").upper(), logging.INFO),
     format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
     datefmt="%Y-%m-%d %H:%M:%S",
 )
 logger = logging.getLogger("pseudogen")
 
-# -----------------------------------------------------------------------------
-# FastAPI app configuration
-# -----------------------------------------------------------------------------
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    init_db()
+    yield
+
 
 limiter = Limiter(key_func=get_remote_address)
-app = FastAPI(title="Pseudogen V1 API")
+app = FastAPI(title="Pseudogen API", lifespan=lifespan)
 app.state.limiter = limiter
 app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
 
-# CORS: allow_origins from env in production (e.g. CORS_ORIGINS=https://app.example.com), else "*" for dev
 _cors_origins = os.getenv("CORS_ORIGINS", "*").strip()
 allow_origins = [o.strip() for o in _cors_origins.split(",") if o.strip()] if _cors_origins != "*" else ["*"]
 app.add_middleware(
@@ -88,67 +73,47 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# -----------------------------------------------------------------------------
-# Plan limits (Free vs Premium)
-# -----------------------------------------------------------------------------
 FREE_MAX_INPUT_LEN = 4000
 PREMIUM_MAX_INPUT_LEN = 12000
 
-# -----------------------------------------------------------------------------
-# Request model
-# -----------------------------------------------------------------------------
 
 class GenerateRequest(BaseModel):
-    """Schema for pseudocode generation requests. Max length 12000 for Premium."""
     problem_description: Annotated[str, Field(min_length=1, max_length=PREMIUM_MAX_INPUT_LEN)]
     style: Annotated[str, Field(pattern="^(Academic|Developer-Friendly|English-Like|Step-by-Step)$")]
     detail: Annotated[str, Field(pattern="^(Concise|Detailed)$")]
 
-# -----------------------------------------------------------------------------
-# API Routes
-# -----------------------------------------------------------------------------
-
-@app.on_event("startup")
-def on_startup():
-    init_db()
-
 
 app.include_router(auth_router)
 
+v1_router = APIRouter(prefix="/v1", tags=["v1"])
+
 
 @app.get("/")
 async def root():
-    """Health/root endpoint so the backend URL doesn't return 404 when visited."""
-    return {"service": "Pseudogen API", "docs": "/docs", "auth": "/auth/login", "generate": "POST /generate-pseudocode", "v1": "POST /v1/generate-pseudocode"}
+    return {"service": "Pseudogen API", "version": "1"}
 
-# v1 API router (versioned endpoint; same behavior as legacy path)
-v1_router = APIRouter(prefix="/v1", tags=["v1"])
 
 @v1_router.post("/generate-pseudocode")
 @limiter.limit("30/minute")
 async def generate_v1(request: Request, req: GenerateRequest, user: dict = Depends(get_current_user)):
-    """Same as generate; versioned under /v1. Requires auth."""
-    return await generate_impl(request, req, user)
+    return await _generate(request, req, user)
+
 
 app.include_router(v1_router)
 
+
 @app.post("/generate-pseudocode")
 @limiter.limit("30/minute")
 async def generate(request: Request, req: GenerateRequest, user: dict = Depends(get_current_user)):
-    """
-    Generate pseudocode from a given problem description. Requires Bearer token.
-    Plan (free/premium) is taken from the logged-in user.
-    """
-    return await generate_impl(request, req, user)
+    return await _generate(request, req, user)
 
 
-async def generate_impl(request: Request, req: GenerateRequest, user: dict):
-    """Shared implementation for generate and generate_v1."""
+async def _generate(request: Request, req: GenerateRequest, user: dict):
     plan = (user.get("plan") or "free").strip().lower()
     if plan != "premium" and len(req.problem_description) > FREE_MAX_INPUT_LEN:
         raise HTTPException(
             status_code=400,
-            detail=f"Input exceeds Free plan limit ({FREE_MAX_INPUT_LEN} characters). Upgrade to Premium for up to {PREMIUM_MAX_INPUT_LEN}.",
+            detail=f"Input exceeds the Free plan limit of {FREE_MAX_INPUT_LEN} characters. Upgrade to Premium for up to {PREMIUM_MAX_INPUT_LEN}.",
         )
 
     template = TEMPLATES.get(req.style)
@@ -159,8 +124,8 @@ async def generate_impl(request: Request, req: GenerateRequest, user: dict):
 
     try:
         response_text = call_llm(prompt)
-    except Exception as e:
+    except Exception:
         logger.exception("LLM call failed")
-        raise HTTPException(status_code=502, detail=str(e))
+        raise HTTPException(status_code=502, detail="Failed to generate pseudocode. Please try again.")
 
     return {"markdown": response_text}

routers/auth.py

@@ -1,8 +1,7 @@
-# backend/routers/auth.py
 from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel, EmailStr
 
-from database import init_db, get_user_by_email, create_user
+from database import get_user_by_email, create_user
 from auth import hash_password, verify_password, create_access_token, get_current_user
 
 router = APIRouter(prefix="/auth", tags=["auth"])
@@ -41,7 +40,6 @@ def register(req: RegisterRequest):
             status_code=status.HTTP_400_BAD_REQUEST,
             detail="Email already registered",
         )
-    init_db()
     hashed = hash_password(req.password)
     user = create_user(req.email, hashed)
     token = create_access_token({"sub": str(user["id"])})
@@ -50,7 +48,6 @@ def register(req: RegisterRequest):
 
 @router.post("/login", response_model=TokenResponse)
 def login(req: LoginRequest):
-    init_db()
     user = get_user_by_email(req.email)
     if not user or not verify_password(req.password, user["hashed_password"]):
         raise HTTPException(

utils.py

@@ -1,13 +1,3 @@
-# backend/utils.py
-"""
-utils.py
---------
-Utility module for handling LLM API calls (OpenAI, Claude, Groq) with retry logic.
-
-Each provider has a dedicated call function, wrapped by `call_llm()`,
-which selects the active provider from environment variables.
-"""
-
 import os
 import time
 import openai
@@ -18,28 +8,15 @@ from requests.exceptions import RequestException
 from dotenv import load_dotenv
 from pathlib import Path
 
-# --------------------------------------------------------------------------
-# Environment setup
-# --------------------------------------------------------------------------
-
-# Explicitly load environment variables from the backend/.env file
 load_dotenv(dotenv_path=Path(__file__).resolve().parent / ".env")
 
-# --------------------------------------------------------------------------
-# Initialize API clients
-# --------------------------------------------------------------------------
-
 openai.api_key = os.getenv("OPENAI_API_KEY")
-claude_client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+_claude = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+
 
-# --------------------------------------------------------------------------
-# OpenAI
-# --------------------------------------------------------------------------
 def call_openai_with_retries(prompt: str, model: str = None, max_retries: int = 3, backoff: float = 1.0) -> str:
-    """Call OpenAI model with retry logic."""
     model = model or os.getenv("OPENAI_MODEL", "gpt-4o-mini")
     last_err = None
-
     for attempt in range(1, max_retries + 1):
         try:
             resp = openai.ChatCompletion.create(
@@ -51,26 +28,20 @@ def call_openai_with_retries(prompt: str, model: str = None, max_retries: int =
             if resp.choices and resp.choices[0].message.get("content"):
                 return resp.choices[0].message["content"].strip()
             raise RuntimeError("Empty response from OpenAI")
-
         except Exception as e:
             last_err = e
-            logging.warning(f"OpenAI call failed (attempt {attempt}): {e}")
+            logging.warning(f"OpenAI attempt {attempt} failed: {e}")
             if attempt < max_retries:
                 time.sleep(backoff * attempt)
-            else:
-                raise RuntimeError(f"OpenAI failed after {max_retries} attempts: {last_err}")
+    raise RuntimeError(f"OpenAI failed after {max_retries} attempts: {last_err}")
+
 
-# --------------------------------------------------------------------------
-# Claude
-# --------------------------------------------------------------------------
 def call_claude_with_retries(prompt: str, model: str = None, max_retries: int = 3, backoff: float = 1.0) -> str:
-    """Call Anthropic Claude model with retry logic."""
-    model = model or os.getenv("CLAUDE_MODEL", "claude-3-sonnet-20240229")
+    model = model or os.getenv("CLAUDE_MODEL", "claude-3-5-haiku-20241022")
     last_err = None
-
     for attempt in range(1, max_retries + 1):
         try:
-            resp = claude_client.messages.create(
+            resp = _claude.messages.create(
                 model=model,
                 max_tokens=1000,
                 temperature=0.2,
@@ -81,37 +52,29 @@ def call_claude_with_retries(prompt: str, model: str = None, max_retries: int =
                 if text:
                     return text
             raise RuntimeError("Empty response from Claude")
-
         except Exception as e:
             last_err = e
-            logging.warning(f"Claude call failed (attempt {attempt}): {e}")
+            logging.warning(f"Claude attempt {attempt} failed: {e}")
             if attempt < max_retries:
                 time.sleep(backoff * attempt)
-            else:
-                raise RuntimeError(f"Claude failed after {max_retries} attempts: {last_err}")
+    raise RuntimeError(f"Claude failed after {max_retries} attempts: {last_err}")
+
 
-# --------------------------------------------------------------------------
-# Groq
-# --------------------------------------------------------------------------
 def call_groq_with_retries(prompt: str, model: str = None, max_retries: int = 3, backoff: float = 1.0) -> str:
-    """Call Groq model with retry logic."""
     api_key = os.getenv("GROQ_API_KEY")
-    model = model or os.getenv("GROQ_MODEL", "llama3-8b-8192")
     if not api_key:
         raise RuntimeError("Missing GROQ_API_KEY")
-
+    model = model or os.getenv("GROQ_MODEL", "llama3-8b-8192")
     headers = {
         "Authorization": f"Bearer {api_key}",
         "Content-Type": "application/json",
     }
-
     payload = {
         "model": model,
         "messages": [{"role": "user", "content": prompt}],
         "temperature": 0.2,
         "max_tokens": 1000,
     }
-
     last_err = None
     for attempt in range(1, max_retries + 1):
         try:
@@ -121,37 +84,28 @@ def call_groq_with_retries(prompt: str, model: str = None, max_retries: int = 3,
                 json=payload,
                 timeout=30,
             )
-
             if resp.status_code == 200:
                 data = resp.json()
-                if data.get("choices") and data["choices"][0]["message"].get("content"):
-                    return data["choices"][0]["message"]["content"].strip()
+                content = data.get("choices", [{}])[0].get("message", {}).get("content")
+                if content:
+                    return content.strip()
                 raise RuntimeError("Empty response from Groq")
-
             logging.error(f"Groq API error ({resp.status_code}): {resp.text}")
             resp.raise_for_status()
-
         except (RequestException, Exception) as e:
             last_err = e
-            logging.warning(f"Groq call failed (attempt {attempt}): {e}")
+            logging.warning(f"Groq attempt {attempt} failed: {e}")
             if attempt < max_retries:
                 time.sleep(backoff * attempt)
-            else:
-                raise RuntimeError(f"Groq failed after {max_retries} attempts: {last_err}")
+    raise RuntimeError(f"Groq failed after {max_retries} attempts: {last_err}")
 
-# --------------------------------------------------------------------------
-# Generic handler
-# --------------------------------------------------------------------------
 
 def call_llm(prompt: str) -> str:
-    """Route LLM calls based on PROVIDER environment variable."""
     provider = os.getenv("PROVIDER", "openai").lower()
-
-    if provider == "claude":
+    if provider == "claude" or provider == "anthropic":
         return call_claude_with_retries(prompt)
     elif provider == "openai":
         return call_openai_with_retries(prompt)
     elif provider == "groq":
         return call_groq_with_retries(prompt)
-    else:
-        raise RuntimeError(f"Unsupported PROVIDER: {provider}")
+    raise RuntimeError(f"Unsupported PROVIDER: {provider}")