refactored the files

api/__init__.py

@@ -0,0 +1 @@
+# API package: schemas and routers

api/routers/__init__.py

@@ -0,0 +1,34 @@
+"""
+API routers - each module handles a logical group of endpoints.
+"""
+
+from fastapi import APIRouter
+
+from .info import router as info_router
+from .auth import router as auth_router
+from .generate import router as generate_router
+from .trends import router as trends_router
+from .correction import router as correction_router
+from .matrix import router as matrix_router
+from .motivator import router as motivator_router
+from .extensive import router as extensive_router
+from .creative import router as creative_router
+from .database import router as database_router
+from .export import router as export_router
+
+
+def get_all_routers() -> list[APIRouter]:
+    """Return all routers in the order they should be registered."""
+    return [
+        info_router,
+        auth_router,
+        generate_router,
+        trends_router,
+        correction_router,
+        matrix_router,
+        motivator_router,
+        extensive_router,
+        creative_router,
+        database_router,
+        export_router,
+    ]

api/routers/auth.py

@@ -0,0 +1,34 @@
+"""Authentication endpoints."""
+
+from fastapi import APIRouter, HTTPException, Depends
+
+from api.schemas import LoginRequest, LoginResponse
+from services.database import db_service
+from services.auth import auth_service
+
+router = APIRouter(tags=["auth"])
+
+
+@router.post("/auth/login", response_model=LoginResponse)
+async def login(request: LoginRequest):
+    """
+    Authenticate a user and return a JWT token.
+    Credentials must be created manually using the create_user.py script.
+    """
+    user = await db_service.get_user(request.username)
+    if not user:
+        raise HTTPException(status_code=401, detail="Invalid username or password")
+
+    hashed_password = user.get("hashed_password")
+    if not hashed_password:
+        raise HTTPException(status_code=500, detail="User data corrupted")
+
+    if not auth_service.verify_password(request.password, hashed_password):
+        raise HTTPException(status_code=401, detail="Invalid username or password")
+
+    token = auth_service.create_access_token(request.username)
+    return {
+        "token": token,
+        "username": request.username,
+        "message": "Login successful",
+    }

api/routers/correction.py

@@ -0,0 +1,302 @@
+"""Image correction and regeneration endpoints."""
+
+import os
+import time
+import uuid
+import random
+import logging
+from datetime import datetime
+from fastapi import APIRouter, HTTPException, Depends
+
+from api.schemas import (
+    ImageCorrectRequest,
+    ImageCorrectResponse,
+    ImageRegenerateRequest,
+    ImageRegenerateResponse,
+    ImageSelectionRequest,
+)
+from services.correction import correction_service
+from services.database import db_service
+from services.image import image_service
+from services.auth_dependency import get_current_user
+from config import settings
+
+router = APIRouter(tags=["correction"])
+api_logger = logging.getLogger("api")
+
+
+@router.post("/api/correct", response_model=ImageCorrectResponse)
+async def correct_image(
+    request: ImageCorrectRequest,
+    username: str = Depends(get_current_user),
+):
+    """
+    Correct an image by analyzing it for spelling and visual issues,
+    then regenerating a corrected version. Requires authentication.
+    """
+    api_start_time = time.time()
+    api_logger.info("API: Correction request received | User: %s | Image ID: %s", username, request.image_id)
+
+    try:
+        image_url = request.image_url
+        ad = None
+        if request.image_id != "temp-id":
+            ad = await db_service.get_ad_creative(request.image_id, username=username)
+            if not ad:
+                raise HTTPException(status_code=404, detail=f"Ad creative with ID {request.image_id} not found or access denied")
+            if not image_url:
+                image_url = ad.get("r2_url") or ad.get("image_url")
+
+        if not image_url:
+            raise HTTPException(status_code=400, detail="Image URL must be provided for images not in database, or found in database for provided ID")
+
+        image_bytes = await image_service.load_image(
+            image_id=request.image_id if request.image_id != "temp-id" else None,
+            image_url=image_url,
+            image_bytes=None,
+            filepath=None,
+        )
+        if not image_bytes:
+            raise HTTPException(status_code=404, detail="Image not found for analysis. Please ensure the URL is accessible.")
+
+        original_prompt = ad.get("image_prompt") if ad else None
+        result = await correction_service.correct_image(
+            image_bytes=image_bytes,
+            image_url=image_url,
+            original_prompt=original_prompt,
+            width=1024,
+            height=1024,
+            niche=ad.get("niche", "others") if ad else "others",
+            user_instructions=request.user_instructions,
+            auto_analyze=request.auto_analyze,
+        )
+
+        response_data = {
+            "status": result["status"],
+            "analysis": result.get("analysis"),
+            "corrections": None,
+            "corrected_image": None,
+            "error": result.get("error"),
+        }
+        if result.get("corrections"):
+            c = result["corrections"]
+            response_data["corrections"] = {
+                "spelling_corrections": c.get("spelling_corrections", []),
+                "visual_corrections": c.get("visual_corrections", []),
+                "corrected_prompt": c.get("corrected_prompt", ""),
+            }
+        if result.get("corrected_image"):
+            ci = result["corrected_image"]
+            response_data["corrected_image"] = {
+                "filename": ci.get("filename"),
+                "filepath": ci.get("filepath"),
+                "image_url": ci.get("image_url"),
+                "r2_url": ci.get("r2_url"),
+                "model_used": ci.get("model_used"),
+                "corrected_prompt": ci.get("corrected_prompt"),
+            }
+
+        if result.get("status") == "success" and result.get("_db_metadata") and ad:
+            db_metadata = result["_db_metadata"]
+            correction_metadata = {
+                "is_corrected": True,
+                "correction_date": datetime.utcnow().isoformat() + "Z",
+            }
+            for k, v in [
+                ("original_image_url", ad.get("r2_url") or ad.get("image_url")),
+                ("original_r2_url", ad.get("r2_url")),
+                ("original_image_filename", ad.get("image_filename")),
+                ("original_image_model", ad.get("image_model")),
+                ("original_image_prompt", ad.get("image_prompt")),
+            ]:
+                if v:
+                    correction_metadata[k] = v
+            if result.get("corrections"):
+                correction_metadata["corrections"] = result.get("corrections")
+            update_kwargs = {
+                "image_url": db_metadata.get("image_url"),
+                "image_filename": db_metadata.get("filename"),
+                "image_model": db_metadata.get("model_used"),
+                "image_prompt": db_metadata.get("corrected_prompt"),
+            }
+            if db_metadata.get("r2_url"):
+                update_kwargs["r2_url"] = db_metadata.get("r2_url")
+            update_success = await db_service.update_ad_creative(
+                ad_id=request.image_id,
+                username=username,
+                metadata=correction_metadata,
+                **update_kwargs,
+            )
+            if update_success and response_data.get("corrected_image") is not None:
+                response_data["corrected_image"]["ad_id"] = request.image_id
+
+        api_logger.info("Correction request completed in %.2fs", time.time() - api_start_time)
+        return response_data
+    except HTTPException:
+        raise
+    except Exception as e:
+        api_logger.exception("Correction failed")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/api/regenerate", response_model=ImageRegenerateResponse)
+async def regenerate_image(
+    request: ImageRegenerateRequest,
+    username: str = Depends(get_current_user),
+):
+    """
+    Regenerate an image for an existing ad creative with an optional new model.
+    If preview_only=True, returns preview without updating DB; use confirm to save.
+    """
+    api_start_time = time.time()
+    try:
+        ad = await db_service.get_ad_creative(request.image_id, username=username)
+        if not ad:
+            raise HTTPException(status_code=404, detail="Ad creative not found or access denied")
+        image_prompt = ad.get("image_prompt")
+        if not image_prompt:
+            raise HTTPException(status_code=400, detail="No image prompt found for this ad creative.")
+        model_to_use = request.image_model or ad.get("image_model") or settings.image_model
+        seed = random.randint(1, 2147483647)
+        image_bytes, model_used, generated_url = await image_service.generate(
+            prompt=image_prompt,
+            width=1024,
+            height=1024,
+            seed=seed,
+            model_key=model_to_use,
+        )
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        unique_id = uuid.uuid4().hex[:8]
+        niche = ad.get("niche", "unknown").replace(" ", "_")
+        filename = f"regen_{niche}_{timestamp}_{unique_id}.png"
+        r2_url = None
+        try:
+            from services.r2_storage import get_r2_storage
+            r2_storage = get_r2_storage()
+            if r2_storage and image_bytes:
+                r2_url = r2_storage.upload_image(image_bytes=image_bytes, filename=filename, niche=niche)
+        except Exception as e:
+            api_logger.warning("R2 upload failed: %s", e)
+        local_path = None
+        if not r2_url and image_bytes:
+            local_path = os.path.join(settings.output_dir, filename)
+            os.makedirs(os.path.dirname(local_path), exist_ok=True)
+            with open(local_path, "wb") as f:
+                f.write(image_bytes)
+        original_image_url = ad.get("r2_url") or ad.get("image_url")
+        new_image_url = r2_url or generated_url or f"/images/{filename}"
+
+        if request.preview_only:
+            return {
+                "status": "success",
+                "regenerated_image": {
+                    "filename": filename,
+                    "filepath": local_path,
+                    "image_url": new_image_url,
+                    "r2_url": r2_url,
+                    "model_used": model_used,
+                    "prompt_used": image_prompt,
+                    "seed_used": seed,
+                },
+                "original_image_url": original_image_url,
+                "original_preserved": True,
+                "is_preview": True,
+            }
+
+        regeneration_metadata = {
+            "is_regenerated": True,
+            "regeneration_date": datetime.utcnow().isoformat() + "Z",
+            "regeneration_seed": seed,
+        }
+        if original_image_url:
+            regeneration_metadata["original_image_url"] = original_image_url
+        for k, v in [("original_r2_url", ad.get("r2_url")), ("original_image_filename", ad.get("image_filename")), ("original_image_model", ad.get("image_model")), ("original_seed", ad.get("image_seed"))]:
+            if v is not None:
+                regeneration_metadata[k] = v
+        update_kwargs = {"image_filename": filename, "image_model": model_used, "image_seed": seed}
+        if r2_url:
+            update_kwargs["image_url"] = update_kwargs["r2_url"] = r2_url
+        elif generated_url:
+            update_kwargs["image_url"] = generated_url
+        elif local_path:
+            update_kwargs["image_url"] = f"/images/{filename}"
+        await db_service.update_ad_creative(
+            ad_id=request.image_id,
+            username=username,
+            metadata=regeneration_metadata,
+            **update_kwargs,
+        )
+        return {
+            "status": "success",
+            "regenerated_image": {
+                "filename": filename,
+                "filepath": local_path,
+                "image_url": new_image_url,
+                "r2_url": r2_url,
+                "model_used": model_used,
+                "prompt_used": image_prompt,
+                "seed_used": seed,
+            },
+            "original_image_url": original_image_url,
+            "original_preserved": True,
+            "is_preview": False,
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        api_logger.exception("Regeneration failed")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/api/regenerate/confirm")
+async def confirm_image_selection(
+    request: ImageSelectionRequest,
+    username: str = Depends(get_current_user),
+):
+    """
+    Confirm the user's image selection after regeneration preview.
+    selection='new' updates the ad with the new image; selection='original' keeps original.
+    """
+    if request.selection not in ["new", "original"]:
+        raise HTTPException(status_code=400, detail="Selection must be 'new' or 'original'")
+    ad = await db_service.get_ad_creative(request.image_id, username=username)
+    if not ad:
+        raise HTTPException(status_code=404, detail="Ad creative not found or access denied")
+    if request.selection == "original":
+        return {"status": "success", "message": "Original image kept", "selection": "original"}
+    if not request.new_image_url:
+        raise HTTPException(status_code=400, detail="new_image_url is required when selection='new'")
+    regeneration_metadata = {
+        "is_regenerated": True,
+        "regeneration_date": datetime.utcnow().isoformat() + "Z",
+        "regeneration_seed": request.new_seed,
+    }
+    for k, v in [
+        ("original_image_url", ad.get("r2_url") or ad.get("image_url")),
+        ("original_r2_url", ad.get("r2_url")),
+        ("original_image_filename", ad.get("image_filename")),
+        ("original_image_model", ad.get("image_model")),
+        ("original_seed", ad.get("image_seed")),
+    ]:
+        if v is not None:
+            regeneration_metadata[k] = v
+    update_kwargs = {}
+    if request.new_filename:
+        update_kwargs["image_filename"] = request.new_filename
+    if request.new_model:
+        update_kwargs["image_model"] = request.new_model
+    if request.new_seed is not None:
+        update_kwargs["image_seed"] = request.new_seed
+    if request.new_r2_url:
+        update_kwargs["image_url"] = update_kwargs["r2_url"] = request.new_r2_url
+    elif request.new_image_url:
+        update_kwargs["image_url"] = request.new_image_url
+    update_success = await db_service.update_ad_creative(
+        ad_id=request.image_id,
+        username=username,
+        metadata=regeneration_metadata,
+        **update_kwargs,
+    )
+    if not update_success:
+        raise HTTPException(status_code=500, detail="Failed to update ad with new image")
+    return {"status": "success", "message": "New image saved", "selection": "new", "new_image_url": request.new_image_url}

api/routers/creative.py

@@ -0,0 +1,154 @@
+"""Creative upload, analyze, and modify endpoints."""
+
+import os
+from datetime import datetime
+from fastapi import APIRouter, HTTPException, Depends, File, UploadFile
+
+from api.schemas import (
+    CreativeAnalyzeRequest,
+    CreativeAnalysisResponse,
+    CreativeModifyRequest,
+    CreativeModifyResponse,
+    FileUploadResponse,
+)
+from services.creative_modifier import creative_modifier_service
+from services.image import image_service
+from services.auth_dependency import get_current_user
+from config import settings
+
+router = APIRouter(tags=["creative"])
+
+
+@router.post("/api/creative/upload", response_model=FileUploadResponse)
+async def upload_creative(
+    file: UploadFile = File(...),
+    username: str = Depends(get_current_user),
+):
+    """
+    Upload a creative image for analysis and modification.
+    Accepts PNG, JPG, JPEG, WebP. Returns image URL for subsequent steps.
+    """
+    allowed_types = ["image/png", "image/jpeg", "image/jpg", "image/webp"]
+    if file.content_type not in allowed_types:
+        raise HTTPException(status_code=400, detail=f"Invalid file type. Allowed: PNG, JPG, JPEG, WebP. Got: {file.content_type}")
+    contents = await file.read()
+    if len(contents) > 10 * 1024 * 1024:
+        raise HTTPException(status_code=400, detail="File too large. Maximum size is 10MB.")
+    try:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        unique_id = __import__("uuid").uuid4().hex[:8]
+        ext = file.filename.split(".")[-1] if file.filename else "png"
+        filename = f"upload_{username}_{timestamp}_{unique_id}.{ext}"
+        r2_url = None
+        try:
+            from services.r2_storage import get_r2_storage
+            r2_storage = get_r2_storage()
+            if r2_storage:
+                r2_url = r2_storage.upload_image(image_bytes=contents, filename=filename, niche="uploads")
+        except Exception:
+            pass
+        if not r2_url:
+            local_path = os.path.join(settings.output_dir, filename)
+            os.makedirs(os.path.dirname(local_path), exist_ok=True)
+            with open(local_path, "wb") as f:
+                f.write(contents)
+            r2_url = f"/images/{filename}"
+        return {"status": "success", "image_url": r2_url, "filename": filename}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/api/creative/analyze", response_model=CreativeAnalysisResponse)
+async def analyze_creative(
+    request: CreativeAnalyzeRequest,
+    username: str = Depends(get_current_user),
+):
+    """Analyze a creative image using AI vision (via URL)."""
+    if not request.image_url:
+        raise HTTPException(status_code=400, detail="image_url must be provided")
+    try:
+        image_bytes = await image_service.load_image(image_url=request.image_url)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to fetch image from URL: {e}")
+    if not image_bytes:
+        raise HTTPException(status_code=400, detail="Failed to load image")
+    try:
+        result = await creative_modifier_service.analyze_creative(image_bytes)
+        if result["status"] != "success":
+            return CreativeAnalysisResponse(status="error", error=result.get("error", "Analysis failed"))
+        return CreativeAnalysisResponse(
+            status="success",
+            analysis=result.get("analysis"),
+            suggested_angles=result.get("suggested_angles"),
+            suggested_concepts=result.get("suggested_concepts"),
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/api/creative/analyze/upload", response_model=CreativeAnalysisResponse)
+async def analyze_creative_upload(
+    file: UploadFile = File(...),
+    username: str = Depends(get_current_user),
+):
+    """Analyze a creative image using AI vision (via file upload)."""
+    allowed_types = ["image/png", "image/jpeg", "image/jpg", "image/webp"]
+    if file.content_type not in allowed_types:
+        raise HTTPException(status_code=400, detail=f"Invalid file type. Allowed: PNG, JPG, JPEG, WebP. Got: {file.content_type}")
+    image_bytes = await file.read()
+    if not image_bytes:
+        raise HTTPException(status_code=400, detail="Failed to load image")
+    try:
+        result = await creative_modifier_service.analyze_creative(image_bytes)
+        if result["status"] != "success":
+            return CreativeAnalysisResponse(status="error", error=result.get("error", "Analysis failed"))
+        return CreativeAnalysisResponse(
+            status="success",
+            analysis=result.get("analysis"),
+            suggested_angles=result.get("suggested_angles"),
+            suggested_concepts=result.get("suggested_concepts"),
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/api/creative/modify", response_model=CreativeModifyResponse)
+async def modify_creative(
+    request: CreativeModifyRequest,
+    username: str = Depends(get_current_user),
+):
+    """
+    Modify a creative with angle and/or concept.
+    Modes: 'modify' (image-to-image) or 'inspired' (new generation).
+    """
+    if not request.angle and not request.concept:
+        raise HTTPException(status_code=400, detail="At least one of 'angle' or 'concept' must be provided")
+    analysis = request.analysis
+    if not analysis:
+        try:
+            image_bytes = await image_service.load_image(image_url=request.image_url)
+            if not image_bytes:
+                raise HTTPException(status_code=400, detail="Failed to load image from URL")
+            analysis_result = await creative_modifier_service.analyze_creative(image_bytes)
+            if analysis_result["status"] != "success":
+                raise HTTPException(status_code=500, detail=analysis_result.get("error", "Analysis failed"))
+            analysis = analysis_result.get("analysis", {})
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to analyze image: {e}")
+    try:
+        result = await creative_modifier_service.modify_creative(
+            image_url=request.image_url,
+            analysis=analysis,
+            user_angle=request.angle,
+            user_concept=request.concept,
+            mode=request.mode,
+            image_model=request.image_model,
+            user_prompt=request.user_prompt,
+        )
+        if result["status"] != "success":
+            return CreativeModifyResponse(status="error", error=result.get("error", "Modification failed"))
+        return CreativeModifyResponse(status="success", prompt=result.get("prompt"), image=result.get("image"))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

api/routers/database.py

@@ -0,0 +1,171 @@
+"""Database endpoints: stats, list ads, get/delete ad, edit copy."""
+
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Depends
+
+from api.schemas import DbStatsResponse, EditAdCopyRequest
+from services.database import db_service
+from services.auth_dependency import get_current_user
+
+router = APIRouter(tags=["database"])
+
+
+@router.get("/db/stats", response_model=DbStatsResponse)
+async def get_database_stats(username: str = Depends(get_current_user)):
+    """Get statistics about stored ad creatives for the current user."""
+    return await db_service.get_stats(username=username)
+
+
+@router.get("/db/ads")
+async def list_stored_ads(
+    niche: Optional[str] = None,
+    generation_method: Optional[str] = None,
+    limit: int = 50,
+    offset: int = 0,
+    username: str = Depends(get_current_user),
+):
+    """List ad creatives for the current user with optional filters and pagination."""
+    ads, total = await db_service.list_ad_creatives(
+        username=username,
+        niche=niche,
+        generation_method=generation_method,
+        limit=limit,
+        offset=offset,
+    )
+    return {
+        "total": total,
+        "limit": limit,
+        "offset": offset,
+        "ads": [
+            {
+                "id": str(ad.get("id", "")),
+                "niche": ad.get("niche", ""),
+                "title": ad.get("title"),
+                "headline": ad.get("headline", ""),
+                "primary_text": ad.get("primary_text"),
+                "description": ad.get("description"),
+                "body_story": ad.get("body_story"),
+                "cta": ad.get("cta", ""),
+                "psychological_angle": ad.get("psychological_angle", ""),
+                "image_url": ad.get("image_url"),
+                "r2_url": ad.get("r2_url"),
+                "image_filename": ad.get("image_filename"),
+                "image_model": ad.get("image_model"),
+                "angle_key": ad.get("angle_key"),
+                "concept_key": ad.get("concept_key"),
+                "generation_method": ad.get("generation_method", "standard"),
+                "created_at": ad.get("created_at"),
+            }
+            for ad in ads
+        ],
+    }
+
+
+@router.get("/db/ad/{ad_id}")
+async def get_stored_ad(ad_id: str):
+    """Get a specific ad creative by ID."""
+    ad = await db_service.get_ad_creative(ad_id)
+    if not ad:
+        raise HTTPException(status_code=404, detail=f"Ad '{ad_id}' not found")
+    return {
+        "id": str(ad.get("id", "")),
+        "niche": ad.get("niche", ""),
+        "title": ad.get("title"),
+        "headline": ad.get("headline", ""),
+        "primary_text": ad.get("primary_text"),
+        "description": ad.get("description"),
+        "body_story": ad.get("body_story"),
+        "cta": ad.get("cta", ""),
+        "psychological_angle": ad.get("psychological_angle", ""),
+        "why_it_works": ad.get("why_it_works"),
+        "image_url": ad.get("image_url"),
+        "image_filename": ad.get("image_filename"),
+        "image_model": ad.get("image_model"),
+        "image_seed": ad.get("image_seed"),
+        "r2_url": ad.get("r2_url"),
+        "angle_key": ad.get("angle_key"),
+        "angle_name": ad.get("angle_name"),
+        "angle_trigger": ad.get("angle_trigger"),
+        "angle_category": ad.get("angle_category"),
+        "concept_key": ad.get("concept_key"),
+        "concept_name": ad.get("concept_name"),
+        "concept_structure": ad.get("concept_structure"),
+        "concept_visual": ad.get("concept_visual"),
+        "concept_category": ad.get("concept_category"),
+        "generation_method": ad.get("generation_method", "standard"),
+        "metadata": ad.get("metadata"),
+        "created_at": ad.get("created_at"),
+        "updated_at": ad.get("updated_at"),
+    }
+
+
+@router.delete("/db/ad/{ad_id}")
+async def delete_stored_ad(ad_id: str, username: str = Depends(get_current_user)):
+    """Delete an ad creative. Users can only delete their own ads."""
+    success = await db_service.delete_ad_creative(ad_id, username=username)
+    if not success:
+        raise HTTPException(status_code=404, detail=f"Ad '{ad_id}' not found or could not be deleted")
+    return {"success": True, "deleted_id": ad_id}
+
+
+@router.post("/db/ad/edit")
+async def edit_ad_copy(
+    request: EditAdCopyRequest,
+    username: str = Depends(get_current_user),
+):
+    """
+    Edit ad copy fields. Modes: manual (direct update) or ai (AI-improved version).
+    """
+    from services.llm import LLMService
+
+    ad = await db_service.get_ad_creative(request.ad_id)
+    if not ad:
+        raise HTTPException(status_code=404, detail=f"Ad '{request.ad_id}' not found")
+    if ad.get("username") != username:
+        raise HTTPException(status_code=403, detail="You can only edit your own ads")
+
+    if request.mode == "manual":
+        success = await db_service.update_ad_creative(
+            ad_id=request.ad_id,
+            username=username,
+            **{request.field: request.value},
+        )
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to update ad")
+        return {"edited_value": request.value, "success": True}
+
+    llm_service = LLMService()
+    field_labels = {
+        "title": "title",
+        "headline": "headline",
+        "primary_text": "primary text",
+        "description": "description",
+        "body_story": "body story",
+        "cta": "call to action",
+    }
+    field_label = field_labels.get(request.field, request.field)
+    current_value = request.value
+    niche = ad.get("niche", "general")
+    system_prompt = f"""You are an expert copywriter specializing in high-converting ad copy for {niche.replace('_', ' ')}.
+Your task is to improve the {field_label} while maintaining its core message and emotional impact.
+Keep the same tone and style, but make it more compelling, clear, and effective."""
+    user_prompt = f"""Current {field_label}:\n{current_value}\n\n"""
+    if request.user_suggestion:
+        user_prompt += f"User's suggestion: {request.user_suggestion}\n\n"
+    user_prompt += f"""Please provide an improved version of this {field_label} that:
+1. Maintains the core message and emotional impact
+2. Is more compelling and engaging
+3. Follows best practices for {field_label} in ad copy
+4. {"Incorporates the user's suggestion" if request.user_suggestion else "Is optimized for conversion"}
+
+Return ONLY the improved {field_label} text, without any explanations or additional text."""
+    try:
+        edited_value = await llm_service.generate(
+            prompt=user_prompt,
+            system_prompt=system_prompt,
+            temperature=0.7,
+        )
+        edited_value = edited_value.strip().strip('"').strip("'")
+        return {"edited_value": edited_value, "success": True}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to generate AI edit: {str(e)}")

api/routers/export.py

@@ -0,0 +1,48 @@
+"""Bulk export endpoint."""
+
+import os
+import logging
+from fastapi import APIRouter, HTTPException, Depends, BackgroundTasks
+from fastapi.responses import FileResponse
+
+from api.schemas import BulkExportRequest
+from services.database import db_service
+from services.export_service import export_service
+from services.auth_dependency import get_current_user
+
+router = APIRouter(tags=["export"])
+api_logger = logging.getLogger("api")
+
+
+@router.post("/api/export/bulk")
+async def export_bulk_ads(
+    request: BulkExportRequest,
+    background_tasks: BackgroundTasks,
+    username: str = Depends(get_current_user),
+):
+    """
+    Export multiple ad creatives as a ZIP package.
+    Creates /creatives/ folder and ad_copy_data.xlsx. Max 50 ads.
+    """
+    if len(request.ad_ids) > 50:
+        raise HTTPException(status_code=400, detail="Maximum 50 ads can be exported at once")
+    ads = []
+    for ad_id in request.ad_ids:
+        ad = await db_service.get_ad_creative(ad_id, username=username)
+        if not ad:
+            raise HTTPException(status_code=404, detail=f"Ad '{ad_id}' not found or access denied")
+        ads.append(ad)
+    try:
+        api_logger.info("Creating export package for %d ads (user: %s)", len(ads), username)
+        zip_path = await export_service.create_export_package(ads)
+        background_tasks.add_task(export_service.cleanup_zip, zip_path)
+        return FileResponse(
+            zip_path,
+            media_type="application/zip",
+            filename=os.path.basename(zip_path),
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        api_logger.error("Bulk export failed: %s", e)
+        raise HTTPException(status_code=500, detail=f"Export failed: {str(e)}")

api/routers/extensive.py

@@ -0,0 +1,119 @@
+"""Extensive generation (researcher → creative director → designer → copywriter)."""
+
+import asyncio
+import uuid
+from typing import Dict, Any, Optional
+from fastapi import APIRouter, HTTPException, Depends
+
+from api.schemas import ExtensiveGenerateRequest, ExtensiveJobResponse, BatchResponse
+from services.generator import ad_generator
+from services.auth_dependency import get_current_user
+
+router = APIRouter(tags=["extensive"])
+
+_extensive_jobs: Dict[str, Dict[str, Any]] = {}
+
+
+async def _run_extensive_job_async(
+    job_id: str,
+    username: str,
+    effective_niche: str,
+    target_audience: Optional[str],
+    offer: Optional[str],
+    num_images: int,
+    image_model: Optional[str],
+    num_strategies: int,
+):
+    """Run extensive generation on the main event loop."""
+    import logging
+    api_logger = logging.getLogger("api")
+    try:
+        results = await ad_generator.generate_ad_extensive(
+            niche=effective_niche,
+            target_audience=target_audience,
+            offer=offer,
+            num_images=num_images,
+            image_model=image_model,
+            num_strategies=num_strategies,
+            username=username,
+        )
+        _extensive_jobs[job_id]["status"] = "completed"
+        _extensive_jobs[job_id]["result"] = BatchResponse(count=len(results), ads=results)
+    except Exception as e:
+        api_logger.exception("Extensive job %s failed", job_id)
+        _extensive_jobs[job_id]["status"] = "failed"
+        _extensive_jobs[job_id]["error"] = str(e)
+
+
+@router.post("/extensive/generate", status_code=202)
+async def generate_extensive(
+    request: ExtensiveGenerateRequest,
+    username: str = Depends(get_current_user),
+):
+    """
+    Start extensive ad generation. Returns 202 with job_id.
+    Poll GET /extensive/status/{job_id} then GET /extensive/result/{job_id}.
+    """
+    if request.niche == "others":
+        if not request.custom_niche or not request.custom_niche.strip():
+            raise HTTPException(status_code=400, detail="custom_niche is required when niche is 'others'")
+        effective_niche = request.custom_niche.strip()
+    else:
+        effective_niche = request.niche
+
+    job_id = str(uuid.uuid4())
+    _extensive_jobs[job_id] = {
+        "status": "running",
+        "result": None,
+        "error": None,
+        "username": username,
+    }
+    asyncio.create_task(
+        _run_extensive_job_async(
+            job_id,
+            username,
+            effective_niche,
+            request.target_audience,
+            request.offer,
+            request.num_images,
+            request.image_model,
+            request.num_strategies,
+        )
+    )
+    return ExtensiveJobResponse(job_id=job_id)
+
+
+@router.get("/extensive/status/{job_id}")
+async def extensive_job_status(
+    job_id: str,
+    username: str = Depends(get_current_user),
+):
+    """Get status of an extensive generation job."""
+    if job_id not in _extensive_jobs:
+        raise HTTPException(status_code=404, detail="Job not found")
+    job = _extensive_jobs[job_id]
+    if job["username"] != username:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return {
+        "job_id": job_id,
+        "status": job["status"],
+        "error": job.get("error") if job["status"] == "failed" else None,
+    }
+
+
+@router.get("/extensive/result/{job_id}", response_model=BatchResponse)
+async def extensive_job_result(
+    job_id: str,
+    username: str = Depends(get_current_user),
+):
+    """Get result of a completed extensive generation job. 425 if still running."""
+    if job_id not in _extensive_jobs:
+        raise HTTPException(status_code=404, detail="Job not found")
+    job = _extensive_jobs[job_id]
+    if job["username"] != username:
+        raise HTTPException(status_code=404, detail="Job not found")
+    if job["status"] == "running":
+        raise HTTPException(status_code=425, detail="Generation still in progress")
+    if job["status"] == "failed":
+        raise HTTPException(status_code=500, detail=job.get("error", "Generation failed"))
+    return job["result"]

api/routers/generate.py

@@ -0,0 +1,196 @@
+"""Ad generation endpoints (single, batch, image, strategies, models)."""
+
+import os
+from typing import Literal, Optional
+from fastapi import APIRouter, HTTPException, Depends
+from fastapi.responses import FileResponse, Response as FastAPIResponse
+
+from api.schemas import (
+    GenerateRequest,
+    GenerateResponse,
+    GenerateBatchRequest,
+    BatchResponse,
+)
+from services.generator import ad_generator
+from services.auth_dependency import get_current_user
+from config import settings
+
+router = APIRouter(tags=["generate"])
+
+
+@router.post("/generate", response_model=GenerateResponse)
+async def generate(
+    request: GenerateRequest,
+    username: str = Depends(get_current_user),
+):
+    """
+    Generate a single ad creative.
+    Requires authentication. Uses randomization for strategies, hooks, visuals.
+    """
+    try:
+        return await ad_generator.generate_ad(
+            niche=request.niche,
+            num_images=request.num_images,
+            image_model=request.image_model,
+            username=username,
+            target_audience=request.target_audience,
+            offer=request.offer,
+            use_trending=request.use_trending,
+            trending_context=request.trending_context,
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/generate/batch", response_model=BatchResponse)
+async def generate_batch(
+    request: GenerateBatchRequest,
+    username: str = Depends(get_current_user),
+):
+    """
+    Generate multiple ad creatives in batch.
+    Requires authentication. Each ad is unique due to randomization.
+    """
+    try:
+        results = await ad_generator.generate_batch(
+            niche=request.niche,
+            count=request.count,
+            images_per_ad=request.images_per_ad,
+            image_model=request.image_model,
+            username=username,
+            method=request.method,
+            target_audience=request.target_audience,
+            offer=request.offer,
+        )
+        return {"count": len(results), "ads": results}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/image/{filename}")
+async def get_image(filename: str):
+    """Get a generated image by filename."""
+    filepath = os.path.join(settings.output_dir, filename)
+    if not os.path.exists(filepath):
+        raise HTTPException(status_code=404, detail="Image not found")
+    return FileResponse(filepath)
+
+
+@router.get("/api/download-image")
+async def download_image_proxy(
+    image_url: Optional[str] = None,
+    image_id: Optional[str] = None,
+    username: str = Depends(get_current_user),
+):
+    """
+    Proxy endpoint to download images, avoiding CORS.
+    Can fetch from external URLs (R2, Replicate) or local files.
+    """
+    import httpx
+
+    from services.database import db_service
+
+    filename = None
+    if image_id:
+        ad = await db_service.get_ad_creative(image_id)
+        if not ad:
+            raise HTTPException(status_code=404, detail="Ad not found")
+        if ad.get("username") != username:
+            raise HTTPException(status_code=403, detail="Access denied")
+        if not image_url:
+            image_url = ad.get("r2_url") or ad.get("image_url")
+            filename = ad.get("image_filename")
+        else:
+            metadata = ad.get("metadata", {})
+            if metadata.get("original_r2_url") == image_url or metadata.get("original_image_url") == image_url:
+                filename = metadata.get("original_image_filename")
+
+    if not image_url:
+        raise HTTPException(status_code=400, detail="No image URL provided")
+
+    try:
+        if not image_url.startswith(("http://", "https://")):
+            filepath = os.path.join(settings.output_dir, image_url)
+            if os.path.exists(filepath):
+                return FileResponse(filepath, filename=filename or os.path.basename(filepath))
+            raise HTTPException(status_code=404, detail="Image file not found")
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(image_url)
+            response.raise_for_status()
+            content_type = response.headers.get("content-type", "image/png")
+            if not filename:
+                filename = image_url.split("/")[-1].split("?")[0]
+                if not filename or "." not in filename:
+                    filename = "image.png"
+            return FastAPIResponse(
+                content=response.content,
+                media_type=content_type,
+                headers={
+                    "Content-Disposition": f'attachment; filename="{filename}"',
+                    "Cache-Control": "public, max-age=3600",
+                },
+            )
+    except httpx.HTTPError as e:
+        raise HTTPException(status_code=502, detail=f"Failed to fetch image: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error downloading image: {str(e)}")
+
+
+@router.get("/api/models")
+async def list_image_models():
+    """
+    List all available image generation models.
+    """
+    from services.image import MODEL_REGISTRY
+
+    preferred_order = ["nano-banana", "nano-banana-pro", "z-image-turbo", "imagen-4-ultra", "recraft-v3", "ideogram-v3", "photon", "seedream-3"]
+    models = []
+    for key in preferred_order:
+        if key in MODEL_REGISTRY:
+            config = MODEL_REGISTRY[key]
+            models.append({
+                "key": key,
+                "id": config["id"],
+                "uses_dimensions": config.get("uses_dimensions", False),
+            })
+    for key, config in MODEL_REGISTRY.items():
+        if key not in preferred_order:
+            models.append({
+                "key": key,
+                "id": config["id"],
+                "uses_dimensions": config.get("uses_dimensions", False),
+            })
+    models.append({
+        "key": "gpt-image-1.5",
+        "id": "openai/gpt-image-1.5",
+        "uses_dimensions": True,
+    })
+    return {"models": models, "default": "nano-banana"}
+
+
+@router.get("/strategies/{niche}")
+async def get_strategies(niche: Literal["home_insurance", "glp1", "auto_insurance"]):
+    """Get available psychological strategies for a niche."""
+    from data import home_insurance, glp1, auto_insurance
+
+    if niche == "home_insurance":
+        data = home_insurance.get_niche_data()
+    elif niche == "auto_insurance":
+        data = auto_insurance.get_niche_data()
+    else:
+        data = glp1.get_niche_data()
+
+    strategies = {}
+    for name, strategy in data["strategies"].items():
+        strategies[name] = {
+            "name": strategy["name"],
+            "description": strategy["description"],
+            "hook_count": len(strategy["hooks"]),
+            "sample_hooks": strategy["hooks"][:3],
+        }
+    return {
+        "niche": niche,
+        "total_strategies": len(strategies),
+        "total_hooks": len(data["all_hooks"]),
+        "strategies": strategies,
+    }

api/routers/info.py

@@ -0,0 +1,73 @@
+"""Info, root, and health endpoints."""
+
+import httpx
+from fastapi import APIRouter
+from fastapi.responses import Response as FastAPIResponse
+
+router = APIRouter(tags=["info"])
+
+
+@router.get("/api/info")
+async def api_info():
+    """API info endpoint."""
+    return {
+        "name": "PsyAdGenesis",
+        "version": "2.0.0",
+        "description": "Design ads that stop the scroll. Generate high-converting ads using Angle × Concept matrix system",
+        "endpoints": {
+            "POST /generate": "Generate single ad (original mode)",
+            "POST /generate/batch": "Generate multiple ads (original mode)",
+            "POST /matrix/generate": "Generate ad using Angle × Concept matrix",
+            "POST /matrix/testing": "Generate testing matrix (30 combinations)",
+            "GET /matrix/angles": "List all 100 angles",
+            "GET /matrix/concepts": "List all 100 concepts",
+            "GET /matrix/angle/{key}": "Get specific angle details",
+            "GET /matrix/concept/{key}": "Get specific concept details",
+            "GET /matrix/compatible/{angle_key}": "Get compatible concepts for angle",
+            "POST /extensive/generate": "Generate ad using extensive (researcher → creative director → designer → copywriter)",
+            "POST /api/motivator/generate": "Generate motivators from niche + angle + concept (Matrix mode)",
+            "POST /api/correct": "Correct image for spelling mistakes and visual issues (requires image_id)",
+            "POST /api/regenerate": "Regenerate image with optional model selection (requires image_id)",
+            "GET /api/models": "List all available image generation models",
+            "POST /api/creative/upload": "Upload a creative image for analysis",
+            "POST /api/creative/analyze": "Analyze a creative image with AI vision (via URL)",
+            "POST /api/creative/analyze/upload": "Analyze a creative image with AI vision (via file upload)",
+            "POST /api/creative/modify": "Modify a creative with new angle/concept",
+            "GET /api/trends/{niche}": "Get current trending topics from Google News",
+            "GET /api/trends/angles/{niche}": "Get auto-generated angles from trending topics",
+            "GET /health": "Health check",
+        },
+        "supported_niches": ["home_insurance", "glp1"],
+        "matrix_system": {
+            "total_angles": 100,
+            "total_concepts": 100,
+            "possible_combinations": 10000,
+            "formula": "1 Offer → 5-8 Angles → 3-5 Concepts per angle",
+        },
+    }
+
+
+@router.get("/")
+async def root():
+    """Proxy root to Next.js frontend."""
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get("http://localhost:3000/")
+            return FastAPIResponse(
+                content=response.content,
+                status_code=response.status_code,
+                headers={k: v for k, v in response.headers.items() if k.lower() not in ["content-encoding", "transfer-encoding", "content-length"]},
+                media_type=response.headers.get("content-type"),
+            )
+    except httpx.RequestError:
+        return FastAPIResponse(
+            content="<html><head><meta http-equiv='refresh' content='2'></head><body><h1>Loading...</h1></body></html>",
+            status_code=200,
+            media_type="text/html",
+        )
+
+
+@router.get("/health")
+async def health():
+    """Health check endpoint for Hugging Face Spaces."""
+    return {"status": "ok"}

api/routers/matrix.py

@@ -0,0 +1,160 @@
+"""Angle × Concept matrix endpoints."""
+
+from fastapi import APIRouter, HTTPException, Depends
+
+from api.schemas import (
+    MatrixGenerateRequest,
+    MatrixGenerateResponse,
+    MatrixBatchRequest,
+    TestingMatrixResponse,
+    RefineCustomRequest,
+    RefineCustomResponse,
+)
+from services.generator import ad_generator
+from services.matrix import matrix_service
+from services.auth_dependency import get_current_user
+
+router = APIRouter(tags=["matrix"])
+
+
+@router.post("/matrix/generate", response_model=MatrixGenerateResponse)
+async def generate_with_matrix(
+    request: MatrixGenerateRequest,
+    username: str = Depends(get_current_user),
+):
+    """
+    Generate ad using the Angle × Concept matrix approach.
+    Requires authentication. Supports custom angle/concept when key is 'custom'.
+    """
+    try:
+        return await ad_generator.generate_ad_with_matrix(
+            niche=request.niche,
+            angle_key=request.angle_key,
+            concept_key=request.concept_key,
+            custom_angle=request.custom_angle,
+            custom_concept=request.custom_concept,
+            num_images=request.num_images,
+            image_model=request.image_model,
+            username=username,
+            core_motivator=request.core_motivator,
+            target_audience=request.target_audience,
+            offer=request.offer,
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/matrix/testing", response_model=TestingMatrixResponse)
+async def generate_testing_matrix(request: MatrixBatchRequest):
+    """
+    Generate a testing matrix (combinations without images).
+    Strategies: balanced, top_performers, diverse.
+    """
+    try:
+        combinations = matrix_service.generate_testing_matrix(
+            niche=request.niche,
+            angle_count=request.angle_count,
+            concept_count=request.concept_count,
+            strategy=request.strategy,
+        )
+        summary = matrix_service.get_matrix_summary(combinations)
+        return {
+            "niche": request.niche,
+            "strategy": request.strategy,
+            "summary": summary,
+            "combinations": combinations,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/matrix/angles")
+async def list_angles():
+    """List all available angles (100 total, 10 categories)."""
+    from data.angles import ANGLES, get_all_angles
+
+    categories = {}
+    for cat_key, cat_data in ANGLES.items():
+        categories[cat_key.value] = {
+            "name": cat_data["name"],
+            "angle_count": len(cat_data["angles"]),
+            "angles": [
+                {"key": a["key"], "name": a["name"], "trigger": a["trigger"], "example": a["example"]}
+                for a in cat_data["angles"]
+            ],
+        }
+    return {"total_angles": len(get_all_angles()), "categories": categories}
+
+
+@router.get("/matrix/concepts")
+async def list_concepts():
+    """List all available concepts (100 total, 10 categories)."""
+    from data.concepts import CONCEPTS, get_all_concepts
+
+    categories = {}
+    for cat_key, cat_data in CONCEPTS.items():
+        categories[cat_key.value] = {
+            "name": cat_data["name"],
+            "concept_count": len(cat_data["concepts"]),
+            "concepts": [
+                {"key": c["key"], "name": c["name"], "structure": c["structure"], "visual": c["visual"]}
+                for c in cat_data["concepts"]
+            ],
+        }
+    return {"total_concepts": len(get_all_concepts()), "categories": categories}
+
+
+@router.get("/matrix/angle/{angle_key}")
+async def get_angle(angle_key: str):
+    """Get details for a specific angle by key."""
+    from data.angles import get_angle_by_key
+
+    angle = get_angle_by_key(angle_key)
+    if not angle:
+        raise HTTPException(status_code=404, detail=f"Angle '{angle_key}' not found")
+    return angle
+
+
+@router.get("/matrix/concept/{concept_key}")
+async def get_concept(concept_key: str):
+    """Get details for a specific concept by key."""
+    from data.concepts import get_concept_by_key
+
+    concept = get_concept_by_key(concept_key)
+    if not concept:
+        raise HTTPException(status_code=404, detail=f"Concept '{concept_key}' not found")
+    return concept
+
+
+@router.get("/matrix/compatible/{angle_key}")
+async def get_compatible_concepts(angle_key: str):
+    """Get concepts compatible with a specific angle."""
+    from data.angles import get_angle_by_key
+    from data.concepts import get_compatible_concepts as get_compatible
+
+    angle = get_angle_by_key(angle_key)
+    if not angle:
+        raise HTTPException(status_code=404, detail=f"Angle '{angle_key}' not found")
+    compatible = get_compatible(angle.get("trigger", ""))
+    return {
+        "angle": {"key": angle["key"], "name": angle["name"], "trigger": angle["trigger"]},
+        "compatible_concepts": [
+            {"key": c["key"], "name": c["name"], "structure": c["structure"]}
+            for c in compatible
+        ],
+    }
+
+
+@router.post("/matrix/refine-custom", response_model=RefineCustomResponse)
+async def refine_custom_angle_or_concept(request: RefineCustomRequest):
+    """Refine a custom angle or concept text using AI."""
+    try:
+        result = await ad_generator.refine_custom_angle_or_concept(
+            text=request.text,
+            type=request.type,
+            niche=request.niche,
+            goal=request.goal,
+        )
+        return {"status": "success", "type": request.type, "refined": result}
+    except Exception as e:
+        return {"status": "error", "type": request.type, "refined": None, "error": str(e)}

api/routers/motivator.py

@@ -0,0 +1,32 @@
+"""Motivator generation endpoint."""
+
+from fastapi import APIRouter, HTTPException, Depends
+
+from api.schemas import MotivatorGenerateRequest, MotivatorGenerateResponse
+from services.motivator import generate_motivators as motivator_generate
+from services.auth_dependency import get_current_user
+
+router = APIRouter(tags=["motivator"])
+
+
+@router.post("/api/motivator/generate", response_model=MotivatorGenerateResponse)
+async def motivator_generate_endpoint(
+    request: MotivatorGenerateRequest,
+    username: str = Depends(get_current_user),
+):
+    """
+    Generate motivators from niche + angle + concept context (Matrix mode).
+    Requires authentication.
+    """
+    try:
+        motivators = await motivator_generate(
+            niche=request.niche,
+            angle=request.angle,
+            concept=request.concept,
+            target_audience=request.target_audience,
+            offer=request.offer,
+            count=request.count,
+        )
+        return {"motivators": motivators}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

api/routers/trends.py

@@ -0,0 +1,84 @@
+"""Trending topics endpoints."""
+
+from typing import Literal
+from fastapi import APIRouter, Depends
+
+from services.auth_dependency import get_current_user
+from services.trend_monitor import trend_monitor
+from services.current_occasions import get_current_occasions
+
+router = APIRouter(tags=["trends"])
+
+
+@router.get("/api/trends/{niche}")
+async def get_trends(
+    niche: Literal["home_insurance", "glp1", "auto_insurance"],
+    username: str = Depends(get_current_user),
+):
+    """
+    Get current trending topics for a niche: date-based occasions (e.g. Valentine's Week)
+    plus niche-specific news. Topics are analyzed from the current date so they stay timely.
+    """
+    try:
+        data = await trend_monitor.get_relevant_trends_for_niche(niche)
+        raw = data.get("relevant_trends") or []
+        # Map to frontend shape: title, description (from summary), category, url
+        trends = [
+            {
+                "title": t.get("title", ""),
+                "description": t.get("summary", t.get("description", "")),
+                "category": t.get("category", "General"),
+                "url": t.get("url"),
+            }
+            for t in raw
+        ]
+        return {
+            "status": "ok",
+            "niche": niche,
+            "trends": trends,
+            "count": len(trends),
+        }
+    except Exception as e:
+        # Fallback to occasions only if news fails
+        occasions = await get_current_occasions()
+        trends = [
+            {
+                "title": o["title"],
+                "description": o["summary"],
+                "category": o.get("category", "Occasion"),
+            }
+            for o in occasions
+        ]
+        return {
+            "status": "ok",
+            "niche": niche,
+            "trends": trends,
+            "count": len(trends),
+            "message": "Showing current occasions (news temporarily unavailable).",
+        }
+
+
+@router.get("/api/trends/angles/{niche}")
+async def get_trending_angles(
+    niche: Literal["home_insurance", "glp1", "auto_insurance"],
+    username: str = Depends(get_current_user),
+):
+    """
+    Get auto-generated angle suggestions based on current trends and occasions.
+    """
+    try:
+        angles = await trend_monitor.get_trending_angles(niche)
+        return {
+            "status": "ok",
+            "niche": niche,
+            "trending_angles": angles,
+            "count": len(angles),
+        }
+    except Exception as e:
+        return {
+            "status": "ok",
+            "niche": niche,
+            "trending_angles": [],
+            "count": 0,
+            "message": "Angle suggestions temporarily unavailable.",
+        }

api/schemas.py

@@ -0,0 +1,470 @@
+"""
+Request/response schemas for PsyAdGenesis API.
+Keeps all Pydantic models in one place for consistency and reuse.
+"""
+
+from pydantic import BaseModel, Field
+from typing import Optional, List, Literal, Any, Dict
+
+
+# ----- Generate -----
+class GenerateRequest(BaseModel):
+    """Request schema for ad generation."""
+    niche: Literal["home_insurance", "glp1", "auto_insurance"] = Field(
+        description="Target niche: home_insurance, glp1, or auto_insurance"
+    )
+    num_images: int = Field(default=1, ge=1, le=10, description="Number of images to generate (1-10)")
+    image_model: Optional[str] = Field(default=None, description="Image generation model to use")
+    target_audience: Optional[str] = Field(default=None, description="Optional target audience description")
+    offer: Optional[str] = Field(default=None, description="Optional offer to run")
+    use_trending: bool = Field(default=False, description="Whether to incorporate current trending topics")
+    trending_context: Optional[str] = Field(default=None, description="Specific trending context when use_trending=True")
+
+
+class GenerateBatchRequest(BaseModel):
+    """Request schema for batch ad generation."""
+    niche: Literal["home_insurance", "glp1", "auto_insurance"] = Field(description="Target niche")
+    count: int = Field(default=5, ge=1, le=100, description="Number of ads to generate (1-100)")
+    images_per_ad: int = Field(default=1, ge=1, le=3, description="Images per ad (1-3)")
+    image_model: Optional[str] = Field(default=None, description="Image generation model to use")
+    method: Optional[Literal["standard", "matrix"]] = Field(default=None, description="Generation method or None for mixed")
+    target_audience: Optional[str] = Field(default=None, description="Optional target audience")
+    offer: Optional[str] = Field(default=None, description="Optional offer to run")
+
+
+class ImageResult(BaseModel):
+    """Image result schema."""
+    filename: Optional[str] = None
+    filepath: Optional[str] = None
+    image_url: Optional[str] = None
+    model_used: Optional[str] = None
+    seed: Optional[int] = None
+    error: Optional[str] = None
+
+
+class AdMetadata(BaseModel):
+    """Metadata about the generation."""
+    strategies_used: List[str]
+    creative_direction: str
+    visual_mood: str
+    framework: Optional[str] = None
+    camera_angle: Optional[str] = None
+    lighting: Optional[str] = None
+    composition: Optional[str] = None
+    hooks_inspiration: List[str]
+    visual_styles: List[str]
+
+
+class GenerateResponse(BaseModel):
+    """Response schema for ad generation."""
+    id: str
+    niche: str
+    created_at: str
+    title: Optional[str] = Field(default=None, description="Short punchy ad title (3-5 words)")
+    headline: str
+    primary_text: str
+    description: str
+    body_story: str = Field(description="Compelling 8-12 sentence story that hooks emotionally")
+    cta: str
+    psychological_angle: str
+    why_it_works: Optional[str] = None
+    images: List[ImageResult]
+    metadata: AdMetadata
+
+
+class BatchResponse(BaseModel):
+    """Response schema for batch generation."""
+    count: int
+    ads: List[GenerateResponse]
+
+
+# ----- Matrix -----
+class MatrixGenerateRequest(BaseModel):
+    """Request for angle × concept matrix generation."""
+    niche: Literal["home_insurance", "glp1", "auto_insurance"] = Field(description="Target niche")
+    angle_key: Optional[str] = Field(default=None, description="Specific angle key (random if not provided)")
+    concept_key: Optional[str] = Field(default=None, description="Specific concept key (random if not provided)")
+    custom_angle: Optional[str] = Field(default=None, description="Custom angle text when angle_key is 'custom'")
+    custom_concept: Optional[str] = Field(default=None, description="Custom concept text when concept_key is 'custom'")
+    num_images: int = Field(default=1, ge=1, le=5, description="Number of images to generate")
+    image_model: Optional[str] = Field(default=None, description="Image generation model to use")
+    target_audience: Optional[str] = Field(default=None, description="Optional target audience")
+    offer: Optional[str] = Field(default=None, description="Optional offer to run")
+    core_motivator: Optional[str] = Field(default=None, description="Optional motivator to guide generation")
+
+
+class RefineCustomRequest(BaseModel):
+    """Request to refine custom angle or concept text using AI."""
+    text: str = Field(description="The raw custom text from user")
+    type: Literal["angle", "concept"] = Field(description="Whether this is an angle or concept")
+    niche: Literal["home_insurance", "glp1", "auto_insurance"] = Field(description="Target niche for context")
+    goal: Optional[str] = Field(default=None, description="Optional user goal or context")
+
+
+class RefinedAngleResponse(BaseModel):
+    """Response for refined angle."""
+    key: str = Field(default="custom")
+    name: str
+    trigger: str
+    example: str
+    category: str = Field(default="Custom")
+    original_text: str
+
+
+class RefinedConceptResponse(BaseModel):
+    """Response for refined concept."""
+    key: str = Field(default="custom")
+    name: str
+    structure: str
+    visual: str
+    category: str = Field(default="Custom")
+    original_text: str
+
+
+class RefineCustomResponse(BaseModel):
+    """Response for refined custom angle or concept."""
+    status: str
+    type: Literal["angle", "concept"]
+    refined: Optional[dict] = None
+    error: Optional[str] = None
+
+
+class MotivatorGenerateRequest(BaseModel):
+    """Request to generate motivators from niche + angle + concept."""
+    niche: Literal["home_insurance", "glp1", "auto_insurance"] = Field(description="Target niche")
+    angle: Dict[str, Any] = Field(description="Angle context: name, trigger, example")
+    concept: Dict[str, Any] = Field(description="Concept context: name, structure, visual")
+    target_audience: Optional[str] = Field(default=None, description="Optional target audience")
+    offer: Optional[str] = Field(default=None, description="Optional offer")
+    count: int = Field(default=6, ge=3, le=10, description="Number of motivators to generate")
+
+
+class MotivatorGenerateResponse(BaseModel):
+    """Response with generated motivators."""
+    motivators: List[str]
+
+
+class MatrixBatchRequest(BaseModel):
+    """Request for batch matrix generation."""
+    niche: Literal["home_insurance", "glp1"] = Field(description="Target niche")
+    angle_count: int = Field(default=6, ge=1, le=10, description="Number of angles to test")
+    concept_count: int = Field(default=5, ge=1, le=10, description="Number of concepts per angle")
+    strategy: Literal["balanced", "top_performers", "diverse"] = Field(default="balanced", description="Selection strategy")
+
+
+class AngleInfo(BaseModel):
+    """Angle information."""
+    key: str
+    name: str
+    trigger: str
+    category: str
+
+
+class ConceptInfo(BaseModel):
+    """Concept information."""
+    key: str
+    name: str
+    structure: str
+    visual: str
+    category: str
+
+
+class MatrixMetadata(BaseModel):
+    """Matrix generation metadata."""
+    generation_method: str = "angle_concept_matrix"
+
+
+class MatrixResult(BaseModel):
+    """Result from matrix-based generation."""
+    angle: AngleInfo
+    concept: ConceptInfo
+
+
+class MatrixGenerateResponse(BaseModel):
+    """Response for matrix-based ad generation."""
+    id: str
+    niche: str
+    created_at: str
+    title: Optional[str] = Field(default=None, description="Short punchy ad title")
+    headline: str
+    primary_text: str
+    description: str
+    body_story: str = Field(description="Compelling 8-12 sentence story that hooks emotionally")
+    cta: str
+    psychological_angle: str
+    why_it_works: Optional[str] = None
+    images: List[ImageResult]
+    matrix: MatrixResult
+    metadata: MatrixMetadata
+
+
+class CombinationInfo(BaseModel):
+    """Info about a single angle × concept combination."""
+    combination_id: str
+    angle: AngleInfo
+    concept: ConceptInfo
+    compatibility_score: float
+    prompt_guidance: str
+
+
+class MatrixSummary(BaseModel):
+    """Summary of a testing matrix."""
+    total_combinations: int
+    unique_angles: int
+    unique_concepts: int
+    average_compatibility: float
+    angles_used: List[str]
+    concepts_used: List[str]
+
+
+class TestingMatrixResponse(BaseModel):
+    """Response for testing matrix generation."""
+    niche: str
+    strategy: str
+    summary: MatrixSummary
+    combinations: List[CombinationInfo]
+
+
+# ----- Auth -----
+class LoginRequest(BaseModel):
+    """Login request."""
+    username: str = Field(description="Username")
+    password: str = Field(description="Password")
+
+
+class LoginResponse(BaseModel):
+    """Login response."""
+    token: str
+    username: str
+    message: str = "Login successful"
+
+
+# ----- Correction -----
+class ImageCorrectRequest(BaseModel):
+    """Request schema for image correction."""
+    image_id: str = Field(description="ID of existing ad creative or 'temp-id' for images not in DB")
+    image_url: Optional[str] = Field(default=None, description="Optional image URL when image_id='temp-id'")
+    user_instructions: Optional[str] = Field(default=None, description="User instructions for correction")
+    auto_analyze: bool = Field(default=False, description="Auto-analyze image for issues if no instructions")
+
+
+class SpellingCorrection(BaseModel):
+    """Spelling correction entry."""
+    detected: str
+    corrected: str
+    context: Optional[str] = None
+
+
+class VisualCorrection(BaseModel):
+    """Visual correction entry."""
+    issue: str
+    suggestion: str
+    priority: Optional[str] = None
+
+
+class CorrectionData(BaseModel):
+    """Correction data structure."""
+    spelling_corrections: List[SpellingCorrection]
+    visual_corrections: List[VisualCorrection]
+    corrected_prompt: str
+
+
+class CorrectedImageResult(BaseModel):
+    """Corrected image result."""
+    filename: Optional[str] = None
+    filepath: Optional[str] = None
+    image_url: Optional[str] = None
+    r2_url: Optional[str] = None
+    model_used: Optional[str] = None
+    corrected_prompt: Optional[str] = None
+
+
+class ImageCorrectResponse(BaseModel):
+    """Response schema for image correction."""
+    status: str
+    analysis: Optional[str] = None
+    corrections: Optional[CorrectionData] = None
+    corrected_image: Optional[CorrectedImageResult] = None
+    error: Optional[str] = None
+
+
+class ImageRegenerateRequest(BaseModel):
+    """Request schema for image regeneration."""
+    image_id: str = Field(description="ID of existing ad creative in database")
+    image_model: Optional[str] = Field(default=None, description="Image model to use (or original if not provided)")
+    preview_only: bool = Field(default=True, description="If True, preview only; user confirms selection later")
+
+
+class RegeneratedImageResult(BaseModel):
+    """Regenerated image result."""
+    filename: Optional[str] = None
+    filepath: Optional[str] = None
+    image_url: Optional[str] = None
+    r2_url: Optional[str] = None
+    model_used: Optional[str] = None
+    prompt_used: Optional[str] = None
+    seed_used: Optional[int] = None
+
+
+class ImageRegenerateResponse(BaseModel):
+    """Response schema for image regeneration."""
+    status: str
+    regenerated_image: Optional[RegeneratedImageResult] = None
+    original_image_url: Optional[str] = None
+    original_preserved: bool = Field(default=True, description="Whether original image info was preserved")
+    is_preview: bool = Field(default=False, description="Whether this is a preview (not yet saved)")
+    error: Optional[str] = None
+
+
+class ImageSelectionRequest(BaseModel):
+    """Request schema for confirming image selection after regeneration."""
+    image_id: str = Field(description="ID of existing ad creative in database")
+    selection: str = Field(description="Which image to keep: 'new' or 'original'")
+    new_image_url: Optional[str] = Field(default=None, description="URL of new image (required if selection='new')")
+    new_r2_url: Optional[str] = Field(default=None, description="R2 URL of the new image")
+    new_filename: Optional[str] = Field(default=None, description="Filename of the new image")
+    new_model: Optional[str] = Field(default=None, description="Model used for the new image")
+    new_seed: Optional[int] = Field(default=None, description="Seed used for the new image")
+
+
+# ----- Extensive -----
+class ExtensiveGenerateRequest(BaseModel):
+    """Request for extensive generation."""
+    niche: str = Field(description="Target niche or 'others' with custom_niche")
+    custom_niche: Optional[str] = Field(default=None, description="Custom niche when 'others' is selected")
+    target_audience: Optional[str] = Field(default=None, description="Optional target audience")
+    offer: Optional[str] = Field(default=None, description="Optional offer to run")
+    num_images: int = Field(default=1, ge=1, le=3, description="Number of images per strategy (1-3)")
+    image_model: Optional[str] = Field(default=None, description="Image generation model to use")
+    num_strategies: int = Field(default=5, ge=1, le=10, description="Number of creative strategies (1-10)")
+
+
+class ExtensiveJobResponse(BaseModel):
+    """Response when extensive generation is started (202 Accepted)."""
+    job_id: str
+    message: str = "Extensive generation started. Poll /extensive/status/{job_id} for progress."
+
+
+# ----- Creative (upload / analyze / modify) -----
+class CreativeAnalysisData(BaseModel):
+    """Structured analysis of a creative."""
+    visual_style: str
+    color_palette: List[str]
+    mood: str
+    composition: str
+    subject_matter: str
+    text_content: Optional[str] = None
+    current_angle: Optional[str] = None
+    current_concept: Optional[str] = None
+    target_audience: Optional[str] = None
+    strengths: List[str]
+    areas_for_improvement: List[str]
+
+
+class CreativeAnalyzeRequest(BaseModel):
+    """Request for creative analysis."""
+    image_url: Optional[str] = Field(default=None, description="URL of the image to analyze (alternative to file upload)")
+
+
+class CreativeAnalysisResponse(BaseModel):
+    """Response for creative analysis."""
+    status: str
+    analysis: Optional[CreativeAnalysisData] = None
+    suggested_angles: Optional[List[str]] = None
+    suggested_concepts: Optional[List[str]] = None
+    error: Optional[str] = None
+
+
+class CreativeModifyRequest(BaseModel):
+    """Request for creative modification."""
+    image_url: str = Field(description="URL of the original image")
+    analysis: Optional[Dict[str, Any]] = Field(default=None, description="Previous analysis data (optional)")
+    angle: Optional[str] = Field(default=None, description="Angle to apply to the creative")
+    concept: Optional[str] = Field(default=None, description="Concept to apply to the creative")
+    mode: Literal["modify", "inspired"] = Field(default="modify", description="modify = image-to-image, inspired = new generation")
+    image_model: Optional[str] = Field(default=None, description="Image generation model to use")
+    user_prompt: Optional[str] = Field(default=None, description="Optional custom user prompt for modification")
+
+
+class ModifiedImageResult(BaseModel):
+    """Result of creative modification."""
+    filename: Optional[str] = None
+    filepath: Optional[str] = None
+    image_url: Optional[str] = None
+    r2_url: Optional[str] = None
+    model_used: Optional[str] = None
+    mode: Optional[str] = None
+    applied_angle: Optional[str] = None
+    applied_concept: Optional[str] = None
+
+
+class CreativeModifyResponse(BaseModel):
+    """Response for creative modification."""
+    status: str
+    prompt: Optional[str] = None
+    image: Optional[ModifiedImageResult] = None
+    error: Optional[str] = None
+
+
+class FileUploadResponse(BaseModel):
+    """Response for file upload."""
+    status: str
+    image_url: Optional[str] = None
+    filename: Optional[str] = None
+    error: Optional[str] = None
+
+
+# ----- Database -----
+class AdCreativeDB(BaseModel):
+    """Ad creative from database."""
+    id: str
+    niche: str
+    title: Optional[str] = None
+    headline: str
+    primary_text: Optional[str] = None
+    description: Optional[str] = None
+    body_story: Optional[str] = None
+    cta: Optional[str] = None
+    psychological_angle: Optional[str] = None
+    why_it_works: Optional[str] = None
+    image_url: Optional[str] = None
+    image_filename: Optional[str] = None
+    image_model: Optional[str] = None
+    image_seed: Optional[int] = None
+    angle_key: Optional[str] = None
+    angle_name: Optional[str] = None
+    concept_key: Optional[str] = None
+    concept_name: Optional[str] = None
+    generation_method: Optional[str] = None
+    created_at: Optional[str] = None
+
+
+class DbStatsResponse(BaseModel):
+    """Database statistics response."""
+    connected: bool
+    total_ads: Optional[int] = None
+    by_niche: Optional[Dict[str, int]] = None
+    by_method: Optional[Dict[str, int]] = None
+    error: Optional[str] = None
+
+
+class EditAdCopyRequest(BaseModel):
+    """Request for editing ad copy."""
+    ad_id: str = Field(description="ID of the ad to edit")
+    field: Literal["title", "headline", "primary_text", "description", "body_story", "cta"] = Field(description="Field to edit")
+    value: str = Field(description="New value (manual) or current value (AI edit)")
+    mode: Literal["manual", "ai"] = Field(description="Edit mode: manual or ai")
+    user_suggestion: Optional[str] = Field(default=None, description="User suggestion for AI editing (optional)")
+
+
+# ----- Export -----
+class BulkExportRequest(BaseModel):
+    """Request schema for bulk export."""
+    ad_ids: List[str] = Field(description="List of ad IDs to export", min_length=1, max_length=50)
+
+
+class BulkExportResponse(BaseModel):
+    """Response schema for bulk export (actual response is FileResponse with ZIP)."""
+    status: str
+    message: str
+    filename: str

data/frameworks.py

@@ -901,79 +901,6 @@ FRAMEWORKS: Dict[str, Dict[str, Any]] = {
 
     }
 
-# Framework examples by niche
-NICHE_FRAMEWORK_EXAMPLES: Dict[str, Dict[str, List[str]]] = {
-    "home_insurance": {
-        "breaking_news": [
-            "BREAKING: Home Insurance Rates Drop 40%",
-            "ALERT: New Homeowner Discounts Available",
-            "URGENT: Rate Freeze Ends Friday",
-        ],
-        "mobile_post": [
-            "Protect Your Home in 3 Minutes",
-            "One Quote. Big Savings.",
-            "Tap to See Your Rate",
-        ],
-        "before_after": [
-            "Before: $2,400/year. After: $1,200/year",
-            "Old policy vs New savings",
-            "What switching saved me",
-        ],
-        "testimonial": [
-            '"I saved $1,200 on my first year"',
-            "Join 100,000+ protected homeowners",
-            "Rated #1 by customers like you",
-        ],
-        "problem_solution": [
-            "Worried your home isn't covered?",
-            "Stop overpaying for insurance",
-            "End the coverage gaps",
-        ],
-    },
-    "glp1": {
-        "breaking_news": [
-            "NEW: FDA-Approved Weight Loss Solution",
-            "ALERT: Limited Appointments Available",
-            "EXCLUSIVE: Online Consultations Now Open",
-        ],
-        "before_after": [
-            "Her 60-Day Transformation",
-            "What Changed in 90 Days",
-            "The Results Speak for Themselves",
-        ],
-        "testimonial": [
-            '"I finally found what works"',
-            "Thousands have transformed",
-            "Real patients. Real results.",
-        ],
-        "lifestyle": [
-            "Feel Confident Again",
-            "The Energy to Live Fully",
-            "Your New Chapter Starts Here",
-        ],
-        "authority": [
-            "Doctor-Recommended Solution",
-            "Clinically Proven Results",
-            "Backed by Medical Research",
-        ],
-        "scarcity": [
-            "Only 20 Appointments This Week",
-            "Limited Spots Available",
-            "Join the Waitlist Now",
-        ],
-        "risk_reversal": [
-            "100% Satisfaction Guarantee",
-            "Try Risk-Free for 30 Days",
-            "No Commitment Required",
-        ],
-        "case_study": [
-            "How Maria Lost 30 Pounds in 3 Months",
-            "Real Patient Results",
-            "The Transformation Journey",
-        ],
-    },
-}
-
 
 def get_all_frameworks() -> Dict[str, Dict[str, Any]]:
     """Get all available frameworks."""
@@ -998,35 +925,26 @@ def get_frameworks_for_niche(niche: str, count: int = 3) -> List[Dict[str, Any]]
     # Niche-specific framework preferences
     niche_preferences = {
         "home_insurance": ["testimonial", "problem_solution", "authority", "before_after", "lifestyle"],
-        "glp1": ["before_after", "testimonial", "lifestyle", "authority", "problem_solution"],
+        "glp1": ["testimonial", "lifestyle", "authority", "problem_solution", "before_after"],
         "auto_insurance": ["testimonial", "problem_solution", "authority", "before_after", "comparison"],
     }
     
     # Get preferred frameworks or use all
     preferred_keys = niche_preferences.get(niche_lower, list(FRAMEWORKS.keys()))
     
-    # Add remaining frameworks for variety
-    all_keys = preferred_keys + [k for k in FRAMEWORKS.keys() if k not in preferred_keys]
+    # Shuffle so we don't always pick the first (e.g. GLP-1 was always getting before_after when count=1)
+    shuffled_preferred = preferred_keys.copy()
+    random.shuffle(shuffled_preferred)
+    remaining = [k for k in FRAMEWORKS.keys() if k not in preferred_keys]
+    random.shuffle(remaining)
+    all_keys = shuffled_preferred + remaining
     
-    # Select count frameworks with some randomization
+    # Take first count from the shuffled list (random variety per niche)
     selected = all_keys[:count]
-    random.shuffle(selected)
     
     return [{"key": k, **FRAMEWORKS[k]} for k in selected]
 
 
-def get_framework_hook_examples(framework_key: str, niche: Optional[str] = None) -> List[str]:
-    """Get hook examples for a framework, optionally niche-specific."""
-    if niche:
-        niche_key = niche.lower().replace(" ", "_").replace("-", "_")
-        niche_examples = NICHE_FRAMEWORK_EXAMPLES.get(niche_key, {}).get(framework_key, [])
-        if niche_examples:
-            return niche_examples
-    
-    framework = FRAMEWORKS.get(framework_key)
-    return framework.get("hook_examples", []) if framework else []
-
-
 # ---------------------------------------------------------------------------
 # Container-type framework helpers (visual format / "container" = framework with container_type=True)
 # ---------------------------------------------------------------------------

data/glp1.py

@@ -985,6 +985,7 @@ NICHE-SPECIFIC REQUIREMENTS (GLP-1 / WEIGHT LOSS):
         },
         "image_guidance": """
 NICHE REQUIREMENTS (GLP-1):
+- CRITICAL: Every image MUST include at least ONE of: (1) A GLP-1 medication bottle or pen in the scene (e.g. Ozempic, Wegovy, Mounjaro, Zepbound - injectable pen or box), OR (2) The text "GLP-1" or a medication name (e.g. Ozempic, Wegovy, Mounjaro) visible in the image (on a label, screen, document, or surface). Do not generate a GLP-1 ad image without product or name visibility.
 - Use VARIETY in visual types
 - Visual options include: quiz/interactive interfaces, doctor/medical settings, person on scale, mirror reflections, lifestyle/confidence scenes, testimonial portraits, celebrity references, measurement moments, or before/after (only when the strategy specifically requires it)
 - Show REAL people in various moments (not just transformation)

frontend/app/generate/page.tsx

@@ -208,7 +208,7 @@ export default function GeneratePage() {
     }
   };
 
-  const handleStandardGenerate = async (data: { niche: Niche; num_images: number; image_model?: string | null; target_audience?: string | null; offer?: string | null }) => {
+  const handleStandardGenerate = async (data: { niche: Niche; num_images: number; image_model?: string | null; target_audience?: string | null; offer?: string | null; use_trending?: boolean; trending_context?: string | null }) => {
     reset();
     setIsGenerating(true);
     setGenerationStartTime(Date.now());
@@ -217,6 +217,8 @@ export default function GeneratePage() {
       ...data,
       target_audience: data.target_audience || undefined,
       offer: data.offer || undefined,
+      use_trending: data.use_trending ?? false,
+      trending_context: data.trending_context || undefined,
     };
 
     // If num_images > 1, generate batch of ads

frontend/components/generation/GenerationForm.tsx

@@ -166,32 +166,65 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({
             )}
           </div>
 
-          {/* Trending Topics Section - COMING SOON */}
+          {/* Trending Topics – AI occasions + niche news; used in ad copy generation */}
           <div className="border-t border-gray-200 pt-4">
             <div className="flex items-center justify-between mb-3">
-              <div className="opacity-50">
+              <div>
                 <label className="block text-sm font-semibold text-gray-700">
                   Use Trending Topics 🔥
                 </label>
                 <p className="text-xs text-gray-500 mt-1">
-                  Incorporate current affairs and news for increased relevance
+                  Tie your ad to current occasions and niche news for timeliness
                 </p>
               </div>
-              <div className="flex items-center gap-2">
-                <span className="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-yellow-100 text-yellow-800 border border-yellow-200">
-                  Coming Soon
-                </span>
-                <label className="relative inline-flex items-center cursor-not-allowed opacity-50">
-                  <input
-                    type="checkbox"
-                    className="sr-only peer"
-                    disabled
-                    {...register("use_trending")}
-                  />
-                  <div className="w-11 h-6 bg-gray-200 rounded-full"></div>
-                </label>
-              </div>
+              <label className="relative inline-flex items-center cursor-pointer">
+                <input
+                  type="checkbox"
+                  className="sr-only peer"
+                  {...register("use_trending")}
+                />
+                <div className="w-11 h-6 bg-gray-200 rounded-full peer peer-checked:bg-blue-500 peer-focus:ring-2 peer-focus:ring-blue-300 transition-colors"></div>
+              </label>
             </div>
+            {useTrending && (
+              <div className="mt-3 space-y-3 rounded-xl border border-gray-200 bg-gray-50/80 p-3">
+                <Button
+                  type="button"
+                  variant="secondary"
+                  size="sm"
+                  onClick={handleFetchTrends}
+                  disabled={isFetchingTrends}
+                  className="gap-2"
+                >
+                  {isFetchingTrends ? <Loader2 className="h-4 w-4 animate-spin" /> : <TrendingUp className="h-4 w-4" />}
+                  {isFetchingTrends ? "Fetching…" : "Fetch current trends"}
+                </Button>
+                {trendsError && <p className="text-sm text-red-600">{trendsError}</p>}
+                {trends.length > 0 && (
+                  <div className="space-y-2">
+                    <p className="text-xs font-medium text-gray-600">Pick one (optional – otherwise we use the top trend):</p>
+                    <div className="max-h-40 overflow-y-auto space-y-1.5">
+                      {trends.map((trend) => (
+                        <button
+                          key={trend.title}
+                          type="button"
+                          onClick={() => handleSelectTrend(trend)}
+                          className={`w-full text-left px-3 py-2 rounded-lg border text-sm transition-colors ${
+                            selectedTrend?.title === trend.title
+                              ? "border-blue-500 bg-blue-50 text-blue-800"
+                              : "border-gray-200 bg-white hover:bg-gray-100"
+                          }`}
+                        >
+                          <span className="font-medium">{trend.title}</span>
+                          {selectedTrend?.title === trend.title && <Check className="inline h-4 w-4 ml-1 text-blue-600" />}
+                          <p className="text-xs text-gray-500 mt-0.5 line-clamp-2">{trend.description}</p>
+                        </button>
+                      ))}
+                    </div>
+                  </div>
+                )}
+              </div>
+            )}
           </div>
 
 

scripts/test_trends.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""Quick test for trending topics: AI occasions + niche trends. Run from repo root: python scripts/test_trends.py"""
+
+import asyncio
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+
+async def main():
+    from services.current_occasions import get_current_occasions
+
+    print("=== 1. Current occasions (AI) ===\n")
+    occasions = await get_current_occasions()
+    if not occasions:
+        print("No occasions returned (AI may have failed or returned empty).")
+    else:
+        for i, o in enumerate(occasions, 1):
+            print(f"  {i}. {o['title']}")
+            print(f"     {o['summary']}")
+            print()
+        print(f"Total: {len(occasions)} occasions\n")
+
+    try:
+        from services.trend_monitor import trend_monitor
+        print("=== 2. Full trends for niche 'home_insurance' (occasions + news) ===\n")
+        data = await trend_monitor.get_relevant_trends_for_niche("home_insurance")
+        trends = data.get("relevant_trends") or []
+        for i, t in enumerate(trends[:8], 1):
+            print(f"  {i}. [{t.get('category', '?')}] {t.get('title', '')}")
+            print(f"     {(t.get('summary') or '')[:120]}...")
+            print()
+        print(f"Total trends: {len(trends)}")
+    except ImportError as e:
+        print("=== 2. Skipping full trends (missing dependency):", e)
+        print("   Install with: pip install gnews")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

services/current_occasions.py

@@ -0,0 +1,91 @@
+"""
+Current Occasions – AI-driven trending context for ad generation.
+Uses the LLM to infer relevant occasions from the current date (holidays,
+cultural moments, seasonal themes). No fallbacks; results are cached per day.
+"""
+
+from datetime import date
+from typing import List, Dict, Any
+
+# Daily cache: date.isoformat() -> list of occasion dicts (title, summary, category, relevance_window)
+_OCCASIONS_CACHE: Dict[str, List[Dict]] = {}
+
+
+def _normalize_ai_occasions(raw: Any) -> List[Dict]:
+    """Parse and normalize LLM output to our occasion shape."""
+    if not raw:
+        return []
+    items = raw.get("occasions") if isinstance(raw, dict) else raw
+    if not isinstance(items, list):
+        return []
+    normalized: List[Dict] = []
+    for o in items:
+        if not isinstance(o, dict):
+            continue
+        title = o.get("title") or o.get("name")
+        summary = o.get("summary") or o.get("description")
+        if not title or not summary:
+            continue
+        normalized.append({
+            "title": str(title).strip(),
+            "summary": str(summary).strip(),
+            "category": str(o.get("category", "Occasion")).strip() or "Occasion",
+            "relevance_window": str(o.get("relevance_window", "week")).strip() or "week",
+        })
+    return normalized
+
+
+async def get_current_occasions(today: date | None = None) -> List[Dict]:
+    """
+    Return current occasions for ad trending context.
+    Results are cached per day.
+
+    Returns:
+        List of dicts: title, summary, category, relevance_window (empty if AI fails).
+    """
+    if today is None:
+        today = date.today()
+    cache_key = today.isoformat()
+
+    if cache_key in _OCCASIONS_CACHE:
+        return _OCCASIONS_CACHE[cache_key]
+
+    try:
+        from services.llm import llm_service
+    except Exception:
+        _OCCASIONS_CACHE[cache_key] = []
+        return []
+
+    system_prompt = """You are an expert in global holidays, cultural moments, and seasonal themes used for advertising and marketing.
+Given a date, list 4–6 occasions that are relevant RIGHT NOW or in the next few days for that date. Include:
+- Official holidays (US, India, global where relevant)
+- Cultural/seasonal moments (e.g. Valentine's Week with daily themes like Rose Day, Teddy Day; Black Friday; back-to-school)
+- Awareness days/weeks/months (e.g. Black History Month, Earth Day)
+- Shopping or behavior moments (Singles' Day, Prime Day, etc.)
+Be specific to the exact date when it matters (e.g. "Teddy Day" on Feb 10, "Valentine's Day" on Feb 14).
+Respond with valid JSON only, in this exact shape (no extra fields):
+{"occasions": [{"title": "...", "summary": "One sentence on why it matters for ads.", "category": "Occasion", "relevance_window": "day"|"week"|"month"}]}
+Use relevance_window: "day" for single-day events, "week" for a week-long moment, "month" for month-long themes."""
+
+    user_prompt = f"""Today's date is {today.isoformat()} ({today.strftime('%A, %B %d, %Y')}).
+List 4–6 current or upcoming occasions that are relevant for advertising and marketing on or around this date. Consider global and regional relevance. Output JSON only."""
+
+    try:
+        response = await llm_service.generate_json(
+            prompt=user_prompt,
+            system_prompt=system_prompt,
+            temperature=0.3,
+        )
+        occasions = _normalize_ai_occasions(response)
+    except Exception as e:
+        print(f"⚠️ AI occasions failed: {e}")
+        occasions = []
+
+    _OCCASIONS_CACHE[cache_key] = occasions
+    return occasions
+
+
+def clear_occasions_cache() -> None:
+    """Clear the occasions cache (e.g. for tests)."""
+    global _OCCASIONS_CACHE
+    _OCCASIONS_CACHE = {}

services/generator.py

@@ -1,79 +1,75 @@
 """
-Main Ad Generator Service
-Combines LLM + Image generation with maximum randomization for variety
-Uses professional prompting techniques for PsyAdGenesis
-Saves ad creatives to Neon database with image URLs
-"""
+Ad Generator Service
 
-# ============================================================================
-# IMPORTS
-# ============================================================================
+Generates high-converting ad creatives using psychological triggers, LLM copy,
+and image generation. Uses maximum randomization for variety and saves to the
+Neon database with optional R2 image storage.
+"""
 
-# Standard library
+import asyncio
+import json
 import os
-import sys
 import random
 import uuid
-import json
-import asyncio
 from datetime import datetime
-from typing import Dict, Any, List, Optional
+from typing import Any, Dict, List, Optional
 
-# Add parent directory to path for imports
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-# Local application imports
 from config import settings
-from services.llm import llm_service
+from data import auto_insurance, glp1, home_insurance
+from data.frameworks import (
+    get_all_frameworks,
+    get_framework,
+    get_framework_visual_guidance,
+    get_frameworks_for_niche,
+)
+from data.hooks import get_power_words, get_random_cta as get_hook_cta, get_random_hook_style
+from data.triggers import get_random_trigger, get_trigger_combination, get_triggers_for_niche
+from data.visuals import (
+    get_color_palette,
+    get_niche_visual_guidance,
+    get_random_camera_angle,
+    get_random_composition,
+    get_random_lighting,
+    get_random_mood,
+    get_random_visual_style,
+)
+from services.generator_prompts import (
+    get_headline_formulas,
+    get_numbers_section,
+    get_trending_section,
+    get_trending_image_guidance,
+)
 from services.image import image_service
+from services.llm import llm_service
+from services.matrix import matrix_service
 
-# Optional service imports
 try:
     from services.database import db_service
 except ImportError:
     db_service = None
-    print("Note: Database service not available (asyncpg not installed). Ads will be generated but not saved to database.")
 
 try:
     from services.r2_storage import get_r2_storage
     r2_storage_available = True
 except ImportError:
     r2_storage_available = False
-    print("Note: R2 storage not available. Images will only be saved locally.")
 
 try:
     from services.third_flow import third_flow_service
     third_flow_available = True
 except ImportError:
     third_flow_available = False
-    print("Note: Extensive service not available.")
 
 try:
     from services.trend_monitor import trend_monitor
     trend_monitor_available = True
 except ImportError:
     trend_monitor_available = False
-    print("Note: Trend monitor service not available.")
-
-# Data module imports
-from data import home_insurance, glp1, auto_insurance
-from services.matrix import matrix_service
-from data.frameworks import (
-    get_frameworks_for_niche, get_framework_hook_examples, get_all_frameworks,
-    get_framework, get_framework_visual_guidance,
-)
-from data.hooks import get_random_hook_style, get_power_words, get_random_cta as get_hook_cta
-from data.triggers import get_random_trigger, get_trigger_combination, get_triggers_for_niche
-from data.visuals import (
-    get_random_visual_style, get_random_camera_angle, get_random_lighting,
-    get_random_composition, get_random_mood, get_color_palette, get_niche_visual_guidance
-)
 
-# ============================================================================
-# CONSTANTS
-# ============================================================================
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
 
-# Niche data loaders
 NICHE_DATA = {
     "home_insurance": home_insurance.get_niche_data,
     "glp1": glp1.get_niche_data,
@@ -119,14 +115,20 @@ FILM_DAMAGE_EFFECTS = [
 
 class AdGenerator:
     """
-    Generates high-converting ad creatives using psychological triggers.
-    Uses maximum randomization to ensure different results every time.
-    Implements professional prompting techniques.
+    Generates ad creatives: copy (LLM) + images, with randomization and DB/R2 save.
+
+    Sections:
+    - Init & config: output dir, local save, niche cache
+    - Niche & strategy: get niche data, compatible strategies, hooks, visuals
+    - CTAs & numbers: generate CTAs, prices, niche numbers
+    - Copy prompt: _build_copy_prompt (angle × concept, frameworks)
+    - Image prompt: _build_image_prompt, _refine_image_prompt
+    - Public: generate_ad, generate_ad_with_matrix, generate_ad_extensive, generate_batch
+    - Matrix: _build_matrix_ad_prompt, _build_matrix_image_prompt
+    - Refine: refine_custom_angle_or_concept
     """
-    
-    # ========================================================================
-    # INITIALIZATION & UTILITY METHODS
-    # ========================================================================
+
+    # --- Init & config ---
     
     def __init__(self):
         """Initialize the generator."""
@@ -176,6 +178,8 @@ class AdGenerator:
     # DATA RETRIEVAL & CACHING METHODS
     # ========================================================================
     
+    # --- Niche & strategy ---
+
     def _get_niche_data(self, niche: str) -> Dict[str, Any]:
         """Load data for a specific niche (cached for performance)."""
         if niche not in NICHE_DATA:
@@ -428,45 +432,13 @@ class AdGenerator:
     # NICHE & CONTENT CONFIGURATION METHODS
     # ========================================================================
     
+    # --- CTAs & numbers ---
+
     def _get_niche_specific_guidance(self, niche: str) -> str:
         """Get niche-specific guidance for the prompt."""
         niche_data = self._get_niche_data(niche)
         return niche_data.get("niche_guidance", "")
     
-    async def _get_framework_hook_examples_async(self, framework_key: str, niche: Optional[str] = None) -> List[str]:
-        """
-        Get hook examples for a framework. Uses AI generation when enabled, else static from frameworks.py.
-        Falls back to static examples on AI failure or when use_ai_generated_hooks is False.
-        """
-        if not getattr(settings, "use_ai_generated_hooks", False):
-            return get_framework_hook_examples(framework_key, niche)
-        framework = get_framework(framework_key)
-        if not framework:
-            return get_framework_hook_examples(framework_key, niche)
-        niche_label = (niche or "").replace("_", " ").title() or "general advertising"
-        prompt = f"""Generate 6 to 8 short ad hook examples (headline-style phrases) for this ad framework.
-
-Framework: {framework.get('name', framework_key)}
-Description: {framework.get('description', '')}
-Tone: {framework.get('tone', '')}
-Headline style: {framework.get('headline_style', '')}
-Niche/context: {niche_label}
-
-Rules:
-- Each hook must be one short phrase or sentence (under 12 words).
-- Match the framework's tone and style.
-- Make them punchy and scroll-stopping; no generic filler.
-- Return ONLY a JSON object with one key "hooks" containing an array of strings. No other text."""
-
-        try:
-            result = await llm_service.generate_json(prompt=prompt, temperature=0.8)
-            hooks = result.get("hooks") if isinstance(result, dict) else None
-            if isinstance(hooks, list) and len(hooks) > 0:
-                return [str(h).strip() for h in hooks if h]
-        except Exception:
-            pass
-        return get_framework_hook_examples(framework_key, niche)
-    
     async def _generate_ctas_async(
         self, niche: str, framework_name: Optional[str] = None
     ) -> List[str]:
@@ -546,10 +518,8 @@ Rules:
             }
         return {}
     
-    # ========================================================================
-    # PROMPT BUILDING METHODS
-    # ========================================================================
-    
+    # --- Copy prompt ---
+
     def _build_copy_prompt(
         self,
         niche: str,
@@ -559,7 +529,6 @@ Rules:
         creative_direction: str,
         framework: str,
         framework_data: Dict[str, Any],
-        framework_hooks: List[str],
         cta: str,
         trigger_data: Dict[str, Any] = None,
         trigger_combination: Dict[str, Any] = None,
@@ -584,169 +553,13 @@ Rules:
         niche_numbers = self._generate_niche_numbers(niche)
         age_bracket = random.choice(AGE_BRACKETS)
         
-        # Build numbers section from niche number_config type (data-driven)
+        # Numbers and headline formulas from shared prompt content
         num_type = niche_data.get("number_config", {}).get("type", "savings")
-        if num_type == "weight_loss":
-            numbers_section = f"""=== NUMBERS GUIDANCE (WEIGHT LOSS) ===
-You may include specific numbers if they enhance the ad's believability and fit the format:
-- Starting Weight: {niche_numbers['before']}
-- Current Weight: {niche_numbers['after']}
-- Total Lost: {niche_numbers['difference']}
-- Timeframe: {niche_numbers['days']}
-- Sizes Dropped: {niche_numbers['sizes']}
-- Target Age Bracket: {age_bracket['label']}
-
-DECISION: You decide whether to include these numbers based on:
-- The psychological angle (some angles work better with numbers, others without)
-- The psychological strategy (some strategies benefit from specificity, others from emotional appeal)
-- The overall message flow
-
-If including numbers: Use them naturally and make them oddly specific (e.g., "47 lbs" not "50 lbs") for believability.
-If NOT including numbers: Focus on emotional transformation, lifestyle benefits, and outcomes without specific metrics."""
-        else:
-            niche_label = niche.replace("_", " ").upper()
-            numbers_section = f"""=== NUMBERS GUIDANCE ({niche_label}) ===
-You may include specific prices/numbers if they enhance the ad's believability and fit the format:
-- Price Guidance: {price_guidance}
-- Before Price: {niche_numbers['before']}
-- After Price: {niche_numbers['after']}
-- Total Saved: {niche_numbers['difference']}/year
-- Target Age Bracket: {age_bracket['label']}
-
-DECISION: You decide whether to include prices/numbers based on:
-- The psychological angle (some angles benefit from prices, others may not)
-- The psychological strategy (some strategies need specificity, others work better emotionally)
-- The overall message flow and what feels most authentic
-
-If including prices: Use oddly specific amounts (e.g., "$97.33/month" not "$100/month") for maximum believability.
-If NOT including prices: Focus on emotional benefits, problem-solution framing, curiosity gaps, and trust without specific dollar amounts."""
-        
-        # Headline formulas: niche-specific so copy matches the niche (no home-insurance formulas for auto, etc.)
-        if num_type == "weight_loss":
-            headline_formulas = """=== PROVEN WINNING HEADLINE FORMULAS (WEIGHT LOSS) ===
-
-WITH NUMBERS (use if numbers section provided):
-1. THE TRANSFORMATION: Specific weight loss results
-   - "Lost 47 lbs In 90 Days"
-   - "Down 4 Dress Sizes In 8 Weeks"
-   - "From 247 lbs to 168 lbs"
-
-WITHOUT NUMBERS (use if no numbers section):
-1. THE ACCUSATION: Direct accusation about weight struggle
-   - "Still Overweight?"
-   - "Another Failed Diet?"
-   - "Tired Of Hiding Your Body?"
-
-2. THE CURIOSITY GAP: Open loop about weight loss secret
-   - "Thousands Are Losing Weight After THIS"
-   - "Doctors Are Prescribing THIS Instead Of Diets"
-   - "What Hollywood Has Used For Years"
-
-3. THE BEFORE/AFTER: Dramatic transformation proof
-   - "Same Person. 90 Days Apart."
-   - "Is This Even The Same Person?"
-   - "The Transformation That Shocked Everyone"
-
-4. THE IDENTITY CALLOUT: Target demographics
-   - "Women Over 40: This Changes Everything"
-   - "If You've Tried Every Diet And Failed..."
-   - "For People Who've Struggled For Years"
-
-5. THE MEDICAL AUTHORITY: Doctor/FDA credibility
-   - "FDA-Approved Weight Loss"
-   - "Doctor-Prescribed. Clinically Proven."
-   - "What Doctors Prescribe Their Own Families\""""
-        elif niche == "auto_insurance":
-            headline_formulas = """=== PROVEN WINNING HEADLINE FORMULAS (AUTO INSURANCE) ===
-
-WITH NUMBERS (use if numbers section provided):
-1. THE SPECIFIC PRICE ANCHOR: Oddly specific = believable
-   - "Car Insurance for as low as $29/month"
-   - "Drivers Won't Have To Pay More Than $39 A Month"
-
-2. THE BEFORE/AFTER PROOF: Savings with evidence
-   - "WAS: $1,842 → NOW: $647"
-   - "The Easiest Way To Cut Car Insurance Bills"
-
-WITHOUT NUMBERS (use if no numbers section):
-1. THE ACCUSATION: Direct accusation about overpaying
-   - "OVERPAYING?"
-   - "Still Overpaying For Car Insurance?"
-   - "Wasting Money On Auto Insurance?"
-
-2. THE CURIOSITY GAP: Open loop that demands click
-   - "Drivers Are Ditching Their Auto Insurance & Doing This Instead"
-   - "Thousands of drivers are dropping insurance after THIS"
-   - "Why Are Drivers Switching?"
-
-3. THE IDENTITY CALLOUT: Target demographics (drivers, not "seniors" or "homeowners")
-   - "Drivers Over 50: Check Your Eligibility"
-   - "Safe Drivers: Check Your Rate"
-
-4. THE AUTHORITY TRANSFER: Government/institutional trust
-   - "State Program Cuts Insurance Costs"
-   - "Official: Safe Drivers Qualify For Reduced Rates"
-
-5. THE EMOTIONAL BENEFIT: Focus on outcomes
-   - "Protect What Matters Most"
-   - "Finally, Peace of Mind On The Road"
-   - "Drive Confident Knowing You're Covered\""""
-        else:
-            headline_formulas = """=== PROVEN WINNING HEADLINE FORMULAS (HOME INSURANCE) ===
-
-WITH NUMBERS (use if numbers section provided):
-1. THE SPECIFIC PRICE ANCHOR: Oddly specific = believable
-   - "Home Insurance for as low as $97.33/month"
-   - "Seniors Won't Have To Pay More Than $49 A Month"
-
-2. THE BEFORE/AFTER PROOF: Savings with evidence
-   - "WAS: $1,701 → NOW: $583"
-   - "The Easiest Way To Cut Home Insurance Bills"
-
-WITHOUT NUMBERS (use if no numbers section):
-1. THE ACCUSATION: Direct accusation about overpaying
-   - "OVERPAYING?"
-   - "Still Underinsured?"
-   - "Wasting Money On Insurance?"
-
-2. THE CURIOSITY GAP: Open loop that demands click
-   - "Seniors Are Ditching Home Insurance & Doing This Instead"
-   - "Thousands of homeowners are dropping insurance after THIS"
-   - "Why Are Homeowners Switching?"
-
-3. THE IDENTITY CALLOUT: Target demographics
-   - "Homeowners Over 50: Check Your Eligibility"
-   - "Senior homeowners over the age of 50..."
-
-4. THE AUTHORITY TRANSFER: Government/institutional trust
-   - "State Farm Brings Welfare!"
-   - "Sponsored by the US Government"
-
-5. THE EMOTIONAL BENEFIT: Focus on outcomes
-   - "Protect What Matters Most"
-   - "Finally, Peace of Mind"
-   - "Sleep Better Knowing You're Covered\""""
-
-        # Build trending topics section if available
-        trending_section = ""
-        if trending_context:
-            trending_section = f"""
-=== TRENDING TOPICS CONTEXT (INCORPORATE THIS!) ===
-Current Trend: {trending_context}
-
-INSTRUCTIONS FOR USING TRENDING TOPICS:
-- Subtly reference or tie the ad message to this trending topic
-- Make the connection feel natural, not forced
-- Use the trend to create urgency or relevance ("Everyone's talking about...")
-- The trend should enhance the hook, not overshadow the core message
-- Examples:
-  * "With [trend], now is the perfect time to..."
-  * "While everyone's focused on [trend], don't forget about..."
-  * "Just like [trend], your [product benefit]..."
-  * Reference the trend indirectly in the hook or primary text
-
-NOTE: The trend adds timeliness and relevance. Use it strategically!
-"""
+        numbers_section = get_numbers_section(
+            niche, num_type, niche_numbers, age_bracket, price_guidance
+        )
+        headline_formulas = get_headline_formulas(niche, num_type)
+        trending_section = get_trending_section(trending_context)
 
         prompt = f"""You are an elite direct-response copywriter who has reverse-engineered hundreds of 7-8 figure Facebook ad campaigns. You understand the psychology of scroll-stopping creatives that bypass ad-blindness and trigger immediate emotional response.
 
@@ -756,7 +569,7 @@ ADVERTISING FRAMEWORK: {framework}
 FRAMEWORK DESCRIPTION: {framework_data.get('description', '')}
 FRAMEWORK TONE: {framework_data.get('tone', '')}
 FRAMEWORK VISUAL STYLE: {framework_data.get('visual_style', '')}
-FRAMEWORK HOOK EXAMPLES: {', '.join(framework_hooks[:3]) if framework_hooks else 'N/A'}
+FRAMEWORK HEADLINE STYLE: {framework_data.get('headline_style', '') or 'N/A'}
 CREATIVE DIRECTION: {creative_direction}
 CALL-TO-ACTION: {cta}
 {trending_section}
@@ -802,7 +615,6 @@ Incorporate these power words naturally: {', '.join(power_words) if power_words
 
 === HOOK INSPIRATION (create your own powerful variation) ===
 {chr(10).join(f'- "{hook}"' for hook in hooks)}
-FRAMEWORK HOOK EXAMPLES: {', '.join(framework_hooks[:5]) if framework_hooks else 'N/A'}
 
 {niche_guidance}
 
@@ -845,7 +657,7 @@ Create a SCROLL-STOPPING Facebook ad for {niche.replace("_", " ").upper()} using
    - {f"If document-style framework (e.g. memo, email): Include readable, properly formatted text related to {niche.replace('_', ' ').title()}." if 'document_style' in framework_data.get('tags', []) else ""}
    - FOR AUTO INSURANCE: Describe ONLY one of these ad-format layouts: official notification (seal, rate buttons), social post card, rate/seniors table, before/after split (price boxes + split car if any), coverage tier panels, car brand grid, gift card CTA, or savings/urgency (yellow, CONTACT US). Do NOT describe testimonial portraits, couples, speech bubbles, quote bubbles, or people holding documents. Do NOT describe elderly or senior people. Typography, layout, prices, and buttons only. All text in the image must be readable and correctly spelled (e.g. OVERPAYING not OVERDRPAYING); no gibberish.
    - FOR HOME INSURANCE: Show person with document, savings proof, home setting. People 30-60, relatable homeowners.
-   - FOR GLP-1: Use VARIETY - show different visual types: quiz interfaces, doctor/medical settings, person on scale, mirror reflections, lifestyle moments, confidence scenes, testimonial portraits, celebrity references, or before/after (only when strategy calls for it). People aged 30-50, not elderly.
+   - FOR GLP-1: REQUIRED - every image brief MUST describe either (1) a GLP-1 medication bottle or pen visible in the scene (e.g. Ozempic, Wegovy, Mounjaro, Zepbound pen or box), OR (2) the text "GLP-1" or a medication name (e.g. Ozempic, Wegovy) visible on a label, screen, document, or surface. Use VARIETY in visual types: quiz interfaces, doctor/medical settings, person on scale, mirror reflections, lifestyle moments, confidence scenes, testimonial portraits, celebrity references, or before/after (only when strategy calls for it). People aged 30-50, not elderly.
 
 === PSYCHOLOGICAL PRINCIPLES ===
 - Loss Aversion: Make them feel what they're losing/missing
@@ -878,7 +690,9 @@ Create a SCROLL-STOPPING Facebook ad for {niche.replace("_", " ").upper()} using
 Generate the ad copy now for {niche.replace("_", " ").upper()}. Make it look like ORGANIC CONTENT that triggers IMMEDIATE emotional response."""
 
         return prompt
-    
+
+    # --- Image prompt ---
+
     def _build_image_prompt(
         self,
         niche: str,
@@ -890,12 +704,14 @@ Generate the ad copy now for {niche.replace("_", " ").upper()}. Make it look lik
         composition: str,
         visual_style_data: Optional[Dict[str, Any]] = None,
         niche_visual_guidance_data: Optional[Dict[str, Any]] = None,
+        trending_context: Optional[str] = None,
     ) -> str:
         """
         Build professional image generation prompt.
         Uses detailed specifications, style guidance, and negative prompts.
         Creates AUTHENTIC, ORGANIC CONTENT aesthetic.
         Text (if included) should be part of the natural scene, NOT an overlay.
+        When trending_context is set, mood and atmosphere align with the current occasion.
         """
         image_brief = ad_copy.get("image_brief", "")
         headline = ad_copy.get("headline", "")
@@ -952,7 +768,7 @@ Generate the ad copy now for {niche.replace("_", " ").upper()}. Make it look lik
         ]
         text_color = random.choice(text_colors)
         
-        # Niche-specific image guidance (for auto_insurance: no forced subjects/props; people and cars optional)
+        # Niche-specific image guidance (for auto_insurance: no forced subjects/props; for GLP-1: bottle or name required)
         if niche == "auto_insurance":
             niche_data = self._get_niche_data(niche)
             niche_image_guidance = (niche_data.get("image_guidance", "") + """
@@ -960,6 +776,12 @@ Generate the ad copy now for {niche.replace("_", " ").upper()}. Make it look lik
 PEOPLE, FACES, AND CARS ARE OPTIONAL. Only include them when the VISUAL SCENE description explicitly mentions them. Most ad formats are typography, layout, and buttons only.
 NO fake or made-up brand/company names (no gibberish); use generic text only or omit. NO in-car dashboard mockups or screens inside car interiors; stick to the 8 defined ad formats only."""
             )
+        elif niche == "glp1":
+            niche_data = self._get_niche_data(niche)
+            niche_image_guidance = (niche_data.get("image_guidance", "") + """
+
+CRITICAL - GLP-1 PRODUCT VISIBILITY: The image MUST show at least one of: (1) A GLP-1 medication bottle or injectable pen (e.g. Ozempic, Wegovy, Mounjaro, Zepbound) in the scene, OR (2) The text "GLP-1" or a medication name (Ozempic, Wegovy, Mounjaro, etc.) visible on a label, screen, document, or surface. Do not generate a GLP-1 ad image without the product or name visible."""
+            )
         elif niche_visual_guidance_data and isinstance(niche_visual_guidance_data, dict):
             niche_image_guidance = f"""
 NICHE REQUIREMENTS ({niche.replace("_", " ").title()}):
@@ -1149,6 +971,7 @@ MOOD: {visual_mood} - {"trustworthy, clear, high-contrast" if is_auto_insurance_
 CAMERA: {camera_angle} - documentary/candid feel
 LIGHTING: {lighting} - natural, not studio-polished
 COMPOSITION: {composition}
+{get_trending_image_guidance(trending_context)}
 
 {niche_image_guidance}
 
@@ -1214,7 +1037,7 @@ CRITICAL REQUIREMENTS:
         # Refine and clean the prompt before sending (pass niche for demographic fixes)
         refined_prompt = self._refine_image_prompt(prompt, niche=niche)
         return refined_prompt
-    
+
     def _refine_image_prompt(self, prompt: str, niche: str = None) -> str:
         """
         Refine and clean the image prompt for affiliate marketing creatives.
@@ -1392,7 +1215,9 @@ CRITICAL REQUIREMENTS:
             prompt += '.'
         
         return prompt
-    
+
+    # --- Public: single ad (standard) ---
+
     async def generate_ad(
         self,
         niche: str,
@@ -1455,8 +1280,6 @@ CRITICAL REQUIREMENTS:
         creative_direction = random.choice(niche_data["creative_directions"])
         visual_mood = random.choice(niche_data["visual_moods"])
         
-        # Framework hook examples: AI-generated when enabled, else static from frameworks.py
-        framework_hooks = await self._get_framework_hook_examples_async(framework_key, niche)
         ctas = await self._generate_ctas_async(niche, framework_data.get("name"))
         cta = random.choice(ctas) if ctas else "Learn More"
         
@@ -1486,12 +1309,9 @@ CRITICAL REQUIREMENTS:
         if use_trending and trend_monitor_available:
             try:
                 if not trending_context:
-                    # Auto-fetch current trends
-                    print("📰 Fetching current trending topics...")
-                    trends_data = await asyncio.to_thread(
-                        trend_monitor.get_relevant_trends_for_niche,
-                        niche.replace("_", " ").title()
-                    )
+                    # Auto-fetch current trends (occasions + news); occasions are date-based (e.g. Valentine's Week)
+                    print("📰 Fetching current trending topics (occasions + news)...")
+                    trends_data = await trend_monitor.get_relevant_trends_for_niche(niche)
                     if trends_data and trends_data.get("relevant_trends"):
                         # Use top trend for context
                         top_trend = trends_data["relevant_trends"][0]
@@ -1526,7 +1346,6 @@ CRITICAL REQUIREMENTS:
             creative_direction=creative_direction,
             framework=framework,
             framework_data=framework_data,
-            framework_hooks=framework_hooks,
             cta=cta,
             trigger_data=trigger_data,
             trigger_combination=trigger_combination,
@@ -1552,7 +1371,7 @@ CRITICAL REQUIREMENTS:
         # Generate image(s) with professional prompt - PARALLELIZED
         async def generate_single_image(image_index: int):
             """Helper function to generate a single image with all processing."""
-            # Build image prompt with all parameters
+            # Build image prompt with all parameters (include trending context so images match the occasion)
             image_prompt = self._build_image_prompt(
                 niche=niche,
                 ad_copy=ad_copy,
@@ -1563,6 +1382,7 @@ CRITICAL REQUIREMENTS:
                 composition=composition,
                 visual_style_data=visual_style_data,
                 niche_visual_guidance_data=niche_visual_guidance_data,
+                trending_context=trending_context if use_trending else None,
             )
             
             # Store the refined prompt for database saving
@@ -1732,7 +1552,9 @@ CRITICAL REQUIREMENTS:
         }
         
         return result
-    
+
+    # --- Public: matrix ad ---
+
     async def generate_ad_with_matrix(
         self,
         niche: str,
@@ -2075,6 +1897,8 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
             },
         }
     
+    # --- Public: extensive flow ---
+
     async def generate_ad_extensive(
         self,
         niche: str,
@@ -2088,6 +1912,7 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
         """
         Generate ad using extensive: researcher → creative director → designer → copywriter.
         Works for any niche: home_insurance, glp1, auto_insurance, or custom (e.g. from 'others').
+        Motivators are auto-generated per strategy.
         
         Args:
             niche: Target niche (home_insurance, glp1, auto_insurance, or custom display name when 'others')
@@ -2144,7 +1969,19 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
             )
         )
         
-        # Step 3: Creative Director
+        # Step 2b: Generate motivators from research for strategy making
+        print("💡 Step 2b: Generating motivators from research for strategy making...")
+        motivators_from_research = await third_flow_service.generate_motivators_for_research(
+            researcher_output=researcher_output,
+            niche=niche_display,
+            target_audience=target_audience,
+            offer=offer,
+            count_per_item=4,
+        )
+        if motivators_from_research:
+            print(f"    Generated {len(motivators_from_research)} motivators for creative director")
+        
+        # Step 3: Creative Director (with motivators for strategy making)
         print(f"🎨 Step 3: Creating {num_strategies} creative strategy/strategies...")
         print(f"📋 Parameters: num_strategies={num_strategies}, num_images={num_images}")
         creative_strategies = await asyncio.to_thread(
@@ -2155,7 +1992,8 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
             target_audience=target_audience,
             offer=offer,
             niche=niche_display,
-            n=num_strategies
+            n=num_strategies,
+            motivators=motivators_from_research if motivators_from_research else None,
         )
         
         if not creative_strategies:
@@ -2165,6 +2003,37 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
         creative_strategies = creative_strategies[:num_strategies]
         print(f"📊 Using {len(creative_strategies)} strategy/strategies (requested: {num_strategies})")
         
+        # Step 3b: Get motivator per strategy (from strategy if assigned by director, else generate)
+        print(f"💡 Step 3b: Resolving motivators for each strategy...")
+        strategies_needing_motivators = [
+            (idx, s) for idx, s in enumerate(creative_strategies)
+            if not s.motivators or len(s.motivators) == 0
+        ]
+        generated_motivators: dict[int, str | None] = {}
+        if strategies_needing_motivators:
+            gen_tasks = [
+                third_flow_service.generate_motivators_for_strategy(
+                    strategy=s, niche=niche_display,
+                    target_audience=target_audience, offer=offer, count=6,
+                )
+                for _, s in strategies_needing_motivators
+            ]
+            gen_results = await asyncio.gather(*gen_tasks)
+            for (idx, _), motivators in zip(strategies_needing_motivators, gen_results):
+                generated_motivators[idx] = motivators[0] if motivators else None
+        motivators_per_strategy = []
+        for idx, strategy in enumerate(creative_strategies):
+            if strategy.motivators and len(strategy.motivators) > 0:
+                m = strategy.motivators[0]
+                motivators_per_strategy.append(m)
+                if m:
+                    print(f"    Strategy {idx + 1} (from director): \"{m[:60]}...\"" if len(m) > 60 else f"    Strategy {idx + 1} (from director): \"{m}\"")
+            else:
+                sel = generated_motivators.get(idx)
+                motivators_per_strategy.append(sel)
+                if sel:
+                    print(f"    Strategy {idx + 1} (generated): \"{sel[:60]}...\"" if len(sel) > 60 else f"    Strategy {idx + 1} (generated): \"{sel}\"")
+        
         # Step 4: Process strategies in parallel (designer + copywriter) - Optimized: use asyncio.to_thread instead of ThreadPoolExecutor
         print(f"⚡ Step 4: Processing {len(creative_strategies)} strategies in parallel...")
         
@@ -2173,9 +2042,10 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
             asyncio.to_thread(
                 third_flow_service.process_strategy,
                 strategy,
-                niche=niche_display
+                niche=niche_display,
+                selected_motivator=motivators_per_strategy[idx] if idx < len(motivators_per_strategy) else None,
             )
-            for strategy in creative_strategies
+            for idx, strategy in enumerate(creative_strategies)
         ]
         strategy_results = await asyncio.gather(*strategy_tasks)
         
@@ -2394,6 +2264,8 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
     # CUSTOM ANGLE/CONCEPT REFINEMENT
     # ========================================================================
     
+    # --- Refine custom angle/concept ---
+
     async def refine_custom_angle_or_concept(
         self,
         text: str,
@@ -2528,10 +2400,8 @@ Return JSON:
             result["original_text"] = text
             return result
     
-    # ========================================================================
-    # MATRIX-SPECIFIC PROMPT METHODS
-    # ========================================================================
-    
+    # --- Matrix prompt builders ---
+
     def _build_matrix_ad_prompt(
         self,
         niche: str,
@@ -2745,7 +2615,9 @@ If this image includes people or faces, they MUST look like real, original peopl
         # Refine and clean the prompt before sending (pass niche for demographic fixes)
         refined_prompt = self._refine_image_prompt(prompt, niche=niche)
         return refined_prompt
-    
+
+    # --- Public: batch ---
+
     async def generate_batch(
         self,
         niche: str,

services/generator_prompts.py

@@ -0,0 +1,204 @@
+"""
+Prompt content and section builders for the ad generator.
+Keeps long copy-prompt strings out of the main generator class.
+"""
+
+from typing import Dict, Any, Optional
+
+# -----------------------------------------------------------------------------
+# Headline formulas by niche / number type
+# -----------------------------------------------------------------------------
+
+HEADLINE_FORMULAS_WEIGHT_LOSS = """=== PROVEN WINNING HEADLINE FORMULAS (WEIGHT LOSS) ===
+
+WITH NUMBERS (use if numbers section provided):
+1. THE TRANSFORMATION: Specific weight loss results
+   - "Lost 47 lbs In 90 Days"
+   - "Down 4 Dress Sizes In 8 Weeks"
+   - "From 247 lbs to 168 lbs"
+
+WITHOUT NUMBERS (use if no numbers section):
+1. THE ACCUSATION: Direct accusation about weight struggle
+   - "Still Overweight?"
+   - "Another Failed Diet?"
+   - "Tired Of Hiding Your Body?"
+
+2. THE CURIOSITY GAP: Open loop about weight loss secret
+   - "Thousands Are Losing Weight After THIS"
+   - "Doctors Are Prescribing THIS Instead Of Diets"
+   - "What Hollywood Has Used For Years"
+
+3. THE BEFORE/AFTER: Dramatic transformation proof
+   - "Same Person. 90 Days Apart."
+   - "Is This Even The Same Person?"
+   - "The Transformation That Shocked Everyone"
+
+4. THE IDENTITY CALLOUT: Target demographics
+   - "Women Over 40: This Changes Everything"
+   - "If You've Tried Every Diet And Failed..."
+   - "For People Who've Struggled For Years"
+
+5. THE MEDICAL AUTHORITY: Doctor/FDA credibility
+   - "FDA-Approved Weight Loss"
+   - "Doctor-Prescribed. Clinically Proven."
+   - "What Doctors Prescribe Their Own Families\""""
+
+HEADLINE_FORMULAS_AUTO_INSURANCE = """=== PROVEN WINNING HEADLINE FORMULAS (AUTO INSURANCE) ===
+
+WITH NUMBERS (use if numbers section provided):
+1. THE SPECIFIC PRICE ANCHOR: Oddly specific = believable
+   - "Car Insurance for as low as $29/month"
+   - "Drivers Won't Have To Pay More Than $39 A Month"
+
+2. THE BEFORE/AFTER PROOF: Savings with evidence
+   - "WAS: $1,842 → NOW: $647"
+   - "The Easiest Way To Cut Car Insurance Bills"
+
+WITHOUT NUMBERS (use if no numbers section):
+1. THE ACCUSATION: Direct accusation about overpaying
+   - "OVERPAYING?"
+   - "Still Overpaying For Car Insurance?"
+   - "Wasting Money On Auto Insurance?"
+
+2. THE CURIOSITY GAP: Open loop that demands click
+   - "Drivers Are Ditching Their Auto Insurance & Doing This Instead"
+   - "Thousands of drivers are dropping insurance after THIS"
+   - "Why Are Drivers Switching?"
+
+3. THE IDENTITY CALLOUT: Target demographics (drivers, not "seniors" or "homeowners")
+   - "Drivers Over 50: Check Your Eligibility"
+   - "Safe Drivers: Check Your Rate"
+
+4. THE AUTHORITY TRANSFER: Government/institutional trust
+   - "State Program Cuts Insurance Costs"
+   - "Official: Safe Drivers Qualify For Reduced Rates"
+
+5. THE EMOTIONAL BENEFIT: Focus on outcomes
+   - "Protect What Matters Most"
+   - "Finally, Peace of Mind On The Road"
+   - "Drive Confident Knowing You're Covered\""""
+
+HEADLINE_FORMULAS_HOME_INSURANCE = """=== PROVEN WINNING HEADLINE FORMULAS (HOME INSURANCE) ===
+
+WITH NUMBERS (use if numbers section provided):
+1. THE SPECIFIC PRICE ANCHOR: Oddly specific = believable
+   - "Home Insurance for as low as $97.33/month"
+   - "Seniors Won't Have To Pay More Than $49 A Month"
+
+2. THE BEFORE/AFTER PROOF: Savings with evidence
+   - "WAS: $1,701 → NOW: $583"
+   - "The Easiest Way To Cut Home Insurance Bills"
+
+WITHOUT NUMBERS (use if no numbers section):
+1. THE ACCUSATION: Direct accusation about overpaying
+   - "OVERPAYING?"
+   - "Still Underinsured?"
+   - "Wasting Money On Insurance?"
+
+2. THE CURIOSITY GAP: Open loop that demands click
+   - "Seniors Are Ditching Home Insurance & Doing This Instead"
+   - "Thousands of homeowners are dropping insurance after THIS"
+   - "Why Are Homeowners Switching?"
+
+3. THE IDENTITY CALLOUT: Target demographics
+   - "Homeowners Over 50: Check Your Eligibility"
+   - "Senior homeowners over the age of 50..."
+
+4. THE AUTHORITY TRANSFER: Government/institutional trust
+   - "State Farm Brings Welfare!"
+   - "Sponsored by the US Government"
+
+5. THE EMOTIONAL BENEFIT: Focus on outcomes
+   - "Protect What Matters Most"
+   - "Finally, Peace of Mind"
+   - "Sleep Better Knowing You're Covered\""""
+
+
+def get_headline_formulas(niche: str, num_type: str) -> str:
+    """Return the headline formulas block for the given niche and number type."""
+    if num_type == "weight_loss":
+        return HEADLINE_FORMULAS_WEIGHT_LOSS
+    if niche == "auto_insurance":
+        return HEADLINE_FORMULAS_AUTO_INSURANCE
+    return HEADLINE_FORMULAS_HOME_INSURANCE
+
+
+def get_numbers_section(
+    niche: str,
+    num_type: str,
+    niche_numbers: Dict[str, str],
+    age_bracket: Dict[str, str],
+    price_guidance: str,
+) -> str:
+    """Build the numbers guidance section for the copy prompt."""
+    if num_type == "weight_loss":
+        return f"""=== NUMBERS GUIDANCE (WEIGHT LOSS) ===
+You may include specific numbers if they enhance the ad's believability and fit the format:
+- Starting Weight: {niche_numbers['before']}
+- Current Weight: {niche_numbers['after']}
+- Total Lost: {niche_numbers['difference']}
+- Timeframe: {niche_numbers['days']}
+- Sizes Dropped: {niche_numbers['sizes']}
+- Target Age Bracket: {age_bracket['label']}
+
+DECISION: You decide whether to include these numbers based on:
+- The psychological angle (some angles work better with numbers, others without)
+- The psychological strategy (some strategies benefit from specificity, others from emotional appeal)
+- The overall message flow
+
+If including numbers: Use them naturally and make them oddly specific (e.g., "47 lbs" not "50 lbs") for believability.
+If NOT including numbers: Focus on emotional transformation, lifestyle benefits, and outcomes without specific metrics."""
+
+    niche_label = niche.replace("_", " ").upper()
+    return f"""=== NUMBERS GUIDANCE ({niche_label}) ===
+You may include specific prices/numbers if they enhance the ad's believability and fit the format:
+- Price Guidance: {price_guidance}
+- Before Price: {niche_numbers['before']}
+- After Price: {niche_numbers['after']}
+- Total Saved: {niche_numbers['difference']}/year
+- Target Age Bracket: {age_bracket['label']}
+
+DECISION: You decide whether to include prices/numbers based on:
+- The psychological angle (some angles benefit from prices, others may not)
+- The psychological strategy (some strategies need specificity, others work better emotionally)
+- The overall message flow and what feels most authentic
+
+If including prices: Use oddly specific amounts (e.g., "$97.33/month" not "$100/month") for maximum believability.
+If NOT including prices: Focus on emotional benefits, problem-solution framing, curiosity gaps, and trust without specific dollar amounts."""
+
+
+def get_trending_section(trending_context: Optional[str]) -> str:
+    """Build the trending topics section when context is provided."""
+    if not trending_context:
+        return ""
+    return f"""
+=== TRENDING TOPICS CONTEXT (INCORPORATE THIS!) ===
+Current Trend: {trending_context}
+
+INSTRUCTIONS FOR USING TRENDING TOPICS:
+- Subtly reference or tie the ad message to this trending topic
+- Make the connection feel natural, not forced
+- Use the trend to create urgency or relevance ("Everyone's talking about...")
+- The trend should enhance the hook, not overshadow the core message
+- Examples:
+  * "With [trend], now is the perfect time to..."
+  * "While everyone's focused on [trend], don't forget about..."
+  * "Just like [trend], your [product benefit]..."
+  * Reference the trend indirectly in the hook or primary text
+
+NOTE: The trend adds timeliness and relevance. Use it strategically!
+"""
+
+
+def get_trending_image_guidance(trending_context: Optional[str]) -> str:
+    """Build image-prompt guidance so visuals reflect the current occasion. Returns empty string if no context."""
+    if not trending_context or not trending_context.strip():
+        return ""
+    return f"""
+=== CURRENT OCCASION (reflect in mood and atmosphere) ===
+Occasion: {trending_context.strip()}
+
+- Align the image mood and atmosphere with this occasion (e.g. warm and thoughtful for Valentine's/gifts, cozy for holidays, fresh for New Year).
+- Use subtle visual cues: lighting, color warmth, and setting that feel timely and relevant, without literal props unless they fit the ad (e.g. no forced teddy bears or hearts unless the scene naturally calls for it).
+- The image should feel "of the moment" and relevant to the trend, not generic.
+"""

services/third_flow.py

@@ -141,6 +141,55 @@ class ThirdFlowService:
             print(f"Error in researcher: {e}")
             return []
 
+    async def generate_motivators_for_research(
+        self,
+        researcher_output: List[ImageAdEssentials],
+        niche: str,
+        target_audience: str | None,
+        offer: str | None,
+        count_per_item: int = 4,
+    ) -> list[str]:
+        """
+        Generate emotional motivators from researcher output for use in strategy making.
+        Produces motivators for each research item (psychology trigger + angles + concepts).
+        """
+        if not researcher_output:
+            return []
+        niche_key = niche.lower().replace(" ", "_").replace("-", "_")
+        all_motivators: list[str] = []
+        seen: set[str] = set()
+        for item in researcher_output:
+            trigger = item.phsychologyTriggers or ""
+            angles = item.angles or []
+            concepts = item.concepts or []
+            if not angles:
+                angles = [trigger or "benefit"]
+            if not concepts:
+                concepts = ["authentic story"]
+            angle_ctx = {
+                "name": angles[0],
+                "trigger": trigger,
+                "example": angles[0] if len(angles) > 0 else "",
+            }
+            concept_ctx = {
+                "name": concepts[0],
+                "structure": concepts[0],
+                "visual": ", ".join(concepts[:2]) if concepts else "authentic",
+            }
+            motivators = await generate_motivators(
+                niche=niche_key,
+                angle=angle_ctx,
+                concept=concept_ctx,
+                target_audience=target_audience,
+                offer=offer,
+                count=count_per_item,
+            )
+            for m in motivators:
+                if m and m.strip() and m.strip().lower() not in seen:
+                    seen.add(m.strip().lower())
+                    all_motivators.append(m.strip())
+        return all_motivators[:24]  # Cap total for prompt size
+
     async def generate_motivators_for_strategy(
         self,
         strategy: CreativeStrategies,
@@ -398,7 +447,8 @@ class ThirdFlowService:
         target_audience: str,
         offer: str,
         niche: str = "Home Insurance",
-        n: int = 5
+        n: int = 5,
+        motivators: List[str] | None = None,
     ) -> List[CreativeStrategies]:
         """
         Create creative strategies based on research.
@@ -411,6 +461,7 @@ class ThirdFlowService:
             offer: Offer to run
             niche: Niche category
             n: Number of strategies to generate
+            motivators: Emotional motivators (customer's internal voice) to weave into strategies
             
         Returns:
             List of CreativeStrategies
@@ -422,6 +473,18 @@ class ThirdFlowService:
             f"Concepts: {', '.join(item.concepts)}"
             for item in researcher_output
         ])
+        motivators_block = ""
+        if motivators:
+            motivators_str = "\n".join(f"- {m}" for m in motivators[:20])
+            motivators_block = f"""
+EMOTIONAL MOTIVATORS (customer's internal voice - these MUST drive each strategy):
+{motivators_str}
+
+CRITICAL: Each strategy MUST be built around ONE motivator. The motivator is the emotional core—everything else (visual direction, title ideas, body ideas, text overlay) must flow from it.
+- visualDirection: Describe a scene that VISUALLY EXPRESSES the motivator (e.g., fear of loss → family protecting documents; trust → community/social proof; unpreparedness → urgency/planning)
+- titleIdeas: Headlines that echo or evoke the motivator's emotional truth
+- text (if any): Overlay text that hints at the motivator without being on-the-nose
+Assign the chosen motivator to the motivators field. The motivator is non-negotiable—it defines the entire creative."""
         
         messages = [
             {
@@ -459,8 +522,9 @@ class ThirdFlowService:
                         Niche: {niche}
                         Offer to run: {offer}
                         Target Audience: {target_audience}
+                        {motivators_block}
                         
-                        Provide the different creative strategies based on the given input."""
+                        Provide the different creative strategies based on the given input. For each strategy, include in the motivators field the motivator(s) that best fit that strategy."""
                     }
                 ]
             }
@@ -518,15 +582,19 @@ COLOR PREFERENCE: {niche_guidance_data.get('color_preference', 'balanced')}
         CRITICAL: The image MUST be appropriate for {niche} niche.
         """
 
-        motivator_block = (
-            f"\nCORE MOTIVATOR (emotional driver): {selected_motivator}\n"
-            if selected_motivator
-            else ""
-        )
+        motivator_block = ""
+        if selected_motivator:
+            motivator_block = f"""
+PRIMARY DRIVER - CORE MOTIVATOR (the image MUST visually express this emotion):
+"{selected_motivator}"
+
+The motivator is the MAIN creative driver. The image must make a viewer FEEL this emotional truth through composition, expressions, setting, and props. Every element in the image should support conveying this motivator. Do NOT produce a generic scene—the scene must be specifically designed to evoke this emotional response."""
 
+        text_overlay = creative_strategy.text.textToBeWrittern if creative_strategy.text and creative_strategy.text.textToBeWrittern not in (None, "None", "NA", "") else "No text overlay"
         strategy_str = f"""Psychology Trigger: {creative_strategy.phsychologyTrigger}
         Angle: {creative_strategy.angle}
         Concept: {creative_strategy.concept}
+        Text: {text_overlay}
         CTA: {creative_strategy.cta}
         Visual Direction: {creative_strategy.visualDirection}
         {motivator_block}
@@ -543,7 +611,9 @@ COLOR PREFERENCE: {niche_guidance_data.get('color_preference', 'balanced')}
                         Affiliate marketing is a performance-based model where you promote someone else's product or service and earn a commission for each qualified action (click, lead, or sale).
                         In affiliate marketing 'Low-production, realistic images often outperform studio creatives' runs most.
                         
-                        For nano banana image model here's structure for the prompt: [The Hook] + [The Subject] + [The Context/Setting] + [The Technical Polish]
+                        If a CORE MOTIVATOR is provided, it is the PRIMARY driver. Structure the prompt so the image directly conveys that emotional truth—the scene, expressions, props, and composition must all serve that motivator. A generic family-or-house image is not enough; the motivator must differentiate this creative.
+                        
+                        For image model here's structure for the prompt: [The Hook - emotion/motivator] + [The Subject] + [The Context/Setting] + [The Technical Polish]
                         
                         {niche_guidance}
                         
@@ -567,7 +637,7 @@ COLOR PREFERENCE: {niche_guidance_data.get('color_preference', 'balanced')}
                         "type": "text",
                         "text": f"""Following is the creative strategy:
                         {strategy_str}
-                        Provide the image prompt for the given creative strategy. Make sure the prompt follows the NICHE-SPECIFIC REQUIREMENTS above."""
+                        Provide the image prompt. The prompt MUST lead with the motivator's emotion—describe a scene that makes the motivator's feeling unmistakable. Then add subject, setting, and technical polish. Make sure the prompt follows the NICHE-SPECIFIC REQUIREMENTS above."""
                     }
                 ]
             }
@@ -651,16 +721,21 @@ COLOR PREFERENCE: {niche_guidance_data.get('color_preference', 'balanced')}
             CopyWriterOutput with title, body, and description
         """
 
-        motivator_block = (
-            f"\nCORE MOTIVATOR (customer’s internal voice): {selected_motivator}\n"
-            if selected_motivator
-            else ""
-        )
+        motivator_block = ""
+        if selected_motivator:
+            motivator_block = f"""
+PRIMARY DRIVER - CORE MOTIVATOR (the copy MUST speak directly to this emotional truth):
+"{selected_motivator}"
+
+The motivator is the emotional core of the ad. The title should interrupt with this feeling; the body should acknowledge and address it; the description should complete the thought. The reader must feel you understand their internal voice."""
 
         strategy_str = f"""Psychology Trigger: {creative_strategy.phsychologyTrigger}
         Angle: {creative_strategy.angle}
         Concept: {creative_strategy.concept}
         CTA: {creative_strategy.cta}
+        Title Ideas: {creative_strategy.titleIdeas}
+        Caption Ideas: {creative_strategy.captionIdeas}
+        Body Ideas: {creative_strategy.bodyIdeas}
         {motivator_block}
         """
         
@@ -674,6 +749,8 @@ COLOR PREFERENCE: {niche_guidance_data.get('color_preference', 'balanced')}
                         The ad copy must include the title, body and description related to the strategies.
                         Affiliate marketing is a performance-based model where you promote someone else's product or service and earn a commission for each qualified action (click, lead, or sale).
                         
+                        If a CORE MOTIVATOR is provided, it is the PRIMARY driver. The title should evoke that motivator; the body must speak directly to that emotional truth and address it; the description should complete the thought. The motivator differentiates this ad—do not write generic copy.
+                        
                         Role of the Title: Stop the scroll and trigger emotion. 
                         1. The title is not for explaining. It's for interrupting attention. 
                         2. Short titles win because they are scan-friendly. 
@@ -703,7 +780,7 @@ COLOR PREFERENCE: {niche_guidance_data.get('color_preference', 'balanced')}
                         "text": f"""Following is the creative strategy:
                         {strategy_str}
                         
-                        Provide the title, body, and description for the given creative strategy.
+                        Provide the title, body, and description. If a CORE MOTIVATOR is present, center the copy on it—the title should make someone with that thought pause; the body should speak to that specific emotional truth; the description should extend it. Do not write generic insurance copy; the motivator must be unmistakably reflected.
                         
                         IMPORTANT: The body must be 150-250 words long - write a detailed, compelling narrative that tells a story and builds emotional connection with the reader."""
                     }

services/trend_monitor.py

@@ -1,276 +1,141 @@
 """
-Google News Trend Monitor for PsyAdGenesis
-Fetches and analyzes relevant news for Home Insurance and GLP-1 niches
+Trend monitor: current occasions (AI) + niche news (GNews) for ad trending context.
 """
 
 from gnews import GNews
-from typing import List, Dict, Optional
+from typing import List, Dict, Any
 from datetime import datetime, timedelta
 import asyncio
 
-# Niche-specific keywords
+from services.current_occasions import get_current_occasions
+
 NICHE_KEYWORDS = {
-    "home_insurance": [
-        "home insurance", "homeowners insurance", "property insurance",
-        "natural disaster", "hurricane", "wildfire", "flood damage",
-        "insurance rates", "coverage", "home protection"
-    ],
-    "glp1": [
-        "GLP-1", "Ozempic", "Wegovy", "Mounjaro", "Zepbound",
-        "weight loss", "diabetes", "semaglutide", "tirzepatide",
-        "weight loss drug", "obesity treatment"
-    ],
-    "auto_insurance": [
-        "auto insurance", "car insurance", "vehicle insurance",
-        "driving safety", "accident rates", "insurance premiums",
-        "car insurance rates", "driver discounts", "vehicle coverage"
-    ]
+    "home_insurance": ["home insurance", "homeowners insurance", "property insurance", "natural disaster", "insurance rates"],
+    "glp1": ["GLP-1", "Ozempic", "Wegovy", "weight loss", "Mounjaro", "Zepbound"],
+    "auto_insurance": ["auto insurance", "car insurance", "vehicle insurance", "insurance premiums", "driver discounts"],
 }
 
-# Simple in-memory cache
-TREND_CACHE = {}
-CACHE_DURATION = timedelta(hours=1)  # Cache for 1 hour
+TREND_CACHE: Dict[str, tuple] = {}
+CACHE_DURATION = timedelta(hours=1)
+
+TRIGGER_WORDS = [
+    (["crisis", "warning", "danger", "risk", "threat", "disaster"], "Fear"),
+    (["shortage", "limited", "running out", "exclusive", "sold out"], "FOMO"),
+    (["breakthrough", "solution", "cure", "relief", "success"], "Hope"),
+    (["save", "discount", "cheaper", "affordable", "deal"], "Greed"),
+    (["new", "innovation", "discover", "reveal", "secret"], "Curiosity"),
+    (["urgent", "now", "immediate", "breaking"], "Urgency"),
+]
 
 
 class TrendMonitor:
-    """Monitor Google News for trending topics relevant to ad generation"""
-    
     def __init__(self, language: str = "en", country: str = "US"):
         self.google_news = GNews(language=language, country=country)
-        # Set period to last 7 days for freshness
-        self.google_news.period = '7d'
+        self.google_news.period = "7d"
         self.google_news.max_results = 10
-    
+
+    def _normalize_niche(self, niche: str) -> str:
+        key = niche.lower().strip().replace(" ", "_")
+        return key if key in NICHE_KEYWORDS else niche
+
     async def fetch_trends(self, niche: str) -> List[Dict]:
-        """
-        Fetch trending news for a specific niche with caching
-        
-        Args:
-            niche: Target niche (home_insurance or glp1)
-            
-        Returns:
-            List of trend dicts with title, description, date, url, relevance_score
-        """
         cache_key = f"trends_{niche}"
-        
-        # Check cache
         if cache_key in TREND_CACHE:
-            cached_data, cached_time = TREND_CACHE[cache_key]
-            if datetime.now() - cached_time < CACHE_DURATION:
-                print(f"✓ Using cached trends for {niche}")
-                return cached_data
-        
-        # Fetch fresh data
-        print(f"🔍 Fetching fresh trends for {niche}...")
-        trends = await self._fetch_trends_uncached(niche)
-        
-        # Update cache
+            data, cached_at = TREND_CACHE[cache_key]
+            if datetime.now() - cached_at < CACHE_DURATION:
+                return data
+        trends = await self._fetch_news(niche)
         TREND_CACHE[cache_key] = (trends, datetime.now())
-        
         return trends
-    
-    async def _fetch_trends_uncached(self, niche: str) -> List[Dict]:
-        """
-        Fetch trending news without caching
-        
-        Args:
-            niche: Target niche
-            
-        Returns:
-            List of scored and ranked articles
-        """
+
+    async def _fetch_news(self, niche: str) -> List[Dict]:
         if niche not in NICHE_KEYWORDS:
-            raise ValueError(f"Unsupported niche: {niche}. Supported: {list(NICHE_KEYWORDS.keys())}")
-        
-        keywords = NICHE_KEYWORDS[niche]
+            raise ValueError(f"Unsupported niche: {niche}. Use: {list(NICHE_KEYWORDS.keys())}")
+        keywords = NICHE_KEYWORDS[niche][:3]
         all_articles = []
-        
-        # Fetch articles for each keyword (limit to avoid rate limits)
-        for keyword in keywords[:3]:  # Top 3 keywords
+        loop = asyncio.get_event_loop()
+        for kw in keywords:
             try:
-                # Run synchronous GNews call in thread pool
-                loop = asyncio.get_event_loop()
                 articles = await loop.run_in_executor(
-                    None, 
-                    lambda: self.google_news.get_news(keyword)
+                    None, lambda k=kw: self.google_news.get_news(k)
                 )
-                
-                for article in articles:
-                    # Add metadata
-                    article['keyword'] = keyword
-                    article['niche'] = niche
-                    all_articles.append(article)
-                    
+                for a in articles:
+                    a["keyword"] = kw
+                    a["niche"] = niche
+                    all_articles.append(a)
             except Exception as e:
-                print(f"⚠️  Error fetching news for '{keyword}': {e}")
-                continue
-        
+                print(f"⚠️ News fetch failed for '{kw}': {e}")
         if not all_articles:
-            print(f"⚠️  No articles found for {niche}")
             return []
-        
-        # Score and rank by relevance
-        scored_articles = self._score_relevance(all_articles, niche)
-        
-        print(f"✓ Found {len(scored_articles)} articles for {niche}")
-        
-        # Return top 5 most relevant
-        return scored_articles[:5]
-    
-    def _score_relevance(self, articles: List[Dict], niche: str) -> List[Dict]:
-        """
-        Score articles by relevance to niche
-        
-        Args:
-            articles: List of article dicts
-            niche: Target niche
-            
-        Returns:
-            Sorted list with relevance_score added
-        """
+        scored = self._score_articles(all_articles, niche)
+        return scored[:5]
+
+    def _score_articles(self, articles: List[Dict], niche: str) -> List[Dict]:
         keywords = NICHE_KEYWORDS[niche]
-        
-        for article in articles:
-            score = 0
-            text = f"{article.get('title', '')} {article.get('description', '')}".lower()
-            
-            # Keyword matching (more matches = higher score)
-            for keyword in keywords:
-                if keyword.lower() in text:
-                    score += 2
-            
-            # Recency bonus (newer = better)
-            pub_date = article.get('published date')
-            if pub_date:
+        for a in articles:
+            text = f"{a.get('title', '')} {a.get('description', '')}".lower()
+            score = sum(2 for k in keywords if k.lower() in text)
+            pub = a.get("published date")
+            if pub:
                 try:
-                    # Handle datetime object
-                    if isinstance(pub_date, datetime):
-                        days_old = (datetime.now() - pub_date).days
-                    else:
-                        # Try parsing RFC 2822 format first (from RSS feeds)
-                        from email.utils import parsedate_to_datetime
-                        try:
-                            pub_date_obj = parsedate_to_datetime(str(pub_date))
-                        except:
-                            # Fallback to ISO format
-                            pub_date_obj = datetime.fromisoformat(str(pub_date))
-                        days_old = (datetime.now() - pub_date_obj).days
-                    
-                    if days_old <= 1:
-                        score += 5  # Hot news
-                    elif days_old <= 3:
-                        score += 3
-                    elif days_old <= 7:
-                        score += 1
-                except Exception as e:
-                    # Silently skip date parsing errors
+                    from email.utils import parsedate_to_datetime
+                    dt = parsedate_to_datetime(str(pub)) if not isinstance(pub, datetime) else pub
+                    days = (datetime.now() - dt).days
+                    score += 5 if days <= 1 else 3 if days <= 3 else 1
+                except Exception:
                     pass
-            
-            # Emotion triggers (fear, urgency, transformation)
-            emotion_words = [
-                'crisis', 'warning', 'breakthrough', 'new', 'record', 
-                'shortage', 'surge', 'dramatic', 'shocking', 'urgent',
-                'breaking', 'exclusive', 'major', 'critical'
-            ]
-            for word in emotion_words:
+            for word in ["crisis", "warning", "breakthrough", "new", "urgent", "breaking", "major"]:
                 if word in text:
                     score += 1
-            
-            article['relevance_score'] = score
-        
-        # Sort by score descending
-        return sorted(articles, key=lambda x: x.get('relevance_score', 0), reverse=True)
-    
-    def extract_trend_context(self, article: Dict) -> str:
-        """
-        Extract a concise trend context for prompt injection
-        
-        Args:
-            article: Article dict
-            
-        Returns:
-            Concise context string
-        """
-        title = article.get('title', '')
-        description = article.get('description', '')
-        
-        # Create a concise context string
-        context = f"{title}"
-        if description and len(description) < 150:
-            context += f" - {description}"
-        
-        return context.strip()
-    
+            a["relevance_score"] = score
+        return sorted(articles, key=lambda x: x.get("relevance_score", 0), reverse=True)
+
+    def _trigger(self, title: str, description: str) -> str:
+        text = f"{title} {description}".lower()
+        for words, trigger in TRIGGER_WORDS:
+            if any(w in text for w in words):
+                return trigger
+        return "Emotion"
+
+    async def get_relevant_trends_for_niche(self, niche: str) -> Dict[str, Any]:
+        relevant = []
+        for occ in await get_current_occasions():
+            relevant.append({"title": occ["title"], "summary": occ["summary"], "category": occ.get("category", "Occasion")})
+        niche_key = self._normalize_niche(niche)
+        if niche_key in NICHE_KEYWORDS:
+            try:
+                for t in (await self.fetch_trends(niche_key))[:3]:
+                    desc = t.get("description", "") or t.get("title", "")
+                    relevant.append({
+                        "title": t.get("title", ""),
+                        "summary": desc,
+                        "category": t.get("niche", "News").replace("_", " ").title(),
+                    })
+            except Exception as e:
+                print(f"⚠️ News trends skipped: {e}")
+        return {"relevant_trends": relevant}
+
     async def get_trending_angles(self, niche: str) -> List[Dict]:
-        """
-        Generate angle suggestions based on current trends
-        
-        Args:
-            niche: Target niche
-            
-        Returns:
-            List of angle dicts compatible with angle × concept system
-        """
         trends = await self.fetch_trends(niche)
-        
         angles = []
-        for trend in trends[:3]:  # Top 3 trends
-            title = trend.get('title', '')
-            context = self.extract_trend_context(trend)
-            
-            # Analyze trend for psychological trigger
-            trigger = self._detect_trigger(title, trend.get('description', ''))
-            
-            angle = {
+        for t in trends[:3]:
+            title = t.get("title", "")
+            angles.append({
                 "key": f"trend_{abs(hash(title)) % 10000}",
                 "name": f"Trending: {title[:40]}...",
-                "trigger": trigger,
-                "example": context[:100],
+                "trigger": self._trigger(title, t.get("description", "")),
+                "example": (t.get("description") or title)[:100],
                 "category": "Trending",
                 "source": "google_news",
-                "url": trend.get('url'),
+                "url": t.get("url"),
                 "expires": (datetime.now() + timedelta(days=7)).isoformat(),
-                "relevance_score": trend.get('relevance_score', 0)
-            }
-            angles.append(angle)
-        
+                "relevance_score": t.get("relevance_score", 0),
+            })
         return angles
-    
-    def _detect_trigger(self, title: str, description: str) -> str:
-        """
-        Detect psychological trigger from news content
-        
-        Args:
-            title: Article title
-            description: Article description
-            
-        Returns:
-            Trigger name (Fear, Hope, FOMO, etc.)
-        """
-        text = f"{title} {description}".lower()
-        
-        # Trigger detection rules (ordered by priority)
-        if any(word in text for word in ['crisis', 'warning', 'danger', 'risk', 'threat', 'disaster']):
-            return "Fear"
-        elif any(word in text for word in ['shortage', 'limited', 'running out', 'exclusive', 'sold out']):
-            return "FOMO"
-        elif any(word in text for word in ['breakthrough', 'solution', 'cure', 'relief', 'success']):
-            return "Hope"
-        elif any(word in text for word in ['save', 'discount', 'cheaper', 'affordable', 'deal']):
-            return "Greed"
-        elif any(word in text for word in ['new', 'innovation', 'discover', 'reveal', 'secret']):
-            return "Curiosity"
-        elif any(word in text for word in ['urgent', 'now', 'immediate', 'breaking']):
-            return "Urgency"
-        else:
-            return "Emotion"
-    
-    def clear_cache(self):
-        """Clear the trend cache (useful for testing)"""
+
+    def clear_cache(self) -> None:
         global TREND_CACHE
         TREND_CACHE = {}
-        print("✓ Trend cache cleared")
 
 
-# Global instance
 trend_monitor = TrendMonitor()