Automated deployment from GitHub Actions

.env

@@ -1,5 +1,5 @@
-SIEVE_API_KEY="YOUR_KEY_HERE"
-OPENAI_API_KEY="YOUR_KEY_HERE"
-# GEMINI_API_KEY="YOUR_KEY_HERE"
-# GEMINI_API_KEY="YOUR_KEY_HERE"
-GEMINI_API_KEY="YOUR_KEY_HERE"
+SIEVE_API_KEY="YOUR_KEY_HERE"
+OPENAI_API_KEY="YOUR_KEY_HERE"
+# GEMINI_API_KEY="YOUR_KEY_HERE"
+# GEMINI_API_KEY="YOUR_KEY_HERE"
+GEMINI_API_KEY="YOUR_KEY_HERE"

.huggingface.yml

@@ -1,2 +1,2 @@
-sdk: docker
+sdk: docker
 python_version: 3.12

Dockerfile

@@ -1,44 +1,44 @@
-# syntax=docker/dockerfile:1
-
-FROM python:3.12-slim
-
-# Prevent Python from writing pyc files and buffer stdout/stderr
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=off \
-    POETRY_VIRTUALENVS_CREATE=false
-
-WORKDIR /app
-
-# system deps (add if you need ffmpeg, build-essential, libgl1 etc)
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    ffmpeg \
-    libgl1 \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy requirements first for caching
-COPY ui/requirements.txt ./ui/requirements.txt
-
-# Install pip dependencies (use --no-cache-dir in production)
-RUN python -m pip install --upgrade pip setuptools wheel \
-    && pip install --no-cache-dir -r ui/requirements.txt
-
-# Copy the UI code
-COPY ui/ ./ui/
-
-# Add entrypoint script
-COPY entrypoint.sh /entrypoint.sh
-RUN chmod +x /entrypoint.sh
-
-# Expose common ports (Streamlit default 8501, FastAPI/Flask default 8000)
-EXPOSE 8501 8000
-
-# Default env vars (can be overridden at runtime)
-ENV APP_MODULE="app:app" \
-    APP_TYPE="streamlit" \
-    PORT=8501 \
-    PYTHONPATH="/app/ui"
-
-# Entrypoint handles which server to start
-ENTRYPOINT ["/entrypoint.sh"]
+# syntax=docker/dockerfile:1
+
+FROM python:3.12-slim
+
+# Prevent Python from writing pyc files and buffer stdout/stderr
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=off \
+    POETRY_VIRTUALENVS_CREATE=false
+
+WORKDIR /app
+
+# system deps (add if you need ffmpeg, build-essential, libgl1 etc)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    ffmpeg \
+    libgl1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for caching
+COPY ui/requirements.txt ./ui/requirements.txt
+
+# Install pip dependencies (use --no-cache-dir in production)
+RUN python -m pip install --upgrade pip setuptools wheel \
+    && pip install --no-cache-dir -r ui/requirements.txt
+
+# Copy the UI code
+COPY ui/ ./ui/
+
+# Add entrypoint script
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+# Expose common ports (Streamlit default 8501, FastAPI/Flask default 8000)
+EXPOSE 8501 8000
+
+# Default env vars (can be overridden at runtime)
+ENV APP_MODULE="app:app" \
+    APP_TYPE="streamlit" \
+    PORT=8501 \
+    PYTHONPATH="/app/ui"
+
+# Entrypoint handles which server to start
+ENTRYPOINT ["/entrypoint.sh"]

README.md

@@ -1,10 +1 @@
----
-title: Video Virality Scoring
-emoji: 🎬
-colorFrom: indigo
-colorTo: blue
-sdk: streamlit
-sdk_version: "1.39.0"
-app_file: app.py
-pinned: false
----
+# video-virality-scoring

START_HERE.txt

@@ -1,28 +1,28 @@
-==========================================
-  VIRALITY COACH - DEPLOYMENT PACKAGE
-==========================================
-
-This folder contains everything you need to deploy and run the Virality Coach application.
-
-QUICK START:
-1. Install Python dependencies: pip install -r requirements.txt
-2. Install FFmpeg (required for video processing)
-3. Run: streamlit run ui/app_v2.py
-   OR double-click: run_app.bat (Windows)
-
-FILES INCLUDED:
-✓ All application code (app/, ui/)
-✓ Configuration files (config.py)
-✓ Dependencies (requirements.txt)
-✓ Demo video (demo.mp4)
-✓ Startup scripts (run_app.bat, run_app.sh)
-✓ Documentation (README_DEPLOYMENT.md)
-
-IMPORTANT:
-- API Keys can be entered in the UI or set as environment variables
-- Data directories will be auto-created when you run analyses
-- Demo video is included for testing
-
-See README_DEPLOYMENT.md for detailed instructions.
-
-==========================================
+==========================================
+  VIRALITY COACH - DEPLOYMENT PACKAGE
+==========================================
+
+This folder contains everything you need to deploy and run the Virality Coach application.
+
+QUICK START:
+1. Install Python dependencies: pip install -r requirements.txt
+2. Install FFmpeg (required for video processing)
+3. Run: streamlit run ui/app_v2.py
+   OR double-click: run_app.bat (Windows)
+
+FILES INCLUDED:
+✓ All application code (app/, ui/)
+✓ Configuration files (config.py)
+✓ Dependencies (requirements.txt)
+✓ Demo video (demo.mp4)
+✓ Startup scripts (run_app.bat, run_app.sh)
+✓ Documentation (README_DEPLOYMENT.md)
+
+IMPORTANT:
+- API Keys can be entered in the UI or set as environment variables
+- Data directories will be auto-created when you run analyses
+- Demo video is included for testing
+
+See README_DEPLOYMENT.md for detailed instructions.
+
+==========================================

app/pipeline/audio_analysis.py

@@ -0,0 +1,185 @@
+import os
+import json
+import ffmpeg
+import whisper
+import subprocess
+import base64
+from pathlib import Path
+from typing import Dict, List
+import google.generativeai as genai
+
+from config import make_path, GEMINI_API_KEY
+from app.utils.logging import get_logger
+
+
+class AudioAnalyzer:
+    def __init__(self, video_path: str, gemini_api_key: str = "", model_size: str = 'small'):
+        self.model_size = model_size
+        self.video_path = Path(video_path)
+        self.audio_path = make_path('interim/audio', video_path, 'audio', 'wav')
+        self.json_out = make_path('processed/audio-analysis', video_path, 'audio_analysis', 'json')
+        self.logger = get_logger('audio_analysis', f'{self.video_path.stem}_log.txt')
+
+        # ✅ Set Gemini key (explicit or from environment)
+        if gemini_api_key:
+            genai.configure(api_key=gemini_api_key)
+        else:
+            genai.configure(api_key=os.getenv("GEMINI_API_KEY", ""))
+        self.llm_model = genai.GenerativeModel('gemini-2.5-pro')
+
+    def _extract_audio(self) -> None:
+        self.audio_path.parent.mkdir(parents=True, exist_ok=True)
+        (
+            ffmpeg
+            .input(str(self.video_path))
+            .output(str(self.audio_path), ac=1, ar='16k', format='wav', loglevel='quiet')
+            .overwrite_output()
+            .run()
+        )
+        self.logger.info('Audio extracted to %s', self.audio_path)
+
+    def _transcribe(self) -> Dict:
+        model = whisper.load_model(self.model_size)
+        return model.transcribe(str(self.audio_path), fp16=False)
+
+    def _loudness_stats(self, audio_path: Path) -> Dict:
+        cmd = [
+            'ffmpeg', '-i', str(audio_path),
+            '-af', 'volumedetect',
+            '-f', 'null', 'NUL' if os.name == 'nt' else '/dev/null'
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        mean = peak = None
+        for line in result.stderr.splitlines():
+            if 'mean_volume:' in line:
+                mean = float(line.split('mean_volume:')[1].split()[0])
+            if 'max_volume:' in line:
+                peak = float(line.split('max_volume:')[1].split()[0])
+        return {'loudness_mean': mean, 'loudness_peak': peak}
+
+    def _load_visual_context(self) -> Dict:
+        """Load nearby frames and brightness values from extracted frame data."""
+        frame_json_path = make_path('processed/scene-detection', self.video_path, 'scene', 'json')
+        frames_dir = make_path('interim/frames', self.video_path, '', '')
+
+        if not frame_json_path.exists():
+            self.logger.warning("Frame metadata not found: %s", frame_json_path)
+            return {}
+
+        with open(frame_json_path, 'r', encoding='utf-8') as f:
+            scene_data = json.load(f)
+
+        if not scene_data.get('scenes'):
+            return {}
+
+        scene = scene_data['scenes'][0]
+        mid_time = (float(scene['start_time']) + float(scene['end_time'])) / 2
+        scene_idx = 0
+
+        def get_frame_path(tag):
+            return frames_dir / f"{self.video_path.stem}_scene_{scene_idx:02}{tag}.jpg"
+
+        def encode_image(p: Path) -> str:
+            if p.exists():
+                with open(p, 'rb') as f:
+                    return base64.b64encode(f.read()).decode('utf-8')
+            return ""
+
+        return {
+            'mid_time': mid_time,
+            'frame': encode_image(get_frame_path('')),
+            'prev': encode_image(get_frame_path('_prev')),
+            'next': encode_image(get_frame_path('_next')),
+            'brightness': float(scene.get('brightness', -1.0))
+        }
+
+    def _gemini_audio_analysis(self, text: str, loudness: Dict, wps: float, visuals: Dict) -> Dict:
+        """LLM-enhanced audio analysis using audio + first scene frames + metadata"""
+        prompt = f"""
+        You are an expert video analyst. Based on the transcript, loudness, speaking pace,
+        and the first scene's frames (prev, current, next), analyze the audio tone.
+
+        Answer in JSON only:
+        {{
+        "tone": "calm|excited|angry|funny|sad|neutral",
+        "emotion": "joy|sadness|anger|surprise|neutral|mixed",
+        "pace": "fast|medium|slow",
+        "delivery_score": 0-100,
+        "is_hooking_start": true|false,
+        "comment": "brief summary of audio performance",
+        "is_dark_artistic": true|false,
+        "brightness": 0-100
+        }}
+
+        Transcript: {text}
+        Loudness: {json.dumps(loudness)}
+        Words/sec: {wps}
+        Frame brightness: {visuals.get('brightness')}
+        """
+
+        # ✅ Properly formatted parts for Gemini multimodal prompt
+        parts = [{"text": prompt}]
+        for tag in ['prev', 'frame', 'next']:
+            img_b64 = visuals.get(tag)
+            if img_b64:
+                parts.append({
+                    "inline_data": {
+                        "mime_type": "image/jpeg",
+                        "data": base64.b64decode(img_b64),
+                    }
+                })
+
+        try:
+            response = self.llm_model.generate_content(
+                contents=[{"role": "user", "parts": parts}],
+                generation_config={'temperature': 0.3}
+            )
+            text = getattr(response, 'text', '').strip()
+            cleaned = text.replace('```json', '').replace('```', '')
+            return json.loads(cleaned)
+        except Exception as e:
+            error_msg = str(e)
+            self.logger.error("LLM call failed: %s", e)
+            
+            # Check if it's an API key error - if so, raise it to stop the pipeline
+            if any(keyword in error_msg.lower() for keyword in ["api_key", "invalid", "401", "403", "authentication", "unauthorized"]):
+                raise ValueError(f"Invalid Gemini API key: {error_msg}") from e
+            
+            # For other errors, return defaults but log the issue
+            return {
+                "tone": "neutral",
+                "emotion": "neutral",
+                "pace": "medium",
+                "delivery_score": 50,
+                "is_hooking_start": False,
+                "comment": "LLM analysis failed, using defaults",
+                "is_dark_artistic": False,
+                "brightness": visuals.get("brightness", -1.0)
+            }
+
+    def analyze(self) -> Dict:
+        self._extract_audio()
+        whisper_res = self._transcribe()
+        full_text = whisper_res['text']
+        duration_s = whisper_res['segments'][-1]['end'] if whisper_res['segments'] else 0
+        wps = round(len(full_text.split()) / duration_s, 2) if duration_s else 0
+
+        loudness = self._loudness_stats(self.audio_path)
+        visual_context = self._load_visual_context()
+        gemini_analysis = self._gemini_audio_analysis(full_text, loudness, wps, visual_context)
+
+        result = {
+            'full_transcript': full_text,
+            'duration_seconds': duration_s,
+            'word_count': len(full_text.split()),
+            'words_per_second': wps,
+            **loudness,
+            **gemini_analysis
+        }
+
+        self.json_out.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.json_out, 'w', encoding='utf-8') as f:
+            json.dump(result, f, indent=2)
+
+        self.logger.info('Audio + Visual LLM analysis saved to %s', self.json_out)
+        return result

app/pipeline/frame_analysis.py

@@ -0,0 +1,195 @@
+import os
+import re
+import json
+import base64
+import openai
+from pathlib import Path
+import google.generativeai as genai
+from app.utils.logging import get_logger
+from config import make_path, OPENAI_API_KEY, GEMINI_API_KEY, DATA_DIR
+
+
+class FrameAnalyzer:
+    def __init__(self, video_path: str, openai_api_key: str = "", save_dir: str = 'processed/frame-analysis'):
+        # ✅ Set OpenAI key (explicit or from environment)
+        
+        # print(openai_api_key)
+
+        if openai_api_key:
+            openai.api_key = openai_api_key
+        else:
+            import os
+            openai.api_key = os.getenv("OPENAI_API_KEY")
+
+        self.video_path = Path(video_path)
+        self.frames_dir = DATA_DIR / 'interim' / 'frames' / f'{self.video_path.stem}_'
+        self.save_path = make_path(save_dir, video_path, 'frame_analysis', 'json')
+        self.save_path.parent.mkdir(parents=True, exist_ok=True)
+
+        log_file = f'{self.video_path.stem}_log.txt'
+        self.logger = get_logger('frame_analysis', log_file)
+
+    @staticmethod
+    def encode_image(path: Path) -> str:
+        with open(path, 'rb') as f:
+            return base64.b64encode(f.read()).decode('utf-8')
+
+    @staticmethod
+    def extract_json(text: str) -> dict:
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            pass
+
+        match = re.search(r'```json\s*(\{.*?\})\s*```', text, re.DOTALL)
+        if match:
+            return json.loads(match.group(1))
+
+        match = re.search(r'(\{.*?\})', text, re.DOTALL)
+        if match:
+            return json.loads(match.group(1))
+
+        raise ValueError('No valid JSON found in GPT response')
+
+    def gpt_analyze(self, frame_path: Path, prev_path: Path, next_path: Path) -> dict:
+        prompt = """
+        You are an expert video content strategist. Analyze this video frame and surrounding context. 
+        Determine if the lighting is poor or intentionally low for creative reasons. 
+
+        Output JSON only:
+        {
+          lighting: 0-100,
+          is_artistic_dark: true|false,
+          composition: 0-100,
+          has_text: true|false,
+          text: "string",
+          hook_strength: 0-100
+        }
+        """
+
+        images = [
+            {'type': 'image_url', 'image_url': {'url': f'data:image/jpeg;base64,{self.encode_image(p)}'}}
+            for p in [prev_path, frame_path, next_path] if p.exists()
+        ]
+
+        response = openai.chat.completions.create(
+            model='gpt-4o-mini',
+            messages=[
+                {'role': 'user', 'content': [{'type': 'text', 'text': prompt}] + images}
+            ],
+            temperature=0.2,
+            max_tokens=400,
+        )
+        return self.extract_json(response.choices[0].message.content)
+
+    def analyze(self) -> dict:
+        results = {}
+        all_frames = sorted(self.frames_dir.glob('*_scene_*.jpg'))
+        center_frames = [f for f in all_frames if '_prev' not in f.name and '_next' not in f.name]
+
+        for frame in center_frames:
+            prev = frame.with_name(frame.name.replace('.jpg', '_prev.jpg'))
+            next_ = frame.with_name(frame.name.replace('.jpg', '_next.jpg'))
+
+            self.logger.info('Analyzing frame: %s', frame.name)
+            try:
+                result = self.gpt_analyze(frame, prev, next_)
+                results[frame.name] = result
+            except Exception as e:
+                self.logger.error('LLM analysis failed on %s: %s', frame.name, e)
+                results[frame.name] = {'error': str(e)}
+
+        with open(self.save_path, 'w', encoding='utf-8') as f:
+            json.dump(results, f, indent=2)
+
+        self.logger.info('Frame analysis saved to %s', self.save_path)
+        return results
+
+class HookAnalyzer:
+    def __init__(self, video_path: str, gemini_api_key: str = ""):
+        self.video_path = Path(video_path)
+        self.frames_dir = Path('data/interim/frames') / f'{self.video_path.stem}_'
+        self.audio_json = make_path('processed/audio-analysis', video_path, 'audio_analysis', 'json')
+        self.output_json = make_path('processed/hook-analysis', video_path, 'hook_analysis', 'json')
+        self.logger = get_logger('hook_analysis', f'{self.video_path.stem}_log.txt')
+
+        # ✅ Set Gemini key (explicit or from environment)
+        if gemini_api_key:
+            genai.configure(api_key=gemini_api_key)
+        else:
+            genai.configure(api_key=os.getenv("GEMINI_API_KEY", ""))
+        self.model = genai.GenerativeModel('gemini-2.5-pro')
+
+    def _encode_image(self, path: Path) -> bytes:
+        with open(path, 'rb') as f:
+            return f.read()
+
+    def _load_audio_summary(self) -> dict:
+        with open(self.audio_json, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+    def _gemini_hook_alignment(self, audio_summary: dict, frames: list[Path]) -> dict:
+        parts = [{'mime_type': 'image/jpeg', 'data': self._encode_image(f)} for f in frames if f.exists()]
+        text = f"""You are a virality analyst. Analyze the opening visuals and tone:
+        - Does the audio mood match the expressions and visuals?
+        - Are viewers likely to be hooked in the first few seconds?
+
+        Audio Summary: {json.dumps(audio_summary)}
+
+        Give JSON only:
+        {{
+        "hook_alignment_score": 0-100,
+        "facial_sync": "good|ok|poor|none",
+        "comment": "short summary"
+        }}"""
+
+        try:
+            response = self.model.generate_content([text] + parts)
+            raw_text = getattr(response, 'text', '').strip()
+            self.logger.debug("Gemini raw response: %s", raw_text)
+            if not raw_text:
+                raise ValueError("Gemini response was empty.")
+            
+            raw_text = (
+                raw_text
+                .replace('```json\n', '')
+                .replace('\n```', '')
+                .replace('```json', '')
+                .replace('```', '')
+            )
+
+            return json.loads(raw_text)
+        except json.JSONDecodeError as e:
+            self.logger.error("❌ Failed to parse Gemini response as JSON: %s", e)
+            self.logger.debug("Gemini response was: %r", getattr(response, 'text', '<<NO TEXT>>'))
+            return {
+                "hook_alignment_score": -1,
+                "facial_sync": "none",
+                "comment": "Invalid JSON response from Gemini"
+            }
+        except Exception as e:
+            error_msg = str(e)
+            self.logger.error("❌ Gemini API call failed: %s", e)
+            
+            # Check if it's an API key error - if so, raise it to stop the pipeline
+            if any(keyword in error_msg.lower() for keyword in ["api_key", "invalid", "401", "403", "authentication", "unauthorized"]):
+                raise ValueError(f"Invalid Gemini API key: {error_msg}") from e
+            
+            # For other errors, return defaults
+            return {
+                "hook_alignment_score": -1,
+                "facial_sync": "none",
+                "comment": f"Gemini API error: {error_msg}"
+            }
+
+    def analyze(self) -> dict:
+        audio_summary = self._load_audio_summary()
+        frames = sorted(self.frames_dir.glob('*_scene_*.jpg'))[:3]
+        result = self._gemini_hook_alignment(audio_summary, frames)
+
+        self.output_json.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.output_json, 'w', encoding='utf-8') as f:
+            json.dump(result, f, indent=2)
+
+        self.logger.info('Hook analysis saved to %s', self.output_json)
+        return result

app/pipeline/frame_extract.py

@@ -0,0 +1,99 @@
+import json
+import subprocess
+from pathlib import Path
+from config import make_path
+from app.utils.logging import get_logger
+
+
+class FrameExtractor:
+    def __init__(self, video_path: str, min_scene_len: float = 0.2):
+        self.min_scene_len = min_scene_len
+        self.video_path = Path(video_path)
+        self.scene_json_path = self.frame_json = make_path('processed/scene-detection', video_path, 'scene', 'json')
+        self.output_dir = make_path('interim/frames', video_path, '', '')
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        log_file = f'{self.video_path.stem}_log.txt'
+        self.logger = get_logger('frame_extract', log_file)
+
+    def _ffmpeg_extract(self, timestamp: float, out_path: Path):
+        cmd = [
+            'ffmpeg',
+            '-loglevel', 'error',
+            '-y',
+            '-ss', f'{timestamp:.3f}',
+            '-t', '1',
+            '-i', str(self.video_path),
+            '-frames:v', '1',
+            '-q:v', '2',
+            '-pix_fmt', 'yuvj420p',
+            str(out_path)
+        ]
+        result = subprocess.run(cmd, capture_output=True)
+        if result.returncode != 0:
+            self.logger.error('ffmpeg failed: %s', result.stderr.decode('utf-8', 'ignore').strip())
+
+    def _get_brightness(self, timestamp: float) -> float:
+        cmd = [
+            'ffprobe',
+            '-v', 'error',
+            '-read_intervals', f'%{timestamp}+1',
+            '-select_streams', 'v:0',
+            '-show_frames',
+            '-show_entries', 'frame_tags=lavfi.signalstats.YAVG',
+            '-of', 'default=noprint_wrappers=1:nokey=1',
+            str(self.video_path)
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        try:
+            yavg_values = [float(line.strip()) for line in result.stdout.strip().split('\n') if line.strip()]
+            if yavg_values:
+                return yavg_values[0]
+        except Exception:
+            pass
+        self.logger.warning('Could not get brightness at %.2fs', timestamp)
+        return -1.0
+
+    def extract(self) -> list[dict]:
+        with open(self.scene_json_path, encoding='utf-8') as f:
+            scenes = json.load(f).get('scenes', [])
+        if not scenes:
+            self.logger.warning('No scenes found in %s', self.scene_json_path)
+            return []
+
+        delta = 0.5
+        results = []
+
+        for i, sc in enumerate(scenes):
+            start = float(sc['start_time'])
+            end = float(sc['end_time'])
+            dur = end - start
+            if dur < self.min_scene_len:
+                self.logger.warning('Scene %s too short (%.2fs), skipping', i, dur)
+                continue
+
+            mid = (start + end) / 2
+
+            frame_path = self.output_dir / f'{self.video_path.stem}_scene_{i:02}.jpg'
+            prev_path = self.output_dir / f'{self.video_path.stem}_scene_{i:02}_prev.jpg'
+            next_path = self.output_dir / f'{self.video_path.stem}_scene_{i:02}_next.jpg'
+
+            self._ffmpeg_extract(mid, frame_path)
+            self._ffmpeg_extract(mid - delta, prev_path)
+            self._ffmpeg_extract(mid + delta, next_path)
+
+            brightness = self._get_brightness(mid)
+
+            self.logger.info('[Scene %s] %.2fs → %s | Brightness: %.2f', i, mid, frame_path.name, brightness)
+
+            results.append({
+                'scene_index': i,
+                'timestamp': mid,
+                'frame_path': str(frame_path),
+                'prev_frame_path': str(prev_path),
+                'next_frame_path': str(next_path),
+                'brightness': brightness
+            })
+
+        self.logger.info('%s frames (with context) extracted to %s', len(results), self.output_dir)
+        return results

app/pipeline/scene_detect.py

@@ -0,0 +1,64 @@
+import os
+import json
+from pathlib import Path
+from scenedetect import VideoManager, SceneManager
+from scenedetect.detectors import ContentDetector
+from app.utils.logging import get_logger
+from config import make_path
+
+
+class SceneDetector:
+    def __init__(self, video_path: str, backend='base', return_scenes=False,
+                 min_scene_duration=0.1, threshold=30.0, transition_merge_gap=0.1):
+        self.video_path = video_path
+        self.backend = backend
+        self.return_scenes = return_scenes
+        self.min_scene_duration = min_scene_duration
+        self.threshold = threshold
+        self.transition_merge_gap = transition_merge_gap
+
+        log_filename = f'{Path(video_path).stem}_log.txt'
+        self.logger = get_logger(name='scene_detect', log_file=log_filename)
+
+    def detect(self, start_time: float = 0, end_time: float = -1) -> list:
+        try:
+            self.logger.info(f'Detecting scenes for: {self.video_path}')
+
+            video_manager = VideoManager([self.video_path])
+            scene_manager = SceneManager()
+            scene_manager.add_detector(ContentDetector(threshold=self.threshold))
+
+            video_manager.set_downscale_factor()
+            video_manager.start()
+            scene_manager.detect_scenes(frame_source=video_manager)
+            scene_list = scene_manager.get_scene_list()
+
+            # Format output to match Sieve style
+            scenes = []
+            for start, end in scene_list:
+                scenes.append({
+                    "start": round(start.get_seconds(), 2),
+                    "end": round(end.get_seconds(), 2)
+                })
+
+            self.logger.info(f"{len(scenes)} scenes detected.")
+            return [{"scenes": scenes}]
+
+        except Exception as e:
+            self.logger.error(f'Scene detection failed: {e}')
+            return []
+
+    def detect_and_save(self) -> list:
+        scenes = self.detect()
+        if not scenes:
+            self.logger.warning('No scenes detected. Skipping save.')
+            return []
+
+        out_path = make_path('processed/scene-detection', self.video_path, 'scene', 'json')
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            json.dump({'scenes': scenes[0]['scenes']}, f, indent=2)
+
+        self.logger.info(f'Scene data saved to: {out_path}')
+        return scenes

app/pipeline/scoring.py

@@ -0,0 +1,202 @@
+import openai
+import json
+from pathlib import Path
+from app.utils.logging import get_logger
+from config import make_path, OPENAI_API_KEY
+
+
+class VideoReport:
+    def __init__(self, video_path: str, openai_api_key: str = ""):
+        # ✅ Set OpenAI key (explicit or from environment)
+        if openai_api_key:
+            openai.api_key = openai_api_key
+        else:
+            import os
+            openai.api_key = os.getenv("OPENAI_API_KEY", "")
+        self.video_path = Path(video_path)
+        self.audio_json = make_path('processed/audio-analysis', video_path, 'audio_analysis', 'json')
+        self.frame_json = make_path('processed/frame-analysis', video_path, 'frame_analysis', 'json')
+        self.hook_json = make_path('processed/hook-analysis', video_path, 'hook_analysis', 'json')
+        self.output_json = make_path('reports', video_path, 'final_report', 'json')
+
+        log_filename = f'{self.video_path.stem}_log.txt'
+        self.logger = get_logger(name='video_report', log_file=log_filename)
+
+        self.audio_analysis = self.load_json(self.audio_json)
+        self.frame_analysis = self.load_json(self.frame_json)
+        self.hook_analysis = self.load_json(self.hook_json)
+
+    def load_json(self, path: Path):
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception:
+            return {}
+
+    def extract_matrices(self):
+        return {
+            "tone": self.audio_analysis.get("tone", "unknown"),
+            "emotion": self.audio_analysis.get("emotion", "unknown"),
+            "pace": self.audio_analysis.get("pace", "unknown"),
+            "facial_sync": self.hook_analysis.get("facial_sync", "unknown")
+        }
+
+    def prepare_prompt(self) -> str:
+        prompt_sections = []
+        prompt_sections.append(f"""
+        You are an expert evaluator trained to assess the **virality potential and content quality** of short-form video ads (e.g., TikToks, Reels). You are provided with:
+
+        - A sequence of scene-selected **frames**
+        - A full **audio transcription**
+        - Detailed **audio statistics**
+        - And other meta-data of videos
+                                
+        Your task is to analyze the video and assign the **five scores** with weighted importance. Follow the criteria and format strictly.
+                                
+        ---
+                                
+        ### 🎯 Scores to Judge (Each 0–100)
+
+        You must evaluate the following sub-categories:
+
+        - `hook`: Does the video grab attention in the first 3 seconds? A good hook is **surprising, emotional, funny, or visually intense**. A poor hook is **slow, random, or bland**.
+        
+        - `visuals`: Are visuals high-resolution, diverse, and relevant to the message? Good visuals are **intentional and professionally framed**. Poor visuals are **static, noisy, or irrelevant**.
+        
+        - `audio`: Is the audio clean, engaging, and well-synced? Quality audio has **clarity, proper levels, and supports the visuals**. Poor audio is **distracting, flat, or off-sync**.
+        
+        - `engagement`: Does the video maintain interest? Strong pacing, emotional depth, or thought-provoking content improves this. Weak pacing or meaningless content hurts it.
+        
+        - `visual_diversity`: Does the video use **multiple camera angles, transitions, or visual styles**? A lack of variation makes it feel stale.
+
+        ---
+                                
+        ### 📌 Scoring Enforcement Guidelines
+
+        - Be **strict**: Low-effort content should fall well below 50  
+        - Be **realistic**: Reward polish, creativity, clarity, and emotional impact  
+        - Only videos with **clear intent and great execution** should reach 80+  
+        - Penalize poor hooks, bland visuals, unclear audio, or meaningless structure  
+        - Ensure your scores reflect meaningful differences between videos — **don't cluster everything around 60**
+        
+        ---
+        """)
+
+        if self.audio_analysis:
+            prompt_sections.append("Audio Analysis:\n" + json.dumps(self.audio_analysis, indent=2))
+        if self.frame_analysis:
+            prompt_sections.append("\nFrame Analysis:\n" + json.dumps(self.frame_analysis, indent=2))
+        if self.hook_analysis:
+            prompt_sections.append("\nHook Alignment Analysis:\n" + json.dumps(self.hook_analysis, indent=2))
+
+        matrices = self.extract_matrices()
+        prompt_sections.append("\nHere are extracted behavioral/performance matrices:\n" + json.dumps(matrices, indent=2))
+
+        prompt_sections.append(f"""
+        ### 📤 Output Format (JSON Only — No Comments or Explanations):
+        {{
+        "video_name": "{self.video_path.stem}",
+        "scores": {{
+            "hook": 0,
+            "visuals": 0,
+            "audio": 0,
+            "engagement": 0,
+            "visual_diversity": 0
+        }},
+        "matrices": {{
+            "tone": "",
+            "emotion": "",
+            "pace": "",
+            "facial_sync": ""
+        }},
+        "summary": "",
+        "suggestions": [
+            "Specific improvement 1",
+            "Specific improvement 2",
+            "Specific improvement 3",
+            ... more if required
+        ]
+        }}
+        """)
+        return "\n".join(prompt_sections)
+
+    def query_llm(self, prompt: str) -> dict:
+        try:
+            response = openai.chat.completions.create(
+                model='gpt-4o',
+                messages=[
+                    {"role": "system", "content": "You are a professional short-video quality evaluator."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.4,
+            )
+            reply = response.choices[0].message.content.strip()
+            cleaned = reply.replace('```json', '').replace('```', '')
+            result = json.loads(cleaned)
+            return result
+        except Exception as e:
+            self.logger.error(f"LLM generation failed: {e}")
+            return {
+                "scores": {
+                    "hook": 0,
+                    "visuals": 0,
+                    "audio": 0,
+                    "engagement": 0,
+                    "visual_diversity": 0
+                },
+                "matrices": self.extract_matrices(),
+                "summary": "Failed to generate report.",
+                "suggestions": ["Try again", "Check input files", "Verify OpenAI key"]
+            }
+    
+    def compute_virality_score(self, result):
+        weights = {
+            'hook': 0.18,
+            'visuals': 0.20,
+            'audio': 0.25,
+            'engagement': 0.27,
+            'visual_diversity': 0.10
+        }
+
+        sub_scores = result["scores"]
+        base_score = sum(sub_scores[key] * weights[key] for key in weights)
+
+        bonus = 0
+        matrices = result.get("matrices", {})
+
+        if matrices.get("emotion") in ["joy", "inspiration"]:
+            bonus += 6
+        if matrices.get("tone") in ["funny", "relatable"]:
+            bonus += 6
+        if matrices.get("facial_sync") in ["ok", "good"]:
+            bonus += 4
+
+        if sub_scores.get("hook", 0) <= 30:
+            bonus -= 6
+        if sub_scores.get("audio", 0) < 40:
+            bonus -= 5
+        if matrices.get("facial_sync") == "none":
+            bonus -= 5
+
+        final_score = max(0, min(100, int(base_score + bonus)))
+        return final_score
+
+    def generate(self) -> dict:
+        self.logger.info("Preparing prompt for LLM...")
+        prompt = self.prepare_prompt()
+
+        self.logger.info("Querying LLM for report generation...")
+        result = self.query_llm(prompt)
+        total_score = self.compute_virality_score(result)
+        final_output = {
+            "video_name": self.video_path.stem,
+            "total_score":  total_score,
+            **result  
+        }
+        self.logger.info("Saving final report...")
+        self.output_json.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.output_json, 'w', encoding='utf-8') as f:
+            json.dump(final_output, f, indent=2)
+
+        self.logger.info("Report successfully generated at %s", self.output_json)
+        return final_output

app/utils/logging.py

@@ -0,0 +1,19 @@
+import logging
+from pathlib import Path
+from config import LOG_DIR
+
+
+def get_logger(name='vc', log_file: str = 'latest.log', level='INFO'):
+    Path(LOG_DIR).mkdir(exist_ok=True)
+    log_path = LOG_DIR / log_file
+
+    logger = logging.getLogger(name)
+    logger.setLevel(level.upper())
+
+    if not logger.handlers:
+        handler = logging.FileHandler(log_path, encoding='utf-8')
+        formatter = logging.Formatter('%(asctime)s | %(levelname)-7s | %(name)s | %(message)s')
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    return logger

config.py

@@ -1,29 +1,29 @@
-import os
-from pathlib import Path
-
-
-ROOT_DIR = Path(__file__).resolve().parent
-
-LOG_DIR = ROOT_DIR / 'logs'
-DATA_DIR = ROOT_DIR / 'data'
-
-OPENAI_API_KEY = os.getenv('OPENAI_API_KEY', '')
-GEMINI_API_KEY = os.getenv('GEMINI_API_KEY', '')
-SIEVE_API_KEY = os.getenv('SIEVE_API_KEY', '')
-WHISPER_MODEL = os.getenv('WHISPER_MODEL', 'base')
-
-
-def make_name(video_path: str, suffix: str, ext: str) -> str:
-    """
-    Returns: myvideo_transcript.json (etc.)
-    """
-    stem = Path(video_path).stem
-    return f'{stem}_{suffix}.{ext}'
-
-
-def make_path(subdir: str, video_path: str, suffix: str, ext: str) -> Path:
-    """
-    Returns: full path inside subfolder (e.g. data/processed/myvideo_scene.json)
-    """
-    filename = make_name(video_path, suffix, ext)
-    return DATA_DIR / subdir / filename
+import os
+from pathlib import Path
+
+
+ROOT_DIR = Path(__file__).resolve().parent
+
+LOG_DIR = ROOT_DIR / 'logs'
+DATA_DIR = ROOT_DIR / 'data'
+
+OPENAI_API_KEY = os.getenv('OPENAI_API_KEY', '')
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY', '')
+SIEVE_API_KEY = os.getenv('SIEVE_API_KEY', '')
+WHISPER_MODEL = os.getenv('WHISPER_MODEL', 'base')
+
+
+def make_name(video_path: str, suffix: str, ext: str) -> str:
+    """
+    Returns: myvideo_transcript.json (etc.)
+    """
+    stem = Path(video_path).stem
+    return f'{stem}_{suffix}.{ext}'
+
+
+def make_path(subdir: str, video_path: str, suffix: str, ext: str) -> Path:
+    """
+    Returns: full path inside subfolder (e.g. data/processed/myvideo_scene.json)
+    """
+    filename = make_name(video_path, suffix, ext)
+    return DATA_DIR / subdir / filename

demo.txt

@@ -0,0 +1,61 @@
+name: Deploy to Hugging Face Spaces
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout Repository
+      uses: actions/checkout@v3
+
+    - name: Set Up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.8'
+
+    - name: Install Dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install torch --index-url https://download.pytorch.org/whl/cpu
+        pip install -r requirements.txt
+        pip install huggingface_hub
+        
+     
+        
+
+    - name: Configure Git User
+      run: |
+        git config --global user.name "github-actions[bot]"
+        git config --global user.email "github-actions[bot]@users.noreply.github.com"
+
+    - name: Deploy to Hugging Face Space
+      env:
+        HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        HF_USERNAME: ${{ secrets.HF_USERNAME }}
+        HF_SPACE_NAME: ${{ secrets.HF_SPACE_NAME }}
+      run: |
+        # Store credentials
+        echo "https://$HF_USERNAME:$HF_TOKEN@huggingface.co" > ~/.git-credentials
+        git config --global credential.helper store
+        
+        # Clone the space repository
+        git clone https://huggingface.co/spaces/$HF_USERNAME/$HF_SPACE_NAME repo
+        
+        # Copy files to the repo directory
+        rsync -av --exclude={'.git','repo'} ./ repo/
+        
+        # Push changes
+        cd repo
+        git add .
+        git commit -m "Automated deployment" || echo "No changes to commit"
+        git push https://huggingface.co/spaces/$HF_USERNAME/$HF_SPACE_NAME main
+
+    - name: Cleanup Credentials
+      if: always()
+      run: |
+        rm -f ~/.git-credentials

packages.txt

@@ -1,5 +1,5 @@
-libgl1-mesa-glx
-libglib2.0-0
-libsm6
-libxext6
-libxrender1
+libgl1-mesa-glx
+libglib2.0-0
+libsm6
+libxext6
+libxrender1

ui/app.py

@@ -0,0 +1,936 @@
+import re
+import sys
+import json
+import time
+import signal
+import traceback
+import threading
+import unicodedata
+import hashlib
+from pathlib import Path
+import plotly.express as px
+import yt_dlp
+import streamlit as st
+
+# -----------------------------
+# Safe signal handling for non-main thread environments (yt_dlp)
+# -----------------------------
+if threading.current_thread() is not threading.main_thread():
+    _orig_signal = signal.signal
+
+    def _safe(sig, handler):
+        if sig in (signal.SIGTERM, signal.SIGINT):
+            return
+        return _orig_signal(sig, handler)
+
+    signal.signal = _safe
+
+# -----------------------------
+# Project paths & imports
+# -----------------------------
+ROOT = Path(__file__).resolve().parents[1]
+ROOT_STR = str(ROOT.resolve())  # Ensure absolute path
+# Insert at beginning for higher priority
+if ROOT_STR not in sys.path:
+    sys.path.insert(0, ROOT_STR)
+
+# Verify app package exists
+app_dir = ROOT / "app"
+if not app_dir.exists():
+    raise ImportError(f"Cannot find 'app' package at {app_dir}. ROOT={ROOT}")
+
+from config import make_path
+from app.pipeline.scene_detect import SceneDetector
+from app.pipeline.frame_extract import FrameExtractor
+
+# -----------------------------
+# Storage layout
+# -----------------------------
+DATA_DIR = ROOT / "data"
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+for name in ["raw", "interim", "processed", "reports"]:
+    (DATA_DIR / name).mkdir(parents=True, exist_ok=True)
+
+RAW_DIR = DATA_DIR / "raw"
+INTERIM_DIR = DATA_DIR / "interim"
+PROCESSED_DIR = DATA_DIR / "processed"
+REPORTS_DIR = DATA_DIR / "reports"
+
+# -----------------------------
+# Utilities
+# -----------------------------
+def sanitize_title(title: str, max_length: int = 150) -> str:
+    title = unicodedata.normalize("NFKD", title)
+    title = title.encode("ascii", "ignore").decode("ascii")
+    title = re.sub(r"#\w+", "", title)
+    title = re.sub(r"[^\w\s]", "", title)
+    title = re.sub(r"\s+", " ", title).strip()
+    title = title.lower()
+    return title[:max_length]
+
+
+def sanitize_filename(filename: str) -> str:
+    filename = filename.lower().replace(" ", "_")
+    filename = unicodedata.normalize("NFKD", filename)
+    filename = filename.encode("ascii", "ignore").decode("ascii")
+    filename = re.sub(r"[^a-z0-9._-]", "", filename)
+    return filename.strip()
+
+
+def create_short_path(video_path: Path) -> str:
+    """Create a short identifier for frame directories to avoid Windows path limits"""
+    path_str = str(video_path)
+    # Create a short hash of the full path
+    path_hash = hashlib.md5(path_str.encode()).hexdigest()[:12]
+    return f"frames_{path_hash}"
+
+
+def get_frames_directory(video_path: Path) -> Path:
+    """Get the frames directory path using short naming to avoid Windows path limits"""
+    short_id = create_short_path(video_path)
+    return INTERIM_DIR / "frames" / short_id
+
+
+def download_video(url: str) -> tuple[Path, str]:
+    with yt_dlp.YoutubeDL({"quiet": True}) as ydl:
+        info = ydl.extract_info(url, download=False)
+        original_title = info.get("title", "video")
+        ext = info.get("ext", "mp4")
+
+    clean_title = sanitize_title(original_title)
+    sanitized_name = sanitize_filename(clean_title) or "video"
+    filename = f"{sanitized_name}.{ext}"
+    file_path = RAW_DIR / filename
+
+    if not file_path.exists():
+        ydl_opts = {
+            "outtmpl": str(file_path),
+            "restrictfilenames": True,
+            "quiet": True,
+            "noplaylist": True,
+            "no_color": True,
+            "format": "bv*+ba/b",
+        }
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([url])
+
+    return file_path, clean_title
+
+
+def get_paths(video_path: Path):
+    vp_str = str(video_path)
+    audio_json = make_path("processed/audio-analysis", vp_str, "audio_analysis", "json")
+    report_json = make_path("reports", vp_str, "final_report", "json")
+    scene_json = make_path("processed/scene-detection", vp_str, "scene", "json")
+    frame_json = make_path("processed/frame-analysis", vp_str, "frame_analysis", "json")
+    hook_json = make_path("processed/hook-analysis", vp_str, "hook_analysis", "json")
+    return scene_json, frame_json, audio_json, hook_json, report_json
+
+
+def safe_load_json(path: Path | str):
+    p = Path(path)
+    if p.exists():
+        try:
+            with p.open(encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return {}
+    return {}
+
+
+def remove_artifacts(video_path: Path):
+    try:
+        if video_path and video_path.exists():
+            video_path.unlink(missing_ok=True)
+    except Exception:
+        pass
+
+# -----------------------------
+# Streamlit page config & styles
+# -----------------------------
+st.set_page_config(page_title="Virality Coach", layout="wide")
+
+st.markdown(
+    """
+    <style>
+      footer{display:none}
+      .block-container{padding-top:1rem;padding-bottom:2rem;max-width:1100px}
+      .title-center{text-align:center;margin-bottom:0.2rem}
+      .desc-center{text-align:center;margin-bottom:1.2rem;color:#dbdbdb}
+      .metric-card{background:#1f2937;border-radius:12px;padding:1.25rem;text-align:center;box-shadow:0 2px 8px rgba(0,0,0,.08);height:100%}
+      .metric-card h4{margin:0;font-size:0.95rem;color:#d1d5db}
+      .metric-card p{margin:0;font-size:1.8rem;font-weight:700;color:#ffffff}
+      video{max-height:240px;border-radius:10px;margin-bottom:0.5rem}
+      .status-msg{font-size:0.9rem;margin:0}
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+st.markdown('<h1 class="title-center">Video Virality Coach</h1>', unsafe_allow_html=True)
+st.markdown('<p class="desc-center">An AI-powered system that analyzes and scores the virality potential of short-form videos (TikTok, Reels, Shorts) and delivers clear, actionable feedback to creators and marketers.</p>', unsafe_allow_html=True)
+
+# -----------------------------
+# Session state
+# -----------------------------
+DEFAULT_STATE = {
+    "mode": None,
+    "url": "",
+    "uploaded_name": None,
+    "video_path": None,
+    "clean_title": None,
+    "stage": None,
+    "progress": 0,
+    "status": [],
+    "cancel": False,
+    "error_msg": None,
+    "_ready_to_run": False,
+}
+
+for k, v in DEFAULT_STATE.items():
+    if k not in st.session_state:
+        st.session_state[k] = v
+
+
+def reset_state(clear_video: bool = True):
+    keep = st.session_state.get("video_path") if not clear_video else None
+    st.session_state.update(DEFAULT_STATE | {"video_path": keep})
+
+
+def push_status(msg: str):
+    st.session_state.status.append(msg)
+
+
+# -----------------------------
+# Pipeline step executor
+# -----------------------------
+STAGES = ["download video", "scene detection", "frames extraction", "frame analysis", "audio analysis", "hook analysis", "report"]
+
+PROGRESS_MAP = {
+    "download video": 10,
+    "scene detection": 25,
+    "frames extraction": 40,
+    "frame analysis": 55,
+    "audio analysis": 70,
+    "hook analysis": 85,
+    "report": 100,
+}
+
+
+def _run_current_stage():
+    """
+    Run the heavy work for the current stage.
+    This is called only when _ready_to_run is True,
+    so the UI has already rendered progress/cancel.
+    """
+    stage = st.session_state.stage
+    if not stage or stage in ("done", "error"):
+        return
+
+    if st.session_state.cancel:
+        push_status("⚠️ Process canceled by user.")
+        print("[INFO] Processing canceled by user.")
+        st.session_state.stage = None
+        st.session_state.progress = 0
+        try:
+            vp = st.session_state.video_path
+            if vp:
+                remove_artifacts(Path(vp))
+        except Exception:
+            pass
+        st.session_state._ready_to_run = False
+        st.rerun()
+
+    try:
+        vp = Path(st.session_state.video_path) if st.session_state.video_path else None
+
+        if stage == "download video":
+            push_status("Starting download…")
+            print(f"[INFO] Stage: Downloading video from {st.session_state.url}")
+            path, title = download_video(st.session_state.url)
+            st.session_state.video_path = str(path)
+            st.session_state.clean_title = title
+
+            # Skip full pipeline if a report already exists
+            _, _, _, _, report_json = get_paths(path)
+            if Path(report_json).exists():
+                push_status("📄 Report already exists. Skipping analysis.")
+                print("[INFO] Report already exists, skipping pipeline.")
+                st.session_state.progress = 100
+                st.session_state.stage = "done"
+                st.session_state._ready_to_run = False
+                st.rerun()
+
+            st.session_state.progress = PROGRESS_MAP[stage]
+            push_status("✅ Download complete.")
+            print("[INFO] Download complete.")
+            st.session_state.stage = "scene detection"
+            st.session_state._ready_to_run = False
+            st.rerun()
+
+        elif stage == "scene detection":
+            push_status("Detecting scenes…")
+            print("[INFO] Stage: Scene detection started.")
+            try:
+                scene_detector = SceneDetector(str(vp))
+                scene_detector.detect_and_save()
+                
+                # Verify the scene detection file was created
+                scene_json, _, _, _, _ = get_paths(vp)
+                if not Path(scene_json).exists():
+                    raise FileNotFoundError("Scene detection failed - no output file")
+                
+                # Verify the scene file has the expected structure
+                scene_data = safe_load_json(scene_json)
+                if not scene_data or 'scenes' not in scene_data:
+                    raise ValueError("Scene detection produced invalid results - no 'scenes' key")
+                
+                # Check if scenes have the required 'start_time' field
+                if scene_data['scenes'] and 'start_time' not in scene_data['scenes'][0]:
+                    print("[WARNING] Scene data missing 'start_time' field, adding compatible structure")
+                    # Convert the scene data to the expected format
+                    fixed_scenes = []
+                    for i, scene in enumerate(scene_data['scenes']):
+                        fixed_scene = {
+                            'start_time': scene.get('start', 0),  # Use 'start' if available, else 0
+                            'end_time': scene.get('end', 0),      # Use 'end' if available, else 0
+                            'duration': scene.get('duration', 0), # Use 'duration' if available, else 0
+                            'scene_number': i
+                        }
+                        fixed_scenes.append(fixed_scene)
+                    
+                    scene_data['scenes'] = fixed_scenes
+                    
+                    # Save the fixed scene data
+                    with open(scene_json, 'w', encoding='utf-8') as f:
+                        json.dump(scene_data, f, indent=2)
+                    
+                st.session_state.progress = PROGRESS_MAP[stage]
+                push_status("✅ Scene detection done.")
+                print("[INFO] Scene detection complete.")
+                st.session_state.stage = "frames extraction"
+                st.session_state._ready_to_run = False
+                st.rerun()
+                
+            except Exception as e:
+                # If scene detection fails, create a compatible scene file
+                print(f"[WARNING] Scene detection failed: {e}. Creating fallback scene data.")
+                push_status("⚠️ Scene detection failed. Using fallback scene data.")
+                
+                scene_json, _, _, _, _ = get_paths(vp)
+                
+                # Create compatible scene data with required 'start_time' field
+                fallback_scene_data = {
+                    "scenes": [{
+                        "start_time": 0,
+                        "end_time": 30,  # Assume 30 second scenes
+                        "duration": 30,
+                        "scene_number": 0
+                    }]
+                }
+                
+                # Ensure directory exists
+                Path(scene_json).parent.mkdir(parents=True, exist_ok=True)
+                
+                with open(scene_json, 'w', encoding='utf-8') as f:
+                    json.dump(fallback_scene_data, f, indent=2)
+                
+                st.session_state.progress = PROGRESS_MAP[stage]
+                push_status("✅ Using fallback scene detection.")
+                st.session_state.stage = "frames extraction"
+                st.session_state._ready_to_run = False
+                st.rerun()
+
+        elif stage == "frames extraction":
+            push_status("Extracting frames…")
+            print("[INFO] Stage: Frame extraction started.")
+            # Use the original FrameExtractor without modification
+            FrameExtractor(str(vp)).extract()
+            st.session_state.progress = PROGRESS_MAP[stage]
+            push_status("✅ Frame extraction done.")
+            print("[INFO] Frame extraction complete.")
+            st.session_state.stage = "frame analysis"
+            st.session_state._ready_to_run = False
+            st.rerun()
+
+        elif stage == "frame analysis":
+            push_status("Analyzing frames…")
+            if st.session_state.openai_key and st.session_state.openai_key.strip():
+                from app.pipeline.frame_analysis import FrameAnalyzer
+                try:
+                    FrameAnalyzer(str(vp), openai_api_key=st.session_state.openai_key.strip()).analyze()
+                except Exception as api_error:
+                    error_msg = str(api_error)
+                    if "invalid" in error_msg.lower() or "401" in error_msg or "authentication" in error_msg.lower():
+                        st.session_state.stage = "error"
+                        st.session_state.error_msg = f"OPENAI API KEY FAILED: Invalid OpenAI API Key provided. Please verify your API key is correct."
+                        st.session_state._ready_to_run = False
+                        st.rerun()
+                    else:
+                        raise
+            else:
+                st.session_state.stage = "error"
+                st.session_state.error_msg = "OPENAI API KEY FAILED: OpenAI API Key is required for frame analysis but was not provided."
+                st.session_state._ready_to_run = False
+                st.rerun()
+            st.session_state.progress = PROGRESS_MAP[stage]
+            push_status("✅ Frame analysis done.")
+            st.session_state.stage = "audio analysis"
+            st.session_state._ready_to_run = False
+            st.rerun()
+
+        elif stage == "audio analysis":
+            push_status("Analyzing audio…")
+            if st.session_state.gemini_key and st.session_state.gemini_key.strip():
+                from app.pipeline.audio_analysis import AudioAnalyzer
+                try:
+                    AudioAnalyzer(str(vp), gemini_api_key=st.session_state.gemini_key.strip()).analyze()
+                except (ValueError, Exception) as api_error:
+                    error_msg = str(api_error)
+                    if "invalid" in error_msg.lower() or "401" in error_msg or "403" in error_msg or "api_key" in error_msg.lower() or "authentication" in error_msg.lower():
+                        st.session_state.stage = "error"
+                        st.session_state.error_msg = f"GEMINI API KEY FAILED: Invalid Gemini API Key provided. Error: {error_msg}"
+                        st.session_state._ready_to_run = False
+                        st.rerun()
+                    else:
+                        raise
+            else:
+                st.session_state.stage = "error"
+                st.session_state.error_msg = "GEMINI API KEY FAILED: Gemini API Key is required for audio analysis but was not provided."
+                st.session_state._ready_to_run = False
+                st.rerun()
+            st.session_state.progress = PROGRESS_MAP[stage]
+            push_status("✅ Audio analysis done.")
+            st.session_state.stage = "hook analysis"
+            st.session_state._ready_to_run = False
+            st.rerun()
+
+        elif stage == "hook analysis":
+            push_status("Evaluating hook…")
+            if st.session_state.gemini_key and st.session_state.gemini_key.strip():
+                from app.pipeline.frame_analysis import HookAnalyzer
+                try:
+                    HookAnalyzer(str(vp), gemini_api_key=st.session_state.gemini_key.strip()).analyze()
+                except (ValueError, Exception) as api_error:
+                    error_msg = str(api_error)
+                    if "invalid" in error_msg.lower() or "401" in error_msg or "403" in error_msg or "api_key" in error_msg.lower() or "authentication" in error_msg.lower():
+                        st.session_state.stage = "error"
+                        st.session_state.error_msg = f"GEMINI API KEY FAILED: Invalid Gemini API Key provided. Error: {error_msg}"
+                        st.session_state._ready_to_run = False
+                        st.rerun()
+                    else:
+                        raise
+            else:
+                st.session_state.stage = "error"
+                st.session_state.error_msg = "GEMINI API KEY FAILED: Gemini API Key is required for hook analysis but was not provided."
+                st.session_state._ready_to_run = False
+                st.rerun()
+            st.session_state.progress = PROGRESS_MAP[stage]
+            push_status("✅ Hook analysis done.")
+            st.session_state.stage = "report"
+            st.session_state._ready_to_run = False
+            st.rerun()
+
+        elif stage == "report":
+            push_status("Generating final report…")
+            if st.session_state.openai_key and st.session_state.openai_key.strip():
+                from app.pipeline.scoring import VideoReport
+                try:
+                    VideoReport(str(vp), openai_api_key=st.session_state.openai_key.strip()).generate()
+                except Exception as api_error:
+                    error_msg = str(api_error)
+                    if "invalid" in error_msg.lower() or "401" in error_msg or "authentication" in error_msg.lower():
+                        st.session_state.stage = "error"
+                        st.session_state.error_msg = f"OPENAI API KEY FAILED: Invalid OpenAI API Key provided. Error: {error_msg}"
+                        st.session_state._ready_to_run = False
+                        st.rerun()
+                    else:
+                        raise
+            else:
+                st.session_state.stage = "error"
+                st.session_state.error_msg = "OPENAI API KEY FAILED: OpenAI API Key is required for report generation but was not provided."
+                st.session_state._ready_to_run = False
+                st.rerun()
+            st.session_state.progress = PROGRESS_MAP[stage]
+            push_status("🎉 Video report ready!")
+            st.session_state.stage = "done"
+            st.session_state._ready_to_run = False
+            st.rerun()
+
+    except Exception as e:
+        err_type = type(e).__name__
+        err_msg = str(e).strip()
+        tb_last = traceback.format_exc(limit=1).strip() 
+        st.session_state.stage = "error"
+        st.session_state.error_msg = f"{err_type}: {err_msg}\n➡️ {tb_last}"
+        st.session_state.progress = 0
+        st.session_state._ready_to_run = False
+        push_status(f"❌ {err_type}: {err_msg}")
+        st.rerun()
+
+
+def run_next_stage_if_needed():
+    if not st.session_state.stage or st.session_state.stage in ("done", "error"):
+        return
+    if not st.session_state._ready_to_run:
+        st.session_state._ready_to_run = True
+        time.sleep(0.01)
+        st.rerun()
+    else:
+        _run_current_stage()
+
+
+# -----------------------------
+# Input section
+# -----------------------------
+
+report, api_tab = st.tabs(["Upload Video", "🔑 API Configuration"])
+
+with api_tab:
+    st.markdown("### Configure Your API Keys")
+    st.markdown("Enter your API keys below. Keys will be validated during analysis. If a key is invalid, you'll see an error message during the analysis stage.")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.session_state.openai_key = st.text_input(
+            "OpenAI API Key",
+            type="password",
+            placeholder="sk-...",
+            help="Required for frame analysis and report generation",
+            value=st.session_state.get("openai_key", "")
+        )
+    
+    with col2:
+        st.session_state.gemini_key = st.text_input(
+            "Gemini API Key", 
+            type="password",
+            placeholder="AIza...",
+            help="Required for audio analysis and hook analysis",
+            value=st.session_state.get("gemini_key", "")
+        )
+    
+    st.markdown("---")
+    st.info("💡 Add your API keys and return to the Upload Video tab to start analysis. Invalid keys will show error messages during the analysis process.")
+
+if 'openai_key' not in st.session_state:
+    st.session_state.openai_key = ""
+if 'gemini_key' not in st.session_state:
+    st.session_state.gemini_key = ""
+
+with report:
+    method = st.radio("Choose Upload Method", ["Paste Video URL", "Upload MP4 File"], horizontal=True)
+
+    col_in_1, col_in_2 = st.columns([1, 1])
+
+    if method == "Paste Video URL":
+        st.session_state.mode = "url"
+        url = st.text_input(
+            "Paste direct video URL [insta / tiktok / yt-shorts]",
+            placeholder="https://example.com/@username/video/123",
+            value=st.session_state.url,
+        )
+        st.session_state.url = url
+        run_from_url = col_in_1.button("Run Analysis", key="run_url")
+
+        if run_from_url:
+            if not url:
+                st.error("❌ Please enter a video URL.")
+            else:
+                st.session_state.cancel = False
+                st.session_state.stage = "download video"
+                st.session_state.status = []
+                st.session_state.progress = 0
+                st.session_state._ready_to_run = False 
+                st.rerun()
+
+    else:
+        st.session_state.mode = "file"
+        uploaded = st.file_uploader("Upload MP4 File", type=["mp4"])
+        run_from_file = col_in_1.button("Run Analysis", key="run_file")
+
+        if uploaded and run_from_file:
+            clean_name = sanitize_filename(Path(uploaded.name).stem) + ".mp4"
+            dest = RAW_DIR / clean_name
+            with dest.open("wb") as f:
+                f.write(uploaded.getbuffer())
+            st.session_state.video_path = str(dest)
+            st.session_state.clean_title = Path(clean_name).stem
+
+            # Skip if a report is already present
+            _, _, _, _, report_json = get_paths(dest)
+            if Path(report_json).exists():
+                st.session_state.stage = "done"
+                st.session_state.status = ["📄 Report already exists. Skipping analysis."]
+                st.session_state.progress = 100
+                st.rerun()
+
+            st.session_state.cancel = False
+            st.session_state.status = ["✅ Upload complete."]
+            st.session_state.progress = 0
+            st.session_state.stage = "scene detection"
+            st.session_state._ready_to_run = False  
+            st.rerun()
+
+# -----------------------------
+# Progress & Status
+# -----------------------------
+if st.session_state.stage and st.session_state.stage not in ("done", "error"):
+    percent = st.session_state.progress
+    stage = st.session_state.stage.replace("_", " ").title()
+    
+    st.markdown(f"##### {stage}: {percent}%")
+    st.progress(percent)
+
+    if st.button("Cancel Processing"):
+        st.session_state.cancel = True
+        st.rerun()
+
+run_next_stage_if_needed()
+
+# -----------------------------
+# Error state
+# -----------------------------
+if st.session_state.stage == "error":
+    error_msg = st.session_state.error_msg or "An unknown error occurred."
+    
+    # Detect which API key failed and display prominently
+    if "openai" in error_msg.lower() or "openai" in str(st.session_state.error_msg).lower():
+        st.error("🚨 **API KEY ERROR: OpenAI Key Failed**")
+        st.markdown("""
+        <div style='background-color: #fee2e2; border-left: 4px solid #ef4444; padding: 1rem; margin: 1rem 0; border-radius: 4px;'>
+            <h4 style='color: #991b1b; margin-top: 0;'>❌ OpenAI API Key Invalid or Missing</h4>
+            <p style='color: #7f1d1d; margin-bottom: 0;'><strong>Error Details:</strong> {}</p>
+            <p style='color: #7f1d1d; margin-top: 0.5rem;'>Please go to the <strong>🔑 API Configuration</strong> tab and update your OpenAI API key.</p>
+        </div>
+        """.format(error_msg), unsafe_allow_html=True)
+    elif "gemini" in error_msg.lower() or "gemini" in str(st.session_state.error_msg).lower():
+        st.error("🚨 **API KEY ERROR: Gemini Key Failed**")
+        st.markdown("""
+        <div style='background-color: #fee2e2; border-left: 4px solid #ef4444; padding: 1rem; margin: 1rem 0; border-radius: 4px;'>
+            <h4 style='color: #991b1b; margin-top: 0;'>❌ Gemini API Key Invalid or Missing</h4>
+            <p style='color: #7f1d1d; margin-bottom: 0;'><strong>Error Details:</strong> {}</p>
+            <p style='color: #7f1d1d; margin-top: 0.5rem;'>Please go to the <strong>🔑 API Configuration</strong> tab and update your Gemini API key.</p>
+        </div>
+        """.format(error_msg), unsafe_allow_html=True)
+    else:
+        # Generic error display
+        st.error("🚨 **ANALYSIS FAILED**")
+        st.markdown(f"""
+        <div style='background-color: #fee2e2; border-left: 4px solid #ef4444; padding: 1rem; margin: 1rem 0; border-radius: 4px;'>
+            <h4 style='color: #991b1b; margin-top: 0;'>❌ Error Occurred</h4>
+            <p style='color: #7f1d1d; margin-bottom: 0;'><strong>Error Details:</strong> {error_msg}</p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    st.warning("⚠️ **Report Not Generated**: The analysis pipeline stopped due to the error above. No report was created.")
+    
+    if st.button("🔄 Reset & Try Again", type="primary", use_container_width=True):
+        reset_state(clear_video=True)
+        st.rerun()
+
+# -----------------------------
+# Results section
+# -----------------------------
+if st.session_state.stage == "done" and st.session_state.video_path:
+    vp = Path(st.session_state.video_path)
+    scene_json, frame_json, audio_json, hook_json, report_json = get_paths(vp)
+
+    st.success("Analysis complete.")
+
+    with st.expander("Preview Video", expanded=False):
+        if vp.exists():
+            st.video(str(vp), format="video/mp4")
+
+    report = safe_load_json(report_json)
+    audio_data = safe_load_json(audio_json)
+    hook_data = safe_load_json(hook_json)
+
+    if not report:
+        st.warning("No report found. You can rerun the analysis.")
+    else:
+        results_tab, json_tab = st.tabs(["Results", "JSON Reports"])
+
+        with results_tab:
+            st.markdown(
+                "<h2 style='text-align: center;'>📝 Video Virality Report</h2>",
+                unsafe_allow_html=True
+            )
+
+            # --- Main Score Cards ---
+            total = report.get("total_score", 0)
+            st.markdown(f"""
+                <div style="text-align:center; margin-bottom:1rem;">
+                    <div style="font-size:2rem; font-weight:bold; color:#10b981;">Total Score: {total}</div>
+                    <p style="color:#9ca3af;">Overall Virality Potential</p>
+                </div>
+            """, unsafe_allow_html=True)
+
+            scores = report.get("scores", {})
+            if scores:
+                cols = st.columns(len(scores))
+                for col, (cat, val) in zip(cols, scores.items()):
+                    color = "#10b981" if val >= 70 else "#fbbf24" if val >= 50 else "#ef4444"
+                    with col:
+                        st.markdown(
+                            f"""
+                            <div style="background:{color}22;
+                                        border-radius:12px;
+                                        padding:1rem;
+                                        text-align:center;
+                                        box-shadow:0 2px 8px rgba(0,0,0,.08);height:100%">
+                                <h4 style="margin:0; font-size:0.9rem; color:#d1d5db">{cat.title()}</h4>
+                                <p style="margin:0; font-size:1.5rem; font-weight:700; color:{color}">{val}</p>
+                            </div>
+                            """,
+                            unsafe_allow_html=True,
+                        )
+
+            # --- Matrices (tone, emotion, pace, facial_sync) ---
+            st.markdown(
+                """
+                <div style="text-align:center; margin-bottom:1rem; margin-top:1rem;">
+                    <p style="color:#9ca3af;">Video Attributes</p>
+                </div>
+                """,
+                unsafe_allow_html=True
+            )
+            matrices = report.get("matrices", {})
+            if matrices:
+                attr_cols = st.columns(len(matrices))
+                for col, (k, v) in zip(attr_cols, matrices.items()):
+                    color = "#10b981" if str(v).lower() in ["high", "positive", "fast", "good", "funny", "joy"] else "#fbbf24" if str(v).lower() in ["medium", "neutral", "mixed"] else "#ef4444"
+
+                    with col:
+                        st.markdown(f"""
+                            <div style="background:{color}22;
+                                        border-radius:12px;
+                                        padding:1rem;
+                                        text-align:center;
+                                        box-shadow:0 2px 6px rgba(0,0,0,0.1)">
+                                <h4 style="margin:0; font-size:0.9rem; color:#d1d5db">{k.title()}</h4>
+                                <p style="margin:0; font-size:1.3rem; font-weight:700; color:{color}">{v}</p>
+                            </div>
+                        """, unsafe_allow_html=True)
+
+            # --- Summary ---
+            if "summary" in report:
+                st.markdown(
+                    """
+                    <h2 style='text-align: center; font-size:1.4rem; margin-top:1.3rem;'>
+                        Report Summary
+                    </h2>
+                    """,
+                    unsafe_allow_html=True
+                )
+                st.markdown(
+                    f"""
+                    <div style='background-color:#1e3a8a20;
+                                border-left: 0.25rem solid #3b82f6;
+                                border-radius: 8px;
+                                padding: 1rem;
+                                text-align: center;
+                                color: #d1d5db;'>
+                        {report["summary"]}
+                    </div>
+                    """,
+                    unsafe_allow_html=True
+                )
+
+            # --- Suggestions ---
+            st.markdown(
+                """
+                <h2 style='text-align: center; font-size:1.4rem; margin-top:1.3rem;'>
+                    Suggestions
+                </h2>
+                """,
+                unsafe_allow_html=True
+            )
+
+            suggestions = report.get("suggestions", [])
+            if suggestions:
+                for i, s in enumerate(suggestions, start=1):
+                    st.markdown(
+                        f"<p style='text-align:center; font-size:1rem;'> {s}</p>",
+                        unsafe_allow_html=True
+                    )
+            else:
+                st.markdown(
+                    "<p style='text-align:center; color:gray;'>No improvement suggestions provided.</p>",
+                    unsafe_allow_html=True
+                )
+
+            # --- Audio Analysis ---
+            if audio_data:
+                st.markdown(
+                    """
+                    <h2 style='text-align: center; font-size:1.4rem; margin-top:1.5rem;'>
+                        Audio Analysis
+                    </h2>
+                    """,
+                    unsafe_allow_html=True
+                )
+
+                # --- Audio Score Cards ---
+                metrics = {
+                    "Delivery Score": audio_data.get("delivery_score", ""),
+                    "Duration (s)": round(audio_data.get("duration_seconds", 0), 2),
+                    "Words/Sec": audio_data.get("words_per_second", 0),
+                    "Tone": audio_data.get("tone", ""),
+                    "Emotion": audio_data.get("emotion", ""),
+                    "Pace": audio_data.get("pace", ""),
+                }
+
+                cols = st.columns(len(metrics))
+                for col, (title, value) in zip(cols, metrics.items()):
+                    color = "#10b981"  
+
+                    if title in ["Delivery Score", "Tone", "Emotion", "Pace"]:
+                        if title == "Delivery Score" and isinstance(value, (int, float)):
+                            color = "#10b981" if value >= 70 else "#fbbf24" if value >= 50 else "#ef4444"
+                        else:
+                            val = str(value).lower()
+                            if val in ["high", "positive", "fast", "good", "funny", "clear", "joy"]:
+                                color = "#10b981"
+                            elif val in ["medium", "neutral", "mixed", "average"]:
+                                color = "#fbbf24"
+                            elif val in ["low", "negative", "slow", "bad", "sad"]:
+                                color = "#ef4444"
+                            else:
+                                color = "#d1d5db" 
+
+                    with col:
+                        st.markdown(
+                            f"""
+                            <div style="background:{color}22;
+                                        border-radius:12px;
+                                        padding:1rem;
+                                        text-align:center;
+                                        box-shadow:0 2px 6px rgba(0,0,0,0.15);
+                                        margin-bottom:0.8rem;">
+                                <h4 style="margin:0; font-size:0.85rem; color:#d1d5db">{title}</h4>
+                                <p style="margin:0; font-size:1.3rem; font-weight:700; color:{color}">{value}</p>
+                            </div>
+                            """,
+                            unsafe_allow_html=True,
+                        )
+
+                # Transcript box
+                st.markdown(
+                    f"""
+                    <div style='background:#111827;
+                                border-left: 4px solid #3b82f6;
+                                padding:1rem;
+                                margin-top:1rem;
+                                border-radius:8px;
+                                text-align:left;
+                                color:#e5e7eb;'>
+                        <b>Transcript:</b><br>
+                        <i>{audio_data.get("full_transcript","")}</i>
+                    </div>
+                    """,
+                    unsafe_allow_html=True
+                )
+
+                # Comment box
+                st.markdown(
+                    f"""
+                    <div style='background:#1e293b;
+                                border-radius:8px;
+                                padding:0.8rem;
+                                margin-top:0.5rem;
+                                text-align:center;
+                                font-size:0.95rem;
+                                color:#d1d5db;'>
+                        {audio_data.get("comment","")}
+                    </div>
+                    """,
+                    unsafe_allow_html=True
+                )
+
+
+            # --- Hook Analysis ---
+            if hook_data:
+                st.markdown(
+                    """
+                    <h2 style='text-align: center; font-size:1.4rem; margin-top:1.5rem;'>
+                        Hook Analysis
+                    </h2>
+                    """,
+                    unsafe_allow_html=True
+                )
+
+                # --- Hook Score Card ---
+                score = hook_data.get("hook_alignment_score", 0)
+                color = "#10b981" if score >= 70 else "#fbbf24" if score >= 50 else "#ef4444"
+
+                st.markdown(
+                    f"""
+                    <div style="background:{color}22;
+                                border-radius:12px;
+                                padding:1.2rem;
+                                text-align:center;
+                                box-shadow:0 2px 6px rgba(0,0,0,0.1);
+                                margin:0 auto;
+                                width:50%;">
+                        <h4 style="margin:0; font-size:1rem; color:#d1d5db;">Hook Alignment Score</h4>
+                        <p style="margin:0; font-size:2rem; font-weight:700; color:{color};">{score}</p>
+                    </div>
+                    """,
+                    unsafe_allow_html=True
+                )
+
+                # --- Comment Box ---
+                st.markdown(
+                    f"""
+                    <div style='background:#1e293b;
+                                border-radius:8px;
+                                padding:0.8rem;
+                                margin-top:0.5rem;
+                                text-align:center;
+                                font-size:0.95rem;
+                                color:#d1d5db;'>
+                        {audio_data.get("comment","")}
+                    </div>
+                    """,
+                    unsafe_allow_html=True
+                )
+
+            # --- Download Report ---
+            st.markdown("<br>", unsafe_allow_html=True) 
+            st.download_button(
+                "Download Final Report",
+                json.dumps(report, indent=2),
+                file_name="final_report.json",
+            )
+
+        with json_tab:
+            with st.expander("Scene Detection", expanded=False):
+                st.json(safe_load_json(scene_json))
+            with st.expander("Extracted Frames", expanded=False):
+                frames_dir = INTERIM_DIR / "frames" / f"{vp.stem}_"
+                if frames_dir.exists():
+                    imgs = sorted(frames_dir.glob("*.jpg"))
+                    if imgs:
+                        cols = st.columns(4)
+                        for i, img in enumerate(imgs):
+                            with cols[i % 4]:
+                                st.image(str(img), use_container_width=True)
+                    else:
+                        st.info("No frames found.")
+                else:
+                    st.info("No frames directory found.")
+            with st.expander("Frame Analysis", expanded=False):
+                st.json(safe_load_json(frame_json))
+            with st.expander("Audio Analysis", expanded=False):
+                st.json(audio_data)
+            with st.expander("Hook Analysis", expanded=False):
+                st.json(hook_data)
+            with st.expander("Final Report", expanded=False):
+                st.json(report)
+
+    # Reset button only after analysis is done
+    if st.button("Reset Session"):
+        reset_state(clear_video=True)
+        st.rerun()