ALwrity Version 0.5.0 (Fastapi + React )

lib/content_calendar/README.md

@@ -0,0 +1,167 @@
+# Content Calendar & Topic Planning System
+
+A comprehensive content planning and scheduling system that leverages existing SEO tools and AI capabilities to create optimized content calendars based on content gap analysis.
+
+## Folder Structure
+
+```
+content_calendar/
+├── README.md
+├── core/
+│   ├── __init__.py
+│   ├── calendar_manager.py      # Main calendar management system
+│   ├── topic_generator.py       # AI-powered topic generation
+│   └── content_predictor.py     # Content performance prediction
+├── integrations/
+│   ├── __init__.py
+│   ├── seo_tools.py            # Integration with existing SEO tools
+│   ├── gap_analyzer.py         # Content gap analysis integration
+│   └── platform_adapters.py    # Platform-specific content adaptation
+├── models/
+│   ├── __init__.py
+│   ├── calendar.py             # Calendar data models
+│   ├── content.py              # Content data models
+│   └── analytics.py            # Analytics data models
+├── utils/
+│   ├── __init__.py
+│   ├── date_utils.py           # Date and scheduling utilities
+│   ├── validation.py           # Input validation
+│   └── error_handling.py       # Error handling utilities
+└── tests/
+    ├── __init__.py
+    ├── test_calendar.py
+    ├── test_topic_generator.py
+    └── test_integrations.py
+```
+
+## Implementation Plan
+
+### Phase 1: Core Infrastructure
+
+1. **Basic Calendar Management**
+   - Implement calendar data structures
+   - Create scheduling algorithms
+   - Build date management utilities
+
+2. **Topic Generation System**
+   - Integrate with existing AI tools
+   - Implement topic generation logic
+   - Add SEO optimization features
+
+3. **Integration Framework**
+   - Connect with existing SEO tools
+   - Implement content gap analysis integration
+   - Create platform-specific adapters
+
+### Phase 2: AI & SEO Enhancement
+
+1. **AI-Powered Features**
+   - Implement topic ideation
+   - Add content structure generation
+   - Create performance prediction models
+
+2. **SEO Optimization**
+   - Integrate title optimization
+   - Add meta description generation
+   - Implement structured data creation
+
+3. **Content Performance**
+   - Add performance tracking
+   - Implement analytics collection
+   - Create reporting system
+
+### Phase 3: UI Development
+
+1. **Calendar Interface**
+   - Create interactive calendar view
+   - Implement drag-and-drop functionality
+   - Add platform-specific views
+
+2. **Content Planning Panel**
+   - Build topic suggestion interface
+   - Create SEO metrics display
+   - Implement content gap visualization
+
+3. **Analytics Dashboard**
+   - Design performance metrics view
+   - Create engagement tracking
+   - Implement progress monitoring
+
+### Phase 4: Testing & Refinement
+
+1. **Testing**
+   - Unit testing
+   - Integration testing
+   - User acceptance testing
+
+2. **Optimization**
+   - Performance optimization
+   - Code refactoring
+   - Bug fixes
+
+3. **Documentation**
+   - API documentation
+   - User guides
+   - Integration guides
+
+## Integration with Existing Tools
+
+### SEO Tools Integration
+- `content_title_generator.py` - For optimized titles
+- `meta_desc_generator.py` - For meta descriptions
+- `seo_structured_data.py` - For structured data
+- `content_gap_analysis/` - For gap analysis
+- `webpage_content_analysis.py` - For content analysis
+
+### AI Capabilities
+- Leverage existing `llm_text_gen` for:
+  - Topic generation
+  - Content structure
+  - Performance prediction
+
+## Key Features
+
+1. **Content Planning**
+   - AI-powered topic generation
+   - SEO-optimized content scheduling
+   - Platform-specific planning
+
+2. **SEO Integration**
+   - Automated SEO optimization
+   - Performance tracking
+   - Gap analysis integration
+
+3. **Analytics & Reporting**
+   - Content performance metrics
+   - SEO impact tracking
+   - Platform engagement stats
+
+## Getting Started
+
+1. **Prerequisites**
+   - Python 3.8+
+   - Access to existing SEO tools
+   - Required API keys
+
+2. **Installation**
+   ```bash
+   # Add installation steps here
+   ```
+
+3. **Configuration**
+   ```python
+   # Add configuration example here
+   ```
+
+4. **Basic Usage**
+   ```python
+   # Add usage example here
+   ```
+
+## Contributing
+
+Guidelines for contributing to the project.
+
+## License
+
+Project license information. 

lib/content_calendar/core/ai_generator.py

@@ -0,0 +1,754 @@
+from typing import Dict, List, Any, Optional
+import logging
+from pathlib import Path
+import sys
+import json
+
+# Add parent directory to path to import existing tools
+parent_dir = str(Path(__file__).parent.parent.parent.parent)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+from lib.database.models import ContentType, ContentItem, Platform
+from lib.ai_seo_tools.content_calendar.utils.error_handling import handle_calendar_error
+from lib.gpt_providers.text_generation.main_text_generation import llm_text_gen
+from lib.ai_seo_tools.content_gap_analysis.main import ContentGapAnalysis
+from lib.ai_seo_tools.content_title_generator import ai_title_generator
+from lib.ai_seo_tools.meta_desc_generator import metadesc_generator_main
+
+logger = logging.getLogger(__name__)
+
+class AIGenerator:
+    """AI-powered content generation and enhancement."""
+    
+    def __init__(self):
+        self.logger = logging.getLogger('content_calendar.ai_generator')
+        self.logger.info("Initializing AIGenerator")
+        self._setup_logging()
+        self._load_ai_tools()
+    
+    def _setup_logging(self):
+        """Configure logging for AI generator."""
+        logger.setLevel(logging.INFO)
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    
+    def _load_ai_tools(self):
+        """Load and initialize AI tools."""
+        try:
+            # Initialize AI tools
+            self.gap_analyzer = ContentGapAnalysis()
+            self.title_generator = ai_title_generator
+            self.meta_generator = metadesc_generator_main
+            
+        except Exception as e:
+            logger.error(f"Error loading AI tools: {str(e)}")
+            raise
+    
+    def generate_content(self, content_item: ContentItem, target_audience: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate base content using AI."""
+        try:
+            self.logger.info(f"Generating content for: {content_item.title}")
+            
+            # Generate content based on type and platform
+            content = {
+                'title': content_item.title,
+                'content_flow': {
+                    'introduction': {
+                        'summary': f"An engaging introduction about {content_item.title}",
+                        'key_points': [
+                            f"Key point 1 about {content_item.title}",
+                            f"Key point 2 about {content_item.title}",
+                            f"Key point 3 about {content_item.title}"
+                        ]
+                    },
+                    'main_content': {
+                        'sections': [
+                            {
+                                'title': f"Section 1: Understanding {content_item.title}",
+                                'content': f"Detailed content about {content_item.title}",
+                                'subsections': []
+                            },
+                            {
+                                'title': f"Section 2: Best Practices for {content_item.title}",
+                                'content': "Best practices and recommendations",
+                                'subsections': []
+                            }
+                        ]
+                    },
+                    'conclusion': {
+                        'summary': f"Concluding thoughts about {content_item.title}",
+                        'call_to_action': "Next steps and actions"
+                    }
+                },
+                'metadata': {
+                    'tone': target_audience.get('content_settings', {}).get('tone', 'professional'),
+                    'length': target_audience.get('content_settings', {}).get('length', 'medium'),
+                    'platform': content_item.platforms[0].name if content_item.platforms else 'Unknown',
+                    'content_type': content_item.content_type.name
+                }
+            }
+            
+            return content
+            
+        except Exception as e:
+            self.logger.error(f"Error generating content: {str(e)}", exc_info=True)
+            return {}
+
+    def enhance_content(self, content: ContentItem, enhancement_type: str, target_audience: Dict[str, Any]) -> Dict[str, Any]:
+        """Enhance existing content using AI."""
+        try:
+            self.logger.info(f"Enhancing content: {content.title}")
+            
+            # Enhance content based on type
+            enhanced = {
+                'content': f"Enhanced version of {content.description}",
+                'changes': [
+                    "Improved readability",
+                    "Enhanced engagement elements",
+                    "Optimized for target audience"
+                ],
+                'metadata': {
+                    'enhancement_type': enhancement_type,
+                    'target_audience': target_audience
+                }
+            }
+            
+            return enhanced
+            
+        except Exception as e:
+            self.logger.error(f"Error enhancing content: {str(e)}", exc_info=True)
+            return {}
+
+    def enhance_for_platform(self, content: Dict[str, Any], platform: Platform, enhancement_type: str) -> Dict[str, Any]:
+        """Enhance content specifically for a platform."""
+        try:
+            self.logger.info(f"Enhancing content for platform: {platform.name}")
+            
+            # Platform-specific enhancements
+            enhanced = {
+                'content': content.get('content', ''),
+                'changes': [
+                    f"Optimized for {platform.name}",
+                    "Platform-specific formatting",
+                    "Enhanced engagement elements"
+                ],
+                'metadata': {
+                    'platform': platform.name,
+                    'enhancement_type': enhancement_type
+                }
+            }
+            
+            return enhanced
+            
+        except Exception as e:
+            self.logger.error(f"Error enhancing for platform: {str(e)}", exc_info=True)
+            return {}
+
+    def enhance_variant(self, content: Dict[str, Any], variant_type: str, optimization_goals: List[str]) -> Dict[str, Any]:
+        """Enhance a content variant for A/B testing."""
+        try:
+            self.logger.info(f"Enhancing variant: {variant_type}")
+            
+            # Variant-specific enhancements
+            enhanced = {
+                'content': content.get('content', ''),
+                'changes': [
+                    f"Optimized for {', '.join(optimization_goals)}",
+                    "Enhanced variant-specific elements",
+                    "Improved engagement metrics"
+                ],
+                'metadata': {
+                    'variant_type': variant_type,
+                    'optimization_goals': optimization_goals
+                }
+            }
+            
+            return enhanced
+            
+        except Exception as e:
+            self.logger.error(f"Error enhancing variant: {str(e)}", exc_info=True)
+            return {}
+
+    def enhance_for_seo(self, content: Dict[str, Any], seo_goals: List[str]) -> Dict[str, Any]:
+        """Enhance content for SEO optimization."""
+        try:
+            self.logger.info("Enhancing content for SEO")
+            
+            # SEO-specific enhancements
+            enhanced = {
+                'content': content.get('content', ''),
+                'changes': [
+                    f"Optimized for {', '.join(seo_goals)}",
+                    "Enhanced keyword placement",
+                    "Improved meta information"
+                ],
+                'metadata': {
+                    'seo_goals': seo_goals
+                }
+            }
+            
+            return enhanced
+            
+        except Exception as e:
+            self.logger.error(f"Error enhancing for SEO: {str(e)}", exc_info=True)
+            return {}
+
+    def generate_series_content(self, content_item: ContentItem, series_info: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate content for a series."""
+        try:
+            self.logger.info(f"Generating series content: {content_item.title}")
+            
+            # Generate series-specific content
+            content = {
+                'title': content_item.title,
+                'content_flow': {
+                    'introduction': {
+                        'summary': f"Part {series_info['part_number']} of {series_info['total_parts']} about {series_info['topic']}",
+                        'key_points': [
+                            f"Key point 1 for part {series_info['part_number']}",
+                            f"Key point 2 for part {series_info['part_number']}",
+                            f"Key point 3 for part {series_info['part_number']}"
+                        ]
+                    },
+                    'main_content': {
+                        'sections': [
+                            {
+                                'title': f"Section 1: Part {series_info['part_number']} Overview",
+                                'content': f"Detailed content for part {series_info['part_number']}",
+                                'subsections': []
+                            },
+                            {
+                                'title': f"Section 2: Part {series_info['part_number']} Details",
+                                'content': "Specific details and information",
+                                'subsections': []
+                            }
+                        ]
+                    },
+                    'conclusion': {
+                        'summary': f"Concluding thoughts for part {series_info['part_number']}",
+                        'next_part': f"Preview of part {series_info['part_number'] + 1}" if series_info['part_number'] < series_info['total_parts'] else "Series conclusion"
+                    }
+                },
+                'metadata': {
+                    'series_info': series_info,
+                    'platform': content_item.platforms[0].name if content_item.platforms else 'Unknown',
+                    'content_type': content_item.content_type.name
+                }
+            }
+            
+            return content
+            
+        except Exception as e:
+            self.logger.error(f"Error generating series content: {str(e)}", exc_info=True)
+            return {}
+
+    @handle_calendar_error
+    def generate_headings(
+        self,
+        title: str,
+        content_type: ContentType,
+        context: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """
+        Generate content headings using AI.
+        
+        Args:
+            title: Content title
+            content_type: Type of content
+            context: Content context from gap analysis
+            
+        Returns:
+            List of generated headings with metadata
+        """
+        try:
+            # Get content gaps and opportunities
+            gaps = self.gap_analyzer.analyze_gaps(context.get('website_url', ''))
+            
+            # Generate headings based on content type and gaps
+            prompt = self._create_heading_prompt(title, content_type, gaps)
+            headings = self._call_ai_model(prompt)
+            
+            return self._format_headings(headings)
+            
+        except Exception as e:
+            logger.error(f"Error generating headings: {str(e)}")
+            return []
+    
+    @handle_calendar_error
+    def generate_subheadings(
+        self,
+        main_heading: Dict[str, Any],
+        content_type: ContentType,
+        context: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """
+        Generate subheadings for a main heading.
+        
+        Args:
+            main_heading: Main heading to generate subheadings for
+            content_type: Type of content
+            context: Content context
+            
+        Returns:
+            List of generated subheadings
+        """
+        try:
+            # Create prompt for subheading generation
+            prompt = self._create_subheading_prompt(
+                main_heading,
+                content_type,
+                context
+            )
+            
+            # Generate subheadings
+            subheadings = self._call_ai_model(prompt)
+            
+            return self._format_subheadings(subheadings)
+            
+        except Exception as e:
+            logger.error(f"Error generating subheadings: {str(e)}")
+            return []
+    
+    @handle_calendar_error
+    def generate_key_points(
+        self,
+        title: str,
+        content_type: ContentType,
+        context: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """
+        Generate key points for content.
+        
+        Args:
+            title: Content title
+            content_type: Type of content
+            context: Content context
+            
+        Returns:
+            List of key points with supporting information
+        """
+        try:
+            # Generate title and meta description for SEO context
+            seo_title = self.title_generator(title)
+            meta_desc = self.meta_generator(title)
+            
+            # Create prompt for key points
+            prompt = self._create_key_points_prompt(
+                title,
+                content_type,
+                {'title': seo_title, 'meta_description': meta_desc},
+                context
+            )
+            
+            # Generate key points
+            points = self._call_ai_model(prompt)
+            
+            return self._format_key_points(points)
+            
+        except Exception as e:
+            logger.error(f"Error generating key points: {str(e)}")
+            return []
+    
+    @handle_calendar_error
+    def generate_content_flow(
+        self,
+        title: str,
+        content_type: ContentType,
+        outline: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Generate content flow and structure.
+        
+        Args:
+            title: Content title
+            content_type: Type of content
+            outline: Content outline with headings and key points
+            
+        Returns:
+            Dictionary containing content flow and structure
+        """
+        try:
+            # Create prompt for content flow
+            prompt = self._create_flow_prompt(title, content_type, outline)
+            
+            # Generate content flow
+            flow = self._call_ai_model(prompt)
+            
+            return self._format_content_flow(flow)
+            
+        except Exception as e:
+            logger.error(f"Error generating content flow: {str(e)}")
+            return {}
+    
+    def _create_heading_prompt(
+        self,
+        title: str,
+        content_type: ContentType,
+        gaps: Dict[str, Any]
+    ) -> str:
+        """Create prompt for heading generation."""
+        return f"""
+        Generate main headings for a {content_type.value} titled "{title}".
+        Consider the following content gaps and opportunities:
+        {json.dumps(gaps, indent=2)}
+        
+        For each heading, provide:
+        1. Title
+        2. Level (1 for main headings)
+        3. Key keywords to include
+        4. Brief summary of what this section should cover
+        
+        Format the response as a JSON array of heading objects.
+        """
+    
+    def _create_subheading_prompt(
+        self,
+        main_heading: Dict[str, Any],
+        content_type: ContentType,
+        context: Dict[str, Any]
+    ) -> str:
+        """Create prompt for subheading generation."""
+        return f"""
+        Generate subheadings for the main heading "{main_heading['title']}" 
+        in a {content_type.value}.
+        
+        Main heading details:
+        {json.dumps(main_heading, indent=2)}
+        
+        For each subheading, provide:
+        1. Title
+        2. Level (2 for subheadings)
+        3. Key keywords to include
+        4. Brief summary of what this subsection should cover
+        
+        Format the response as a JSON array of subheading objects.
+        """
+    
+    def _create_key_points_prompt(
+        self,
+        title: str,
+        content_type: ContentType,
+        seo_data: Dict[str, Any],
+        context: Dict[str, Any]
+    ) -> str:
+        """Create prompt for key points generation."""
+        return f"""
+        Generate key points for a {content_type.value} titled "{title}".
+        
+        SEO Requirements:
+        {json.dumps(seo_data, indent=2)}
+        
+        For each key point, provide:
+        1. Main point
+        2. Importance level (high/medium/low)
+        3. Supporting evidence or examples
+        4. Related keywords to include
+        
+        Format the response as a JSON array of key point objects.
+        """
+    
+    def _create_flow_prompt(
+        self,
+        title: str,
+        content_type: ContentType,
+        outline: Dict[str, Any]
+    ) -> str:
+        """Create prompt for content flow generation."""
+        return f"""
+        Generate content flow and structure for a {content_type.value} titled "{title}".
+        
+        Content Outline:
+        {json.dumps(outline, indent=2)}
+        
+        Provide:
+        1. Introduction structure
+        2. Main sections flow
+        3. Conclusion approach
+        4. Transition points between sections
+        5. Content pacing recommendations
+        
+        Format the response as a JSON object with these sections.
+        """
+    
+    def _call_ai_model(self, prompt: str) -> Any:
+        """
+        Call the AI model with the given prompt.
+        
+        Args:
+            prompt: The prompt to send to the AI model
+            
+        Returns:
+            The AI model's response, parsed as JSON
+        """
+        try:
+            # Call the AI model
+            response = llm_text_gen(
+                prompt=prompt,
+                max_tokens=1000,
+                temperature=0.7,
+                top_p=0.9,
+                frequency_penalty=0.5,
+                presence_penalty=0.5
+            )
+            
+            # Parse the response as JSON
+            try:
+                return json.loads(response)
+            except json.JSONDecodeError as e:
+                logger.error(f"Error parsing AI response as JSON: {str(e)}")
+                logger.error(f"Raw response: {response}")
+                return {}
+            
+        except Exception as e:
+            logger.error(f"Error calling AI model: {str(e)}")
+            return {}
+    
+    def _format_headings(self, headings: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Format and validate generated headings."""
+        formatted = []
+        for heading in headings:
+            formatted.append({
+                'title': heading.get('title', ''),
+                'level': heading.get('level', 1),
+                'keywords': heading.get('keywords', []),
+                'summary': heading.get('summary', '')
+            })
+        return formatted
+    
+    def _format_subheadings(self, subheadings: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Format and validate generated subheadings."""
+        formatted = []
+        for subheading in subheadings:
+            formatted.append({
+                'title': subheading.get('title', ''),
+                'level': subheading.get('level', 2),
+                'keywords': subheading.get('keywords', []),
+                'summary': subheading.get('summary', '')
+            })
+        return formatted
+    
+    def _format_key_points(self, points: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Format and validate generated key points."""
+        formatted = []
+        for point in points:
+            formatted.append({
+                'point': point.get('point', ''),
+                'importance': point.get('importance', 'medium'),
+                'supporting_evidence': point.get('evidence', []),
+                'related_keywords': point.get('keywords', [])
+            })
+        return formatted
+    
+    def _format_content_flow(self, flow: Dict[str, Any]) -> Dict[str, Any]:
+        """Format and validate generated content flow."""
+        return {
+            'introduction': flow.get('introduction', {}),
+            'main_sections': flow.get('main_sections', []),
+            'conclusion': flow.get('conclusion', {}),
+            'transitions': flow.get('transitions', []),
+            'content_pacing': flow.get('pacing', {})
+        }
+
+    def generate_ai_suggestions(
+        self,
+        content_type: str,
+        topic: str,
+        audience: str,
+        goals: List[str],
+        tone: str,
+        length: str,
+        model_settings: Dict[str, Any],
+        style_preferences: List[str],
+        seo_preferences: Dict[str, Any],
+        platform_settings: Dict[str, Any],
+        platform: str
+    ) -> List[Dict[str, Any]]:
+        """
+        Generate AI content suggestions based on input parameters.
+        """
+        try:
+            self.logger.info(f"Generating AI suggestions for topic: {topic}")
+            
+            # Create a comprehensive prompt for content generation
+            prompt = f"""Generate content suggestions for the following parameters:
+
+Content Type: {content_type}
+Topic: {topic}
+Target Audience: {audience}
+Goals: {', '.join(goals)}
+Tone: {tone}
+Length: {length}
+
+Style Preferences:
+- Creativity Level: {model_settings.get('Creativity Level', 'medium')}
+- Formality Level: {model_settings.get('Formality Level', 'professional')}
+- Style Elements: {', '.join(style_preferences)}
+
+SEO Preferences:
+- Keyword Density: {seo_preferences.get('Keyword Density', 2)}%
+- Internal Linking: {'Enabled' if seo_preferences.get('Internal Linking', True) else 'Disabled'}
+- External Linking: {'Enabled' if seo_preferences.get('External Linking', True) else 'Disabled'}
+
+Platform Settings:
+- Platform: {platform}
+- Platform-specific requirements: {', '.join(platform_settings)}
+
+Please generate 3 different content suggestions. Format your response as a valid JSON object with the following structure:
+{{
+    "suggestions": [
+        {{
+            "title": "string",
+            "introduction": "string",
+            "key_points": ["string"],
+            "main_sections": [
+                {{
+                    "title": "string",
+                    "content": "string",
+                    "engagement_elements": ["string"],
+                    "seo_elements": ["string"]
+                }}
+            ],
+            "conclusion": "string",
+            "seo_elements": ["string"],
+            "platform_optimizations": ["string"],
+            "engagement_strategies": ["string"],
+            "content_metrics": {{
+                "estimated_read_time": "string",
+                "word_count": "number",
+                "keyword_density": "number",
+                "engagement_score": "number"
+            }}
+        }}
+    ]
+}}
+
+IMPORTANT: Your response must be a valid JSON object. Do not include any text before or after the JSON object."""
+
+            # Generate content using llm_text_gen
+            generated_content = llm_text_gen(
+                prompt=prompt,
+                max_tokens=1000,
+                temperature=0.7,
+                top_p=0.9,
+                frequency_penalty=0.5,
+                presence_penalty=0.5
+            )
+            
+            if not generated_content:
+                self.logger.error("No content generated from AI model")
+                return []
+
+            # Parse the generated content
+            try:
+                # If generated_content is already a dict, use it directly
+                if isinstance(generated_content, dict):
+                    content_data = generated_content
+                else:
+                    # Try to parse as JSON string
+                    content_data = json.loads(generated_content)
+                
+                if not content_data or 'suggestions' not in content_data:
+                    self.logger.error("Invalid content structure in AI response")
+                    return []
+
+                return self._format_suggestions(
+                    content_data,
+                    content_type,
+                    audience,
+                    goals,
+                    tone,
+                    length,
+                    model_settings,
+                    seo_preferences,
+                    platform
+                )
+                
+            except json.JSONDecodeError as e:
+                self.logger.error(f"Error parsing generated content: {str(e)}")
+                # Try to extract JSON from the response if it's wrapped in other text
+                try:
+                    # Find the first '{' and last '}'
+                    start = generated_content.find('{')
+                    end = generated_content.rfind('}') + 1
+                    if start >= 0 and end > start:
+                        json_str = generated_content[start:end]
+                        content_data = json.loads(json_str)
+                        if not content_data or 'suggestions' not in content_data:
+                            self.logger.error("Invalid content structure in extracted JSON")
+                            return []
+                        return self._format_suggestions(
+                            content_data,
+                            content_type,
+                            audience,
+                            goals,
+                            tone,
+                            length,
+                            model_settings,
+                            seo_preferences,
+                            platform
+                        )
+                except Exception as e2:
+                    self.logger.error(f"Error extracting JSON from response: {str(e2)}")
+                    return []
+            
+        except Exception as e:
+            self.logger.error(f"Error generating AI suggestions: {str(e)}", exc_info=True)
+            return []
+
+    def _format_suggestions(
+        self,
+        content_data: Dict[str, Any],
+        content_type: str,
+        audience: str,
+        goals: List[str],
+        tone: str,
+        length: str,
+        model_settings: Dict[str, Any],
+        seo_preferences: Dict[str, Any],
+        platform: str
+    ) -> List[Dict[str, Any]]:
+        """Format and process suggestions from content data."""
+        suggestions = []
+        for suggestion in content_data.get('suggestions', []):
+            formatted_suggestion = {
+                'title': suggestion.get('title', ''),
+                'type': content_type,
+                'platform': platform,
+                'audience': audience,
+                'impact': f"High impact for {', '.join(goals)}",
+                'preview': suggestion.get('introduction', ''),
+                'style_elements': [
+                    f"Tone: {tone}",
+                    f"Length: {length}",
+                    f"Creativity: {model_settings['Creativity Level']}",
+                    f"Formality: {model_settings['Formality Level']}"
+                ],
+                'seo_elements': [
+                    f"Keyword Density: {seo_preferences['Keyword Density']}%",
+                    "Internal Linking: Enabled" if seo_preferences['Internal Linking'] else "Internal Linking: Disabled",
+                    "External Linking: Enabled" if seo_preferences['External Linking'] else "External Linking: Disabled"
+                ],
+                'engagement_score': f"{85 + len(suggestions)*5}%",
+                'reach': 'High',
+                'conversion': f"{3.5 + len(suggestions)*0.5}%",
+                'seo_impact': 'Strong',
+                'platform_optimizations': suggestion.get('platform_optimizations', []),
+                'variations': [
+                    "Alternative headline",
+                    "Different content angle",
+                    "Alternative format"
+                ],
+                'seo_recommendations': suggestion.get('seo_elements', []),
+                'media_suggestions': [
+                    "Featured image",
+                    "Supporting graphics",
+                    "Social media visuals"
+                ]
+            }
+            suggestions.append(formatted_suggestion)
+        return suggestions 

lib/content_calendar/core/calendar_manager.py

@@ -0,0 +1,163 @@
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional
+import logging
+import sys
+import json
+import os
+from lib.database.models import ContentItem, ContentType, Platform, get_engine, get_session, init_db
+from ..integrations.seo_tools import SEOToolsIntegration
+from ..integrations.gap_analyzer import GapAnalyzerIntegration
+from ..utils.date_utils import calculate_publish_dates
+from ..utils.error_handling import handle_calendar_error
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler('content_calendar_debug.log', mode='a')
+    ]
+)
+logger = logging.getLogger(__name__)
+
+engine = get_engine()
+init_db(engine)
+session = get_session(engine)
+
+class CalendarManager:
+    """
+    Main calendar management system that coordinates content planning,
+    scheduling, and optimization.
+    """
+    def __init__(self):
+        self.logger = logging.getLogger('content_calendar.manager')
+        self.logger.info("Initializing CalendarManager")
+        self.seo_tools = SEOToolsIntegration()
+        self.gap_analyzer = GapAnalyzerIntegration()
+        self.logger.info("CalendarManager initialized successfully")
+
+    @handle_calendar_error
+    def create_calendar(
+        self,
+        start_date: datetime,
+        duration: str,  # 'weekly', 'monthly', 'quarterly'
+        platforms: List[str],
+        website_url: str
+    ) -> List[ContentItem]:
+        self.logger.info(f"Creating new calendar for {website_url}")
+        self.logger.debug(f"Parameters: start_date={start_date}, duration={duration}, platforms={platforms}")
+        try:
+            gap_analysis = self.gap_analyzer.analyze_gaps(website_url)
+            topics = self._generate_topics(gap_analysis, platforms)
+            schedule = calculate_publish_dates(
+                topics=topics,
+                start_date=start_date,
+                duration=duration
+            )
+            # Add to DB
+            for topic in schedule:
+                session.add(topic)
+            session.commit()
+            self.logger.info("Calendar created and content scheduled in DB successfully")
+            return schedule
+        except Exception as e:
+            self.logger.error(f"Error creating calendar: {str(e)}", exc_info=True)
+            raise
+
+    def _generate_topics(
+        self,
+        gap_analysis: Dict[str, Any],
+        platforms: List[str]
+    ) -> List[ContentItem]:
+        topics = []
+        for gap in gap_analysis['gaps']:
+            topic = self._generate_topic_from_gap(gap, platforms)
+            optimized_topic = self._optimize_topic(topic)
+            topics.append(optimized_topic)
+        return topics
+
+    def _generate_topic_from_gap(
+        self,
+        gap: Dict[str, Any],
+        platforms: List[str]
+    ) -> ContentItem:
+        topic_data = {
+            'title': self._generate_title(gap),
+            'description': self._generate_description(gap),
+            'keywords': gap.get('keywords', []),
+            'platforms': platforms,
+            'content_type': self._determine_content_type(gap, platforms),
+            'publish_date': datetime.now(),
+            'status': 'Draft',
+            'author': None,
+            'tags': [],
+            'notes': None,
+            'seo_data': {}
+        }
+        return ContentItem(**topic_data)
+
+    def _optimize_topic(self, topic: ContentItem) -> ContentItem:
+        topic.title = self.seo_tools.optimize_title(topic.title)
+        topic.seo_data['meta_description'] = self.seo_tools.generate_meta_description(topic.description)
+        topic.seo_data['structured_data'] = self.seo_tools.generate_structured_data(topic.content_type)
+        return topic
+
+    def get_all_content(self) -> List[ContentItem]:
+        return session.query(ContentItem).all()
+
+    def remove_content(self, content_id):
+        content = session.query(ContentItem).get(content_id)
+        if content:
+            session.delete(content)
+            session.commit()
+
+    def update_content(self, content_id, **kwargs):
+        content = session.query(ContentItem).get(content_id)
+        if content:
+            for key, value in kwargs.items():
+                setattr(content, key, value)
+            session.commit()
+
+    def get_calendar(self) -> Optional[List[ContentItem]]:
+        """
+        Get the current calendar.
+        """
+        self.logger.debug("Getting current calendar")
+        return self.get_all_content()
+    
+    def update_calendar(self, calendar: List[ContentItem]) -> None:
+        """
+        Update the current calendar.
+        """
+        self.get_all_content()
+        for content in calendar:
+            session.add(content)
+        session.commit()
+    
+    def export_calendar(self) -> Optional[Dict[str, Any]]:
+        """Export the current calendar."""
+        self.logger.info("Exporting calendar")
+        calendar = self.get_calendar()
+        if not calendar:
+            self.logger.warning("No calendar to export")
+            return None
+        
+        try:
+            calendar_data = [content.to_dict() for content in calendar]
+            self.logger.info("Calendar exported successfully")
+            return calendar_data
+        except Exception as e:
+            self.logger.error(f"Error exporting calendar: {str(e)}", exc_info=True)
+            return None
+
+    def save_calendar_to_json(self):
+        calendar = self.get_calendar()
+        if calendar:
+            with open("calendar_data.json", "w") as f:
+                json.dump(calendar, f, indent=2, default=str)
+
+    def load_calendar_from_json(self):
+        if os.path.exists("calendar_data.json"):
+            with open("calendar_data.json", "r") as f:
+                data = json.load(f)
+            self.update_calendar(data) 

lib/content_calendar/core/content_brief.py

@@ -0,0 +1,151 @@
+from typing import Dict, List, Any, Optional
+import logging
+from pathlib import Path
+import sys
+
+# Add parent directory to path to import existing tools
+parent_dir = str(Path(__file__).parent.parent.parent.parent)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+from lib.database.models import ContentType, ContentItem, Platform
+from lib.ai_seo_tools.content_calendar.utils.error_handling import handle_calendar_error
+from lib.gpt_providers.text_generation.main_text_generation import llm_text_gen
+from lib.ai_seo_tools.content_gap_analysis.main import ContentGapAnalysis
+from lib.ai_seo_tools.content_title_generator import ai_title_generator
+from lib.ai_seo_tools.meta_desc_generator import metadesc_generator_main
+from .ai_generator import AIGenerator
+
+logger = logging.getLogger(__name__)
+
+class ContentBriefGenerator:
+    """
+    Generates comprehensive content briefs using AI-powered analysis.
+    """
+    
+    def __init__(self):
+        self.logger = logging.getLogger('content_calendar.content_brief')
+        self.logger.info("Initializing ContentBriefGenerator")
+        self._setup_logging()
+        self._load_ai_tools()
+    
+    def _setup_logging(self):
+        """Configure logging for content brief generator."""
+        logger.setLevel(logging.INFO)
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    
+    def _load_ai_tools(self):
+        """Load and initialize AI tools."""
+        try:
+            # Initialize AI tools
+            self.gap_analyzer = ContentGapAnalysis()
+            self.title_generator = ai_title_generator
+            self.meta_generator = metadesc_generator_main
+            self.ai_generator = AIGenerator()
+            
+        except Exception as e:
+            logger.error(f"Error loading AI tools: {str(e)}")
+            raise
+    
+    @handle_calendar_error
+    def generate_brief(
+        self,
+        content_item: ContentItem,
+        target_audience: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Generate a comprehensive content brief.
+        
+        Args:
+            content_item: Content item to generate brief for
+            target_audience: Optional target audience data
+            
+        Returns:
+            Dictionary containing the content brief
+        """
+        try:
+            logger.info(f"Generating content brief for: {content_item.title}")
+            
+            # Generate content outline
+            outline = self._generate_outline(content_item)
+            
+            # Generate key points
+            key_points = self.ai_generator.generate_key_points(
+                title=content_item.title,
+                content_type=content_item.content_type,
+                context=content_item.context
+            )
+            
+            # Generate content flow
+            content_flow = self.ai_generator.generate_content_flow(
+                title=content_item.title,
+                content_type=content_item.content_type,
+                outline=outline
+            )
+            
+            # Compile the brief
+            brief = {
+                'title': content_item.title,
+                'content_type': content_item.content_type.value,
+                'outline': outline,
+                'key_points': key_points,
+                'content_flow': content_flow,
+                'target_audience': target_audience or {},
+                'seo_data': content_item.seo_data,
+                'platform_specs': content_item.platform_specs
+            }
+            
+            logger.info("Content brief generated successfully")
+            return brief
+            
+        except Exception as e:
+            logger.error(f"Error generating content brief: {str(e)}")
+            raise
+    
+    def _generate_outline(
+        self,
+        content_item: ContentItem
+    ) -> Dict[str, Any]:
+        """
+        Generate content outline with headings and subheadings.
+        
+        Args:
+            content_item: Content item to generate outline for
+            
+        Returns:
+            Dictionary containing the content outline
+        """
+        try:
+            # Generate main headings
+            main_headings = self.ai_generator.generate_headings(
+                title=content_item.title,
+                content_type=content_item.content_type,
+                context=content_item.context
+            )
+            
+            # Generate subheadings for each main heading
+            subheadings = {}
+            for heading in main_headings:
+                heading_subheadings = self.ai_generator.generate_subheadings(
+                    main_heading=heading,
+                    content_type=content_item.content_type,
+                    context=content_item.context
+                )
+                subheadings[heading['title']] = heading_subheadings
+            
+            return {
+                'main_headings': main_headings,
+                'subheadings': subheadings
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating outline: {str(e)}")
+            return {
+                'main_headings': [],
+                'subheadings': {}
+            } 

lib/content_calendar/core/content_generator.py

@@ -0,0 +1,626 @@
+from typing import Dict, List, Any, Optional
+import logging
+from pathlib import Path
+import sys
+from datetime import datetime, timedelta
+
+# Add parent directory to path to import existing tools
+parent_dir = str(Path(__file__).parent.parent.parent.parent)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+from lib.database.models import ContentItem, ContentType, Platform
+from ..utils.error_handling import handle_calendar_error
+from lib.ai_seo_tools.content_gap_analysis.main import ContentGapAnalysis
+from lib.ai_seo_tools.content_title_generator import ai_title_generator
+from lib.ai_seo_tools.meta_desc_generator import metadesc_generator_main
+from lib.ai_seo_tools.content_calendar.core.content_repurposer import SmartContentRepurposingEngine
+
+logger = logging.getLogger(__name__)
+
+class ContentGenerator:
+    """
+    Enhanced content generator with smart repurposing capabilities.
+    """
+    
+    def __init__(self):
+        self.logger = logging.getLogger('content_calendar.content_generator')
+        self.logger.info("Initializing ContentGenerator")
+        self._setup_logging()
+        self._load_ai_tools()
+        # Initialize the Smart Content Repurposing Engine
+        self.repurposing_engine = SmartContentRepurposingEngine()
+    
+    def _setup_logging(self):
+        """Configure logging for content generator."""
+        logger.setLevel(logging.INFO)
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    
+    def _load_ai_tools(self):
+        """Load and initialize AI tools."""
+        try:
+            # Initialize AI tools
+            self.gap_analyzer = ContentGapAnalysis()
+            self.title_generator = ai_title_generator
+            self.meta_generator = metadesc_generator_main
+            
+        except Exception as e:
+            logger.error(f"Error loading AI tools: {str(e)}")
+            raise
+    
+    @handle_calendar_error
+    def generate_headings(
+        self,
+        content_item: ContentItem,
+        context: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """
+        Generate main headings for content.
+        
+        Args:
+            content_item: Content item to generate headings for
+            context: Content context from gap analysis
+            
+        Returns:
+            List of main headings with metadata
+        """
+        try:
+            # Use AI to generate headings based on content type and context
+            headings = self._generate_ai_headings(
+                title=content_item.title,
+                content_type=content_item.content_type,
+                context=context
+            )
+            
+            # Format and validate headings
+            formatted_headings = []
+            for heading in headings:
+                formatted_heading = {
+                    'title': heading['title'],
+                    'level': heading.get('level', 1),
+                    'keywords': heading.get('keywords', []),
+                    'summary': heading.get('summary', '')
+                }
+                formatted_headings.append(formatted_heading)
+            
+            return formatted_headings
+            
+        except Exception as e:
+            logger.error(f"Error generating headings: {str(e)}")
+            return []
+    
+    @handle_calendar_error
+    def generate_subheadings(
+        self,
+        content_item: ContentItem,
+        main_headings: List[Dict[str, Any]],
+        context: Dict[str, Any]
+    ) -> Dict[str, List[Dict[str, Any]]]:
+        """
+        Generate subheadings for each main heading.
+        
+        Args:
+            content_item: Content item to generate subheadings for
+            main_headings: List of main headings
+            context: Content context from gap analysis
+            
+        Returns:
+            Dictionary mapping main headings to their subheadings
+        """
+        try:
+            subheadings = {}
+            
+            for heading in main_headings:
+                # Generate subheadings for each main heading
+                heading_subheadings = self._generate_ai_subheadings(
+                    main_heading=heading,
+                    content_type=content_item.content_type,
+                    context=context
+                )
+                
+                # Format and validate subheadings
+                formatted_subheadings = []
+                for subheading in heading_subheadings:
+                    formatted_subheading = {
+                        'title': subheading['title'],
+                        'level': subheading.get('level', 2),
+                        'keywords': subheading.get('keywords', []),
+                        'summary': subheading.get('summary', '')
+                    }
+                    formatted_subheadings.append(formatted_subheading)
+                
+                subheadings[heading['title']] = formatted_subheadings
+            
+            return subheadings
+            
+        except Exception as e:
+            logger.error(f"Error generating subheadings: {str(e)}")
+            return {}
+    
+    @handle_calendar_error
+    def generate_key_points(
+        self,
+        content_item: ContentItem,
+        context: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """
+        Generate key points for the content.
+        
+        Args:
+            content_item: Content item to generate key points for
+            context: Content context from gap analysis
+            
+        Returns:
+            List of key points with supporting information
+        """
+        try:
+            # Generate key points using AI
+            key_points = self._generate_ai_key_points(
+                title=content_item.title,
+                content_type=content_item.content_type,
+                context=context
+            )
+            
+            # Format and validate key points
+            formatted_points = []
+            for point in key_points:
+                formatted_point = {
+                    'point': point['point'],
+                    'importance': point.get('importance', 'medium'),
+                    'supporting_evidence': point.get('evidence', []),
+                    'related_keywords': point.get('keywords', [])
+                }
+                formatted_points.append(formatted_point)
+            
+            return formatted_points
+            
+        except Exception as e:
+            logger.error(f"Error generating key points: {str(e)}")
+            return []
+    
+    @handle_calendar_error
+    def generate_content_flow(
+        self,
+        content_item: ContentItem,
+        outline: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Generate content flow and structure.
+        
+        Args:
+            content_item: Content item to generate flow for
+            outline: Content outline with headings and key points
+            
+        Returns:
+            Dictionary containing content flow and structure
+        """
+        try:
+            # Generate content flow using AI
+            flow = self._generate_ai_content_flow(
+                title=content_item.title,
+                content_type=content_item.content_type,
+                outline=outline
+            )
+            
+            return {
+                'introduction': flow.get('introduction', {}),
+                'main_sections': flow.get('main_sections', []),
+                'conclusion': flow.get('conclusion', {}),
+                'transitions': flow.get('transitions', []),
+                'content_pacing': flow.get('pacing', {})
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating content flow: {str(e)}")
+            return {}
+    
+    def _generate_ai_headings(
+        self,
+        title: str,
+        content_type: ContentType,
+        context: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """
+        Use AI to generate content headings.
+        """
+        # TODO: Implement AI heading generation
+        # This would use the existing AI tools to generate headings
+        return []
+    
+    def _generate_ai_subheadings(
+        self,
+        main_heading: Dict[str, Any],
+        content_type: ContentType,
+        context: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """
+        Use AI to generate subheadings.
+        """
+        # TODO: Implement AI subheading generation
+        return []
+    
+    def _generate_ai_key_points(
+        self,
+        title: str,
+        content_type: ContentType,
+        context: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """
+        Use AI to generate key points.
+        """
+        # TODO: Implement AI key point generation
+        return []
+    
+    def _generate_ai_content_flow(
+        self,
+        title: str,
+        content_type: ContentType,
+        outline: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Use AI to generate content flow.
+        """
+        # TODO: Implement AI content flow generation
+        return {}
+    
+    def generate_variation(self, content: Dict[str, Any], variation_type: str) -> Dict[str, Any]:
+        """Generate a variation of the given content.
+        
+        Args:
+            content: Original content to vary
+            variation_type: Type of variation to generate ('tone', 'length', 'style', etc.)
+            
+        Returns:
+            Dictionary containing the varied content
+        """
+        try:
+            self.logger.info(f"Generating {variation_type} variation for content")
+            
+            # Generate variation based on type
+            variation = {
+                'title': f"{content.get('title', '')} - {variation_type.title()} Variation",
+                'content_flow': {
+                    'introduction': {
+                        'summary': f"Varied introduction for {content.get('title', '')}",
+                        'key_points': [
+                            f"Varied key point 1 for {variation_type}",
+                            f"Varied key point 2 for {variation_type}",
+                            f"Varied key point 3 for {variation_type}"
+                        ]
+                    },
+                    'main_content': {
+                        'sections': [
+                            {
+                                'title': f"Varied Section 1: {variation_type.title()} Approach",
+                                'content': f"Varied content for {variation_type}",
+                                'subsections': []
+                            },
+                            {
+                                'title': f"Varied Section 2: {variation_type.title()} Details",
+                                'content': "Varied details and information",
+                                'subsections': []
+                            }
+                        ]
+                    },
+                    'conclusion': {
+                        'summary': f"Varied conclusion for {variation_type}",
+                        'call_to_action': "Varied call to action"
+                    }
+                },
+                'metadata': {
+                    'variation_type': variation_type,
+                    'original_content': content.get('title', ''),
+                    'platform': content.get('metadata', {}).get('platform', 'Unknown'),
+                    'content_type': content.get('metadata', {}).get('content_type', 'Unknown')
+                }
+            }
+            
+            return variation
+            
+        except Exception as e:
+            self.logger.error(f"Error generating variation: {str(e)}")
+            return {}
+    
+    @handle_calendar_error
+    def repurpose_content_for_platforms(
+        self,
+        content_item: ContentItem,
+        target_platforms: List[Platform],
+        strategy: str = 'adaptive'
+    ) -> List[ContentItem]:
+        """
+        Repurpose existing content for multiple platforms using the Smart Content Repurposing Engine.
+        
+        Args:
+            content_item: Original content to repurpose
+            target_platforms: List of platforms to create content for
+            strategy: Repurposing strategy ('adaptive', 'atomic', 'series')
+            
+        Returns:
+            List of repurposed content items optimized for each platform
+        """
+        try:
+            self.logger.info(f"Repurposing content '{content_item.title}' for {len(target_platforms)} platforms")
+            
+            # Use the repurposing engine to create platform-specific content
+            repurposed_content = self.repurposing_engine.repurpose_single_content(
+                content=content_item,
+                target_platforms=target_platforms,
+                strategy=strategy
+            )
+            
+            self.logger.info(f"Successfully created {len(repurposed_content)} repurposed content pieces")
+            return repurposed_content
+            
+        except Exception as e:
+            self.logger.error(f"Error repurposing content: {str(e)}")
+            return []
+    
+    @handle_calendar_error
+    def create_content_series_across_platforms(
+        self,
+        source_content: ContentItem,
+        platforms: List[Platform],
+        series_type: str = 'progressive_disclosure'
+    ) -> Dict[str, List[ContentItem]]:
+        """
+        Create a cross-platform content series with progressive disclosure strategy.
+        
+        Args:
+            source_content: Original comprehensive content
+            platforms: Target platforms for the series
+            series_type: Type of series ('progressive_disclosure', 'platform_native')
+            
+        Returns:
+            Dictionary mapping platforms to their content pieces
+        """
+        try:
+            self.logger.info(f"Creating cross-platform series for '{source_content.title}'")
+            
+            # Use the repurposing engine to create a content series
+            series_content = self.repurposing_engine.create_content_series(
+                content=source_content,
+                platforms=platforms,
+                series_type=series_type
+            )
+            
+            total_pieces = sum(len(pieces) for pieces in series_content.values())
+            self.logger.info(f"Successfully created series with {total_pieces} pieces across {len(series_content)} platforms")
+            
+            return series_content
+            
+        except Exception as e:
+            self.logger.error(f"Error creating content series: {str(e)}")
+            return {}
+    
+    @handle_calendar_error
+    def analyze_content_for_repurposing(
+        self,
+        content_item: ContentItem,
+        available_platforms: List[Platform]
+    ) -> Dict[str, Any]:
+        """
+        Analyze content and get AI-powered repurposing suggestions.
+        
+        Args:
+            content_item: Content to analyze
+            available_platforms: Available platforms for repurposing
+            
+        Returns:
+            Dictionary containing repurposing suggestions and analysis
+        """
+        try:
+            self.logger.info(f"Analyzing content '{content_item.title}' for repurposing opportunities")
+            
+            # Get repurposing suggestions from the engine
+            suggestions = self.repurposing_engine.get_repurposing_suggestions(
+                content=content_item,
+                available_platforms=available_platforms
+            )
+            
+            # Add content analysis
+            content_text = content_item.description or content_item.notes or ""
+            content_atoms = self.repurposing_engine.analyze_content_atoms(
+                content=content_text,
+                title=content_item.title
+            )
+            
+            analysis = {
+                'content_analysis': {
+                    'word_count': len(content_text.split()) if content_text else 0,
+                    'content_richness': self._assess_content_richness(content_atoms),
+                    'repurposing_potential': self._assess_repurposing_potential(content_atoms),
+                    'content_atoms': content_atoms
+                },
+                'platform_suggestions': suggestions['recommended_platforms'],
+                'strategy_suggestions': suggestions['repurposing_strategies'],
+                'estimated_output': {
+                    'total_pieces': suggestions['estimated_pieces'],
+                    'time_savings': f"{suggestions['estimated_pieces'] * 2} hours",
+                    'content_multiplication': f"{suggestions['estimated_pieces']}x"
+                }
+            }
+            
+            return analysis
+            
+        except Exception as e:
+            self.logger.error(f"Error analyzing content for repurposing: {str(e)}")
+            return {}
+    
+    def _assess_content_richness(self, content_atoms: Dict[str, List[str]]) -> str:
+        """Assess the richness of content based on extracted atoms."""
+        total_atoms = sum(len(atoms) for atoms in content_atoms.values())
+        
+        if total_atoms >= 15:
+            return "High"
+        elif total_atoms >= 8:
+            return "Medium"
+        else:
+            return "Low"
+    
+    def _assess_repurposing_potential(self, content_atoms: Dict[str, List[str]]) -> str:
+        """Assess the repurposing potential based on content atoms."""
+        # Check for diverse content types
+        atom_types_with_content = sum(1 for atoms in content_atoms.values() if atoms)
+        
+        if atom_types_with_content >= 4:
+            return "Excellent"
+        elif atom_types_with_content >= 3:
+            return "Good"
+        elif atom_types_with_content >= 2:
+            return "Fair"
+        else:
+            return "Limited"
+    
+    @handle_calendar_error
+    def generate_content_with_repurposing_plan(
+        self,
+        content_item: ContentItem,
+        context: Dict[str, Any],
+        target_platforms: List[Platform] = None
+    ) -> Dict[str, Any]:
+        """
+        Generate content along with a comprehensive repurposing plan.
+        
+        Args:
+            content_item: Content item to generate
+            context: Content context from gap analysis
+            target_platforms: Platforms to include in repurposing plan
+            
+        Returns:
+            Dictionary containing generated content and repurposing plan
+        """
+        try:
+            self.logger.info(f"Generating content with repurposing plan for '{content_item.title}'")
+            
+            # Generate the main content structure
+            headings = self.generate_headings(content_item, context)
+            subheadings = self.generate_subheadings(content_item, headings, context)
+            key_points = self.generate_key_points(content_item, context)
+            
+            outline = {
+                'headings': headings,
+                'subheadings': subheadings,
+                'key_points': key_points
+            }
+            
+            content_flow = self.generate_content_flow(content_item, outline)
+            
+            # Create repurposing plan if platforms are specified
+            repurposing_plan = {}
+            if target_platforms:
+                # Analyze repurposing potential
+                analysis = self.analyze_content_for_repurposing(content_item, target_platforms)
+                
+                # Generate repurposing suggestions
+                repurposing_plan = {
+                    'analysis': analysis,
+                    'recommended_strategy': self._recommend_repurposing_strategy(analysis),
+                    'platform_roadmap': self._create_platform_roadmap(content_item, target_platforms),
+                    'content_calendar_integration': self._suggest_calendar_integration(content_item, target_platforms)
+                }
+            
+            return {
+                'content': {
+                    'outline': outline,
+                    'content_flow': content_flow,
+                    'metadata': {
+                        'generated_at': str(datetime.now()),
+                        'content_type': content_item.content_type.name,
+                        'platforms': [p.name for p in content_item.platforms] if content_item.platforms else []
+                    }
+                },
+                'repurposing_plan': repurposing_plan
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Error generating content with repurposing plan: {str(e)}")
+            return {}
+    
+    def _recommend_repurposing_strategy(self, analysis: Dict[str, Any]) -> str:
+        """Recommend the best repurposing strategy based on content analysis."""
+        content_richness = analysis.get('content_analysis', {}).get('content_richness', 'Low')
+        repurposing_potential = analysis.get('content_analysis', {}).get('repurposing_potential', 'Limited')
+        
+        if content_richness == 'High' and repurposing_potential in ['Excellent', 'Good']:
+            return 'progressive_disclosure'
+        elif content_richness in ['Medium', 'High']:
+            return 'adaptive'
+        else:
+            return 'atomic'
+    
+    def _create_platform_roadmap(
+        self,
+        content_item: ContentItem,
+        target_platforms: List[Platform]
+    ) -> Dict[str, Any]:
+        """Create a roadmap for content distribution across platforms."""
+        roadmap = {
+            'timeline': {},
+            'platform_sequence': [],
+            'cross_promotion_opportunities': []
+        }
+        
+        # Create a timeline for content release
+        base_date = content_item.publish_date or datetime.now()
+        
+        for i, platform in enumerate(target_platforms):
+            release_date = base_date + timedelta(days=i)
+            roadmap['timeline'][platform.name] = {
+                'release_date': release_date.strftime('%Y-%m-%d'),
+                'content_type': self._get_optimal_content_type_for_platform(platform),
+                'engagement_strategy': self._get_engagement_strategy_for_platform(platform)
+            }
+            roadmap['platform_sequence'].append(platform.name)
+        
+        return roadmap
+    
+    def _suggest_calendar_integration(
+        self,
+        content_item: ContentItem,
+        target_platforms: List[Platform]
+    ) -> Dict[str, Any]:
+        """Suggest how to integrate repurposed content into the content calendar."""
+        return {
+            'scheduling_recommendations': {
+                'primary_content': 'Schedule as main content piece',
+                'repurposed_content': 'Schedule 1-2 days after primary content',
+                'series_content': 'Schedule weekly releases for maximum impact'
+            },
+            'calendar_tags': [
+                'repurposed_content',
+                f'source_{content_item.id}',
+                'multi_platform_series'
+            ],
+            'performance_tracking': {
+                'metrics_to_track': ['engagement_rate', 'cross_platform_traffic', 'conversion_rate'],
+                'comparison_baseline': 'Compare against single-platform content performance'
+            }
+        }
+    
+    def _get_optimal_content_type_for_platform(self, platform: Platform) -> str:
+        """Get the optimal content type for a specific platform."""
+        platform_content_types = {
+            Platform.TWITTER: 'Thread or single tweet',
+            Platform.LINKEDIN: 'Professional post or article',
+            Platform.INSTAGRAM: 'Visual post with caption',
+            Platform.FACEBOOK: 'Engaging post with discussion starter',
+            Platform.WEBSITE: 'Full blog post or article'
+        }
+        return platform_content_types.get(platform, 'Standard post')
+    
+    def _get_engagement_strategy_for_platform(self, platform: Platform) -> str:
+        """Get the engagement strategy for a specific platform."""
+        engagement_strategies = {
+            Platform.TWITTER: 'Use hashtags, engage in conversations, create polls',
+            Platform.LINKEDIN: 'Professional networking, thought leadership, industry discussions',
+            Platform.INSTAGRAM: 'Visual storytelling, user-generated content, stories',
+            Platform.FACEBOOK: 'Community building, discussions, live interactions',
+            Platform.WEBSITE: 'SEO optimization, internal linking, lead magnets'
+        }
+        return engagement_strategies.get(platform, 'Standard engagement tactics') 

lib/content_calendar/core/content_repurposer.py

@@ -0,0 +1,599 @@
+from typing import Dict, List, Any, Optional, Tuple
+import logging
+import re
+from datetime import datetime, timedelta
+from pathlib import Path
+import sys
+import json
+
+# Add parent directory to path to import existing tools
+parent_dir = str(Path(__file__).parent.parent.parent.parent)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+from lib.database.models import ContentItem, ContentType, Platform, SEOData
+from lib.gpt_providers.text_generation.main_text_generation import llm_text_gen
+from ..utils.error_handling import handle_calendar_error
+
+logger = logging.getLogger(__name__)
+
+class ContentAtomizer:
+    """
+    Break down content into atomic pieces that can be recombined
+    for different platforms and purposes.
+    """
+    
+    def __init__(self):
+        self.logger = logging.getLogger('content_calendar.atomizer')
+        
+    def atomize_content(self, content: str, title: str = "") -> Dict[str, List[str]]:
+        """
+        Extract key quotes, statistics, tips, and examples from content.
+        
+        Args:
+            content: The content text to atomize
+            title: The content title for context
+            
+        Returns:
+            Dictionary containing different types of content atoms
+        """
+        try:
+            self.logger.info(f"Atomizing content: {title[:50]}...")
+            
+            # Use AI to extract content atoms
+            prompt = f"""
+            Analyze the following content and extract key elements that can be repurposed:
+
+            Title: {title}
+            Content: {content[:3000]}...
+
+            Extract and categorize the following elements:
+            1. Key Statistics (numbers, percentages, data points)
+            2. Quotable Insights (memorable quotes or key insights)
+            3. Actionable Tips (practical advice or steps)
+            4. Examples/Case Studies (real examples or stories)
+            5. Key Questions (thought-provoking questions)
+            6. Main Arguments (core points or arguments)
+
+            Format your response as JSON:
+            {{
+                "statistics": ["stat1", "stat2", ...],
+                "quotes": ["quote1", "quote2", ...],
+                "tips": ["tip1", "tip2", ...],
+                "examples": ["example1", "example2", ...],
+                "questions": ["question1", "question2", ...],
+                "arguments": ["argument1", "argument2", ...]
+            }}
+            """
+            
+            response = llm_text_gen(
+                prompt=prompt,
+                system_prompt="You are an expert content analyst. Extract key elements that can be repurposed across different platforms.",
+                json_struct={
+                    "type": "object",
+                    "properties": {
+                        "statistics": {"type": "array", "items": {"type": "string"}},
+                        "quotes": {"type": "array", "items": {"type": "string"}},
+                        "tips": {"type": "array", "items": {"type": "string"}},
+                        "examples": {"type": "array", "items": {"type": "string"}},
+                        "questions": {"type": "array", "items": {"type": "string"}},
+                        "arguments": {"type": "array", "items": {"type": "string"}}
+                    }
+                }
+            )
+            
+            if response:
+                return response
+            else:
+                # Fallback to basic extraction
+                return self._basic_content_extraction(content)
+                
+        except Exception as e:
+            self.logger.error(f"Error atomizing content: {str(e)}")
+            return self._basic_content_extraction(content)
+    
+    def _basic_content_extraction(self, content: str) -> Dict[str, List[str]]:
+        """Fallback method for basic content extraction."""
+        atoms = {
+            "statistics": [],
+            "quotes": [],
+            "tips": [],
+            "examples": [],
+            "questions": [],
+            "arguments": []
+        }
+        
+        # Extract statistics (numbers with %)
+        stats = re.findall(r'\d+%|\d+\.\d+%|\d+,\d+|\d+ percent', content)
+        atoms["statistics"] = stats[:5]  # Limit to 5
+        
+        # Extract questions
+        questions = re.findall(r'[A-Z][^.!?]*\?', content)
+        atoms["questions"] = questions[:3]  # Limit to 3
+        
+        # Extract sentences that might be tips (containing words like "should", "must", "need to")
+        tip_patterns = r'[^.!?]*(?:should|must|need to|important to|remember to)[^.!?]*[.!?]'
+        tips = re.findall(tip_patterns, content, re.IGNORECASE)
+        atoms["tips"] = tips[:5]  # Limit to 5
+        
+        return atoms
+
+class ContentRepurposer:
+    """
+    Main content repurposing engine that transforms content for different platforms.
+    """
+    
+    def __init__(self):
+        self.logger = logging.getLogger('content_calendar.repurposer')
+        self.atomizer = ContentAtomizer()
+        
+        # Platform-specific content specifications
+        self.platform_specs = {
+            Platform.TWITTER: {
+                'max_length': 280,
+                'optimal_length': 240,
+                'format': 'concise',
+                'tone': 'engaging',
+                'hashtags': True,
+                'mentions': True
+            },
+            Platform.LINKEDIN: {
+                'max_length': 3000,
+                'optimal_length': 1500,
+                'format': 'professional',
+                'tone': 'authoritative',
+                'hashtags': True,
+                'mentions': False
+            },
+            Platform.INSTAGRAM: {
+                'max_length': 2200,
+                'optimal_length': 1000,
+                'format': 'visual-focused',
+                'tone': 'casual',
+                'hashtags': True,
+                'mentions': True
+            },
+            Platform.FACEBOOK: {
+                'max_length': 63206,
+                'optimal_length': 500,
+                'format': 'engaging',
+                'tone': 'conversational',
+                'hashtags': False,
+                'mentions': True
+            },
+            Platform.WEBSITE: {
+                'max_length': None,
+                'optimal_length': 2000,
+                'format': 'comprehensive',
+                'tone': 'informative',
+                'hashtags': False,
+                'mentions': False
+            }
+        }
+    
+    @handle_calendar_error
+    def repurpose_content(
+        self,
+        source_content: ContentItem,
+        target_platforms: List[Platform],
+        repurpose_strategy: str = 'adaptive'
+    ) -> List[ContentItem]:
+        """
+        Repurpose content for multiple platforms.
+        
+        Args:
+            source_content: Original content to repurpose
+            target_platforms: List of platforms to create content for
+            repurpose_strategy: Strategy for repurposing ('adaptive', 'atomic', 'series')
+            
+        Returns:
+            List of repurposed content items
+        """
+        try:
+            self.logger.info(f"Repurposing content '{source_content.title}' for {len(target_platforms)} platforms")
+            
+            repurposed_content = []
+            
+            # Get content text (assuming it's in description or notes)
+            content_text = source_content.description or source_content.notes or ""
+            
+            if not content_text:
+                self.logger.warning("No content text found for repurposing")
+                return []
+            
+            # Atomize the content
+            atoms = self.atomizer.atomize_content(content_text, source_content.title)
+            
+            # Generate repurposed content for each platform
+            for platform in target_platforms:
+                if platform == source_content.platforms[0] if source_content.platforms else None:
+                    continue  # Skip the original platform
+                
+                repurposed_item = self._create_platform_specific_content(
+                    source_content=source_content,
+                    target_platform=platform,
+                    atoms=atoms,
+                    strategy=repurpose_strategy
+                )
+                
+                if repurposed_item:
+                    repurposed_content.append(repurposed_item)
+            
+            self.logger.info(f"Successfully repurposed content into {len(repurposed_content)} variations")
+            return repurposed_content
+            
+        except Exception as e:
+            self.logger.error(f"Error repurposing content: {str(e)}")
+            return []
+    
+    def _create_platform_specific_content(
+        self,
+        source_content: ContentItem,
+        target_platform: Platform,
+        atoms: Dict[str, List[str]],
+        strategy: str
+    ) -> Optional[ContentItem]:
+        """Create platform-specific content variation."""
+        try:
+            platform_spec = self.platform_specs.get(target_platform, {})
+            
+            # Generate platform-specific content using AI
+            repurposed_text = self._generate_platform_content(
+                source_content=source_content,
+                target_platform=target_platform,
+                atoms=atoms,
+                platform_spec=platform_spec,
+                strategy=strategy
+            )
+            
+            if not repurposed_text:
+                return None
+            
+            # Create new content item
+            repurposed_item = ContentItem(
+                title=self._adapt_title_for_platform(source_content.title, target_platform),
+                description=repurposed_text,
+                content_type=self._determine_content_type_for_platform(target_platform),
+                platforms=[target_platform],
+                publish_date=source_content.publish_date + timedelta(days=1),  # Schedule for next day
+                status="draft",
+                author=source_content.author,
+                tags=source_content.tags + [f"repurposed_from_{source_content.id}"],
+                notes=f"Repurposed from: {source_content.title}",
+                seo_data=self._adapt_seo_data_for_platform(source_content.seo_data, target_platform)
+            )
+            
+            return repurposed_item
+            
+        except Exception as e:
+            self.logger.error(f"Error creating platform-specific content: {str(e)}")
+            return None
+    
+    def _generate_platform_content(
+        self,
+        source_content: ContentItem,
+        target_platform: Platform,
+        atoms: Dict[str, List[str]],
+        platform_spec: Dict[str, Any],
+        strategy: str
+    ) -> str:
+        """Generate content optimized for specific platform."""
+        try:
+            # Prepare content elements
+            title = source_content.title
+            original_content = source_content.description or ""
+            
+            # Create platform-specific prompt
+            prompt = self._create_repurposing_prompt(
+                title=title,
+                original_content=original_content,
+                target_platform=target_platform,
+                atoms=atoms,
+                platform_spec=platform_spec,
+                strategy=strategy
+            )
+            
+            # Generate content using AI
+            repurposed_content = llm_text_gen(prompt)
+            
+            return repurposed_content or ""
+            
+        except Exception as e:
+            self.logger.error(f"Error generating platform content: {str(e)}")
+            return ""
+    
+    def _create_repurposing_prompt(
+        self,
+        title: str,
+        original_content: str,
+        target_platform: Platform,
+        atoms: Dict[str, List[str]],
+        platform_spec: Dict[str, Any],
+        strategy: str
+    ) -> str:
+        """Create AI prompt for content repurposing."""
+        
+        platform_guidelines = {
+            Platform.TWITTER: "Create engaging tweets that drive conversation. Use threads for complex topics. Include relevant hashtags.",
+            Platform.LINKEDIN: "Write professional content that provides value to business professionals. Focus on insights and actionable advice.",
+            Platform.INSTAGRAM: "Create visually-oriented content with engaging captions. Use storytelling and include relevant hashtags.",
+            Platform.FACEBOOK: "Write conversational content that encourages engagement. Ask questions and create community discussion.",
+            Platform.WEBSITE: "Create comprehensive, SEO-optimized content with clear structure and valuable information."
+        }
+        
+        atoms_text = ""
+        for atom_type, atom_list in atoms.items():
+            if atom_list:
+                atoms_text += f"\n{atom_type.title()}: {', '.join(atom_list[:3])}"
+        
+        prompt = f"""
+        Repurpose the following content for {target_platform.name}:
+
+        Original Title: {title}
+        Original Content: {original_content[:1500]}...
+
+        Key Content Elements:{atoms_text}
+
+        Platform Guidelines: {platform_guidelines.get(target_platform, '')}
+
+        Platform Specifications:
+        - Optimal Length: {platform_spec.get('optimal_length', 'flexible')} characters
+        - Format: {platform_spec.get('format', 'standard')}
+        - Tone: {platform_spec.get('tone', 'professional')}
+        - Include Hashtags: {platform_spec.get('hashtags', False)}
+
+        Requirements:
+        1. Adapt the content to fit {target_platform.name}'s format and audience
+        2. Maintain the core message and value
+        3. Optimize for {target_platform.name} engagement
+        4. Include platform-appropriate calls to action
+        5. Use the extracted content elements effectively
+
+        Create compelling, platform-optimized content that will perform well on {target_platform.name}.
+        """
+        
+        return prompt
+    
+    def _adapt_title_for_platform(self, original_title: str, platform: Platform) -> str:
+        """Adapt title for specific platform."""
+        platform_prefixes = {
+            Platform.TWITTER: "🧵 ",
+            Platform.LINKEDIN: "💼 ",
+            Platform.INSTAGRAM: "📸 ",
+            Platform.FACEBOOK: "💬 ",
+            Platform.WEBSITE: ""
+        }
+        
+        prefix = platform_prefixes.get(platform, "")
+        return f"{prefix}{original_title}"
+    
+    def _determine_content_type_for_platform(self, platform: Platform) -> ContentType:
+        """Determine appropriate content type for platform."""
+        platform_content_types = {
+            Platform.TWITTER: ContentType.SOCIAL_MEDIA,
+            Platform.LINKEDIN: ContentType.SOCIAL_MEDIA,
+            Platform.INSTAGRAM: ContentType.SOCIAL_MEDIA,
+            Platform.FACEBOOK: ContentType.SOCIAL_MEDIA,
+            Platform.WEBSITE: ContentType.BLOG_POST
+        }
+        
+        return platform_content_types.get(platform, ContentType.SOCIAL_MEDIA)
+    
+    def _adapt_seo_data_for_platform(self, original_seo: SEOData, platform: Platform) -> SEOData:
+        """Adapt SEO data for specific platform."""
+        if platform == Platform.WEBSITE:
+            return original_seo
+        
+        # For social media platforms, create simplified SEO data
+        return SEOData(
+            title=original_seo.title,
+            meta_description=original_seo.meta_description[:160] if original_seo.meta_description else "",
+            keywords=original_seo.keywords[:5] if original_seo.keywords else [],
+            structured_data={}
+        )
+
+class ContentSeriesRepurposer:
+    """
+    Create cross-platform content series with progressive disclosure strategy.
+    """
+    
+    def __init__(self):
+        self.logger = logging.getLogger('content_calendar.series_repurposer')
+        self.repurposer = ContentRepurposer()
+    
+    def create_cross_platform_series(
+        self,
+        source_content: ContentItem,
+        platforms: List[Platform],
+        series_strategy: str = 'progressive_disclosure'
+    ) -> Dict[str, List[ContentItem]]:
+        """
+        Create a content series that progressively reveals information
+        across different platforms, driving traffic between them.
+        
+        Args:
+            source_content: Original comprehensive content
+            platforms: Target platforms for the series
+            series_strategy: Strategy for content distribution
+            
+        Returns:
+            Dictionary mapping platforms to their content pieces
+        """
+        try:
+            self.logger.info(f"Creating cross-platform series for: {source_content.title}")
+            
+            series_content = {}
+            
+            if series_strategy == 'progressive_disclosure':
+                series_content = self._create_progressive_disclosure_series(
+                    source_content, platforms
+                )
+            elif series_strategy == 'platform_native':
+                series_content = self._create_platform_native_series(
+                    source_content, platforms
+                )
+            else:
+                # Default to simple repurposing
+                repurposed = self.repurposer.repurpose_content(
+                    source_content, platforms
+                )
+                for item in repurposed:
+                    platform = item.platforms[0]
+                    if platform not in series_content:
+                        series_content[platform] = []
+                    series_content[platform].append(item)
+            
+            return series_content
+            
+        except Exception as e:
+            self.logger.error(f"Error creating cross-platform series: {str(e)}")
+            return {}
+    
+    def _create_progressive_disclosure_series(
+        self,
+        source_content: ContentItem,
+        platforms: List[Platform]
+    ) -> Dict[str, List[ContentItem]]:
+        """Create series with progressive information disclosure."""
+        series_content = {}
+        
+        # Define disclosure strategy
+        disclosure_strategy = {
+            Platform.TWITTER: "teaser",      # Hook with key stat/question
+            Platform.INSTAGRAM: "visual",    # Visual summary with key points
+            Platform.LINKEDIN: "insight",    # Professional insight/analysis
+            Platform.FACEBOOK: "discussion", # Community discussion starter
+            Platform.WEBSITE: "complete"     # Full detailed content
+        }
+        
+        for platform in platforms:
+            strategy = disclosure_strategy.get(platform, "summary")
+            content_piece = self._create_disclosure_content(
+                source_content, platform, strategy
+            )
+            if content_piece:
+                series_content[platform] = [content_piece]
+        
+        return series_content
+    
+    def _create_disclosure_content(
+        self,
+        source_content: ContentItem,
+        platform: Platform,
+        disclosure_type: str
+    ) -> Optional[ContentItem]:
+        """Create content piece for specific disclosure strategy."""
+        try:
+            # This would use the repurposer with specific instructions
+            # for the disclosure type
+            repurposed = self.repurposer._create_platform_specific_content(
+                source_content=source_content,
+                target_platform=platform,
+                atoms=self.repurposer.atomizer.atomize_content(
+                    source_content.description or "", 
+                    source_content.title
+                ),
+                strategy=disclosure_type
+            )
+            
+            return repurposed
+            
+        except Exception as e:
+            self.logger.error(f"Error creating disclosure content: {str(e)}")
+            return None
+    
+    def _create_platform_native_series(
+        self,
+        source_content: ContentItem,
+        platforms: List[Platform]
+    ) -> Dict[str, List[ContentItem]]:
+        """Create series optimized for each platform's native format."""
+        # Implementation for platform-native series
+        # This would create multiple pieces per platform
+        # optimized for that platform's specific characteristics
+        return {}
+
+# Main repurposing interface
+class SmartContentRepurposingEngine:
+    """
+    Main interface for the Smart Content Repurposing Engine.
+    """
+    
+    def __init__(self):
+        self.logger = logging.getLogger('content_calendar.repurposing_engine')
+        self.repurposer = ContentRepurposer()
+        self.series_repurposer = ContentSeriesRepurposer()
+        self.atomizer = ContentAtomizer()
+    
+    def repurpose_single_content(
+        self,
+        content: ContentItem,
+        target_platforms: List[Platform],
+        strategy: str = 'adaptive'
+    ) -> List[ContentItem]:
+        """Repurpose a single piece of content."""
+        return self.repurposer.repurpose_content(content, target_platforms, strategy)
+    
+    def create_content_series(
+        self,
+        content: ContentItem,
+        platforms: List[Platform],
+        series_type: str = 'progressive_disclosure'
+    ) -> Dict[str, List[ContentItem]]:
+        """Create a cross-platform content series."""
+        return self.series_repurposer.create_cross_platform_series(
+            content, platforms, series_type
+        )
+    
+    def analyze_content_atoms(self, content: str, title: str = "") -> Dict[str, List[str]]:
+        """Analyze content and extract reusable atoms."""
+        return self.atomizer.atomize_content(content, title)
+    
+    def get_repurposing_suggestions(
+        self,
+        content: ContentItem,
+        available_platforms: List[Platform]
+    ) -> Dict[str, Any]:
+        """Get AI-powered suggestions for content repurposing."""
+        try:
+            # Analyze content to suggest best repurposing strategies
+            content_text = content.description or content.notes or ""
+            atoms = self.atomizer.atomize_content(content_text, content.title)
+            
+            suggestions = {
+                'recommended_platforms': [],
+                'repurposing_strategies': [],
+                'content_atoms': atoms,
+                'estimated_pieces': 0
+            }
+            
+            # Analyze content type and suggest platforms
+            if content.content_type == ContentType.BLOG_POST:
+                suggestions['recommended_platforms'] = [
+                    Platform.TWITTER, Platform.LINKEDIN, Platform.INSTAGRAM
+                ]
+                suggestions['estimated_pieces'] = len(available_platforms) * 2
+            elif content.content_type == ContentType.VIDEO:
+                suggestions['recommended_platforms'] = [
+                    Platform.TWITTER, Platform.INSTAGRAM, Platform.FACEBOOK
+                ]
+                suggestions['estimated_pieces'] = len(available_platforms) * 3
+            
+            # Suggest strategies based on content richness
+            if len(atoms.get('statistics', [])) > 3:
+                suggestions['repurposing_strategies'].append('data_driven')
+            if len(atoms.get('tips', [])) > 5:
+                suggestions['repurposing_strategies'].append('tip_series')
+            if len(atoms.get('examples', [])) > 2:
+                suggestions['repurposing_strategies'].append('case_study_series')
+            
+            return suggestions
+            
+        except Exception as e:
+            self.logger.error(f"Error getting repurposing suggestions: {str(e)}")
+            return {
+                'recommended_platforms': [],
+                'repurposing_strategies': [],
+                'content_atoms': {},
+                'estimated_pieces': 0
+            } 

lib/content_calendar/integrations/gap_analyzer.py

@@ -0,0 +1,127 @@
+"""
+Gap analyzer integration for content calendar.
+"""
+
+import streamlit as st
+from typing import Dict, Any, List, Optional
+from loguru import logger
+from lib.utils.website_analyzer.analyzer import WebsiteAnalyzer
+from lib.ai_seo_tools.content_gap_analysis.main import ContentGapAnalysis
+import asyncio
+import sys
+import os
+import json
+from datetime import datetime
+
+# Configure logger for content calendar debugging
+logger.remove()  # Remove default handler
+logger.add(
+    sys.stdout,
+    level="DEBUG",
+    format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan> | <yellow>{function}</yellow> | {message}",
+    filter=lambda record: "content_calendar" in record["name"].lower()
+)
+
+class GapAnalyzerIntegration:
+    """Integrates content gap analysis with content calendar."""
+    
+    def __init__(self):
+        """Initialize the gap analyzer integration."""
+        self.gap_analyzer = ContentGapAnalysis()
+        logger.debug("GapAnalyzerIntegration initialized for content calendar")
+    
+    def analyze_gaps(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Analyze content gaps.
+        
+        Args:
+            data: Dictionary containing content data
+            
+        Returns:
+            Dictionary containing gap analysis results
+        """
+        try:
+            logger.debug(f"Starting gap analysis with data: {json.dumps(data, indent=2)}")
+            # Run gap analysis
+            results = self.gap_analyzer.analyze(data)
+            logger.debug(f"Gap analysis completed with results: {json.dumps(results, indent=2)}")
+            return results
+            
+        except Exception as e:
+            error_msg = f"Error analyzing content gaps: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return {
+                'error': error_msg,
+                'gaps': [],
+                'recommendations': []
+            }
+    
+    def get_topic_suggestions(
+        self,
+        gap_analysis: Dict[str, Any],
+        platform: str,
+        count: int = 5
+    ) -> List[Dict[str, Any]]:
+        """
+        Get topic suggestions for a specific platform based on gap analysis.
+        
+        Args:
+            gap_analysis: Results from gap analysis
+            platform: Target platform for content
+            count: Number of suggestions to generate
+            
+        Returns:
+            List of topic suggestions
+        """
+        try:
+            logger.debug(f"Generating topic suggestions for platform: {platform}, count: {count}")
+            suggestions = []
+            
+            for gap in gap_analysis.get('processed_gaps', []):
+                # Generate platform-specific topics
+                platform_topics = self.ai_processor.generate_platform_topics(
+                    gap=gap,
+                    platform=platform,
+                    count=count
+                )
+                logger.debug(f"Generated topics for gap: {json.dumps(platform_topics, indent=2)}")
+                suggestions.extend(platform_topics)
+            
+            logger.debug(f"Total suggestions generated: {len(suggestions)}")
+            return suggestions
+            
+        except Exception as e:
+            logger.error(f"Error generating topic suggestions: {str(e)}")
+            return []
+    
+    def analyze_topic_relevance(
+        self,
+        topic: Dict[str, Any],
+        gap_analysis: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Analyze how well a topic addresses content gaps.
+        
+        Args:
+            topic: Topic to analyze
+            gap_analysis: Results from gap analysis
+            
+        Returns:
+            Dictionary containing relevance analysis
+        """
+        try:
+            logger.debug(f"Analyzing topic relevance: {json.dumps(topic, indent=2)}")
+            relevance = self.ai_processor.analyze_topic_relevance(
+                topic=topic,
+                gaps=gap_analysis.get('gaps', [])
+            )
+            
+            logger.debug(f"Topic relevance analysis completed: {json.dumps(relevance, indent=2)}")
+            return relevance
+            
+        except Exception as e:
+            logger.error(f"Error analyzing topic relevance: {str(e)}")
+            return {
+                'error': str(e),
+                'score': 0
+            } 

lib/content_calendar/integrations/integration_manager.py

@@ -0,0 +1,196 @@
+import logging
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+
+from ..core.calendar_manager import CalendarManager
+from ..core.content_brief import ContentBriefGenerator
+from .platform_adapters import UnifiedPlatformAdapter
+
+logger = logging.getLogger(__name__)
+
+class IntegrationManager:
+    """Manages integration between content calendar and platform adapters."""
+    
+    def __init__(self):
+        """Initialize the integration manager."""
+        self.calendar_manager = CalendarManager()
+        self.content_brief_generator = ContentBriefGenerator()
+        self.platform_adapter = UnifiedPlatformAdapter()
+        
+    def create_cross_platform_calendar(
+        self,
+        start_date: datetime,
+        end_date: datetime,
+        platforms: List[str],
+        content_types: List[str],
+        target_audience: Optional[Dict[str, Any]] = None,
+        industry: Optional[str] = None,
+        keywords: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """Create a cross-platform content calendar."""
+        try:
+            # Generate base calendar
+            calendar = self.calendar_manager.create_calendar(
+                start_date=start_date,
+                end_date=end_date,
+                content_types=content_types,
+                target_audience=target_audience,
+                industry=industry,
+                keywords=keywords
+            )
+            
+            # Adapt content for each platform
+            platform_calendars = {}
+            for platform in platforms:
+                platform_calendars[platform] = self._adapt_calendar_for_platform(
+                    calendar=calendar,
+                    platform=platform
+                )
+            
+            return {
+                'base_calendar': calendar,
+                'platform_calendars': platform_calendars,
+                'metadata': {
+                    'start_date': start_date,
+                    'end_date': end_date,
+                    'platforms': platforms,
+                    'content_types': content_types,
+                    'industry': industry,
+                    'keywords': keywords
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Error creating cross-platform calendar: {str(e)}")
+            raise
+    
+    def _adapt_calendar_for_platform(
+        self,
+        calendar: Dict[str, Any],
+        platform: str
+    ) -> Dict[str, Any]:
+        """Adapt calendar content for a specific platform."""
+        try:
+            adapted_calendar = {
+                'platform': platform,
+                'content_items': [],
+                'metadata': calendar.get('metadata', {})
+            }
+            
+            # Adapt each content item
+            for item in calendar.get('content_items', []):
+                adapted_item = self._adapt_content_item(item, platform)
+                if adapted_item:
+                    adapted_calendar['content_items'].append(adapted_item)
+            
+            return adapted_calendar
+            
+        except Exception as e:
+            logger.error(f"Error adapting calendar for platform {platform}: {str(e)}")
+            return {
+                'platform': platform,
+                'content_items': [],
+                'error': str(e)
+            }
+    
+    def _adapt_content_item(
+        self,
+        item: Dict[str, Any],
+        platform: str
+    ) -> Optional[Dict[str, Any]]:
+        """Adapt a content item for a specific platform."""
+        try:
+            # Generate content brief if not exists
+            if 'brief' not in item:
+                item['brief'] = self.content_brief_generator.generate_brief(item)
+            
+            # Adapt content for platform
+            adapted_content = self.platform_adapter.adapt_content(
+                content=item,
+                platform=platform
+            )
+            
+            if adapted_content:
+                return {
+                    'original_item': item,
+                    'adapted_content': adapted_content,
+                    'platform_specifics': self.platform_adapter.get_platform_specs(platform)
+                }
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"Error adapting content item for platform {platform}: {str(e)}")
+            return None
+    
+    def get_platform_suggestions(
+        self,
+        content: Dict[str, Any],
+        platforms: List[str]
+    ) -> Dict[str, Any]:
+        """Get platform-specific suggestions for content."""
+        try:
+            suggestions = {}
+            
+            for platform in platforms:
+                platform_suggestions = self.platform_adapter.get_platform_suggestions(
+                    content=content,
+                    platform=platform
+                )
+                if platform_suggestions:
+                    suggestions[platform] = platform_suggestions
+            
+            return suggestions
+            
+        except Exception as e:
+            logger.error(f"Error getting platform suggestions: {str(e)}")
+            return {}
+    
+    def validate_platform_content(
+        self,
+        content: Dict[str, Any],
+        platform: str
+    ) -> Dict[str, Any]:
+        """Validate content for a specific platform."""
+        try:
+            validation_result = self.platform_adapter.validate_content(
+                content=content,
+                platform=platform
+            )
+            
+            return {
+                'platform': platform,
+                'is_valid': validation_result,
+                'specifications': self.platform_adapter.get_platform_specs(platform)
+            }
+            
+        except Exception as e:
+            logger.error(f"Error validating platform content: {str(e)}")
+            return {
+                'platform': platform,
+                'is_valid': False,
+                'error': str(e)
+            }
+    
+    def optimize_cross_platform_content(
+        self,
+        content: Dict[str, Any],
+        platforms: List[str]
+    ) -> Dict[str, Any]:
+        """Optimize content for multiple platforms."""
+        try:
+            optimized_content = {}
+            
+            for platform in platforms:
+                platform_optimized = self.platform_adapter.optimize_content(
+                    content=content,
+                    platform=platform
+                )
+                if platform_optimized:
+                    optimized_content[platform] = platform_optimized
+            
+            return optimized_content
+            
+        except Exception as e:
+            logger.error(f"Error optimizing cross-platform content: {str(e)}")
+            return {} 

lib/content_calendar/integrations/platform_adapters.py

@@ -0,0 +1,307 @@
+"""
+Unified platform adapter for content adaptation across different platforms.
+"""
+
+import logging
+from typing import Dict, Any, List, Optional, TypedDict
+from datetime import datetime
+from loguru import logger
+
+from lib.utils.website_analyzer.analyzer import WebsiteAnalyzer
+from lib.ai_seo_tools.content_gap_analysis.main import ContentGapAnalysis
+from lib.ai_seo_tools.content_title_generator import ai_title_generator
+from lib.ai_seo_tools.meta_desc_generator import metadesc_generator_main
+from lib.ai_seo_tools.seo_structured_data import ai_structured_data
+
+class ContentItem(TypedDict):
+    """Type definition for content items."""
+    id: str
+    title: str
+    content: str
+    platforms: List[str]
+    status: str
+    created_at: datetime
+    updated_at: datetime
+    published_at: Optional[datetime]
+    metadata: Dict[str, Any]
+    analytics: Optional[Dict[str, Any]]
+
+class UnifiedPlatformAdapter:
+    """Unified adapter for different social media platforms."""
+    
+    def __init__(self):
+        """Initialize the platform adapter."""
+        self.platform_handlers = {
+            'instagram': self._handle_instagram,
+            'linkedin': self._handle_linkedin,
+            'twitter': self._handle_twitter,
+            'facebook': self._handle_facebook
+        }
+        logger.info("UnifiedPlatformAdapter initialized")
+    
+    def generate_content(self, platform: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Generate content for a specific platform.
+        
+        Args:
+            platform: Target platform
+            data: Content data
+            
+        Returns:
+            Dictionary containing generated content
+        """
+        try:
+            handler = self.platform_handlers.get(platform.lower())
+            if not handler:
+                raise ValueError(f"Unsupported platform: {platform}")
+            
+            return handler(data)
+            
+        except Exception as e:
+            error_msg = f"Error generating content for {platform}: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return {
+                'error': error_msg,
+                'content': None
+            }
+    
+    def get_content_performance(self, content_item: ContentItem) -> Dict[str, Any]:
+        """Get performance metrics for content across platforms."""
+        try:
+            logger.info(f"Getting performance metrics for content: {getattr(content_item, 'title', 'Untitled')}")
+            
+            # Get platform from content item
+            platforms = getattr(content_item, 'platforms', None)
+            if platforms and len(platforms) > 0:
+                platform = platforms[0].name if hasattr(platforms[0], 'name') else str(platforms[0])
+            else:
+                platform = 'Unknown'
+            
+            # Initialize performance metrics
+            performance = {
+                'engagement_metrics': {
+                    'likes': 0,
+                    'comments': 0,
+                    'shares': 0,
+                    'reach': 0
+                },
+                'seo_metrics': {
+                    'impressions': 0,
+                    'clicks': 0,
+                    'ctr': 0,
+                    'position': 0
+                },
+                'conversion_metrics': {
+                    'conversions': 0,
+                    'conversion_rate': 0,
+                    'revenue': 0
+                },
+                'platform_specific': {},
+                'performance_trends': [],
+                'recommendations': []
+            }
+            
+            # Add platform-specific metrics
+            if platform.upper() == 'WEBSITE':
+                performance['platform_specific'] = {
+                    'bounce_rate': 0,
+                    'time_on_page': 0,
+                    'page_views': 0
+                }
+            
+            return performance
+            
+        except Exception as e:
+            error_msg = f"Error getting content performance: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return {
+                'error': error_msg,
+                'metrics': {},
+                'trends': {},
+                'recommendations': []
+            }
+    
+    def _handle_instagram(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle Instagram content generation."""
+        try:
+            # Generate Instagram-specific content
+            caption = metadesc_generator_main(data)
+            hashtags = self._generate_hashtags(data)
+            
+            return {
+                'platform': 'instagram',
+                'content': {
+                    'caption': caption,
+                    'hashtags': hashtags,
+                    'media_suggestions': self._get_media_suggestions(data)
+                }
+            }
+        except Exception as e:
+            logger.error(f"Error generating Instagram content: {str(e)}")
+            return {
+                'platform': 'instagram',
+                'error': str(e)
+            }
+    
+    def _handle_linkedin(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle LinkedIn content generation."""
+        try:
+            # Generate LinkedIn-specific content
+            post = metadesc_generator_main(data)
+            
+            return {
+                'platform': 'linkedin',
+                'content': {
+                    'post': post,
+                    'engagement_optimization': self._get_engagement_suggestions(data),
+                    'media_suggestions': self._get_media_suggestions(data)
+                }
+            }
+        except Exception as e:
+            logger.error(f"Error generating LinkedIn content: {str(e)}")
+            return {
+                'platform': 'linkedin',
+                'error': str(e)
+            }
+    
+    def _handle_twitter(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle Twitter content generation."""
+        try:
+            # Generate Twitter-specific content
+            tweet = metadesc_generator_main(data)
+            hashtags = self._generate_hashtags(data)
+            
+            return {
+                'platform': 'twitter',
+                'content': {
+                    'tweet': tweet,
+                    'hashtags': hashtags,
+                    'thread_structure': self._get_thread_structure(data),
+                    'media_suggestions': self._get_media_suggestions(data)
+                }
+            }
+        except Exception as e:
+            logger.error(f"Error generating Twitter content: {str(e)}")
+            return {
+                'platform': 'twitter',
+                'error': str(e)
+            }
+    
+    def _handle_facebook(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle Facebook content generation."""
+        try:
+            # Generate Facebook-specific content
+            post = metadesc_generator_main(data)
+            
+            return {
+                'platform': 'facebook',
+                'content': {
+                    'post': post,
+                    'engagement_optimization': self._get_engagement_suggestions(data),
+                    'media_suggestions': self._get_media_suggestions(data)
+                }
+            }
+        except Exception as e:
+            logger.error(f"Error generating Facebook content: {str(e)}")
+            return {
+                'platform': 'facebook',
+                'error': str(e)
+            }
+    
+    def _generate_hashtags(self, data: Dict[str, Any]) -> List[str]:
+        """Generate relevant hashtags for content."""
+        try:
+            # Extract keywords from content
+            keywords = data.get('keywords', [])
+            
+            # Add platform-specific hashtags
+            platform = data.get('platform', '').lower()
+            platform_hashtags = {
+                'instagram': ['#instagood', '#photooftheday'],
+                'twitter': ['#trending', '#followme'],
+                'linkedin': ['#business', '#professional'],
+                'facebook': ['#social', '#community']
+            }.get(platform, [])
+            
+            return keywords + platform_hashtags
+            
+        except Exception as e:
+            logger.error(f"Error generating hashtags: {str(e)}")
+            return []
+    
+    def _get_media_suggestions(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Get media suggestions for content."""
+        try:
+            # Generate media suggestions based on content type
+            content_type = data.get('type', 'post')
+            
+            suggestions = []
+            if content_type == 'blog':
+                suggestions.append({
+                    'type': 'featured_image',
+                    'description': 'Main blog post image',
+                    'dimensions': '1200x630'
+                })
+            elif content_type == 'social':
+                suggestions.append({
+                    'type': 'post_image',
+                    'description': 'Social media post image',
+                    'dimensions': '1080x1080'
+                })
+            
+            return suggestions
+            
+        except Exception as e:
+            logger.error(f"Error getting media suggestions: {str(e)}")
+            return []
+    
+    def _get_engagement_suggestions(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Get engagement optimization suggestions."""
+        try:
+            return {
+                'best_posting_times': ['9:00 AM', '5:00 PM'],
+                'engagement_tips': [
+                    'Ask questions to encourage comments',
+                    'Use relevant hashtags',
+                    'Include a clear call-to-action'
+                ],
+                'content_length': {
+                    'optimal': '150-200 characters',
+                    'maximum': '300 characters'
+                }
+            }
+        except Exception as e:
+            logger.error(f"Error getting engagement suggestions: {str(e)}")
+            return {}
+    
+    def _get_thread_structure(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Get thread structure for Twitter threads."""
+        try:
+            content = data.get('content', '')
+            sentences = content.split('.')
+            
+            thread = []
+            current_tweet = ''
+            
+            for sentence in sentences:
+                if len(current_tweet + sentence) <= 280:
+                    current_tweet += sentence + '.'
+                else:
+                    if current_tweet:
+                        thread.append({
+                            'content': current_tweet.strip(),
+                            'type': 'tweet'
+                        })
+                    current_tweet = sentence + '.'
+            
+            if current_tweet:
+                thread.append({
+                    'content': current_tweet.strip(),
+                    'type': 'tweet'
+                })
+            
+            return thread
+            
+        except Exception as e:
+            logger.error(f"Error generating thread structure: {str(e)}")
+            return [] 

lib/content_calendar/integrations/seo_optimizer.py

@@ -0,0 +1,219 @@
+import logging
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+from ...meta_desc_generator import generate_blog_metadesc
+from ...content_title_generator import generate_blog_titles
+from ...seo_structured_data import generate_json_data
+
+logger = logging.getLogger(__name__)
+
+class SEOOptimizer:
+    """Integrates SEO tools with content calendar system."""
+    
+    def __init__(self):
+        """Initialize the SEO optimizer."""
+        self._setup_logging()
+    
+    def _setup_logging(self):
+        """Configure logging for SEO optimizer."""
+        logger.setLevel(logging.INFO)
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    
+    def optimize_content(
+        self,
+        content: Dict[str, Any],
+        content_type: str = 'article',
+        language: str = 'English',
+        search_intent: str = 'Informational Intent'
+    ) -> Dict[str, Any]:
+        """
+        Optimize content for SEO using existing tools.
+        
+        Args:
+            content: Content to optimize
+            content_type: Type of content (article, product, etc.)
+            language: Content language
+            search_intent: Search intent type
+            
+        Returns:
+            Optimized content with SEO elements
+        """
+        try:
+            # Extract content details
+            title = content.get('title', '')
+            keywords = content.get('keywords', [])
+            content_text = content.get('content', '')
+            
+            # Generate SEO elements
+            optimized_title = self._optimize_title(
+                title=title,
+                keywords=keywords,
+                content_type=content_type,
+                language=language,
+                search_intent=search_intent
+            )
+            
+            meta_description = self._generate_meta_description(
+                keywords=keywords,
+                content_type=content_type,
+                language=language,
+                search_intent=search_intent
+            )
+            
+            structured_data = self._generate_structured_data(
+                content=content,
+                content_type=content_type
+            )
+            
+            return {
+                'original_content': content,
+                'seo_optimized': {
+                    'title': optimized_title,
+                    'meta_description': meta_description,
+                    'structured_data': structured_data,
+                    'keywords': keywords,
+                    'content_type': content_type,
+                    'language': language,
+                    'search_intent': search_intent
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Error optimizing content: {str(e)}")
+            return {
+                'error': str(e)
+            }
+    
+    def _optimize_title(
+        self,
+        title: str,
+        keywords: List[str],
+        content_type: str,
+        language: str,
+        search_intent: str
+    ) -> List[str]:
+        """Generate SEO-optimized titles."""
+        try:
+            # Convert keywords list to comma-separated string
+            keywords_str = ', '.join(keywords)
+            
+            # Generate titles using existing tool
+            titles = generate_blog_titles(
+                input_blog_keywords=keywords_str,
+                input_blog_content=title,
+                input_title_type=content_type,
+                input_title_intent=search_intent,
+                input_language=language
+            )
+            
+            return titles.split('\n') if titles else []
+            
+        except Exception as e:
+            logger.error(f"Error optimizing title: {str(e)}")
+            return []
+    
+    def _generate_meta_description(
+        self,
+        keywords: List[str],
+        content_type: str,
+        language: str,
+        search_intent: str
+    ) -> List[str]:
+        """Generate SEO-optimized meta descriptions."""
+        try:
+            # Convert keywords list to comma-separated string
+            keywords_str = ', '.join(keywords)
+            
+            # Generate meta descriptions using existing tool
+            descriptions = generate_blog_metadesc(
+                keywords=keywords_str,
+                tone='Informative',
+                search_type=search_intent,
+                language=language
+            )
+            
+            return descriptions.split('\n') if descriptions else []
+            
+        except Exception as e:
+            logger.error(f"Error generating meta description: {str(e)}")
+            return []
+    
+    def _generate_structured_data(
+        self,
+        content: Dict[str, Any],
+        content_type: str
+    ) -> Optional[Dict[str, Any]]:
+        """Generate structured data for content."""
+        try:
+            # Prepare content details for structured data
+            details = {
+                'Headline': content.get('title', ''),
+                'Author': content.get('author', ''),
+                'Date Published': content.get('publish_date', datetime.now().isoformat()),
+                'Keywords': ', '.join(content.get('keywords', [])),
+                'Description': content.get('description', ''),
+                'Image URL': content.get('image_url', '')
+            }
+            
+            # Generate structured data using existing tool
+            structured_data = generate_json_data(
+                content_type=content_type,
+                details=details,
+                url=content.get('url', '')
+            )
+            
+            return structured_data
+            
+        except Exception as e:
+            logger.error(f"Error generating structured data: {str(e)}")
+            return None
+    
+    def optimize_calendar_content(
+        self,
+        calendar: Dict[str, Any],
+        content_type: str = 'article',
+        language: str = 'English',
+        search_intent: str = 'Informational Intent'
+    ) -> Dict[str, Any]:
+        """
+        Optimize all content in calendar for SEO.
+        
+        Args:
+            calendar: Content calendar to optimize
+            content_type: Type of content
+            language: Content language
+            search_intent: Search intent type
+            
+        Returns:
+            Calendar with SEO-optimized content
+        """
+        try:
+            optimized_calendar = {
+                'metadata': calendar.get('metadata', {}),
+                'content_items': []
+            }
+            
+            # Optimize each content item
+            for item in calendar.get('content_items', []):
+                optimized_item = self.optimize_content(
+                    content=item,
+                    content_type=content_type,
+                    language=language,
+                    search_intent=search_intent
+                )
+                if optimized_item:
+                    optimized_calendar['content_items'].append(optimized_item)
+            
+            return optimized_calendar
+            
+        except Exception as e:
+            logger.error(f"Error optimizing calendar content: {str(e)}")
+            return {
+                'error': str(e)
+            } 

lib/content_calendar/integrations/seo_tools.py

@@ -0,0 +1,143 @@
+"""SEO tools integration for content calendar."""
+
+import streamlit as st
+from loguru import logger
+from typing import Dict, Any, List, Optional
+import asyncio
+import sys
+import os
+from lib.ai_seo_tools.content_title_generator import ai_title_generator
+from lib.utils.website_analyzer.analyzer import WebsiteAnalyzer
+from lib.gpt_providers.text_generation.main_text_generation import llm_text_gen
+
+# Configure logger
+logger.remove()  # Remove default handler
+logger.add(
+    "logs/seo_tools_integration.log",
+    rotation="50 MB",
+    retention="10 days",
+    level="DEBUG",
+    format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}"
+)
+logger.add(
+    sys.stdout,
+    level="INFO",
+    format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{message}</cyan>"
+)
+
+# Ensure logs directory exists
+os.makedirs("logs", exist_ok=True)
+
+class SEOToolsIntegration:
+    """Integration with SEO tools for content calendar."""
+    
+    def __init__(self):
+        """Initialize the SEO tools integration."""
+        self.website_analyzer = WebsiteAnalyzer()
+        logger.info("SEOToolsIntegration initialized")
+    
+    def analyze_content(self, url: str) -> Dict[str, Any]:
+        """
+        Analyze content for SEO optimization.
+        
+        Args:
+            url: The URL to analyze
+            
+        Returns:
+            Dictionary containing SEO analysis results
+        """
+        try:
+            # Analyze website
+            analysis = self.website_analyzer.analyze_website(url)
+            if not analysis.get('success', False):
+                return {
+                    'error': analysis.get('error', 'Unknown error in analysis'),
+                    'seo_score': 0,
+                    'recommendations': []
+                }
+            
+            # Extract SEO information
+            seo_info = analysis['data']['analysis']['seo_info']
+            
+            return {
+                'seo_score': seo_info.get('overall_score', 0),
+                'meta_tags': seo_info.get('meta_tags', {}),
+                'content': seo_info.get('content', {}),
+                'recommendations': seo_info.get('recommendations', [])
+            }
+            
+        except Exception as e:
+            error_msg = f"Error analyzing content: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return {
+                'error': error_msg,
+                'seo_score': 0,
+                'recommendations': []
+            }
+    
+    def generate_title(self, url: str) -> Dict[str, Any]:
+        """
+        Generate SEO-optimized title.
+        
+        Args:
+            url: The URL to analyze
+            
+        Returns:
+            Dictionary containing title suggestions
+        """
+        return ai_title_generator(url)
+    
+    def optimize_content(self, content: str, keywords: List[str]) -> Dict[str, Any]:
+        """
+        Optimize content for SEO.
+        
+        Args:
+            content: The content to optimize
+            keywords: List of target keywords
+            
+        Returns:
+            Dictionary containing optimization suggestions
+        """
+        try:
+            # Prepare prompt for content optimization
+            prompt = f"""Optimize the following content for SEO:
+            
+            Content: {content}
+            Target Keywords: {', '.join(keywords)}
+            
+            Provide optimization suggestions for:
+            1. Keyword usage and placement
+            2. Content structure and readability
+            3. Meta information
+            4. Internal linking opportunities
+            5. Content length and depth
+            
+            Format the response as JSON with 'suggestions' and 'score' keys."""
+            
+            # Get AI optimization suggestions
+            suggestions = llm_text_gen(
+                prompt=prompt,
+                system_prompt="You are an SEO expert specializing in content optimization.",
+                response_format="json_object"
+            )
+            
+            if not suggestions:
+                return {
+                    'error': 'Failed to generate optimization suggestions',
+                    'suggestions': [],
+                    'score': 0
+                }
+            
+            return {
+                'suggestions': suggestions.get('suggestions', []),
+                'score': suggestions.get('score', 0)
+            }
+            
+        except Exception as e:
+            error_msg = f"Error optimizing content: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return {
+                'error': error_msg,
+                'suggestions': [],
+                'score': 0
+            } 

lib/content_calendar/ui/add_content_modal.py

@@ -0,0 +1,21 @@
+import streamlit as st
+
+def render_add_content_modal(selected_date, on_add_content, on_generate_with_ai):
+    if st.button("+ Add Content", key="open_add_content_dialog_bottom"):
+        st.session_state['show_add_content_dialog'] = True
+    if st.session_state.get('show_add_content_dialog', False):
+        st.markdown("### Add Content")
+        with st.form("quick_add_form_dialog_bottom"):
+            title = st.text_input("Title")
+            platform = st.selectbox("Platform", ["Blog", "Instagram", "Twitter", "LinkedIn", "Facebook"])
+            content_type = st.selectbox("Content Type", ["Article", "Social Post", "Video", "Newsletter"])
+            publish_date = st.date_input("Publish Date", selected_date)
+            col_add, col_ai = st.columns([0.6, 0.4])
+            with col_add:
+                if st.form_submit_button("Add Content"):
+                    on_add_content(title, platform, content_type, publish_date)
+            with col_ai:
+                if st.form_submit_button("Generate with AI"):
+                    on_generate_with_ai(title, platform, content_type)
+        if st.button("Close", key="close_add_content_dialog_bottom"):
+            st.session_state['show_add_content_dialog'] = False 

lib/content_calendar/ui/ai_suggestions_modal.py

@@ -0,0 +1,137 @@
+import streamlit as st
+
+def render_ai_suggestions_modal(generate_ai_suggestions, on_create_brief, on_schedule, on_refine, on_customize):
+    st.subheader("AI Content Suggestions")
+    default_type = st.session_state.get('ai_modal_type', "Blog Post")
+    default_topic = st.session_state.get('ai_modal_topic', "")
+    default_platform = st.session_state.get('ai_modal_platform', "Blog")
+    content_types = {
+        "Blog Post": "Long-form content for in-depth topics",
+        "Social Media Post": "Short, engaging content for social platforms",
+        "Video": "Visual content with script and storyboard",
+        "Newsletter": "Email content for subscriber engagement"
+    }
+    content_type = st.selectbox(
+        "Content Type",
+        list(content_types.keys()),
+        format_func=lambda x: f"{x} - {content_types[x]}",
+        key="modal_suggestion_type",
+        index=list(content_types.keys()).index(default_type) if default_type in content_types else 0
+    )
+    topic = st.text_input("Enter topic or keyword", value=default_topic, key="modal_suggestion_topic")
+    with st.expander("Advanced Options"):
+        audience = st.multiselect(
+            "Target Audience",
+            ["Professionals", "Students", "Entrepreneurs", "General Public", "Industry Experts"],
+            default=["Professionals"]
+        )
+        goals = st.multiselect(
+            "Content Goals",
+            ["Increase Engagement", "Generate Leads", "Build Authority", "Drive Traffic", "Educate"],
+            default=["Increase Engagement"]
+        )
+        tone = st.select_slider(
+            "Content Tone",
+            options=["Professional", "Casual", "Educational", "Entertaining", "Persuasive"],
+            value="Professional"
+        )
+        length = st.radio(
+            "Content Length",
+            ["Short", "Medium", "Long"],
+            horizontal=True
+        )
+        st.subheader("AI Model Settings")
+        model_settings = {
+            "Creativity Level": st.slider("Creativity Level", 0.0, 1.0, 0.7, 0.1),
+            "Formality Level": st.slider("Formality Level", 0.0, 1.0, 0.5, 0.1),
+            "Technical Depth": st.slider("Technical Depth", 0.0, 1.0, 0.5, 0.1)
+        }
+        st.subheader("Content Style Preferences")
+        style_preferences = {
+            "Use Examples": st.checkbox("Include Real-world Examples", True),
+            "Use Statistics": st.checkbox("Include Statistics and Data", True),
+            "Use Quotes": st.checkbox("Include Expert Quotes", False),
+            "Use Case Studies": st.checkbox("Include Case Studies", False)
+        }
+        st.subheader("SEO Preferences")
+        seo_preferences = {
+            "Keyword Density": st.slider("Keyword Density (%)", 1, 5, 2),
+            "Internal Linking": st.checkbox("Suggest Internal Links", True),
+            "External Linking": st.checkbox("Suggest External Links", True),
+            "Meta Description": st.checkbox("Generate Meta Description", True)
+        }
+        st.subheader("Platform-specific Settings")
+        platform_settings = {
+            "Hashtag Usage": st.checkbox("Suggest Hashtags", True),
+            "Image Suggestions": st.checkbox("Suggest Images", True),
+            "Video Suggestions": st.checkbox("Suggest Videos", False),
+            "Interactive Elements": st.checkbox("Suggest Interactive Elements", False)
+        }
+    if st.button("Generate Suggestions", type="primary", key="modal_generate_btn"):
+        with st.spinner("Generating suggestions..."):
+            suggestions = generate_ai_suggestions(
+                content_type,
+                topic,
+                audience,
+                goals,
+                tone,
+                length,
+                model_settings,
+                style_preferences,
+                seo_preferences,
+                platform_settings
+            )
+            if suggestions:
+                suggestion_tabs = st.tabs([f"Suggestion {i+1}" for i in range(len(suggestions))])
+                for i, (tab, suggestion) in enumerate(zip(suggestion_tabs, suggestions)):
+                    with tab:
+                        col1, col2 = st.columns([2, 1])
+                        with col1:
+                            st.subheader(suggestion['title'])
+                            st.write(f"**Type:** {suggestion['type']}")
+                            st.write(f"**Platform:** {suggestion['platform']}")
+                            st.write(f"**Target Audience:** {', '.join(suggestion['audience'])}")
+                            st.write(f"**Estimated Impact:** {suggestion['impact']}")
+                            with st.expander("Content Preview"):
+                                st.write(suggestion.get('preview', 'Preview not available'))
+                                if suggestion.get('style_elements'):
+                                    st.write("**Style Elements:**")
+                                    for element in suggestion['style_elements']:
+                                        st.write(f"- {element}")
+                                if suggestion.get('seo_elements'):
+                                    st.write("**SEO Elements:**")
+                                    for element in suggestion['seo_elements']:
+                                        st.write(f"- {element}")
+                        with col2:
+                            st.subheader("Performance Metrics")
+                            metrics = {
+                                "Engagement Score": suggestion.get('engagement_score', '85%'),
+                                "Reach Potential": suggestion.get('reach', 'High'),
+                                "Conversion Rate": suggestion.get('conversion', '3.5%'),
+                                "SEO Impact": suggestion.get('seo_impact', 'Strong')
+                            }
+                            for metric, value in metrics.items():
+                                st.metric(metric, value)
+                            st.subheader("Actions")
+                            if st.button("Create Brief", key=f"modal_brief_{i}"):
+                                on_create_brief(suggestion)
+                            if st.button("Schedule", key=f"modal_schedule_{i}"):
+                                on_schedule(suggestion)
+                            if st.button("Refine", key=f"modal_refine_{i}"):
+                                on_refine(suggestion)
+                            if st.button("Customize", key=f"modal_customize_{i}"):
+                                on_customize(suggestion)
+                        with st.expander("Additional Options"):
+                            st.write("**Platform Optimizations**")
+                            for platform in suggestion.get('platform_optimizations', []):
+                                st.write(f"- {platform}")
+                            st.write("**Content Variations**")
+                            for variation in suggestion.get('variations', []):
+                                st.write(f"- {variation}")
+                            st.write("**SEO Recommendations**")
+                            for seo in suggestion.get('seo_recommendations', []):
+                                st.write(f"- {seo}")
+                            if suggestion.get('media_suggestions'):
+                                st.write("**Media Suggestions**")
+                                for media in suggestion['media_suggestions']:
+                                    st.write(f"- {media}") 

lib/content_calendar/ui/calendar_view.py

@@ -0,0 +1,51 @@
+import streamlit as st
+from .components.content_card import render_content_card
+from .components.badge import render_badge
+
+def render_calendar_view(calendar_data, icon_map, status_color, on_edit, on_delete, on_generate, get_item_key):
+    if calendar_data is not None and not calendar_data.empty:
+        st.markdown("### All Scheduled Content")
+        calendar_data = calendar_data.sort_values(by="date")
+        grouped = list(calendar_data.groupby(calendar_data['date'].dt.date))
+        for i, (date, group) in enumerate(grouped):
+            exp_open = (i == 0)
+            with st.expander(f"{date.strftime('%B %d, %Y')}", expanded=exp_open):
+                for idx, row in group.iterrows():
+                    item_key = get_item_key(row)
+                    is_editing = st.session_state.get("editing_item_key") == item_key
+                    platform = str(row['platform'])
+                    if hasattr(platform, 'value'):
+                        platform = platform.value
+                    platform_map = {
+                        'blog': 'Blog',
+                        'website': 'Blog',
+                        'instagram': 'Instagram',
+                        'twitter': 'Twitter',
+                        'linkedin': 'LinkedIn',
+                        'facebook': 'Facebook',
+                    }
+                    platform_disp = platform_map.get(platform.lower(), 'Blog')
+                    type_disp = str(row['type'])
+                    if hasattr(type_disp, 'value'):
+                        type_disp = type_disp.value
+                    type_disp = type_disp.replace('_', ' ').title()
+                    status_disp = row['status'].capitalize()
+                    platform_icon = icon_map.get(platform_disp, '🌐')
+                    type_icon = icon_map.get(type_disp, '📄')
+                    render_content_card(
+                        row=row,
+                        is_editing=is_editing,
+                        on_edit=lambda r=row: on_edit(r),
+                        on_delete=lambda r=row: on_delete(r),
+                        on_generate=lambda r=row: on_generate(r),
+                        icon_map=icon_map,
+                        status_color=status_color,
+                        platform_disp=platform_disp,
+                        type_disp=type_disp,
+                        status_disp=status_disp,
+                        platform_icon=platform_icon,
+                        type_icon=type_icon,
+                        item_key=item_key
+                    )
+    else:
+        st.info("No content scheduled yet. Add content to see it here.") 

lib/content_calendar/ui/components/ab_testing.py

@@ -0,0 +1,294 @@
+import streamlit as st
+from typing import Dict, Any, List
+from lib.database.models import ContentItem
+import logging
+from lib.ai_seo_tools.content_calendar.core.content_generator import ContentGenerator
+from lib.ai_seo_tools.content_calendar.core.calendar_manager import CalendarManager
+
+logger = logging.getLogger(__name__)
+
+def render_ab_testing(content_generator: ContentGenerator, calendar_manager: CalendarManager):
+    """Render the A/B testing interface."""
+    st.header("A/B Testing")
+    
+    # Check if calendar manager is available
+    if 'calendar_manager' not in st.session_state:
+        st.error("Calendar manager not initialized. Please refresh the page.")
+        return
+    
+    # Get available content
+    try:
+        available_content = calendar_manager.get_calendar().get_all_content()
+        content_options = [item.title for item in available_content]
+    except Exception as e:
+        logger.error(f"Error getting content options: {str(e)}")
+        st.error("Error loading content. Please try again.")
+        return
+    
+    if not content_options:
+        st.info("""
+        ## Welcome to A/B Testing! 🧪
+        
+        Test different versions of your content to find what works best. Here's what you can do:
+        
+        ### Features:
+        - 🔄 **Variant Generation**: Create multiple versions of your content
+        - 📊 **Performance Tracking**: Compare metrics across variants
+        - 📈 **Statistical Analysis**: Get data-driven insights
+        - 🎯 **Winner Selection**: Identify the best performing content
+        
+        ### Getting Started:
+        1. First, add some content to your calendar
+        2. Select the content you want to test
+        3. Generate variants with different parameters
+        4. Track performance and analyze results
+        
+        Ready to get started? Add some content to your calendar first!
+        """)
+        return
+    
+    # Content Selection
+    selected_content = st.selectbox(
+        "Select content to test",
+        options=content_options,
+        key="ab_test_content_select"
+    )
+    
+    if selected_content:
+        try:
+            content_item = next(
+                item for item in available_content
+                if item.title == selected_content
+            )
+            
+            # Show onboarding info if no test history
+            if not st.session_state.get('ab_test_results', {}).get(content_item.title):
+                st.info("""
+                ### A/B Testing Guide
+                
+                Create and compare different versions of your content:
+                
+                - **Headline Variations**: Test different titles and hooks
+                - **Content Structure**: Try different content flows
+                - **Call-to-Action**: Test various CTAs
+                - **Visual Elements**: Compare different media placements
+                
+                Click 'Generate Test Variants' to get started!
+                """)
+            
+            # Test Configuration
+            st.markdown("### Create A/B Test")
+            col1, col2 = st.columns([2, 1])
+            
+            with col1:
+                test_content = st.selectbox(
+                    "Select content to A/B test",
+                    options=content_options,
+                    key="ab_test_content_select_unique"
+                )
+            
+            with col2:
+                num_variants = st.slider(
+                    "Number of variants",
+                    min_value=2,
+                    max_value=5,
+                    value=2,
+                    help="Number of different versions to test"
+                )
+            
+            if test_content:
+                content_item = next(
+                    item for item in calendar_manager.get_calendar().get_all_content()
+                    if item.title == test_content
+                )
+                
+                # Test Settings
+                with st.expander("Test Settings"):
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        test_duration = st.number_input(
+                            "Test Duration (days)",
+                            min_value=1,
+                            max_value=30,
+                            value=7
+                        )
+                        target_metric = st.selectbox(
+                            "Primary Metric",
+                            options=['Engagement', 'Conversion', 'Reach', 'Click-through'],
+                            index=0
+                        )
+                    with col2:
+                        audience_size = st.select_slider(
+                            "Audience Size",
+                            options=['Small', 'Medium', 'Large'],
+                            value='Medium'
+                        )
+                        confidence_level = st.slider(
+                            "Confidence Level",
+                            min_value=90,
+                            max_value=99,
+                            value=95,
+                            help="Statistical confidence level for test results"
+                        )
+                
+                # Generate Variants
+                if st.button("Generate Variants"):
+                    with st.spinner("Generating variants..."):
+                        variants = _generate_ab_test_variants(content_generator, content_item, num_variants)
+                        if variants:
+                            st.success(f"Generated {len(variants)} variants!")
+                            
+                            # Display variants in tabs
+                            variant_tabs = st.tabs([f"Variant {i+1}" for i in range(len(variants))])
+                            for i, tab in enumerate(variant_tabs):
+                                with tab:
+                                    st.markdown(f"### Variant {i+1}")
+                                    st.json(variants[i]['content'])
+                                    
+                                    # Variant metrics
+                                    col1, col2, col3 = st.columns(3)
+                                    with col1:
+                                        st.metric(
+                                            "Engagement Score",
+                                            f"{variants[i]['metrics']['engagement_score']:.1f}%"
+                                        )
+                                    with col2:
+                                        st.metric(
+                                            "Conversion Rate",
+                                            f"{variants[i]['metrics']['conversion_rate']:.1f}%"
+                                        )
+                                    with col3:
+                                        st.metric(
+                                            "Reach",
+                                            f"{variants[i]['metrics']['reach']:,}"
+                                        )
+            
+            # Results Analysis
+            st.markdown("### Analyze Results")
+            if test_content in st.session_state.ab_test_results:
+                test_data = st.session_state.ab_test_results[test_content]
+                
+                # Test Status
+                st.info(f"Test Status: {test_data['status']}")
+                st.write(f"Started: {test_data['start_time']}")
+                
+                if test_data['status'] == 'running':
+                    if st.button("End Test and Analyze"):
+                        with st.spinner("Analyzing results..."):
+                            results = _analyze_ab_test_results(content_item)
+                            if results:
+                                st.success("Analysis complete!")
+                                _display_test_results(results)
+        
+        except Exception as e:
+            logger.error(f"Error in A/B testing interface: {str(e)}", exc_info=True)
+            st.error(f"Error in A/B testing: {str(e)}")
+
+def _generate_ab_test_variants(
+    content_generator,
+    content: ContentItem,
+    num_variants: int
+) -> List[Dict[str, Any]]:
+    """Generate A/B test variants for content."""
+    try:
+        logger.info(f"Generating {num_variants} variants for content: {content.title}")
+        
+        # Convert content to dictionary format
+        content_dict = {
+            'title': content.title,
+            'content': content.description,
+            'metadata': {
+                'platform': content.platforms[0].name if content.platforms else 'Unknown',
+                'content_type': content.content_type.name
+            }
+        }
+        
+        variants = []
+        for i in range(num_variants):
+            # Generate different variations
+            variant = content_generator.generate_variation(
+                content=content_dict,
+                variation_type=f"variant_{i+1}"
+            )
+            if variant:
+                variants.append(variant)
+        
+        return variants
+        
+    except Exception as e:
+        logger.error(f"Error generating variants: {str(e)}")
+        return []
+
+def _analyze_ab_test_results(content_item: ContentItem) -> Dict[str, Any]:
+    """Analyze results of A/B testing for content optimization."""
+    try:
+        logger.info(f"Analyzing A/B test results for: {content_item.title}")
+        
+        if content_item.title not in st.session_state.ab_test_results:
+            raise ValueError("No A/B test results found for this content")
+        
+        test_data = st.session_state.ab_test_results[content_item.title]
+        variants = test_data['variants']
+        
+        # Calculate performance metrics
+        results = {
+            'total_engagement': sum(v['metrics']['engagement_score'] for v in variants),
+            'total_conversions': sum(v['metrics']['conversion_rate'] for v in variants),
+            'total_reach': sum(v['metrics']['reach'] for v in variants),
+            'best_performing_variant': max(variants, key=lambda x: x['metrics']['engagement_score']),
+            'recommendations': []
+        }
+        
+        # Generate recommendations
+        for variant in variants:
+            if variant['metrics']['engagement_score'] > 0.7:  # High engagement threshold
+                results['recommendations'].append({
+                    'variant_id': variant['variant_id'],
+                    'reason': 'High engagement score',
+                    'suggested_actions': ['Scale this variant', 'Apply learnings to other content']
+                })
+        
+        # Update test status
+        test_data['status'] = 'completed'
+        test_data['results'] = results
+        
+        logger.info("A/B test results analyzed successfully")
+        return results
+        
+    except Exception as e:
+        logger.error(f"Error analyzing A/B test results: {str(e)}", exc_info=True)
+        st.error(f"Error analyzing A/B test results: {str(e)}")
+        return {}
+
+def _display_test_results(results: Dict[str, Any]) -> None:
+    """Display A/B test results in the UI."""
+    with st.expander("Overall Performance", expanded=True):
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric(
+                "Total Engagement",
+                f"{results['total_engagement']:.1f}%"
+            )
+        with col2:
+            st.metric(
+                "Total Conversions",
+                f"{results['total_conversions']:.1f}%"
+            )
+        with col3:
+            st.metric(
+                "Total Reach",
+                f"{results['total_reach']:,}"
+            )
+    
+    with st.expander("Best Performing Variant", expanded=True):
+        best_variant = results['best_performing_variant']
+        st.markdown(f"### {best_variant['variant_id']}")
+        st.json(best_variant['content'])
+    
+    with st.expander("Recommendations", expanded=True):
+        for rec in results['recommendations']:
+            st.markdown(f"#### {rec['variant_id']}")
+            st.write(f"Reason: {rec['reason']}")
+            st.write("Suggested Actions:")
+            for action in rec['suggested_actions']:
+                st.write(f"- {action}") 

lib/content_calendar/ui/components/badge.py

@@ -0,0 +1,2 @@
+def render_badge(platform_disp, platform_icon, type_disp, status_disp):
+    return f"<span class='badge-content-calendar badge-platform-{platform_disp.lower()}'>{platform_icon} {platform_disp} &nbsp;|&nbsp; {type_disp} &nbsp;|&nbsp; <span class='chip-status chip-status-{status_disp.lower()}'>{status_disp}</span></span>" 

lib/content_calendar/ui/components/content_card.py

@@ -0,0 +1,22 @@
+import streamlit as st
+
+def render_content_card(row, is_editing, on_edit, on_delete, on_generate, icon_map, status_color, platform_disp, type_disp, status_disp, platform_icon, type_icon, item_key):
+    st.markdown(f"<div class='card-content-calendar'>", unsafe_allow_html=True)
+    st.markdown(f"<div style='display:flex;align-items:center;justify-content:space-between;gap:8px;'>", unsafe_allow_html=True)
+    st.markdown(f"<div style='display:flex;align-items:center;gap:8px;min-width:0;flex:1;'>"
+                f"{type_icon}<span class='content-title'>{row['title']}</span></div>", unsafe_allow_html=True)
+    st.markdown("<div style='display:flex;align-items:center;gap:4px;'>", unsafe_allow_html=True)
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col1:
+        if st.button("⚡", key=f"generate_{item_key}", help="Generate with AI Blog Writer", use_container_width=True):
+            on_generate()
+    with col2:
+        if st.button("✏️", key=f"edit_{item_key}", help="Edit Content", use_container_width=True):
+            on_edit()
+    with col3:
+        if st.button("🗑️", key=f"delete_{item_key}", help="Delete Content", use_container_width=True):
+            on_delete()
+    st.markdown("</div>", unsafe_allow_html=True)
+    st.markdown("</div>", unsafe_allow_html=True)
+    st.markdown(f"<div class='content-meta'><span class='badge-content-calendar badge-platform-{platform_disp.lower()}'>{platform_icon} {platform_disp} &nbsp;|&nbsp; {type_disp} &nbsp;|&nbsp; <span class='chip-status chip-status-{status_disp.lower()}'>{status_disp}</span></span></div>", unsafe_allow_html=True)
+    st.markdown("</div>", unsafe_allow_html=True) 

lib/content_calendar/ui/components/content_optimization.py

@@ -0,0 +1,498 @@
+import streamlit as st
+from typing import Dict, Any, List
+from datetime import datetime
+import pandas as pd
+from lib.ai_seo_tools.content_calendar.core.content_generator import ContentGenerator
+from lib.ai_seo_tools.content_calendar.core.ai_generator import AIGenerator
+from lib.ai_seo_tools.content_calendar.integrations.seo_optimizer import SEOOptimizer
+from lib.database.models import ContentItem, ContentType, Platform, SEOData
+import logging
+from lib.database.models import get_engine, get_session, init_db
+
+logger = logging.getLogger('content_calendar.optimization')
+
+engine = get_engine()
+init_db(engine)
+session = get_session(engine)
+
+class OptimizationManager:
+    def __init__(self):
+        if 'optimization_history' not in st.session_state:
+            st.session_state.optimization_history = {}
+        if 'optimization_previews' not in st.session_state:
+            st.session_state.optimization_previews = {}
+        if 'optimization_metrics' not in st.session_state:
+            st.session_state.optimization_metrics = {}
+
+    def track_optimization(self, content_id: str, optimization_data: Dict[str, Any]) -> bool:
+        """Track optimization changes for content with detailed metrics."""
+        try:
+            if content_id not in st.session_state.optimization_history:
+                st.session_state.optimization_history[content_id] = []
+            
+            optimization_data['timestamp'] = datetime.now()
+            optimization_data['metrics'] = self._calculate_optimization_metrics(optimization_data)
+            st.session_state.optimization_history[content_id].append(optimization_data)
+            
+            # Update metrics
+            if content_id not in st.session_state.optimization_metrics:
+                st.session_state.optimization_metrics[content_id] = []
+            st.session_state.optimization_metrics[content_id].append(optimization_data['metrics'])
+            
+            return True
+        except Exception as e:
+            logger.error(f"Error tracking optimization: {str(e)}")
+            return False
+
+    def _calculate_optimization_metrics(self, optimization_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Calculate detailed optimization metrics."""
+        try:
+            metrics = {
+                'readability_score': 0,
+                'seo_score': 0,
+                'engagement_potential': 0,
+                'keyword_density': 0,
+                'content_quality': 0
+            }
+            
+            # Calculate readability score
+            if 'content' in optimization_data:
+                content = optimization_data['content']
+                metrics['readability_score'] = self._calculate_readability(content)
+            
+            # Calculate SEO score
+            if 'seo_data' in optimization_data:
+                seo_data = optimization_data['seo_data']
+                metrics['seo_score'] = self._calculate_seo_score(seo_data)
+                metrics['keyword_density'] = self._calculate_keyword_density(seo_data)
+            
+            # Calculate engagement potential
+            if 'engagement_metrics' in optimization_data:
+                engagement = optimization_data['engagement_metrics']
+                metrics['engagement_potential'] = self._calculate_engagement_potential(engagement)
+            
+            # Calculate overall content quality
+            metrics['content_quality'] = (
+                metrics['readability_score'] * 0.3 +
+                metrics['seo_score'] * 0.3 +
+                metrics['engagement_potential'] * 0.4
+            )
+            
+            return metrics
+        except Exception as e:
+            logger.error(f"Error calculating optimization metrics: {str(e)}")
+            return {}
+
+    def _calculate_readability(self, content: str) -> float:
+        """Calculate content readability score."""
+        try:
+            # Implement readability calculation logic
+            # This is a placeholder implementation
+            return 0.8
+        except Exception as e:
+            logger.error(f"Error calculating readability: {str(e)}")
+            return 0.0
+
+    def _calculate_seo_score(self, seo_data: SEOData) -> float:
+        """Calculate SEO optimization score."""
+        try:
+            # Implement SEO score calculation logic
+            # This is a placeholder implementation
+            return 0.85
+        except Exception as e:
+            logger.error(f"Error calculating SEO score: {str(e)}")
+            return 0.0
+
+    def _calculate_keyword_density(self, seo_data: SEOData) -> float:
+        """Calculate keyword density."""
+        try:
+            # Implement keyword density calculation logic
+            # This is a placeholder implementation
+            return 2.5
+        except Exception as e:
+            logger.error(f"Error calculating keyword density: {str(e)}")
+            return 0.0
+
+    def _calculate_engagement_potential(self, engagement: Dict[str, Any]) -> float:
+        """Calculate content engagement potential."""
+        try:
+            # Implement engagement potential calculation logic
+            # This is a placeholder implementation
+            return 0.75
+        except Exception as e:
+            logger.error(f"Error calculating engagement potential: {str(e)}")
+            return 0.0
+
+    def get_optimization_history(self, content_id: str) -> List[Dict[str, Any]]:
+        """Get detailed optimization history for content."""
+        return st.session_state.optimization_history.get(content_id, [])
+
+    def get_optimization_metrics(self, content_id: str) -> List[Dict[str, Any]]:
+        """Get optimization metrics history."""
+        return st.session_state.optimization_metrics.get(content_id, [])
+
+    def save_preview(self, content_id: str, preview_data: Dict[str, Any]) -> bool:
+        """Save optimization preview with versioning."""
+        try:
+            if content_id not in st.session_state.optimization_previews:
+                st.session_state.optimization_previews[content_id] = []
+            
+            preview_data['version'] = len(st.session_state.optimization_previews[content_id]) + 1
+            preview_data['timestamp'] = datetime.now()
+            st.session_state.optimization_previews[content_id].append(preview_data)
+            return True
+        except Exception as e:
+            logger.error(f"Error saving preview: {str(e)}")
+            return False
+
+    def get_preview(self, content_id: str, version: int = None) -> Dict[str, Any]:
+        """Get optimization preview with optional versioning."""
+        try:
+            previews = st.session_state.optimization_previews.get(content_id, [])
+            if not previews:
+                return {}
+            
+            if version is None:
+                return previews[-1]
+            
+            for preview in previews:
+                if preview['version'] == version:
+                    return preview
+            
+            return {}
+        except Exception as e:
+            logger.error(f"Error getting preview: {str(e)}")
+            return {}
+
+def render_content_optimization(
+    content_generator: ContentGenerator,
+    ai_generator: AIGenerator,
+    seo_optimizer: SEOOptimizer
+):
+    """Render the content optimization interface with advanced features."""
+    st.title("Content Calendar")
+    
+    # Initialize optimization manager
+    optimization_manager = OptimizationManager()
+    
+    # Check if calendar manager is available
+    if 'calendar_manager' not in st.session_state:
+        st.error("Calendar manager not initialized. Please refresh the page.")
+        return
+
+    # Create main tabs
+    main_tabs = st.tabs(["Content Planning", "Content Optimization"])
+    
+    with main_tabs[0]:
+        # Create two columns for the layout
+        col1, col2 = st.columns([1, 1])
+        
+        with col1:
+            st.header("Quick Calendar Generation")
+            st.markdown("""
+            Generate a content calendar in three simple steps:
+            1. Enter your keywords
+            2. Select target platforms
+            3. Choose time period
+            """)
+            
+            # Step 1: Keywords Input
+            st.subheader("Step 1: Enter Keywords")
+            keywords = st.text_area(
+                "Enter keywords or topics (one per line)",
+                help="Enter the main topics or keywords you want to create content about"
+            )
+            
+            # Step 2: Platform Selection
+            st.subheader("Step 2: Select Target Platforms")
+            platform_categories = {
+                "Website": ["WEBSITE"],
+                "Social Media": ["INSTAGRAM", "FACEBOOK", "TWITTER", "LINKEDIN"],
+                "Video": ["YOUTUBE"],
+                "Newsletter": ["NEWSLETTER"]
+            }
+            
+            selected_platforms = []
+            for category, platforms in platform_categories.items():
+                st.markdown(f"**{category}**")
+                for platform in platforms:
+                    if st.checkbox(platform.replace("_", " ").title(), key=f"platform_{platform}"):
+                        selected_platforms.append(platform)
+            
+            # Step 3: Time Period
+            st.subheader("Step 3: Choose Time Period")
+            time_period = st.selectbox(
+                "Select time period",
+                ["1 Week", "2 Weeks", "1 Month", "3 Months", "6 Months"],
+                help="Choose how far ahead you want to plan your content"
+            )
+            
+            # Generate Calendar Button
+            if st.button("Generate with AI", type="primary"):
+                if not keywords or not selected_platforms:
+                    st.error("Please enter keywords and select at least one platform.")
+                else:
+                    with st.spinner("Generating content calendar..."):
+                        try:
+                            # Generate content ideas based on keywords
+                            content_ideas = []
+                            for keyword in keywords.split('\n'):
+                                if keyword.strip():
+                                    # Generate content ideas for each platform
+                                    for platform in selected_platforms:
+                                        try:
+                                            # Create a content item for the AI generator
+                                            content_item = ContentItem(
+                                                title=keyword.strip(),
+                                                description=f"Content about {keyword.strip()}",
+                                                content_type=ContentType.BLOG_POST if platform == "WEBSITE" else ContentType.SOCIAL_MEDIA,
+                                                platforms=[Platform[platform]],
+                                                publish_date=datetime.now(),
+                                                seo_data=SEOData(
+                                                    title=keyword.strip(),
+                                                    meta_description=f"Content about {keyword.strip()}",
+                                                    keywords=[keyword.strip()],
+                                                    structured_data={}
+                                                )
+                                            )
+                                            
+                                            # Generate content using AI generator
+                                            content_idea = ai_generator.enhance_content(
+                                                content=content_item,
+                                                enhancement_type='content_generation',
+                                                target_audience={
+                                                    'content_settings': {
+                                                        'tone': 'professional',
+                                                        'length': 'medium',
+                                                        'engagement_goal': 'awareness',
+                                                        'creativity_level': 5
+                                                    }
+                                                }
+                                            )
+                                            
+                                            if content_idea:
+                                                content_ideas.append({
+                                                    'title': content_idea.get('title', keyword.strip()),
+                                                    'introduction': content_idea.get('content', f"Content about {keyword.strip()}"),
+                                                    'platform': platform,
+                                                    'meta_description': content_idea.get('meta_description', ''),
+                                                    'keywords': [keyword.strip()]
+                                                })
+                                        except Exception as e:
+                                            logger.error(f"Error generating content for {keyword} on {platform}: {str(e)}")
+                                            continue
+                            
+                            if content_ideas:
+                                # Create calendar entries
+                                calendar = st.session_state.calendar_manager.get_calendar()
+                                for idea in content_ideas:
+                                    try:
+                                        # Create content item
+                                        content_item = ContentItem(
+                                            title=idea['title'],
+                                            description=idea['introduction'],
+                                            content_type=ContentType.BLOG_POST if idea['platform'] == "WEBSITE" else ContentType.SOCIAL_MEDIA,
+                                            platforms=[Platform[idea['platform']]],
+                                            publish_date=datetime.now(),
+                                            seo_data=SEOData(
+                                                title=idea['title'],
+                                                meta_description=idea.get('meta_description', ''),
+                                                keywords=idea.get('keywords', []),
+                                                structured_data={}
+                                            )
+                                        )
+                                        calendar.add_content(content_item)
+                                    except Exception as e:
+                                        logger.error(f"Error adding content to calendar: {str(e)}")
+                                        continue
+                                
+                                st.success("Content calendar generated successfully!")
+                                st.rerun()  # Refresh to show new content
+                            else:
+                                st.error("Failed to generate any content ideas. Please try different keywords or settings.")
+                        except Exception as e:
+                            logger.error(f"Error generating content calendar: {str(e)}")
+                            st.error("An error occurred while generating the content calendar. Please try again.")
+        
+        with col2:
+            st.header("Scheduled Content")
+            # Get all content from calendar
+            calendar = st.session_state.calendar_manager.get_calendar()
+            if not calendar:
+                st.info("No content scheduled yet. Generate content using the form on the left.")
+            else:
+                # Group content by platform
+                platform_content = {}
+                for item in calendar.get_all_content():
+                    platform = item.platforms[0].name if item.platforms else "Unknown"
+                    if platform not in platform_content:
+                        platform_content[platform] = []
+                    platform_content[platform].append(item)
+                
+                # Create tabs for each platform
+                platform_tabs = st.tabs(list(platform_content.keys()))
+                
+                for i, (platform, content) in enumerate(platform_content.items()):
+                    with platform_tabs[i]:
+                        st.write(f"### {platform} Content")
+                        
+                        # Convert content to DataFrame for better display
+                        content_data = []
+                        for item in content:
+                            content_data.append({
+                                'Date': item.publish_date.strftime('%Y-%m-%d'),
+                                'Title': item.title,
+                                'Type': item.content_type.name,
+                                'Status': item.status
+                            })
+                        
+                        if content_data:
+                            df = pd.DataFrame(content_data)
+                            st.dataframe(df, use_container_width=True)
+                            
+                            # Add action buttons for each content item
+                            for item in content:
+                                with st.expander(f"Actions for: {item.title}"):
+                                    col1, col2, col3 = st.columns(3)
+                                    with col1:
+                                        if st.button("Edit", key=f"edit_{item.title}"):
+                                            st.session_state.selected_content = item.title
+                                    with col2:
+                                        if st.button("Optimize", key=f"optimize_{item.title}"):
+                                            st.session_state.selected_content = item.title
+                                            st.session_state.active_tab = "Content Optimization"
+                                    with col3:
+                                        if st.button("Delete", key=f"delete_{item.title}"):
+                                            calendar.remove_content(item)
+                                            st.success(f"Removed {item.title}")
+                                            st.rerun()
+    
+    with main_tabs[1]:
+        st.header("Content Optimization")
+        # Get available content
+        calendar = st.session_state.calendar_manager.get_calendar()
+        if not calendar:
+            st.info("No content available for optimization. Use the Content Planning tab to generate content.")
+            return
+        
+        available_content = calendar.get_all_content()
+        content_options = [item.title for item in available_content]
+        
+        # Content selection
+        selected_content = st.selectbox(
+            "Select content to optimize",
+            options=content_options,
+            key="optimize_content_select"
+        )
+        
+        if selected_content:
+            try:
+                content_item = next(
+                    item for item in available_content
+                    if item.title == selected_content
+                )
+                
+                # Create tabs for different optimization aspects
+                opt_tabs = st.tabs(["Content Optimization", "SEO Optimization", "Preview", "History", "Analytics"])
+                
+                with opt_tabs[0]:
+                    st.subheader("Content Optimization")
+                    
+                    # Show onboarding info if no optimization history
+                    if not optimization_manager.get_optimization_history(content_item.title):
+                        st.info("""
+                        ### Content Optimization Guide
+                        
+                        Use these tools to enhance your content:
+                        
+                        - **Content Tone**: Adjust the writing style to match your brand voice
+                        - **Content Length**: Optimize for your target platform's requirements
+                        - **Engagement Goal**: Focus on specific audience actions
+                        - **Creativity Level**: Balance between creative and professional content
+                        
+                        Click 'Generate Optimization' to get started!
+                        """)
+                    
+                    # Advanced Optimization Settings
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        tone = st.select_slider(
+                            "Content Tone",
+                            options=["Professional", "Casual", "Educational", "Entertaining", "Persuasive"],
+                            value="Professional"
+                        )
+                        length = st.radio(
+                            "Content Length",
+                            ["Short", "Medium", "Long"],
+                            horizontal=True
+                        )
+                    with col2:
+                        engagement_goal = st.selectbox(
+                            "Engagement Goal",
+                            ["Awareness", "Consideration", "Conversion", "Retention"]
+                        )
+                        creativity_level = st.slider(
+                            "Creativity Level",
+                            min_value=1,
+                            max_value=10,
+                            value=5
+                        )
+                    
+                    if st.button("Generate Optimization", type="primary"):
+                        with st.spinner("Optimizing content..."):
+                            try:
+                                # Generate optimization
+                                optimization = content_generator.optimize_content(
+                                    content=content_item,
+                                    tone=tone,
+                                    length=length,
+                                    engagement_goal=engagement_goal,
+                                    creativity_level=creativity_level
+                                )
+                                
+                                if optimization:
+                                    st.success("Content optimized successfully!")
+                                    
+                                    # Show optimization results
+                                    st.subheader("Optimization Results")
+                                    st.write(optimization.get('content', ''))
+                                    
+                                    # Save optimization history
+                                    optimization_manager.track_optimization(
+                                        content_item.title,
+                                        {
+                                            'tone': tone,
+                                            'length': length,
+                                            'engagement_goal': engagement_goal,
+                                            'creativity_level': creativity_level,
+                                            'content': optimization.get('content', ''),
+                                            'timestamp': datetime.now()
+                                        }
+                                    )
+                                else:
+                                    st.error("Failed to optimize content. Please try again.")
+                            except Exception as e:
+                                logger.error(f"Error optimizing content: {str(e)}")
+                                st.error("An error occurred while optimizing content. Please try again.")
+                
+                with opt_tabs[1]:
+                    st.subheader("SEO Optimization")
+                    # SEO optimization content here
+                
+                with opt_tabs[2]:
+                    st.subheader("Content Preview")
+                    # Content preview here
+                
+                with opt_tabs[3]:
+                    st.subheader("Optimization History")
+                    # Optimization history here
+                
+                with opt_tabs[4]:
+                    st.subheader("Performance Analytics")
+                    # Analytics content here
+                    
+            except Exception as e:
+                logger.error(f"Error processing selected content: {str(e)}")
+                st.error("Error processing selected content. Please try again.")
+
+# Remove everything after this point 

lib/content_calendar/ui/components/content_repurposing_ui.py

@@ -0,0 +1,517 @@
+import streamlit as st
+import pandas as pd
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+import logging
+from pathlib import Path
+import sys
+
+# Add parent directory to path to import existing tools
+parent_dir = str(Path(__file__).parent.parent.parent.parent.parent)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+from lib.database.models import ContentItem, ContentType, Platform, SEOData
+from lib.ai_seo_tools.content_calendar.core.content_repurposer import SmartContentRepurposingEngine
+from lib.ai_seo_tools.content_calendar.core.content_generator import ContentGenerator
+
+logger = logging.getLogger(__name__)
+
+class ContentRepurposingUI:
+    """
+    Streamlit UI component for the Smart Content Repurposing Engine.
+    """
+    
+    def __init__(self):
+        self.repurposing_engine = SmartContentRepurposingEngine()
+        self.content_generator = ContentGenerator()
+        self.logger = logging.getLogger('content_calendar.repurposing_ui')
+    
+    def render_repurposing_interface(self):
+        """Render the main repurposing interface."""
+        st.header("🔄 Smart Content Repurposing Engine")
+        st.markdown("Transform your content into multiple platform-optimized pieces with AI-powered repurposing.")
+        
+        # Create tabs for different repurposing functions
+        tab1, tab2, tab3, tab4 = st.tabs([
+            "📝 Single Content Repurposing",
+            "📚 Content Series Creation", 
+            "🔍 Content Analysis",
+            "📊 Repurposing Dashboard"
+        ])
+        
+        with tab1:
+            self._render_single_content_repurposing()
+        
+        with tab2:
+            self._render_content_series_creation()
+        
+        with tab3:
+            self._render_content_analysis()
+        
+        with tab4:
+            self._render_repurposing_dashboard()
+    
+    def _render_single_content_repurposing(self):
+        """Render the single content repurposing interface."""
+        st.subheader("Repurpose Single Content")
+        st.markdown("Transform one piece of content into multiple platform-optimized variations.")
+        
+        # Content input section
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            st.markdown("### 📄 Source Content")
+            
+            # Content input options
+            input_method = st.radio(
+                "How would you like to provide content?",
+                ["Manual Input", "Upload File", "Select from Calendar"],
+                horizontal=True
+            )
+            
+            source_content = None
+            
+            if input_method == "Manual Input":
+                source_content = self._render_manual_content_input()
+            elif input_method == "Upload File":
+                source_content = self._render_file_upload_input()
+            else:  # Select from Calendar
+                source_content = self._render_calendar_selection()
+        
+        with col2:
+            st.markdown("### 🎯 Target Platforms")
+            
+            # Platform selection
+            available_platforms = [
+                Platform.TWITTER,
+                Platform.LINKEDIN,
+                Platform.INSTAGRAM,
+                Platform.FACEBOOK,
+                Platform.WEBSITE
+            ]
+            
+            selected_platforms = st.multiselect(
+                "Select target platforms:",
+                options=available_platforms,
+                default=[Platform.TWITTER, Platform.LINKEDIN],
+                format_func=lambda x: x.name.title()
+            )
+            
+            # Repurposing strategy
+            strategy = st.selectbox(
+                "Repurposing Strategy:",
+                ["adaptive", "atomic", "series"],
+                help="Adaptive: AI chooses best approach, Atomic: Break into small pieces, Series: Create connected content"
+            )
+        
+        # Generate repurposed content
+        if st.button("🚀 Generate Repurposed Content", type="primary"):
+            if source_content and selected_platforms:
+                with st.spinner("Repurposing content..."):
+                    try:
+                        repurposed_content = self.content_generator.repurpose_content_for_platforms(
+                            content_item=source_content,
+                            target_platforms=selected_platforms,
+                            strategy=strategy
+                        )
+                        
+                        if repurposed_content:
+                            self._display_repurposed_content(repurposed_content)
+                        else:
+                            st.error("Failed to generate repurposed content. Please try again.")
+                    
+                    except Exception as e:
+                        st.error(f"Error during repurposing: {str(e)}")
+            else:
+                st.warning("Please provide source content and select at least one target platform.")
+    
+    def _render_content_series_creation(self):
+        """Render the content series creation interface."""
+        st.subheader("Create Cross-Platform Content Series")
+        st.markdown("Generate a strategic content series that progressively reveals information across platforms.")
+        
+        # Source content input
+        source_content = self._render_manual_content_input(key_suffix="_series")
+        
+        if source_content:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown("### 🌐 Platform Strategy")
+                
+                # Platform selection with strategy
+                platforms = st.multiselect(
+                    "Select platforms for series:",
+                    options=[Platform.TWITTER, Platform.LINKEDIN, Platform.INSTAGRAM, Platform.FACEBOOK, Platform.WEBSITE],
+                    default=[Platform.TWITTER, Platform.LINKEDIN, Platform.WEBSITE],
+                    format_func=lambda x: x.name.title(),
+                    key="series_platforms"
+                )
+                
+                series_type = st.selectbox(
+                    "Series Strategy:",
+                    ["progressive_disclosure", "platform_native"],
+                    help="Progressive: Gradually reveal info across platforms, Native: Optimize for each platform's strengths"
+                )
+            
+            with col2:
+                st.markdown("### 📅 Timeline Preview")
+                
+                if platforms:
+                    # Show timeline preview
+                    timeline_df = self._create_series_timeline_preview(source_content, platforms)
+                    st.dataframe(timeline_df, use_container_width=True)
+            
+            # Generate series
+            if st.button("📚 Create Content Series", type="primary", key="create_series"):
+                if platforms:
+                    with st.spinner("Creating content series..."):
+                        try:
+                            series_content = self.content_generator.create_content_series_across_platforms(
+                                source_content=source_content,
+                                platforms=platforms,
+                                series_type=series_type
+                            )
+                            
+                            if series_content:
+                                self._display_content_series(series_content)
+                            else:
+                                st.error("Failed to create content series. Please try again.")
+                        
+                        except Exception as e:
+                            st.error(f"Error creating series: {str(e)}")
+                else:
+                    st.warning("Please select at least one platform for the series.")
+    
+    def _render_content_analysis(self):
+        """Render the content analysis interface."""
+        st.subheader("Content Repurposing Analysis")
+        st.markdown("Analyze your content's repurposing potential and get AI-powered recommendations.")
+        
+        # Content input
+        content_to_analyze = self._render_manual_content_input(key_suffix="_analysis")
+        
+        if content_to_analyze:
+            col1, col2 = st.columns([1, 1])
+            
+            with col1:
+                available_platforms = st.multiselect(
+                    "Available platforms for analysis:",
+                    options=[Platform.TWITTER, Platform.LINKEDIN, Platform.INSTAGRAM, Platform.FACEBOOK, Platform.WEBSITE],
+                    default=[Platform.TWITTER, Platform.LINKEDIN, Platform.INSTAGRAM, Platform.FACEBOOK, Platform.WEBSITE],
+                    format_func=lambda x: x.name.title(),
+                    key="analysis_platforms"
+                )
+            
+            with col2:
+                if st.button("🔍 Analyze Content", type="primary"):
+                    if available_platforms:
+                        with st.spinner("Analyzing content..."):
+                            try:
+                                analysis = self.content_generator.analyze_content_for_repurposing(
+                                    content_item=content_to_analyze,
+                                    available_platforms=available_platforms
+                                )
+                                
+                                if analysis:
+                                    self._display_content_analysis(analysis)
+                                else:
+                                    st.error("Failed to analyze content. Please try again.")
+                            
+                            except Exception as e:
+                                st.error(f"Error during analysis: {str(e)}")
+                    else:
+                        st.warning("Please select at least one platform for analysis.")
+    
+    def _render_repurposing_dashboard(self):
+        """Render the repurposing dashboard with metrics and insights."""
+        st.subheader("Repurposing Dashboard")
+        st.markdown("Track your content repurposing performance and insights.")
+        
+        # Mock data for demonstration
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.metric("Content Pieces Created", "156", "+23")
+        
+        with col2:
+            st.metric("Time Saved", "312 hours", "+45 hours")
+        
+        with col3:
+            st.metric("Platform Coverage", "85%", "+12%")
+        
+        with col4:
+            st.metric("Engagement Boost", "34%", "+8%")
+        
+        # Recent repurposing activity
+        st.markdown("### 📈 Recent Repurposing Activity")
+        
+        # Mock data for recent activity
+        recent_activity = pd.DataFrame({
+            'Date': ['2024-01-15', '2024-01-14', '2024-01-13', '2024-01-12'],
+            'Source Content': ['AI Writing Tips', 'SEO Best Practices', 'Content Strategy Guide', 'Social Media Trends'],
+            'Platforms': ['Twitter, LinkedIn', 'LinkedIn, Instagram', 'All Platforms', 'Twitter, Facebook'],
+            'Pieces Created': [3, 2, 5, 2],
+            'Status': ['Published', 'Scheduled', 'Draft', 'Published']
+        })
+        
+        st.dataframe(recent_activity, use_container_width=True)
+        
+        # Performance insights
+        st.markdown("### 💡 Performance Insights")
+        
+        insights_col1, insights_col2 = st.columns(2)
+        
+        with insights_col1:
+            st.info("🎯 **Best Performing Platform**: LinkedIn posts show 45% higher engagement when repurposed from blog content.")
+        
+        with insights_col2:
+            st.success("📊 **Optimization Tip**: Twitter threads perform 60% better when created from long-form content with statistics.")
+    
+    def _render_manual_content_input(self, key_suffix: str = "") -> Optional[ContentItem]:
+        """Render manual content input form."""
+        with st.form(f"content_input_form{key_suffix}"):
+            title = st.text_input("Content Title:", key=f"title{key_suffix}")
+            content_type = st.selectbox(
+                "Content Type:",
+                options=[ContentType.BLOG_POST, ContentType.SOCIAL_MEDIA, ContentType.VIDEO, ContentType.NEWSLETTER],
+                format_func=lambda x: x.name.replace('_', ' ').title(),
+                key=f"content_type{key_suffix}"
+            )
+            
+            description = st.text_area(
+                "Content Description/Body:",
+                height=200,
+                help="Paste your content here. This will be analyzed and repurposed.",
+                key=f"description{key_suffix}"
+            )
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                author = st.text_input("Author:", value="Content Creator", key=f"author{key_suffix}")
+            with col2:
+                tags = st.text_input("Tags (comma-separated):", key=f"tags{key_suffix}")
+            
+            submitted = st.form_submit_button("📝 Use This Content")
+            
+            if submitted and title and description:
+                # Create ContentItem
+                content_item = ContentItem(
+                    title=title,
+                    description=description,
+                    content_type=content_type,
+                    platforms=[],
+                    publish_date=datetime.now(),
+                    status="draft",
+                    author=author,
+                    tags=tags.split(',') if tags else [],
+                    notes="",
+                    seo_data=SEOData(title=title, meta_description="", keywords=[], structured_data={})
+                )
+                return content_item
+        
+        return None
+    
+    def _render_file_upload_input(self) -> Optional[ContentItem]:
+        """Render file upload input."""
+        uploaded_file = st.file_uploader(
+            "Upload content file:",
+            type=['txt', 'md', 'docx'],
+            help="Upload a text file, markdown file, or Word document"
+        )
+        
+        if uploaded_file:
+            try:
+                # Read file content
+                if uploaded_file.type == "text/plain":
+                    content = str(uploaded_file.read(), "utf-8")
+                else:
+                    content = str(uploaded_file.read(), "utf-8")  # Simplified for demo
+                
+                # Extract title from filename
+                title = uploaded_file.name.split('.')[0].replace('_', ' ').title()
+                
+                # Create ContentItem
+                content_item = ContentItem(
+                    title=title,
+                    description=content,
+                    content_type=ContentType.BLOG_POST,
+                    platforms=[],
+                    publish_date=datetime.now(),
+                    status="draft",
+                    author="Uploaded Content",
+                    tags=[],
+                    notes=f"Uploaded from file: {uploaded_file.name}",
+                    seo_data=SEOData(title=title, meta_description="", keywords=[], structured_data={})
+                )
+                
+                st.success(f"✅ File uploaded: {uploaded_file.name}")
+                return content_item
+                
+            except Exception as e:
+                st.error(f"Error reading file: {str(e)}")
+        
+        return None
+    
+    def _render_calendar_selection(self) -> Optional[ContentItem]:
+        """Render calendar content selection."""
+        st.info("📅 Calendar integration coming soon! For now, please use manual input or file upload.")
+        return None
+    
+    def _display_repurposed_content(self, repurposed_content: List[ContentItem]):
+        """Display the repurposed content results."""
+        st.success(f"✅ Successfully created {len(repurposed_content)} repurposed content pieces!")
+        
+        for i, content in enumerate(repurposed_content):
+            with st.expander(f"📱 {content.platforms[0].name.title()} - {content.title}"):
+                st.markdown(f"**Platform:** {content.platforms[0].name.title()}")
+                st.markdown(f"**Content Type:** {content.content_type.name.replace('_', ' ').title()}")
+                st.markdown(f"**Scheduled for:** {content.publish_date.strftime('%Y-%m-%d')}")
+                
+                st.markdown("**Content:**")
+                st.write(content.description)
+                
+                if content.tags:
+                    st.markdown(f"**Tags:** {', '.join(content.tags)}")
+                
+                # Action buttons
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    if st.button(f"📝 Edit", key=f"edit_{i}"):
+                        st.info("Edit functionality coming soon!")
+                with col2:
+                    if st.button(f"📅 Schedule", key=f"schedule_{i}"):
+                        st.info("Scheduling functionality coming soon!")
+                with col3:
+                    if st.button(f"📋 Copy", key=f"copy_{i}"):
+                        st.code(content.description)
+    
+    def _display_content_series(self, series_content: Dict[str, List[ContentItem]]):
+        """Display the content series results."""
+        total_pieces = sum(len(pieces) for pieces in series_content.values())
+        st.success(f"✅ Successfully created content series with {total_pieces} pieces across {len(series_content)} platforms!")
+        
+        for platform, content_pieces in series_content.items():
+            st.markdown(f"### 📱 {platform.title()} Series ({len(content_pieces)} pieces)")
+            
+            for i, content in enumerate(content_pieces):
+                with st.expander(f"Part {i+1}: {content.title}"):
+                    st.markdown(f"**Scheduled for:** {content.publish_date.strftime('%Y-%m-%d')}")
+                    st.markdown("**Content:**")
+                    st.write(content.description)
+                    
+                    if content.tags:
+                        st.markdown(f"**Tags:** {', '.join(content.tags)}")
+    
+    def _display_content_analysis(self, analysis: Dict[str, Any]):
+        """Display content analysis results."""
+        st.markdown("### 📊 Content Analysis Results")
+        
+        # Content metrics
+        col1, col2, col3 = st.columns(3)
+        
+        content_analysis = analysis.get('content_analysis', {})
+        
+        with col1:
+            st.metric("Word Count", content_analysis.get('word_count', 0))
+        
+        with col2:
+            richness = content_analysis.get('content_richness', 'Unknown')
+            st.metric("Content Richness", richness)
+        
+        with col3:
+            potential = content_analysis.get('repurposing_potential', 'Unknown')
+            st.metric("Repurposing Potential", potential)
+        
+        # Recommendations
+        st.markdown("### 💡 Recommendations")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("**Recommended Platforms:**")
+            platforms = analysis.get('platform_suggestions', [])
+            for platform in platforms:
+                st.write(f"• {platform.name.title()}")
+        
+        with col2:
+            st.markdown("**Suggested Strategies:**")
+            strategies = analysis.get('strategy_suggestions', [])
+            for strategy in strategies:
+                st.write(f"• {strategy.replace('_', ' ').title()}")
+        
+        # Content atoms
+        st.markdown("### 🔬 Content Atoms Analysis")
+        
+        atoms = content_analysis.get('content_atoms', {})
+        
+        for atom_type, atom_list in atoms.items():
+            if atom_list:
+                with st.expander(f"{atom_type.title()} ({len(atom_list)} found)"):
+                    for atom in atom_list:
+                        st.write(f"• {atom}")
+        
+        # Estimated output
+        estimated = analysis.get('estimated_output', {})
+        if estimated:
+            st.markdown("### 📈 Estimated Output")
+            
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                st.metric("Total Pieces", estimated.get('total_pieces', 0))
+            
+            with col2:
+                st.metric("Time Savings", estimated.get('time_savings', '0 hours'))
+            
+            with col3:
+                st.metric("Content Multiplication", estimated.get('content_multiplication', '1x'))
+    
+    def _create_series_timeline_preview(self, content: ContentItem, platforms: List[Platform]) -> pd.DataFrame:
+        """Create a preview timeline for content series."""
+        timeline_data = []
+        base_date = datetime.now()
+        
+        for i, platform in enumerate(platforms):
+            release_date = base_date + timedelta(days=i)
+            timeline_data.append({
+                'Platform': platform.name.title(),
+                'Release Date': release_date.strftime('%Y-%m-%d'),
+                'Content Type': self._get_platform_content_type(platform),
+                'Strategy': self._get_platform_strategy(platform)
+            })
+        
+        return pd.DataFrame(timeline_data)
+    
+    def _get_platform_content_type(self, platform: Platform) -> str:
+        """Get content type for platform."""
+        types = {
+            Platform.TWITTER: "Thread/Tweet",
+            Platform.LINKEDIN: "Professional Post",
+            Platform.INSTAGRAM: "Visual Post",
+            Platform.FACEBOOK: "Engaging Post",
+            Platform.WEBSITE: "Blog Article"
+        }
+        return types.get(platform, "Standard Post")
+    
+    def _get_platform_strategy(self, platform: Platform) -> str:
+        """Get strategy for platform."""
+        strategies = {
+            Platform.TWITTER: "Hook & Engage",
+            Platform.LINKEDIN: "Authority Building",
+            Platform.INSTAGRAM: "Visual Storytelling",
+            Platform.FACEBOOK: "Community Discussion",
+            Platform.WEBSITE: "Complete Information"
+        }
+        return strategies.get(platform, "Standard Approach")
+
+# Main function to render the UI
+def render_content_repurposing_ui():
+    """Main function to render the content repurposing UI."""
+    ui = ContentRepurposingUI()
+    ui.render_repurposing_interface()
+
+# For testing
+if __name__ == "__main__":
+    render_content_repurposing_ui() 

lib/content_calendar/ui/components/content_series.py

@@ -0,0 +1,457 @@
+import streamlit as st
+from typing import Dict, Any, List
+from datetime import datetime, timedelta
+import pandas as pd
+from lib.ai_seo_tools.content_calendar.core.content_generator import ContentGenerator
+from lib.ai_seo_tools.content_calendar.core.ai_generator import AIGenerator
+from lib.ai_seo_tools.content_calendar.integrations.seo_optimizer import SEOOptimizer
+from lib.database.models import ContentItem, ContentType, Platform, SEOData
+import logging
+
+logger = logging.getLogger('content_calendar.series')
+
+class SeriesManager:
+    def __init__(self):
+        self.series_data = {}
+        if 'content_series' not in st.session_state:
+            st.session_state.content_series = {}
+        if 'series_relationships' not in st.session_state:
+            st.session_state.series_relationships = {}
+        if 'series_performance' not in st.session_state:
+            st.session_state.series_performance = {}
+
+    def create_series(self, series_id: str, topic: str, num_pieces: int, content_type: ContentType, 
+                     platforms: List[Platform], schedule_strategy: str = 'linear', series_type: str = '', series_flow: str = '', metadata: Dict[str, Any] = {}) -> Dict[str, Any]:
+        """Create a new content series with tracking and scheduling."""
+        try:
+            series = {
+                'id': series_id,
+                'topic': topic,
+                'num_pieces': num_pieces,
+                'content_type': content_type,
+                'platforms': platforms,
+                'schedule_strategy': schedule_strategy,
+                'series_type': series_type,
+                'series_flow': series_flow,
+                'pieces': [],
+                'performance': {},
+                'created_at': datetime.now(),
+                'status': 'draft',
+                'relationships': {},
+                'platform_distribution': {p.name: [] for p in platforms},
+                'metadata': metadata
+            }
+            st.session_state.content_series[series_id] = series
+            return series
+        except Exception as e:
+            logger.error(f"Error creating series: {str(e)}")
+            return None
+
+    def add_piece(self, series_id: str, piece: Dict[str, Any]) -> bool:
+        """Add a content piece to the series with relationship tracking."""
+        try:
+            if series_id in st.session_state.content_series:
+                series = st.session_state.content_series[series_id]
+                piece_id = f"piece_{len(series['pieces'])}"
+                
+                # Create a structured piece object
+                structured_piece = {
+                    'id': piece_id,
+                    'title': piece.get('title', f"Part {len(series['pieces']) + 1}"),
+                    'content': piece.get('content', ''),
+                    'platform': piece.get('platform', series['platforms'][0]),
+                    'scheduled_date': None,
+                    'status': 'draft',
+                    'relationships': {
+                        'previous': None,
+                        'next': None
+                    },
+                    'performance': {
+                        'engagement': 0,
+                        'reach': 0,
+                        'conversion_rate': 0
+                    }
+                }
+                
+                # Track relationships
+                if series['pieces']:
+                    previous_piece = series['pieces'][-1]
+                    structured_piece['relationships']['previous'] = previous_piece['id']
+                    structured_piece['relationships']['next'] = piece_id
+                
+                # Add to platform distribution
+                platform_name = structured_piece['platform'].name
+                if platform_name in series['platform_distribution']:
+                    series['platform_distribution'][platform_name].append(piece_id)
+                
+                series['pieces'].append(structured_piece)
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"Error adding piece to series: {str(e)}")
+            return False
+
+    def get_series_performance(self, series_id: str) -> Dict[str, Any]:
+        """Get comprehensive performance analytics for a series."""
+        try:
+            if series_id in st.session_state.content_series:
+                series = st.session_state.content_series[series_id]
+                performance = {
+                    'overall': {
+                        'total_engagement': 0,
+                        'total_reach': 0,
+                        'conversion_rate': 0,
+                        'average_engagement': 0
+                    },
+                    'platforms': {},
+                    'pieces': {},
+                    'trends': {
+                        'engagement': [],
+                        'reach': [],
+                        'conversions': []
+                    }
+                }
+                
+                # Calculate overall metrics
+                for piece in series['pieces']:
+                    piece_performance = piece.get('performance', {})
+                    performance['overall']['total_engagement'] += piece_performance.get('engagement', 0)
+                    performance['overall']['total_reach'] += piece_performance.get('reach', 0)
+                    performance['overall']['conversion_rate'] += piece_performance.get('conversion_rate', 0)
+                    
+                    # Track piece-specific performance
+                    performance['pieces'][piece['id']] = piece_performance
+                    
+                    # Track trends
+                    performance['trends']['engagement'].append(piece_performance.get('engagement', 0))
+                    performance['trends']['reach'].append(piece_performance.get('reach', 0))
+                    performance['trends']['conversions'].append(piece_performance.get('conversion_rate', 0))
+                
+                # Calculate averages
+                num_pieces = len(series['pieces'])
+                if num_pieces > 0:
+                    performance['overall']['average_engagement'] = performance['overall']['total_engagement'] / num_pieces
+                    performance['overall']['conversion_rate'] = performance['overall']['conversion_rate'] / num_pieces
+                
+                # Calculate platform-specific performance
+                for platform in series['platforms']:
+                    platform_pieces = series['platform_distribution'].get(platform.name, [])
+                    platform_performance = {
+                        'engagement': 0,
+                        'reach': 0,
+                        'conversion_rate': 0
+                    }
+                    
+                    for piece_id in platform_pieces:
+                        piece_performance = performance['pieces'].get(piece_id, {})
+                        platform_performance['engagement'] += piece_performance.get('engagement', 0)
+                        platform_performance['reach'] += piece_performance.get('reach', 0)
+                        platform_performance['conversion_rate'] += piece_performance.get('conversion_rate', 0)
+                    
+                    if platform_pieces:
+                        platform_performance['engagement'] /= len(platform_pieces)
+                        platform_performance['conversion_rate'] /= len(platform_pieces)
+                    
+                    performance['platforms'][platform.name] = platform_performance
+                
+                return performance
+            return {}
+        except Exception as e:
+            logger.error(f"Error getting series performance: {str(e)}")
+            return {}
+
+    def update_series_status(self, series_id: str, status: str) -> bool:
+        """Update the status of a series."""
+        try:
+            if series_id in st.session_state.content_series:
+                st.session_state.content_series[series_id]['status'] = status
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"Error updating series status: {str(e)}")
+            return False
+
+    def schedule_series(self, series_id: str, start_date: datetime, interval: int = 7) -> bool:
+        """Schedule the series content with flexible scheduling strategies."""
+        try:
+            if series_id in st.session_state.content_series:
+                series = st.session_state.content_series[series_id]
+                current_date = start_date
+                
+                for piece in series['pieces']:
+                    piece['scheduled_date'] = current_date
+                    if series['schedule_strategy'] == 'linear':
+                        current_date += timedelta(days=interval)
+                    elif series['schedule_strategy'] == 'burst':
+                        current_date += timedelta(days=1)
+                    elif series['schedule_strategy'] == 'custom':
+                        # Custom scheduling is handled by the UI
+                        pass
+                
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"Error scheduling series: {str(e)}")
+            return False
+
+def render_content_series_generator(
+    ai_generator: AIGenerator,
+    content_generator: ContentGenerator,
+    seo_optimizer: SEOOptimizer
+):
+    """Render the content series generator interface."""
+    st.header("Content Series Generator")
+    
+    # Check if calendar manager is available
+    if 'calendar_manager' not in st.session_state:
+        st.error("Calendar manager not initialized. Please refresh the page.")
+        return
+    
+    # Get available content
+    try:
+        available_content = st.session_state.calendar_manager.get_calendar().get_all_content()
+        content_options = [item.title for item in available_content]
+    except Exception as e:
+        logger.error(f"Error getting content options: {str(e)}")
+        st.error("Error loading content. Please try again.")
+        return
+    
+    if not content_options:
+        st.info("""
+        ## Welcome to Content Series Generator! 📚
+        
+        Create and manage content series across multiple platforms. Here's what you can do:
+        
+        ### Features:
+        - 📝 **Series Creation**: Generate connected content pieces
+        - 🔄 **Cross-Platform Distribution**: Optimize for different platforms
+        - 📊 **Series Analytics**: Track performance across the series
+        - 📅 **Smart Scheduling**: Plan content distribution
+        
+        ### Getting Started:
+        1. First, add some content to your calendar
+        2. Select a topic for your content series
+        3. Configure series parameters and platforms
+        4. Generate and schedule your series
+        
+        Ready to get started? Add some content to your calendar first!
+        """)
+        return
+    
+    # Series Configuration
+    st.subheader("Create New Content Series")
+    
+    # Show onboarding info if no series exist
+    if not st.session_state.get('content_series', {}):
+        st.info("""
+        ### Content Series Guide
+        
+        Create engaging content series with these features:
+        
+        - **Series Planning**: Define your series structure and goals
+        - **Content Generation**: Create connected content pieces
+        - **Platform Optimization**: Adapt content for each platform
+        - **Performance Tracking**: Monitor series success
+        
+        Fill out the form below to create your first series!
+        """)
+    
+    # Initialize series manager
+    series_manager = SeriesManager()
+    
+    # Series Creation Form
+    with st.form("series_creation_form"):
+        st.subheader("Create New Series")
+        series_topic = st.text_input("Series Topic")
+        num_pieces = st.slider("Number of pieces", 2, 10, 3)
+        content_type = st.selectbox(
+            "Content Type",
+            options=[ct.name for ct in ContentType],
+            key="series_content_type"
+        )
+        
+        # Multi-platform selection
+        platforms = st.multiselect(
+            "Target Platforms",
+            options=[p.name for p in Platform],
+            default=['WEBSITE'],
+            key="series_platforms"
+        )
+        
+        # Schedule strategy
+        schedule_strategy = st.selectbox(
+            "Schedule Strategy",
+            options=['linear', 'burst', 'custom'],
+            help="Linear: Evenly spaced, Burst: Grouped together, Custom: Manual scheduling"
+        )
+        
+        # Series metadata
+        with st.expander("Series Metadata"):
+            target_audience = st.text_area("Target Audience")
+            series_goals = st.multiselect(
+                "Series Goals",
+                options=['Awareness', 'Engagement', 'Conversion', 'Education'],
+                default=['Awareness']
+            )
+            series_tone = st.select_slider(
+                "Series Tone",
+                options=['Professional', 'Casual', 'Friendly', 'Authoritative', 'Conversational'],
+                value='Professional'
+            )
+        
+        submitted = st.form_submit_button("Generate Series")
+        
+        if submitted and series_topic:
+            with st.spinner("Generating content series..."):
+                try:
+                    # Create series
+                    series_id = f"series_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+                    
+                    # Prepare metadata with default values
+                    metadata = {
+                        'tone': series_tone,
+                        'length': 'medium',  # Default length
+                        'engagement_goal': series_goals[0] if series_goals else 'Awareness',
+                        'creativity_level': 'balanced'  # Default creativity level
+                    }
+                    
+                    series = series_manager.create_series(
+                        series_id=series_id,
+                        topic=series_topic,
+                        num_pieces=num_pieces,
+                        content_type=ContentType[content_type],
+                        platforms=[Platform[p] for p in platforms],
+                        schedule_strategy=schedule_strategy,
+                        series_type=series_goals[0] if series_goals else 'Awareness',
+                        series_flow='sequential',  # Default flow
+                        metadata=metadata
+                    )
+                    
+                    if series:
+                        # Generate series content
+                        series_content = content_generator.generate_content(
+                            content_type=ContentType[content_type],
+                            topic=series_topic,
+                            platforms=[Platform[p] for p in platforms],
+                            num_pieces=num_pieces,
+                            requirements={
+                                'tone': series_tone,
+                                'length': metadata['length'],
+                                'engagement_goal': metadata['engagement_goal'],
+                                'creativity_level': metadata['creativity_level'],
+                                'series_type': metadata['engagement_goal'],
+                                'series_flow': 'sequential',
+                                'target_audience': target_audience
+                            }
+                        )
+                        
+                        if series_content:
+                            # Add content pieces to series
+                            for piece in series_content:
+                                series_manager.add_piece(
+                                    series_id=series['id'],
+                                    piece=piece
+                                )
+                            
+                            # Schedule series
+                            if schedule_strategy == 'linear':
+                                start_date = st.date_input("Start Date", datetime.now())
+                                interval = st.number_input("Days between pieces", min_value=1, value=7)
+                                series_manager.schedule_series(
+                                    series_id=series['id'],
+                                    start_date=start_date,
+                                    interval_days=interval
+                                )
+                            elif schedule_strategy == 'burst':
+                                start_date = st.date_input("Start Date", datetime.now())
+                                burst_size = st.number_input("Burst Size", min_value=1, value=1)
+                                series_manager.schedule_series(
+                                    series_id=series['id'],
+                                    start_date=start_date,
+                                    interval_days=1,
+                                    burst_size=burst_size
+                                )
+                            else:  # custom
+                                for i, piece in enumerate(series_manager.series_data[series['id']]['pieces']):
+                                    piece['scheduled_date'] = st.date_input(
+                                        f"Publish Date for Part {i+1}",
+                                        datetime.now() + timedelta(days=i*7)
+                                    )
+                                
+                                if st.button("Save Schedule"):
+                                    st.success("Series schedule saved!")
+                            
+                            st.success(f"Generated {num_pieces} content pieces for series!")
+                            
+                            # Display series preview
+                            with st.expander("Series Preview", expanded=True):
+                                for piece in series_manager.series_data[series_id]['pieces']:
+                                    st.markdown(f"### Part {piece['part_number']}")
+                                    st.json(piece['content'])
+                                    
+                                    # Platform-specific previews
+                                    st.markdown("#### Platform Previews")
+                                    for platform in platforms:
+                                        with st.expander(f"{platform} Preview"):
+                                            st.write(piece['content'].get('platform_previews', {}).get(platform, 'No preview available'))
+                            
+                            # Series performance tracking
+                            st.subheader("Series Performance")
+                            performance_data = series_manager.get_series_performance(series_id)
+                            if performance_data:
+                                st.write("### Overall Performance")
+                                col1, col2, col3 = st.columns(3)
+                                with col1:
+                                    st.metric("Total Engagement", f"{performance_data['overall']['total_engagement']:.1f}%")
+                                with col2:
+                                    st.metric("Total Reach", f"{performance_data['overall']['total_reach']:,}")
+                                with col3:
+                                    st.metric("Conversion Rate", f"{performance_data['overall']['conversion_rate']:.1f}%")
+                                
+                                # Platform-specific performance
+                                st.write("### Platform Performance")
+                                for platform in platforms:
+                                    with st.expander(f"{platform} Performance"):
+                                        platform_data = performance_data['platforms'].get(platform, {})
+                                        st.write(f"Engagement: {platform_data.get('engagement', 0):.1f}%")
+                                        st.write(f"Reach: {platform_data.get('reach', 0):,}")
+                                        st.write(f"Conversions: {platform_data.get('conversion_rate', 0):.1f}%")
+                                
+                                # Performance trends
+                                st.write("### Performance Trends")
+                                trend_data = performance_data['trends']
+                                st.line_chart(pd.DataFrame({
+                                    'Engagement': trend_data['engagement'],
+                                    'Reach': trend_data['reach'],
+                                    'Conversions': trend_data['conversions']
+                                }))
+                        
+                except Exception as e:
+                    logger.error(f"Error generating series: {str(e)}", exc_info=True)
+                    st.error(f"Error generating series: {str(e)}")
+
+    # Display existing series
+    if st.session_state.content_series:
+        st.subheader("Existing Series")
+        for series_id, series in st.session_state.content_series.items():
+            with st.expander(f"Series: {series['topic']}"):
+                st.write(f"Status: {series['status']}")
+                st.write(f"Pieces: {len(series['pieces'])}")
+                st.write(f"Created: {series['created_at']}")
+                
+                # Series actions
+                if st.button(f"View Details", key=f"view_{series_id}"):
+                    st.session_state.selected_series = series_id
+                
+                if st.button(f"Delete Series", key=f"delete_{series_id}"):
+                    del st.session_state.content_series[series_id]
+                    st.rerun()
+
+def on_series_complete():
+    """Handle series completion."""
+    try:
+        st.session_state.series_complete = True
+        st.rerun()
+    except Exception as e:
+        logger.error(f"Error handling series completion: {str(e)}")
+        st.error("An error occurred while completing the series. Please try again.") 

lib/content_calendar/ui/components/performance_insights.py

@@ -0,0 +1,81 @@
+import streamlit as st
+from typing import Dict, Any
+from lib.database.models import ContentItem
+import logging
+
+logger = logging.getLogger(__name__)
+
+def render_performance_insights(content_item: ContentItem, platform_adapter) -> None:
+    """Render performance insights for a content item."""
+    try:
+        logger.info(f"Rendering performance insights for: {content_item.title}")
+        
+        # Get performance data from platform adapter
+        performance_data = platform_adapter.get_content_performance(content_item)
+        
+        if not performance_data:
+            st.warning("No performance data available for this content")
+            return
+        
+        # Create metrics section
+        st.subheader("Performance Metrics")
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric(
+                "Engagement Rate",
+                f"{performance_data.get('engagement_rate', 0):.1f}%",
+                f"{performance_data.get('engagement_rate_change', 0):+.1f}%"
+            )
+        
+        with col2:
+            st.metric(
+                "Reach",
+                f"{performance_data.get('reach', 0):,}",
+                f"{performance_data.get('reach_change', 0):+,}"
+            )
+        
+        with col3:
+            st.metric(
+                "Conversion Rate",
+                f"{performance_data.get('conversion_rate', 0):.1f}%",
+                f"{performance_data.get('conversion_rate_change', 0):+.1f}%"
+            )
+        
+        # Create audience insights section
+        st.subheader("Audience Insights")
+        audience_data = performance_data.get('audience_insights', {})
+        
+        if audience_data:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.write("Demographics")
+                st.write(f"- Age: {audience_data.get('age_range', 'N/A')}")
+                st.write(f"- Gender: {audience_data.get('gender', 'N/A')}")
+                st.write(f"- Location: {audience_data.get('location', 'N/A')}")
+            
+            with col2:
+                st.write("Behavior")
+                st.write(f"- Peak Time: {audience_data.get('peak_time', 'N/A')}")
+                st.write(f"- Device: {audience_data.get('device', 'N/A')}")
+                st.write(f"- Platform: {audience_data.get('platform', 'N/A')}")
+        
+        # Create content insights section
+        st.subheader("Content Insights")
+        content_insights = performance_data.get('content_insights', {})
+        
+        if content_insights:
+            st.write("Top Performing Elements")
+            for element, score in content_insights.get('top_elements', {}).items():
+                st.write(f"- {element}: {score}")
+            
+            st.write("Improvement Suggestions")
+            for suggestion in content_insights.get('suggestions', []):
+                st.write(f"- {suggestion}")
+        
+        logger.info(f"Performance insights rendered successfully for: {content_item.title}")
+        
+    except Exception as e:
+        logger.error(f"Error rendering performance insights: {str(e)}", exc_info=True)
+        st.error(f"Error rendering performance insights: {str(e)}") 

lib/content_calendar/ui/dashboard.py

@@ -0,0 +1,638 @@
+import streamlit as st
+import pandas as pd
+from datetime import datetime, timedelta
+import logging
+import sys
+import hashlib
+from pathlib import Path
+from typing import Dict, Any
+from .calendar_view import render_calendar_view
+from .filters import render_filters
+from .add_content_modal import render_add_content_modal
+from .ai_suggestions_modal import render_ai_suggestions_modal
+from .components.content_optimization import render_content_optimization
+from .components.ab_testing import render_ab_testing
+from .components.content_series import render_content_series_generator
+from .components.performance_insights import render_performance_insights
+import json
+from lib.content_scheduler.ui.dashboard import run_dashboard as run_scheduler_dashboard
+
+# Add parent directory to path to import existing tools
+parent_dir = str(Path(__file__).parent.parent.parent.parent)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+from lib.database.models import ContentItem, ContentType, Platform, get_engine, get_session, init_db
+from ..core.calendar_manager import CalendarManager
+from ..core.content_generator import ContentGenerator
+from ..core.ai_generator import AIGenerator
+from ..core.content_brief import ContentBriefGenerator
+from ..integrations.seo_optimizer import SEOOptimizer
+from lib.integrations.platform_adapters import PlatformAdapter, UnifiedPlatformAdapter
+
+# Initialize logger
+logger = logging.getLogger(__name__)
+
+# Initialize DB/session (do this once at app startup)
+engine = get_engine()
+init_db(engine)
+session = get_session(engine)
+
+# Import content repurposing UI with error handling
+def render_smart_repurposing_tab():
+    """Render the Smart Content Repurposing tab with error handling."""
+    try:
+        from lib.ai_seo_tools.content_calendar.ui.components.content_repurposing_ui import render_content_repurposing_ui
+        render_content_repurposing_ui()
+    except ImportError as e:
+        st.error(f"Smart Content Repurposing feature is not available: {str(e)}")
+        st.info("Please ensure all dependencies are installed correctly.")
+    except Exception as e:
+        st.error(f"Error loading Smart Content Repurposing: {str(e)}")
+        st.info("Please check the logs for more details.")
+
+class ContentCalendarDashboard:
+    """Interactive dashboard for content calendar management."""
+    def __init__(self):
+        self.logger = logging.getLogger('content_calendar.dashboard')
+        self.logger.info("Initializing ContentCalendarDashboard")
+        self.content_brief_generator = ContentBriefGenerator()
+        self.content_generator = ContentGenerator()
+        self.ai_generator = AIGenerator()
+        self.platform_adapter = UnifiedPlatformAdapter()
+        self.seo_optimizer = SEOOptimizer()
+        # Initialize session state variables
+        if 'ab_test_results' not in st.session_state:
+            st.session_state.ab_test_results = {}
+        if 'optimization_history' not in st.session_state:
+            st.session_state.optimization_history = {}
+        if 'calendar_data' not in st.session_state:
+            st.session_state.calendar_data = None
+        if 'selected_content' not in st.session_state:
+            st.session_state.selected_content = None
+        if 'view_mode' not in st.session_state:
+            st.session_state.view_mode = 'day'
+        if 'selected_date' not in st.session_state:
+            st.session_state.selected_date = datetime.now()
+        self.logger.info("ContentCalendarDashboard initialized successfully")
+
+    def render(self):
+        self.logger.info("Starting dashboard render (tabbed UI)")
+        try:
+            self._inject_custom_css()
+            st.title("AI Content Planning")
+            st.markdown("""
+            Plan, schedule, and manage your content strategy with AI-powered insights. Use the calendar to organize your content and leverage AI tools for optimization.
+            """)
+            tabs = st.tabs([
+                "Content Planning",
+                "Content Optimization",
+                "🔄 Smart Repurposing",
+                "A/B Testing",
+                "Content Series",
+                "Analytics",
+                "Content Scheduling"
+            ])
+            with tabs[0]:
+                icon_map = {
+                    'Blog': '📝', 'Website': '🌐', 'Instagram': '📸', 'Twitter': '🐦', 'LinkedIn': '💼', 'Facebook': '📘',
+                    'Article': '📄', 'Social Post': '💬', 'Video': '🎬', 'Newsletter': '✉️'
+                }
+                status_color = {
+                    'Draft': '#bdbdbd', 'Scheduled': '#1976d2', 'Published': '#43a047', 'Archived': '#757575'
+                }
+                calendar_data = self._get_calendar_data()
+                def on_edit(row):
+                    try:
+                        st.session_state.editing_content = row
+                        st.rerun()
+                    except Exception as e:
+                        logger.error(f"Error handling edit action: {str(e)}")
+                        st.error("An error occurred while editing content. Please try again.")
+                def on_delete(row):
+                    try:
+                        self._delete_content(row)
+                        st.success(f"Successfully deleted content: {row['title']}")
+                        st.rerun()
+                    except Exception as e:
+                        logger.error(f"Error handling delete action: {str(e)}")
+                        st.error("An error occurred while deleting content. Please try again.")
+                def on_generate(row):
+                    st.session_state['show_ai_modal'] = True
+                    st.session_state['ai_modal_topic'] = row['title']
+                    st.session_state['ai_modal_type'] = str(row['type'])
+                    st.session_state['ai_modal_platform'] = str(row['platform'])
+                    st.rerun()
+                render_calendar_view(
+                    calendar_data=calendar_data,
+                    icon_map=icon_map,
+                    status_color=status_color,
+                    on_edit=on_edit,
+                    on_delete=on_delete,
+                    on_generate=on_generate,
+                    get_item_key=self._get_item_key
+                )
+                st.markdown("---")
+                render_filters()
+                def handle_add_content(title, platform, content_type, publish_date):
+                    self._add_content({
+                        'title': title,
+                        'platform': platform,
+                        'type': content_type,
+                        'publish_date': publish_date
+                    })
+                    st.session_state['show_add_content_dialog'] = False
+                    st.success("Content added!")
+                    st.rerun()
+                def handle_generate_with_ai(title, platform, content_type):
+                    st.session_state['show_add_content_dialog'] = False
+                    st.session_state['show_ai_modal'] = True
+                    st.session_state['ai_modal_topic'] = title
+                    st.session_state['ai_modal_type'] = content_type
+                    st.session_state['ai_modal_platform'] = platform
+                render_add_content_modal(
+                    selected_date=st.session_state.selected_date,
+                    on_add_content=handle_add_content,
+                    on_generate_with_ai=handle_generate_with_ai
+                )
+                if st.session_state.get('show_ai_modal', False):
+                    st.markdown("### AI Content Suggestions")
+                    with st.container():
+                        render_ai_suggestions_modal(
+                            generate_ai_suggestions=self._generate_ai_suggestions,
+                            on_create_brief=self._create_content_brief,
+                            on_schedule=self._schedule_content,
+                            on_refine=self._refine_suggestion,
+                            on_customize=self._customize_suggestion
+                        )
+                        if st.button("Close"):
+                            st.session_state['show_ai_modal'] = False
+            with tabs[1]:
+                render_content_optimization(
+                    content_generator=self.content_generator,
+                    ai_generator=self.ai_generator,
+                    seo_optimizer=self.seo_optimizer
+                )
+            with tabs[2]:
+                render_smart_repurposing_tab()
+            with tabs[3]:
+                render_ab_testing(self.content_generator, None)
+            with tabs[4]:
+                render_content_series_generator(
+                    self.ai_generator,
+                    self.content_generator,
+                    self.seo_optimizer
+                )
+            with tabs[5]:
+                st.header("Analytics")
+                st.markdown("### Performance Insights")
+                all_content = session.query(ContentItem).all()
+                selected_content = st.selectbox(
+                    "Select content to analyze",
+                    options=[item.title for item in all_content],
+                    key="analytics_content_select"
+                )
+                if selected_content:
+                    content_item = next(
+                        item for item in all_content
+                        if item.title == selected_content
+                    )
+                    render_performance_insights(content_item, self.platform_adapter)
+                st.markdown("### Optimization History")
+                if selected_content in st.session_state.optimization_history:
+                    st.json(st.session_state.optimization_history[selected_content])
+            with tabs[6]:
+                run_scheduler_dashboard()
+            self.logger.info("Dashboard render completed successfully (tabbed UI)")
+        except Exception as e:
+            self.logger.error(f"Error rendering dashboard: {str(e)}", exc_info=True)
+            st.error(f"An error occurred: {str(e)}")
+
+    def _inject_custom_css(self):
+        st.markdown("""
+            <style>
+            /* Add your custom CSS here if needed */
+            </style>
+        """, unsafe_allow_html=True)
+
+    def _get_calendar_data(self):
+        self.logger.info("_get_calendar_data called")
+        try:
+            all_content = session.query(ContentItem).all()
+            data = []
+            for item in all_content:
+                data.append({
+                    'date': item.publish_date,
+                    'title': item.title,
+                    'platform': item.platforms[0] if item.platforms else 'Unknown',
+                    'type': item.content_type.value if hasattr(item.content_type, 'value') else str(item.content_type),
+                    'status': item.status
+                })
+            df = pd.DataFrame(data) if data else None
+            return df
+        except Exception as e:
+            self.logger.error(f"Error loading calendar data: {str(e)}", exc_info=True)
+            st.error(f"Error loading calendar data: {str(e)}")
+            return None
+
+    def _add_content(self, content):
+        platform_map = {
+            'Blog': Platform.WEBSITE,
+            'Instagram': Platform.INSTAGRAM,
+            'Twitter': Platform.TWITTER,
+            'LinkedIn': Platform.LINKEDIN,
+            'Facebook': Platform.FACEBOOK,
+        }
+        platform_enum = platform_map.get(content['platform'], Platform.WEBSITE)
+        content_type_map = {
+            'Article': ContentType.BLOG_POST,
+            'Social Post': ContentType.SOCIAL_MEDIA,
+            'Video': ContentType.VIDEO,
+            'Newsletter': ContentType.NEWSLETTER,
+        }
+        content_type_enum = content_type_map.get(content['type'], ContentType.BLOG_POST)
+        new_item = ContentItem(
+            title=content['title'],
+            description="",
+            content_type=content_type_enum,
+            platforms=[platform_enum.value],
+            publish_date=pd.to_datetime(content['publish_date']),
+            status=content.get('status', 'Draft'),
+            author=None,
+            tags=[],
+            notes=None,
+            seo_data={}
+        )
+        session.add(new_item)
+        session.commit()
+
+    def _delete_content(self, row):
+        # Find by title and publish_date (could be improved with unique IDs)
+        all_content = session.query(ContentItem).all()
+        for item in all_content:
+            if (item.title == row['title'] and
+                str(item.publish_date.date()) == str(row['date'].date()) and
+                (item.platforms[0] if item.platforms else 'Unknown') == str(row['platform']) and
+                (item.content_type.value if hasattr(item.content_type, 'value') else str(item.content_type)) == str(row['type'])):
+                session.delete(item)
+                session.commit()
+                break
+
+    def _edit_content(self, row, new_title, new_platform, new_type, new_status):
+        self._delete_content(row)
+        self._add_content({
+            'title': new_title,
+            'platform': new_platform,
+            'type': new_type,
+            'publish_date': row['date'],
+            'status': new_status
+        })
+
+    def _get_item_key(self, row):
+        key_str = f"{row['title']}_{row['date']}_{row['platform']}_{row['type']}"
+        return hashlib.md5(key_str.encode()).hexdigest()
+
+    def _generate_ai_suggestions(self, content_type, topic, audience, goals, tone, length, model_settings, style_preferences, seo_preferences, platform_settings):
+        """Generate AI content suggestions based on input parameters."""
+        try:
+            self.logger.info(f"Generating AI suggestions for topic: {topic}")
+            
+            # Map content type string to ContentType enum
+            content_type_map = {
+                'Blog Post': ContentType.BLOG_POST,
+                'Social Media Post': ContentType.SOCIAL_MEDIA,
+                'Video': ContentType.VIDEO,
+                'Newsletter': ContentType.NEWSLETTER,
+                'Article': ContentType.BLOG_POST,
+                'Social Post': ContentType.SOCIAL_MEDIA
+            }
+            content_type_enum = content_type_map.get(content_type, ContentType.BLOG_POST)
+            
+            # Map platform string to Platform enum
+            platform_map = {
+                'Blog': Platform.WEBSITE,
+                'Instagram': Platform.INSTAGRAM,
+                'Twitter': Platform.TWITTER,
+                'LinkedIn': Platform.LINKEDIN,
+                'Facebook': Platform.FACEBOOK,
+                'Website': Platform.WEBSITE
+            }
+            platform = st.session_state.get('ai_modal_platform', 'Blog')
+            platform_enum = platform_map.get(platform, Platform.WEBSITE)
+            
+            # Create a content item for the suggestion
+            content_item = ContentItem(
+                title=topic,
+                description="",
+                content_type=content_type_enum,
+                platforms=[platform_enum],
+                publish_date=datetime.now(),
+                seo_data=SEOData(
+                    title=topic,
+                    meta_description="",
+                    keywords=[],
+                    structured_data={}
+                ),
+                status='Draft'
+            )
+            
+            # Use AIGenerator to generate suggestions
+            suggestions = self.ai_generator.generate_ai_suggestions(
+                content_type=content_type_enum,
+                topic=topic,
+                audience=audience,
+                goals=goals,
+                tone=tone,
+                length=length,
+                model_settings=model_settings,
+                style_preferences=style_preferences,
+                seo_preferences=seo_preferences,
+                platform_settings=platform_settings,
+                platform=platform_enum
+            )
+            
+            if not suggestions:
+                self.logger.warning("No suggestions generated")
+                return []
+            
+            # Format suggestions
+            formatted_suggestions = []
+            for suggestion in suggestions:
+                formatted_suggestion = {
+                    'title': suggestion.get('title', topic),
+                    'type': content_type,
+                    'platform': platform,
+                    'audience': audience,
+                    'impact': f"High impact for {', '.join(goals)}",
+                    'preview': suggestion.get('preview', ''),
+                    'style_elements': [
+                        f"Tone: {tone}",
+                        f"Length: {length}",
+                        f"Creativity: {model_settings.get('Creativity Level', 'balanced')}",
+                        f"Formality: {model_settings.get('Formality Level', 'professional')}"
+                    ],
+                    'seo_elements': [
+                        f"Keyword Density: {seo_preferences.get('Keyword Density', '2')}%",
+                        "Internal Linking: Enabled" if seo_preferences.get('Internal Linking', True) else "Internal Linking: Disabled",
+                        "External Linking: Enabled" if seo_preferences.get('External Linking', True) else "External Linking: Disabled"
+                    ],
+                    'engagement_score': f"{85 + len(formatted_suggestions)*5}%",
+                    'reach': 'High',
+                    'conversion': f"{3.5 + len(formatted_suggestions)*0.5}%",
+                    'seo_impact': 'Strong',
+                    'platform_optimizations': suggestion.get('platform_optimizations', []),
+                    'variations': suggestion.get('variations', [
+                        "Alternative headline",
+                        "Different content angle",
+                        "Alternative format"
+                    ]),
+                    'seo_recommendations': suggestion.get('seo_elements', []),
+                    'media_suggestions': suggestion.get('media_suggestions', [
+                        "Featured image",
+                        "Supporting graphics",
+                        "Social media visuals"
+                    ])
+                }
+                formatted_suggestions.append(formatted_suggestion)
+            
+            self.logger.info(f"Generated {len(formatted_suggestions)} suggestions successfully")
+            return formatted_suggestions
+            
+        except Exception as e:
+            self.logger.error(f"Error generating AI suggestions: {str(e)}", exc_info=True)
+            st.error(f"Error generating suggestions: {str(e)}")
+            return []
+
+    def _create_content_brief(self, content_item: ContentItem) -> Dict[str, Any]:
+        """Create a detailed content brief for the given content item."""
+        try:
+            self.logger.info(f"Creating content brief for: {content_item.title}")
+            
+            # Generate content brief using the content brief generator
+            brief = self.content_brief_generator.generate_brief(
+                content_item=content_item,
+                target_audience={
+                    'audience': content_item.description,
+                    'goals': ['engage', 'inform', 'convert']
+                }
+            )
+            
+            # Enhance brief with SEO data
+            if brief and 'content_flow' in brief:
+                brief['seo_optimization'] = {
+                    'meta_description': self.seo_optimizer.generate_meta_description(
+                        brief['content_flow'].get('introduction', {}).get('summary', '')
+                    ),
+                    'keywords': self.seo_optimizer.extract_keywords(
+                        brief['content_flow'].get('introduction', {}).get('summary', '')
+                    ),
+                    'structured_data': self.seo_optimizer.generate_structured_data(
+                        content_item.content_type
+                    )
+                }
+            
+            self.logger.info(f"Content brief created successfully for: {content_item.title}")
+            return brief
+            
+        except Exception as e:
+            self.logger.error(f"Error creating content brief: {str(e)}", exc_info=True)
+            st.error(f"Error creating content brief: {str(e)}")
+            return {}
+
+    def _schedule_content(self, content_item: ContentItem, publish_date: datetime) -> bool:
+        """Schedule content for publishing on the specified date."""
+        try:
+            self.logger.info(f"Scheduling content: {content_item.title} for {publish_date}")
+            
+            # Get the calendar
+            calendar = self.calendar_manager.get_calendar()
+            if not calendar:
+                raise ValueError("No calendar found")
+            
+            # Update the publish date
+            content_item.publish_date = publish_date
+            
+            # Add to calendar
+            calendar.add_content(content_item)
+            
+            # Save changes
+            self.calendar_manager.save_calendar_to_json()
+            
+            self.logger.info(f"Content scheduled successfully: {content_item.title}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Error scheduling content: {str(e)}", exc_info=True)
+            st.error(f"Error scheduling content: {str(e)}")
+            return False
+
+    def _refine_suggestion(self, suggestion: Dict[str, Any], feedback: Dict[str, Any]) -> Dict[str, Any]:
+        """Refine an AI-generated suggestion based on user feedback."""
+        try:
+            self.logger.info("Refining AI suggestion based on feedback")
+            
+            # Update suggestion based on feedback
+            if 'tone' in feedback:
+                suggestion['style_elements'] = [
+                    f"Tone: {feedback['tone']}",
+                    *[elem for elem in suggestion['style_elements'] if not elem.startswith('Tone:')]
+                ]
+            
+            if 'length' in feedback:
+                suggestion['style_elements'] = [
+                    f"Length: {feedback['length']}",
+                    *[elem for elem in suggestion['style_elements'] if not elem.startswith('Length:')]
+                ]
+            
+            if 'keywords' in feedback:
+                suggestion['seo_elements'] = [
+                    f"Keywords: {', '.join(feedback['keywords'])}",
+                    *[elem for elem in suggestion['seo_elements'] if not elem.startswith('Keywords:')]
+                ]
+            
+            # Regenerate content with refined parameters
+            refined_content = self.content_brief_generator.generate_brief(
+                content_item=ContentItem(
+                    title=suggestion['title'],
+                    description="",
+                    content_type=ContentType[suggestion['type'].upper().replace(' ', '_')],
+                    platforms=[Platform[suggestion['platform'].upper()]],
+                    publish_date=datetime.now(),
+                    seo_data=SEOData(
+                        title=suggestion['title'],
+                        meta_description="",
+                        keywords=feedback.get('keywords', []),
+                        structured_data={}
+                    ),
+                    status='Draft'
+                ),
+                target_audience={
+                    'audience': suggestion['audience'],
+                    'goals': feedback.get('goals', ['engage', 'inform']),
+                    'preferences': {
+                        'tone': feedback.get('tone', 'professional'),
+                        'length': feedback.get('length', 'medium')
+                    }
+                }
+            )
+            
+            if refined_content:
+                suggestion['preview'] = refined_content.get('content_flow', {}).get('introduction', {}).get('summary', '')
+            
+            self.logger.info("Suggestion refined successfully")
+            return suggestion
+            
+        except Exception as e:
+            self.logger.error(f"Error refining suggestion: {str(e)}", exc_info=True)
+            st.error(f"Error refining suggestion: {str(e)}")
+            return suggestion
+
+    def _customize_suggestion(self, suggestion: Dict[str, Any], customizations: Dict[str, Any]) -> Dict[str, Any]:
+        """Customize an AI-generated suggestion with specific requirements."""
+        try:
+            self.logger.info("Customizing AI suggestion")
+            
+            # Apply customizations
+            if 'title' in customizations:
+                suggestion['title'] = customizations['title']
+            
+            if 'platform' in customizations:
+                suggestion['platform'] = customizations['platform']
+            
+            if 'style' in customizations:
+                suggestion['style_elements'] = [
+                    f"Tone: {customizations['style'].get('tone', 'professional')}",
+                    f"Length: {customizations['style'].get('length', 'medium')}",
+                    f"Creativity: {customizations['style'].get('creativity', 'balanced')}",
+                    f"Formality: {customizations['style'].get('formality', 'professional')}"
+                ]
+            
+            if 'seo' in customizations:
+                suggestion['seo_elements'] = [
+                    f"Keyword Density: {customizations['seo'].get('keyword_density', '2')}%",
+                    "Internal Linking: Enabled" if customizations['seo'].get('internal_linking', True) else "Internal Linking: Disabled",
+                    "External Linking: Enabled" if customizations['seo'].get('external_linking', True) else "External Linking: Disabled"
+                ]
+            
+            # Regenerate content with customizations
+            customized_content = self.content_brief_generator.generate_brief(
+                content_item=ContentItem(
+                    title=suggestion['title'],
+                    description="",
+                    content_type=ContentType[suggestion['type'].upper().replace(' ', '_')],
+                    platforms=[Platform[suggestion['platform'].upper()]],
+                    publish_date=datetime.now(),
+                    seo_data=SEOData(
+                        title=suggestion['title'],
+                        meta_description="",
+                        keywords=customizations.get('seo', {}).get('keywords', []),
+                        structured_data={}
+                    ),
+                    status='Draft'
+                ),
+                target_audience={
+                    'audience': suggestion['audience'],
+                    'goals': customizations.get('goals', ['engage', 'inform']),
+                    'preferences': customizations.get('style', {})
+                }
+            )
+            
+            if customized_content:
+                suggestion['preview'] = customized_content.get('content_flow', {}).get('introduction', {}).get('summary', '')
+            
+            self.logger.info("Suggestion customized successfully")
+            return suggestion
+            
+        except Exception as e:
+            self.logger.error(f"Error customizing suggestion: {str(e)}", exc_info=True)
+            st.error(f"Error customizing suggestion: {str(e)}")
+            return suggestion
+
+    def _optimize_content_for_platform(self, content_item: ContentItem, platform: Platform) -> Dict[str, Any]:
+        """Optimize content specifically for a target platform."""
+        try:
+            self.logger.info(f"Optimizing content for {platform.name}: {content_item.title}")
+            
+            # Get platform-specific requirements
+            platform_requirements = self.platform_adapter.get_platform_requirements(platform)
+            
+            # Generate platform-optimized content
+            optimized_content = self.content_generator.optimize_for_platform(
+                content=content_item,
+                platform=platform,
+                requirements=platform_requirements
+            )
+            
+            if not optimized_content:
+                raise ValueError(f"Failed to optimize content for {platform.name}")
+            
+            # Enhance with AI
+            ai_enhanced = self.ai_generator.enhance_for_platform(
+                content=optimized_content,
+                platform=platform,
+                enhancement_type='platform_specific'
+            )
+            
+            if ai_enhanced:
+                optimized_content.update(ai_enhanced)
+            
+            # Track optimization history
+            if content_item.title not in st.session_state.optimization_history:
+                st.session_state.optimization_history[content_item.title] = []
+            st.session_state.optimization_history[content_item.title].append({
+                'platform': platform.name,
+                'timestamp': datetime.now(),
+                'changes': optimized_content.get('changes', [])
+            })
+            
+            self.logger.info(f"Content optimized successfully for {platform.name}")
+            return optimized_content
+            
+        except Exception as e:
+            self.logger.error(f"Error optimizing content: {str(e)}", exc_info=True)
+            st.error(f"Error optimizing content: {str(e)}")
+            return {}
+
+if __name__ == "__main__":
+    dashboard = ContentCalendarDashboard()
+    dashboard.render() 

lib/content_calendar/ui/filters.py

@@ -0,0 +1,30 @@
+import streamlit as st
+from datetime import datetime, timedelta
+
+def render_filters():
+    with st.expander("Filters", expanded=False):
+        col1, col2 = st.columns(2)
+        with col1:
+            start_date = st.date_input("Start Date", st.session_state.get('filter_start_date', datetime.now()))
+            end_date = st.date_input("End Date", st.session_state.get('filter_end_date', datetime.now() + timedelta(days=30)))
+            st.session_state['filter_start_date'] = start_date
+            st.session_state['filter_end_date'] = end_date
+        with col2:
+            platforms = st.multiselect(
+                "Platforms",
+                ["Blog", "Instagram", "Twitter", "LinkedIn", "Facebook"],
+                default=st.session_state.get('filter_platforms', ["Blog"])
+            )
+            st.session_state['filter_platforms'] = platforms
+            content_types = st.multiselect(
+                "Content Types",
+                ["Article", "Social Post", "Video", "Newsletter"],
+                default=st.session_state.get('filter_content_types', ["Article"])
+            )
+            st.session_state['filter_content_types'] = content_types
+            statuses = st.multiselect(
+                "Status",
+                ["Draft", "Scheduled", "Published", "Archived"],
+                default=st.session_state.get('filter_statuses', ["Draft", "Scheduled"])
+            )
+            st.session_state['filter_statuses'] = statuses 

lib/content_calendar/utils/date_utils.py

@@ -0,0 +1,198 @@
+from datetime import datetime, timedelta
+from typing import Dict, List, Any
+import calendar
+import random
+
+def calculate_publish_dates(
+    topics: List[Dict[str, Any]],
+    start_date: datetime,
+    duration: str
+) -> Dict[str, List[Dict[str, Any]]]:
+    """
+    Calculate optimal publish dates for content topics.
+    
+    Args:
+        topics: List of content topics to schedule
+        start_date: When to start publishing
+        duration: How long the calendar should span ('weekly', 'monthly', 'quarterly')
+        
+    Returns:
+        Dictionary mapping dates to scheduled content
+    """
+    # Calculate end date based on duration
+    end_date = _calculate_end_date(start_date, duration)
+    
+    # Get all dates in range
+    dates = _get_dates_in_range(start_date, end_date)
+    
+    # Calculate optimal posting frequency
+    frequency = _calculate_posting_frequency(len(topics), len(dates))
+    
+    # Schedule content
+    schedule = _schedule_content(topics, dates, frequency)
+    
+    return schedule
+
+def _calculate_end_date(start_date: datetime, duration: str) -> datetime:
+    """Calculate end date based on duration."""
+    if duration == 'weekly':
+        return start_date + timedelta(days=7)
+    elif duration == 'monthly':
+        # Add one month
+        if start_date.month == 12:
+            return datetime(start_date.year + 1, 1, start_date.day)
+        return datetime(start_date.year, start_date.month + 1, start_date.day)
+    elif duration == 'quarterly':
+        # Add three months
+        new_month = start_date.month + 3
+        new_year = start_date.year
+        if new_month > 12:
+            new_month -= 12
+            new_year += 1
+        return datetime(new_year, new_month, start_date.day)
+    else:
+        raise ValueError(f"Invalid duration: {duration}")
+
+def _get_dates_in_range(
+    start_date: datetime,
+    end_date: datetime
+) -> List[datetime]:
+    """Get all dates in the given range."""
+    dates = []
+    current_date = start_date
+    
+    while current_date <= end_date:
+        # Skip weekends
+        if current_date.weekday() < 5:  # 0-4 are weekdays
+            dates.append(current_date)
+        current_date += timedelta(days=1)
+    
+    return dates
+
+def _calculate_posting_frequency(
+    num_topics: int,
+    num_dates: int
+) -> Dict[str, int]:
+    """
+    Calculate optimal posting frequency based on number of topics and dates.
+    
+    Returns:
+        Dictionary with posting frequency for each content type
+    """
+    # Calculate base frequency
+    base_frequency = num_dates / num_topics
+    
+    # Adjust for content types
+    return {
+        'blog_post': max(1, int(base_frequency * 0.4)),  # 40% of content
+        'social_media': max(1, int(base_frequency * 0.3)),  # 30% of content
+        'video': max(1, int(base_frequency * 0.2)),  # 20% of content
+        'newsletter': max(1, int(base_frequency * 0.1))  # 10% of content
+    }
+
+def _schedule_content(
+    topics: List[Dict[str, Any]],
+    dates: List[datetime],
+    frequency: Dict[str, int]
+) -> Dict[str, List[Dict[str, Any]]]:
+    """
+    Schedule content topics across available dates.
+    
+    Args:
+        topics: List of content topics to schedule
+        dates: Available dates for scheduling
+        frequency: Posting frequency for each content type
+        
+    Returns:
+        Dictionary mapping dates to scheduled content
+    """
+    schedule = {}
+    current_date_index = 0
+    
+    # Group topics by content type
+    topics_by_type = _group_topics_by_type(topics)
+    
+    # Schedule each content type
+    for content_type, type_topics in topics_by_type.items():
+        type_frequency = frequency.get(content_type, 1)
+        
+        for topic in type_topics:
+            # Find next available date
+            while current_date_index < len(dates):
+                date = dates[current_date_index]
+                date_str = date.strftime('%Y-%m-%d')
+                
+                # Check if date is available
+                if date_str not in schedule:
+                    schedule[date_str] = []
+                
+                # Add topic to schedule
+                schedule[date_str].append(topic)
+                
+                # Move to next date based on frequency
+                current_date_index += type_frequency
+                break
+            
+            # If we've used all dates, wrap around
+            if current_date_index >= len(dates):
+                current_date_index = 0
+    
+    return schedule
+
+def _group_topics_by_type(
+    topics: List[Dict[str, Any]]
+) -> Dict[str, List[Dict[str, Any]]]:
+    """Group topics by their content type."""
+    grouped = {}
+    
+    for topic in topics:
+        content_type = topic.get('content_type', 'blog_post')
+        if content_type not in grouped:
+            grouped[content_type] = []
+        grouped[content_type].append(topic)
+    
+    return grouped
+
+def get_optimal_posting_time(
+    content_type: str,
+    platform: str
+) -> datetime.time:
+    """
+    Get optimal posting time for content type and platform.
+    
+    Args:
+        content_type: Type of content
+        platform: Target platform
+        
+    Returns:
+        Optimal time to post
+    """
+    # Default optimal times (can be customized based on platform analytics)
+    optimal_times = {
+        'blog_post': {
+            'website': datetime.time(9, 0),  # 9 AM
+            'medium': datetime.time(10, 0)   # 10 AM
+        },
+        'social_media': {
+            'facebook': datetime.time(15, 0),  # 3 PM
+            'twitter': datetime.time(12, 0),   # 12 PM
+            'linkedin': datetime.time(8, 0),   # 8 AM
+            'instagram': datetime.time(19, 0)  # 7 PM
+        },
+        'video': {
+            'youtube': datetime.time(14, 0)   # 2 PM
+        },
+        'newsletter': {
+            'email': datetime.time(6, 0)      # 6 AM
+        }
+    }
+    
+    # Get optimal time for content type and platform
+    content_times = optimal_times.get(content_type, {})
+    optimal_time = content_times.get(platform)
+    
+    if optimal_time is None:
+        # Default to 9 AM if no specific time is set
+        optimal_time = datetime.time(9, 0)
+    
+    return optimal_time 

lib/content_calendar/utils/error_handling.py

@@ -0,0 +1,154 @@
+import functools
+import logging
+from typing import Any, Callable, TypeVar, cast
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar('T')
+
+def handle_calendar_error(func: Callable[..., T]) -> Callable[..., T]:
+    """
+    Decorator to handle errors in calendar operations.
+    
+    Args:
+        func: Function to decorate
+        
+    Returns:
+        Decorated function with error handling
+    """
+    @functools.wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> T:
+        try:
+            return func(*args, **kwargs)
+        except ValueError as e:
+            logger.error(f"Invalid input in {func.__name__}: {str(e)}")
+            raise
+        except Exception as e:
+            logger.error(f"Error in {func.__name__}: {str(e)}")
+            raise CalendarError(f"Calendar operation failed: {str(e)}")
+    return cast(Callable[..., T], wrapper)
+
+class CalendarError(Exception):
+    """Base exception for calendar-related errors."""
+    pass
+
+class ContentError(CalendarError):
+    """Exception for content-related errors."""
+    pass
+
+class SchedulingError(CalendarError):
+    """Exception for scheduling-related errors."""
+    pass
+
+class ValidationError(CalendarError):
+    """Exception for validation-related errors."""
+    pass
+
+def validate_date_range(
+    start_date: datetime,
+    end_date: datetime
+) -> None:
+    """
+    Validate date range for calendar operations.
+    
+    Args:
+        start_date: Start date
+        end_date: End date
+        
+    Raises:
+        ValidationError: If date range is invalid
+    """
+    if not isinstance(start_date, datetime):
+        raise ValidationError("Start date must be a datetime object")
+    
+    if not isinstance(end_date, datetime):
+        raise ValidationError("End date must be a datetime object")
+    
+    if start_date > end_date:
+        raise ValidationError("Start date must be before end date")
+    
+    if (end_date - start_date).days > 365:
+        raise ValidationError("Calendar duration cannot exceed one year")
+
+def validate_content_item(content: dict) -> None:
+    """
+    Validate content item structure.
+    
+    Args:
+        content: Content item to validate
+        
+    Raises:
+        ValidationError: If content item is invalid
+    """
+    required_fields = ['title', 'description', 'content_type', 'platforms']
+    
+    for field in required_fields:
+        if field not in content:
+            raise ValidationError(f"Missing required field: {field}")
+    
+    if not isinstance(content['platforms'], list):
+        raise ValidationError("Platforms must be a list")
+    
+    if not content['platforms']:
+        raise ValidationError("At least one platform must be specified")
+
+def validate_calendar_duration(duration: str) -> None:
+    """
+    Validate calendar duration.
+    
+    Args:
+        duration: Duration to validate ('weekly', 'monthly', 'quarterly')
+        
+    Raises:
+        ValidationError: If duration is invalid
+    """
+    valid_durations = ['weekly', 'monthly', 'quarterly']
+    
+    if duration not in valid_durations:
+        raise ValidationError(
+            f"Invalid duration: {duration}. "
+            f"Must be one of: {', '.join(valid_durations)}"
+        )
+
+def log_calendar_operation(
+    operation: str,
+    details: dict
+) -> None:
+    """
+    Log calendar operation details.
+    
+    Args:
+        operation: Name of the operation
+        details: Operation details to log
+    """
+    logger.info(f"Calendar operation: {operation}")
+    logger.debug(f"Operation details: {details}")
+
+def handle_api_error(
+    error: Exception,
+    operation: str
+) -> None:
+    """
+    Handle API-related errors.
+    
+    Args:
+        error: The error that occurred
+        operation: The operation that failed
+    """
+    logger.error(f"API error in {operation}: {str(error)}")
+    raise CalendarError(f"API operation failed: {str(error)}")
+
+def handle_integration_error(
+    error: Exception,
+    integration: str
+) -> None:
+    """
+    Handle integration-related errors.
+    
+    Args:
+        error: The error that occurred
+        integration: The integration that failed
+    """
+    logger.error(f"Integration error with {integration}: {str(error)}")
+    raise CalendarError(f"Integration failed: {str(error)}")