Refactor ad generation process to improve progress tracking and niche-specific guidance

- Enhanced the GeneratePage component to provide detailed progress updates during ad generation, including estimated times for each step.
- Updated the generator service to process strategies in parallel and introduced niche-specific visual guidance for image generation.
- Improved the creative_designer method to incorporate niche requirements, ensuring generated images align with specific categories.
- Added error handling for progress intervals to maintain stability during ad generation.

frontend/app/generate/page.tsx

@@ -242,42 +242,131 @@ export default function GeneratePage() {
     reset();
     setIsGenerating(true);
     setGenerationStartTime(Date.now());
-    setProgress({
-      step: "copy",
-      progress: 10,
-      message: "Researching psychology triggers, angles, and concepts...",
-    });
+    
+    // Calculate estimated time based on strategies and images
+    // Step 1 (Researcher): ~10-15 seconds
+    // Step 2 (Retrieve knowledge): ~15-20 seconds (parallel)
+    // Step 3 (Creative Director): ~20-30 seconds
+    // Step 4 (Process strategies): ~10-15 seconds per strategy (parallel)
+    // Step 5 (Generate images): ~15-30 seconds per image
+    const estimatedTimePerStrategy = 10; // seconds for processing strategy
+    const estimatedTimePerImage = 20; // seconds per image
+    const totalEstimatedTime = 
+      15 + // Step 1: Researcher
+      20 + // Step 2: Retrieve knowledge
+      25 + // Step 3: Creative Director
+      (data.num_strategies * estimatedTimePerStrategy) + // Step 4: Process strategies
+      (data.num_strategies * data.num_images * estimatedTimePerImage); // Step 5: Generate images
+    
+    let elapsedTime = 0;
+    let progressInterval: NodeJS.Timeout | null = null;
+    
+    // Progress steps aligned with actual backend steps
+    const progressSteps = [
+      { 
+        step: "copy" as const, 
+        progress: 5, 
+        message: "🔍 Step 1: Researching psychology triggers, angles, and concepts...",
+        duration: 15 // seconds
+      },
+      { 
+        step: "copy" as const, 
+        progress: 15, 
+        message: "📚 Step 2: Retrieving marketing knowledge...",
+        duration: 20 // seconds
+      },
+      { 
+        step: "copy" as const, 
+        progress: 30, 
+        message: `🎨 Step 3: Creating ${data.num_strategies} creative strategy/strategies...`,
+        duration: 25 // seconds
+      },
+      { 
+        step: "copy" as const, 
+        progress: 50, 
+        message: `⚡ Step 4: Processing ${data.num_strategies} strategies in parallel...`,
+        duration: data.num_strategies * estimatedTimePerStrategy // seconds
+      },
+      { 
+        step: "image" as const, 
+        progress: 70, 
+        message: `🖼️ Step 5: Generating ${data.num_images} image(s) per strategy...`,
+        duration: data.num_strategies * data.num_images * estimatedTimePerImage // seconds
+      },
+    ];
+    
+    let currentStepIndex = 0;
+    let stepStartTime = 0;
+    const progressUpdateInterval = 500; // Update every 500ms
+    
+    const updateProgress = () => {
+      elapsedTime += progressUpdateInterval / 1000; // Convert to seconds
+      
+      // Determine which step we should be on based on elapsed time
+      let cumulativeTime = 0;
+      let targetStepIndex = 0;
+      let stepStartCumulativeTime = 0;
+      
+      for (let i = 0; i < progressSteps.length; i++) {
+        const stepStart = cumulativeTime;
+        cumulativeTime += progressSteps[i].duration;
+        if (elapsedTime <= cumulativeTime) {
+          targetStepIndex = i;
+          stepStartCumulativeTime = stepStart;
+          break;
+        }
+        targetStepIndex = i;
+        stepStartCumulativeTime = stepStart;
+      }
+      
+      // Update to the correct step if we've moved forward
+      if (targetStepIndex > currentStepIndex) {
+        currentStepIndex = targetStepIndex;
+        stepStartTime = stepStartCumulativeTime;
+      }
+      
+      const currentStep = progressSteps[currentStepIndex];
+      const stepElapsed = elapsedTime - stepStartTime;
+      const stepProgress = Math.min(1, Math.max(0, stepElapsed / currentStep.duration));
+      
+      // Calculate overall progress
+      let overallProgress = currentStep.progress;
+      if (currentStepIndex < progressSteps.length - 1) {
+        // Within current step, interpolate to next step's progress
+        const nextStep = progressSteps[currentStepIndex + 1];
+        const progressRange = nextStep.progress - currentStep.progress;
+        overallProgress = currentStep.progress + (stepProgress * progressRange);
+      } else {
+        // Last step, interpolate from current step progress to 90%
+        overallProgress = currentStep.progress + (stepProgress * (90 - currentStep.progress));
+      }
+      
+      setProgress({
+        step: currentStep.step,
+        progress: Math.min(90, overallProgress), // Cap at 90% until completion
+        message: currentStep.message,
+      });
+    };
 
     try {
-      // Simulate progress updates for extensive
-      let currentProgress = 20;
-      const progressSteps = [
-        { step: "copy" as const, progress: 20, message: "Researching psychology triggers..." },
-        { step: "copy" as const, progress: 35, message: "Retrieving marketing knowledge..." },
-        { step: "copy" as const, progress: 50, message: "Creating creative strategies..." },
-        { step: "copy" as const, progress: 70, message: "Generating image prompts and copy..." },
-        { step: "image" as const, progress: 85, message: "Generating images..." },
-      ];
-      let stepIndex = 0;
+      // Start progress updates
+      progressInterval = setInterval(updateProgress, progressUpdateInterval);
       
-      const progressInterval = setInterval(() => {
-        if (stepIndex < progressSteps.length) {
-          setProgress(progressSteps[stepIndex]);
-          stepIndex++;
-        } else {
-          currentProgress = Math.min(95, currentProgress + 2);
-          setProgress({
-            step: "image",
-            progress: currentProgress,
-            message: "Generating images...",
-          });
-        }
-      }, 2000);
+      // Set initial progress
+      setProgress({
+        step: progressSteps[0].step,
+        progress: progressSteps[0].progress,
+        message: progressSteps[0].message,
+      });
 
       // Generate ad using extensive
       const result = await generateExtensiveAd(data);
 
-      clearInterval(progressInterval);
+      // Clear progress interval
+      if (progressInterval) {
+        clearInterval(progressInterval);
+        progressInterval = null;
+      }
 
       // Verify all images are included
       if (result.images && result.images.length > 0) {
@@ -292,6 +381,9 @@ export default function GeneratePage() {
         message: "Saving to database...",
       });
 
+      // Small delay to show saving step
+      await new Promise(resolve => setTimeout(resolve, 500));
+
       setCurrentGeneration(result);
       setProgress({
         step: "complete",
@@ -301,6 +393,12 @@ export default function GeneratePage() {
 
       toast.success("Ad generated successfully using Extensive!");
     } catch (error: any) {
+      // Clear progress interval on error
+      if (progressInterval) {
+        clearInterval(progressInterval);
+        progressInterval = null;
+      }
+      
       setError(error.message || "Failed to generate ad");
       setProgress({
         step: "error",

services/generator.py

@@ -1967,10 +1967,17 @@ CONCEPT: {concept['name']}
         # Step 4: Process strategies in parallel (designer + copywriter)
         print(f"⚡ Step 4: Processing {len(creative_strategies)} strategies in parallel...")
         from concurrent.futures import ThreadPoolExecutor as TPE
+        from functools import partial
+        
+        # Create a partial function that includes the niche parameter
+        process_strategy_with_niche = partial(
+            third_flow_service.process_strategy,
+            niche=niche_display
+        )
         
         with TPE(max_workers=8) as executor:
             strategy_results = list(executor.map(
-                third_flow_service.process_strategy,
+                process_strategy_with_niche,
                 creative_strategies
             ))
         

services/third_flow.py

@@ -447,16 +447,57 @@ class ThirdFlowService:
             print(f"Error in creative_director: {e}")
             return []
     
-    def creative_designer(self, creative_strategy: CreativeStrategies) -> str:
+    def creative_designer(self, creative_strategy: CreativeStrategies, niche: str = "Home Insurance") -> str:
         """
         Generate image prompt from creative strategy.
         
         Args:
             creative_strategy: Creative strategy object
+            niche: Niche category (Home Insurance or GLP-1)
             
         Returns:
             Image generation prompt
         """
+        # Import niche visual guidance
+        from data.visuals import get_niche_visual_guidance
+        
+        # Get niche-specific visual guidance
+        niche_lower = niche.lower().replace(" ", "_").replace("-", "_")
+        niche_guidance_data = get_niche_visual_guidance(niche_lower)
+        
+        # Build niche-specific guidance text
+        if niche_guidance_data:
+            niche_guidance = f"""
+NICHE-SPECIFIC REQUIREMENTS ({niche}):
+SUBJECTS TO INCLUDE: {', '.join(niche_guidance_data.get('subjects', []))}
+PROPS TO INCLUDE: {', '.join(niche_guidance_data.get('props', []))}
+AVOID: {', '.join(niche_guidance_data.get('avoid', []))}
+COLOR PREFERENCE: {niche_guidance_data.get('color_preference', 'balanced')}
+
+CRITICAL: The image MUST be appropriate for {niche} niche. Ensure all visual elements match this niche category."""
+        elif niche_lower == "home_insurance":
+            niche_guidance = """
+NICHE-SPECIFIC REQUIREMENTS (Home Insurance):
+SUBJECTS TO INCLUDE: family in front of home, house exterior, homeowner looking confident, couple reviewing papers
+PROPS TO INCLUDE: insurance documents, house keys, tablet showing coverage, family photos
+AVOID: disasters, fire or floods, stressed expressions, dark settings
+COLOR PREFERENCE: trust
+
+CRITICAL: The image MUST show home insurance-related content. Show REAL American suburban homes, homeowners, and insurance-related elements."""
+        elif niche_lower == "glp1":
+            niche_guidance = """
+NICHE-SPECIFIC REQUIREMENTS (GLP-1):
+SUBJECTS TO INCLUDE: confident person smiling, active lifestyle scenes, healthy meal preparation, doctor consultation
+PROPS TO INCLUDE: fitness equipment, healthy food, comfortable clothing
+AVOID: before/after weight comparisons, measuring tapes, scales prominently, needle close-ups
+COLOR PREFERENCE: health
+
+CRITICAL: The image MUST be appropriate for GLP-1/weight loss niche. Show lifestyle, health, and confidence-related content, NOT home insurance content."""
+        else:
+            niche_guidance = f"""
+NICHE-SPECIFIC REQUIREMENTS ({niche}):
+CRITICAL: The image MUST be appropriate for {niche} niche."""
+        
         strategy_str = f"""Psychology Trigger: {creative_strategy.phsychologyTrigger}
         Angle: {creative_strategy.angle}
         Concept: {creative_strategy.concept}
@@ -471,13 +512,15 @@ class ThirdFlowService:
                 "content": [
                     {
                         "type": "text",
-                        "text": """You are the Creative Designer for the affiliate marketing company which makes the prompt from creative strategy given for the ad images in the affiliate marketing.
+                        "text": f"""You are the Creative Designer for the affiliate marketing company which makes the prompt from creative strategy given for the ad images in the affiliate marketing.
                         Nano Banana image model will be used to generate the images
                         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]
                         
+                        {niche_guidance}
+                        
                         CRITICAL: If the image includes people or faces, ensure they look like real, original people with:
                         - Photorealistic faces with natural skin texture, visible pores, and realistic skin imperfections
                         - Natural facial asymmetry (no perfectly symmetrical faces)
@@ -498,7 +541,7 @@ class ThirdFlowService:
                         "type": "text",
                         "text": f"""Following is the creative strategy:
                         {strategy_str}
-                        Provide the image prompt for the given creative strategy."""
+                        Provide the image prompt for the given creative strategy. Make sure the prompt follows the NICHE-SPECIFIC REQUIREMENTS above."""
                     }
                 ]
             }
@@ -611,18 +654,20 @@ class ThirdFlowService:
     
     def process_strategy(
         self,
-        creative_strategy: CreativeStrategies
+        creative_strategy: CreativeStrategies,
+        niche: str = "Home Insurance"
     ) -> tuple[str, str, str, str]:
         """
         Process a single creative strategy to generate prompt and copy.
         
         Args:
             creative_strategy: Creative strategy object
+            niche: Niche category (Home Insurance or GLP-1)
             
         Returns:
             Tuple of (prompt, title, body, description)
         """
-        prompt = self.creative_designer(creative_strategy)
+        prompt = self.creative_designer(creative_strategy, niche=niche)
         ad_copy = self.copy_writer(creative_strategy)
         return (
             prompt,