feat: comprehensive refactoring and UI improvements

- Complete modular refactoring with API/Services/Models separation
- Compact temperature controls with improved unit switching
- Fixed Energy Cutoff and DFT Functional 2-column layout alignment
- Added solid phase calculation notice
- Improved error handling and logging
- Added comprehensive test suite
- Better CSS organization with component separation

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

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

Author: ToshihiroIguchi

app/api/__init__.py

@@ -0,0 +1,90 @@
+from fastapi import APIRouter, Depends, Header, HTTPException, Request
+from fastapi.responses import JSONResponse
+
+from ..core.logging import get_logger
+from ..core.security import hash_api_key, create_rate_limit_key, validate_api_key
+from ..models.requests import DiagramRequest
+from ..models.responses import DiagramResponse, ErrorResponse
+from ..services.materials_client import MaterialsProjectClient
+from ..services.phase_analyzer import PhaseAnalyzer
+from ..services.rate_limiter import rate_limiter
+
+logger = get_logger(__name__)
+router = APIRouter(prefix="/diagrams", tags=["diagrams"])
+
+
+def get_client_ip(request: Request) -> str:
+    """Extract client IP from request (proxy-aware)."""
+    forwarded_for = request.headers.get("x-forwarded-for")
+    if forwarded_for:
+        return forwarded_for.split(",")[0].strip()
+    return request.client.host or "unknown"
+
+
+@router.post("/", response_model=DiagramResponse)
+async def generate_diagram(
+    request: DiagramRequest,
+    x_api_key: str = Header(..., alias="X-API-KEY"),
+    client_ip: str = Depends(get_client_ip)
+):
+    """
+    Generate a phase diagram with detailed phase information.
+    
+    This endpoint creates a phase diagram using Materials Project data
+    and returns both the plot data and detailed phase information.
+    """
+    # Validate API key format
+    if not validate_api_key(x_api_key):
+        logger.warning(f"Invalid API key format from IP: {client_ip}")
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API key format"
+        )
+    
+    # Create rate limiting key
+    api_key_hash = hash_api_key(x_api_key)
+    rate_limit_key = create_rate_limit_key(api_key_hash, client_ip)
+    
+    # Check rate limit
+    if not rate_limiter.is_allowed(rate_limit_key):
+        remaining_time = rate_limiter.get_reset_time(rate_limit_key) - __import__('time').time()
+        raise HTTPException(
+            status_code=429,
+            detail=f"Rate limit exceeded. Please wait {int(remaining_time)} seconds before making another request.",
+            headers={"Retry-After": str(int(remaining_time))}
+        )
+    
+    # Log request details
+    logger.info(f"API Request: formulas={request.formulas}, T={request.temperature}K, "
+               f"e_cut={request.energy_cutoff}, functional={request.functional}, "
+               f"key_hash={api_key_hash}, IP={client_ip}")
+    
+    try:
+        # Create services
+        materials_client = MaterialsProjectClient(x_api_key)
+        phase_analyzer = PhaseAnalyzer(materials_client)
+        
+        # Generate phase diagram
+        result = phase_analyzer.generate_phase_diagram(
+            formulas=request.formulas,
+            temperature=request.temperature,
+            energy_cutoff=request.energy_cutoff,
+            functional=request.functional,
+            api_key=x_api_key
+        )
+        
+        logger.info(f"Diagram generated successfully: {len(result.phase_info)} phases")
+        return result
+        
+    except ValueError as e:
+        # Client errors (bad input, invalid API key, etc.)
+        logger.warning(f"Client error: {str(e)}")
+        raise HTTPException(status_code=400, detail=str(e))
+        
+    except Exception as e:
+        # Server errors
+        logger.error(f"Server error: {str(e)}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail="Internal server error occurred while generating phase diagram"
+        )

app/api/diagrams.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+from fastapi import APIRouter
+
+from ..core.config import settings
+from ..models.responses import HealthResponse
+
+router = APIRouter(prefix="/health", tags=["health"])
+
+
+@router.get("/", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint."""
+    return HealthResponse(
+        status="healthy",
+        app_name=settings.app_name,
+        version=settings.app_version,
+        timestamp=datetime.utcnow().isoformat()
+    )

app/api/health.py

@@ -0,0 +1,51 @@
+import os
+from typing import List
+
+try:
+    from pydantic import BaseSettings
+except ImportError:
+    from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    # Application
+    app_name: str = "PhaseNavigator"
+    app_version: str = "1.0.0"
+    debug: bool = False
+    
+    # Rate Limiting
+    rate_limit_window: int = 30  # seconds
+    rate_limit_max_requests: int = 10
+    
+    # Phase Diagram
+    default_functional: str = "GGA_GGA_U_R2SCAN"
+    supported_functionals: List[str] = ["GGA_GGA_U_R2SCAN", "R2SCAN", "GGA_GGA_U"]
+    
+    # Temperature constraints
+    min_temperature: int = 300
+    max_temperature: int = 2000
+    default_temperature: int = 0
+    
+    # Energy constraints
+    default_energy_cutoff: float = 0.2
+    max_energy_cutoff: float = 2.0
+    
+    # Formula constraints
+    min_formulas: int = 2
+    max_formulas: int = 4
+    
+    # Logging
+    log_level: str = "INFO"
+    log_file: str = "phasenav.log"
+    log_format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    
+    # Security
+    api_key_hash_length: int = 12
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+
+# Global settings instance
+settings = Settings()

app/core/__init__.py

@@ -0,0 +1,60 @@
+import logging
+import sys
+from pathlib import Path
+from typing import Optional
+
+from .config import settings
+
+
+def setup_logging(
+    level: Optional[str] = None,
+    log_file: Optional[str] = None,
+    log_format: Optional[str] = None
+) -> logging.Logger:
+    """
+    Setup logging configuration for the application.
+    
+    Args:
+        level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        log_file: Path to log file
+        log_format: Log message format
+    
+    Returns:
+        Configured logger instance
+    """
+    # Use settings defaults if not provided
+    level = level or settings.log_level
+    log_file = log_file or settings.log_file
+    log_format = log_format or settings.log_format
+    
+    # Create logger
+    logger = logging.getLogger("phasenav")
+    logger.setLevel(getattr(logging, level.upper()))
+    
+    # Remove existing handlers to avoid duplicates
+    logger.handlers.clear()
+    
+    # Create formatter
+    formatter = logging.Formatter(log_format)
+    
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    # File handler
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+
+def get_logger(name: str = "phasenav") -> logging.Logger:
+    """Get a logger instance."""
+    return logging.getLogger(name)
+
+
+# Initialize default logger
+logger = setup_logging()

app/core/config.py

@@ -0,0 +1,51 @@
+import hashlib
+from typing import Tuple
+
+from .config import settings
+
+
+def hash_api_key(api_key: str) -> str:
+    """
+    Generate a short SHA-256 hash of the API key for logging and rate limiting.
+    
+    Args:
+        api_key: The Materials Project API key
+        
+    Returns:
+        Short hash of the API key
+    """
+    return hashlib.sha256(api_key.encode()).hexdigest()[:settings.api_key_hash_length]
+
+
+def create_rate_limit_key(api_key_hash: str, client_ip: str) -> Tuple[str, str]:
+    """
+    Create a rate limiting key from API key hash and client IP.
+    
+    Args:
+        api_key_hash: Hashed API key
+        client_ip: Client IP address
+        
+    Returns:
+        Tuple of (api_key_hash, client_ip) for rate limiting
+    """
+    return (api_key_hash, client_ip)
+
+
+def validate_api_key(api_key: str) -> bool:
+    """
+    Basic validation for Materials Project API key format.
+    
+    Args:
+        api_key: The API key to validate
+        
+    Returns:
+        True if the key appears to be in correct format
+    """
+    if not api_key or not isinstance(api_key, str):
+        return False
+    
+    # Materials Project API keys are typically 32 characters long
+    if len(api_key) < 20:
+        return False
+        
+    return True