update app.py add extra gui

app.py

@@ -8,6 +8,7 @@ import os
 import tempfile
 import json
 from typing import Dict, Any, List
+import time  # Add this if not present
 
 # Import our custom modules
 from utils.parser import PDFParser, TextParser, WebpageParser
@@ -183,7 +184,7 @@ class GEOSEOApp:
                 st.error(f"An error occurred: {str(e)}")
     
     def render_content_enhancement_tab(self):
-        """Render Content Enhancement tab"""
+        """Render Content Enhancement tab with optimization type selector"""
         st.header("🔧 Content Enhancement")
         st.markdown("Analyze and optimize your content for better AI/LLM performance.")
         
@@ -194,84 +195,415 @@ class GEOSEOApp:
             key="enhancement_input"
         )
         
-        # Analysis options
+        # Optimization type selector
+        st.markdown("### ⚙️ Optimization Settings")
         col1, col2 = st.columns(2)
+        
         with col1:
-            analyze_only = st.checkbox("Analysis only (no rewriting)", value=False)
+            optimization_type = st.selectbox(
+                "Select Optimization Type:",
+                options=[
+                    "standard", 
+                    "seo", 
+                    "competitive", 
+                    "voice_search", 
+                    "batch_optimize",
+                    "content_variations",
+                    "readability_analysis",
+                    "entity_extraction"
+                ],
+                format_func=lambda x: {
+                    "standard": "🔧 Standard Enhancement",
+                    "seo": "🌐 SEO-Focused Optimization", 
+                    "competitive": "📊 Competitive Analysis",
+                    "voice_search": "🎤 Voice Search Optimization",
+                    "batch_optimize": "📦 Batch Optimization",
+                    "content_variations": "🔄 Content Variations",
+                    "readability_analysis": "📖 Readability Analysis",
+                    "entity_extraction": "🏷️ Entity Extraction"
+                }[x],
+                index=0,
+                help="Choose the type of optimization to apply to your content"
+            )
+        
         with col2:
-            include_keywords = st.checkbox("Include keyword suggestions", value=True)
+            # Additional options based on optimization type
+            if optimization_type in ["standard", "seo"]:
+                analyze_only = st.checkbox("Analysis only (no rewriting)", value=False)
+                include_keywords = st.checkbox("Include keyword suggestions", value=True)
+            elif optimization_type == "batch_optimize":
+                st.info("For batch optimization, separate multiple content pieces with '---' in the text area above")
+            elif optimization_type == "content_variations":
+                num_variations = st.slider("Number of variations", min_value=1, max_value=5, value=3)
+            else:
+                analyze_only = False
+                include_keywords = True
+                num_variations = 3
+        
+        # Show description based on optimization type
+        optimization_descriptions = {
+            "standard": "General content enhancement focusing on clarity, structure, and AI answerability.",
+            "seo": "SEO-focused optimization for AI search engines with semantic keyword analysis.",
+            "competitive": "Competitive analysis against AI search best practices with gap identification.",
+            "voice_search": "Optimization for voice search and conversational AI systems.",
+            "batch_optimize": "Process multiple content pieces simultaneously.",
+            "content_variations": "Generate multiple optimized variations of the same content.",
+            "readability_analysis": "Detailed readability analysis specifically for AI systems.",
+            "entity_extraction": "Extract key entities, topics, and concepts for optimization insights."
+        }
+        
+        st.info(f"**{optimization_descriptions[optimization_type]}**")
         
         # Submit button
-        if st.button("🔧 Analyze & Enhance", key="enhancement_submit"):
+        if st.button("🚀 Process Content", key="enhancement_submit"):
             if not input_text.strip():
                 st.warning("Please enter some content to analyze.")
                 return
             
             try:
-                with st.spinner("Analyzing content..."):
-                    # Run content analysis and optimization
-                    result = self.content_optimizer.optimize_content(
-                        input_text,
-                        analyze_only=analyze_only,
-                        include_keywords=include_keywords
-                    )
+                with st.spinner(f"Processing content with {optimization_type} optimization..."):
+                    # Handle different optimization types
+                    if optimization_type == "standard":
+                        result = self.content_optimizer.optimize_content(
+                            input_text,
+                            analyze_only=analyze_only,
+                            include_keywords=include_keywords,
+                            optimization_type="standard"
+                        )
+                    
+                    elif optimization_type == "seo":
+                        result = self.content_optimizer.optimize_content(
+                            input_text,
+                            analyze_only=analyze_only,
+                            include_keywords=include_keywords,
+                            optimization_type="seo"
+                        )
+                    
+                    elif optimization_type == "competitive":
+                        result = self.content_optimizer.optimize_content(
+                            input_text,
+                            optimization_type="competitive"
+                        )
+                    
+                    elif optimization_type == "voice_search":
+                        result = self.content_optimizer.optimize_for_voice_search(input_text)
+                    
+                    elif optimization_type == "batch_optimize":
+                        # Split content by '---' separator
+                        content_pieces = [piece.strip() for piece in input_text.split('---') if piece.strip()]
+                        if len(content_pieces) > 1:
+                            result = self.content_optimizer.batch_optimize_content(content_pieces)
+                        else:
+                            st.warning("For batch optimization, please separate content pieces with '---'")
+                            return
+                    
+                    elif optimization_type == "content_variations":
+                        result = self.content_optimizer.generate_content_variations(
+                            input_text, 
+                            num_variations=num_variations
+                        )
+                    
+                    elif optimization_type == "readability_analysis":
+                        result = self.content_optimizer.analyze_content_readability(input_text)
+                    
+                    elif optimization_type == "entity_extraction":
+                        result = self.content_optimizer.extract_key_entities(input_text)
                 
                 if result.get("error"):
-                    st.error(f"Analysis failed: {result['error']}")
+                    st.error(f"Processing failed: {result['error']}")
                     return
                 
-                # Display results
-                if analyze_only:
-                    st.success("Content analysis and enhancement completed successfully!")  
-                    st.markdown("### 📊 Analysis Results")
+                # Display results based on optimization type
+                self.display_enhancement_results(result, optimization_type, input_text)
                 
-                    # Show scores
-                    scores = result.get("scores", {})
-                    if scores:
-                        col1, col2, col3 = st.columns(3)
-
-                        with col1:
-                            clarity = scores.get("clarity", 0)
-                            st.metric("Clarity", f"{clarity}/10")
+            except Exception as e:
+                st.error(f"An error occurred: {str(e)}")
 
-                        with col2:
-                            structure = scores.get("structuredness", 0)
-                            st.metric("Structure", f"{structure}/10")
+    def display_enhancement_results(self, result, optimization_type, original_text):
+        """Display results based on optimization type"""
+        st.success(f"{optimization_type.title()} optimization completed successfully!")
+        
+        if optimization_type == "batch_optimize":
+            self.display_batch_results(result)
+        elif optimization_type == "content_variations":
+            self.display_variation_results(result)
+        elif optimization_type == "readability_analysis":
+            self.display_readability_results(result)
+        elif optimization_type == "entity_extraction":
+            self.display_entity_results(result)
+        elif optimization_type == "voice_search":
+            self.display_voice_search_results(result)
+        else:
+            self.display_standard_results(result, optimization_type)
+        
+        # Export functionality
+        self.display_export_options(result, optimization_type, original_text)
 
-                        with col3:
-                            answerability = scores.get("answerability", 0)
-                            st.metric("Answerability", f"{answerability}/10")
+    def display_standard_results(self, result, optimization_type):
+        """Display results for standard, SEO, and competitive optimizations"""
+        st.markdown("### 📊 Analysis Results")
+        
+        # Show scores if available
+        scores = result.get("scores", {})
+        if scores:
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                clarity = scores.get("clarity", 0)
+                st.metric("Clarity", f"{clarity}/10")
+            
+            with col2:
+                structure = scores.get("structuredness", 0)
+                st.metric("Structure", f"{structure}/10")
+            
+            with col3:
+                answerability = scores.get("answerability", 0)
+                st.metric("Answerability", f"{answerability}/10")
+        
+        # Show SEO analysis if available
+        if "seo_analysis" in result:
+            st.markdown("#### 🌐 SEO Analysis")
+            seo_data = result["seo_analysis"]
+            if "readability_score" in seo_data:
+                st.metric("Readability Score", f"{seo_data['readability_score']}/10")
+            if "semantic_gaps" in seo_data:
+                st.write("**Semantic Gaps:**", ", ".join(seo_data["semantic_gaps"]))
+        
+        # Show competitive analysis if available
+        if "competitive_analysis" in result:
+            st.markdown("#### 📊 Competitive Analysis")
+            comp_data = result["competitive_analysis"]
+            for key, value in comp_data.items():
+                if isinstance(value, list):
+                    st.write(f"**{key.replace('_', ' ').title()}:**", ", ".join(value))
+                else:
+                    st.write(f"**{key.replace('_', ' ').title()}:**", value)
+        
+        # Show keywords
+        keywords = result.get("keywords", [])
+        if keywords:
+            st.markdown("#### 🔑 Key Terms")
+            st.write(", ".join(keywords))
+        
+        # Show optimized content
+        optimized_content = result.get("optimized_text") or result.get("optimized_content", {}).get("enhanced_content", "")
+        if optimized_content:
+            st.markdown("#### ✨ Optimized Content")
+            st.text_area(
+                "Enhanced version:", 
+                value=optimized_content, 
+                height=200, 
+                key="optimized_output"
+            )
+        
+        # Show recommendations
+        recommendations = result.get("recommendations", [])
+        if recommendations:
+            st.markdown("#### 💡 Recommendations")
+            for i, rec in enumerate(recommendations, 1):
+                st.write(f"**{i}.** {rec}")
 
-                # Show keywords
-                keywords = result.get("keywords", [])
-                if keywords:
-                    st.markdown("#### 🔑 Key Terms")
-                    st.write(", ".join(keywords))
-                
-                # Show optimized content
-                optimized_text = result.get("optimized_text", "")
-                # if optimized_text and not analyze_only:
-                if optimized_text :
-                    st.markdown("#### ✨ Optimized Content")
-                    st.text_area(
-                        "Enhanced version:", 
-                        value=optimized_text, 
-                        height=200, 
-                        key="optimized_output"
-                    )
+    def display_batch_results(self, results):
+        """Display batch optimization results"""
+        st.markdown("### 📦 Batch Processing Results")
+        
+        successful_results = [r for r in results if not r.get('error')]
+        failed_results = [r for r in results if r.get('error')]
+        
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("Total Pieces", len(results))
+        with col2:
+            st.metric("Successful", len(successful_results))
+        with col3:
+            st.metric("Failed", len(failed_results))
+        
+        # Show individual results
+        for result in results:
+            idx = result.get('batch_index', 0)
+            st.markdown(f"#### Content Piece {idx + 1}")
+            
+            if result.get('error'):
+                st.error(f"Processing failed: {result['error']}")
+            else:
+                # Show scores
+                scores = result.get("scores", {})
+                if scores:
+                    col1, col2, col3 = st.columns(3)
+                    with col1:
+                        st.metric("Clarity", f"{scores.get('clarity', 0)}/10")
+                    with col2:
+                        st.metric("Structure", f"{scores.get('structuredness', 0)}/10") 
+                    with col3:
+                        st.metric("Answerability", f"{scores.get('answerability', 0)}/10")
                 
-                # Export option
-                if st.button("📥 Export Results"):
-                    export_data = self.result_exporter.export_enhancement_results(result)
-                    st.download_button(
-                        label="Download Analysis Report",
-                        data=json.dumps(export_data, indent=2),
-                        file_name=f"content_analysis_{int(time.time())}.json",
-                        mime="application/json"
-                    )
+                # Show optimized content if available
+                optimized = result.get("optimized_text", "")
+                if optimized:
+                    with st.expander("View optimized content"):
+                        st.text_area("", value=optimized, height=150, key=f"batch_output_{idx}")
             
-            except Exception as e:
-                st.error(f"An error occurred: {str(e)}")
+            st.write("---")
+
+    def display_variation_results(self, variations):
+        """Display content variation results"""
+        st.markdown("### 🔄 Content Variations")
+        
+        for i, variation in enumerate(variations):
+            if variation.get('error'):
+                st.error(f"Variation {i+1} failed: {variation['error']}")
+                continue
+            
+            variation_type = variation.get('variation_type', f'Variation {i+1}')
+            st.markdown(f"#### {variation_type.title()} Version")
+            
+            # Show variation details
+            target_use_case = variation.get('target_use_case', '')
+            if target_use_case:
+                st.info(f"**Target Use Case:** {target_use_case}")
+            
+            # Show key changes
+            key_changes = variation.get('key_changes', [])
+            if key_changes:
+                st.write("**Key Changes:**")
+                for change in key_changes:
+                    st.write(f"• {change}")
+            
+            # Show optimized content
+            optimized_content = variation.get('optimized_content', '')
+            if optimized_content:
+                st.text_area(
+                    f"{variation_type} content:", 
+                    value=optimized_content, 
+                    height=150, 
+                    key=f"variation_{i}"
+                )
+            
+            st.write("---")
+
+    def display_readability_results(self, result):
+        """Display readability analysis results"""
+        st.markdown("### 📖 Readability Analysis")
+        
+        # Basic metrics
+        basic_metrics = result.get('basic_metrics', {})
+        if basic_metrics:
+            st.markdown("#### 📊 Basic Metrics")
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                st.metric("Total Words", basic_metrics.get('total_words', 0))
+            with col2:
+                st.metric("Sentences", basic_metrics.get('total_sentences', 0))
+            with col3:
+                st.metric("Paragraphs", basic_metrics.get('total_paragraphs', 0))
+            with col4:
+                st.metric("AI Readability", f"{result.get('ai_readability_score', 0)}/10")
+        
+        # Complexity indicators
+        complexity = result.get('complexity_indicators', {})
+        if complexity:
+            st.markdown("#### 🎯 Complexity Analysis")
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.metric("Long Sentences", f"{complexity.get('long_sentences_percentage', 0):.1f}%")
+            with col2:
+                st.metric("Complex Words", f"{complexity.get('complex_words_percentage', 0):.1f}%")
+        
+        # Recommendations
+        recommendations = result.get('recommendations', [])
+        if recommendations:
+            st.markdown("#### 💡 Readability Recommendations")
+            for i, rec in enumerate(recommendations, 1):
+                st.write(f"**{i}.** {rec}")
+
+    def display_entity_results(self, result):
+        """Display entity extraction results"""
+        st.markdown("### 🏷️ Entity Analysis")
+        
+        # Named entities
+        named_entities = result.get('named_entities', [])
+        if named_entities:
+            st.markdown("#### 👥 Named Entities")
+            st.write(", ".join(named_entities))
+        
+        # Key topics
+        key_topics = result.get('key_topics', [])
+        if key_topics:
+            st.markdown("#### 📋 Key Topics")
+            st.write(", ".join(key_topics))
+        
+        # Technical terms
+        technical_terms = result.get('technical_terms', [])
+        if technical_terms:
+            st.markdown("#### 🔧 Technical Terms")
+            st.write(", ".join(technical_terms))
+        
+        # Semantic keywords
+        semantic_keywords = result.get('semantic_keywords', [])
+        if semantic_keywords:
+            st.markdown("#### 🔍 Semantic Keywords")
+            st.write(", ".join(semantic_keywords))
+        
+        # Question opportunities
+        questions = result.get('question_opportunities', [])
+        if questions:
+            st.markdown("#### ❓ Question Opportunities")
+            for q in questions:
+                st.write(f"• {q}")
+
+    def display_voice_search_results(self, result):
+        """Display voice search optimization results"""
+        st.markdown("### 🎤 Voice Search Optimization")
+        
+        # Conversational score
+        conv_score = result.get('conversational_score', 0)
+        if conv_score:
+            st.metric("Conversational Score", f"{conv_score}/10")
+        
+        # Question-answer pairs
+        qa_pairs = result.get('question_answer_pairs', [])
+        if qa_pairs:
+            st.markdown("#### ❓ Question-Answer Pairs")
+            for qa in qa_pairs:
+                st.write(f"**Q:** {qa.get('question', '')}")
+                st.write(f"**A:** {qa.get('answer', '')}")
+                st.write("---")
+        
+        # Featured snippet candidates
+        snippets = result.get('featured_snippet_candidates', [])
+        if snippets:
+            st.markdown("#### 🌟 Featured Snippet Candidates")
+            for i, snippet in enumerate(snippets, 1):
+                st.write(f"**{i}.** {snippet}")
+        
+        # Voice optimized content
+        voice_content = result.get('voice_optimized_content', '')
+        if voice_content:
+            st.markdown("#### 🎤 Voice-Optimized Content")
+            st.text_area("Conversational version:", value=voice_content, height=200, key="voice_output")
+
+    def display_export_options(self, result, optimization_type, original_text):
+        """Display export options for results"""
+        st.markdown("### 📥 Export Results")
+        
+        if st.button("📊 Generate Report", key="export_button"):
+            import time
+            export_data = {
+                'timestamp': time.time(),
+                'optimization_type': optimization_type,
+                'original_text': original_text,
+                'original_word_count': len(original_text.split()),
+                'results': result
+            }
+            
+            st.download_button(
+                label="Download Analysis Report",
+                data=json.dumps(export_data, indent=2),
+                file_name=f"{optimization_type}_analysis_{int(time.time())}.json",
+                mime="application/json"
+            )
     
     def render_website_analysis_tab(self):
         """Render Website GEO Analysis tab"""