deckbuilder 1.0.0b1__py3-none-any.whl

mcp_server/content_optimization.py

@@ -0,0 +1,822 @@
+"""
+Content Optimization Engine for Content-First Presentation Intelligence
+
+This module implements Tool #3: optimize_content_for_layout() which takes user content
+and a chosen layout, then optimizes the content structure and generates ready-to-use
+YAML for immediate presentation creation.
+
+Design Philosophy: Transform raw content into presentation-ready structure that
+maximizes communication effectiveness within the chosen layout constraints.
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+
+@dataclass
+class ContentOptimizationResult:
+    """Result of content optimization with YAML and analysis"""
+
+    yaml_structure: str
+    content_mapping: Dict[str, str]
+    formatting_applied: List[str]
+    title_generated: str
+
+
+@dataclass
+class GapAnalysis:
+    """Analysis of how well content fits the chosen layout"""
+
+    content_fit: str  # excellent|good|fair|poor
+    missing_elements: List[str]
+    recommendations: List[str]
+    layout_utilization: float
+
+
+class ContentOptimizationEngine:
+    """
+    Optimizes raw content for specific PowerPoint layouts and generates ready-to-use YAML.
+
+    The final step in the content-first workflow that transforms analyzed content
+    into presentation-ready structured frontmatter.
+    """
+
+    def __init__(self):
+        """Initialize with layout templates and optimization rules"""
+        self.layout_templates = self._build_layout_templates()
+        self.formatting_rules = self._build_formatting_rules()
+
+    def optimize_content_for_layout(
+        self, content: str, chosen_layout: str, slide_context: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """
+        Optimize content structure and generate ready-to-use YAML.
+
+        Args:
+            content: Raw content to optimize
+            chosen_layout: Layout selected from recommend_slide_approach
+            slide_context: Optional context from previous tools
+
+        Returns:
+            Dictionary with optimized YAML, gap analysis, and presentation tips
+        """
+        # Clean and prepare content
+        cleaned_content = self._clean_content(content)
+
+        # Generate optimized content structure
+        optimization_result = self._optimize_content_structure(
+            cleaned_content, chosen_layout, slide_context
+        )
+
+        # Perform gap analysis
+        gap_analysis = self._analyze_content_layout_fit(
+            cleaned_content, chosen_layout, optimization_result
+        )
+
+        # Generate presentation tips
+        presentation_tips = self._generate_presentation_tips(
+            chosen_layout, gap_analysis, slide_context
+        )
+
+        return {
+            "optimized_content": {
+                "yaml_structure": optimization_result.yaml_structure,
+                "content_mapping": optimization_result.content_mapping,
+                "formatting_applied": optimization_result.formatting_applied,
+                "title_generated": optimization_result.title_generated,
+            },
+            "gap_analysis": {
+                "content_fit": gap_analysis.content_fit,
+                "missing_elements": gap_analysis.missing_elements,
+                "recommendations": gap_analysis.recommendations,
+                "layout_utilization": gap_analysis.layout_utilization,
+            },
+            "presentation_tips": presentation_tips,
+        }
+
+    def _clean_content(self, content: str) -> str:
+        """Clean and normalize the input content."""
+        # Remove excessive whitespace
+        cleaned = re.sub(r"\n\s*\n", "\n\n", content.strip())
+
+        # Normalize quotes
+        cleaned = re.sub(r'["""]', '"', cleaned)
+        cleaned = re.sub(r"[''']", "'", cleaned)
+
+        return cleaned
+
+    def _optimize_content_structure(
+        self, content: str, chosen_layout: str, slide_context: Optional[Dict]
+    ) -> ContentOptimizationResult:
+        """Optimize content structure for the chosen layout."""
+        layout_handler = self._get_layout_handler(chosen_layout)
+
+        if layout_handler:
+            return layout_handler(content, slide_context)
+        else:
+            # Fallback to basic Title and Content layout
+            return self._optimize_for_title_and_content(content, slide_context)
+
+    def _get_layout_handler(self, layout: str):
+        """Get the appropriate optimization handler for the layout."""
+        handlers = {
+            "Four Columns": self._optimize_for_four_columns,
+            "Comparison": self._optimize_for_comparison,
+            "Two Content": self._optimize_for_two_content,
+            "Title and Content": self._optimize_for_title_and_content,
+            "Section Header": self._optimize_for_section_header,
+            "Title Slide": self._optimize_for_title_slide,
+        }
+        return handlers.get(layout)
+
+    def _optimize_for_four_columns(
+        self, content: str, slide_context: Optional[Dict]
+    ) -> ContentOptimizationResult:
+        """Optimize content for Four Columns layout."""
+        # Extract title
+        title = self._extract_or_generate_title(content, slide_context)
+
+        # Parse content into 4 columns
+        columns = self._parse_content_into_columns(content, 4)
+
+        # Apply formatting
+        formatted_columns = []
+        formatting_applied = []
+
+        for col in columns:
+            formatted_col = self._apply_content_formatting(col)
+            formatted_columns.append(formatted_col)
+            if formatted_col != col:
+                formatting_applied.append("content optimization")
+
+        # Generate YAML
+        yaml_structure = self._generate_four_columns_yaml(title, formatted_columns)
+
+        # Create content mapping
+        content_mapping = {
+            "title": title,
+            **{f"column_{i + 1}": col for i, col in enumerate(formatted_columns)},
+        }
+
+        return ContentOptimizationResult(
+            yaml_structure=yaml_structure,
+            content_mapping=content_mapping,
+            formatting_applied=formatting_applied,
+            title_generated=title,
+        )
+
+    def _optimize_for_comparison(
+        self, content: str, slide_context: Optional[Dict]
+    ) -> ContentOptimizationResult:
+        """Optimize content for Comparison layout."""
+        title = self._extract_or_generate_title(content, slide_context)
+
+        # Parse content into left/right comparison
+        left_content, right_content = self._parse_content_into_comparison(content)
+
+        # Apply formatting
+        left_formatted = self._apply_content_formatting(left_content["content"])
+        right_formatted = self._apply_content_formatting(right_content["content"])
+
+        formatting_applied = []
+        if left_formatted != left_content["content"] or right_formatted != right_content["content"]:
+            formatting_applied.append("comparison content optimization")
+
+        # Generate YAML
+        yaml_structure = self._generate_comparison_yaml(
+            title, left_content["title"], left_formatted, right_content["title"], right_formatted
+        )
+
+        content_mapping = {
+            "title": title,
+            "left_title": left_content["title"],
+            "left_content": left_formatted,
+            "right_title": right_content["title"],
+            "right_content": right_formatted,
+        }
+
+        return ContentOptimizationResult(
+            yaml_structure=yaml_structure,
+            content_mapping=content_mapping,
+            formatting_applied=formatting_applied,
+            title_generated=title,
+        )
+
+    def _optimize_for_two_content(
+        self, content: str, slide_context: Optional[Dict]
+    ) -> ContentOptimizationResult:
+        """Optimize content for Two Content layout."""
+        title = self._extract_or_generate_title(content, slide_context)
+
+        # Parse into two sections
+        sections = self._parse_content_into_columns(content, 2)
+
+        # Apply formatting
+        formatted_sections = []
+        formatting_applied = []
+
+        for section in sections:
+            formatted_section = self._apply_content_formatting(section)
+            formatted_sections.append(formatted_section)
+            if formatted_section != section:
+                formatting_applied.append("section content optimization")
+
+        # Generate YAML
+        yaml_structure = self._generate_two_content_yaml(title, formatted_sections)
+
+        content_mapping = {
+            "title": title,
+            "section_1": formatted_sections[0] if len(formatted_sections) > 0 else "",
+            "section_2": formatted_sections[1] if len(formatted_sections) > 1 else "",
+        }
+
+        return ContentOptimizationResult(
+            yaml_structure=yaml_structure,
+            content_mapping=content_mapping,
+            formatting_applied=formatting_applied,
+            title_generated=title,
+        )
+
+    def _optimize_for_title_and_content(
+        self, content: str, slide_context: Optional[Dict]
+    ) -> ContentOptimizationResult:
+        """Optimize content for Title and Content layout."""
+        title = self._extract_or_generate_title(content, slide_context)
+
+        # Extract main content (everything after title)
+        main_content = self._extract_main_content(content, title)
+
+        # Apply formatting and structure
+        formatted_content = self._apply_content_formatting(main_content)
+        formatted_content = self._structure_as_bullets(formatted_content)
+
+        formatting_applied = (
+            ["bullet point structuring"] if formatted_content != main_content else []
+        )
+
+        # Generate YAML
+        yaml_structure = self._generate_title_and_content_yaml(title, formatted_content)
+
+        content_mapping = {"title": title, "content": formatted_content}
+
+        return ContentOptimizationResult(
+            yaml_structure=yaml_structure,
+            content_mapping=content_mapping,
+            formatting_applied=formatting_applied,
+            title_generated=title,
+        )
+
+    def _optimize_for_section_header(
+        self, content: str, slide_context: Optional[Dict]
+    ) -> ContentOptimizationResult:
+        """Optimize content for Section Header layout."""
+        title = self._extract_or_generate_title(content, slide_context)
+        subtitle = self._extract_subtitle_or_summary(content)
+
+        # Generate YAML
+        yaml_structure = self._generate_section_header_yaml(title, subtitle)
+
+        content_mapping = {"title": title, "subtitle": subtitle}
+
+        return ContentOptimizationResult(
+            yaml_structure=yaml_structure,
+            content_mapping=content_mapping,
+            formatting_applied=["section header formatting"],
+            title_generated=title,
+        )
+
+    def _optimize_for_title_slide(
+        self, content: str, slide_context: Optional[Dict]
+    ) -> ContentOptimizationResult:
+        """Optimize content for Title Slide layout."""
+        title = self._extract_or_generate_title(content, slide_context)
+        subtitle = self._extract_subtitle_or_summary(content)
+
+        # Generate YAML
+        yaml_structure = self._generate_title_slide_yaml(title, subtitle)
+
+        content_mapping = {"title": title, "subtitle": subtitle}
+
+        return ContentOptimizationResult(
+            yaml_structure=yaml_structure,
+            content_mapping=content_mapping,
+            formatting_applied=["title slide formatting"],
+            title_generated=title,
+        )
+
+    def _extract_or_generate_title(self, content: str, slide_context: Optional[Dict]) -> str:
+        """Extract title from content or generate from context."""
+        # Try to extract from first line if it looks like a title
+        lines = content.strip().split("\n")
+        first_line = lines[0].strip() if lines else ""
+
+        # Check if first line is title-like
+        if len(first_line) < 80 and not first_line.endswith(".") and len(first_line.split()) <= 8:
+            return first_line
+
+        # Try to generate from slide context
+        if slide_context and "message_intent" in slide_context:
+            intent = slide_context["message_intent"]
+            # Extract key words from intent
+            key_words = [word for word in intent.split() if len(word) > 3][:3]
+            if key_words:
+                return " ".join(word.capitalize() for word in key_words)
+
+        # Extract key terms from content
+        content_words = re.findall(r"\b[A-Za-z]{4,}\b", content)
+        if content_words:
+            # Take first few significant words
+            title_words = content_words[:3]
+            return " ".join(word.capitalize() for word in title_words)
+
+        return "Content Overview"
+
+    def _parse_content_into_columns(self, content: str, num_columns: int) -> List[str]:
+        """Parse content into specified number of columns."""
+        # Look for explicit list items first
+        bullet_items = re.findall(r"[-*•]\s*([^\n]+)", content)
+        if len(bullet_items) >= num_columns:
+            return bullet_items[:num_columns]
+
+        # Look for numbered list items
+        numbered_items = re.findall(r"\d+\)\s*([^\n]+)", content)
+        if len(numbered_items) >= num_columns:
+            return numbered_items[:num_columns]
+
+        # Try comma-separated items
+        comma_parts = [part.strip() for part in content.split(",")]
+        if len(comma_parts) >= num_columns:
+            return comma_parts[:num_columns]
+
+        # Try colon-separated items
+        colon_items = re.findall(r"([^:]+):\s*([^,\n]+)", content)
+        if len(colon_items) >= num_columns:
+            return [f"{item[0]}: {item[1]}" for item in colon_items[:num_columns]]
+
+        # Split by sentences/phrases
+        sentences = re.split(r"[.!?]+", content)
+        clean_sentences = [s.strip() for s in sentences if s.strip()]
+
+        if len(clean_sentences) >= num_columns:
+            return clean_sentences[:num_columns]
+
+        # Fallback: split content into equal parts
+        words = content.split()
+        if len(words) < num_columns * 3:  # Too few words
+            # Pad with placeholder content
+            result = [content] if words else []
+            while len(result) < num_columns:
+                result.append(f"Additional content for column {len(result) + 1}")
+            return result
+
+        # Split words roughly equally
+        words_per_column = len(words) // num_columns
+        columns = []
+        for i in range(num_columns):
+            start = i * words_per_column
+            end = start + words_per_column if i < num_columns - 1 else len(words)
+            columns.append(" ".join(words[start:end]))
+
+        return columns
+
+    def _parse_content_into_comparison(self, content: str) -> Tuple[Dict[str, str], Dict[str, str]]:
+        """Parse content into left/right comparison structure."""
+        # Look for explicit vs/versus patterns
+        vs_match = re.search(r"(.+?)\s+(?:vs|versus|compared to)\s+(.+)", content, re.IGNORECASE)
+        if vs_match:
+            left_content = vs_match.group(1).strip()
+            right_content = vs_match.group(2).strip()
+
+            return (
+                {"title": self._extract_comparison_title(left_content), "content": left_content},
+                {"title": self._extract_comparison_title(right_content), "content": right_content},
+            )
+
+        # Look for contrasting words
+        contrast_patterns = [
+            r"(.+?)\s+(?:but|however|while)\s+(.+)",
+            r"(.+?)\s+(?:whereas|although)\s+(.+)",
+        ]
+
+        for pattern in contrast_patterns:
+            match = re.search(pattern, content, re.IGNORECASE)
+            if match:
+                left_content = match.group(1).strip()
+                right_content = match.group(2).strip()
+
+                return (
+                    {"title": "Current Approach", "content": left_content},
+                    {"title": "Alternative Approach", "content": right_content},
+                )
+
+        # Split content in half
+        sentences = re.split(r"[.!?]+", content)
+        clean_sentences = [s.strip() for s in sentences if s.strip()]
+
+        mid_point = len(clean_sentences) // 2
+        left_content = ". ".join(clean_sentences[:mid_point])
+        right_content = ". ".join(clean_sentences[mid_point:])
+
+        return (
+            {"title": "Option A", "content": left_content},
+            {"title": "Option B", "content": right_content},
+        )
+
+    def _extract_comparison_title(self, content: str) -> str:
+        """Extract a short title from comparison content."""
+        words = content.split()[:3]
+        return " ".join(word.capitalize() for word in words)
+
+    def _extract_main_content(self, content: str, title: str) -> str:
+        """Extract main content excluding the title."""
+        if title and title in content:
+            # Remove title from content
+            content_without_title = content.replace(title, "", 1).strip()
+            return content_without_title if content_without_title else content
+        return content
+
+    def _extract_subtitle_or_summary(self, content: str) -> str:
+        """Extract subtitle or create a summary."""
+        # Look for a second line that could be a subtitle
+        lines = [line.strip() for line in content.split("\n") if line.strip()]
+        if len(lines) >= 2:
+            second_line = lines[1]
+            if len(second_line) < 100:  # Reasonable subtitle length
+                return second_line
+
+        # Create a summary from content
+        sentences = re.split(r"[.!?]+", content)
+        clean_sentences = [s.strip() for s in sentences if s.strip()]
+
+        if clean_sentences:
+            # Take first sentence as summary, limited length
+            summary = clean_sentences[0]
+            if len(summary) > 100:
+                summary = summary[:97] + "..."
+            return summary
+
+        return "Overview"
+
+    def _apply_content_formatting(self, content: str) -> str:
+        """Apply smart formatting to content."""
+        if not content:
+            return content
+
+        # Emphasize key numbers and percentages
+        content = re.sub(r"(\d+%)", r"**\1**", content)
+        content = re.sub(r"(\$[\d,]+)", r"**\1**", content)
+
+        # Emphasize superlatives and strong words
+        strong_words = [
+            "best",
+            "fastest",
+            "highest",
+            "lowest",
+            "most",
+            "least",
+            "critical",
+            "important",
+            "key",
+        ]
+        for word in strong_words:
+            content = re.sub(rf"\b({word})\b", r"**\1**", content, flags=re.IGNORECASE)
+
+        return content
+
+    def _structure_as_bullets(self, content: str) -> str:
+        """Structure content as bullet points if appropriate."""
+        # If already has bullets, keep as is
+        if re.search(r"^\s*[-*•]", content, re.MULTILINE):
+            return content
+
+        # Split sentences and convert to bullets
+        sentences = re.split(r"[.!?]+", content)
+        clean_sentences = [s.strip() for s in sentences if s.strip() and len(s) > 10]
+
+        if len(clean_sentences) >= 2:
+            return "\n".join(f"- {sentence}" for sentence in clean_sentences)
+
+        return content
+
+    # YAML Generation Methods
+    def _generate_four_columns_yaml(self, title: str, columns: List[str]) -> str:
+        """Generate YAML for Four Columns layout."""
+        yaml_columns = []
+        for i, col in enumerate(columns):
+            col_title = f"Column {i + 1}"
+            # Try to extract a title from the column content
+            if ":" in col:
+                parts = col.split(":", 1)
+                col_title = parts[0].strip()
+                col_content = parts[1].strip()
+            else:
+                col_content = col
+
+            yaml_columns.append(
+                f"""  - title: {col_title}
+    content: "{col_content}" """
+            )
+
+        return f"""---
+layout: Four Columns
+title: {title}
+columns:
+{chr(10).join(yaml_columns)}
+---"""
+
+    def _generate_comparison_yaml(
+        self, title: str, left_title: str, left_content: str, right_title: str, right_content: str
+    ) -> str:
+        """Generate YAML for Comparison layout."""
+        return f"""---
+layout: Comparison
+title: {title}
+comparison:
+  left:
+    title: {left_title}
+    content: "{left_content}"
+  right:
+    title: {right_title}
+    content: "{right_content}"
+---"""
+
+    def _generate_two_content_yaml(self, title: str, sections: List[str]) -> str:
+        """Generate YAML for Two Content layout."""
+        section1 = sections[0] if len(sections) > 0 else "Content for first section"
+        section2 = sections[1] if len(sections) > 1 else "Content for second section"
+
+        return f"""---
+layout: Two Content
+title: {title}
+sections:
+  - title: Section 1
+    content: "{section1}"
+  - title: Section 2
+    content: "{section2}"
+---"""
+
+    def _generate_title_and_content_yaml(self, title: str, content: str) -> str:
+        """Generate YAML for Title and Content layout."""
+        return f"""---
+layout: Title and Content
+title: {title}
+---
+{content}"""
+
+    def _generate_section_header_yaml(self, title: str, subtitle: str) -> str:
+        """Generate YAML for Section Header layout."""
+        return f"""---
+layout: Section Header
+title: {title}
+subtitle: {subtitle}
+---"""
+
+    def _generate_title_slide_yaml(self, title: str, subtitle: str) -> str:
+        """Generate YAML for Title Slide layout."""
+        return f"""---
+layout: Title Slide
+title: {title}
+subtitle: {subtitle}
+---"""
+
+    def _analyze_content_layout_fit(
+        self, content: str, chosen_layout: str, optimization_result: ContentOptimizationResult
+    ) -> GapAnalysis:
+        """Analyze how well the content fits the chosen layout."""
+        # Analyze content characteristics
+        # content_length = len(content.split())  # Future: use for length analysis
+        # layout_requirements = self._get_layout_requirements(chosen_layout)
+        # Future: use for validation
+
+        # Assess content fit
+        fit_score = self._calculate_fit_score(content, chosen_layout, optimization_result)
+
+        if fit_score >= 0.8:
+            content_fit = "excellent"
+        elif fit_score >= 0.6:
+            content_fit = "good"
+        elif fit_score >= 0.4:
+            content_fit = "fair"
+        else:
+            content_fit = "poor"
+
+        # Identify missing elements
+        missing_elements = self._identify_missing_elements(content, chosen_layout)
+
+        # Generate recommendations
+        recommendations = self._generate_fit_recommendations(
+            content_fit, missing_elements, chosen_layout
+        )
+
+        # Calculate layout utilization
+        layout_utilization = min(fit_score, 1.0)
+
+        return GapAnalysis(
+            content_fit=content_fit,
+            missing_elements=missing_elements,
+            recommendations=recommendations,
+            layout_utilization=layout_utilization,
+        )
+
+    def _calculate_fit_score(
+        self, content: str, layout: str, optimization_result: ContentOptimizationResult
+    ) -> float:
+        """Calculate a fit score between content and layout."""
+        score = 0.5  # Base score
+
+        # Bonus for having appropriate content structure
+        if layout == "Four Columns":
+            content_elements = len(optimization_result.content_mapping) - 1  # Exclude title
+            if content_elements >= 4:
+                score += 0.3
+            elif content_elements >= 3:
+                score += 0.2
+            elif content_elements >= 2:
+                score += 0.1
+
+        elif layout == "Comparison":
+            if (
+                "left_content" in optimization_result.content_mapping
+                and "right_content" in optimization_result.content_mapping
+            ):
+                score += 0.3
+                # Bonus for balanced content
+                left_len = len(optimization_result.content_mapping["left_content"].split())
+                right_len = len(optimization_result.content_mapping["right_content"].split())
+                if 0.5 <= left_len / max(right_len, 1) <= 2.0:
+                    score += 0.2
+
+        elif layout in ["Title and Content", "Section Header", "Title Slide"]:
+            # These layouts are very flexible
+            score += 0.3
+
+        # Bonus for appropriate content length
+        word_count = len(content.split())
+        if 50 <= word_count <= 200:  # Sweet spot for slide content
+            score += 0.2
+        elif 20 <= word_count <= 300:  # Acceptable range
+            score += 0.1
+
+        return min(score, 1.0)
+
+    def _identify_missing_elements(self, content: str, layout: str) -> List[str]:
+        """Identify elements missing for optimal layout utilization."""
+        missing = []
+
+        if layout == "Four Columns":
+            content_elements = len(self._parse_content_into_columns(content, 4))
+            if content_elements < 4:
+                missing.append(
+                    f"Need {4 - content_elements} more content elements for full utilization"
+                )
+
+        elif layout == "Comparison":
+            if not any(
+                word in content.lower()
+                for word in ["vs", "versus", "compared", "against", "but", "however"]
+            ):
+                missing.append("Content lacks clear comparison elements")
+
+        # Check for visual elements that could enhance the slide
+        if not re.search(r"\d+%|\$[\d,]+", content):
+            if layout in ["Four Columns", "Title and Content"]:
+                missing.append("Consider adding metrics or data points for impact")
+
+        return missing
+
+    def _generate_fit_recommendations(
+        self, content_fit: str, missing_elements: List[str], layout: str
+    ) -> List[str]:
+        """Generate recommendations for improving content-layout fit."""
+        recommendations = []
+
+        if content_fit == "poor":
+            recommendations.append(
+                "Consider switching to a simpler layout like 'Title and Content'"
+            )
+        elif content_fit == "fair":
+            recommendations.append(
+                "Content structure could be improved for better layout utilization"
+            )
+
+        if missing_elements:
+            recommendations.extend([f"Suggestion: {element}" for element in missing_elements])
+
+        # Layout-specific recommendations
+        if layout == "Four Columns" and content_fit in ["fair", "poor"]:
+            recommendations.append("Try organizing content into 4 distinct categories or points")
+        elif layout == "Comparison" and content_fit in ["fair", "poor"]:
+            recommendations.append("Highlight the contrasting elements more clearly")
+
+        return recommendations
+
+    def _generate_presentation_tips(
+        self, layout: str, gap_analysis: GapAnalysis, slide_context: Optional[Dict]
+    ) -> Dict[str, str]:
+        """Generate presentation delivery tips."""
+        tips = {}
+
+        # Layout-specific delivery guidance
+        if layout == "Four Columns":
+            tips["delivery_guidance"] = (
+                "Present columns in logical order, allow time for audience to "
+                "process each section"
+            )
+        elif layout == "Comparison":
+            tips["delivery_guidance"] = (
+                "Guide audience through left side first, then right, conclude with recommendation"
+            )
+        elif layout == "Title and Content":
+            tips["delivery_guidance"] = (
+                "Use title to set context, walk through content points systematically"
+            )
+        else:
+            tips["delivery_guidance"] = "Keep focus on key message, use slide as visual support"
+
+        # Audience adaptation
+        if slide_context and "audience" in slide_context:
+            audience = slide_context["audience"]
+            if audience == "board":
+                tips["audience_adaptation"] = (
+                    "Focus on high-level insights, minimize technical details"
+                )
+            elif audience == "technical":
+                tips["audience_adaptation"] = (
+                    "Include technical details, be prepared for deep-dive questions"
+                )
+            else:
+                tips["audience_adaptation"] = "Balance detail level, check for understanding"
+        else:
+            tips["audience_adaptation"] = "Adapt detail level based on audience expertise"
+
+        # Timing estimate
+        word_count = sum(
+            len(mapping.split())
+            for mapping in gap_analysis.__dict__.values()
+            if isinstance(mapping, str)
+        )
+        if word_count < 50:
+            tips["timing_estimate"] = "1-2 minutes"
+        elif word_count < 100:
+            tips["timing_estimate"] = "2-3 minutes"
+        else:
+            tips["timing_estimate"] = "3-4 minutes"
+
+        return tips
+
+    def _get_layout_requirements(self, layout: str) -> Dict[str, Any]:
+        """Get requirements and characteristics for each layout."""
+        return {
+            "Four Columns": {"min_elements": 2, "max_elements": 4, "flexibility": "medium"},
+            "Comparison": {"min_elements": 2, "max_elements": 2, "flexibility": "low"},
+            "Two Content": {"min_elements": 1, "max_elements": 2, "flexibility": "high"},
+            "Title and Content": {
+                "min_elements": 1,
+                "max_elements": "unlimited",
+                "flexibility": "very_high",
+            },
+            "Section Header": {"min_elements": 1, "max_elements": 2, "flexibility": "high"},
+            "Title Slide": {"min_elements": 1, "max_elements": 2, "flexibility": "high"},
+        }.get(layout, {"min_elements": 1, "max_elements": "unlimited", "flexibility": "high"})
+
+    def _build_layout_templates(self) -> Dict[str, Dict]:
+        """Build templates for different layouts."""
+        return {
+            "Four Columns": {
+                "required_fields": ["title", "columns"],
+                "optimal_content_length": "20-40 words per column",
+            },
+            "Comparison": {
+                "required_fields": ["title", "left", "right"],
+                "optimal_content_length": "30-60 words per side",
+            },
+        }
+
+    def _build_formatting_rules(self) -> Dict[str, List[str]]:
+        """Build formatting rules for different content types."""
+        return {
+            "numbers": ["**{number}**"],
+            "percentages": ["**{percentage}**"],
+            "currency": ["**{amount}**"],
+            "emphasis": ["**{word}**"],
+        }
+
+
+# Helper function for easy import
+def optimize_content_for_layout(
+    content: str, chosen_layout: str, slide_context: Optional[Dict] = None
+) -> Dict[str, Any]:
+    """
+    Convenience function for optimizing content for a specific layout.
+
+    Args:
+        content: Raw content to optimize
+        chosen_layout: Layout selected from recommend_slide_approach
+        slide_context: Optional context from previous tools
+
+    Returns:
+        Dictionary with optimized YAML, gap analysis, and presentation tips
+    """
+    engine = ContentOptimizationEngine()
+    return engine.optimize_content_for_layout(content, chosen_layout, slide_context)