feat: Enhance ad generation with trending topics integration and bulk export functionality

- Updated API endpoints to include optional parameters for trending topics in ad generation requests.
- Added new endpoint for bulk exporting ads as a ZIP file containing images and an Excel sheet.
- Implemented trend monitoring service to fetch relevant news articles for specified niches.
- Enhanced validation schemas to accommodate new parameters for trending topics.
- Updated generator service to incorporate trending context into ad copy generation.
- Created export service for handling bulk ad exports, including image downloads and Excel file creation.
- Added caching mechanism for trending topics to optimize performance.

data/containers.py

@@ -63,24 +63,24 @@ CONTAINER_TYPES: Dict[str, Dict[str, Any]] = {
             "Include carrier/time info",
         ],
     },
-    "bank_alert": {
-        "name": "Bank Alert",
-        "description": "Bank transaction notification style",
-        "visual_guidance": "Bank transaction notification style, red alert box, bank app UI, urgent notification aesthetic",
-        "font_style": "Arial, Helvetica, system font",
-        "colors": {
-            "primary": "#D32F2F",  # Alert red
-            "secondary": "#1976D2",  # Bank blue
-            "background": "#FFFFFF",
-            "text": "#212121",
-        },
-        "best_for": ["financial urgency", "savings alerts", "money-related offers"],
-        "authenticity_tips": [
-            "Use official-looking format",
-            "Include dollar amounts",
-            "Add bank-style icons",
-        ],
-    },
+    # "bank_alert": {
+    #     "name": "Bank Alert",
+    #     "description": "Bank transaction notification style",
+    #     "visual_guidance": "Bank transaction notification style, red alert box, bank app UI, urgent notification aesthetic",
+    #     "font_style": "Arial, Helvetica, system font",
+    #     "colors": {
+    #         "primary": "#D32F2F",  # Alert red
+    #         "secondary": "#1976D2",  # Bank blue
+    #         "background": "#FFFFFF",
+    #         "text": "#212121",
+    #     },
+    #     "best_for": ["financial urgency", "savings alerts", "money-related offers"],
+    #     "authenticity_tips": [
+    #         "Use official-looking format",
+    #         "Include dollar amounts",
+    #         "Add bank-style icons",
+    #     ],
+    # },
     "news_chyron": {
         "name": "News Chyron",
         "description": "Breaking news ticker style",

frontend/app/gallery/page.tsx

@@ -5,7 +5,7 @@ import { GalleryGrid } from "@/components/gallery/GalleryGrid";
 import { FilterBar } from "@/components/gallery/FilterBar";
 import { Button } from "@/components/ui/Button";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/Card";
-import { listAds, deleteAd } from "@/lib/api/endpoints";
+import { listAds, deleteAd, exportBulkAds } from "@/lib/api/endpoints";
 import { useGalleryStore } from "@/store/galleryStore";
 import { toast } from "react-hot-toast";
 import { Download, Trash2, CheckSquare, Square, ArrowUpDown } from "lucide-react";
@@ -150,6 +150,42 @@ export default function GalleryPage() {
     }
   };
 
+  const handleBulkExport = async () => {
+    if (selectedAds.length === 0) return;
+
+    if (selectedAds.length > 50) {
+      toast.error("Maximum 50 ads can be exported at once");
+      return;
+    }
+
+    const exportToast = toast.loading(`Preparing export for ${selectedAds.length} ad(s)...`);
+
+    try {
+      // Call the export API
+      const blob = await exportBulkAds(selectedAds);
+      
+      // Create download link
+      const url = window.URL.createObjectURL(blob);
+      const link = document.createElement("a");
+      link.href = url;
+      
+      // Generate filename with timestamp
+      const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      link.download = `creatives_export_${timestamp}.zip`;
+      
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+      window.URL.revokeObjectURL(url);
+      
+      toast.success(`Successfully exported ${selectedAds.length} ad(s)`, { id: exportToast });
+      clearSelection();
+    } catch (error: any) {
+      console.error("Export error:", error);
+      toast.error(error.response?.data?.detail || "Failed to export ads", { id: exportToast });
+    }
+  };
+
   const handlePageChange = (newOffset: number) => {
     setOffset(newOffset);
     window.scrollTo({ top: 0, behavior: "smooth" });
@@ -185,6 +221,12 @@ export default function GalleryPage() {
                       <span>Deselect ({selectedAds.length})</span>
                     </div>
                   </Button>
+                  <Button variant="primary" size="sm" onClick={handleBulkExport}>
+                    <div className="flex items-center gap-2">
+                      <Download className="h-4 w-4" />
+                      <span>Export Selected</span>
+                    </div>
+                  </Button>
                   <Button variant="danger" size="sm" onClick={handleBulkDelete}>
                     <div className="flex items-center gap-2">
                       <Trash2 className="h-4 w-4" />

frontend/app/generate/page.tsx

@@ -208,11 +208,17 @@ export default function GeneratePage() {
     }
   };
 
-  const handleStandardGenerate = async (data: { niche: Niche; num_images: number; image_model?: string | null; target_audience?: string; offer?: string }) => {
+  const handleStandardGenerate = async (data: { niche: Niche; num_images: number; image_model?: string | null; target_audience?: string | null; offer?: string | null }) => {
     reset();
     setIsGenerating(true);
     setGenerationStartTime(Date.now());
     
+    const formattedData = {
+      ...data,
+      target_audience: data.target_audience || undefined,
+      offer: data.offer || undefined,
+    };
+
     // If num_images > 1, generate batch of ads
     if (data.num_images > 1) {
       setBatchCount(data.num_images);
@@ -229,13 +235,13 @@ export default function GeneratePage() {
       try {
         // Use batch generation for multiple ads with standard method
         const batchResponse = await generateBatch({
-          niche: data.niche,
-          count: data.num_images,
+          niche: formattedData.niche,
+          count: formattedData.num_images,
           images_per_ad: 1, // Each ad gets 1 image
-          image_model: data.image_model,
+          image_model: formattedData.image_model,
           method: "standard", // Use standard method only
-          target_audience: data.target_audience,
-          offer: data.offer,
+          target_audience: formattedData.target_audience,
+          offer: formattedData.offer,
         });
         const results = batchResponse.ads;
 
@@ -289,10 +295,8 @@ export default function GeneratePage() {
 
         // Generate single ad with 1 image
         const result = await generateAd({
-          ...data,
+          ...formattedData,
           num_images: 1,
-          target_audience: data.target_audience,
-          offer: data.offer,
         });
 
         clearInterval(progressInterval);
@@ -364,8 +368,8 @@ export default function GeneratePage() {
               custom_concept: useCustomConcept ? JSON.stringify(effectiveConcept) : null,
               num_images: 1,
               image_model: imageModel,
-              target_audience: targetAudience || undefined,
-              offer: offer || undefined,
+              target_audience: targetAudience || null,
+              offer: offer || null,
               core_motivator: motivator,
             });
           })
@@ -410,18 +414,18 @@ export default function GeneratePage() {
       try {
         const motivator =
           selectedMotivators.length > 0 ? selectedMotivators[0] : undefined;
-        const result = await generateMatrixAd({
-          niche,
-          angle_key: useCustomAngle ? "custom" : effectiveAngle.key,
-          concept_key: useCustomConcept ? "custom" : effectiveConcept.key,
-          custom_angle: useCustomAngle ? JSON.stringify(effectiveAngle) : null,
-          custom_concept: useCustomConcept ? JSON.stringify(effectiveConcept) : null,
-          num_images: 1,
-          image_model: imageModel,
-          target_audience: targetAudience || undefined,
-          offer: offer || undefined,
-          core_motivator: motivator,
-        });
+    const result = await generateMatrixAd({
+      niche,
+      angle_key: useCustomAngle ? "custom" : effectiveAngle.key,
+      concept_key: useCustomConcept ? "custom" : effectiveConcept.key,
+      custom_angle: useCustomAngle ? JSON.stringify(effectiveAngle) : null,
+      custom_concept: useCustomConcept ? JSON.stringify(effectiveConcept) : null,
+      num_images: 1,
+      image_model: imageModel,
+      target_audience: targetAudience || null,
+      offer: offer || null,
+      core_motivator: motivator,
+    });
 
         setCurrentGeneration(result);
         setProgress({
@@ -445,10 +449,16 @@ export default function GeneratePage() {
     }
   };
 
-  const handleBatchGenerate = async (data: { niche: Niche; count: number; images_per_ad: number; image_model?: string | null; target_audience?: string; offer?: string }) => {
+  const handleBatchGenerate = async (data: { niche: Niche; count: number; images_per_ad: number; image_model?: string | null; target_audience?: string | null; offer?: string | null }) => {
     setBatchResults([]);
     setIsGenerating(true);
     setGenerationStartTime(Date.now());
+    
+    const formattedData = {
+      ...data,
+      target_audience: data.target_audience || undefined,
+      offer: data.offer || undefined,
+    };
     setBatchProgress(0);
     setCurrentBatchIndex(0);
     setBatchCount(data.count);
@@ -478,11 +488,7 @@ export default function GeneratePage() {
     }, progressInterval);
 
     try {
-      const result = await generateBatch({
-        ...data,
-        target_audience: data.target_audience,
-        offer: data.offer,
-      });
+      const result = await generateBatch(formattedData);
       clearInterval(progressIntervalId);
       setBatchResults(result.ads);
       setCurrentBatchIndex(data.count - 1); // Set to last ad
@@ -510,9 +516,9 @@ export default function GeneratePage() {
 
   const handleExtensiveGenerate = async (data: {
     niche: Niche;
-    custom_niche?: string;
-    target_audience?: string;
-    offer?: string;
+    custom_niche?: string | null;
+    target_audience?: string | null;
+    offer?: string | null;
     num_images: number;
     num_strategies: number;
     image_model?: string | null;
@@ -521,6 +527,21 @@ export default function GeneratePage() {
     setIsGenerating(true);
     setGenerationStartTime(Date.now());
     
+    const formattedData: {
+      niche: Niche;
+      custom_niche?: string;
+      target_audience?: string;
+      offer?: string;
+      num_images: number;
+      num_strategies: number;
+      image_model?: string | null;
+    } = {
+      ...data,
+      custom_niche: data.custom_niche || undefined,
+      target_audience: data.target_audience || undefined,
+      offer: data.offer || undefined,
+    };
+    
     // Calculate estimated time based on strategies and images
     // Step 1 (Researcher): ~10-15 seconds
     // Step 2 (Retrieve knowledge): ~15-20 seconds (parallel)
@@ -638,7 +659,7 @@ export default function GeneratePage() {
       });
 
       // Generate ad using extensive - returns BatchResponse like batch flow
-      const result = await generateExtensiveAd(data);
+      const result = await generateExtensiveAd(formattedData);
 
       // Clear progress interval
       if (progressInterval) {
@@ -807,7 +828,7 @@ export default function GeneratePage() {
 
                     <div>
                       <label className="block text-sm font-semibold text-gray-700 mb-2">
-                        Target Audience
+                        Target Audience <span className="text-gray-400 font-normal">(Optional)</span>
                       </label>
                       <input
                         type="text"
@@ -820,7 +841,7 @@ export default function GeneratePage() {
 
                     <div>
                       <label className="block text-sm font-semibold text-gray-700 mb-2">
-                        Offer
+                        Offer <span className="text-gray-400 font-normal">(Optional)</span>
                       </label>
                       <input
                         type="text"

frontend/components/generation/BatchForm.tsx

@@ -12,7 +12,7 @@ import { IMAGE_MODELS } from "@/lib/constants/models";
 import type { Niche } from "@/types/api";
 
 interface BatchFormProps {
-  onSubmit: (data: { niche: Niche; count: number; images_per_ad: number; image_model?: string | null; target_audience?: string; offer?: string }) => Promise<void>;
+  onSubmit: (data: { niche: Niche; count: number; images_per_ad: number; image_model?: string | null; target_audience?: string | null; offer?: string | null }) => Promise<void>;
   isLoading: boolean;
 }
 
@@ -62,7 +62,7 @@ export const BatchForm: React.FC<BatchFormProps> = ({
 
           <div>
             <label className="block text-sm font-semibold text-gray-700 mb-2">
-              Target Audience
+              Target Audience <span className="text-gray-400 font-normal">(Optional)</span>
             </label>
             <input
               type="text"
@@ -77,7 +77,7 @@ export const BatchForm: React.FC<BatchFormProps> = ({
 
           <div>
             <label className="block text-sm font-semibold text-gray-700 mb-2">
-              Offer
+              Offer <span className="text-gray-400 font-normal">(Optional)</span>
             </label>
             <input
               type="text"

frontend/components/generation/ExtensiveForm.tsx

@@ -11,9 +11,9 @@ import type { Niche } from "@/types/api";
 
 const extensiveSchema = z.object({
   niche: z.enum(["home_insurance", "glp1", "others"]),
-  custom_niche: z.string().optional(),
-  target_audience: z.string().optional(),
-  offer: z.string().optional(),
+  custom_niche: z.string().optional().nullable(),
+  target_audience: z.string().optional().nullable(),
+  offer: z.string().optional().nullable(),
   num_images: z.number().min(1).max(3),
   num_strategies: z.number().min(1).max(10),
   image_model: z.string().nullable().optional(),
@@ -35,9 +35,9 @@ type ExtensiveFormData = z.infer<typeof extensiveSchema>;
 interface ExtensiveFormProps {
   onSubmit: (data: {
     niche: Niche;
-    custom_niche?: string;
-    target_audience?: string;
-    offer?: string;
+    custom_niche?: string | null;
+    target_audience?: string | null;
+    offer?: string | null;
     num_images: number;
     num_strategies: number;
     image_model?: string | null;
@@ -111,7 +111,7 @@ export const ExtensiveForm: React.FC<ExtensiveFormProps> = ({
 
           <div>
             <label className="block text-sm font-semibold text-gray-700 mb-2">
-              Target Audience
+              Target Audience <span className="text-gray-400 font-normal">(Optional)</span>
             </label>
             <input
               type="text"
@@ -126,7 +126,7 @@ export const ExtensiveForm: React.FC<ExtensiveFormProps> = ({
 
           <div>
             <label className="block text-sm font-semibold text-gray-700 mb-2">
-              Offer
+              Offer <span className="text-gray-400 font-normal">(Optional)</span>
             </label>
             <input
               type="text"

frontend/components/generation/GenerationForm.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import React from "react";
+import React, { useState } from "react";
 import { useForm } from "react-hook-form";
 import { zodResolver } from "@hookform/resolvers/zod";
 import { generateAdSchema } from "@/lib/utils/validators";
@@ -10,21 +10,45 @@ import { Button } from "@/components/ui/Button";
 import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "@/components/ui/Card";
 import { IMAGE_MODELS } from "@/lib/constants/models";
 import type { Niche } from "@/types/api";
+import { Loader2, TrendingUp, Check } from "lucide-react";
+import apiClient from "@/lib/api/client";
 
 interface GenerationFormProps {
-  onSubmit: (data: { niche: Niche; num_images: number; image_model?: string | null; target_audience?: string; offer?: string }) => Promise<void>;
+  onSubmit: (data: { 
+    niche: Niche; 
+    num_images: number; 
+    image_model?: string | null; 
+    target_audience?: string | null; 
+    offer?: string | null;
+    use_trending?: boolean;
+    trending_context?: string | null;
+  }) => Promise<void>;
   isLoading: boolean;
 }
 
+interface TrendItem {
+  title: string;
+  description: string;
+  url?: string;
+  keyword?: string;
+  relevance_score?: number;
+}
+
 export const GenerationForm: React.FC<GenerationFormProps> = ({
   onSubmit,
   isLoading,
 }) => {
+  const [trends, setTrends] = useState<TrendItem[]>([]);
+  const [selectedTrend, setSelectedTrend] = useState<TrendItem | null>(null);
+  const [isFetchingTrends, setIsFetchingTrends] = useState(false);
+  const [trendsError, setTrendsError] = useState<string | null>(null);
+
   const {
     register,
     handleSubmit,
     formState: { errors },
     watch,
+    setValue,
   } = useForm({
     resolver: zodResolver(generateAdSchema),
     defaultValues: {
@@ -33,10 +57,54 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({
       image_model: null,
       target_audience: "",
       offer: "",
+      use_trending: false,
+      trending_context: "",
     },
   });
 
   const numImages = watch("num_images");
+  const currentNiche = watch("niche");
+  const useTrending = watch("use_trending");
+
+  // Fetch trends when toggle is enabled
+  const handleFetchTrends = async () => {
+    setIsFetchingTrends(true);
+    setTrendsError(null);
+    setTrends([]);
+    setSelectedTrend(null);
+
+    try {
+      const response = await apiClient.get(`/api/trends/${currentNiche}`);
+      const data = response.data;
+      
+      if (data.trends && data.trends.length > 0) {
+        setTrends(data.trends);
+      } else {
+        setTrendsError("No relevant trends found for this niche");
+      }
+    } catch (error: any) {
+      setTrendsError(error.message || "Failed to fetch trends");
+    } finally {
+      setIsFetchingTrends(false);
+    }
+  };
+
+  // Handle trend selection
+  const handleSelectTrend = (trend: TrendItem) => {
+    setSelectedTrend(trend);
+    // Set the trending context with title and description
+    const trendContext = `${trend.title} - ${trend.description}`;
+    setValue("trending_context", trendContext);
+  };
+
+  // Reset trends when toggle is turned off
+  React.useEffect(() => {
+    if (!useTrending) {
+      setTrends([]);
+      setSelectedTrend(null);
+      setTrendsError(null);
+    }
+  }, [useTrending]);
 
   return (
     <Card variant="glass">
@@ -60,7 +128,7 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({
 
           <div>
             <label className="block text-sm font-semibold text-gray-700 mb-2">
-              Target Audience
+              Target Audience <span className="text-gray-400 font-normal">(Optional)</span>
             </label>
             <input
               type="text"
@@ -75,7 +143,7 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({
 
           <div>
             <label className="block text-sm font-semibold text-gray-700 mb-2">
-              Offer
+              Offer <span className="text-gray-400 font-normal">(Optional)</span>
             </label>
             <input
               type="text"
@@ -88,6 +156,35 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({
             )}
           </div>
 
+          {/* Trending Topics Section - COMING SOON */}
+          <div className="border-t border-gray-200 pt-4">
+            <div className="flex items-center justify-between mb-3">
+              <div className="opacity-50">
+                <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
+                </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>
+            </div>
+          </div>
+
+
           <Select
             label="Image Model"
             options={IMAGE_MODELS.map(model => ({ value: model.value, label: model.label }))}

frontend/lib/api/endpoints.ts

@@ -44,8 +44,10 @@ export const generateAd = async (params: {
   niche: Niche;
   num_images: number;
   image_model?: string | null;
-  target_audience?: string;
-  offer?: string;
+  target_audience?: string | null;
+  offer?: string | null;
+  use_trending?: boolean;
+  trending_context?: string | null;
 }): Promise<GenerateResponse> => {
   const response = await apiClient.post<GenerateResponse>("/generate", params);
   return response.data;
@@ -57,8 +59,8 @@ export const generateBatch = async (params: {
   images_per_ad: number;
   image_model?: string | null;
   method?: "standard" | "matrix" | null;
-  target_audience?: string;
-  offer?: string;
+  target_audience?: string | null;
+  offer?: string | null;
 }): Promise<BatchResponse> => {
   const response = await apiClient.post<BatchResponse>("/generate/batch", params);
   return response.data;
@@ -73,8 +75,8 @@ export const generateMatrixAd = async (params: {
   custom_concept?: string | null;
   num_images: number;
   image_model?: string | null;
-  target_audience?: string;
-  offer?: string;
+  target_audience?: string | null;
+  offer?: string | null;
   core_motivator?: string;
 }): Promise<MatrixGenerateResponse> => {
   const response = await apiClient.post<MatrixGenerateResponse>("/matrix/generate", params);
@@ -94,9 +96,9 @@ export const generateMotivators = async (
 // Extensive Endpoint
 export const generateExtensiveAd = async (params: {
   niche: Niche;
-  custom_niche?: string;
-  target_audience?: string;
-  offer?: string;
+  custom_niche?: string | null;
+  target_audience?: string | null;
+  offer?: string | null;
   num_images: number;
   image_model?: string | null;
   num_strategies: number;
@@ -334,3 +336,13 @@ export const modifyCreative = async (params: {
   );
   return response.data;
 };
+
+// Bulk Export Endpoint
+export const exportBulkAds = async (adIds: string[]): Promise<Blob> => {
+  const response = await apiClient.post(
+    "/api/export/bulk",
+    { ad_ids: adIds },
+    { responseType: "blob" }
+  );
+  return response.data as Blob;
+};

frontend/lib/utils/validators.ts

@@ -4,8 +4,10 @@ export const generateAdSchema = z.object({
   niche: z.enum(["home_insurance", "glp1"]),
   num_images: z.number().min(1).max(10),
   image_model: z.string().optional().nullable(),
-  target_audience: z.string().optional(),
-  offer: z.string().optional(),
+  target_audience: z.string().optional().nullable(),
+  offer: z.string().optional().nullable(),
+  use_trending: z.boolean().optional(),
+  trending_context: z.string().optional().nullable(),
 });
 
 export const generateBatchSchema = z.object({
@@ -13,8 +15,8 @@ export const generateBatchSchema = z.object({
   count: z.number().min(1).max(20),
   images_per_ad: z.number().min(1).max(3),
   image_model: z.string().optional().nullable(),
-  target_audience: z.string().optional(),
-  offer: z.string().optional(),
+  target_audience: z.string().optional().nullable(),
+  offer: z.string().optional().nullable(),
 });
 
 export const generateMatrixSchema = z.object({
@@ -23,8 +25,8 @@ export const generateMatrixSchema = z.object({
   concept_key: z.string().optional().nullable(),
   num_images: z.number().min(1).max(5),
   image_model: z.string().optional().nullable(),
-  target_audience: z.string().optional(),
-  offer: z.string().optional(),
+  target_audience: z.string().optional().nullable(),
+  offer: z.string().optional().nullable(),
 });
 
 export const testingMatrixSchema = z.object({

frontend/types/api.ts

@@ -414,8 +414,8 @@ export interface MotivatorGenerateRequest {
   niche: Niche;
   angle: { name: string; trigger: string; example?: string; [k: string]: unknown };
   concept: { name: string; structure: string; visual: string; [k: string]: unknown };
-  target_audience?: string;
-  offer?: string;
+  target_audience?: string | null;
+  offer?: string | null;
   count?: number;
 }
 

main.py

@@ -5,7 +5,7 @@ Saves all ads to Neon PostgreSQL database with image URLs
 """
 
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, HTTPException, Request, Response, Depends
+from fastapi import FastAPI, HTTPException, Request, Response, Depends, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse, StreamingResponse, Response as FastAPIResponse
@@ -29,6 +29,8 @@ from services.image import image_service
 from services.auth import auth_service
 from services.auth_dependency import get_current_user
 from services.motivator import generate_motivators as motivator_generate
+from services.trend_monitor import trend_monitor
+from services.export_service import export_service
 from config import settings
 
 # Configure logging for API
@@ -129,6 +131,14 @@ class GenerateRequest(BaseModel):
         default=None,
         description="Optional offer to run (e.g., 'Don't overpay your insurance')"
     )
+    use_trending: bool = Field(
+        default=False,
+        description="Whether to incorporate current trending topics from Google News"
+    )
+    trending_context: Optional[str] = Field(
+        default=None,
+        description="Specific trending context to use (auto-fetched if not provided when use_trending=True)"
+    )
 
 
 class GenerateBatchRequest(BaseModel):
@@ -446,6 +456,8 @@ async def api_info():
             "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"],
@@ -487,6 +499,91 @@ async def health():
     return {"status": "ok"}
 
 
+# =============================================================================
+# TRENDING TOPICS ENDPOINTS
+# =============================================================================
+
+@app.get("/api/trends/{niche}")
+async def get_trends(
+    niche: Literal["home_insurance", "glp1"],
+    username: str = Depends(get_current_user)
+):
+    """
+    Get current trending topics for a niche from Google News.
+    
+    Requires authentication.
+    
+    🚧 COMING SOON - This feature is currently under development.
+    
+    Returns top 5 most relevant news articles with context for ad generation.
+    Articles are scored by relevance, recency, and emotional triggers.
+    
+    Results are cached for 1 hour to avoid rate limits.
+    """
+    # Feature temporarily disabled - coming soon
+    return {
+        "status": "coming_soon",
+        "message": "🔥 Trending Topics feature is coming soon! Stay tuned.",
+        "niche": niche,
+        "trends": [],
+        "count": 0,
+        "available_soon": True
+    }
+    
+    # Original implementation (commented out for later)
+    # try:
+    #     trends = await trend_monitor.fetch_trends(niche)
+    #     return {
+    #         "niche": niche,
+    #         "trends": trends,
+    #         "count": len(trends),
+    #         "fetched_at": datetime.now().isoformat()
+    #     }
+    # except Exception as e:
+    #     raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/trends/angles/{niche}")
+async def get_trending_angles(
+    niche: Literal["home_insurance", "glp1"],
+    username: str = Depends(get_current_user)
+):
+    """
+    Get auto-generated angle suggestions based on current trends.
+    
+    Requires authentication.
+    
+    🚧 COMING SOON - This feature is currently under development.
+    
+    These trending angles can be used in matrix generation like regular angles.
+    Each angle is generated from a real news article with:
+    - Detected psychological trigger
+    - Relevance score
+    - Expiry date (7 days)
+    """
+    # Feature temporarily disabled - coming soon
+    return {
+        "status": "coming_soon",
+        "message": "🔥 Trending Topics feature is coming soon! Stay tuned.",
+        "niche": niche,
+        "trending_angles": [],
+        "count": 0,
+        "available_soon": True
+    }
+    
+    # Original implementation (commented out for later)
+    # try:
+    #     angles = await trend_monitor.get_trending_angles(niche)
+    #     return {
+    #         "niche": niche,
+    #         "trending_angles": angles,
+    #         "count": len(angles),
+    #         "fetched_at": datetime.now().isoformat()
+    #     }
+    # except Exception as e:
+    #     raise HTTPException(status_code=500, detail=str(e))
+
+
 # =============================================================================
 # AUTHENTICATION ENDPOINTS
 # =============================================================================
@@ -559,9 +656,13 @@ async def generate(
     - Random visual styles and moods
     - Random seed for image generation
     
-    Supported niches:
+    Supports niches:
     - home_insurance: Fear, urgency, savings, authority, guilt strategies
     - glp1: Shame, transformation, FOMO, authority, simplicity strategies
+    
+    Trending Topics Integration:
+    - Set use_trending=True to incorporate current Google News trends
+    - Optionally provide trending_context, or it will be auto-fetched
     """
     try:
         result = await ad_generator.generate_ad(
@@ -569,6 +670,10 @@ async def generate(
             num_images=request.num_images,
             image_model=request.image_model,
             username=username,  # Pass current user
+            target_audience=request.target_audience,
+            offer=request.offer,
+            use_trending=request.use_trending,
+            trending_context=request.trending_context,
         )
         return result
     except Exception as e:
@@ -599,6 +704,8 @@ async def generate_batch(
             image_model=request.image_model,
             username=username,  # Pass current user
             method=request.method,  # Pass method parameter
+            target_audience=request.target_audience,
+            offer=request.offer,
         )
         return {
             "count": len(results),
@@ -939,8 +1046,8 @@ async def correct_image(
                 
                 if update_success:
                     api_logger.info(f"✓ Original ad updated with corrected image (ID: {request.image_id})")
-                    # Add the updated ad ID to the response
-                    if "corrected_image" not in response_data:
+                    # Add the updated ad ID to the response; ensure corrected_image is a dict
+                    if not response_data.get("corrected_image"):
                         response_data["corrected_image"] = {}
                     response_data["corrected_image"]["ad_id"] = request.image_id
                 else:
@@ -1471,6 +1578,8 @@ async def generate_with_matrix(
             image_model=request.image_model,
             username=username,
             core_motivator=request.core_motivator,
+            target_audience=request.target_audience,
+            offer=request.offer,
         )
         return result
     except Exception as e:
@@ -2392,6 +2501,82 @@ Return ONLY the improved {field_label} text, without any explanations or additio
             raise HTTPException(status_code=500, detail=f"Failed to generate AI edit: {str(e)}")
 
 
+# =============================================================================
+# BULK EXPORT ENDPOINTS
+# =============================================================================
+
+class BulkExportRequest(BaseModel):
+    """Request schema for bulk export."""
+    ad_ids: List[str] = Field(
+        description="List of ad IDs to export",
+        min_items=1,
+        max_items=50
+    )
+
+
+class BulkExportResponse(BaseModel):
+    """Response schema for bulk export."""
+    status: str
+    message: str
+    filename: str
+
+
+@app.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.
+    
+    Requires authentication. Users can only export their own ads.
+    
+    Creates a ZIP file containing:
+    - /creatives/ folder with renamed images (nomenclature: {niche}_{concept}_{angle}_{date}_{version}.png)
+    - ad_copy_data.xlsx with core fields (Headline, Title, Description, CTA, Psychological Angle, Image Filename, Image URL)
+    
+    Maximum 50 ads per export.
+    """
+    try:
+        # Validate number of ads
+        if len(request.ad_ids) > 50:
+            raise HTTPException(
+                status_code=400,
+                detail="Maximum 50 ads can be exported at once"
+            )
+        
+        # Fetch all ads and verify ownership
+        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)
+        
+        # Create export package
+        api_logger.info(f"Creating export package for {len(ads)} ads (user: {username})")
+        zip_path = await export_service.create_export_package(ads)
+        
+        # Schedule cleanup after response is sent
+        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(f"Bulk export failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Export failed: {str(e)}")
+
+
 # Frontend proxy - forward non-API requests to Next.js
 # This must be LAST so it doesn't intercept API routes
 @app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"])
@@ -2403,8 +2588,8 @@ async def frontend_proxy(path: str, request: StarletteRequest):
     # Exact API-only routes (never frontend)
     # Note: /health has its own explicit route, so not listed here
     api_only_routes = [
-        "auth/login", "api/correct", "api/download-image", "db/stats", "db/ads",
-        "strategies", "extensive/generate"
+        "auth/login", "api/correct", "api/download-image", "api/export/bulk", 
+        "db/stats", "db/ads", "strategies", "extensive/generate"
     ]
     
     # Routes that are API for POST but frontend for GET

requirements.txt

@@ -9,6 +9,7 @@ aiofiles>=23.0.0
 Pillow>=10.0.0
 replicate>=0.25.0
 python-docx>=1.1.0
+openpyxl>=3.1.0
 motor
 boto3>=1.34.0
 bcrypt>=4.0.0

services/export_service.py

@@ -0,0 +1,305 @@
+"""
+Export Service for Creative Breakthrough
+Handles bulk export of ad creatives with images and Excel data
+"""
+
+import os
+import zipfile
+import tempfile
+import shutil
+import re
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+import httpx
+from openpyxl import Workbook
+from openpyxl.styles import Font, Alignment
+import logging
+
+from config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class ExportService:
+    """Service for exporting ad creatives in bulk."""
+    
+    def __init__(self):
+        self.temp_dir = None
+    
+    def sanitize_filename(self, text: str, max_length: int = 50) -> str:
+        """
+        Sanitize text for use in filename.
+        Remove special characters and limit length.
+        """
+        if not text:
+            return "unknown"
+        
+        # Convert to lowercase
+        text = text.lower()
+        
+        # Replace spaces and special chars with underscore
+        text = re.sub(r'[^a-z0-9]+', '_', text)
+        
+        # Remove leading/trailing underscores
+        text = text.strip('_')
+        
+        # Limit length
+        if len(text) > max_length:
+            text = text[:max_length]
+        
+        # Remove trailing underscore if any
+        text = text.rstrip('_')
+        
+        return text or "unknown"
+    
+    def generate_image_filename(
+        self,
+        ad: Dict[str, Any],
+        version: int,
+        date_str: str
+    ) -> str:
+        """
+        Generate filename using nomenclature:
+        {niche}_{concept}_{angle}_{date}_{version}.png
+        
+        Example: home_insurance_before_after_fear_20260130_001.png
+        """
+        # Get niche
+        niche = self.sanitize_filename(ad.get("niche", "standard"), max_length=20)
+        
+        # Get concept (from concept_name or concept_key)
+        concept = self.sanitize_filename(
+            ad.get("concept_name") or ad.get("concept_key") or "standard",
+            max_length=20
+        )
+        
+        # Get angle (from angle_name or angle_key or psychological_angle)
+        angle = self.sanitize_filename(
+            ad.get("angle_name") or 
+            ad.get("angle_key") or 
+            ad.get("psychological_angle") or 
+            "standard",
+            max_length=20
+        )
+        
+        # Format version with leading zeros
+        version_str = f"{version:03d}"
+        
+        # Construct filename
+        filename = f"{niche}_{concept}_{angle}_{date_str}_{version_str}.png"
+        
+        return filename
+    
+    async def download_image(self, image_url: str) -> Optional[bytes]:
+        """Download image from URL and return bytes."""
+        try:
+            # Handle local file paths
+            if not image_url.startswith(("http://", "https://")):
+                local_path = os.path.join(settings.output_dir, image_url.lstrip("/images/"))
+                if os.path.exists(local_path):
+                    with open(local_path, "rb") as f:
+                        return f.read()
+                logger.warning(f"Local file not found: {local_path}")
+                return None
+            
+            # Download from URL
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.get(image_url)
+                response.raise_for_status()
+                return response.content
+        except Exception as e:
+            logger.error(f"Failed to download image from {image_url}: {e}")
+            return None
+    
+    async def download_and_rename_images(
+        self,
+        ads: List[Dict[str, Any]],
+        output_dir: str
+    ) -> Dict[str, str]:
+        """
+        Download all images and rename them according to nomenclature.
+        Returns mapping of ad_id -> new_filename.
+        """
+        filename_map = {}
+        date_str = datetime.now().strftime("%Y%m%d")
+        
+        for idx, ad in enumerate(ads, start=1):
+            ad_id = ad.get("id")
+            
+            # Get image URL (prefer r2_url, fallback to image_url)
+            image_url = ad.get("r2_url") or ad.get("image_url")
+            
+            if not image_url:
+                logger.warning(f"No image URL for ad {ad_id}, skipping")
+                continue
+            
+            # Generate new filename
+            new_filename = self.generate_image_filename(ad, idx, date_str)
+            
+            # Download image
+            logger.info(f"Downloading image {idx}/{len(ads)}: {image_url}")
+            image_bytes = await self.download_image(image_url)
+            
+            if not image_bytes:
+                logger.warning(f"Failed to download image for ad {ad_id}, skipping")
+                continue
+            
+            # Save with new filename
+            output_path = os.path.join(output_dir, new_filename)
+            with open(output_path, "wb") as f:
+                f.write(image_bytes)
+            
+            filename_map[ad_id] = new_filename
+            logger.info(f"Saved: {new_filename}")
+        
+        return filename_map
+    
+    def create_excel_sheet(
+        self,
+        ads: List[Dict[str, Any]],
+        filename_map: Dict[str, str],
+        output_path: str
+    ):
+        """
+        Create Excel sheet with ad copy data.
+        Columns: Image Filename, Headline, Title, Description, CTA, Psychological Angle
+        """
+        wb = Workbook()
+        ws = wb.active
+        ws.title = "Ad Copy Data"
+        
+        # Define headers (Core fields as requested)
+        headers = [
+            "Image Filename",
+            "Image URL",
+            "Headline",
+            "Title",
+            "Description",
+            "CTA",
+            "Psychological Angle",
+            "Niche",
+            "Created Date"
+        ]
+        
+        # Write headers with formatting
+        for col_idx, header in enumerate(headers, start=1):
+            cell = ws.cell(row=1, column=col_idx, value=header)
+            cell.font = Font(bold=True)
+            cell.alignment = Alignment(horizontal="center", vertical="center")
+        
+        # Write data rows
+        for row_idx, ad in enumerate(ads, start=2):
+            ad_id = ad.get("id")
+            
+            # Get filename from map
+            filename = filename_map.get(ad_id, "N/A")
+            
+            # Get image URL (prefer r2_url, fallback to image_url)
+            image_url = ad.get("r2_url") or ad.get("image_url") or ""
+            
+            # Extract data
+            row_data = [
+                filename,
+                image_url,
+                ad.get("headline", ""),
+                ad.get("title", ""),
+                ad.get("description", ""),
+                ad.get("cta", ""),
+                ad.get("psychological_angle", ""),
+                ad.get("niche", ""),
+                ad.get("created_at", "")[:10] if ad.get("created_at") else ""  # Date only
+            ]
+            
+            # Write row
+            for col_idx, value in enumerate(row_data, start=1):
+                ws.cell(row=row_idx, column=col_idx, value=value)
+        
+        # Auto-adjust column widths
+        for column in ws.columns:
+            max_length = 0
+            column_letter = column[0].column_letter
+            for cell in column:
+                try:
+                    if cell.value:
+                        max_length = max(max_length, len(str(cell.value)))
+                except:
+                    pass
+            adjusted_width = min(max_length + 2, 50)  # Cap at 50 for readability
+            ws.column_dimensions[column_letter].width = adjusted_width
+        
+        # Freeze first row
+        ws.freeze_panes = "A2"
+        
+        # Save workbook
+        wb.save(output_path)
+        logger.info(f"Excel sheet created: {output_path}")
+    
+    async def create_export_package(
+        self,
+        ads: List[Dict[str, Any]]
+    ) -> str:
+        """
+        Create a complete export package with images and Excel sheet.
+        Returns path to the ZIP file.
+        """
+        # Create temporary directory for export
+        self.temp_dir = tempfile.mkdtemp(prefix="export_")
+        
+        try:
+            # Create subdirectories
+            creatives_dir = os.path.join(self.temp_dir, "creatives")
+            os.makedirs(creatives_dir, exist_ok=True)
+            
+            # Download and rename images
+            logger.info(f"Downloading {len(ads)} images...")
+            filename_map = await self.download_and_rename_images(ads, creatives_dir)
+            
+            if not filename_map:
+                raise Exception("No images were successfully downloaded")
+            
+            # Create Excel sheet
+            excel_path = os.path.join(self.temp_dir, "ad_copy_data.xlsx")
+            logger.info("Creating Excel sheet...")
+            self.create_excel_sheet(ads, filename_map, excel_path)
+            
+            # Create ZIP file
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            zip_filename = f"creatives_export_{timestamp}.zip"
+            zip_path = os.path.join(tempfile.gettempdir(), zip_filename)
+            
+            logger.info(f"Creating ZIP file: {zip_filename}")
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                # Add all images
+                for filename in os.listdir(creatives_dir):
+                    file_path = os.path.join(creatives_dir, filename)
+                    zipf.write(file_path, os.path.join("creatives", filename))
+                
+                # Add Excel file
+                zipf.write(excel_path, "ad_copy_data.xlsx")
+            
+            logger.info(f"Export package created successfully: {zip_path}")
+            return zip_path
+            
+        except Exception as e:
+            logger.error(f"Failed to create export package: {e}")
+            raise
+        finally:
+            # Cleanup temp directory (but keep ZIP file)
+            if self.temp_dir and os.path.exists(self.temp_dir):
+                try:
+                    shutil.rmtree(self.temp_dir)
+                except Exception as e:
+                    logger.warning(f"Failed to cleanup temp directory: {e}")
+    
+    def cleanup_zip(self, zip_path: str):
+        """Clean up the ZIP file after it's been sent."""
+        try:
+            if os.path.exists(zip_path):
+                os.remove(zip_path)
+                logger.info(f"Cleaned up ZIP file: {zip_path}")
+        except Exception as e:
+            logger.warning(f"Failed to cleanup ZIP file: {e}")
+
+
+# Global export service instance
+export_service = ExportService()

services/generator.py

@@ -48,6 +48,13 @@ 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
 from services.matrix import matrix_service
@@ -608,10 +615,14 @@ NICHE-SPECIFIC REQUIREMENTS (GLP-1 / WEIGHT LOSS):
         power_words: List[str] = None,
         angle: Dict[str, Any] = None,
         concept: Dict[str, Any] = None,
+        target_audience: Optional[str] = None,
+        offer: Optional[str] = None,
+        trending_context: Optional[str] = None,
     ) -> str:
         """
         Build professional LLM prompt for ad copy generation.
         Uses angle × concept matrix approach for psychological targeting.
+        Can optionally incorporate trending topics for increased relevance.
         """
         strategy_names = [s["name"] for s in strategies]
         strategy_descriptions = [f"- {s['name']}: {s['description']}" for s in strategies]
@@ -732,6 +743,27 @@ WITHOUT NUMBERS (use if no numbers section):
    - "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!
+"""
+
         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.
 
 === CONTEXT ===
@@ -743,6 +775,7 @@ FRAMEWORK VISUAL STYLE: {framework_data.get('visual_style', '')}
 FRAMEWORK HOOK EXAMPLES: {', '.join(framework_hooks[:3]) if framework_hooks else 'N/A'}
 CREATIVE DIRECTION: {creative_direction}
 CALL-TO-ACTION: {cta}
+{trending_section}
 
 === ANGLE × CONCEPT FRAMEWORK ===
 ANGLE: {angle.get('name') if angle else 'N/A'}
@@ -755,6 +788,10 @@ CONCEPT: {concept.get('name') if concept else 'N/A'}
 - Visual Guidance: {concept.get('visual') if concept else 'N/A'}
 - This concept defines HOW to show it visually
 
+{f'=== USER INPUTS ===' if target_audience or offer else ''}
+{f'TARGET AUDIENCE: {target_audience}' if target_audience else ''}
+{f'OFFER: {offer}' if offer else ''}
+
 === CONTAINER FORMAT (Native-Looking Ad) ===
 CONTAINER TYPE: {container['name']}
 DESCRIPTION: {container.get('description', '')}
@@ -1405,6 +1442,10 @@ CRITICAL REQUIREMENTS:
         num_images: int = 1,
         image_model: Optional[str] = None,
         username: Optional[str] = None,  # Username of the user generating the ad
+        target_audience: Optional[str] = None,
+        offer: Optional[str] = None,
+        use_trending: bool = False,  # Whether to incorporate trending topics
+        trending_context: Optional[str] = None,  # Optional specific trending context
     ) -> Dict[str, Any]:
         """
         Generate a complete ad creative with copy and image.
@@ -1418,9 +1459,13 @@ CRITICAL REQUIREMENTS:
         - Random camera angle, lighting, composition
         - Random seed for image generation
         
+        Can optionally incorporate current trending topics from Google News.
+        
         Args:
             niche: Target niche (home_insurance or glp1)
             num_images: Number of images to generate
+            use_trending: Whether to incorporate current trending topics
+            trending_context: Specific trending context (auto-fetched if not provided)
             
         Returns:
             Dict with ad copy, image path, and metadata
@@ -1477,6 +1522,42 @@ CRITICAL REQUIREMENTS:
         angle = combination["angle"]
         concept = combination["concept"]
         
+        # Fetch trending context if requested
+        trending_info = None
+        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()
+                    )
+                    if trends_data and trends_data.get("relevant_trends"):
+                        # Use top trend for context
+                        top_trend = trends_data["relevant_trends"][0]
+                        trending_context = f"{top_trend['title']} - {top_trend['summary']}"
+                        trending_info = {
+                            "title": top_trend["title"],
+                            "summary": top_trend["summary"],
+                            "category": top_trend.get("category", "General"),
+                            "source": "Google News",
+                        }
+                        print(f"✓ Using trend: {top_trend['title']}")
+                else:
+                    # User provided specific trending context
+                    trending_info = {
+                        "context": trending_context,
+                        "source": "User provided",
+                    }
+                    print(f"✓ Using user-provided trending context")
+            except Exception as e:
+                print(f"Warning: Failed to fetch trending topics: {e}")
+                use_trending = False
+        elif use_trending and not trend_monitor_available:
+            print("Warning: Trending topics requested but trend monitor not available")
+            use_trending = False
+        
         # Generate ad copy via LLM with professional prompt
         copy_prompt = self._build_copy_prompt(
             niche=niche,
@@ -1492,6 +1573,9 @@ CRITICAL REQUIREMENTS:
             power_words=power_words,
             angle=angle,
             concept=concept,
+            target_audience=target_audience,
+            offer=offer,
+            trending_context=trending_context if use_trending else None,
         )
         
         ad_copy = await llm_service.generate_json(
@@ -1693,6 +1777,8 @@ CRITICAL REQUIREMENTS:
         image_model: Optional[str] = None,
         username: Optional[str] = None,
         core_motivator: Optional[str] = None,
+        target_audience: Optional[str] = None,
+        offer: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Generate ad using angle × concept matrix approach.
@@ -1802,6 +1888,8 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
             concept=concept,
             niche_data=niche_data,
             core_motivator=core_motivator,
+            target_audience=target_audience,
+            offer=offer,
         )
         
         # Generate ad copy
@@ -2477,6 +2565,8 @@ Return JSON:
         concept: Dict[str, Any],
         niche_data: Dict[str, Any],
         core_motivator: Optional[str] = None,
+        target_audience: Optional[str] = None,
+        offer: Optional[str] = None,
     ) -> str:
         """Build ad copy prompt using angle + concept framework."""
         
@@ -2527,6 +2617,10 @@ CONCEPT: {concept.get('name')}
 - Visual Guidance: {concept.get('visual')}
 - This concept defines HOW to show it visually
 
+{f'=== USER INPUTS ===' if target_audience or offer else ''}
+{f'TARGET AUDIENCE: {target_audience}' if target_audience else ''}
+{f'OFFER: {offer}' if offer else ''}
+
 === CONTEXT ===
 NICHE: {niche.replace("_", " ").title()}
 CTA: {cta}
@@ -2698,6 +2792,8 @@ If this image includes people or faces, they MUST look like real, original peopl
         image_model: Optional[str] = None,
         username: Optional[str] = None,  # Username of the user generating the ads
         method: Optional[str] = None,  # "standard", "matrix", or None (mixed)
+        target_audience: Optional[str] = None,
+        offer: Optional[str] = None,
     ) -> List[Dict[str, Any]]:
         """
         Generate multiple ad creatives - PARALLELIZED.
@@ -2737,6 +2833,8 @@ If this image includes people or faces, they MUST look like real, original peopl
                             num_images=images_per_ad,
                             image_model=image_model,
                             username=username,  # Pass username
+                            target_audience=target_audience,
+                            offer=offer,
                         )
                         # Normalize matrix result to standard format for batch response
                         # Extract matrix info and convert metadata
@@ -2765,6 +2863,8 @@ If this image includes people or faces, they MUST look like real, original peopl
                             num_images=images_per_ad,
                             image_model=image_model,
                             username=username,  # Pass username
+                            target_audience=target_audience,
+                            offer=offer,
                         )
                     return result
                 except Exception as e:

services/motivator.py

@@ -42,9 +42,9 @@ async def generate_motivators(
     concept_visual = concept.get("visual", "")
 
     extra = []
-    if target_audience:
+    if target_audience and str(target_audience).strip():
         extra.append(f"Target audience: {target_audience}")
-    if offer:
+    if offer and str(offer).strip():
         extra.append(f"Offer: {offer}")
     extra_block = "\n".join(extra) if extra else ""
     extra_segment = f"\n{extra_block}" if extra_block else ""

services/trend_monitor.py

@@ -0,0 +1,271 @@
+"""
+Google News Trend Monitor for PsyAdGenesis
+Fetches and analyzes relevant news for Home Insurance and GLP-1 niches
+"""
+
+from gnews import GNews
+from typing import List, Dict, Optional
+from datetime import datetime, timedelta
+import asyncio
+
+# Niche-specific keywords
+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"
+    ]
+}
+
+# Simple in-memory cache
+TREND_CACHE = {}
+CACHE_DURATION = timedelta(hours=1)  # Cache for 1 hour
+
+
+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.max_results = 10
+    
+    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
+        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
+        """
+        if niche not in NICHE_KEYWORDS:
+            raise ValueError(f"Unsupported niche: {niche}. Supported: {list(NICHE_KEYWORDS.keys())}")
+        
+        keywords = NICHE_KEYWORDS[niche]
+        all_articles = []
+        
+        # Fetch articles for each keyword (limit to avoid rate limits)
+        for keyword in keywords[:3]:  # Top 3 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)
+                )
+                
+                for article in articles:
+                    # Add metadata
+                    article['keyword'] = keyword
+                    article['niche'] = niche
+                    all_articles.append(article)
+                    
+            except Exception as e:
+                print(f"⚠️  Error fetching news for '{keyword}': {e}")
+                continue
+        
+        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
+        """
+        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:
+                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
+                    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:
+                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()
+    
+    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 = {
+                "key": f"trend_{abs(hash(title)) % 10000}",
+                "name": f"Trending: {title[:40]}...",
+                "trigger": trigger,
+                "example": context[:100],
+                "category": "Trending",
+                "source": "google_news",
+                "url": trend.get('url'),
+                "expires": (datetime.now() + timedelta(days=7)).isoformat(),
+                "relevance_score": trend.get('relevance_score', 0)
+            }
+            angles.append(angle)
+        
+        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)"""
+        global TREND_CACHE
+        TREND_CACHE = {}
+        print("✓ Trend cache cleared")
+
+
+# Global instance
+trend_monitor = TrendMonitor()