Deploy cv-buddy backend

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.env
+.env.*
+fly.toml
+*.egg-info/
+.pytest_cache/

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies for WeasyPrint + supervisor for running multiple processes
+RUN apt-get update && apt-get install -y \
+    libpango-1.0-0 \
+    libpangocairo-1.0-0 \
+    libgdk-pixbuf-2.0-0 \
+    libffi-dev \
+    shared-mime-info \
+    supervisor \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf
+
+ENV PORT=7860
+
+CMD ["supervisord", "-c", "/etc/supervisor/conf.d/supervisord.conf"]

app/api/dependencies.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+import uuid
+from typing import Optional
+from fastapi import Header, HTTPException
+from app.core.redis import get_redis
+
+
+async def get_session_id(x_session_id: Optional[str] = Header(default=None)) -> str:
+    if not x_session_id:
+        raise HTTPException(status_code=401, detail="No session found. Please upload a resume first.")
+
+    redis = await get_redis()
+    exists = await redis.exists(f"session:{x_session_id}:resume")
+    if not exists:
+        raise HTTPException(status_code=401, detail="Session expired. Please upload your resume again.")
+
+    return x_session_id
+
+
+def generate_session_id() -> str:
+    return str(uuid.uuid4())

app/api/routes/analyze.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+import json
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
+from app.api.dependencies import get_session_id
+from app.core.redis import get_redis
+from app.workers.tasks import analyze_and_customize
+from app.models.customization import Intensity
+from app.models.resume import ResumeData
+from app.services.job_scraper import JobScraper
+from app.services.ats_scorer import ATSScorer
+
+router = APIRouter()
+
+# Threshold for low ATS score warning
+LOW_SCORE_THRESHOLD = 30
+
+
+class AnalyzeRequest(BaseModel):
+    job_url: Optional[str] = None
+    job_text: Optional[str] = None
+    intensity: Intensity = Intensity.MODERATE
+    confirm_low_score: bool = False  # User confirmation for low scores
+
+
+class PreviewScoreRequest(BaseModel):
+    job_url: Optional[str] = None
+    job_text: Optional[str] = None
+
+
+@router.post("/preview-score")
+async def preview_score(
+    request: PreviewScoreRequest,
+    session_id: str = Depends(get_session_id),
+):
+    """Get preliminary ATS score before full customization."""
+    if not request.job_url and not request.job_text:
+        raise HTTPException(
+            status_code=400,
+            detail="Please provide either a job URL or job description text."
+        )
+
+    # Get resume from session
+    redis = await get_redis()
+    resume_data = await redis.get(f"session:{session_id}:resume")
+    if not resume_data:
+        raise HTTPException(status_code=404, detail="Session expired or resume not found")
+
+    resume = ResumeData(**json.loads(resume_data))
+
+    # Parse job posting
+    scraper = JobScraper()
+    try:
+        if request.job_url:
+            job = await scraper.scrape(request.job_url)
+        else:
+            job = await scraper.parse_text(request.job_text)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to parse job posting: {str(e)}")
+
+    # Calculate preliminary ATS score
+    scorer = ATSScorer()
+    score = await scorer.calculate(resume, job)
+
+    # Determine if confirmation is needed
+    needs_confirmation = score.total < LOW_SCORE_THRESHOLD
+
+    return {
+        "score": score.total,
+        "matched_keywords": score.matched_keywords,
+        "missing_keywords": score.missing_keywords,
+        "needs_confirmation": needs_confirmation,
+        "message": (
+            f"Your resume has a {score.total}% match with this job. "
+            f"This is quite low and will require significant changes. "
+            f"Do you want to proceed?"
+        ) if needs_confirmation else None,
+    }
+
+
+@router.post("/analyze-job")
+async def analyze_job(
+    request: AnalyzeRequest,
+    session_id: str = Depends(get_session_id),
+):
+    if not request.job_url and not request.job_text:
+        raise HTTPException(
+            status_code=400,
+            detail="Please provide either a job URL or job description text."
+        )
+
+    # If not explicitly confirmed, do a quick score check
+    if not request.confirm_low_score:
+        redis = await get_redis()
+        resume_data = await redis.get(f"session:{session_id}:resume")
+        if resume_data:
+            resume = ResumeData(**json.loads(resume_data))
+            scraper = JobScraper()
+            try:
+                if request.job_url:
+                    job = await scraper.scrape(request.job_url)
+                else:
+                    job = await scraper.parse_text(request.job_text)
+
+                scorer = ATSScorer()
+                score = await scorer.calculate(resume, job)
+
+                if score.total < LOW_SCORE_THRESHOLD:
+                    return {
+                        "needs_confirmation": True,
+                        "score": score.total,
+                        "message": (
+                            f"Your resume has only a {score.total}% match with this job. "
+                            f"Major changes will be needed. Do you want to continue?"
+                        ),
+                    }
+            except Exception:
+                pass  # If score check fails, proceed anyway
+
+    # Queue the task
+    task = analyze_and_customize.delay(
+        session_id=session_id,
+        job_url=request.job_url,
+        job_text=request.job_text,
+        intensity=request.intensity.value,
+    )
+
+    return {"task_id": task.id}

app/api/routes/compare.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+import json
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from app.core.redis import get_redis
+from app.services.resume_parser import ResumeParser
+from app.services.resume_comparator import ResumeComparator
+from app.models.resume import ResumeData
+
+router = APIRouter()
+
+
+@router.post("/compare/{result_id}")
+async def compare_resumes(
+    result_id: str,
+    original_file: UploadFile = File(...),
+    job_description: str = Form(default="")
+):
+    """
+    Compare original (ground truth) resume with LLM-generated version.
+
+    Args:
+        result_id: ID of the LLM analysis result
+        original_file: Original resume file uploaded by user
+        job_description: Job description text (optional)
+
+    Returns:
+        Detailed comparison metrics
+    """
+    # Get LLM result from Redis
+    redis = await get_redis()
+    data = await redis.get(f"result:{result_id}")
+
+    if not data:
+        raise HTTPException(status_code=404, detail="Result not found or expired.")
+
+    result = json.loads(data)
+    llm_resume = ResumeData(**result["customized"])
+
+    # Parse original resume
+    parser = ResumeParser()
+
+    if not original_file.content_type or not parser.is_supported(original_file.content_type):
+        raise HTTPException(
+            status_code=400,
+            detail="Invalid file type. Please upload a PDF or Word document."
+        )
+
+    try:
+        contents = await original_file.read()
+        original_resume = await parser.parse(contents, original_file.content_type)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to parse original resume: {str(e)}")
+
+    # Run comparison
+    comparator = ResumeComparator(
+        original=original_resume,
+        llm_version=llm_resume,
+        job_description=job_description
+    )
+
+    try:
+        comparison_result = comparator.compare()
+        return comparison_result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Comparison failed: {str(e)}")

app/api/routes/export.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+import json
+from enum import Enum
+from fastapi import APIRouter, HTTPException, Query
+from fastapi.responses import Response
+from app.core.redis import get_redis
+from app.services.resume_generator import ResumeGenerator
+from app.models.resume import ResumeData
+
+router = APIRouter()
+
+
+class ExportFormat(str, Enum):
+    PDF = "pdf"
+    DOCX = "docx"
+
+
+@router.get("/export/{result_id}")
+async def export_resume(
+    result_id: str,
+    format: ExportFormat = Query(default=ExportFormat.PDF),
+):
+    redis = await get_redis()
+    data = await redis.get(f"result:{result_id}")
+
+    if not data:
+        raise HTTPException(status_code=404, detail="Result not found or expired.")
+
+    result = json.loads(data)
+    resume = ResumeData(**result["customized"])
+
+    generator = ResumeGenerator()
+
+    try:
+        if format == ExportFormat.PDF:
+            content = generator.to_pdf(resume)
+            media_type = "application/pdf"
+            filename = "resume.pdf"
+        else:
+            content = generator.to_docx(resume)
+            media_type = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+            filename = "resume.docx"
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Export failed: {str(e)}")
+
+    return Response(
+        content=content,
+        media_type=media_type,
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )

app/api/routes/progress.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+import json
+import asyncio
+from typing import AsyncGenerator
+from fastapi import APIRouter
+from fastapi.responses import StreamingResponse
+from app.core.redis import get_redis
+
+router = APIRouter()
+
+
+@router.get("/progress/{task_id}")
+async def stream_progress(task_id: str):
+    async def event_generator() -> AsyncGenerator[str, None]:
+        redis = await get_redis()
+        pubsub = redis.pubsub()
+        channel = f"progress:{task_id}"
+
+        await pubsub.subscribe(channel)
+
+        # Send current state if exists
+        current_state = await redis.get(f"progress_state:{task_id}")
+        if current_state:
+            yield f"data: {current_state}\n\n"
+
+        try:
+            while True:
+                message = await asyncio.wait_for(
+                    pubsub.get_message(ignore_subscribe_messages=True),
+                    timeout=30.0,
+                )
+
+                if message and message["type"] == "message":
+                    data = message["data"]
+                    yield f"data: {data}\n\n"
+
+                    # Check if complete or error
+                    parsed = json.loads(data)
+                    if parsed.get("step") in ("complete", "error"):
+                        break
+                else:
+                    # Send heartbeat
+                    yield ": heartbeat\n\n"
+
+        except asyncio.TimeoutError:
+            yield 'data: {"step": "error", "error": {"code": "TIMEOUT", "message": "Connection timeout"}}\n\n'
+        finally:
+            await pubsub.unsubscribe(channel)
+            await pubsub.close()
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    )

app/api/routes/result.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+import json
+from fastapi import APIRouter, HTTPException
+from app.core.redis import get_redis
+
+router = APIRouter()
+
+
+@router.get("/result/{result_id}")
+async def get_result(result_id: str):
+    redis = await get_redis()
+    data = await redis.get(f"result:{result_id}")
+
+    if not data:
+        raise HTTPException(status_code=404, detail="Result not found or expired.")
+
+    return json.loads(data)

app/api/routes/upload.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+import logging
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from app.api.dependencies import generate_session_id
+from app.core.redis import get_redis
+from app.core.config import settings
+from app.services.resume_parser import ResumeParser
+from app.services.layout_scanner import LayoutScanner
+from app.models.analysis import SafetyScan
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+@router.post("/upload")
+async def upload_resume(file: UploadFile = File(...)):
+    try:
+        parser = ResumeParser()
+
+        # Validate file type
+        if not file.content_type or not parser.is_supported(file.content_type):
+            raise HTTPException(
+                status_code=400,
+                detail="Invalid file type. Please upload a PDF or Word document."
+            )
+
+        # Validate file size (5MB max)
+        contents = await file.read()
+        if len(contents) > 5 * 1024 * 1024:
+            raise HTTPException(status_code=400, detail="File too large. Maximum size is 5MB.")
+
+        # Scan document format for ATS compatibility issues FIRST
+        format_warnings = []
+        try:
+            scanner = LayoutScanner()
+            safety_scan = scanner.scan(contents, file.content_type)
+            if safety_scan.has_issues:
+                format_warnings = [
+                    {"type": w.type, "message": w.message, "recommendation": w.recommendation}
+                    for w in safety_scan.warnings
+                ]
+        except Exception as e:
+            logger.warning(f"Format scan failed: {e}")
+
+        try:
+            resume = await parser.parse(contents, file.content_type)
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        except Exception as e:
+            logger.error(f"Resume parsing failed: {e}", exc_info=True)
+            raise HTTPException(status_code=500, detail=f"Failed to parse resume: {str(e)}")
+
+        # Validate resume has minimum required content
+        content_issues = []
+        if not resume.contact.name:
+            content_issues.append("No name detected in resume")
+        if not resume.experience:
+            content_issues.append("No work experience detected")
+        if len(resume.skills) == 0:
+            content_issues.append("No skills detected")
+
+        # Store in Redis
+        session_id = generate_session_id()
+        redis = await get_redis()
+
+        await redis.set(
+            f"session:{session_id}:resume",
+            resume.model_dump_json(),
+            ex=settings.session_ttl_seconds,
+        )
+
+        # Also store raw file for potential re-processing
+        await redis.set(
+            f"session:{session_id}:file",
+            contents,
+            ex=settings.session_ttl_seconds,
+        )
+
+        # Store content type for layout scanning
+        await redis.set(
+            f"session:{session_id}:content_type",
+            file.content_type,
+            ex=settings.session_ttl_seconds,
+        )
+
+        return {
+            "session_id": session_id,
+            "profile": {
+                "name": resume.contact.name,
+                "email": resume.contact.email,
+                "skills": resume.skills[:10],
+                "experience_count": len(resume.experience),
+            },
+            "format_warnings": format_warnings,
+            "content_issues": content_issues,
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Upload failed with unexpected error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Upload failed: {str(e)}")

app/core/config.py

@@ -0,0 +1,25 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
+
+    # Redis
+    redis_url: str = "redis://localhost:6379/0"
+
+    # LLM
+    llm_provider: str = "google"
+    llm_model_fast: str = "gemini-2.0-flash"
+    llm_model_smart: str = "gemini-2.0-flash"
+
+    # API Keys
+    openai_api_key: str = ""
+    google_api_key: str = ""
+    zai_api_key: str = ""
+    groq_api_key: str = ""
+
+    # Session
+    session_ttl_seconds: int = 7200
+
+
+settings = Settings()

app/core/redis.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+import ssl
+from contextlib import asynccontextmanager
+from typing import Optional
+
+import redis.asyncio as redis
+from app.core.config import settings
+
+# Global client for FastAPI (long-lived connection)
+_fastapi_client: Optional[redis.Redis] = None
+
+
+def _redis_kwargs() -> dict:
+    """Extra kwargs for rediss:// (TLS) connections like Upstash."""
+    if settings.redis_url.startswith("rediss://"):
+        return {"ssl_cert_reqs": None}
+    return {}
+
+
+async def get_redis() -> redis.Redis:
+    """Get Redis client for FastAPI (reuses connection)."""
+    global _fastapi_client
+    if _fastapi_client is None:
+        _fastapi_client = redis.from_url(
+            settings.redis_url, decode_responses=True, **_redis_kwargs()
+        )
+    return _fastapi_client
+
+
+async def close_redis():
+    """Close FastAPI Redis connection."""
+    global _fastapi_client
+    if _fastapi_client:
+        await _fastapi_client.close()
+        _fastapi_client = None
+
+
+@asynccontextmanager
+async def get_redis_for_worker():
+    """Get fresh Redis client for Celery workers (new connection per task)."""
+    client = redis.from_url(
+        settings.redis_url, decode_responses=True, **_redis_kwargs()
+    )
+    try:
+        yield client
+    finally:
+        await client.close()

app/llm/base.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from typing import Protocol, Any, Dict, Optional
+from abc import abstractmethod
+
+
+class LLMProvider(Protocol):
+    model: str
+
+    @abstractmethod
+    async def complete(self, prompt: str, system: Optional[str] = None) -> str:
+        """Generate text completion."""
+        ...
+
+    @abstractmethod
+    async def complete_json(self, prompt: str, schema: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate structured JSON output."""
+        ...

app/llm/factory.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+import logging
+from typing import Dict, List, Tuple, Type
+
+from app.llm.base import LLMProvider
+from app.llm.openai_provider import OpenAIProvider
+from app.llm.google_provider import GoogleProvider
+from app.llm.zai_provider import ZAIProvider
+from app.llm.groq_provider import GroqProvider
+from app.llm.fallback_provider import FallbackLLMProvider
+from app.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class LLMFactory:
+    _providers: Dict[str, Type[LLMProvider]] = {
+        "openai": OpenAIProvider,
+        "google": GoogleProvider,
+        "zai": ZAIProvider,
+        "groq": GroqProvider,
+    }
+
+    _default_models: Dict[str, Tuple[str, str]] = {
+        "openai": ("gpt-4o-mini", "gpt-4o"),
+        "google": ("gemini-3-flash-preview", "gemini-3-flash-preview"),
+        "zai": ("glm-4.7", "glm-4.7"),
+        "groq": ("llama-3.1-8b-instant", "llama-3.1-8b-instant"),
+    }
+
+    @classmethod
+    def create(cls, provider: str, model: str, api_key: str) -> LLMProvider:
+        if provider not in cls._providers:
+            raise ValueError(f"Unknown provider: {provider}. Available: {list(cls._providers.keys())}")
+        return cls._providers[provider](model=model, api_key=api_key)
+
+    @classmethod
+    def _get_available_providers(cls, use_fast: bool = True) -> List[LLMProvider]:
+        """Get list of available providers with valid API keys, primary first."""
+        providers: List[LLMProvider] = []
+
+        # Map of provider names to their API keys
+        api_keys = {
+            "openai": settings.openai_api_key,
+            "google": settings.google_api_key,
+            "zai": settings.zai_api_key,
+            "groq": settings.groq_api_key,
+        }
+
+        # Get primary provider's model
+        primary = settings.llm_provider
+        model_index = 0 if use_fast else 1
+
+        # Add primary provider first if it has an API key
+        if api_keys.get(primary):
+            model = settings.llm_model_fast if use_fast else settings.llm_model_smart
+            providers.append(cls.create(primary, model, api_keys[primary]))
+            logger.info(f"Primary provider: {primary} ({model})")
+
+        # Add fallback providers
+        for name, key in api_keys.items():
+            if name != primary and key:
+                fast_model, smart_model = cls._default_models[name]
+                model = fast_model if use_fast else smart_model
+                providers.append(cls.create(name, model, key))
+                logger.info(f"Fallback provider: {name} ({model})")
+
+        return providers
+
+    @classmethod
+    def get_fast(cls) -> LLMProvider:
+        """Get configured fast/cheap model with automatic fallback."""
+        providers = cls._get_available_providers(use_fast=True)
+        if len(providers) == 1:
+            return providers[0]
+        return FallbackLLMProvider(providers)
+
+    @classmethod
+    def get_smart(cls) -> LLMProvider:
+        """Get configured smart model with automatic fallback."""
+        providers = cls._get_available_providers(use_fast=False)
+        if len(providers) == 1:
+            return providers[0]
+        return FallbackLLMProvider(providers)
+
+    @classmethod
+    def _get_api_key(cls) -> str:
+        """Get API key for primary provider (legacy method)."""
+        keys = {
+            "openai": settings.openai_api_key,
+            "google": settings.google_api_key,
+            "zai": settings.zai_api_key,
+            "groq": settings.groq_api_key,
+        }
+        return keys.get(settings.llm_provider, "")

app/llm/fallback_provider.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+import asyncio
+import logging
+import re
+import time
+from typing import Any, Dict, List, Optional
+
+from app.llm.base import LLMProvider
+
+logger = logging.getLogger(__name__)
+
+
+class QuotaExceededError(Exception):
+    """Raised when all LLM providers are exhausted."""
+    pass
+
+
+class FallbackLLMProvider(LLMProvider):
+    """LLM provider with automatic fallback and retry with exponential backoff."""
+
+    # Retry configuration
+    MAX_RETRIES_PER_PROVIDER = 3
+    INITIAL_BACKOFF_SECONDS = 5
+    MAX_BACKOFF_SECONDS = 65
+
+    def __init__(self, providers: List[LLMProvider]):
+        if not providers:
+            raise ValueError("At least one provider is required")
+        self.providers = providers
+        self.model = providers[0].model
+
+    def _is_rate_limit_error(self, error: Exception) -> bool:
+        """Check if error is a rate limit/quota error that might resolve with retry."""
+        error_str = str(error).lower()
+        rate_limit_indicators = [
+            "rate_limit",
+            "rate limit",
+            "429",
+            "too many requests",
+            "retry",
+            "quota exceeded",
+            "resource_exhausted",
+        ]
+        return any(indicator in error_str for indicator in rate_limit_indicators)
+
+    def _extract_retry_delay(self, error: Exception) -> Optional[float]:
+        """Extract retry delay from error message if present."""
+        error_str = str(error)
+        # Look for patterns like "retry in 22.428058397s" or "retry_delay { seconds: 22 }"
+        patterns = [
+            r'retry in ([\d.]+)s',
+            r'retry_delay.*?seconds[:\s]+(\d+)',
+            r'(\d+)\s*seconds?',
+        ]
+        for pattern in patterns:
+            match = re.search(pattern, error_str, re.IGNORECASE)
+            if match:
+                try:
+                    return min(float(match.group(1)), self.MAX_BACKOFF_SECONDS)
+                except ValueError:
+                    pass
+        return None
+
+    async def _call_with_retry(
+        self,
+        provider: LLMProvider,
+        call_func,
+        *args,
+        **kwargs
+    ) -> Any:
+        """Call provider method with retry on rate limit errors."""
+        last_error = None
+        backoff = self.INITIAL_BACKOFF_SECONDS
+
+        for attempt in range(self.MAX_RETRIES_PER_PROVIDER):
+            try:
+                # Track time to first token (TTFT)
+                start_time = time.time()
+                result = await call_func(*args, **kwargs)
+                ttft = (time.time() - start_time) * 1000  # Convert to milliseconds
+                logger.info(f"⏱️  {provider.__class__.__name__} TTFT: {ttft:.2f}ms ({ttft/1000:.3f}s)")
+                return result
+            except Exception as e:
+                last_error = e
+
+                if self._is_rate_limit_error(e) and attempt < self.MAX_RETRIES_PER_PROVIDER - 1:
+                    # Extract delay from error or use exponential backoff
+                    delay = self._extract_retry_delay(e) or backoff
+                    logger.warning(
+                        f"{provider.__class__.__name__} rate limited, "
+                        f"retrying in {delay:.1f}s (attempt {attempt + 1}/{self.MAX_RETRIES_PER_PROVIDER})"
+                    )
+                    await asyncio.sleep(delay)
+                    backoff = min(backoff * 2, self.MAX_BACKOFF_SECONDS)
+                else:
+                    raise
+
+        raise last_error
+
+    async def complete(self, prompt: str, system: Optional[str] = None) -> str:
+        last_error: Optional[Exception] = None
+        errors_by_provider: List[str] = []
+
+        for i, provider in enumerate(self.providers):
+            try:
+                logger.info(f"Trying provider {i + 1}/{len(self.providers)}: {provider.__class__.__name__}")
+                return await self._call_with_retry(
+                    provider,
+                    provider.complete,
+                    prompt,
+                    system
+                )
+            except Exception as e:
+                last_error = e
+                errors_by_provider.append(f"{provider.__class__.__name__}: {str(e)[:100]}")
+                logger.warning(f"Provider {provider.__class__.__name__} failed after retries: {e}")
+                continue
+
+        error_summary = "; ".join(errors_by_provider)
+        raise QuotaExceededError(f"All providers exhausted. Errors: {error_summary}")
+
+    async def complete_json(self, prompt: str, schema: Dict[str, Any]) -> Dict[str, Any]:
+        last_error: Optional[Exception] = None
+        errors_by_provider: List[str] = []
+
+        for i, provider in enumerate(self.providers):
+            try:
+                logger.info(f"Trying provider {i + 1}/{len(self.providers)}: {provider.__class__.__name__}")
+                return await self._call_with_retry(
+                    provider,
+                    provider.complete_json,
+                    prompt,
+                    schema
+                )
+            except Exception as e:
+                last_error = e
+                errors_by_provider.append(f"{provider.__class__.__name__}: {str(e)[:100]}")
+                logger.warning(f"Provider {provider.__class__.__name__} failed after retries: {e}")
+                continue
+
+        error_summary = "; ".join(errors_by_provider)
+        raise QuotaExceededError(f"All providers exhausted. Errors: {error_summary}")

app/llm/google_provider.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+import json
+from typing import Any, Dict, Optional
+import google.generativeai as genai
+from app.llm.base import LLMProvider
+
+
+class GoogleProvider(LLMProvider):
+    def __init__(self, model: str, api_key: str):
+        self.model = model
+        genai.configure(api_key=api_key)
+        self._model = genai.GenerativeModel(model)
+
+    async def complete(self, prompt: str, system: Optional[str] = None) -> str:
+        full_prompt = f"{system}\n\n{prompt}" if system else prompt
+        response = await self._model.generate_content_async(full_prompt)
+        return response.text
+
+    async def complete_json(self, prompt: str, schema: Dict[str, Any]) -> Dict[str, Any]:
+        system = f"Respond only with valid JSON matching this schema: {json.dumps(schema)}. No markdown, no explanation, just JSON."
+        full_prompt = f"{system}\n\n{prompt}"
+        response = await self._model.generate_content_async(full_prompt)
+        content = response.text
+        # Strip markdown code blocks if present
+        if content.startswith("```"):
+            content = content.split("```")[1]
+            if content.startswith("json"):
+                content = content[4:]
+        return json.loads(content.strip())

app/llm/groq_provider.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+import json
+from typing import Any, Dict, List, Optional
+from openai import AsyncOpenAI
+from app.llm.base import LLMProvider
+
+
+class GroqProvider(LLMProvider):
+    def __init__(self, model: str, api_key: str):
+        self.model = model
+        self.client = AsyncOpenAI(
+            api_key=api_key,
+            base_url="https://api.groq.com/openai/v1"
+        )
+
+    async def complete(self, prompt: str, system: Optional[str] = None) -> str:
+        messages: List[Dict[str, str]] = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": prompt})
+
+        response = await self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+        )
+        return response.choices[0].message.content or ""
+
+    async def complete_json(self, prompt: str, schema: Dict[str, Any]) -> Dict[str, Any]:
+        system = f"Respond only with valid JSON matching this schema: {json.dumps(schema)}"
+        messages = [
+            {"role": "system", "content": system},
+            {"role": "user", "content": prompt},
+        ]
+
+        response = await self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            response_format={"type": "json_object"},
+        )
+        content = response.choices[0].message.content or "{}"
+        return json.loads(content)

app/llm/openai_provider.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+import json
+from typing import Any, Dict, List, Optional
+from openai import AsyncOpenAI
+from app.llm.base import LLMProvider
+
+
+class OpenAIProvider(LLMProvider):
+    def __init__(self, model: str, api_key: str):
+        self.model = model
+        self.client = AsyncOpenAI(api_key=api_key)
+
+    async def complete(self, prompt: str, system: Optional[str] = None) -> str:
+        messages: List[Dict[str, str]] = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": prompt})
+
+        response = await self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+        )
+        return response.choices[0].message.content or ""
+
+    async def complete_json(self, prompt: str, schema: Dict[str, Any]) -> Dict[str, Any]:
+        system = f"Respond only with valid JSON matching this schema: {json.dumps(schema)}"
+        messages = [
+            {"role": "system", "content": system},
+            {"role": "user", "content": prompt},
+        ]
+
+        response = await self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            response_format={"type": "json_object"},
+        )
+        content = response.choices[0].message.content or "{}"
+        return json.loads(content)

app/llm/zai_provider.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+import json
+from typing import Any, Dict, List, Optional
+from openai import AsyncOpenAI
+from app.llm.base import LLMProvider
+
+
+class ZAIProvider(LLMProvider):
+    def __init__(self, model: str, api_key: str):
+        self.model = model
+        self.client = AsyncOpenAI(
+            api_key=api_key,
+            base_url="https://api.z.ai/api/coding/paas/v4",
+            timeout=60.0
+        )
+
+    async def complete(self, prompt: str, system: Optional[str] = None) -> str:
+        messages: List[Dict[str, str]] = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": prompt})
+
+        response = await self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+        )
+        return response.choices[0].message.content or ""
+
+    async def complete_json(self, prompt: str, schema: Dict[str, Any]) -> Dict[str, Any]:
+        system = f"Respond only with valid JSON matching this schema: {json.dumps(schema)}"
+        messages = [
+            {"role": "system", "content": system},
+            {"role": "user", "content": prompt},
+        ]
+
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                response_format={"type": "json_object"},
+            )
+        except Exception:
+            # Fallback without response_format if not supported
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+            )
+        content = response.choices[0].message.content or "{}"
+        return json.loads(content)

app/main.py

@@ -0,0 +1,94 @@
+from contextlib import asynccontextmanager
+import logging
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from app.core.redis import close_redis
+from app.api.routes import upload, analyze, progress, result, export, compare
+
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    yield
+    await close_redis()
+
+
+app = FastAPI(
+    title="CV-Buddy API",
+    description="AI-powered resume customization",
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+import os
+
+allowed_origins = [
+    "http://localhost:3000",
+]
+# Add production Vercel URL if set
+vercel_url = os.environ.get("FRONTEND_URL")
+if vercel_url:
+    allowed_origins.append(vercel_url)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allowed_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Global exception handler - ALWAYS return JSON
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    """Catch all unhandled exceptions and return JSON error response."""
+    logger.error(f"Unhandled exception: {exc}", exc_info=True)
+
+    # Extract useful error message
+    error_message = str(exc)
+
+    # Check for common error types
+    if "quota" in error_message.lower() or "rate" in error_message.lower():
+        return JSONResponse(
+            status_code=429,
+            content={
+                "detail": "API rate limit reached. Please wait a moment and try again.",
+                "error_type": "rate_limit",
+                "original_error": error_message[:500],
+            }
+        )
+
+    if "exhausted" in error_message.lower():
+        return JSONResponse(
+            status_code=503,
+            content={
+                "detail": "AI service temporarily unavailable. Please try again in a few seconds.",
+                "error_type": "service_unavailable",
+                "original_error": error_message[:500],
+            }
+        )
+
+    return JSONResponse(
+        status_code=500,
+        content={
+            "detail": f"An error occurred: {error_message[:200]}",
+            "error_type": "internal_error",
+        }
+    )
+
+
+# Include routers
+app.include_router(upload.router, prefix="/api", tags=["upload"])
+app.include_router(analyze.router, prefix="/api", tags=["analyze"])
+app.include_router(progress.router, prefix="/api", tags=["progress"])
+app.include_router(result.router, prefix="/api", tags=["result"])
+app.include_router(export.router, prefix="/api", tags=["export"])
+app.include_router(compare.router, prefix="/api", tags=["compare"])
+
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok"}

app/models/__init__.py

@@ -0,0 +1,5 @@
+from app.models.resume import ResumeData, ContactInfo, Experience, Education
+from app.models.job import JobData
+from app.models.score import ATSScore, ScoreBreakdown
+from app.models.customization import CustomizationResult, Change, Intensity
+from app.models.analysis import BulletAnalysis, LayoutWarning, SafetyScan, KeywordPlacement

app/models/analysis.py

@@ -0,0 +1,38 @@
+from typing import List, Optional
+from pydantic import BaseModel
+
+
+class BulletAnalysis(BaseModel):
+    """Analysis of a single resume bullet point against job requirements."""
+    location: str  # e.g., "experience[0].bullets[2]"
+    original_text: str
+    relevance_score: int  # 0-100
+    matched_keywords: List[str] = []
+    missing_keywords: List[str] = []
+    suggestion: str = ""
+
+    # After customization (populated if bullet was modified)
+    customized_text: Optional[str] = None
+    new_relevance_score: Optional[int] = None
+    keywords_added: List[str] = []
+
+
+class LayoutWarning(BaseModel):
+    """A single layout compatibility warning."""
+    type: str  # "multi_column", "complex_table", "graphics"
+    message: str
+    recommendation: str
+
+
+class SafetyScan(BaseModel):
+    """Results of layout safety analysis for ATS compatibility."""
+    has_issues: bool = False
+    warnings: List[LayoutWarning] = []
+
+
+class KeywordPlacement(BaseModel):
+    """Analysis of where a keyword appears and if it's naturally integrated."""
+    keyword: str
+    locations: List[str] = []  # Where the keyword appears
+    is_natural: bool = True
+    flag: Optional[str] = None  # Warning message if unnatural

app/models/customization.py

@@ -0,0 +1,32 @@
+from enum import Enum
+from typing import List, Optional
+from pydantic import BaseModel
+from app.models.resume import ResumeData
+from app.models.score import ATSScore
+from app.models.analysis import BulletAnalysis, SafetyScan, KeywordPlacement
+
+
+class Intensity(str, Enum):
+    CONSERVATIVE = "conservative"
+    MODERATE = "moderate"
+    AGGRESSIVE = "aggressive"
+
+
+class Change(BaseModel):
+    type: str  # "added", "modified", "reordered"
+    location: str  # e.g., "experience[0].bullets[2]"
+    before: str = ""
+    after: str = ""
+
+
+class CustomizationResult(BaseModel):
+    original: ResumeData
+    customized: ResumeData
+    changes: List[Change] = []
+    original_score: ATSScore
+    customized_score: ATSScore
+
+    # Enhanced analysis fields
+    bullet_analysis: List[BulletAnalysis] = []
+    safety_scan: Optional[SafetyScan] = None
+    keyword_quality: List[KeywordPlacement] = []

app/models/job.py

@@ -0,0 +1,13 @@
+from typing import List
+from pydantic import BaseModel
+
+
+class JobData(BaseModel):
+    title: str = ""
+    company: str = ""
+    location: str = ""
+    requirements: List[str] = []
+    responsibilities: List[str] = []
+    keywords_required: List[str] = []
+    keywords_preferred: List[str] = []
+    raw_text: str = ""

app/models/resume.py

@@ -0,0 +1,32 @@
+from typing import List
+from pydantic import BaseModel
+
+
+class ContactInfo(BaseModel):
+    name: str = ""
+    email: str = ""
+    phone: str = ""
+    linkedin: str = ""
+    location: str = ""
+
+
+class Experience(BaseModel):
+    company: str
+    title: str
+    dates: str
+    bullets: List[str]
+
+
+class Education(BaseModel):
+    school: str
+    degree: str
+    dates: str
+
+
+class ResumeData(BaseModel):
+    contact: ContactInfo
+    summary: str = ""
+    experience: List[Experience] = []
+    education: List[Education] = []
+    skills: List[str] = []
+    raw_text: str = ""

app/models/score.py

@@ -0,0 +1,16 @@
+from typing import List
+from pydantic import BaseModel
+
+
+class ScoreBreakdown(BaseModel):
+    keyword_match: float = 0.0  # 0-100
+    skills_alignment: float = 0.0  # 0-100
+    experience_relevance: float = 0.0  # 0-100
+    format_score: float = 100.0  # 0-100 (always 100 for our generated resumes)
+
+
+class ATSScore(BaseModel):
+    total: int = 0  # 0-100
+    breakdown: ScoreBreakdown = ScoreBreakdown()
+    matched_keywords: List[str] = []
+    missing_keywords: List[str] = []

app/services/ats_scorer.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+import re
+from typing import List, Tuple
+from app.models.resume import ResumeData
+from app.models.job import JobData
+from app.models.score import ATSScore, ScoreBreakdown
+from app.models.analysis import KeywordPlacement
+from app.llm.factory import LLMFactory
+
+
+class ATSScorer:
+    # Weights for score components
+    WEIGHT_KEYWORD = 0.4
+    WEIGHT_SKILLS = 0.3
+    WEIGHT_EXPERIENCE = 0.2
+    WEIGHT_FORMAT = 0.1
+
+    def match_keywords(self, text: str, keywords: List[str]) -> Tuple[List[str], List[str]]:
+        """Match keywords in text (case-insensitive)."""
+        text_lower = text.lower()
+        matched = []
+        missing = []
+
+        for keyword in keywords:
+            # Create pattern for word boundary matching
+            pattern = r'\b' + re.escape(keyword.lower()) + r'\b'
+            if re.search(pattern, text_lower):
+                matched.append(keyword)
+            else:
+                missing.append(keyword)
+
+        return matched, missing
+
+    def calculate_keyword_score(self, resume: ResumeData, job: JobData) -> Tuple[float, List[str], List[str]]:
+        """Calculate keyword match percentage."""
+        all_keywords = job.keywords_required + job.keywords_preferred
+        if not all_keywords:
+            return 100.0, [], []
+
+        # Combine all resume text
+        resume_text = " ".join([
+            resume.raw_text,
+            " ".join(resume.skills),
+            resume.summary,
+        ])
+
+        matched, missing = self.match_keywords(resume_text, all_keywords)
+
+        # Weight required keywords more heavily
+        required_matched = [k for k in matched if k in job.keywords_required]
+        preferred_matched = [k for k in matched if k in job.keywords_preferred]
+
+        required_count = len(job.keywords_required) or 1
+        preferred_count = len(job.keywords_preferred) or 1
+
+        required_score = (len(required_matched) / required_count) * 70
+        preferred_score = (len(preferred_matched) / preferred_count) * 30
+
+        return required_score + preferred_score, matched, missing
+
+    def calculate_skills_score(self, resume: ResumeData, job: JobData) -> float:
+        """Calculate skills alignment score."""
+        if not job.keywords_required:
+            return 100.0
+
+        resume_skills_lower = [s.lower() for s in resume.skills]
+        matched = sum(1 for k in job.keywords_required if k.lower() in resume_skills_lower)
+
+        return (matched / len(job.keywords_required)) * 100
+
+    async def calculate_experience_relevance(self, resume: ResumeData, job: JobData) -> float:
+        """Use LLM to judge experience relevance (0-100)."""
+        if not resume.experience or not job.responsibilities:
+            return 50.0
+
+        experience_text = "\n".join([
+            f"{exp.title} at {exp.company}: " + "; ".join(exp.bullets[:3])
+            for exp in resume.experience[:3]
+        ])
+
+        responsibilities_text = "\n".join(job.responsibilities[:5])
+
+        prompt = f"""Rate how relevant this candidate's experience is to the job responsibilities on a scale of 0-100.
+
+Candidate Experience:
+{experience_text}
+
+Job Responsibilities:
+{responsibilities_text}
+
+Respond with only a number between 0 and 100."""
+
+        llm = LLMFactory.get_fast()
+        response = await llm.complete(prompt)
+
+        try:
+            match = re.search(r'\d+', response)
+            if match:
+                score = int(match.group())
+                return min(100, max(0, score))
+            return 50.0
+        except (AttributeError, ValueError):
+            return 50.0
+
+    async def calculate(self, resume: ResumeData, job: JobData) -> ATSScore:
+        """Calculate complete ATS score."""
+        keyword_score, matched, missing = self.calculate_keyword_score(resume, job)
+        skills_score = self.calculate_skills_score(resume, job)
+        experience_score = await self.calculate_experience_relevance(resume, job)
+        format_score = 100.0  # Our generated resumes are always ATS-friendly
+
+        total = int(
+            keyword_score * self.WEIGHT_KEYWORD +
+            skills_score * self.WEIGHT_SKILLS +
+            experience_score * self.WEIGHT_EXPERIENCE +
+            format_score * self.WEIGHT_FORMAT
+        )
+
+        return ATSScore(
+            total=total,
+            breakdown=ScoreBreakdown(
+                keyword_match=keyword_score,
+                skills_alignment=skills_score,
+                experience_relevance=experience_score,
+                format_score=format_score,
+            ),
+            matched_keywords=matched,
+            missing_keywords=missing,
+        )
+
+    def check_keyword_quality(
+        self,
+        resume: ResumeData,
+        job: JobData,
+        added_keywords: List[str]
+    ) -> List[KeywordPlacement]:
+        """Check if keywords are naturally placed or potentially stuffed."""
+        placements = []
+
+        for keyword in added_keywords:
+            locations = self._find_keyword_locations(resume, keyword)
+            is_natural, flag = self._evaluate_placement(locations, keyword)
+
+            placements.append(KeywordPlacement(
+                keyword=keyword,
+                locations=locations,
+                is_natural=is_natural,
+                flag=flag
+            ))
+
+        return placements
+
+    def _find_keyword_locations(self, resume: ResumeData, keyword: str) -> List[str]:
+        """Find all locations where a keyword appears in the resume."""
+        locations = []
+        pattern = r'\b' + re.escape(keyword.lower()) + r'\b'
+
+        # Check summary
+        if resume.summary and re.search(pattern, resume.summary.lower()):
+            locations.append("summary")
+
+        # Check skills
+        for skill in resume.skills:
+            if re.search(pattern, skill.lower()):
+                locations.append("skills")
+                break
+
+        # Check experience bullets
+        for exp_idx, exp in enumerate(resume.experience):
+            for bullet_idx, bullet in enumerate(exp.bullets):
+                if re.search(pattern, bullet.lower()):
+                    locations.append(f"experience[{exp_idx}].bullets[{bullet_idx}]")
+
+        return locations
+
+    def _evaluate_placement(self, locations: List[str], keyword: str) -> Tuple[bool, str | None]:
+        """Evaluate if a keyword placement is natural or stuffed."""
+        if not locations:
+            return True, None  # Not found, no issue
+
+        # Check if keyword ONLY appears in skills (potential stuffing)
+        if locations == ["skills"]:
+            return False, f"'{keyword}' only appears in Skills section - consider demonstrating it in your experience bullets"
+
+        # Check if keyword appears too many times (over-optimization)
+        experience_mentions = [loc for loc in locations if "experience" in loc]
+        if len(experience_mentions) > 3:
+            return False, f"'{keyword}' appears {len(experience_mentions)} times - this may seem repetitive to reviewers"
+
+        # Natural: appears in experience or summary with context
+        has_context = any("experience" in loc or loc == "summary" for loc in locations)
+        if has_context:
+            return True, None
+
+        return True, None

app/services/bullet_analyzer.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+import json
+import logging
+import re
+from pathlib import Path
+from typing import List, Optional
+
+from app.models.resume import ResumeData
+from app.models.job import JobData
+from app.models.analysis import BulletAnalysis
+from app.llm.factory import LLMFactory
+
+logger = logging.getLogger(__name__)
+
+PROMPT_PATH = Path(__file__).parent.parent.parent / "prompts" / "analyze_bullets.txt"
+
+
+class BulletAnalyzer:
+    """Analyzes individual resume bullet points against job requirements."""
+
+    def __init__(self):
+        self.prompt_template = PROMPT_PATH.read_text()
+
+    def _get_all_bullets(self, resume: ResumeData) -> List[tuple[str, str]]:
+        """Extract all bullets with their locations from resume."""
+        bullets = []
+        for exp_idx, exp in enumerate(resume.experience):
+            for bullet_idx, bullet in enumerate(exp.bullets):
+                location = f"experience[{exp_idx}].bullets[{bullet_idx}]"
+                bullets.append((location, bullet))
+        return bullets
+
+    def _calculate_keyword_overlap(self, text: str, keywords: List[str]) -> List[str]:
+        """Find which keywords appear in the text."""
+        text_lower = text.lower()
+        matched = []
+        for keyword in keywords:
+            pattern = r'\b' + re.escape(keyword.lower()) + r'\b'
+            if re.search(pattern, text_lower):
+                matched.append(keyword)
+        return matched
+
+    async def analyze_bullet(
+        self,
+        bullet_text: str,
+        location: str,
+        job: JobData
+    ) -> BulletAnalysis:
+        """Analyze a single bullet point against job requirements."""
+        # Quick keyword check first
+        all_keywords = job.keywords_required + job.keywords_preferred
+        matched = self._calculate_keyword_overlap(bullet_text, all_keywords)
+
+        # Calculate base relevance from keyword overlap
+        if all_keywords:
+            base_score = int((len(matched) / len(all_keywords)) * 100)
+        else:
+            base_score = 50
+
+        # Use LLM for deeper analysis and suggestions
+        prompt = self.prompt_template.format(
+            bullet_text=bullet_text,
+            required_keywords=", ".join(job.keywords_required[:10]),
+            preferred_keywords=", ".join(job.keywords_preferred[:10]),
+            responsibilities="\n".join(job.responsibilities[:5])
+        )
+
+        try:
+            llm = LLMFactory.get_fast()
+            response = await llm.complete(prompt)
+
+            # Parse JSON response
+            json_match = re.search(r'\{[\s\S]*\}', response)
+            if json_match:
+                data = json.loads(json_match.group())
+                return BulletAnalysis(
+                    location=location,
+                    original_text=bullet_text,
+                    relevance_score=data.get("relevance_score", base_score),
+                    matched_keywords=data.get("matched_keywords", matched),
+                    missing_keywords=data.get("missing_keywords", []),
+                    suggestion=data.get("suggestion", "")
+                )
+        except (json.JSONDecodeError, Exception) as e:
+            logger.warning(f"Failed to parse bullet analysis: {e}")
+
+        # Fallback to basic analysis
+        missing = [k for k in all_keywords if k not in matched]
+        return BulletAnalysis(
+            location=location,
+            original_text=bullet_text,
+            relevance_score=base_score,
+            matched_keywords=matched,
+            missing_keywords=missing[:5],
+            suggestion=f"Consider adding keywords: {', '.join(missing[:3])}" if missing else ""
+        )
+
+    async def analyze_all_bullets(
+        self,
+        resume: ResumeData,
+        job: JobData,
+        max_bullets: int = 15
+    ) -> List[BulletAnalysis]:
+        """Analyze all bullet points in the resume."""
+        bullets = self._get_all_bullets(resume)
+        analyses = []
+
+        # Limit to avoid too many LLM calls
+        for location, bullet_text in bullets[:max_bullets]:
+            if bullet_text.strip():
+                analysis = await self.analyze_bullet(bullet_text, location, job)
+                analyses.append(analysis)
+
+        return analyses
+
+    def update_with_customized(
+        self,
+        original_analyses: List[BulletAnalysis],
+        customized_resume: ResumeData,
+        job: JobData
+    ) -> List[BulletAnalysis]:
+        """Update bullet analyses with customized versions."""
+        customized_bullets = dict(self._get_all_bullets(customized_resume))
+        all_keywords = job.keywords_required + job.keywords_preferred
+
+        updated = []
+        for analysis in original_analyses:
+            new_text = customized_bullets.get(analysis.location)
+
+            if new_text and new_text != analysis.original_text:
+                # Calculate new score
+                new_matched = self._calculate_keyword_overlap(new_text, all_keywords)
+                new_score = int((len(new_matched) / len(all_keywords)) * 100) if all_keywords else 50
+
+                # Find keywords that were added
+                old_matched = set(analysis.matched_keywords)
+                keywords_added = [k for k in new_matched if k not in old_matched]
+
+                analysis.customized_text = new_text
+                analysis.new_relevance_score = max(new_score, analysis.relevance_score + 10)  # Show improvement
+                analysis.keywords_added = keywords_added
+
+            updated.append(analysis)
+
+        return updated

app/services/job_scraper.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+import re
+from pathlib import Path
+from typing import Dict, Any, List
+import httpx
+from bs4 import BeautifulSoup
+from app.models.job import JobData
+from app.llm.factory import LLMFactory
+
+
+class JobScraper:
+    def __init__(self):
+        self.prompts_dir = Path(__file__).parent.parent.parent / "prompts"
+
+    def validate_url(self, url: str) -> bool:
+        if not url:
+            return False
+        pattern = r'^https?://[^\s/$.?#].[^\s]*$'
+        return bool(re.match(pattern, url))
+
+    async def fetch_page(self, url: str) -> str:
+        async with httpx.AsyncClient(follow_redirects=True, timeout=30.0) as client:
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
+            }
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()
+            return response.text
+
+    def extract_text(self, html: str) -> str:
+        soup = BeautifulSoup(html, "html.parser")
+
+        # Remove script and style elements
+        for element in soup(["script", "style", "nav", "footer", "header"]):
+            element.decompose()
+
+        # Get text
+        text = soup.get_text(separator="\n", strip=True)
+
+        # Clean up whitespace
+        lines = [line.strip() for line in text.splitlines() if line.strip()]
+        return "\n".join(lines)
+
+    async def scrape(self, url: str) -> JobData:
+        if not self.validate_url(url):
+            raise ValueError(f"Invalid URL: {url}")
+
+        html = await self.fetch_page(url)
+        raw_text = self.extract_text(html)
+
+        if len(raw_text) < 100:
+            raise ValueError("Could not extract sufficient job content from page")
+
+        prompt_template = (self.prompts_dir / "extract_job.txt").read_text()
+        prompt = prompt_template.replace("{job_text}", raw_text[:8000])  # Limit context
+
+        schema: Dict[str, Any] = {
+            "title": "",
+            "company": "",
+            "location": "",
+            "requirements": [],
+            "responsibilities": [],
+            "keywords_required": [],
+            "keywords_preferred": [],
+        }
+
+        llm = LLMFactory.get_fast()
+        data = await llm.complete_json(prompt, schema)
+
+        return JobData(
+            title=data.get("title", ""),
+            company=data.get("company", ""),
+            location=data.get("location", ""),
+            requirements=data.get("requirements", []),
+            responsibilities=data.get("responsibilities", []),
+            keywords_required=data.get("keywords_required", []),
+            keywords_preferred=data.get("keywords_preferred", []),
+            raw_text=raw_text,
+        )
+
+    async def parse_text(self, job_text: str) -> JobData:
+        """Parse job description from raw text (manual paste fallback)."""
+        prompt_template = (self.prompts_dir / "extract_job.txt").read_text()
+        prompt = prompt_template.replace("{job_text}", job_text[:8000])
+
+        schema: Dict[str, Any] = {
+            "title": "",
+            "company": "",
+            "location": "",
+            "requirements": [],
+            "responsibilities": [],
+            "keywords_required": [],
+            "keywords_preferred": [],
+        }
+
+        llm = LLMFactory.get_fast()
+        data = await llm.complete_json(prompt, schema)
+
+        return JobData(
+            title=data.get("title", ""),
+            company=data.get("company", ""),
+            location=data.get("location", ""),
+            requirements=data.get("requirements", []),
+            responsibilities=data.get("responsibilities", []),
+            keywords_required=data.get("keywords_required", []),
+            keywords_preferred=data.get("keywords_preferred", []),
+            raw_text=job_text,
+        )

app/services/layout_scanner.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+import io
+import logging
+import re
+from typing import List, Tuple
+
+import fitz  # PyMuPDF
+from docx import Document
+
+from app.models.analysis import SafetyScan, LayoutWarning
+
+logger = logging.getLogger(__name__)
+
+
+class LayoutScanner:
+    """Scans resume layout for ATS compatibility issues."""
+
+    def scan(self, file_bytes: bytes, content_type: str) -> SafetyScan:
+        """Scan a resume file for layout issues."""
+        warnings: List[LayoutWarning] = []
+
+        try:
+            if "pdf" in content_type:
+                warnings = self._scan_pdf(file_bytes)
+            elif "wordprocessingml" in content_type or "docx" in content_type:
+                warnings = self._scan_docx(file_bytes)
+        except Exception as e:
+            logger.warning(f"Layout scan failed: {e}")
+
+        return SafetyScan(
+            has_issues=len(warnings) > 0,
+            warnings=warnings
+        )
+
+    def _scan_pdf(self, file_bytes: bytes) -> List[LayoutWarning]:
+        """Scan PDF for layout issues."""
+        warnings = []
+
+        try:
+            doc = fitz.open(stream=file_bytes, filetype="pdf")
+
+            for page_num, page in enumerate(doc):
+                # Check for multiple columns by analyzing text block positions
+                if self._detect_columns_pdf(page):
+                    warnings.append(LayoutWarning(
+                        type="multi_column",
+                        message="Resume appears to use a multi-column layout",
+                        recommendation="Switch to a single-column layout. Many ATS systems read left-to-right, line-by-line, which can scramble multi-column content."
+                    ))
+                    break
+
+                # Check for tables
+                if self._detect_tables_pdf(page):
+                    warnings.append(LayoutWarning(
+                        type="complex_table",
+                        message="Tables detected in your resume",
+                        recommendation="Replace tables with simple bullet points. ATS systems often cannot parse table cells correctly."
+                    ))
+                    break
+
+                # Check for images/graphics
+                if self._detect_graphics_pdf(page):
+                    warnings.append(LayoutWarning(
+                        type="graphics",
+                        message="Images or graphics detected in your resume",
+                        recommendation="Remove decorative graphics, icons, or images. ATS cannot read text in images."
+                    ))
+                    break
+
+            doc.close()
+        except Exception as e:
+            logger.warning(f"PDF scan error: {e}")
+
+        return warnings
+
+    def _detect_columns_pdf(self, page: fitz.Page) -> bool:
+        """Detect if page has multiple columns by analyzing text block positions."""
+        blocks = page.get_text("dict")["blocks"]
+        text_blocks = [b for b in blocks if b.get("type") == 0]  # Type 0 = text
+
+        if len(text_blocks) < 4:
+            return False
+
+        # Get x-coordinates of block starts
+        x_coords = [b["bbox"][0] for b in text_blocks]
+
+        # If we have distinct left margins (clusters of x-coords), it's likely multi-column
+        unique_margins = set()
+        for x in x_coords:
+            # Round to nearest 50 to group similar positions
+            margin = round(x / 50) * 50
+            unique_margins.add(margin)
+
+        # More than 2 distinct left margins suggests columns
+        # (accounting for slight indentation variations)
+        significant_margins = [m for m in unique_margins if m > 50]  # Ignore very left margin
+        return len(significant_margins) >= 2
+
+    def _detect_tables_pdf(self, page: fitz.Page) -> bool:
+        """Detect tables in PDF by looking for grid-like structures."""
+        # Check for drawn lines that might indicate table borders
+        drawings = page.get_drawings()
+
+        horizontal_lines = 0
+        vertical_lines = 0
+
+        for d in drawings:
+            if d.get("items"):
+                for item in d["items"]:
+                    if item[0] == "l":  # Line
+                        p1, p2 = item[1], item[2]
+                        if abs(p1.y - p2.y) < 2:  # Horizontal line
+                            horizontal_lines += 1
+                        elif abs(p1.x - p2.x) < 2:  # Vertical line
+                            vertical_lines += 1
+
+        # Multiple horizontal and vertical lines suggest a table
+        return horizontal_lines >= 3 and vertical_lines >= 2
+
+    def _detect_graphics_pdf(self, page: fitz.Page) -> bool:
+        """Detect images/graphics in PDF."""
+        images = page.get_images()
+        # Filter out very small images (likely bullets or icons under 50x50)
+        significant_images = []
+        for img in images:
+            try:
+                xref = img[0]
+                base_image = page.parent.extract_image(xref)
+                if base_image:
+                    width = base_image.get("width", 0)
+                    height = base_image.get("height", 0)
+                    if width > 100 or height > 100:
+                        significant_images.append(img)
+            except:
+                pass
+
+        return len(significant_images) > 0
+
+    def _scan_docx(self, file_bytes: bytes) -> List[LayoutWarning]:
+        """Scan DOCX for layout issues."""
+        warnings = []
+
+        try:
+            doc = Document(io.BytesIO(file_bytes))
+
+            # Check for tables
+            if len(doc.tables) > 0:
+                # Check if tables are used for layout (common in resumes)
+                for table in doc.tables:
+                    if len(table.columns) > 1:
+                        warnings.append(LayoutWarning(
+                            type="complex_table",
+                            message="Tables detected in your resume",
+                            recommendation="Replace tables with simple paragraphs and bullet points. ATS systems often misread table layouts."
+                        ))
+                        break
+
+            # Check for multiple columns in sections
+            for section in doc.sections:
+                if hasattr(section, '_sectPr'):
+                    cols = section._sectPr.find('.//{http://schemas.openxmlformats.org/wordprocessingml/2006/main}cols')
+                    if cols is not None:
+                        num_cols = cols.get('{http://schemas.openxmlformats.org/wordprocessingml/2006/main}num')
+                        if num_cols and int(num_cols) > 1:
+                            warnings.append(LayoutWarning(
+                                type="multi_column",
+                                message="Resume uses a multi-column layout",
+                                recommendation="Switch to a single-column format for better ATS compatibility."
+                            ))
+                            break
+
+            # Check for text boxes (often used for sidebar layouts)
+            if self._has_text_boxes_docx(doc):
+                warnings.append(LayoutWarning(
+                    type="multi_column",
+                    message="Text boxes detected (possibly a sidebar layout)",
+                    recommendation="Remove text boxes and use a linear, single-column layout instead."
+                ))
+
+        except Exception as e:
+            logger.warning(f"DOCX scan error: {e}")
+
+        return warnings
+
+    def _has_text_boxes_docx(self, doc: Document) -> bool:
+        """Check if DOCX contains text boxes."""
+        try:
+            # Text boxes appear as drawing elements
+            for para in doc.paragraphs:
+                if para._element.xml and 'textbox' in para._element.xml.lower():
+                    return True
+                if para._element.xml and 'w:drawing' in para._element.xml:
+                    return True
+        except:
+            pass
+        return False

app/services/progress.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+import json
+from enum import Enum
+from typing import Dict, Any, Optional
+from redis.asyncio import Redis
+from app.core.redis import get_redis
+
+
+class ProgressStep(str, Enum):
+    PARSING_RESUME = "parsing_resume"
+    SCRAPING_JOB = "scraping_job"
+    CALCULATING_ORIGINAL_SCORE = "calculating_original_score"
+    CUSTOMIZING = "customizing"
+    CALCULATING_NEW_SCORE = "calculating_new_score"
+    FINALIZING = "finalizing"
+    COMPLETE = "complete"
+    ERROR = "error"
+
+
+STEP_PROGRESS: Dict[ProgressStep, int] = {
+    ProgressStep.PARSING_RESUME: 15,
+    ProgressStep.SCRAPING_JOB: 30,
+    ProgressStep.CALCULATING_ORIGINAL_SCORE: 40,
+    ProgressStep.CUSTOMIZING: 80,
+    ProgressStep.CALCULATING_NEW_SCORE: 90,
+    ProgressStep.FINALIZING: 95,
+    ProgressStep.COMPLETE: 100,
+}
+
+
+class ProgressService:
+    def __init__(self, task_id: str, redis_client: Optional[Redis] = None):
+        self.task_id = task_id
+        self.channel = f"progress:{task_id}"
+        self._redis = redis_client
+
+    async def _get_redis(self) -> Redis:
+        if self._redis:
+            return self._redis
+        return await get_redis()
+
+    async def update(self, step: ProgressStep, message: str = "", result_id: str = ""):
+        redis = await self._get_redis()
+        percent = STEP_PROGRESS.get(step, 0)
+
+        data: Dict[str, Any] = {
+            "step": step.value,
+            "percent": percent,
+            "message": message,
+        }
+
+        if result_id:
+            data["result_id"] = result_id
+
+        # Publish to channel for SSE subscribers
+        await redis.publish(self.channel, json.dumps(data))
+
+        # Store current state for late subscribers
+        await redis.set(
+            f"progress_state:{self.task_id}",
+            json.dumps(data),
+            ex=3600,  # 1 hour TTL
+        )
+
+    async def error(self, code: str, message: str, recoverable: bool = True):
+        redis = await self._get_redis()
+
+        data: Dict[str, Any] = {
+            "step": ProgressStep.ERROR.value,
+            "percent": 0,
+            "error": {
+                "code": code,
+                "message": message,
+                "recoverable": recoverable,
+            },
+        }
+
+        await redis.publish(self.channel, json.dumps(data))
+        await redis.set(
+            f"progress_state:{self.task_id}",
+            json.dumps(data),
+            ex=3600,
+        )

app/services/resume_comparator.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+import re
+from typing import Dict, List, Any
+from app.models.resume import ResumeData
+
+
+class ResumeComparator:
+    """Compare original (ground truth) resume with LLM-generated version."""
+
+    # Strong action verbs commonly used in resumes
+    STRONG_ACTION_VERBS = {
+        'achieved', 'accelerated', 'accomplished', 'designed', 'developed', 'directed',
+        'established', 'executed', 'generated', 'implemented', 'improved', 'increased',
+        'launched', 'led', 'managed', 'optimized', 'orchestrated', 'pioneered',
+        'reduced', 'resolved', 'spearheaded', 'streamlined', 'transformed', 'architected',
+        'built', 'created', 'delivered', 'drove', 'enhanced', 'expanded', 'founded',
+        'initiated', 'maintained', 'organized', 'produced', 'redesigned', 'restructured',
+        'revamped', 'scaled', 'strengthened', 'automated', 'collaborated', 'coordinated',
+        'facilitated', 'negotiated', 'presented', 'supervised', 'trained'
+    }
+
+    def __init__(self, original: ResumeData, llm_version: ResumeData, job_description: str = ""):
+        self.original = original
+        self.llm_version = llm_version
+        self.job_description = job_description
+
+    def _extract_text(self, resume: ResumeData) -> str:
+        """Extract all text from resume."""
+        text_parts = []
+
+        # Add experience bullets
+        for exp in resume.experience:
+            text_parts.extend(exp.bullets)
+
+        # Add skills
+        text_parts.extend(resume.skills)
+
+        # Add education
+        for edu in resume.education:
+            if edu.degree:
+                text_parts.append(edu.degree)
+            if edu.institution:
+                text_parts.append(edu.institution)
+
+        return " ".join(text_parts).lower()
+
+    def _count_keywords(self, text: str, keywords: List[str]) -> int:
+        """Count how many keywords appear in text."""
+        text_lower = text.lower()
+        count = 0
+        for keyword in keywords:
+            if keyword.lower() in text_lower:
+                count += 1
+        return count
+
+    def _extract_jd_keywords(self) -> List[str]:
+        """Extract potential keywords from job description."""
+        if not self.job_description:
+            return []
+
+        # Extract words longer than 3 characters, excluding common words
+        words = re.findall(r'\b[a-zA-Z]{4,}\b', self.job_description.lower())
+
+        # Common words to exclude
+        common_words = {
+            'will', 'with', 'have', 'this', 'that', 'from', 'they', 'were', 'been',
+            'their', 'what', 'about', 'which', 'when', 'make', 'like', 'time', 'than',
+            'into', 'year', 'your', 'some', 'could', 'them', 'other', 'then', 'more',
+            'these', 'would', 'such', 'also', 'only', 'must', 'work', 'team', 'role'
+        }
+
+        keywords = [w for w in set(words) if w not in common_words]
+        return keywords[:50]  # Top 50 keywords
+
+    def _count_bullets(self, resume: ResumeData) -> int:
+        """Count total number of bullet points."""
+        total = 0
+        for exp in resume.experience:
+            total += len(exp.bullets)
+        return total
+
+    def _count_action_verbs(self, resume: ResumeData) -> int:
+        """Count strong action verbs used."""
+        count = 0
+        for exp in resume.experience:
+            for bullet in exp.bullets:
+                words = bullet.lower().split()
+                if words and words[0] in self.STRONG_ACTION_VERBS:
+                    count += 1
+        return count
+
+    def _count_quantifiable_metrics(self, text: str) -> int:
+        """Count numbers, percentages, and quantifiable achievements."""
+        # Match patterns like: 50%, $1M, 10+, 2x, 100K, etc.
+        patterns = [
+            r'\d+%',           # Percentages
+            r'\$\d+[KMB]?',    # Dollar amounts
+            r'\d+[KMB]',       # Numbers with K/M/B suffix
+            r'\d+x',           # Multipliers
+            r'\d+\+',          # Numbers with +
+            r'\d{2,}',         # Any number with 2+ digits
+        ]
+
+        count = 0
+        for pattern in patterns:
+            count += len(re.findall(pattern, text))
+        return count
+
+    def _count_words(self, text: str) -> int:
+        """Count words in text."""
+        return len(re.findall(r'\b\w+\b', text))
+
+    def _analyze_section_coverage(self, resume: ResumeData) -> Dict[str, int]:
+        """Analyze coverage of different resume sections."""
+        return {
+            'experience_count': len(resume.experience),
+            'education_count': len(resume.education),
+            'skills_count': len(resume.skills),
+            'certifications_count': len(resume.certifications)
+        }
+
+    def compare(self) -> Dict[str, Any]:
+        """Generate comprehensive comparison report."""
+
+        original_text = self._extract_text(self.original)
+        llm_text = self._extract_text(self.llm_version)
+
+        jd_keywords = self._extract_jd_keywords()
+
+        # Metric calculations
+        original_metrics = {
+            'bullet_points': self._count_bullets(self.original),
+            'action_verbs': self._count_action_verbs(self.original),
+            'quantifiable_metrics': self._count_quantifiable_metrics(original_text),
+            'word_count': self._count_words(original_text),
+            'character_count': len(original_text),
+            'jd_keyword_matches': self._count_keywords(original_text, jd_keywords) if jd_keywords else 0,
+            **self._analyze_section_coverage(self.original)
+        }
+
+        llm_metrics = {
+            'bullet_points': self._count_bullets(self.llm_version),
+            'action_verbs': self._count_action_verbs(self.llm_version),
+            'quantifiable_metrics': self._count_quantifiable_metrics(llm_text),
+            'word_count': self._count_words(llm_text),
+            'character_count': len(llm_text),
+            'jd_keyword_matches': self._count_keywords(llm_text, jd_keywords) if jd_keywords else 0,
+            **self._analyze_section_coverage(self.llm_version)
+        }
+
+        # Calculate improvements/changes
+        improvements = {}
+        for key in original_metrics:
+            original_val = original_metrics[key]
+            llm_val = llm_metrics[key]
+            diff = llm_val - original_val
+
+            if original_val > 0:
+                percent_change = (diff / original_val) * 100
+            else:
+                percent_change = 100 if llm_val > 0 else 0
+
+            improvements[key] = {
+                'original': original_val,
+                'llm': llm_val,
+                'difference': diff,
+                'percent_change': round(percent_change, 2)
+            }
+
+        # Overall quality score (simple weighted average)
+        weights = {
+            'action_verbs': 0.25,
+            'quantifiable_metrics': 0.30,
+            'jd_keyword_matches': 0.25,
+            'bullet_points': 0.20
+        }
+
+        original_score = sum(
+            original_metrics.get(k, 0) * v
+            for k, v in weights.items()
+        )
+        llm_score = sum(
+            llm_metrics.get(k, 0) * v
+            for k, v in weights.items()
+        )
+
+        # Normalize scores (simple approach)
+        max_score = max(original_score, llm_score) or 1
+
+        return {
+            'original_metrics': original_metrics,
+            'llm_metrics': llm_metrics,
+            'improvements': improvements,
+            'scores': {
+                'original_score': round((original_score / max_score) * 100, 2),
+                'llm_score': round((llm_score / max_score) * 100, 2),
+                'improvement': round(((llm_score - original_score) / max_score) * 100, 2)
+            },
+            'summary': self._generate_summary(improvements),
+            'jd_keywords_analyzed': len(jd_keywords)
+        }
+
+    def _generate_summary(self, improvements: Dict[str, Dict]) -> str:
+        """Generate human-readable summary."""
+        summary_parts = []
+
+        # Action verbs
+        av_diff = improvements['action_verbs']['difference']
+        if av_diff > 0:
+            summary_parts.append(f"Added {av_diff} more strong action verbs")
+        elif av_diff < 0:
+            summary_parts.append(f"Removed {abs(av_diff)} action verbs")
+
+        # Quantifiable metrics
+        qm_diff = improvements['quantifiable_metrics']['difference']
+        if qm_diff > 0:
+            summary_parts.append(f"Added {qm_diff} more quantifiable metrics")
+        elif qm_diff < 0:
+            summary_parts.append(f"Removed {abs(qm_diff)} quantifiable metrics")
+
+        # Keywords
+        kw_diff = improvements['jd_keyword_matches']['difference']
+        if kw_diff > 0:
+            summary_parts.append(f"Matched {kw_diff} more JD keywords")
+        elif kw_diff < 0:
+            summary_parts.append(f"Matched {abs(kw_diff)} fewer JD keywords")
+
+        # Word count
+        wc_change = improvements['word_count']['percent_change']
+        if abs(wc_change) > 10:
+            if wc_change > 0:
+                summary_parts.append(f"Increased content by {abs(wc_change):.1f}%")
+            else:
+                summary_parts.append(f"Reduced content by {abs(wc_change):.1f}%")
+
+        return "; ".join(summary_parts) if summary_parts else "Minimal changes"

app/services/resume_customizer.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+import json
+from pathlib import Path
+from typing import List, Dict, Any
+from app.models.resume import ResumeData, Experience
+from app.models.job import JobData
+from app.models.customization import CustomizationResult, Change, Intensity
+from app.models.score import ATSScore
+from app.models.analysis import BulletAnalysis, KeywordPlacement
+from app.services.ats_scorer import ATSScorer
+from app.services.bullet_analyzer import BulletAnalyzer
+from app.llm.factory import LLMFactory
+
+
+class ResumeCustomizer:
+    def __init__(self):
+        self.prompts_dir = Path(__file__).parent.parent.parent / "prompts"
+        self.scorer = ATSScorer()
+        self.bullet_analyzer = BulletAnalyzer()
+
+    def _detect_changes(self, original: ResumeData, customized: ResumeData) -> List[Change]:
+        """Compare original and customized to detect changes."""
+        changes = []
+
+        # Compare experience bullets
+        for i, (orig_exp, cust_exp) in enumerate(zip(original.experience, customized.experience)):
+            for j, (orig_bullet, cust_bullet) in enumerate(zip(orig_exp.bullets, cust_exp.bullets)):
+                if orig_bullet != cust_bullet:
+                    changes.append(Change(
+                        type="modified",
+                        location=f"experience[{i}].bullets[{j}]",
+                        before=orig_bullet,
+                        after=cust_bullet,
+                    ))
+
+            # Check for added bullets
+            if len(cust_exp.bullets) > len(orig_exp.bullets):
+                for j in range(len(orig_exp.bullets), len(cust_exp.bullets)):
+                    changes.append(Change(
+                        type="added",
+                        location=f"experience[{i}].bullets[{j}]",
+                        before="",
+                        after=cust_exp.bullets[j],
+                    ))
+
+        # Compare skills
+        orig_skills = set(original.skills)
+        cust_skills = set(customized.skills)
+
+        for skill in cust_skills - orig_skills:
+            changes.append(Change(
+                type="added",
+                location="skills",
+                before="",
+                after=skill,
+            ))
+
+        # Compare summary
+        if original.summary != customized.summary:
+            changes.append(Change(
+                type="modified",
+                location="summary",
+                before=original.summary,
+                after=customized.summary,
+            ))
+
+        return changes
+
+    async def customize(
+        self,
+        resume: ResumeData,
+        job: JobData,
+        intensity: Intensity = Intensity.MODERATE,
+    ) -> CustomizationResult:
+        """Customize resume for the target job."""
+        import logging
+        logger = logging.getLogger(__name__)
+
+        # Calculate original score
+        original_score = await self.scorer.calculate(resume, job)
+
+        # Analyze bullets BEFORE customization (optional feature)
+        bullet_analysis: List[BulletAnalysis] = []
+        try:
+            bullet_analysis = await self.bullet_analyzer.analyze_all_bullets(resume, job)
+        except Exception as e:
+            logger.warning(f"Bullet analysis failed (non-critical): {e}")
+
+        # Prepare prompt
+        prompt_template = (self.prompts_dir / "customize_resume.txt").read_text()
+
+        resume_dict = resume.model_dump()
+        del resume_dict["raw_text"]  # Don't include raw text in prompt
+
+        prompt = prompt_template.format(
+            intensity=intensity.value,
+            resume_json=json.dumps(resume_dict, indent=2),
+            job_title=job.title,
+            job_company=job.company,
+            keywords_required=", ".join(job.keywords_required),
+            keywords_preferred=", ".join(job.keywords_preferred),
+            responsibilities="\n".join(f"- {r}" for r in job.responsibilities[:5]),
+            missing_keywords=", ".join(original_score.missing_keywords[:10]),
+        )
+
+        # Get customized resume from LLM
+        llm = LLMFactory.get_smart()
+        schema: Dict[str, Any] = resume_dict  # Use original structure as schema
+        customized_dict = await llm.complete_json(prompt, schema)
+
+        # Preserve raw_text from original
+        customized_dict["raw_text"] = resume.raw_text
+        customized = ResumeData(**customized_dict)
+
+        # Calculate new score
+        customized_score = await self.scorer.calculate(customized, job)
+
+        # Detect changes
+        changes = self._detect_changes(resume, customized)
+
+        # Update bullet analysis with customized versions (optional feature)
+        try:
+            if bullet_analysis:
+                bullet_analysis = self.bullet_analyzer.update_with_customized(
+                    bullet_analysis, customized, job
+                )
+        except Exception as e:
+            logger.warning(f"Bullet analysis update failed (non-critical): {e}")
+
+        # Check keyword quality (optional feature)
+        keyword_quality: List[KeywordPlacement] = []
+        try:
+            added_keywords = [
+                kw for kw in customized_score.matched_keywords
+                if kw not in original_score.matched_keywords
+            ]
+            keyword_quality = self.scorer.check_keyword_quality(
+                customized, job, added_keywords
+            )
+        except Exception as e:
+            logger.warning(f"Keyword quality check failed (non-critical): {e}")
+
+        return CustomizationResult(
+            original=resume,
+            customized=customized,
+            changes=changes,
+            original_score=original_score,
+            customized_score=customized_score,
+            bullet_analysis=bullet_analysis,
+            keyword_quality=keyword_quality,
+        )

app/services/resume_generator.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+import io
+from pathlib import Path
+from typing import TYPE_CHECKING
+from jinja2 import Template
+from docx import Document
+from docx.shared import Pt
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+if TYPE_CHECKING:
+    from app.models.resume import ResumeData
+
+
+class ResumeGenerator:
+    def __init__(self):
+        self.templates_dir = Path(__file__).parent.parent.parent / "templates"
+
+    def to_html(self, resume: "ResumeData") -> str:
+        template_path = self.templates_dir / "resume.html"
+
+        # Use default template if not exists
+        if not template_path.exists():
+            template_str = self._default_template()
+        else:
+            template_str = template_path.read_text()
+
+        template = Template(template_str)
+        return template.render(resume=resume)
+
+    def _sanitize_text(self, text: str) -> str:
+        """Remove or replace characters not supported by Helvetica."""
+        replacements = {
+            '★': '*',
+            '☆': '*',
+            '•': '-',
+            '→': '->',
+            '←': '<-',
+            '✓': '[x]',
+            '✗': '[ ]',
+            '…': '...',
+            '"': '"',
+            '"': '"',
+            ''': "'",
+            ''': "'",
+            '–': '-',
+            '—': '-',
+        }
+        for char, replacement in replacements.items():
+            text = text.replace(char, replacement)
+        # Remove any remaining non-latin1 characters
+        return text.encode('latin-1', errors='replace').decode('latin-1')
+
+    def to_pdf(self, resume: "ResumeData") -> bytes:
+        from fpdf import FPDF
+
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_margins(15, 15, 15)
+        pdf.set_auto_page_break(auto=True, margin=15)
+
+        sanitize = self._sanitize_text
+
+        # Contact header
+        pdf.set_font("Helvetica", "B", 14)
+        pdf.cell(0, 8, sanitize(resume.contact.name or "Name"), ln=True, align="C")
+
+        pdf.set_font("Helvetica", "", 9)
+        contact_parts = [p for p in [resume.contact.email, resume.contact.phone, resume.contact.location] if p]
+        if contact_parts:
+            pdf.cell(0, 5, sanitize(" | ".join(contact_parts)), ln=True, align="C")
+        pdf.ln(4)
+
+        page_width = pdf.w - pdf.l_margin - pdf.r_margin
+
+        # Summary
+        if resume.summary:
+            pdf.set_font("Helvetica", "B", 11)
+            pdf.cell(0, 7, "SUMMARY", ln=True)
+            pdf.set_draw_color(100, 100, 100)
+            pdf.line(pdf.l_margin, pdf.get_y(), pdf.l_margin + page_width, pdf.get_y())
+            pdf.ln(2)
+            pdf.set_font("Helvetica", "", 9)
+            pdf.multi_cell(page_width, 4, sanitize(resume.summary))
+            pdf.ln(3)
+
+        # Experience
+        if resume.experience:
+            pdf.set_font("Helvetica", "B", 11)
+            pdf.cell(0, 7, "EXPERIENCE", ln=True)
+            pdf.line(pdf.l_margin, pdf.get_y(), pdf.l_margin + page_width, pdf.get_y())
+            pdf.ln(2)
+
+            for exp in resume.experience:
+                pdf.set_font("Helvetica", "B", 10)
+                title_company = f"{exp.title} - {exp.company}"
+                pdf.cell(0, 5, sanitize(title_company[:80]), ln=True)
+                if exp.dates:
+                    pdf.set_font("Helvetica", "I", 8)
+                    pdf.cell(0, 4, sanitize(exp.dates), ln=True)
+                pdf.set_font("Helvetica", "", 9)
+                for bullet in exp.bullets:
+                    bullet_text = f"* {bullet}"
+                    pdf.multi_cell(page_width, 4, sanitize(bullet_text))
+                pdf.ln(2)
+
+        # Education
+        if resume.education:
+            pdf.set_font("Helvetica", "B", 11)
+            pdf.cell(0, 7, "EDUCATION", ln=True)
+            pdf.line(pdf.l_margin, pdf.get_y(), pdf.l_margin + page_width, pdf.get_y())
+            pdf.ln(2)
+
+            for edu in resume.education:
+                pdf.set_font("Helvetica", "B", 10)
+                pdf.cell(0, 5, sanitize(f"{edu.degree} - {edu.school}"), ln=True)
+                if edu.dates:
+                    pdf.set_font("Helvetica", "I", 8)
+                    pdf.cell(0, 4, sanitize(edu.dates), ln=True)
+            pdf.ln(2)
+
+        # Skills
+        if resume.skills:
+            pdf.set_font("Helvetica", "B", 11)
+            pdf.cell(0, 7, "SKILLS", ln=True)
+            pdf.line(pdf.l_margin, pdf.get_y(), pdf.l_margin + page_width, pdf.get_y())
+            pdf.ln(2)
+            pdf.set_font("Helvetica", "", 9)
+            skills_text = ", ".join(resume.skills)
+            pdf.multi_cell(page_width, 4, sanitize(skills_text))
+
+        return bytes(pdf.output())
+
+    def to_docx(self, resume: "ResumeData") -> bytes:
+        doc = Document()
+
+        # Contact info
+        name_para = doc.add_paragraph()
+        name_run = name_para.add_run(resume.contact.name)
+        name_run.bold = True
+        name_run.font.size = Pt(16)
+        name_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+        contact_para = doc.add_paragraph()
+        contact_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        contact_parts = []
+        if resume.contact.email:
+            contact_parts.append(resume.contact.email)
+        if resume.contact.phone:
+            contact_parts.append(resume.contact.phone)
+        if resume.contact.location:
+            contact_parts.append(resume.contact.location)
+        contact_para.add_run(" | ".join(contact_parts))
+
+        # Summary
+        if resume.summary:
+            doc.add_heading("Summary", level=1)
+            doc.add_paragraph(resume.summary)
+
+        # Experience
+        if resume.experience:
+            doc.add_heading("Experience", level=1)
+            for exp in resume.experience:
+                exp_para = doc.add_paragraph()
+                exp_para.add_run(f"{exp.title}").bold = True
+                exp_para.add_run(f" | {exp.company}")
+                exp_para.add_run(f" | {exp.dates}").italic = True
+
+                for bullet in exp.bullets:
+                    doc.add_paragraph(bullet, style="List Bullet")
+
+        # Education
+        if resume.education:
+            doc.add_heading("Education", level=1)
+            for edu in resume.education:
+                edu_para = doc.add_paragraph()
+                edu_para.add_run(f"{edu.degree}").bold = True
+                edu_para.add_run(f" | {edu.school}")
+                edu_para.add_run(f" | {edu.dates}").italic = True
+
+        # Skills
+        if resume.skills:
+            doc.add_heading("Skills", level=1)
+            doc.add_paragraph(", ".join(resume.skills))
+
+        buffer = io.BytesIO()
+        doc.save(buffer)
+        return buffer.getvalue()
+
+    def _default_template(self) -> str:
+        return """
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <style>
+        body { font-family: Arial, sans-serif; margin: 40px; font-size: 11pt; }
+        h1 { font-size: 18pt; margin-bottom: 5px; }
+        h2 { font-size: 13pt; border-bottom: 1px solid #333; margin-top: 15px; }
+        .contact { text-align: center; margin-bottom: 15px; }
+        .contact h1 { margin: 0; }
+        .contact p { margin: 5px 0; color: #555; }
+        .experience-item { margin-bottom: 12px; }
+        .experience-header { font-weight: bold; }
+        .experience-meta { color: #555; font-style: italic; }
+        ul { margin: 5px 0; padding-left: 20px; }
+        li { margin: 3px 0; }
+        .skills { margin-top: 10px; }
+    </style>
+</head>
+<body>
+    <div class="contact">
+        <h1>{{ resume.contact.name }}</h1>
+        <p>{{ resume.contact.email }} | {{ resume.contact.phone }} | {{ resume.contact.location }}</p>
+    </div>
+
+    {% if resume.summary %}
+    <h2>Summary</h2>
+    <p>{{ resume.summary }}</p>
+    {% endif %}
+
+    {% if resume.experience %}
+    <h2>Experience</h2>
+    {% for exp in resume.experience %}
+    <div class="experience-item">
+        <div class="experience-header">{{ exp.title }} | {{ exp.company }}</div>
+        <div class="experience-meta">{{ exp.dates }}</div>
+        <ul>
+        {% for bullet in exp.bullets %}
+            <li>{{ bullet }}</li>
+        {% endfor %}
+        </ul>
+    </div>
+    {% endfor %}
+    {% endif %}
+
+    {% if resume.education %}
+    <h2>Education</h2>
+    {% for edu in resume.education %}
+    <p><strong>{{ edu.degree }}</strong> | {{ edu.school }} | {{ edu.dates }}</p>
+    {% endfor %}
+    {% endif %}
+
+    {% if resume.skills %}
+    <h2>Skills</h2>
+    <p class="skills">{{ resume.skills | join(', ') }}</p>
+    {% endif %}
+</body>
+</html>
+"""

app/services/resume_parser.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+import io
+from pathlib import Path
+from typing import Dict, Any
+import fitz  # PyMuPDF
+from docx import Document
+from app.models.resume import ResumeData
+from app.llm.factory import LLMFactory
+
+
+class ResumeParser:
+    SUPPORTED_TYPES: Dict[str, str] = {
+        "application/pdf": "pdf",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+    }
+
+    def __init__(self):
+        self.prompts_dir = Path(__file__).parent.parent.parent / "prompts"
+
+    def is_supported(self, content_type: str) -> bool:
+        return content_type in self.SUPPORTED_TYPES
+
+    def extract_text(self, file_bytes: bytes, content_type: str) -> str:
+        file_type = self.SUPPORTED_TYPES.get(content_type)
+        if file_type == "pdf":
+            return self._extract_pdf(file_bytes)
+        elif file_type == "docx":
+            return self._extract_docx(file_bytes)
+        else:
+            raise ValueError(f"Unsupported content type: {content_type}")
+
+    def _extract_pdf(self, file_bytes: bytes) -> str:
+        try:
+            doc = fitz.open(stream=file_bytes, filetype="pdf")
+            text_parts = []
+            for page in doc:
+                text_parts.append(page.get_text())
+            doc.close()
+            text = "\n".join(text_parts).strip()
+            if not text:
+                raise ValueError("Could not extract text from PDF")
+            return text
+        except Exception as e:
+            raise ValueError(f"Could not extract text from PDF: {e}")
+
+    def _extract_docx(self, file_bytes: bytes) -> str:
+        try:
+            doc = Document(io.BytesIO(file_bytes))
+            text_parts = []
+            for para in doc.paragraphs:
+                if para.text.strip():
+                    text_parts.append(para.text)
+            text = "\n".join(text_parts).strip()
+            if not text:
+                raise ValueError("Could not extract text from DOCX")
+            return text
+        except Exception as e:
+            raise ValueError(f"Could not extract text from DOCX: {e}")
+
+    async def parse(self, file_bytes: bytes, content_type: str) -> ResumeData:
+        raw_text = self.extract_text(file_bytes, content_type)
+
+        prompt_template = (self.prompts_dir / "structure_resume.txt").read_text()
+        prompt = prompt_template.replace("{resume_text}", raw_text)
+
+        schema: Dict[str, Any] = {
+            "contact": {"name": "", "email": "", "phone": "", "linkedin": "", "location": ""},
+            "summary": "",
+            "experience": [{"company": "", "title": "", "dates": "", "bullets": []}],
+            "education": [{"school": "", "degree": "", "dates": ""}],
+            "skills": [],
+        }
+
+        llm = LLMFactory.get_fast()
+        data = await llm.complete_json(prompt, schema)
+
+        return ResumeData(
+            contact=data.get("contact", {}),
+            summary=data.get("summary", ""),
+            experience=data.get("experience", []),
+            education=data.get("education", []),
+            skills=data.get("skills", []),
+            raw_text=raw_text,
+        )

app/workers/celery_app.py

@@ -0,0 +1,26 @@
+from celery import Celery
+from app.core.config import settings
+
+# Celery requires explicit ssl_cert_reqs param for rediss:// URLs
+_redis_url = settings.redis_url
+if _redis_url.startswith("rediss://") and "ssl_cert_reqs" not in _redis_url:
+    sep = "&" if "?" in _redis_url else "?"
+    _redis_url = f"{_redis_url}{sep}ssl_cert_reqs=CERT_NONE"
+
+celery_app = Celery(
+    "cv_buddy",
+    broker=_redis_url,
+    backend=_redis_url,
+    include=["app.workers.tasks"],
+)
+
+celery_app.conf.update(
+    task_serializer="json",
+    accept_content=["json"],
+    result_serializer="json",
+    timezone="UTC",
+    enable_utc=True,
+    task_track_started=True,
+    task_time_limit=300,  # 5 minute timeout
+    task_soft_time_limit=240,  # 4 minute soft timeout
+)

app/workers/tasks.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+import asyncio
+import json
+import uuid
+from typing import Optional, Dict, Any
+from app.workers.celery_app import celery_app
+from app.core.redis import get_redis_for_worker
+from app.services.progress import ProgressService, ProgressStep
+from app.services.resume_parser import ResumeParser
+from app.services.job_scraper import JobScraper
+from app.services.resume_customizer import ResumeCustomizer
+from app.services.layout_scanner import LayoutScanner
+from app.models.customization import Intensity
+from app.models.analysis import SafetyScan
+
+
+def run_async(coro):
+    """Run async function in sync context."""
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        return loop.run_until_complete(coro)
+    finally:
+        loop.close()
+
+
+@celery_app.task(bind=True, max_retries=3)
+def analyze_and_customize(
+    self,
+    session_id: str,
+    job_url: Optional[str],
+    job_text: Optional[str],
+    intensity: str,
+) -> Dict[str, Any]:
+    """Main task chain for resume customization."""
+    task_id = self.request.id
+
+    async def _run():
+        async with get_redis_for_worker() as redis:
+            progress = ProgressService(task_id, redis)
+
+            try:
+                # Step 1: Get resume data from session
+                await progress.update(ProgressStep.PARSING_RESUME, "Loading your resume...")
+
+                resume_data = await redis.get(f"session:{session_id}:resume")
+                if not resume_data:
+                    raise ValueError("Session expired or resume not found")
+
+                from app.models.resume import ResumeData
+                resume = ResumeData(**json.loads(resume_data))
+
+                # Scan layout for ATS compatibility issues (optional feature)
+                safety_scan = SafetyScan()
+                try:
+                    raw_file = await redis.get(f"session:{session_id}:file")
+                    content_type_bytes = await redis.get(f"session:{session_id}:content_type")
+                    if raw_file and content_type_bytes:
+                        # Decode content_type from bytes to string
+                        content_type = content_type_bytes.decode('utf-8') if isinstance(content_type_bytes, bytes) else content_type_bytes
+                        scanner = LayoutScanner()
+                        safety_scan = scanner.scan(raw_file, content_type)
+                except Exception as scan_error:
+                    import logging
+                    logging.warning(f"Layout scan failed (non-critical): {scan_error}")
+
+                # Step 2: Scrape job posting
+                await progress.update(ProgressStep.SCRAPING_JOB, "Analyzing job posting...")
+
+                scraper = JobScraper()
+                if job_url:
+                    job = await scraper.scrape(job_url)
+                elif job_text:
+                    job = await scraper.parse_text(job_text)
+                else:
+                    raise ValueError("No job URL or text provided")
+
+                # Step 3-5: Customize resume (includes scoring)
+                await progress.update(ProgressStep.CUSTOMIZING, "Customizing your resume...")
+
+                customizer = ResumeCustomizer()
+                result = await customizer.customize(
+                    resume=resume,
+                    job=job,
+                    intensity=Intensity(intensity),
+                )
+
+                # Step 6: Store result
+                await progress.update(ProgressStep.FINALIZING, "Preparing results...")
+
+                result_id = str(uuid.uuid4())
+                result_data = {
+                    "original": result.original.model_dump(),
+                    "customized": result.customized.model_dump(),
+                    "changes": [c.model_dump() for c in result.changes],
+                    "original_score": result.original_score.model_dump(),
+                    "customized_score": result.customized_score.model_dump(),
+                    "job": job.model_dump(),
+                    # Enhanced analysis fields
+                    "bullet_analysis": [b.model_dump() for b in result.bullet_analysis],
+                    "safety_scan": safety_scan.model_dump(),
+                    "keyword_quality": [k.model_dump() for k in result.keyword_quality],
+                }
+
+                from app.core.config import settings
+                await redis.set(
+                    f"result:{result_id}",
+                    json.dumps(result_data),
+                    ex=settings.session_ttl_seconds,
+                )
+
+                await progress.update(ProgressStep.COMPLETE, "Done!", result_id=result_id)
+
+                return {"result_id": result_id}
+
+            except Exception as e:
+                await progress.error(
+                    code="PROCESSING_ERROR",
+                    message=str(e),
+                    recoverable=True,
+                )
+                raise
+
+    return run_async(_run())

prompts/analyze_bullets.txt

@@ -0,0 +1,27 @@
+Analyze this resume bullet point against the job requirements.
+
+BULLET POINT:
+{bullet_text}
+
+JOB REQUIREMENTS:
+Required Keywords: {required_keywords}
+Preferred Keywords: {preferred_keywords}
+Key Responsibilities: {responsibilities}
+
+Analyze the bullet point and provide:
+1. A relevance score from 0-100 (how well this bullet aligns with the job)
+2. Which keywords from the job are already present in the bullet
+3. Which missing keywords could naturally fit in this bullet
+4. A specific, actionable suggestion to improve this bullet
+
+Respond in this exact JSON format:
+{
+  "relevance_score": <number 0-100>,
+  "matched_keywords": ["keyword1", "keyword2"],
+  "missing_keywords": ["keyword3", "keyword4"],
+  "suggestion": "Change to: '<improved bullet text>' to include '<keyword>'"
+}
+
+Be specific in your suggestion. Don't just say "add keywords" - provide the actual rewritten bullet text.
+If the bullet is already strong (score > 80), the suggestion can acknowledge this.
+Only include missing_keywords that would NATURALLY fit this bullet's context.

prompts/customize_resume.txt

@@ -0,0 +1,26 @@
+You are a professional resume writer. Customize this resume for the target job using the Google XYZ format for achievements: "Accomplished [X] as measured by [Y], by doing [Z]"
+
+INTENSITY LEVEL: {intensity}
+- conservative: Minor tweaks only. Add missing keywords naturally, keep original phrasing.
+- moderate: Rewrite bullets in XYZ format, add keywords, reorder to highlight relevant experience.
+- aggressive: Significant rewrites for maximum ATS optimization while staying truthful.
+
+ORIGINAL RESUME:
+{resume_json}
+
+TARGET JOB:
+Title: {job_title}
+Company: {job_company}
+Required Keywords: {keywords_required}
+Preferred Keywords: {keywords_preferred}
+Key Responsibilities: {responsibilities}
+
+INSTRUCTIONS:
+1. Rewrite experience bullets using XYZ format where possible
+2. Naturally incorporate missing keywords: {missing_keywords}
+3. Ensure skills section includes all relevant keywords
+4. Keep all facts truthful - only rephrase, don't fabricate
+5. Prioritize recent and relevant experience
+
+Return the customized resume as valid JSON matching the original structure exactly.
+Only return the JSON, no explanation.

prompts/extract_job.txt

@@ -0,0 +1,15 @@
+Extract structured data from this job posting. Return valid JSON matching the schema exactly.
+
+Schema:
+{
+  "title": "string (job title)",
+  "company": "string (company name)",
+  "location": "string (job location)",
+  "requirements": ["string (required qualification/experience)"],
+  "responsibilities": ["string (job duty/responsibility)"],
+  "keywords_required": ["string (must-have technical skills, tools, technologies)"],
+  "keywords_preferred": ["string (nice-to-have skills, bonus qualifications)"]
+}
+
+Job posting text:
+{job_text}

prompts/structure_resume.txt

@@ -0,0 +1,32 @@
+Extract structured data from this resume text. Return valid JSON matching the schema exactly.
+
+Schema:
+{
+  "contact": {
+    "name": "string",
+    "email": "string",
+    "phone": "string",
+    "linkedin": "string",
+    "location": "string"
+  },
+  "summary": "string (professional summary if present)",
+  "experience": [
+    {
+      "company": "string",
+      "title": "string",
+      "dates": "string (e.g., 'Jan 2020 - Present')",
+      "bullets": ["string (achievement/responsibility)"]
+    }
+  ],
+  "education": [
+    {
+      "school": "string",
+      "degree": "string",
+      "dates": "string"
+    }
+  ],
+  "skills": ["string"]
+}
+
+Resume text:
+{resume_text}

pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "cv-buddy-backend"
+version = "0.1.0"
+description = "AI-powered resume customization backend"
+requires-python = ">=3.11"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

requirements.txt

@@ -0,0 +1,33 @@
+# Core
+fastapi>=0.109.0
+uvicorn[standard]>=0.27.0
+python-multipart>=0.0.6
+
+# Background jobs
+celery>=5.3.0
+redis>=5.0.0
+
+# Document parsing
+pymupdf>=1.23.0
+python-docx>=1.1.0
+
+# Document generation
+weasyprint>=60.0
+jinja2>=3.1.0
+
+# Web scraping
+httpx>=0.26.0
+beautifulsoup4>=4.12.0
+
+# LLM providers
+openai>=1.10.0
+google-generativeai>=0.4.0
+
+# Utilities
+pydantic>=2.5.0
+pydantic-settings>=2.1.0
+
+# Testing
+pytest>=8.0.0
+pytest-asyncio>=0.23.0
+pytest-cov>=4.1.0

supervisord.conf

@@ -0,0 +1,24 @@
+[supervisord]
+nodaemon=true
+logfile=/dev/null
+logfile_maxbytes=0
+
+[program:uvicorn]
+command=uvicorn app.main:app --host 0.0.0.0 --port %(ENV_PORT)s
+directory=/app
+autostart=true
+autorestart=true
+stdout_logfile=/dev/fd/1
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/fd/2
+stderr_logfile_maxbytes=0
+
+[program:celery]
+command=celery -A app.workers.celery_app worker --loglevel=info --concurrency=2
+directory=/app
+autostart=true
+autorestart=true
+stdout_logfile=/dev/fd/1
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/fd/2
+stderr_logfile_maxbytes=0