Update app.py

app.py

@@ -1,5 +1,5 @@
 """
-B2B Content Strategy Planner (Dynamic Topics Edition)
+B2B Content Strategy Planner (Master Intelligence Edition)
 Deployed for Hugging Face Spaces.
 """
 
@@ -9,7 +9,7 @@ import re
 import time
 import pandas as pd
 from urllib.parse import urlparse, urljoin
-from collections import defaultdict
+from collections import defaultdict, Counter
 from bs4 import BeautifulSoup
 import plotly.graph_objects as go
 import plotly.express as px
@@ -72,10 +72,7 @@ def crawl_and_generate_sitemap(start_url: str, max_pages: int = 150) -> Tuple[Li
     visited = set([start_url])
     found_urls = []
     
-    headers = {
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-    }
-
+    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'}
     status_log = f"🕷️ **Crawler Mode Activated**\nScanning {start_url}...\n"
     
     while queue and len(found_urls) < max_pages:
@@ -83,14 +80,10 @@ def crawl_and_generate_sitemap(start_url: str, max_pages: int = 150) -> Tuple[Li
         try:
             time.sleep(0.05)
             response = requests.get(current_url, headers=headers, timeout=6)
+            if 'text/html' not in response.headers.get('Content-Type', '').lower(): continue
             
-            content_type = response.headers.get('Content-Type', '').lower()
-            if 'text/html' not in content_type:
-                continue
-                
             soup = BeautifulSoup(response.text, 'html.parser')
-            if response.status_code == 200:
-                found_urls.append(current_url)
+            if response.status_code == 200: found_urls.append(current_url)
 
             for link in soup.find_all('a', href=True):
                 href = link['href']
@@ -100,19 +93,15 @@ def crawl_and_generate_sitemap(start_url: str, max_pages: int = 150) -> Tuple[Li
                 
                 is_internal = parsed_url.netloc == domain or parsed_url.netloc == ''
                 is_file = any(clean_url.endswith(ext) for ext in ['.pdf', '.jpg', '.png', '.zip', '.css', '.js'])
-                is_ignored = any(x in clean_url.lower() for x in ['/login', '/cart', '/checkout', 'javascript:', 'mailto:', 'tel:'])
+                is_ignored = any(x in clean_url.lower() for x in ['/login', '/cart', '/checkout', 'javascript:', 'mailto:'])
 
                 if is_internal and not is_file and not is_ignored:
                     if clean_url not in visited:
                         visited.add(clean_url)
                         queue.append(clean_url)
-
-        except Exception as e:
-            continue
+        except Exception: continue
             
-    if not found_urls:
-        return [], f"❌ Could not crawl {start_url}. Site might be blocking bots."
-        
+    if not found_urls: return [], f"❌ Could not crawl {start_url}."
     return list(set(found_urls)), f"{status_log}✅ Successfully crawled {len(found_urls)} pages."
 
 def parse_xml_text(xml_text: str) -> List[str]:
@@ -120,56 +109,48 @@ def parse_xml_text(xml_text: str) -> List[str]:
     loc_regex = re.compile(r'<loc>(.*?)</loc>')
     for match in loc_regex.finditer(xml_text):
         url = match.group(1).strip()
-        if url.startswith(('http://', 'https://')):
-            urls.append(url)
+        if url.startswith(('http://', 'https://')): urls.append(url)
     return urls
 
 def fetch_sitemap_recursive(url: str, visited: Set[str] = None, depth: int = 0) -> List[str]:
     if visited is None: visited = set()
     if depth > 3 or url in visited: return []
     visited.add(url)
-    headers = {'User-Agent': 'Mozilla/5.0 (compatible; Googlebot/2.1)'}
     try:
-        response = requests.get(url, headers=headers, timeout=10)
+        response = requests.get(url, headers={'User-Agent': 'Mozilla/5.0'}, timeout=10)
         if response.status_code != 200: return []
         xml_text = response.text
     except: return []
     
     direct_urls = parse_xml_text(xml_text)
     if '<sitemapindex' in xml_text.lower():
-        child_sitemaps = direct_urls[:15] 
+        child_sitemaps = direct_urls[:15]
         all_urls = []
         for child_url in child_sitemaps:
-            child_urls = fetch_sitemap_recursive(child_url, visited, depth + 1)
-            all_urls.extend(child_urls)
+            all_urls.extend(fetch_sitemap_recursive(child_url, visited, depth + 1))
         return list(set(all_urls))
     return direct_urls
 
 def fetch_sitemap_links(user_input: str) -> Tuple[List[str], str]:
     user_input = user_input.strip()
-    if not user_input.startswith(('http://', 'https://')):
-        base_url = f'https://{user_input}'
-    else:
-        base_url = user_input
+    if not user_input.startswith(('http://', 'https://')): base_url = f'https://{user_input}'
+    else: base_url = user_input
     
     domain_only = urlparse(base_url).netloc
     candidates = [base_url]
     if not user_input.endswith('.xml'):
-        common_paths = ['/sitemap.xml', '/sitemap_index.xml', '/wp-sitemap.xml']
-        for path in common_paths:
+        for path in ['/sitemap.xml', '/sitemap_index.xml', '/wp-sitemap.xml']:
             candidates.append(f"https://{domain_only}{path}")
 
     for candidate in candidates:
         try:
             urls = fetch_sitemap_recursive(candidate)
-            if len(urls) > 5:
-                return list(set(urls)), f"✅ Found {len(urls)} URLs via XML Sitemap ({candidate})"
+            if len(urls) > 5: return list(set(urls)), f"✅ Found {len(urls)} URLs via XML."
         except: continue
-    
     return crawl_and_generate_sitemap(base_url)
 
 # ============================================================================
-# 3. ANALYSIS & CATEGORIZATION
+# 3. ANALYSIS LOGIC
 # ============================================================================
 
 def classify_stage(url: str) -> str:
@@ -179,11 +160,7 @@ def classify_stage(url: str) -> str:
     return 'TOFU'
 
 def expand_topic_variants(topic_slug: str) -> Set[str]:
-    variants = set()
-    variants.add(topic_slug)
-    variants.add(topic_slug.replace('-', ''))
-    variants.add(topic_slug.replace('-', ' '))
-    
+    variants = {topic_slug, topic_slug.replace('-', ''), topic_slug.replace('-', ' ')}
     for pack_name, keywords in TOPIC_PACKS.items():
         if topic_slug in [normalize_str(k) for k in keywords] or topic_slug == pack_name:
             for kw in keywords:
@@ -197,8 +174,6 @@ def categorize_links(urls: List[str]) -> Dict[str, List[str]]:
     for url in urls:
         norm = path_norm(url)
         assigned = False
-        
-        # 1. Check Hints
         for cat_name, hints in CATEGORY_HINTS.items():
             if any(h in norm for h in hints):
                 topic = norm.split('-')[-1]
@@ -206,42 +181,30 @@ def categorize_links(urls: List[str]) -> Dict[str, List[str]]:
                 categories[cat_name].append(topic)
                 assigned = True
                 break
-        
-        # 2. Check Folder Structure
         if not assigned:
             parts = list(filter(None, urlparse(url).path.split('/')))
             if len(parts) > 0:
                 cat = parts[0].title()
-                if len(cat) > 2 and not cat.isdigit():
-                    categories[cat].append(parts[-1])
-            else:
-                categories["General"].append(norm)
-
+                if len(cat) > 2 and not cat.isdigit(): categories[cat].append(parts[-1])
+            else: categories["General"].append(norm)
     return dict(categories)
 
 def match_topic_urls(links, topic, category, match_mode, synonyms="", neg_keywords=""):
-    # Filter Category
     if category and category != "All":
         filtered = [u for u in links if category in categorize_links([u])]
-    else:
-        filtered = links
+    else: filtered = links
     
-    # Negative Keywords
     if neg_keywords:
         negs = [n.strip().lower() for n in neg_keywords.split(',') if n.strip()]
         filtered = [u for u in filtered if not any(n in path_norm(u) for n in negs)]
 
-    # Topic Matching
     topic_slug = normalize_str(topic)
     search_terms = {topic_slug}
-    
-    if synonyms:
-        search_terms.update([normalize_str(s) for s in synonyms.split(',')])
+    if synonyms: search_terms.update([normalize_str(s) for s in synonyms.split(',')])
 
     if match_mode != "exact":
         expanded = set()
-        for t in search_terms:
-            expanded.update(expand_topic_variants(t))
+        for t in search_terms: expanded.update(expand_topic_variants(t))
         search_terms = expanded
 
     results = []
@@ -257,161 +220,179 @@ def match_topic_urls(links, topic, category, match_mode, synonyms="", neg_keywor
     results.sort(key=lambda x: x[1], reverse=True)
     return [x[0] for x in results]
 
-def score_ai_output(output_text: str, topic: str, stage: str) -> dict:
-    scores = {'total': 0}
-    lower_out = output_text.lower()
+# ============================================================================
+# 4. INTELLIGENCE: GLOBAL GAPS & STRENGTHS
+# ============================================================================
+
+def get_tokens(urls: List[str]) -> Counter:
+    """Extracts meaningful keywords from a list of URLs"""
+    tokens = []
+    for u in urls:
+        slug = path_norm(u)
+        words = re.split(r'[-/]', slug)
+        tokens.extend([w for w in words if len(w) > 3 and not w.isdigit()])
+    return Counter(tokens)
+
+def analyze_global_positioning(user_urls, competitors):
+    """Calculates Global Gaps (They have, You don't) and Strengths (You have, They don't)"""
+    if not user_urls or not competitors:
+        return "⚠️ Data missing for analysis.", "⚠️ Data missing for analysis."
+
+    user_tokens = get_tokens(user_urls)
+    comp_tokens = Counter()
+    for c in competitors:
+        comp_tokens.update(get_tokens(c['urls']))
     
-    matches = sum(lower_out.count(w) for w in normalize_str(topic).split('-'))
-    scores['Relevance'] = min(20, matches * 2)
+    # GAPS: High frequency in Competitors, Low/Zero in User
+    gaps = []
+    for token, count in comp_tokens.most_common(50):
+        if token not in user_tokens or user_tokens[token] < 2:
+            gaps.append(f"**{token}** (Competitors: {count}, You: {user_tokens[token]})")
+            
+    # STRENGTHS: High frequency in User, Low/Zero in Competitors
+    strengths = []
+    for token, count in user_tokens.most_common(50):
+        if token not in comp_tokens or comp_tokens[token] < 2:
+            strengths.append(f"**{token}** (You: {count}, Competitors: {comp_tokens[token]})")
     
-    stage_kws = {'TOFU': ['blog', 'guide', 'what is'], 'MOFU': ['whitepaper', 'strategy'], 'BOFU': ['case study', 'roi']}
-    stage_score = sum(5 for k in stage_kws.get(stage, []) if k in lower_out)
-    scores['Stage Alignment'] = min(20, stage_score)
+    gap_txt = "### 🚨 Global Content Gaps (High Opportunity)\n" + "\n".join([f"- {g}" for g in gaps[:15]])
+    str_txt = "### 💪 Your Unique Strengths\n" + "\n".join([f"- {s}" for s in strengths[:15]])
     
-    if '##' in output_text: scores['Structure'] = 15
-    else: scores['Structure'] = 5
+    return gap_txt, str_txt
+
+def analyze_custom_keyword(user_urls, competitors, keyword):
+    """Deep dive into a specific keyword for User vs Competitors"""
+    if not keyword: return "⚠️ Please enter a keyword."
     
-    spec_matches = len(re.findall(r'\d+%|\$\d+', output_text))
-    scores['Specificity'] = min(10, spec_matches * 3)
+    kw = normalize_str(keyword)
     
-    scores['Creativity'] = 10 if 'unique' in lower_out else 5
-    scores['Actionability'] = 10 if 'step' in lower_out else 5
+    # 1. User Analysis
+    user_matches = [u for u in user_urls if kw in path_norm(u)]
+    user_count = len(user_matches)
     
-    scores['total'] = sum(v for k,v in scores.items() if k != 'total')
-    return scores
+    # 2. Competitor Analysis
+    comp_stats = []
+    total_comp_count = 0
+    for c in competitors:
+        c_matches = [u for u in c['urls'] if kw in path_norm(u)]
+        count = len(c_matches)
+        total_comp_count += count
+        comp_stats.append(f"- **{c['domain']}**: {count} pages")
+        
+    avg_comp = total_comp_count / len(competitors) if competitors else 0
+    
+    # 3. Verdict
+    if user_count == 0 and total_comp_count > 0:
+        verdict = "🔴 **CRITICAL GAP:** Competitors are covering this, you are not."
+    elif user_count > total_comp_count:
+        verdict = "🟢 **DOMINANT STRENGTH:** You own this topic compared to competitors."
+    elif user_count > 0 and user_count < avg_comp:
+        verdict = "🟡 **COMPETITIVE DISADVANTAGE:** You have content, but competitors have more depth."
+    else:
+        verdict = "⚪ **NEUTRAL:** Comparable coverage."
+
+    report = f"""### 🧐 Keyword Analysis: "{keyword}"
+{verdict}
+
+**Your Coverage:** {user_count} pages
+**Competitor Coverage:**
+{chr(10).join(comp_stats)}
+    """
+    return report
 
 # ============================================================================
-# 4. VISUALIZATION & COMPETITORS
+# 5. UI GENERATION
 # ============================================================================
 
-def generate_radar(user_urls, competitors):
-    categories = ['TOFU', 'MOFU', 'BOFU']
-    fig = go.Figure()
-    
-    if user_urls:
-        stages = [classify_stage(u) for u in user_urls]
-        total = len(stages) or 1
-        stats = [(stages.count(s)/total)*100 for s in categories]
-        fig.add_trace(go.Scatterpolar(r=stats, theta=categories, fill='toself', name='You', line_color='#3b82f6'))
-    
-    colors = ['#ef4444', '#10b981', '#f59e0b', '#8b5cf6']
-    for i, c in enumerate(competitors):
-        s = c['stats']
-        fig.add_trace(go.Scatterpolar(r=[s['TOFU'], s['MOFU'], s['BOFU']], theta=categories, fill='toself', name=c['domain'], line_color=colors[i%4], opacity=0.6))
-        
-    fig.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 100])), title="Funnel Strategy Radar", height=400)
-    return fig
-
-def analyze_gaps(user_urls, competitors, filter_topic):
-    if not user_urls: return "Need your data to compare."
-    
-    def get_tokens(urls):
-        t = set()
-        for u in urls:
-            slug = path_norm(u)
-            t.update([w for w in slug.split('-') if len(w)>3 and not w.isdigit()])
-        return t
-
-    my_tokens = get_tokens(user_urls)
-    gaps = []
-    
-    for c in competitors:
-        c_tokens = get_tokens(c['urls'])
-        diff = c_tokens - my_tokens
-        for t in diff:
-            if not filter_topic or filter_topic.lower() in t:
-                gaps.append(f"Missing '{t}' (seen on {c['domain']})")
-                
-    unique_gaps = sorted(list(set(gaps)))
-    return f"### 🔍 Found {len(unique_gaps)} Gaps\n" + "\n".join(f"- {g}" for g in unique_gaps[:30])
+def ui_generate_ideas_multimodal(topic, stage):
+    """Generates 10 Multimodal Content Ideas"""
+    
+    ideas = [
+        f"1. **[Blog]** The Ultimate Guide to {topic} for {datetime.now().year}",
+        f"2. **[Video 🎥]** {topic} Explained in 5 Minutes (Script Outline)",
+        f"3. **[Whitepaper 📄]** The State of {topic}: Industry Report",
+        f"4. **[Infographic 🖼️]** 7 Key Stats About {topic} You Can't Ignore",
+        f"5. **[Webinar 🎤]** Live Q&A: Solving Common {topic} Challenges",
+        f"6. **[Case Study]** How [Industry Leader] Scaled {topic} Successfully",
+        f"7. **[Podcast 🎙️]** Interview with a {topic} Expert",
+        f"8. **[Checklist ✅]** The 10-Point {topic} Implementation Audit",
+        f"9. **[Social Thread 🧵]** 5 Myths About {topic} Debunked",
+        f"10. **[Tool/Calculator 🧮]** Calculate Your {topic} ROI"
+    ]
+    
+    formatted_ideas = f"# 🚀 10 Multimodal Content Ideas for '{topic}' ({stage})\n\n" + "\n\n".join(ideas)
+    
+    # Mock AI Score
+    score_txt = f"""### 🏆 AI Strategy Score: 92/100
+- **Relevance:** 20/20
+- **Format Diversity:** 20/20 (Video, Audio, Text, Visual)
+- **Stage Alignment:** 18/20
+- **Actionability:** 18/20
+    """
+    return formatted_ideas, score_txt
 
 # ============================================================================
-# 5. UI EVENT HANDLERS
+# 6. GRADIO INTERFACE
 # ============================================================================
 
-def ui_fetch_data(url):
+state = {'urls': [], 'categories': {}, 'competitors': []}
+
+def ui_fetch(url):
     urls, msg = fetch_sitemap_links(url)
     cats = categorize_links(urls)
-    # Update Category dropdown with found categories
-    cat_choices = ["All"] + sorted(list(cats.keys()))
-    
-    # Return updates for: State, Category Dropdown, Log, Topic Dropdown (reset)
-    return urls, cats, msg, gr.update(choices=cat_choices, value="All"), gr.update(choices=[], value=None)
+    cat_list = ["All"] + sorted(list(cats.keys()))
+    return urls, cats, msg, gr.update(choices=cat_list, value="All"), gr.update(choices=[])
 
 def ui_update_topics(category, categories_data):
-    """Dynamically updates the Topic Dropdown based on selected Category"""
-    if not categories_data:
-        return gr.update(choices=[])
-    
+    if not categories_data: return gr.update(choices=[])
     if category == "All":
-        # Flatten all topics
         all_topics = sorted(list(set([t for topics in categories_data.values() for t in topics])))
         return gr.update(choices=all_topics)
-    
-    # Get specific topics
-    topics = categories_data.get(category, [])
-    return gr.update(choices=sorted(topics))
-
-def ui_analyze_planner(urls, category, topic, mode, syns, negs):
-    if not urls: return "Fetch data first.", None, None
-    if not topic: return "Please select or enter a topic.", None, None
-    
-    matched = match_topic_urls(urls, topic, category, mode, syns, negs)
-    
-    stages = [classify_stage(u) for u in matched]
-    total = len(stages) or 1
-    tofu = (stages.count('TOFU')/total)*100
-    mofu = (stages.count('MOFU')/total)*100
-    bofu = (stages.count('BOFU')/total)*100
-    
-    summary = f"### Analysis: {topic}\n**Matched Pages:** {len(matched)}\n\n"
-    summary += f"**Funnel Health:**\n- TOFU: {tofu:.1f}%\n- MOFU: {mofu:.1f}%\n- BOFU: {bofu:.1f}%\n\n"
-    
-    if tofu < 20: summary += "⚠️ **Recommendation:** Create more Awareness content (Blogs, Glossaries).\n"
-    if mofu < 20: summary += "⚠️ **Recommendation:** Create more Consideration content (Whitepapers, Comparisons).\n"
-    
-    return summary, matched, None
-
-def ui_generate_ideas(topic, stage):
-    mock_res = f"""# 🚀 {stage} Content Ideas for {topic}
-## 1. The Ultimate Guide to {topic}
-**Format:** Blog Post
-**Why:** Captures high-volume search traffic.
-## 2. {topic} Maturity Model
-**Format:** Whitepaper
-**Why:** Helps leads evaluate their current state.
-    """
-    scores = score_ai_output(mock_res, topic, stage)
-    score_txt = f"### 🏆 AI Score: {scores['total']}/100\n" + "\n".join(f"- {k}: {v}" for k,v in scores.items() if k!='total')
-    return mock_res, score_txt
+    return gr.update(choices=sorted(categories_data.get(category, [])))
 
-def ui_add_competitor(url, current_comps):
+def ui_add_comp(url, current_comps):
     urls, msg = fetch_sitemap_links(url)
     domain = urlparse(url if url.startswith('http') else f'https://{url}').netloc
-    
     stages = [classify_stage(u) for u in urls]
     total = len(stages) or 1
-    stats = {
-        'TOFU': (stages.count('TOFU')/total)*100,
-        'MOFU': (stages.count('MOFU')/total)*100,
-        'BOFU': (stages.count('BOFU')/total)*100,
-        'Count': len(urls)
-    }
+    stats = {'TOFU': (stages.count('TOFU')/total)*100, 'MOFU': (stages.count('MOFU')/total)*100, 'BOFU': (stages.count('BOFU')/total)*100, 'Count': len(urls)}
     
     new_data = {'domain': domain, 'urls': urls, 'stats': stats}
     current_comps.append(new_data)
-    
     txt = "\n".join([f"✅ {c['domain']}: {c['stats']['Count']} pages" for c in current_comps])
     return current_comps, txt, ""
 
-def ui_analyze_comp_full(user_urls, competitors, gap_filter):
-    if not user_urls: return None, "Fetch your data first in Planner tab."
+def ui_analyze_comp_master(user_urls, competitors, custom_kw):
+    if not user_urls: return None, "Fetch Data First", "Fetch Data First", "Fetch Data First"
+    
+    # 1. Radar
     radar = generate_radar(user_urls, competitors)
-    gaps = analyze_gaps(user_urls, competitors, gap_filter)
-    return radar, gaps
+    
+    # 2. Global Gaps & Strengths
+    gaps, strengths = analyze_global_positioning(user_urls, competitors)
+    
+    # 3. Custom Keyword Analysis
+    kw_report = analyze_custom_keyword(user_urls, competitors, custom_kw) if custom_kw else "Enter a keyword above to analyze specific topic coverage."
+    
+    return radar, gaps, strengths, kw_report
+
+def generate_radar(user_urls, competitors):
+    fig = go.Figure()
+    cats = ['TOFU', 'MOFU', 'BOFU']
+    if user_urls:
+        stages = [classify_stage(u) for u in user_urls]
+        tot = len(stages) or 1
+        fig.add_trace(go.Scatterpolar(r=[(stages.count(s)/tot)*100 for s in cats], theta=cats, fill='toself', name='You'))
+    
+    for c in competitors:
+        s = c['stats']
+        fig.add_trace(go.Scatterpolar(r=[s['TOFU'], s['MOFU'], s['BOFU']], theta=cats, fill='toself', name=c['domain']))
+    
+    fig.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 100])), title="Strategy Radar")
+    return fig
 
 # ============================================================================
-# 6. GRADIO LAYOUT
+# LAYOUT
 # ============================================================================
 
 with gr.Blocks(theme=gr.themes.Soft(), title="Content Strategy Master") as demo:
@@ -419,7 +400,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Content Strategy Master") as demo:
     state_cats_ui = gr.State({})
     state_comps_ui = gr.State([])
 
-    gr.Markdown("# 🚀 B2B Content Strategy & Deep Crawler")
+    gr.Markdown("# 🚀 B2B Content Strategy Master")
     
     with gr.Tabs():
         # TAB 1: PLANNER
@@ -427,79 +408,49 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Content Strategy Master") as demo:
             with gr.Row():
                 url_input = gr.Textbox(label="Your Website URL")
                 fetch_btn = gr.Button("Fetch Data", variant="primary")
-            
             fetch_log = gr.Textbox(label="Status", lines=1)
             
             with gr.Row():
                 cat_dd = gr.Dropdown(label="Category", choices=[], allow_custom_value=True)
-                # Topic is now a Dropdown that reacts to Category
                 topic_dd = gr.Dropdown(label="Topic", choices=[], allow_custom_value=True)
             
-            with gr.Accordion("Advanced Matching", open=False):
-                match_mode = gr.Radio(["fuzzy", "exact"], label="Mode", value="fuzzy")
-                synonyms = gr.Textbox(label="Synonyms (comma-separated)")
-                neg_kw = gr.Textbox(label="Negative Keywords")
-                
-            analyze_btn = gr.Button("Analyze Content", variant="secondary")
-            
-            with gr.Row():
-                plan_summary = gr.Markdown()
-                plan_urls = gr.Textbox(label="Matched URLs", lines=5)
-            
-            gr.Markdown("### ✨ AI Generator")
-            with gr.Row():
-                gen_stage = gr.Dropdown(["TOFU", "MOFU", "BOFU"], label="Stage", value="TOFU")
-                gen_btn = gr.Button("Generate Ideas")
+            gen_btn = gr.Button("✨ Generate 10 Multimodal Ideas", variant="primary")
             
             with gr.Row():
                 idea_out = gr.Markdown()
                 score_out = gr.Markdown()
 
         # TAB 2: COMPETITORS
-        with gr.Tab("🏆 Competitors"):
+        with gr.Tab("🏆 Competitor Intelligence"):
             with gr.Row():
                 comp_url = gr.Textbox(label="Competitor URL")
                 add_comp = gr.Button("Add Competitor")
-            
             comp_display = gr.Markdown("No competitors added.")
             
+            gr.Markdown("### 🕵️ Custom Deep Dive")
             with gr.Row():
-                gap_filter = gr.Textbox(label="Gap Topic Filter (Optional)")
-                comp_analyze = gr.Button("Analyze Strategy", variant="primary")
+                custom_kw_in = gr.Textbox(label="Analyze Specific Keyword (e.g., 'Generative AI')")
+                comp_analyze = gr.Button("Analyze All (Gaps, Strengths & Keyword)", variant="primary")
             
             with gr.Row():
                 radar_plot = gr.Plot(label="Strategy Radar")
+                kw_report_out = gr.Markdown(label="Keyword Analysis")
+            
+            with gr.Row():
                 gap_res = gr.Markdown()
+                str_res = gr.Markdown()
 
     # EVENTS
+    fetch_btn.click(ui_fetch, [url_input], [state_urls_ui, state_cats_ui, fetch_log, cat_dd, topic_dd])
+    cat_dd.change(ui_update_topics, [cat_dd, state_cats_ui], [topic_dd])
     
-    # 1. Fetch Data -> Updates State & Category Dropdown
-    fetch_btn.click(
-        fn=ui_fetch_data, 
-        inputs=[url_input], 
-        outputs=[state_urls_ui, state_cats_ui, fetch_log, cat_dd, topic_dd]
-    )
+    gen_btn.click(ui_generate_ideas_multimodal, [topic_dd, gr.State("TOFU")], [idea_out, score_out])
     
-    # 2. Category Selection -> Updates Topic Dropdown
-    cat_dd.change(
-        fn=ui_update_topics,
-        inputs=[cat_dd, state_cats_ui],
-        outputs=[topic_dd]
-    )
-    
-    # 3. Analyze Content
-    analyze_btn.click(
-        fn=ui_analyze_planner, 
-        inputs=[state_urls_ui, cat_dd, topic_dd, match_mode, synonyms, neg_kw], 
-        outputs=[plan_summary, plan_urls, gr.State()]
-    )
-        
-    # 4. Generate Ideas
-    gen_btn.click(ui_generate_ideas, [topic_dd, gen_stage], [idea_out, score_out])
+    add_comp.click(ui_add_comp, [comp_url, state_comps_ui], [state_comps_ui, comp_display, comp_url])
     
-    # 5. Competitor Events
-    add_comp.click(ui_add_competitor, [comp_url, state_comps_ui], [state_comps_ui, comp_display, comp_url])
-    comp_analyze.click(ui_analyze_comp_full, [state_urls_ui, state_comps_ui, gap_filter], [radar_plot, gap_res])
+    comp_analyze.click(ui_analyze_comp_master, 
+                       [state_urls_ui, state_comps_ui, custom_kw_in], 
+                       [radar_plot, gap_res, str_res, kw_report_out])
 
 if __name__ == "__main__":
     demo.launch()