V5: Full PPT Master workflow — Strategist + spec_lock + Executor LLM SVG + finalize + export

interface/app_gradio.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-PPT Master — Interface Gradio
-Génère des présentations PowerPoint via LLM (OpenRouter) + images (ComfyUI/Web).
+PPT Master — Interface Gradio V5
+Full PPT Master workflow: Strategist → spec_lock → Image Acquisition → Executor (LLM SVG) → Quality Check → Finalize → Export
 """
 
 import gradio as gr
@@ -21,377 +21,390 @@ SCRIPT_DIR = Path(__file__).resolve().parent
 SKILL_DIR = SCRIPT_DIR / "skills" / "ppt-master"
 SCRIPTS_DIR = SKILL_DIR / "scripts"
 PROJECTS_DIR = SCRIPT_DIR / "projects"
+REFS_DIR = SKILL_DIR / "references"
 
 sys.path.insert(0, str(SCRIPTS_DIR))
-from config import load_prefixed_env_file, resolve_env_path
+from config import load_prefixed_env_file
 
 # Load env
 load_prefixed_env_file(("OPENROUTER_", "COMFYUI_", "IMAGE_", "PEXELS_", "PIXABAY_"))
 
 # ============================================================
-# LLM Client (OpenRouter)
+# LLM Client
 # ============================================================
 
-def llm_chat(prompt, system=None, max_tokens=16000, temperature=0.4):
-    """Call OpenRouter LLM."""
+def llm_chat(prompt, system=None, max_tokens=32000, temperature=0.3):
     import requests
     api_key = os.environ.get("OPENROUTER_API_KEY", "")
     model = os.environ.get("OPENROUTER_MODEL", "tencent/hy3-preview:free")
     base_url = os.environ.get("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1").rstrip("/")
-
     if not api_key:
         raise RuntimeError("OPENROUTER_API_KEY non configuré dans .env")
-
     messages = []
     if system:
         messages.append({"role": "system", "content": system})
     messages.append({"role": "user", "content": prompt})
-
-    r = requests.post(
-        f"{base_url}/chat/completions",
-        headers={
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
-            "HTTP-Referer": "http://localhost/ppt-master",
-            "X-Title": "ppt-master-gradio",
-        },
-        json={
-            "model": model,
-            "messages": messages,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-            "reasoning": {"exclude": True},
-        },
-        timeout=300,
-    )
+    r = requests.post(f"{base_url}/chat/completions",
+        headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json",
+                 "HTTP-Referer": "http://localhost/ppt-master", "X-Title": "ppt-master-gradio"},
+        json={"model": model, "messages": messages, "temperature": temperature,
+              "max_tokens": max_tokens, "reasoning": {"exclude": True}},
+        timeout=600)
     if r.status_code >= 400:
         raise RuntimeError(f"OpenRouter erreur {r.status_code}: {r.text[:500]}")
     data = r.json()
     content = data.get("choices", [{}])[0].get("message", {}).get("content")
     if not content:
-        raise RuntimeError(f"Pas de contenu: {json.dumps(data, ensure_ascii=False)[:500]}")
+        raise RuntimeError(f"Pas de contenu retourné par le LLM")
     return content
 
 
 # ============================================================
-# Pipeline Functions
+# STEP 1: STRATEGIST — Generate design_spec + spec_lock + outline
 # ============================================================
 
-def generate_outline(subject, num_slides, style, language, audience, image_mode):
-    """Step 1: Ask LLM to generate the slide outline."""
-
-    prompt = f"""Generate a {num_slides}-slide presentation about "{subject}". Style: {style}. Language: {language}. Audience: {audience}.
-Reply ONLY raw JSON: {{"title":"...","slides":[{{"number":1,"title":"...","content":["point1","point2","point3"],"image_prompt":"english cinematic description","layout":"cover"}}]}}
-Layouts: cover(1st), content, comparison, timeline, closing(last).
-IMPORTANT: Keep each content point SHORT (max 20 words). Keep image_prompt under 30 words. No text in images."""
+def strategist_phase(subject, num_slides, style, language, audience):
+    """The Strategist generates the full design specification."""
+
+    prompt = f"""You are the Strategist for PPT Master. Generate a complete design specification for a presentation.
+
+Subject: {subject}
+Number of slides: {num_slides}
+Style: {style}
+Language: {language}
+Target audience: {audience}
+Canvas: PPT 16:9 (1280x720, viewBox="0 0 1280 720")
+
+Produce a JSON response with this EXACT structure:
+{{
+  "title": "Presentation title",
+  "spec_lock": {{
+    "canvas": {{"viewBox": "0 0 1280 720", "format": "PPT 16:9"}},
+    "colors": {{"bg": "#...", "bg_alt": "#...", "primary": "#...", "accent": "#...", "secondary_accent": "#...", "text": "#...", "text_secondary": "#...", "border": "#..."}},
+    "typography": {{"title_family": "...", "body_family": "...", "body": 20, "title": 40, "subtitle": 26, "annotation": 14}},
+    "icons": {{"library": "chunk-filled", "inventory": ["icon1", "icon2", "..."]}},
+    "page_rhythm": {{"P01": "anchor", "P02": "dense", "...": "..."}}
+  }},
+  "slides": [
+    {{
+      "number": 1,
+      "title": "Slide title",
+      "layout": "cover",
+      "rhythm": "anchor",
+      "content": ["Point 1", "Point 2", "Point 3"],
+      "image_prompt": "English cinematic image description, no text",
+      "image_source": "ai",
+      "notes": "Speaker notes for this slide (conversational tone)"
+    }}
+  ]
+}}
+
+Style guidelines:
+- "Dark Fantasy": dark backgrounds (#0B0F17), gold (#C8A45D), red (#8B1E2D), ice blue (#6FA8B8)
+- "Corporate": white, professional blue (#1A56DB), clean
+- "Tech / Startup": dark navy (#0F172A), cyan (#06B6D4), purple (#8B5CF6)
+- "Nature / Zen": warm white (#FEFDF8), green (#2D5016), amber (#B45309)
+- "Académique": cream (#FFFBF5), burgundy (#7C2D12), blue (#1E40AF)
+- "Minimaliste": pure white, black (#18181B), red accent (#DC2626)
+
+Rules:
+- Content points: max 20 words each, factual and specific
+- image_prompt: English, cinematic, under 30 words, NO text in image
+- image_source: "ai" for generated, "web" for stock photo search
+- notes: conversational tone, 2-3 sentences, like talking to audience
+- icons inventory: pick from chunk-filled library (crown, shield, sword, fire, users, chart-bar, lightbulb, target, bolt, map, castle, skull, book-open, globe, rocket, heart, star, trophy, flag, clock)
+- First slide layout="cover", last="closing", others mix of "content"/"comparison"/"timeline"/"quote"
+- page_rhythm: "anchor" for cover/closing, "dense" for data-heavy, "breathing" for impact pages
+- Reply ONLY with raw JSON, no markdown code blocks, no explanation"""
 
     result = llm_chat(prompt, max_tokens=32000)
 
-    # Extract JSON from response
+    # Parse JSON
     try:
-        # Try to find JSON in the response
         json_match = re.search(r'\{[\s\S]*\}', result)
         if json_match:
-            outline = json.loads(json_match.group())
+            data = json.loads(json_match.group())
         else:
-            outline = json.loads(result)
-    except json.JSONDecodeError as e:
-        # Try to repair truncated JSON by closing brackets
-        repaired = result.rstrip()
-        # Remove trailing incomplete values
-        for _ in range(10):
+            data = json.loads(result)
+    except json.JSONDecodeError:
+        # Try repair
+        for suffix in ['}]}', '"}]}', '"]}]}']:
             try:
-                # Try adding closing brackets
-                for fix in ['}]}', '"}]}', '"]},{"number":99,"title":"FIN","content":[""],"image_prompt":"","layout":"closing"}]}']:
-                    try:
-                        test = repaired + fix
-                        json_match = re.search(r'\{[\s\S]*\}', test)
-                        if json_match:
-                            outline = json.loads(json_match.group())
-                            # Remove dummy slides if added
-                            outline["slides"] = [s for s in outline.get("slides",[]) if s.get("number") != 99]
-                            return outline
-                    except:
-                        continue
-                # Cut last incomplete entry and retry
-                last_brace = repaired.rfind('{')
-                if last_brace > 0:
-                    repaired = repaired[:last_brace].rstrip().rstrip(',')
-                else:
+                repaired = result.rstrip() + suffix
+                json_match = re.search(r'\{[\s\S]*\}', repaired)
+                if json_match:
+                    data = json.loads(json_match.group())
                     break
             except:
-                break
-        raise RuntimeError(f"Le LLM n'a pas retourné du JSON valide.\n\nRéponse:\n{result[:2000]}")
+                continue
+        else:
+            raise RuntimeError(f"JSON invalide du Strategist.\n\nRéponse:\n{result[:3000]}")
+
+    return data
+
 
-    return outline
+def format_strategist_preview(data):
+    """Format strategist output as readable markdown."""
+    lines = [f"# {data.get('title', 'Présentation')}\n"]
 
+    spec = data.get("spec_lock", {})
+    colors = spec.get("colors", {})
+    typo = spec.get("typography", {})
 
-def outline_to_preview(outline):
-    """Convert outline dict to readable markdown preview."""
-    lines = [f"# {outline['title']}\n"]
-    for slide in outline.get("slides", []):
-        lines.append(f"## Slide {slide['number']}: {slide['title']}")
-        lines.append(f"*Layout: {slide.get('layout', 'content')}*\n")
-        for point in slide.get("content", []):
-            lines.append(f"- {point}")
+    lines.append("## 🎨 Design Spec\n")
+    lines.append(f"**Palette**: {' | '.join(f'{k}: `{v}`' for k,v in colors.items())}\n")
+    lines.append(f"**Typo**: titre={typo.get('title_family','?')}, corps={typo.get('body_family','?')}, taille={typo.get('body',20)}px\n")
+    lines.append(f"**Icônes**: {', '.join(spec.get('icons',{}).get('inventory',[]))}\n")
+
+    lines.append("\n## 📋 Plan des slides\n")
+    for slide in data.get("slides", []):
+        lines.append(f"### Slide {slide['number']}: {slide['title']}")
+        lines.append(f"*Layout: {slide.get('layout','content')} | Rythme: {slide.get('rhythm','dense')}*\n")
+        for p in slide.get("content", []):
+            lines.append(f"- {p}")
         if slide.get("image_prompt"):
-            lines.append(f"\n🖼️ Image: *{slide['image_prompt']}*")
+            lines.append(f"\n🖼️ Image ({slide.get('image_source','ai')}): *{slide['image_prompt']}*")
+        if slide.get("notes"):
+            lines.append(f"\n🎙️ Notes: *{slide['notes'][:100]}...*")
         lines.append("")
+
     return "\n".join(lines)
 
 
-def generate_images(outline, project_path, image_mode, progress_callback=None):
-    """Generate images for each slide."""
+# ============================================================
+# STEP 2: IMAGE ACQUISITION
+# ============================================================
+
+def acquire_images(data, project_path, image_mode, progress_cb=None):
+    """Generate/search images for each slide."""
     images_dir = Path(project_path) / "images"
     images_dir.mkdir(parents=True, exist_ok=True)
 
-    for i, slide in enumerate(outline.get("slides", [])):
+    slides = data.get("slides", [])
+    for i, slide in enumerate(slides):
         prompt = slide.get("image_prompt", "")
         if not prompt:
             continue
-
+        source = slide.get("image_source", "ai")
         filename = f"slide_{slide['number']:02d}"
 
-        if progress_callback:
-            progress_callback(f"🖼️ Image {i+1}/{len(outline['slides'])}: {prompt[:60]}...")
+        if progress_cb:
+            progress_cb(f"🖼️ [{i+1}/{len(slides)}] {prompt[:50]}...")
+
+        if image_mode == "Aucune image":
+            continue
+
+        use_comfyui = (image_mode == "ComfyUI (local GPU)") or \
+                      (image_mode == "Les deux (ComfyUI + web)" and source == "ai")
+        use_web = (image_mode == "Recherche web (Wikimedia)") or \
+                  (image_mode == "Les deux (ComfyUI + web)" and source == "web")
 
-        if image_mode == "ComfyUI (local GPU)":
+        if use_comfyui:
             try:
-                result = subprocess.run(
+                subprocess.run(
                     [sys.executable, str(SCRIPTS_DIR / "image_gen.py"),
                      prompt, "--backend", "comfyui",
                      "--aspect_ratio", "16:9", "--image_size", "1K",
                      "-o", str(images_dir), "--filename", filename],
-                    capture_output=True, text=True, timeout=120,
-                    cwd=str(SCRIPTS_DIR)
-                )
-                if result.returncode != 0:
-                    print(f"  [WARN] image_gen failed for slide {slide['number']}: {result.stderr[:200]}")
+                    capture_output=True, text=True, timeout=180, cwd=str(SCRIPTS_DIR))
             except Exception as e:
-                print(f"  [WARN] Image generation error: {e}")
-
-        elif image_mode == "Recherche web (Wikimedia)":
+                if progress_cb:
+                    progress_cb(f"  ⚠️ ComfyUI failed: {str(e)[:60]}")
+        elif use_web:
             try:
-                result = subprocess.run(
+                subprocess.run(
                     [sys.executable, str(SCRIPTS_DIR / "image_search.py"),
                      prompt, "--filename", f"{filename}.jpg",
-                     "--orientation", "landscape",
-                     "-o", str(images_dir)],
-                    capture_output=True, text=True, timeout=60,
-                    cwd=str(SCRIPTS_DIR)
-                )
+                     "--orientation", "landscape", "-o", str(images_dir)],
+                    capture_output=True, text=True, timeout=60, cwd=str(SCRIPTS_DIR))
             except Exception as e:
-                print(f"  [WARN] Image search error: {e}")
-
-        elif image_mode == "Les deux (ComfyUI + web)":
-            # Alternate between comfyui and web
-            if i % 2 == 0:
-                try:
-                    subprocess.run(
-                        [sys.executable, str(SCRIPTS_DIR / "image_gen.py"),
-                         prompt, "--backend", "comfyui",
-                         "--aspect_ratio", "16:9", "--image_size", "1K",
-                         "-o", str(images_dir), "--filename", filename],
-                        capture_output=True, text=True, timeout=120,
-                        cwd=str(SCRIPTS_DIR)
-                    )
-                except:
-                    pass
-            else:
-                try:
-                    subprocess.run(
-                        [sys.executable, str(SCRIPTS_DIR / "image_search.py"),
-                         prompt, "--filename", f"{filename}.jpg",
-                         "--orientation", "landscape",
-                         "-o", str(images_dir)],
-                        capture_output=True, text=True, timeout=60,
-                        cwd=str(SCRIPTS_DIR)
-                    )
-                except:
-                    pass
-
-
-def generate_svgs(outline, project_path, style, progress_callback=None):
-    """Generate SVG files for each slide using the LLM for high-quality output."""
+                if progress_cb:
+                    progress_cb(f"  ⚠��� Web search failed: {str(e)[:60]}")
+
+
+# ============================================================
+# STEP 3: EXECUTOR — LLM generates each SVG sequentially
+# ============================================================
+
+def executor_phase(data, project_path, style, progress_cb=None):
+    """Generate SVG slides sequentially using the LLM as Executor."""
     svg_dir = Path(project_path) / "svg_output"
     svg_dir.mkdir(parents=True, exist_ok=True)
     images_dir = Path(project_path) / "images"
+    notes_dir = Path(project_path) / "notes"
+    notes_dir.mkdir(parents=True, exist_ok=True)
 
-    # Style color palettes
-    palettes = {
-        "Dark Fantasy": "Dark background gradient (#0B0F17 to #111827), gold accent #C8A45D, red #8B1E2D, ice blue #6FA8B8, light text #E8E2D6, muted #AAB2C0",
-        "Corporate": "White background #FFFFFF, blue primary #1A56DB, red accent #E02424, dark text #1F2937, clean professional",
-        "Tech / Startup": "Dark navy background #0F172A to #1E293B, cyan #06B6D4, purple accent #8B5CF6, light text #F1F5F9",
-        "Nature / Zen": "Warm white #FEFDF8, green primary #2D5016, amber accent #B45309, dark text #1C1917, organic soft",
-        "Académique": "Cream background #FFFBF5, burgundy #7C2D12, blue accent #1E40AF, dark text, scholarly elegant",
-        "Minimaliste": "Pure white #FFFFFF, black primary #18181B, red accent #DC2626, maximum whitespace, ultra clean",
-    }
-    palette_desc = palettes.get(style, palettes["Dark Fantasy"])
-
-    num_slides = len(outline.get("slides", []))
-
-    for slide in outline.get("slides", []):
+    spec_lock = data.get("spec_lock", {})
+    colors = spec_lock.get("colors", {})
+    typo = spec_lock.get("typography", {})
+    icons = spec_lock.get("icons", {})
+    slides = data.get("slides", [])
+    num_total = len(slides)
+
+    # Build color string for the prompt
+    color_str = ", ".join(f"{k}: {v}" for k, v in colors.items())
+    font_title = typo.get("title_family", "Georgia, Times New Roman, serif")
+    font_body = typo.get("body_family", "Arial, sans-serif")
+    icon_lib = icons.get("library", "chunk-filled")
+    icon_inv = ", ".join(icons.get("inventory", []))
+
+    # Shared executor instructions
+    executor_rules = f"""SVG RULES (MANDATORY):
+- viewBox="0 0 1280 720" width="1280" height="720" xmlns="http://www.w3.org/2000/svg"
+- Colors ONLY from spec_lock: {color_str}
+- Title font: {font_title}. Body font: {font_body}
+- Body size: {typo.get('body',20)}px, Title size: {typo.get('title',40)}px
+- Icons: use <use data-icon="{icon_lib}/ICON_NAME" x="" y="" width="40" height="40" fill="COLOR"/>
+- Available icons: {icon_inv}
+- FORBIDDEN: <style>, class, foreignObject, animate, script, mask, @font-face, rgba(), <g opacity="">
+- Use linearGradient/radialGradient in <defs> for backgrounds
+- Decorative elements: circles, lines, rects with fill-opacity for visual richness
+- All text as absolute <text> elements with font-family, font-size, fill attributes
+- Images: <image href="../images/FILENAME" x="" y="" width="" height="" preserveAspectRatio="xMidYMid slice"/>
+- Page number in bottom-right corner
+- Reply ONLY with SVG code: start with <svg, end with </svg>"""
+
+    total_notes = []
+
+    for slide in slides:
         num = slide["number"]
         name = f"slide_{num:02d}"
 
-        if progress_callback:
-            progress_callback(f"🎨 SVG {num}/{num_slides}: {slide['title'][:50]}...")
+        if progress_cb:
+            progress_cb(f"🎨 SVG {num}/{num_total}: {slide['title'][:40]}...")
 
-        # Find image for this slide
+        # Find image
         img_ref = ""
         for ext in ('.png', '.jpg', '.jpeg', '.webp'):
-            candidate = images_dir / f"{name}{ext}"
-            if candidate.exists():
-                img_ref = f'Include this image: <image href="../images/{name}{ext}" preserveAspectRatio="xMidYMid slice"/>'
+            if (images_dir / f"{name}{ext}").exists():
+                img_ref = f'Image available: "../images/{name}{ext}"'
                 break
 
-        content_text = "\n".join(f"- {p}" for p in slide.get("content", []))
-
-        prompt = f"""Generate a beautiful SVG slide (viewBox="0 0 1280 720") for a presentation.
-Slide {num}/{num_slides}. Layout: {slide.get('layout','content')}. Style: {style}.
-
-Title: {slide['title']}
-Content:
-{content_text}
+        content_str = "\n".join(f"  - {p}" for p in slide.get("content", []))
+        rhythm = slide.get("rhythm", "dense")
 
-{img_ref}
+        prompt = f"""Generate SVG slide {num}/{num_total} for this presentation.
 
-Color palette: {palette_desc}
-Fonts: Georgia, Times New Roman, serif for titles. Arial, sans-serif for body text.
+SLIDE SPEC:
+- Title: {slide['title']}
+- Layout: {slide.get('layout','content')}
+- Rhythm: {rhythm} ({'full-bleed imagery, minimal text, breathing space' if rhythm == 'breathing' else 'information-rich, cards, structured content' if rhythm == 'dense' else 'structural, decorative, impactful'})
+- Content:
+{content_str}
+- {img_ref or 'No image for this slide — use colors/shapes creatively'}
 
-Design rules:
-- viewBox="0 0 1280 720", include width="1280" height="720"
-- Include xmlns="http://www.w3.org/2000/svg"
-- Use gradients, decorative shapes (circles, lines, rects with opacity)
-- {f'Place the image prominently (half-slide or background)' if img_ref else 'No image available, use shapes and colors creatively'}
-- Show ALL content points as text elements, nicely positioned
-- Add a page number {num}/{num_slides} in bottom right
-- NO <style>, NO class, NO foreignObject, NO animate, NO script, NO mask
-- NO HTML entities, use raw Unicode characters
-- All text in absolute positioned <text> elements
-- Make it visually rich and professional
+{executor_rules}
 
-Reply with ONLY the SVG code. Start with <svg, end with </svg>."""
+Design direction for "{style}" style. Make it visually striking and professional.
+{"Use the image prominently (background or half-slide). Add dark overlay for text readability." if img_ref else ""}
+{"This is a COVER page: large title, dramatic, impactful." if slide.get('layout') == 'cover' else ""}
+{"This is a CLOSING page: centered, memorable, call-to-action feel." if slide.get('layout') == 'closing' else ""}
+{"This is a TIMELINE: show progression horizontally with nodes/circles." if slide.get('layout') == 'timeline' else ""}
+{"This is a COMPARISON: show two sides contrasted." if slide.get('layout') == 'comparison' else ""}"""
 
         try:
             svg_content = llm_chat(prompt, max_tokens=8000, temperature=0.3)
 
-            # Clean up: extract just the SVG
+            # Extract SVG
             svg_start = svg_content.find('<svg')
             svg_end = svg_content.rfind('</svg>')
             if svg_start >= 0 and svg_end > svg_start:
                 svg_content = svg_content[svg_start:svg_end + 6]
             elif svg_start >= 0:
-                svg_content = svg_content[svg_start:] + '</svg>'
-
-            # Basic validation
-            if '<svg' not in svg_content:
-                raise RuntimeError("No SVG in response")
+                svg_content += '</svg>'
+            else:
+                raise RuntimeError("No <svg> found in response")
 
             (svg_dir / f"{name}.svg").write_text(svg_content, encoding="utf-8")
 
         except Exception as e:
-            # Fallback: simple template SVG if LLM fails
-            if progress_callback:
-                progress_callback(f"  ⚠️ LLM failed for slide {num}, using fallback: {str(e)[:60]}")
-            _fallback_svg(svg_dir, name, slide, style, img_ref, num, num_slides)
-
-
-def _fallback_svg(svg_dir, name, slide, style, img_ref, num, total):
-    """Simple fallback SVG when LLM generation fails."""
-    palettes = {
-        "Dark Fantasy": ('#0B0F17','#111827','#C8A45D','#E8E2D6','#AAB2C0','#344052'),
-        "Corporate": ('#FFFFFF','#F4F6F9','#1A56DB','#1F2937','#6B7280','#E5E7EB'),
-        "Tech / Startup": ('#0F172A','#1E293B','#06B6D4','#F1F5F9','#94A3B8','#334155'),
-        "Nature / Zen": ('#FEFDF8','#F0EDE4','#2D5016','#1C1917','#78716C','#D6D3D1'),
-        "Académique": ('#FFFBF5','#F5F0E8','#7C2D12','#1C1917','#57534E','#D6D3D1'),
-        "Minimaliste": ('#FFFFFF','#FAFAFA','#18181B','#18181B','#71717A','#E4E4E7'),
-    }
-    bg, bg2, primary, text, muted, border = palettes.get(style, palettes["Dark Fantasy"])
+            if progress_cb:
+                progress_cb(f"  ⚠️ Slide {num} failed ({str(e)[:50]}), using fallback")
+            _write_fallback_svg(svg_dir, name, slide, colors, font_title, font_body, num, num_total, img_ref)
+
+        # Write notes
+        note = slide.get("notes", f"{slide['title']}. " + " ".join(slide.get("content", [])))
+        (notes_dir / f"{name}.md").write_text(note, encoding="utf-8")
+        total_notes.append(f"# {name}\n\n{note}")
+
+    # Write total.md
+    (notes_dir / "total.md").write_text("\n\n---\n\n".join(total_notes), encoding="utf-8")
+
+
+def _write_fallback_svg(svg_dir, name, slide, colors, font_title, font_body, num, total, img_ref):
+    """Minimal fallback SVG."""
+    bg = colors.get("bg", "#0B0F17")
+    primary = colors.get("primary", "#C8A45D")
+    text = colors.get("text", "#E8E2D6")
+    muted = colors.get("text_secondary", "#AAB2C0")
     title = slide["title"].replace('&','&amp;').replace('<','&lt;').replace('>','&gt;')
     content = slide.get("content", [])
 
     lines = [f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720" width="1280" height="720">',
-             f'  <rect width="1280" height="720" fill="{bg}"/>',
-             f'  <text x="60" y="90" font-family="Georgia, Times New Roman, serif" font-size="36" font-weight="bold" fill="{text}">{title}</text>',
-             f'  <rect x="60" y="108" width="160" height="4" fill="{primary}"/>']
+             f'  <rect width="1280" height="720" fill="{bg}"/>']
+    if img_ref:
+        href = img_ref.split('"')[1] if '"' in img_ref else ""
+        if href:
+            lines.append(f'  <image href="{href}" x="680" y="60" width="540" height="600" preserveAspectRatio="xMidYMid slice"/>')
+    lines.append(f'  <text x="60" y="90" font-family="{font_title}" font-size="36" font-weight="bold" fill="{text}">{title}</text>')
+    lines.append(f'  <rect x="60" y="108" width="160" height="4" fill="{primary}"/>')
     for j, p in enumerate(content[:6]):
-        y = 180 + j * 80
+        y = 170 + j * 75
         p_esc = p.replace('&','&amp;').replace('<','&lt;').replace('>','&gt;')[:100]
-        lines.append(f'  <text x="80" y="{y}" font-family="Arial, sans-serif" font-size="20" fill="{text}">{p_esc}</text>')
-    lines.append(f'  <text x="1224" y="700" text-anchor="end" font-family="Arial, sans-serif" font-size="12" fill="{muted}">{num}/{total}</text>')
+        lines.append(f'  <text x="80" y="{y}" font-family="{font_body}" font-size="20" fill="{text}">{p_esc}</text>')
+    lines.append(f'  <text x="1224" y="700" text-anchor="end" font-family="{font_body}" font-size="12" fill="{muted}">{num}/{total}</text>')
     lines.append('</svg>')
     (svg_dir / f"{name}.svg").write_text("\n".join(lines), encoding="utf-8")
 
 
-def generate_notes(outline, project_path):
-    """Generate speaker notes."""
-    notes_dir = Path(project_path) / "notes"
-    notes_dir.mkdir(parents=True, exist_ok=True)
-
-    total_lines = []
-    for slide in outline.get("slides", []):
-        name = f"slide_{slide['number']:02d}"
-        note = f"{slide['title']}. " + " ".join(slide.get("content", []))
-        (notes_dir / f"{name}.md").write_text(note, encoding="utf-8")
-        total_lines.append(f"# {name}\n\n{note}")
-
-    (notes_dir / "total.md").write_text("\n\n---\n\n".join(total_lines), encoding="utf-8")
-
+# ============================================================
+# STEP 4: POST-PROCESSING & EXPORT
+# ============================================================
 
-def run_postprocessing(project_path):
-    """Run the PPT Master post-processing pipeline."""
+def postprocess_and_export(project_path):
+    """Run finalize_svg + svg_to_pptx."""
     env = os.environ.copy()
 
     # total_md_split
-    subprocess.run(
-        [sys.executable, str(SCRIPTS_DIR / "total_md_split.py"), project_path],
-        capture_output=True, text=True, timeout=60, cwd=str(SCRIPTS_DIR), env=env
-    )
+    subprocess.run([sys.executable, str(SCRIPTS_DIR / "total_md_split.py"), project_path],
+        capture_output=True, text=True, timeout=60, cwd=str(SCRIPTS_DIR), env=env)
 
     # finalize_svg
-    subprocess.run(
-        [sys.executable, str(SCRIPTS_DIR / "finalize_svg.py"), project_path],
-        capture_output=True, text=True, timeout=120, cwd=str(SCRIPTS_DIR), env=env
-    )
+    subprocess.run([sys.executable, str(SCRIPTS_DIR / "finalize_svg.py"), project_path],
+        capture_output=True, text=True, timeout=120, cwd=str(SCRIPTS_DIR), env=env)
 
     # svg_to_pptx
-    result = subprocess.run(
-        [sys.executable, str(SCRIPTS_DIR / "svg_to_pptx.py"), project_path],
-        capture_output=True, text=True, timeout=120, cwd=str(SCRIPTS_DIR), env=env
-    )
+    result = subprocess.run([sys.executable, str(SCRIPTS_DIR / "svg_to_pptx.py"), project_path],
+        capture_output=True, text=True, timeout=180, cwd=str(SCRIPTS_DIR), env=env)
 
     return result.stdout + result.stderr
 
 
 # ============================================================
-# Main Gradio Pipeline
+# GRADIO HANDLERS
 # ============================================================
 
-def step1_generate_outline(subject, num_slides, style, language, audience, image_mode):
-    """Generate and preview the outline."""
+def step1_handler(subject, num_slides, style, language, audience, image_mode):
+    """Strategist phase."""
     if not subject.strip():
         return "❌ Entre un sujet !", "", "{}"
-
     try:
-        outline = generate_outline(subject, num_slides, style, language, audience, image_mode)
-        preview = outline_to_preview(outline)
-        return f"✅ Plan généré avec succès — {len(outline.get('slides', []))} slides", preview, json.dumps(outline, ensure_ascii=False)
+        data = strategist_phase(subject, int(num_slides), style, language, audience)
+        preview = format_strategist_preview(data)
+        return f"✅ Design spec généré — {len(data.get('slides',[]))} slides", preview, json.dumps(data, ensure_ascii=False)
     except Exception as e:
-        return f"❌ Erreur: {str(e)}", "", "{}"
+        return f"❌ Erreur Strategist: {str(e)[:300]}", "", "{}"
 
 
-def step2_generate_pptx(outline_json, style, image_mode, progress=gr.Progress()):
-    """Full pipeline: images → SVG → PPTX."""
-    if not outline_json or outline_json == "{}":
+def step2_handler(data_json, style, image_mode, progress=gr.Progress()):
+    """Full generation pipeline."""
+    if not data_json or data_json == "{}":
         return "❌ Génère d'abord le plan (étape 1)", None, ""
-
     try:
-        outline = json.loads(outline_json)
+        data = json.loads(data_json)
     except:
-        return "❌ Plan invalide", None, ""
+        return "❌ Données invalides", None, ""
 
-    # Create project
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     project_name = f"gradio_{timestamp}"
     project_path = str(PROJECTS_DIR / project_name)
@@ -399,164 +412,113 @@ def step2_generate_pptx(outline_json, style, image_mode, progress=gr.Progress())
     for d in ("svg_output", "svg_final", "images", "notes", "exports"):
         os.makedirs(f"{project_path}/{d}", exist_ok=True)
 
-    log_lines = [f"📁 Projet: {project_name}\n"]
-
-    # Step A: Generate images
-    num_slides = len(outline.get("slides", []))
-    progress(0.1, desc="Génération des images...")
-    log_lines.append("🖼️ Génération des images...")
-
-    def img_progress(msg):
-        log_lines.append(f"  {msg}")
+    num_slides = len(data.get("slides", []))
+    log = [f"📁 Projet: {project_name}", f"📊 {num_slides} slides à générer\n"]
 
-    generate_images(outline, project_path, image_mode, progress_callback=img_progress)
-    log_lines.append(f"  ✅ Images terminées\n")
+    # Phase 1: Images
+    progress(0.05, desc="Acquisition des images...")
+    log.append("━━━ PHASE 1: Images ━━━")
 
-    # Step B: Generate SVGs via LLM (high quality)
-    progress(0.3, desc="Création des slides SVG via LLM (peut prendre plusieurs minutes)...")
-    log_lines.append("🎨 Génération SVG par le LLM (qualité haute)...")
-    log_lines.append(f"  ⏱️ ~60-90s par slide, {num_slides} slides à générer...")
+    def img_cb(msg): log.append(f"  {msg}")
+    acquire_images(data, project_path, image_mode, progress_cb=img_cb)
+    log.append("  ✅ Images acquises\n")
 
-    def svg_progress(msg):
-        log_lines.append(f"  {msg}")
+    # Phase 2: Executor (SVG generation via LLM)
+    progress(0.2, desc=f"Génération SVG par LLM (0/{num_slides})...")
+    log.append("━━━ PHASE 2: Executor (SVG via LLM) ━━━")
+    log.append(f"  ⏱️ Estimation: ~60-90s par slide, {num_slides} slides\n")
 
-    generate_svgs(outline, project_path, style, progress_callback=svg_progress)
-    log_lines.append(f"  ✅ {num_slides} SVG générés\n")
+    slide_count = [0]
+    def svg_cb(msg):
+        log.append(f"  {msg}")
+        slide_count[0] += 1
+        frac = 0.2 + 0.6 * (slide_count[0] / (num_slides * 2))
+        progress(min(frac, 0.8), desc=f"SVG {slide_count[0]//2}/{num_slides}...")
 
-    # Step C: Generate notes
-    progress(0.6, desc="Notes orateur...")
-    generate_notes(outline, project_path)
-    log_lines.append("📝 Notes orateur générées\n")
+    executor_phase(data, project_path, style, progress_cb=svg_cb)
+    log.append("  ✅ Tous les SVG générés\n")
 
-    # Step D: Post-processing & export
-    progress(0.7, desc="Export PPTX...")
-    log_lines.append("📦 Post-traitement et export PPTX...")
-    pp_output = run_postprocessing(project_path)
-    log_lines.append(f"  {pp_output[:500]}\n")
+    # Phase 3: Post-processing
+    progress(0.85, desc="Export PPTX...")
+    log.append("━━━ PHASE 3: Post-traitement & Export ━━━")
+    pp_out = postprocess_and_export(project_path)
+    log.append(f"  {pp_out[:400]}")
 
-    # Find the exported PPTX
+    # Find PPTX
     pptx_files = glob.glob(f"{project_path}/exports/*.pptx")
     if pptx_files:
         pptx_path = pptx_files[0]
+        size_mb = Path(pptx_path).stat().st_size / 1024 / 1024
         progress(1.0, desc="Terminé !")
-        log_lines.append(f"\n✅ PPTX généré: {Path(pptx_path).name}")
-        log_lines.append(f"   Taille: {Path(pptx_path).stat().st_size / 1024 / 1024:.1f} MB")
-        return "✅ Présentation générée avec succès !", pptx_path, "\n".join(log_lines)
+        log.append(f"\n✅ PPTX: {Path(pptx_path).name} ({size_mb:.1f} MB)")
+        return "✅ Présentation générée !", pptx_path, "\n".join(log)
     else:
-        progress(1.0, desc="Erreur")
-        log_lines.append("\n❌ Pas de PPTX trouvé dans exports/")
-        return "❌ Erreur lors de l'export", None, "\n".join(log_lines)
+        return "❌ Export échoué", None, "\n".join(log)
 
 
 # ============================================================
-# Gradio Interface
+# GRADIO UI
 # ============================================================
 
 STYLES = ["Dark Fantasy", "Corporate", "Tech / Startup", "Nature / Zen", "Académique", "Minimaliste"]
 LANGUAGES = ["Français", "English", "Español", "Deutsch", "中文", "日本語"]
 IMAGE_MODES = ["ComfyUI (local GPU)", "Recherche web (Wikimedia)", "Les deux (ComfyUI + web)", "Aucune image"]
 
-with gr.Blocks(
-    title="PPT Master — Générateur de Présentations IA",
-    theme=gr.themes.Soft(primary_hue="amber", secondary_hue="slate"),
-    css="""
-    .main-title { text-align: center; margin-bottom: 0.5em; }
-    .subtitle { text-align: center; color: #666; margin-bottom: 1.5em; }
-    """
-) as app:
+with gr.Blocks(title="PPT Master — Générateur IA") as app:
 
-    # State
     outline_state = gr.State("{}")
 
-    # Header
-    gr.Markdown("# 🎯 PPT Master — Générateur de Présentations IA", elem_classes="main-title")
-    gr.Markdown("*OpenRouter LLM + ComfyUI local + export PowerPoint natif*", elem_classes="subtitle")
+    gr.Markdown("# 🎯 PPT Master — Générateur de Présentations IA")
+    gr.Markdown("*Workflow complet: Strategist → Images → Executor SVG → PPTX natif*")
 
     with gr.Tabs():
-        # ─── TAB 1: Configuration & Planification ───
-        with gr.Tab("1️⃣ Sujet & Plan", id="tab1"):
+        with gr.Tab("1️⃣ Sujet & Design"):
             with gr.Row():
                 with gr.Column(scale=2):
-                    subject = gr.Textbox(
-                        label="📌 Sujet de la présentation",
-                        placeholder="Ex: Game of Thrones, l'Intelligence Artificielle en 2025, la conquête spatiale...",
-                        lines=2
-                    )
+                    subject = gr.Textbox(label="📌 Sujet", placeholder="Ex: Game of Thrones, L'IA en 2025...", lines=2)
                     with gr.Row():
-                        num_slides = gr.Slider(5, 20, value=10, step=1, label="📄 Nombre de slides")
+                        num_slides = gr.Slider(5, 20, value=10, step=1, label="📄 Slides")
                         language = gr.Dropdown(LANGUAGES, value="Français", label="🌐 Langue")
-
                 with gr.Column(scale=1):
-                    style = gr.Dropdown(STYLES, value="Dark Fantasy", label="🎨 Style visuel")
-                    audience = gr.Textbox(label="👥 Public cible", value="Grand public, curieux", placeholder="Ex: professionnels, étudiants...")
-                    image_mode = gr.Dropdown(IMAGE_MODES, value="ComfyUI (local GPU)", label="🖼️ Source d'images")
-
-            btn_outline = gr.Button("🧠 Générer le plan (LLM)", variant="primary", size="lg")
-            status_outline = gr.Textbox(label="Statut", interactive=False)
-
-            gr.Markdown("### 📋 Aperçu du plan généré")
-            outline_preview = gr.Markdown(label="Plan", value="*Le plan apparaîtra ici après génération...*")
-
-        # ─── TAB 2: Génération ───
-        with gr.Tab("2️⃣ Générer le PPTX", id="tab2"):
-            gr.Markdown("### 🚀 Lancer la génération complète")
-            gr.Markdown("Cliquer sur le bouton ci-dessous pour générer les images, créer les slides et exporter le PowerPoint.")
-
-            btn_generate = gr.Button("⚡ Générer la présentation complète", variant="primary", size="lg")
-            status_generate = gr.Textbox(label="Statut", interactive=False)
-
+                    style = gr.Dropdown(STYLES, value="Dark Fantasy", label="🎨 Style")
+                    audience = gr.Textbox(label="👥 Public", value="Grand public", placeholder="Ex: professionnels, étudiants...")
+                    image_mode = gr.Dropdown(IMAGE_MODES, value="ComfyUI (local GPU)", label="🖼️ Images")
+
+            btn_plan = gr.Button("🧠 Générer le design spec (Strategist)", variant="primary", size="lg")
+            status1 = gr.Textbox(label="Statut", interactive=False)
+            gr.Markdown("### 📋 Design Spec & Plan")
+            preview = gr.Markdown(value="*Le design spec apparaîtra ici...*")
+
+        with gr.Tab("2️⃣ Générer le PPTX"):
+            gr.Markdown("### 🚀 Pipeline complet: Images + SVG (LLM) + Export")
+            gr.Markdown("⏱️ **Temps estimé**: ~2 min (images) + ~8-12 min (SVG par LLM) + ~30s (export)")
+            btn_gen = gr.Button("⚡ Lancer la génération complète", variant="primary", size="lg")
+            status2 = gr.Textbox(label="Statut", interactive=False)
             with gr.Row():
-                with gr.Column():
-                    log_output = gr.Textbox(label="📜 Log de génération", lines=15, interactive=False)
-                with gr.Column():
-                    pptx_file = gr.File(label="📥 Télécharger le PPTX")
+                log_box = gr.Textbox(label="📜 Log", lines=20, interactive=False)
+                pptx_out = gr.File(label="📥 Télécharger PPTX")
 
-        # ─── TAB 3: À propos ───
         with gr.Tab("ℹ️ À propos"):
             gr.Markdown("""
-## PPT Master — Interface Gradio
+## Workflow PPT Master complet
 
-**Stack technique:**
-- 🧠 **LLM**: OpenRouter — tencent/hy3-preview:free (gratuit)
-- 🖼️ **Images**: ComfyUI local (RTX 5070 Ti) ou recherche web (Wikimedia/Openverse)
-- 📊 **Export**: PPT Master pipeline (SVG → DrawingML → PPTX natif éditable)
+1. **Strategist** → Génère design_spec + spec_lock (palette, typo, icônes, rythme)
+2. **Image Acquisition** → ComfyUI GPU ou recherche web
+3. **Executor** → Le LLM génère chaque SVG individuellement en respectant le spec_lock
+4. **Post-processing** → finalize_svg.py (icônes, images, rounded rects)
+5. **Export** → svg_to_pptx.py → PPTX natif éditable
 
-**Comment ça marche:**
-1. Tu entres un sujet → le LLM génère un plan structuré (titres, contenu, prompts image)
-2. Tu valides → la pipeline génère les images, crée les SVG, exporte en PPTX
-3. Tu télécharges le PowerPoint final, entièrement éditable dans PowerPoint/LibreOffice
+**Qualité**: Chaque slide est conçue par le LLM avec dégradés, décorations, typographie variée.
+Le spec_lock garantit la cohérence couleurs/fonts sur l'ensemble du deck.
 
-**Configuration:**
-- Fichier `.env` pour les clés API et chemins ComfyUI
-- ComfyUI doit tourner en arrière-plan sur le port 8188
-
-**Crédits:**
-- PPT Master par Hugo He (https://github.com/hugohe3/ppt-master)
-- Modifications: backend ComfyUI + OpenRouter + interface Gradio
+**Stack**: OpenRouter (tencent/hy3-preview:free) + ComfyUI local (RTX 5070 Ti)
 """)
 
-    # ─── Event handlers ───
-    btn_outline.click(
-        fn=step1_generate_outline,
-        inputs=[subject, num_slides, style, language, audience, image_mode],
-        outputs=[status_outline, outline_preview, outline_state]
-    )
-
-    btn_generate.click(
-        fn=step2_generate_pptx,
-        inputs=[outline_state, style, image_mode],
-        outputs=[status_generate, pptx_file, log_output]
-    )
+    btn_plan.click(fn=step1_handler, inputs=[subject, num_slides, style, language, audience, image_mode],
+                   outputs=[status1, preview, outline_state])
+    btn_gen.click(fn=step2_handler, inputs=[outline_state, style, image_mode],
+                  outputs=[status2, pptx_out, log_box])
 
 
-# ============================================================
-# Launch
-# ============================================================
-
 if __name__ == "__main__":
-    app.launch(
-        server_name="127.0.0.1",
-        server_port=7860,
-        share=False,
-        inbrowser=True
-    )
+    app.launch(server_name="127.0.0.1", server_port=7860, share=False, inbrowser=True)