Update core/analyze.py

core/analyze.py

@@ -13,91 +13,121 @@ logger = logging.getLogger(__name__)
 
 # Configure Groq Client
 api_key = os.getenv("GROQ_API_KEY")
-MODEL_NAME = os.getenv("GROQ_MODEL", "llama-3.1-8b-instant")
+MODEL_NAME = os.getenv("GROQ_MODEL", "openai/gpt-oss-120b")
 
 client = Groq(api_key=api_key)
 
+MIN_DURATION = 60   # seconds
+MAX_DURATION = 180  # seconds
+
+
+def validate_segments(segments):
+    """
+    Remove segments that don't meet duration requirements (60-180 seconds).
+    Recalculates duration from start/end times — never trusts AI's duration field.
+    """
+    valid = []
+    for seg in segments:
+        start = seg.get("start_time", 0)
+        end = seg.get("end_time", 0)
+        duration = end - start
+
+        if duration < MIN_DURATION:
+            print(f"⚠️ Skipped short segment: {duration:.1f}s → [{start}s–{end}s] ({seg.get('description', '')})")
+            continue
+
+        if duration > MAX_DURATION:
+            print(f"⚠️ Skipped long segment: {duration:.1f}s → [{start}s–{end}s] ({seg.get('description', '')})")
+            continue
+
+        seg["duration"] = round(duration, 2)
+        valid.append(seg)
+
+    print(f"✅ Valid segments after duration filter: {len(valid)}/{len(segments)}")
+    return valid
+
 
 def analyze_transcript(transcript):
-    """Analyze transcript using Groq API."""
+    """Analyze transcript using Groq API — minimal output, maximum quality."""
 
     prompt = f"""
-    You are an expert video editor and viral content strategist. 
-    Your task is to identify the most engaging segments from the provided transcript 
-    that are suitable for short-form video platforms like TikTok, Reels, and YouTube Shorts.
-    
-    **STRICT REQUIREMENTS:**
-    1. **Duration**: duration MUST be between 60 seconds and 180 seconds (3 minutes)
-    2. **Context Preservation**: Each segment must be a complete thought - no abrupt cuts
-    3. **Sentence Boundaries**: Start at the beginning of a sentence, end at a natural conclusion
-    4. **Meaning Coherence**: The clip must make sense on its own without requiring prior context
-    
-    **SELECTION CRITERIA:**
-    - Strong hooks that grab attention 
-    - Emotional moments, humor, or surprising revelations
-    - Clear beginning, middle, and satisfying conclusion
-    - High shareability potential
-    
-    **JSON OUTPUT FORMAT (REQUIRED):**
+You are an expert viral video editor. Analyze this transcript and find the best self-contained segments for TikTok/Reels/YouTube Shorts.
+
+SEGMENT RULES (STRICT):
+- Duration MUST be 60–180 seconds (end_time - start_time >= 60)
+- Must be a COMPLETE thought: natural start, full story/point, satisfying end
+- Must make sense WITHOUT watching anything before or after it
+- NO mid-sentence cuts, NO abrupt endings
+
+QUALITY CRITERIA (pick segments that have ALL of these):
+- Strong hook in the first few seconds that grabs attention
+- One clear emotional core: funny / surprising / inspiring / controversial
+- Builds naturally to a satisfying conclusion
+- Highly shareable standalone moment
+
+OUTPUT — return ONLY this JSON, nothing else:
+{{
+  "segments": [
     {{
-      "segments": [
-        {{
-          "start_time": <float, start time in seconds>,
-          "end_time": <float, end time in seconds>,
-          "duration": <float, duration in seconds (30-180)>,
-          "description": "<string, brief summary of the clip content 10 words max>",
-          "viral_score": <float, score from 0-10 indicating viral potential>,
-          "reason": "<string, explanation of why this segment is engaging>"
-        }}
-      ]
+      "start_time": <float>,
+      "end_time": <float>,
+      "title": "<YouTube-ready title, punchy, max 60 chars>",
+      "description": "<YouTube description, 1-2 sentences, include relevant keywords>",
+      "reason": "<why this specific segment is complete and viral-worthy, max 20 words>"
     }}
-    
-    **IMPORTANT NOTES:**
-    - If no suitable segments are found, return {{ "segments": [] }}
-    - Ensure all strings are properly escaped
-    - Each segment must be a complete, coherent thought
-    - Avoid cutting mid-sentence or mid-thought
-    
-    Transcript to Analyze:
-    {transcript}
-    """
+  ]
+}}
+
+RULES:
+- end_time - start_time MUST be >= 60, skip any segment shorter than that
+- Return empty segments array if nothing qualifies: {{"segments": []}}
+- Raw JSON only, no markdown, no explanation
+
+TRANSCRIPT:
+{transcript}
+"""
 
     max_retries = 3
     base_delay = 5
-    content = None
 
     for attempt in range(max_retries):
         try:
             response = client.chat.completions.create(
                 model=MODEL_NAME,
                 messages=[
-                    {"role": "system", "content": "You are a helpful assistant that outputs only valid JSON."},
+                    {
+                        "role": "system",
+                        "content": "You are a JSON-only assistant. Output raw JSON with no markdown, no explanation, no code blocks."
+                    },
                     {"role": "user", "content": prompt}
                 ],
-                temperature=0.7,
+                temperature=0.3,
             )
 
-            content = response.choices[0].message.content
-            print(f"🤖 AI Raw Response (First 500 chars): {content[:500]}...")
+            content = response.choices[0].message.content.strip()
+            print(f"🤖 AI Raw Response (First 300 chars): {content[:300]}...")
 
-            # Clean Markdown code blocks if present
+            # Strip markdown if model ignores system prompt
             if "```json" in content:
                 content = content.split("```json")[1].split("```")[0].strip()
             elif "```" in content:
                 content = content.split("```")[1].split("```")[0].strip()
 
-            # Validate JSON and log segment count
+            # Parse and validate
             data = json.loads(content)
-            segments_count = len(data.get("segments", []))
-            print(f"🤖 AI Response parsed successfully: Found {segments_count} segments.")
+            raw_segments = data.get("segments", [])
+            valid_segments = validate_segments(raw_segments)
+            data["segments"] = valid_segments
 
+            content = json.dumps(data)
+            print(f"🤖 Parsed: {len(raw_segments)} raw → {len(valid_segments)} valid segments.")
             return {"content": content}
 
         except Exception as e:
-            print(f"❌ Error in Groq analysis: {e}")
+            print(f"❌ Error in Groq analysis (attempt {attempt + 1}): {e}")
             if attempt < max_retries - 1:
                 wait_time = base_delay * (2 ** attempt)
-                print(f"⚠️ Retrying task in {wait_time}s...")
+                print(f"⚠️ Retrying in {wait_time}s...")
                 time.sleep(wait_time)
             else:
                 break
@@ -108,8 +138,7 @@ def analyze_transcript(transcript):
 
 def smart_chunk_transcript(transcript, max_tokens=4000):
     """
-    Split transcript into coherent chunks at sentence boundaries
-    while preserving context and meaning.
+    Split transcript into coherent chunks at sentence boundaries.
     """
     sentences = transcript.replace('\n', ' ').split('. ')
     chunks = []
@@ -158,7 +187,7 @@ def analyze_transcript_with_chunking(transcript):
                 continue
 
         if all_segments:
-            all_segments.sort(key=lambda x: x.get('viral_score', 0), reverse=True)
+            # Sort by viral quality (reason length as proxy, or add viral_score back if needed)
             unique_segments = []
             seen_times = set()
 
@@ -183,6 +212,10 @@ if __name__ == "__main__":
     [45.0 - 60.0] This has saved me hours every week. I batch my emails, phone calls, and even errands.
     [60.0 - 90.0] The third hack is the Pomodoro Technique. Work for 25 minutes, then take a 5-minute break.
     [90.0 - 120.0] This technique helps me stay focused and avoid burnout. I get more done in less time.
+    [120.0 - 150.0] The fourth hack is to eliminate distractions completely. Turn off notifications, close tabs, and focus.
+    [150.0 - 180.0] When you eliminate distractions, your productivity skyrockets. I finish in 2 hours what used to take 6.
+    [180.0 - 210.0] The fifth and final hack is to review your day every evening. Spend 5 minutes planning tomorrow.
+    [210.0 - 240.0] This evening review changed everything for me. I wake up knowing exactly what to do and I never waste morning time figuring out priorities.
     """
 
     logger.info("🧪 Testing AI Analysis...")
@@ -191,11 +224,16 @@ if __name__ == "__main__":
     try:
         data = json.loads(result['content'])
         segments = data.get('segments', [])
-        logger.info(f"✅ Found {len(segments)} viral segments:")
+        logger.info(f"✅ Found {len(segments)} valid segments:\n")
 
         for i, seg in enumerate(segments):
-            logger.info(f"  #{i+1} [{seg['start_time']:.0f}s-{seg['end_time']:.0f}s] "
-                        f"Score: {seg['viral_score']}/10 - {seg['description']}")
+            duration = seg['end_time'] - seg['start_time']
+            logger.info(
+                f"#{i+1} [{seg['start_time']:.0f}s – {seg['end_time']:.0f}s] ({duration:.0f}s)\n"
+                f"  📌 Title:       {seg.get('title', 'N/A')}\n"
+                f"  📝 Description: {seg.get('description', 'N/A')}\n"
+                f"  💡 Reason:      {seg.get('reason', 'N/A')}\n"
+            )
     except Exception as e:
         logger.error(f"❌ Error parsing result: {e}")
         logger.info(f"Raw result: {result}")