Update app.py

app.py

@@ -9,7 +9,45 @@ import time
 from typing import Dict, List, Tuple
 import concurrent.futures
 
-# --- Enhanced Keyword Research ---
+# --- Manual Keywords Processor ---
+class ManualKeywordProcessor:
+    def parse_manual_keywords(self, manual_keywords: str) -> List[str]:
+        """Parse and clean manual target keywords"""
+        if not manual_keywords.strip():
+            return []
+        
+        keywords = []
+        # Split by comma, semicolon, or newline
+        raw_keywords = re.split(r'[,;\n]', manual_keywords)
+        
+        for keyword in raw_keywords:
+            cleaned = keyword.strip().lower()
+            if cleaned and len(cleaned) > 2:  # Minimum keyword length
+                keywords.append(cleaned)
+        
+        return list(set(keywords))  # Remove duplicates
+    
+    def integrate_manual_keywords(self, auto_keywords: Dict, manual_keywords: List[str]) -> Dict:
+        """Integrate manual keywords with auto-generated ones"""
+        # Add manual keywords to primary keywords list
+        manual_keyword_objects = []
+        for kw in manual_keywords:
+            manual_keyword_objects.append({
+                "keyword": kw,
+                "search_volume": "manual",
+                "difficulty": "unknown",
+                "intent": "targeted"
+            })
+        
+        # Merge with existing keywords
+        integrated = auto_keywords.copy()
+        
+        if "manual_targets" not in integrated:
+            integrated["manual_targets"] = []
+        
+        integrated["manual_targets"] = manual_keyword_objects
+        
+        return integrated
 class KeywordResearcher:
     def __init__(self):
         self.serp_api_key = None  # Users can add their SERP API key for real data
@@ -204,10 +242,41 @@ class SnippetOptimizer:
         
         return "\n".join(optimized_sections)
 
-# --- Smart Internal Linking ---
-class InternalLinker:
-    def suggest_internal_links(self, content: str, keyword: str, model) -> List[Dict]:
-        """Suggest relevant internal links based on content"""
+# --- Enhanced Link Management ---
+class LinkManager:
+    def parse_manual_links(self, links_input: str) -> Dict:
+        """Parse manual internal and external links"""
+        internal_links = []
+        external_links = []
+        
+        if not links_input.strip():
+            return {"internal": [], "external": []}
+        
+        lines = links_input.strip().split('\n')
+        for line in lines:
+            if ':' in line:
+                anchor_text, url = line.split(':', 1)
+                anchor_text = anchor_text.strip()
+                url = url.strip()
+                
+                # Determine if internal or external
+                if url.startswith('http'):
+                    # Check if it's same domain (simplified check)
+                    if 'website.com' in url or 'yourdomain.com' in url or url.startswith('/'):
+                        internal_links.append({"anchor": anchor_text, "url": url})
+                    else:
+                        external_links.append({"anchor": anchor_text, "url": url})
+                else:
+                    # Assume internal if no http
+                    internal_links.append({"anchor": anchor_text, "url": url})
+        
+        return {"internal": internal_links, "external": external_links}
+    
+    def suggest_internal_links(self, content: str, keyword: str, manual_links: Dict, model) -> List[Dict]:
+        """Suggest relevant internal links based on content and manual links"""
+        
+        # Include manual internal links in suggestions
+        existing_internal = manual_links.get("internal", [])
         
         prompt = f"""
         Analyze this content and suggest 5-7 internal linking opportunities:
@@ -215,13 +284,16 @@ class InternalLinker:
         Primary keyword: {keyword}
         Content sample: {content[:1000]}...
         
-        For each suggestion, provide:
+        Already provided internal links:
+        {chr(10).join([f"- {link['anchor']}: {link['url']}" for link in existing_internal])}
+        
+        For each NEW suggestion, provide:
         - Anchor text (natural, not over-optimized)
         - Context where it should be placed
         - Reason why it's valuable for SEO
         - Suggested target page type
         
-        Format as actionable suggestions.
+        Format as actionable suggestions. Don't repeat the existing links above.
         """
         
         try:
@@ -251,6 +323,26 @@ class InternalLinker:
                 {"text": f"Add contextual links to '{keyword}' tools or guides"},
                 {"text": f"Reference other '{keyword}' articles in conclusion"}
             ]
+    
+    def format_links_for_content(self, manual_links: Dict) -> str:
+        """Format manual links for inclusion in content"""
+        formatted_links = []
+        
+        # Internal links
+        internal_links = manual_links.get("internal", [])
+        if internal_links:
+            formatted_links.append("**Internal Links to Include:**")
+            for link in internal_links:
+                formatted_links.append(f'<a href="{link["url"]}">{link["anchor"]}</a>')
+        
+        # External links
+        external_links = manual_links.get("external", [])
+        if external_links:
+            formatted_links.append("\n**External Links to Include:**")
+            for link in external_links:
+                formatted_links.append(f'<a href="{link["url"]}" target="_blank" rel="noopener">{link["anchor"]}</a>')
+        
+        return "\n".join(formatted_links)
 
 # --- Enhanced Image Strategy ---
 class ImageStrategist:
@@ -322,7 +414,7 @@ class ImageStrategist:
 # --- Main Enhanced Generator ---
 def generate_complete_seo_content(api_key, seed_keyword, custom_outline, pov, tone, length, emotion, 
                                 include_research, include_competitor, include_outline, include_snippets, 
-                                include_linking, include_images, target_keywords, custom_cta):
+                                include_linking, include_images, manual_target_keywords, manual_links_input, custom_cta):
     
     if not api_key or not seed_keyword:
         return "Please provide API key and seed keyword to generate content."
@@ -338,21 +430,58 @@ def generate_complete_seo_content(api_key, seed_keyword, custom_outline, pov, to
     competitor_analyzer = CompetitorAnalyzer()
     outliner = ContentOutliner()
     snippet_optimizer = SnippetOptimizer()
-    internal_linker = InternalLinker()
+    link_manager = LinkManager()
     image_strategist = ImageStrategist()
+    keyword_processor = ManualKeywordProcessor()
     
     results = []
     
+    # Process manual keywords
+    manual_keywords = keyword_processor.parse_manual_keywords(manual_target_keywords)
+    if manual_keywords:
+        results.append("🎯 **MANUAL TARGET KEYWORDS PROCESSED**")
+        results.append("**Your Specified Keywords:**")
+        for kw in manual_keywords:
+            results.append(f"• {kw}")
+        results.append("\n" + "="*50 + "\n")
+    
+    # Process manual links
+    parsed_links = link_manager.parse_manual_links(manual_links_input)
+    if parsed_links["internal"] or parsed_links["external"]:
+        results.append("🔗 **MANUAL LINKS PROCESSED**")
+        
+        if parsed_links["internal"]:
+            results.append("**Internal Links:**")
+            for link in parsed_links["internal"]:
+                results.append(f"• {link['anchor']} → {link['url']}")
+        
+        if parsed_links["external"]:
+            results.append("**External Links:**")
+            for link in parsed_links["external"]:
+                results.append(f"• {link['anchor']} → {link['url']}")
+        
+        results.append("\n" + "="*50 + "\n")
+    
     # Step 1: Keyword Research
     if include_research:
         results.append("🔍 **STEP 1: KEYWORD RESEARCH**")
         keywords_data = researcher.suggest_keywords(seed_keyword, model)
         
+        # Integrate manual keywords
+        if manual_keywords:
+            keywords_data = keyword_processor.integrate_manual_keywords(keywords_data, manual_keywords)
+        
         # Format keyword research results
         results.append("**Primary Keywords:**")
         for kw in keywords_data.get("primary_keywords", [])[:5]:
             results.append(f"• {kw['keyword']} (Volume: {kw['search_volume']}, Difficulty: {kw['difficulty']})")
         
+        # Show manual keywords separately
+        if manual_keywords:
+            results.append("\n**Manual Target Keywords:**")
+            for kw in keywords_data.get("manual_targets", []):
+                results.append(f"• {kw['keyword']} (Manual Target)")
+        
         results.append("\n**Long-tail Keywords:**")
         for kw in keywords_data.get("long_tail", [])[:3]:
             results.append(f"• {kw['keyword']} (Intent: {kw['intent']})")
@@ -364,6 +493,8 @@ def generate_complete_seo_content(api_key, seed_keyword, custom_outline, pov, to
         results.append("\n" + "="*50 + "\n")
     else:
         keywords_data = {"primary_keywords": [{"keyword": seed_keyword, "search_volume": "medium", "difficulty": "medium", "intent": "informational"}]}
+        if manual_keywords:
+            keywords_data = keyword_processor.integrate_manual_keywords(keywords_data, manual_keywords)
     
     # Step 2: Competitor Analysis
     if include_competitor:
@@ -394,13 +525,18 @@ def generate_complete_seo_content(api_key, seed_keyword, custom_outline, pov, to
     
     # Extract all keywords for content generation
     all_keywords = [seed_keyword]
-    if target_keywords:
-        all_keywords.extend([k.strip() for k in target_keywords.split(',')])
     
+    # Add manual keywords first (highest priority)
+    all_keywords.extend(manual_keywords)
+    
+    # Add auto-generated keywords
     for category in keywords_data.values():
         if isinstance(category, list):
             all_keywords.extend([k["keyword"] for k in category[:2]])  # Top 2 from each category
     
+    # Prepare manual links for content integration
+    manual_links_formatted = link_manager.format_links_for_content(parsed_links)
+    
     # Enhanced content generation prompt
     content_prompt = f"""
     Write a comprehensive, SEO-optimized blog post based on this outline:
@@ -409,18 +545,26 @@ def generate_complete_seo_content(api_key, seed_keyword, custom_outline, pov, to
     
     REQUIREMENTS:
     - Primary keyword: "{seed_keyword}"
-    - Integrate these keywords naturally: {', '.join(all_keywords[:15])}
+    - MUST integrate these manual target keywords naturally: {', '.join(manual_keywords) if manual_keywords else 'None specified'}
+    - Also include these keywords: {', '.join(all_keywords[len(manual_keywords)+1:15])}
     - Tone: {tone}, POV: {pov}, Emotion: {emotion}
     - Length: {length}
     - Write in genuinely human style - avoid AI phrases
     - Use HTML formatting for WordPress
     - Include specific examples and actionable advice
     - Optimize for readability with short paragraphs
-    - Add [INTERNAL LINK] placeholders where relevant
+    
+    LINKS TO INTEGRATE:
+    {manual_links_formatted if manual_links_formatted else 'No manual links provided'}
+    
+    Instructions for links:
+    - Naturally integrate the provided internal and external links where contextually relevant
+    - Add [INTERNAL LINK OPPORTUNITY] markers for additional internal link suggestions
     - Add [IMAGE: description] placeholders for visuals
     
     Content should be comprehensive, engaging, and provide real value to readers.
     Make it feel like it's written by an expert who genuinely cares about helping the reader.
+    Prioritize the manual target keywords - they should appear naturally throughout the content.
     """
     
     try:
@@ -447,9 +591,24 @@ def generate_complete_seo_content(api_key, seed_keyword, custom_outline, pov, to
     
     # Step 6: Internal Linking Strategy
     if include_linking:
-        results.append("🔗 **STEP 6: INTERNAL LINKING STRATEGY**")
-        link_suggestions = internal_linker.suggest_internal_links(main_content, seed_keyword, model)
-        results.append("**Suggested Internal Links:**")
+        results.append("🔗 **STEP 6: LINKING STRATEGY**")
+        
+        # Show processed manual links
+        if parsed_links["internal"] or parsed_links["external"]:
+            results.append("**Your Manual Links (Already Integrated):**")
+            if parsed_links["internal"]:
+                results.append("*Internal Links:*")
+                for link in parsed_links["internal"]:
+                    results.append(f"• {link['anchor']} → {link['url']}")
+            if parsed_links["external"]:
+                results.append("*External Links:*")
+                for link in parsed_links["external"]:
+                    results.append(f"• {link['anchor']} → {link['url']}")
+            results.append("")
+        
+        # Suggest additional internal links
+        link_suggestions = link_manager.suggest_internal_links(main_content, seed_keyword, parsed_links, model)
+        results.append("**Additional Internal Link Suggestions:**")
         for i, suggestion in enumerate(link_suggestions, 1):
             results.append(f"{i}. {suggestion['text']}")
         results.append("\n" + "="*50 + "\n")
@@ -473,12 +632,15 @@ def generate_complete_seo_content(api_key, seed_keyword, custom_outline, pov, to
     Create SEO-optimized meta data for this content:
     
     Primary keyword: {seed_keyword}
+    Manual target keywords: {', '.join(manual_keywords) if manual_keywords else 'None'}
     Content summary: {main_content[:500]}...
     
     Generate:
-    1. Meta title (under 60 characters, include primary keyword)
+    1. Meta title (under 60 characters, include primary keyword and/or manual keywords)
     2. Meta description (under 160 characters, compelling and click-worthy)
     3. 3 alternative title variations
+    
+    Prioritize the manual target keywords in meta data if provided.
     """
     
     try:
@@ -488,14 +650,30 @@ def generate_complete_seo_content(api_key, seed_keyword, custom_outline, pov, to
         results.append(f"**Meta Title:** {seed_keyword.title()} - Complete Guide")
         results.append(f"**Meta Description:** Discover everything about {seed_keyword} in this comprehensive guide. Get actionable tips and expert insights.")
     
-    # Final readability analysis
+    # Final analysis including manual keywords
     word_count = len(main_content.split())
     flesch_score = textstat.flesch_reading_ease(main_content) if main_content else 0
     
+    # Count manual keyword usage
+    manual_keyword_usage = {}
+    if manual_keywords:
+        for kw in manual_keywords:
+            count = main_content.lower().count(kw.lower())
+            manual_keyword_usage[kw] = count
+    
     results.append(f"\n**Content Analysis:**")
     results.append(f"• Word Count: {word_count}")
     results.append(f"• Readability Score: {flesch_score:.1f}")
-    results.append(f"• Keywords Integrated: {len(all_keywords)}")
+    results.append(f"• Total Keywords Integrated: {len(all_keywords)}")
+    
+    if manual_keyword_usage:
+        results.append(f"• Manual Keywords Usage:")
+        for kw, count in manual_keyword_usage.items():
+            density = round((count / word_count) * 100, 2) if word_count > 0 else 0
+            results.append(f"  - '{kw}': {count} times ({density}% density)")
+    
+    if parsed_links["internal"] or parsed_links["external"]:
+        results.append(f"• Manual Links Integrated: {len(parsed_links['internal']) + len(parsed_links['external'])}")
     
     return "\n".join(results)
 
@@ -571,12 +749,23 @@ with gr.Blocks(css="""
             include_linking = gr.Checkbox(label="🔗 Internal Link Strategy", value=True)
             include_images = gr.Checkbox(label="🖼️ Image Strategy", value=True)
 
-    with gr.Accordion("⚙️ Additional Options", open=False):
-        target_keywords_input = gr.Textbox(
-            label="Additional Target Keywords", 
-            placeholder="Comma-separated keywords to include",
-            info="Optional: Add specific keywords you want to target"
+    with gr.Accordion("⚙️ Manual Targeting & Links", open=True):
+        gr.Markdown("### 🎯 Manual Target Keywords")
+        manual_target_keywords_input = gr.Textbox(
+            label="Manual Target Keywords", 
+            placeholder="fermented pickle, homemade fermentation, pickle fermentation process",
+            lines=3,
+            info="Comma-separated keywords you specifically want to target. These get PRIORITY in content generation."
+        )
+        
+        gr.Markdown("### 🔗 Manual Internal & External Links")
+        manual_links_input = gr.Textbox(
+            label="Links to Include", 
+            placeholder="fermented pickle guide: https://www.website.com/fermented-pickle-at-home\nhealthy fermentation: /internal-page\nfermentation benefits: https://external-authority.com/benefits",
+            lines=6,
+            info="Format: 'Anchor Text: URL' (one per line). Use full URLs for external, relative paths for internal."
         )
+        
         custom_cta_input = gr.Textbox(
             label="Custom Call-to-Action", 
             placeholder="Leave blank for auto-generated CTA",
@@ -592,7 +781,8 @@ with gr.Blocks(css="""
         inputs=[
             api_key_input, seed_keyword_input, custom_outline_input, pov_input, tone_input,
             length_input, emotion_input, include_research, include_competitor, include_outline,
-            include_snippets, include_linking, include_images, target_keywords_input, custom_cta_input
+            include_snippets, include_linking, include_images, manual_target_keywords_input, 
+            manual_links_input, custom_cta_input
         ],
         outputs=output
     )
@@ -601,14 +791,29 @@ with gr.Blocks(css="""
     ## 🎯 What This System Does:
 
     **Complete SEO Workflow Coverage:**
-    1. **Keyword Research** - Find primary, long-tail, and question keywords with intent analysis
-    2. **Competitor Analysis** - Identify content gaps and differentiation opportunities  
-    3. **Content Outline** - Generate SEO-optimized H1/H2/H3 structure
-    4. **Article Generation** - Write comprehensive, human-like content
-    5. **Featured Snippet Optimization** - Format FAQs and answers for Google snippets
-    6. **Internal Link Strategy** - Suggest relevant internal linking opportunities
-    7. **Image Strategy** - Plan visual content with SEO-optimized alt texts
-    8. **Meta Data** - Generate optimized titles and descriptions
+    1. **Manual Targeting** - Specify exact keywords and links you want prioritized
+    2. **Keyword Research** - Find primary, long-tail, and question keywords with intent analysis
+    3. **Competitor Analysis** - Identify content gaps and differentiation opportunities  
+    4. **Content Outline** - Generate SEO-optimized H1/H2/H3 structure
+    5. **Article Generation** - Write comprehensive, human-like content with your manual targets
+    6. **Featured Snippet Optimization** - Format FAQs and answers for Google snippets
+    7. **Link Strategy** - Integrate your manual links + suggest additional opportunities
+    8. **Image Strategy** - Plan visual content with SEO-optimized alt texts
+    9. **Meta Data** - Generate optimized titles and descriptions
+
+    **🆕 NEW Manual Targeting Features:**
+    - **Priority Keywords**: Your manual keywords get highest priority in content
+    - **Smart Link Integration**: Automatically integrates your internal/external links contextually  
+    - **Link Classification**: Automatically detects internal vs external links
+    - **Usage Tracking**: Shows exactly how many times your manual keywords appear
+    - **Density Analysis**: Calculates keyword density for your target terms
+
+    **Link Format Examples:**
+    ```
+    fermented pickle guide: https://www.website.com/fermented-pickle-at-home
+    healthy fermentation: /internal-fermentation-page
+    scientific study: https://pubmed.ncbi.nlm.nih.gov/study-link
+    ```
 
     **Enhanced Features:**
     - Human tone enforcement (avoid AI-like phrases)
@@ -616,8 +821,9 @@ with gr.Blocks(css="""
     - Competitor content gap analysis
     - Featured snippet formatting
     - Strategic image placement
-    - Internal linking suggestions
+    - Manual + automatic linking strategy
     - Complete meta data optimization
+    - Priority keyword tracking
     """)
 
 if __name__ == "__main__":