Pptx Creator

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = ["python-pptx"]
# ///
"""
Analyze a PowerPoint template to extract layouts, colors, fonts, and structure.
Use this to understand existing templates before creating new presentations.
"""

import argparse
import json
from pathlib import Path

from pptx import Presentation
from pptx.util import Inches, Pt


def analyze_template(pptx_path: str, verbose: bool = False) -> dict:
    """Analyze a PowerPoint template and return its structure."""
    prs = Presentation(pptx_path)
    
    analysis = {
        "file": str(pptx_path),
        "dimensions": {
            "width_inches": round(prs.slide_width.inches, 2),
            "height_inches": round(prs.slide_height.inches, 2),
        },
        "slide_count": len(prs.slides),
        "masters": [],
        "layouts": [],
        "slides": [],
    }
    
    # Analyze slide masters
    for i, master in enumerate(prs.slide_masters):
        master_info = {
            "index": i,
            "layout_count": len(master.slide_layouts),
            "layouts": []
        }
        
        for j, layout in enumerate(master.slide_layouts):
            layout_info = {
                "index": j,
                "name": layout.name,
                "placeholders": []
            }
            
            for ph in layout.placeholders:
                layout_info["placeholders"].append({
                    "idx": ph.placeholder_format.idx,
                    "type": str(ph.placeholder_format.type),
                    "name": ph.name,
                })
            
            master_info["layouts"].append(layout_info)
            analysis["layouts"].append({
                "name": layout.name,
                "index": j,
                "master": i,
            })
        
        analysis["masters"].append(master_info)
    
    # Analyze slides (sample or all)
    max_slides = len(prs.slides) if verbose else min(10, len(prs.slides))
    
    for idx in range(max_slides):
        slide = prs.slides[idx]
        slide_info = {
            "number": idx + 1,
            "layout": slide.slide_layout.name,
            "shapes": []
        }
        
        for shape in slide.shapes:
            shape_info = {
                "name": shape.name,
                "type": str(shape.shape_type) if shape.shape_type else "Unknown",
            }
            
            # Get position/size
            shape_info["left"] = round(shape.left.inches, 2) if shape.left else 0
            shape_info["top"] = round(shape.top.inches, 2) if shape.top else 0
            shape_info["width"] = round(shape.width.inches, 2) if shape.width else 0
            shape_info["height"] = round(shape.height.inches, 2) if shape.height else 0
            
            # Get text content
            if hasattr(shape, 'text') and shape.text.strip():
                shape_info["text"] = shape.text.strip()[:100]
            
            # Get fill color
            if hasattr(shape, 'fill'):
                try:
                    if shape.fill.type is not None:
                        shape_info["fill_type"] = str(shape.fill.type)
                        if hasattr(shape.fill, 'fore_color'):
                            try:
                                rgb = shape.fill.fore_color.rgb
                                if rgb:
                                    shape_info["fill_color"] = f"#{rgb}"
                            except:
                                pass
                except:
                    pass
            
            # Get font info from first paragraph
            if hasattr(shape, 'text_frame'):
                try:
                    for para in shape.text_frame.paragraphs[:1]:
                        if para.runs:
                            run = para.runs[0]
                            font = run.font
                            font_info = {}
                            if font.name:
                                font_info["name"] = font.name
                            if font.size:
                                font_info["size"] = font.size.pt
                            if font.bold:
                                font_info["bold"] = True
                            if font.color.rgb:
                                font_info["color"] = f"#{font.color.rgb}"
                            if font_info:
                                shape_info["font"] = font_info
                except:
                    pass
            
            slide_info["shapes"].append(shape_info)
        
        analysis["slides"].append(slide_info)
    
    return analysis


def print_summary(analysis: dict):
    """Print a human-readable summary."""
    print(f"📊 Template Analysis: {Path(analysis['file']).name}")
    print(f"   Dimensions: {analysis['dimensions']['width_inches']}\" x {analysis['dimensions']['height_inches']}\"")
    print(f"   Total slides: {analysis['slide_count']}")
    print()
    
    print("📐 Available Layouts:")
    for layout in analysis["layouts"]:
        print(f"   [{layout['index']}] {layout['name']}")
    print()
    
    print("📄 Slide Structure (first 10):")
    for slide in analysis["slides"][:10]:
        print(f"\n   Slide {slide['number']}: {slide['layout']}")
        for shape in slide["shapes"][:5]:
            text_preview = f" → \"{shape.get('text', '')[:40]}\"" if shape.get('text') else ""
            print(f"      • {shape['type']}: {shape['name']}{text_preview}")
        if len(slide["shapes"]) > 5:
            print(f"      ... and {len(slide['shapes']) - 5} more shapes")


def main():
    parser = argparse.ArgumentParser(description="Analyze PowerPoint template")
    parser.add_argument("template", help="Path to PPTX file")
    parser.add_argument("--json", "-j", action="store_true", help="Output JSON")
    parser.add_argument("--verbose", "-v", action="store_true", help="Analyze all slides")
    parser.add_argument("--output", "-o", help="Save JSON to file")
    
    args = parser.parse_args()
    
    analysis = analyze_template(args.template, verbose=args.verbose)
    
    if args.json or args.output:
        output = json.dumps(analysis, indent=2)
        if args.output:
            with open(args.output, "w") as f:
                f.write(output)
            print(f"Saved analysis to {args.output}")
        else:
            print(output)
    else:
        print_summary(analysis)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = ["python-pptx", "httpx", "pyyaml", "Pillow"]
# ///
"""
PowerPoint Creator - Generate professional presentations from outlines, topics, or data.
"""

import argparse
import json
import os
import re
import sys
import tempfile
from pathlib import Path
from datetime import datetime
from io import BytesIO

import httpx
import yaml
from PIL import Image
from pptx import Presentation
from pptx.util import Inches, Pt
from pptx.dml.color import RGBColor
from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
from pptx.enum.chart import XL_CHART_TYPE
from pptx.enum.shapes import MSO_SHAPE
from pptx.chart.data import CategoryChartData


def hex_to_rgb(hex_color: str) -> RGBColor:
    """Convert hex color to RGBColor."""
    hex_color = hex_color.lstrip('#')
    r = int(hex_color[0:2], 16)
    g = int(hex_color[2:4], 16)
    b = int(hex_color[4:6], 16)
    return RGBColor(r, g, b)

# Skill directory (for templates)
SKILL_DIR = Path(__file__).parent.parent
TEMPLATES_DIR = SKILL_DIR / "templates"

# Style presets - these match create_template.py PRESETS
STYLES = {
    "minimal": {
        "title_font": "Helvetica Neue",
        "body_font": "Helvetica Neue",
        "title_size": 44,
        "body_size": 18,
        "title_color": "1a1a1a",
        "body_color": "4a4a4a",
        "accent_color": "0066cc",
    },
    "corporate": {
        "title_font": "Arial",
        "body_font": "Arial",
        "title_size": 40,
        "body_size": 18,
        "title_color": "003366",
        "body_color": "333333",
        "accent_color": "0066cc",
    },
    "creative": {
        "title_font": "Avenir Next",
        "body_font": "Avenir",
        "title_size": 48,
        "body_size": 20,
        "title_color": "2d2d2d",
        "body_color": "4a4a4a",
        "accent_color": "ff5722",
    },
    "dark": {
        "title_font": "SF Pro Display",
        "body_font": "SF Pro Text",
        "title_size": 44,
        "body_size": 18,
        "title_color": "FFFFFF",
        "body_color": "e0e0e0",
        "accent_color": "00d4ff",
    },
    "executive": {
        "title_font": "Georgia",
        "body_font": "Calibri",
        "title_size": 42,
        "body_size": 18,
        "title_color": "1e3a5f",
        "body_color": "2c3e50",
        "accent_color": "c9a227",
    },
    "startup": {
        "title_font": "Poppins",
        "body_font": "Inter",
        "title_size": 48,
        "body_size": 20,
        "title_color": "2d3436",
        "body_color": "636e72",
        "accent_color": "6c5ce7",
    },
}


def parse_outline(outline_path: str) -> dict:
    """Parse markdown outline into slide structure."""
    with open(outline_path, "r") as f:
        content = f.read()
    
    presentation = {
        "title": "",
        "subtitle": "",
        "author": "",
        "slides": []
    }
    
    lines = content.strip().split("\n")
    current_slide = None
    
    for line in lines:
        line = line.rstrip()
        
        # Presentation title (# Title)
        if line.startswith("# ") and not presentation["title"]:
            presentation["title"] = line[2:].strip()
            continue
        
        # Metadata (subtitle:, author:)
        if line.lower().startswith("subtitle:"):
            presentation["subtitle"] = line.split(":", 1)[1].strip()
            continue
        if line.lower().startswith("author:"):
            presentation["author"] = line.split(":", 1)[1].strip()
            continue
        
        # Slide header (## Slide N: Title or ## Title)
        if line.startswith("## "):
            if current_slide:
                presentation["slides"].append(current_slide)
            
            title = line[3:].strip()
            # Remove "Slide N:" prefix if present
            title = re.sub(r"^Slide\s+\d+:\s*", "", title, flags=re.IGNORECASE)
            
            current_slide = {
                "title": title,
                "layout": "title_and_content",
                "bullets": [],
                "notes": "",
                "image": None,
                "chart": None,
                "table": None,
                "data_source": None,
            }
            continue
        
        # Slide content
        if current_slide:
            # Bullet point
            if line.startswith("- "):
                item = line[2:].strip()
                
                # Check for special directives
                if item.lower().startswith("chart:"):
                    current_slide["chart"] = item.split(":", 1)[1].strip()
                    current_slide["layout"] = "chart"
                elif item.lower().startswith("table:"):
                    current_slide["table"] = item.split(":", 1)[1].strip()
                    current_slide["layout"] = "table"
                elif item.lower().startswith("data:") or item.lower().startswith("source:"):
                    current_slide["data_source"] = item.split(":", 1)[1].strip()
                elif item.lower().startswith("layout:"):
                    current_slide["layout"] = item.split(":", 1)[1].strip()
                elif item.startswith("!["):
                    # Image: ![alt](path or generate: prompt)
                    match = re.match(r"!\[([^\]]*)\]\(([^)]+)\)", item)
                    if match:
                        alt, src = match.groups()
                        current_slide["image"] = {"alt": alt, "src": src.strip()}
                        if "generate:" not in src.lower():
                            current_slide["layout"] = "image_and_text"
                else:
                    current_slide["bullets"].append(item)
            
            # Speaker notes (indented or after ---)
            elif line.strip().startswith(">"):
                current_slide["notes"] += line.strip()[1:].strip() + "\n"
    
    # Don't forget the last slide
    if current_slide:
        presentation["slides"].append(current_slide)
    
    return presentation


def generate_image(prompt: str, output_path: str) -> str | None:
    """Generate image using nano-banana-pro skill."""
    try:
        import subprocess
        script_path = SKILL_DIR.parent / "nano-banana-pro" / "scripts" / "generate_image.py"
        
        if not script_path.exists():
            print(f"Warning: nano-banana-pro not found, skipping image generation", file=sys.stderr)
            return None
        
        result = subprocess.run(
            ["uv", "run", str(script_path), "--prompt", prompt, "--filename", output_path, "--resolution", "1K"],
            capture_output=True,
            text=True,
            timeout=60
        )
        
        if result.returncode == 0:
            # Parse output for file path
            for line in result.stdout.split("\n"):
                if line.startswith("Image saved:"):
                    return line.split(":", 1)[1].strip()
            return output_path
        else:
            print(f"Warning: Image generation failed: {result.stderr}", file=sys.stderr)
            return None
    except Exception as e:
        print(f"Warning: Image generation error: {e}", file=sys.stderr)
        return None


def fetch_crm_data(query: str) -> list[dict]:
    """Fetch data from CRM."""
    api_url = os.environ.get("TWENTY_API_URL", "")
    api_token = os.environ.get("TWENTY_API_TOKEN", "")
    
    if not api_url or not api_token:
        print("Warning: CRM not configured, skipping data fetch", file=sys.stderr)
        return []
    
    # Parse query like "twenty://opportunities?stage=negotiation"
    # For now, return empty - this would need proper CRM API integration
    return []


def create_presentation(data: dict, style: str = "minimal", template_path: str | None = None) -> Presentation:
    """Create PowerPoint presentation from structured data."""
    
    # Start with template or blank
    if template_path and Path(template_path).exists():
        prs = Presentation(template_path)
    else:
        prs = Presentation()
        prs.slide_width = Inches(13.333)  # 16:9
        prs.slide_height = Inches(7.5)
    
    style_config = STYLES.get(style, STYLES["minimal"])
    
    # Title slide
    if data.get("title"):
        slide_layout = prs.slide_layouts[0]  # Title slide
        slide = prs.slides.add_slide(slide_layout)
        
        title = slide.shapes.title
        if title:
            title.text = data["title"]
            for paragraph in title.text_frame.paragraphs:
                paragraph.font.size = Pt(style_config["title_size"])
                paragraph.font.name = style_config["title_font"]
                paragraph.font.bold = True
                paragraph.font.color.rgb = hex_to_rgb(style_config["title_color"])
        
        if data.get("subtitle") and len(slide.placeholders) > 1:
            subtitle = slide.placeholders[1]
            subtitle.text = data["subtitle"]
            if data.get("author"):
                subtitle.text += f"\n{data['author']}"
            for paragraph in subtitle.text_frame.paragraphs:
                paragraph.font.color.rgb = hex_to_rgb(style_config["body_color"])
        
        # Add accent bar at bottom
        accent_bar = slide.shapes.add_shape(
            MSO_SHAPE.RECTANGLE,
            Inches(0), Inches(7.0),
            Inches(13.333), Inches(0.15)
        )
        accent_bar.fill.solid()
        accent_bar.fill.fore_color.rgb = hex_to_rgb(style_config["accent_color"])
        accent_bar.line.fill.background()
    
    # Content slides
    for slide_data in data.get("slides", []):
        layout_idx = 1  # Default: title and content
        
        if slide_data.get("layout") == "section":
            layout_idx = 2  # Section header
        elif slide_data.get("layout") == "two_column":
            layout_idx = 3  # Two content
        elif slide_data.get("layout") == "blank":
            layout_idx = 6  # Blank
        
        try:
            slide_layout = prs.slide_layouts[layout_idx]
        except IndexError:
            slide_layout = prs.slide_layouts[1]
        
        slide = prs.slides.add_slide(slide_layout)
        
        # Title
        if slide.shapes.title and slide_data.get("title"):
            slide.shapes.title.text = slide_data["title"]
            for paragraph in slide.shapes.title.text_frame.paragraphs:
                paragraph.font.size = Pt(style_config["title_size"] - 4)
                paragraph.font.name = style_config["title_font"]
                paragraph.font.bold = True
                paragraph.font.color.rgb = hex_to_rgb(style_config["title_color"])
        
        # Bullets
        if slide_data.get("bullets"):
            # Find content placeholder
            content_shape = None
            for shape in slide.placeholders:
                if shape.placeholder_format.idx == 1:  # Content placeholder
                    content_shape = shape
                    break
            
            if content_shape and hasattr(content_shape, "text_frame"):
                tf = content_shape.text_frame
                tf.clear()
                
                for i, bullet in enumerate(slide_data["bullets"]):
                    if i == 0:
                        p = tf.paragraphs[0]
                    else:
                        p = tf.add_paragraph()
                    
                    p.text = bullet
                    p.font.size = Pt(style_config["body_size"])
                    p.font.name = style_config["body_font"]
                    p.font.color.rgb = hex_to_rgb(style_config["body_color"])
                    p.level = 0
        
        # Image
        if slide_data.get("image"):
            img_data = slide_data["image"]
            img_path = None
            
            if isinstance(img_data, dict):
                src = img_data.get("src", "")
                if "generate:" in src.lower():
                    prompt = src.split("generate:", 1)[1].strip()
                    timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
                    img_path = generate_image(prompt, f"/tmp/pptx_img_{timestamp}.png")
                else:
                    img_path = src
            elif isinstance(img_data, str):
                if "generate:" in img_data.lower():
                    prompt = img_data.split("generate:", 1)[1].strip()
                    timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
                    img_path = generate_image(prompt, f"/tmp/pptx_img_{timestamp}.png")
                else:
                    img_path = img_data
            
            if img_path and Path(img_path).exists():
                # Add image to slide
                left = Inches(7)
                top = Inches(1.5)
                width = Inches(5)
                slide.shapes.add_picture(img_path, left, top, width=width)
        
        # Speaker notes
        if slide_data.get("notes"):
            notes_slide = slide.notes_slide
            notes_slide.notes_text_frame.text = slide_data["notes"]
    
    return prs


def list_templates():
    """List available templates."""
    print("Built-in styles:")
    for style in STYLES:
        print(f"  - {style}")
    
    print("\nCustom templates:")
    if TEMPLATES_DIR.exists():
        templates = list(TEMPLATES_DIR.glob("*.pptx"))
        if templates:
            for t in templates:
                print(f"  - {t.stem}")
        else:
            print("  (none)")
    else:
        print("  (none)")


def save_template(name: str, source_path: str):
    """Save a presentation as a reusable template."""
    TEMPLATES_DIR.mkdir(exist_ok=True)
    
    import shutil
    dest = TEMPLATES_DIR / f"{name}.pptx"
    shutil.copy(source_path, dest)
    print(f"Template saved: {dest}")


def main():
    parser = argparse.ArgumentParser(description="Create PowerPoint presentations")
    
    # Input options
    parser.add_argument("--outline", "-o", help="Markdown outline file")
    parser.add_argument("--json", "-j", help="JSON structure file")
    parser.add_argument("--topic", "-t", help="Topic for AI-generated outline")
    parser.add_argument("--slides", "-n", type=int, default=6, help="Number of slides (for --topic)")
    
    # Template/style options
    parser.add_argument("--template", default="minimal", help="Template name or style")
    parser.add_argument("--list-templates", action="store_true", help="List available templates")
    parser.add_argument("--save-template", metavar="NAME", help="Save presentation as template")
    parser.add_argument("--from", dest="from_file", help="Source file for --save-template")
    
    # Output
    parser.add_argument("--output", "-O", default="presentation.pptx", help="Output file path")
    
    # Features
    parser.add_argument("--generate-images", action="store_true", help="Generate images for slides")
    parser.add_argument("--data-source", help="Data source URI (twenty://, csv, etc.)")
    
    args = parser.parse_args()
    
    # Handle utility commands
    if args.list_templates:
        list_templates()
        return
    
    if args.save_template:
        if not args.from_file:
            print("Error: --save-template requires --from <file>", file=sys.stderr)
            sys.exit(1)
        save_template(args.save_template, args.from_file)
        return
    
    # Determine input
    presentation_data = None
    
    if args.outline:
        presentation_data = parse_outline(args.outline)
    elif args.json:
        with open(args.json, "r") as f:
            presentation_data = json.load(f)
    elif args.topic:
        # Generate outline from topic (placeholder - would use AI)
        presentation_data = {
            "title": args.topic,
            "subtitle": datetime.now().strftime("%B %Y"),
            "slides": [
                {"title": "Overview", "bullets": ["Key point 1", "Key point 2", "Key point 3"]},
                {"title": "Background", "bullets": ["Context", "History", "Current state"]},
                {"title": "Analysis", "bullets": ["Finding 1", "Finding 2", "Finding 3"]},
                {"title": "Recommendations", "bullets": ["Action 1", "Action 2", "Action 3"]},
                {"title": "Next Steps", "bullets": ["Timeline", "Resources", "Follow-up"]},
            ][:args.slides]
        }
        print(f"Note: Generated placeholder outline for '{args.topic}'", file=sys.stderr)
        print("For AI-generated content, provide a detailed outline file.", file=sys.stderr)
    else:
        print("Error: Provide --outline, --json, or --topic", file=sys.stderr)
        sys.exit(1)
    
    # Find template
    template_path = None
    style = "minimal"
    
    if args.template in STYLES:
        style = args.template
    else:
        # Look for custom template
        custom_template = TEMPLATES_DIR / f"{args.template}.pptx"
        if custom_template.exists():
            template_path = str(custom_template)
        elif Path(args.template).exists():
            template_path = args.template
    
    # Create presentation
    prs = create_presentation(presentation_data, style=style, template_path=template_path)
    
    # Save
    output_path = Path(args.output)
    prs.save(output_path)
    print(f"Created: {output_path}")
    print(f"Slides: {len(prs.slides)}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = ["python-pptx", "Pillow"]
# ///
"""
Template Creator - Generate branded PowerPoint templates with proper layouts.
"""

import argparse
import json
from pathlib import Path

from pptx import Presentation
from pptx.util import Inches, Pt, Emu
from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
from pptx.enum.shapes import MSO_SHAPE
from pptx.oxml.ns import nsmap
from pptx.oxml import parse_xml


from pptx.dml.color import RGBColor

SKILL_DIR = Path(__file__).parent.parent
TEMPLATES_DIR = SKILL_DIR / "templates"

# Template presets with full styling
PRESETS = {
    "minimal": {
        "name": "Minimal",
        "colors": {
            "background": "FFFFFF",
            "title": "1a1a1a",
            "body": "4a4a4a",
            "accent": "0066cc",
            "accent2": "00a86b",
        },
        "fonts": {
            "title": "Helvetica Neue",
            "body": "Helvetica Neue",
        },
        "sizes": {
            "title": 44,
            "subtitle": 24,
            "heading": 36,
            "body": 18,
            "caption": 14,
        }
    },
    "corporate": {
        "name": "Corporate",
        "colors": {
            "background": "FFFFFF",
            "title": "003366",
            "body": "333333",
            "accent": "0066cc",
            "accent2": "ff6600",
        },
        "fonts": {
            "title": "Arial",
            "body": "Arial",
        },
        "sizes": {
            "title": 40,
            "subtitle": 22,
            "heading": 32,
            "body": 18,
            "caption": 12,
        }
    },
    "creative": {
        "name": "Creative",
        "colors": {
            "background": "FAFAFA",
            "title": "2d2d2d",
            "body": "4a4a4a",
            "accent": "ff5722",
            "accent2": "9c27b0",
        },
        "fonts": {
            "title": "Avenir Next",
            "body": "Avenir",
        },
        "sizes": {
            "title": 48,
            "subtitle": 24,
            "heading": 40,
            "body": 20,
            "caption": 14,
        }
    },
    "dark": {
        "name": "Dark Mode",
        "colors": {
            "background": "1a1a2e",
            "title": "ffffff",
            "body": "e0e0e0",
            "accent": "00d4ff",
            "accent2": "ff6b6b",
        },
        "fonts": {
            "title": "SF Pro Display",
            "body": "SF Pro Text",
        },
        "sizes": {
            "title": 44,
            "subtitle": 24,
            "heading": 36,
            "body": 18,
            "caption": 14,
        }
    },
    "executive": {
        "name": "Executive",
        "colors": {
            "background": "FFFFFF",
            "title": "1e3a5f",
            "body": "2c3e50",
            "accent": "c9a227",
            "accent2": "1e3a5f",
        },
        "fonts": {
            "title": "Georgia",
            "body": "Calibri",
        },
        "sizes": {
            "title": 42,
            "subtitle": 22,
            "heading": 34,
            "body": 18,
            "caption": 12,
        }
    },
    "startup": {
        "name": "Startup Pitch",
        "colors": {
            "background": "FFFFFF",
            "title": "2d3436",
            "body": "636e72",
            "accent": "6c5ce7",
            "accent2": "00b894",
        },
        "fonts": {
            "title": "Poppins",
            "body": "Inter",
        },
        "sizes": {
            "title": 48,
            "subtitle": 24,
            "heading": 40,
            "body": 20,
            "caption": 14,
        }
    },
}


def hex_to_rgb(hex_color: str) -> RGBColor:
    """Convert hex color to RGBColor."""
    hex_color = hex_color.lstrip('#')
    r = int(hex_color[0:2], 16)
    g = int(hex_color[2:4], 16)
    b = int(hex_color[4:6], 16)
    return RGBColor(r, g, b)


def create_template(preset_name: str, output_path: Path) -> None:
    """Create a PowerPoint template with proper layouts."""
    preset = PRESETS.get(preset_name, PRESETS["minimal"])
    colors = preset["colors"]
    fonts = preset["fonts"]
    sizes = preset["sizes"]
    
    # Create presentation
    prs = Presentation()
    prs.slide_width = Inches(13.333)  # 16:9
    prs.slide_height = Inches(7.5)
    
    # We'll create slides that demonstrate each layout
    # Users can delete these after seeing them
    
    # 1. Title Slide
    slide_layout = prs.slide_layouts[0]
    slide = prs.slides.add_slide(slide_layout)
    
    title = slide.shapes.title
    title.text = "Presentation Title"
    title.text_frame.paragraphs[0].font.size = Pt(sizes["title"])
    title.text_frame.paragraphs[0].font.name = fonts["title"]
    title.text_frame.paragraphs[0].font.bold = True
    title.text_frame.paragraphs[0].font.color.rgb = hex_to_rgb(colors["title"])
    
    if len(slide.placeholders) > 1:
        subtitle = slide.placeholders[1]
        subtitle.text = "Subtitle goes here\nAuthor Name"
        for para in subtitle.text_frame.paragraphs:
            para.font.size = Pt(sizes["subtitle"])
            para.font.name = fonts["body"]
            para.font.color.rgb = hex_to_rgb(colors["body"])
    
    # Add accent bar
    shape = slide.shapes.add_shape(
        MSO_SHAPE.RECTANGLE,
        Inches(0), Inches(6.8),
        Inches(13.333), Inches(0.2)
    )
    shape.fill.solid()
    shape.fill.fore_color.rgb = hex_to_rgb(colors["accent"])
    shape.line.fill.background()
    
    # 2. Section Header
    slide_layout = prs.slide_layouts[2] if len(prs.slide_layouts) > 2 else prs.slide_layouts[0]
    slide = prs.slides.add_slide(slide_layout)
    
    if slide.shapes.title:
        slide.shapes.title.text = "Section Title"
        for para in slide.shapes.title.text_frame.paragraphs:
            para.font.size = Pt(sizes["title"])
            para.font.name = fonts["title"]
            para.font.bold = True
            para.font.color.rgb = hex_to_rgb(colors["accent"])
    
    # 3. Title and Content
    slide_layout = prs.slide_layouts[1]
    slide = prs.slides.add_slide(slide_layout)
    
    slide.shapes.title.text = "Slide Title"
    for para in slide.shapes.title.text_frame.paragraphs:
        para.font.size = Pt(sizes["heading"])
        para.font.name = fonts["title"]
        para.font.color.rgb = hex_to_rgb(colors["title"])
    
    # Find content placeholder
    for shape in slide.placeholders:
        if shape.placeholder_format.idx == 1:
            tf = shape.text_frame
            tf.clear()
            
            bullets = ["First key point", "Second key point", "Third key point with more detail", "Final point"]
            for i, bullet in enumerate(bullets):
                if i == 0:
                    p = tf.paragraphs[0]
                else:
                    p = tf.add_paragraph()
                p.text = bullet
                p.font.size = Pt(sizes["body"])
                p.font.name = fonts["body"]
                p.font.color.rgb = hex_to_rgb(colors["body"])
                p.level = 0
            break
    
    # 4. Two Column Layout
    slide_layout = prs.slide_layouts[3] if len(prs.slide_layouts) > 3 else prs.slide_layouts[1]
    slide = prs.slides.add_slide(slide_layout)
    
    if slide.shapes.title:
        slide.shapes.title.text = "Two Column Layout"
        for para in slide.shapes.title.text_frame.paragraphs:
            para.font.size = Pt(sizes["heading"])
            para.font.name = fonts["title"]
            para.font.color.rgb = hex_to_rgb(colors["title"])
    
    # 5. Image with Caption (simulated)
    slide = prs.slides.add_slide(prs.slide_layouts[1])
    slide.shapes.title.text = "Image Slide"
    for para in slide.shapes.title.text_frame.paragraphs:
        para.font.size = Pt(sizes["heading"])
        para.font.name = fonts["title"]
        para.font.color.rgb = hex_to_rgb(colors["title"])
    
    # Add placeholder rectangle for image
    img_placeholder = slide.shapes.add_shape(
        MSO_SHAPE.RECTANGLE,
        Inches(1), Inches(1.8),
        Inches(7), Inches(5)
    )
    img_placeholder.fill.solid()
    img_placeholder.fill.fore_color.rgb = hex_to_rgb(colors["body"])
    img_placeholder.fill.fore_color.brightness = 0.8
    img_placeholder.line.color.rgb = hex_to_rgb(colors["accent"])
    
    # Add text box for caption
    caption_box = slide.shapes.add_textbox(
        Inches(8.5), Inches(2),
        Inches(4), Inches(4)
    )
    tf = caption_box.text_frame
    tf.word_wrap = True
    p = tf.paragraphs[0]
    p.text = "Image description and supporting text goes here. This area can contain bullet points or paragraphs."
    p.font.size = Pt(sizes["body"])
    p.font.name = fonts["body"]
    p.font.color.rgb = hex_to_rgb(colors["body"])
    
    # 6. Quote/Callout Slide
    slide = prs.slides.add_slide(prs.slide_layouts[6] if len(prs.slide_layouts) > 6 else prs.slide_layouts[1])
    
    # Add large quote
    quote_box = slide.shapes.add_textbox(
        Inches(1.5), Inches(2),
        Inches(10), Inches(3)
    )
    tf = quote_box.text_frame
    tf.word_wrap = True
    p = tf.paragraphs[0]
    p.text = '"This is a powerful quote or key insight that you want to emphasize."'
    p.font.size = Pt(36)
    p.font.name = fonts["title"]
    p.font.italic = True
    p.font.color.rgb = hex_to_rgb(colors["accent"])
    p.alignment = PP_ALIGN.CENTER
    
    # Attribution
    p2 = tf.add_paragraph()
    p2.text = "— Attribution"
    p2.font.size = Pt(sizes["body"])
    p2.font.name = fonts["body"]
    p2.font.color.rgb = hex_to_rgb(colors["body"])
    p2.alignment = PP_ALIGN.CENTER
    
    # 7. Thank You / End Slide
    slide = prs.slides.add_slide(prs.slide_layouts[0])
    
    title = slide.shapes.title
    title.text = "Thank You"
    for para in title.text_frame.paragraphs:
        para.font.size = Pt(sizes["title"])
        para.font.name = fonts["title"]
        para.font.bold = True
        para.font.color.rgb = hex_to_rgb(colors["accent"])
        para.alignment = PP_ALIGN.CENTER
    
    if len(slide.placeholders) > 1:
        subtitle = slide.placeholders[1]
        subtitle.text = "Questions?\ncontact@example.com"
        for para in subtitle.text_frame.paragraphs:
            para.font.size = Pt(sizes["subtitle"])
            para.font.name = fonts["body"]
            para.font.color.rgb = hex_to_rgb(colors["body"])
            para.alignment = PP_ALIGN.CENTER
    
    # Add accent bar
    shape = slide.shapes.add_shape(
        MSO_SHAPE.RECTANGLE,
        Inches(0), Inches(0),
        Inches(13.333), Inches(0.2)
    )
    shape.fill.solid()
    shape.fill.fore_color.rgb = hex_to_rgb(colors["accent"])
    shape.line.fill.background()
    
    # Save
    prs.save(output_path)
    print(f"Created template: {output_path}")


def create_all_templates():
    """Generate all preset templates."""
    TEMPLATES_DIR.mkdir(exist_ok=True)
    
    for preset_name in PRESETS:
        output_path = TEMPLATES_DIR / f"{preset_name}.pptx"
        create_template(preset_name, output_path)
    
    # Also create a config file with template metadata
    config = {
        "templates": {
            name: {
                "name": preset["name"],
                "description": f"{preset['name']} theme with {preset['fonts']['title']} font",
                "colors": preset["colors"],
            }
            for name, preset in PRESETS.items()
        }
    }
    
    config_path = TEMPLATES_DIR / "templates.json"
    with open(config_path, "w") as f:
        json.dump(config, f, indent=2)
    print(f"Created config: {config_path}")


def list_presets():
    """List available template presets."""
    print("Available template presets:\n")
    for name, preset in PRESETS.items():
        colors = preset["colors"]
        print(f"  {name}")
        print(f"    Name: {preset['name']}")
        print(f"    Fonts: {preset['fonts']['title']} / {preset['fonts']['body']}")
        print(f"    Accent: #{colors['accent']}")
        print()


def main():
    parser = argparse.ArgumentParser(description="Create PowerPoint templates")
    parser.add_argument("--preset", "-p", help="Preset name to generate")
    parser.add_argument("--all", "-a", action="store_true", help="Generate all templates")
    parser.add_argument("--list", "-l", action="store_true", help="List available presets")
    parser.add_argument("--output", "-o", help="Output path (default: templates/<preset>.pptx)")
    
    args = parser.parse_args()
    
    if args.list:
        list_presets()
        return
    
    if args.all:
        create_all_templates()
        return
    
    if args.preset:
        if args.preset not in PRESETS:
            print(f"Unknown preset: {args.preset}")
            print(f"Available: {', '.join(PRESETS.keys())}")
            return
        
        TEMPLATES_DIR.mkdir(exist_ok=True)
        output_path = Path(args.output) if args.output else TEMPLATES_DIR / f"{args.preset}.pptx"
        create_template(args.preset, output_path)
        return
    
    parser.print_help()


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = ["python-pptx", "Pillow"]
# ///
"""
Create presentations using existing PPTX templates.
Preserves master slides, layouts, and branding from the template.
"""

import argparse
import json
import copy
from pathlib import Path
from datetime import datetime

from pptx import Presentation
from pptx.util import Inches, Pt
from pptx.dml.color import RGBColor
from pptx.enum.shapes import MSO_SHAPE

SKILL_DIR = Path(__file__).parent.parent
TEMPLATES_DIR = SKILL_DIR / "templates"


def hex_to_rgb(hex_color: str) -> RGBColor:
    """Convert hex color to RGBColor."""
    hex_color = hex_color.lstrip('#')
    r = int(hex_color[0:2], 16)
    g = int(hex_color[2:4], 16)
    b = int(hex_color[4:6], 16)
    return RGBColor(r, g, b)


def get_layout_by_name(prs: Presentation, name: str):
    """Find a layout by name (case-insensitive partial match)."""
    name_lower = name.lower()
    for master in prs.slide_masters:
        for layout in master.slide_layouts:
            if name_lower in layout.name.lower():
                return layout
    # Default to first content layout
    return prs.slide_layouts[1] if len(prs.slide_layouts) > 1 else prs.slide_layouts[0]


def create_from_template(template_path: str, slides_data: list, output_path: str, 
                          clear_content: bool = True, start_from: int = 0):
    """
    Create a new presentation based on an existing template.
    
    Args:
        template_path: Path to the template PPTX
        slides_data: List of slide definitions
        output_path: Where to save the result
        clear_content: If True, remove existing slides except master
        start_from: Keep slides 0 to start_from-1 from template
    """
    prs = Presentation(template_path)
    
    # Optionally clear existing content slides but keep structure
    if clear_content:
        # Keep only the first N slides (title, navigation, etc.)
        slides_to_keep = start_from
        while len(prs.slides) > slides_to_keep:
            rId = prs.slides._sldIdLst[slides_to_keep].rId
            prs.part.drop_rel(rId)
            del prs.slides._sldIdLst[slides_to_keep]
    
    # Add new slides from data
    for slide_def in slides_data:
        layout_name = slide_def.get("layout", "Title and Content")
        layout = get_layout_by_name(prs, layout_name)
        
        slide = prs.slides.add_slide(layout)
        
        # Set title
        if slide.shapes.title and slide_def.get("title"):
            slide.shapes.title.text = slide_def["title"]
        
        # Set content/bullets
        if slide_def.get("bullets"):
            # Find content placeholder
            for shape in slide.placeholders:
                if "content" in shape.name.lower() and shape.placeholder_format.idx == 1:
                    tf = shape.text_frame
                    tf.clear()
                    
                    for i, bullet in enumerate(slide_def["bullets"]):
                        if i == 0:
                            p = tf.paragraphs[0]
                        else:
                            p = tf.add_paragraph()
                        p.text = bullet
                        p.level = slide_def.get("bullet_level", 0)
                    break
        
        # Add custom text box
        if slide_def.get("text_box"):
            tb = slide_def["text_box"]
            txBox = slide.shapes.add_textbox(
                Inches(tb.get("left", 1)),
                Inches(tb.get("top", 1)),
                Inches(tb.get("width", 5)),
                Inches(tb.get("height", 1))
            )
            tf = txBox.text_frame
            tf.text = tb.get("text", "")
            tf.word_wrap = True
        
        # Add rounded rectangle (navigation button style)
        if slide_def.get("nav_buttons"):
            for btn in slide_def["nav_buttons"]:
                shape = slide.shapes.add_shape(
                    MSO_SHAPE.ROUNDED_RECTANGLE,
                    Inches(btn.get("left", 1)),
                    Inches(btn.get("top", 1)),
                    Inches(btn.get("width", 2)),
                    Inches(btn.get("height", 0.8))
                )
                shape.text = btn.get("text", "")
                
                if btn.get("fill_color"):
                    shape.fill.solid()
                    shape.fill.fore_color.rgb = hex_to_rgb(btn["fill_color"])
                
                if btn.get("line_color"):
                    shape.line.color.rgb = hex_to_rgb(btn["line_color"])
        
        # Add image from path
        if slide_def.get("image"):
            img = slide_def["image"]
            img_path = img.get("path")
            if img_path and Path(img_path).exists():
                slide.shapes.add_picture(
                    img_path,
                    Inches(img.get("left", 7)),
                    Inches(img.get("top", 1.5)),
                    width=Inches(img.get("width", 5))
                )
        
        # Speaker notes
        if slide_def.get("notes"):
            notes_slide = slide.notes_slide
            notes_slide.notes_text_frame.text = slide_def["notes"]
    
    prs.save(output_path)
    return len(prs.slides)


def main():
    parser = argparse.ArgumentParser(description="Create presentation from template")
    parser.add_argument("--template", "-t", required=True, help="Template PPTX path or name")
    parser.add_argument("--slides", "-s", required=True, help="JSON file with slide definitions")
    parser.add_argument("--output", "-o", default="output.pptx", help="Output path")
    parser.add_argument("--keep-slides", "-k", type=int, default=0, 
                       help="Keep first N slides from template")
    parser.add_argument("--append", "-a", action="store_true",
                       help="Append to existing slides instead of clearing")
    
    args = parser.parse_args()
    
    # Find template
    template_path = args.template
    if not Path(template_path).exists():
        # Check templates directory
        template_path = TEMPLATES_DIR / f"{args.template}.pptx"
        if not template_path.exists():
            print(f"Template not found: {args.template}")
            print(f"Available templates in {TEMPLATES_DIR}:")
            for t in TEMPLATES_DIR.glob("*.pptx"):
                print(f"  - {t.stem}")
            return
    
    # Load slide definitions
    with open(args.slides, "r") as f:
        slides_data = json.load(f)
    
    if not isinstance(slides_data, list):
        slides_data = slides_data.get("slides", [])
    
    # Create presentation
    num_slides = create_from_template(
        str(template_path),
        slides_data,
        args.output,
        clear_content=not args.append,
        start_from=args.keep_slides
    )
    
    print(f"Created: {args.output}")
    print(f"Total slides: {num_slides}")


if __name__ == "__main__":
    main()

{
  "templates": {
    "minimal": {
      "name": "Minimal",
      "description": "Minimal theme with Helvetica Neue font",
      "colors": {
        "background": "FFFFFF",
        "title": "1a1a1a",
        "body": "4a4a4a",
        "accent": "0066cc",
        "accent2": "00a86b"
      }
    },
    "corporate": {
      "name": "Corporate",
      "description": "Corporate theme with Arial font",
      "colors": {
        "background": "FFFFFF",
        "title": "003366",
        "body": "333333",
        "accent": "0066cc",
        "accent2": "ff6600"
      }
    },
    "creative": {
      "name": "Creative",
      "description": "Creative theme with Avenir Next font",
      "colors": {
        "background": "FAFAFA",
        "title": "2d2d2d",
        "body": "4a4a4a",
        "accent": "ff5722",
        "accent2": "9c27b0"
      }
    },
    "dark": {
      "name": "Dark Mode",
      "description": "Dark Mode theme with SF Pro Display font",
      "colors": {
        "background": "1a1a2e",
        "title": "ffffff",
        "body": "e0e0e0",
        "accent": "00d4ff",
        "accent2": "ff6b6b"
      }
    },
    "executive": {
      "name": "Executive",
      "description": "Executive theme with Georgia font",
      "colors": {
        "background": "FFFFFF",
        "title": "1e3a5f",
        "body": "2c3e50",
        "accent": "c9a227",
        "accent2": "1e3a5f"
      }
    },
    "startup": {
      "name": "Startup Pitch",
      "description": "Startup Pitch theme with Poppins font",
      "colors": {
        "background": "FFFFFF",
        "title": "2d3436",
        "body": "636e72",
        "accent": "6c5ce7",
        "accent2": "00b894"
      }
    }
  }
}