@ztffn/presentation-generator-plugin 1.3.3 → 1.3.6

package/scripts/outline_to_graph.py

@@ -0,0 +1,413 @@
+#!/usr/bin/env python3
+"""
+outline_to_graph.py — Deterministic markdown-to-ReactFlow converter.
+Parses a presentation outline markdown and emits valid graph JSON with
+correct node wrappers, positions, edges, and handles. Default visual
+treatment on all slides; a styling agent applies visual refinements later.
+Usage: python3 outline_to_graph.py <outline.md> [-o <output.json>]
+"""
+
+import sys
+import re
+import json
+import argparse
+from pathlib import Path
+from datetime import datetime, timezone
+
+
+# ---------------------------------------------------------------------------
+# Parsing helpers
+# ---------------------------------------------------------------------------
+
+def slugify(text):
+    """Convert a title string to a kebab-case slug."""
+    text = text.lower().strip()
+    text = re.sub(r"[''']", "", text)          # remove apostrophes
+    text = re.sub(r"[^a-z0-9\s-]", "", text)   # remove non-alphanum
+    text = re.sub(r"[\s_]+", "-", text)         # spaces/underscores to hyphens
+    text = re.sub(r"-{2,}", "-", text)          # collapse multiple hyphens
+    return text.strip("-")
+
+
+def parse_spine(text):
+    """Parse the SPINE section into an ordered list of (number, title)."""
+    spines = []
+    for m in re.finditer(r"^\d+\.\s+\*\*(.+?)\*\*", text, re.MULTILINE):
+        spines.append(m.group(1).strip())
+    return spines
+
+
+def parse_drilldowns(text):
+    """Parse DRILL-DOWNS into {parent_spine_num: [(child_num, child_subnum, title), ...]}."""
+    drilldowns = {}
+    current_parent = None
+
+    for line in text.splitlines():
+        parent_match = re.match(r"###\s+Under Spine (\d+)", line)
+        if parent_match:
+            current_parent = int(parent_match.group(1))
+            if current_parent not in drilldowns:
+                drilldowns[current_parent] = []
+            continue
+
+        if current_parent is not None:
+            child_match = re.match(
+                r"-\s+\*\*(\d+)\.(\d+)\*\*\s+(.+?):\s*(.*)", line
+            )
+            if child_match:
+                major = int(child_match.group(1))
+                minor = int(child_match.group(2))
+                title = child_match.group(3).strip()
+                drilldowns[current_parent].append((major, minor, title))
+
+    return drilldowns
+
+
+def parse_content_blocks(text):
+    """Parse CONTENT PER SLIDE into a dict keyed by slide identifier (e.g. '1', '2.1')."""
+    blocks = {}
+    # Split on ### SPINE headers
+    parts = re.split(r"(?=^### SPINE )", text, flags=re.MULTILINE)
+
+    for part in parts:
+        header_match = re.match(
+            r"^### SPINE (\d+(?:\.\d+)?)\s*:\s*(.+?)(?:\s*\(.*\))?\s*$",
+            part, re.MULTILINE,
+        )
+        if not header_match:
+            continue
+
+        slide_id = header_match.group(1)
+        block_text = part[header_match.end():]
+
+        block = extract_fields(block_text)
+        blocks[slide_id] = block
+
+    return blocks
+
+
+def extract_fields(text):
+    """Extract Key message, Content, Speaker notes, Transition from a content block."""
+    fields = {}
+
+    # Define field markers in order
+    markers = [
+        ("key_message", r"\*\*Key message:\*\*"),
+        ("content", r"\*\*Content:\*\*"),
+        ("speaker_notes", r"\*\*Speaker notes:\*\*"),
+        ("transition", r"\*\*Transition to next:\*\*"),
+    ]
+
+    # Find positions of all markers
+    positions = []
+    for name, pattern in markers:
+        m = re.search(pattern, text)
+        if m:
+            positions.append((m.start(), m.end(), name))
+
+    # Also find next section boundary (---)
+    for m in re.finditer(r"^---\s*$", text, re.MULTILINE):
+        positions.append((m.start(), m.end(), "__separator__"))
+
+    positions.sort(key=lambda x: x[0])
+
+    for i, (start, end, name) in enumerate(positions):
+        if name == "__separator__":
+            continue
+        # Find next marker/separator position
+        next_pos = len(text)
+        for j in range(i + 1, len(positions)):
+            next_pos = positions[j][0]
+            break
+        value = text[end:next_pos].strip()
+        fields[name] = value
+
+    return fields
+
+
+def build_content_markdown(block):
+    """Build the data.content field from key_message and content fields."""
+    parts = []
+    if block.get("key_message"):
+        parts.append(f"## {block['key_message']}")
+        parts.append("")
+    if block.get("content"):
+        parts.append(block["content"])
+    return "\n".join(parts).strip()
+
+
+# ---------------------------------------------------------------------------
+# Graph construction
+# ---------------------------------------------------------------------------
+
+def build_node(node_id, title, topic, content, notes, transition, position,
+               is_first=False, is_last=False):
+    """Build a single ReactFlow node dict."""
+    data = {
+        "label": title,
+        "topic": topic,
+        "content": content,
+        "notes": notes,
+        "centered": False,
+    }
+
+    if transition:
+        data["transitionToNext"] = transition
+
+    if is_first or is_last:
+        data["centered"] = True
+        data["brandFont"] = True
+        data["showBranding"] = True
+
+    # Remove empty optional fields
+    if not data.get("notes"):
+        del data["notes"]
+    if not data.get("content"):
+        del data["content"]
+
+    return {
+        "id": node_id,
+        "type": "huma",
+        "position": {"x": position[0], "y": position[1]},
+        "data": data,
+        "style": {"width": 180, "height": 70},
+        "measured": {"width": 180, "height": 70},
+    }
+
+
+def make_edge_pair_horizontal(source_id, target_id):
+    """Generate bidirectional horizontal edge pair (right/left)."""
+    return [
+        {
+            "id": f"e-{source_id}-{target_id}",
+            "source": source_id,
+            "target": target_id,
+            "sourceHandle": "s-right",
+            "targetHandle": "t-left",
+        },
+        {
+            "id": f"e-{target_id}-{source_id}",
+            "source": target_id,
+            "target": source_id,
+            "sourceHandle": "s-left",
+            "targetHandle": "t-right",
+        },
+    ]
+
+
+def make_edge_pair_vertical(parent_id, child_id):
+    """Generate bidirectional vertical edge pair (bottom/top)."""
+    return [
+        {
+            "id": f"e-{parent_id}-{child_id}",
+            "source": parent_id,
+            "target": child_id,
+            "sourceHandle": "s-bottom",
+            "targetHandle": "t-top",
+        },
+        {
+            "id": f"e-{child_id}-{parent_id}",
+            "source": child_id,
+            "target": parent_id,
+            "sourceHandle": "s-top",
+            "targetHandle": "t-bottom",
+        },
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Main pipeline
+# ---------------------------------------------------------------------------
+
+def parse_outline(outline_path):
+    """Parse the outline markdown and return graph JSON dict."""
+    text = Path(outline_path).read_text(encoding="utf-8")
+
+    # 1. Extract title
+    title_match = re.match(r"^#\s+Presentation Outline:\s*(.+)", text, re.MULTILINE)
+    if not title_match:
+        print("ERROR  Could not find title line (expected '# Presentation Outline: ...')",
+              file=sys.stderr)
+        sys.exit(1)
+    deck_title = title_match.group(1).strip()
+
+    # 2. Split into sections
+    spine_section = ""
+    drilldown_section = ""
+    content_section = ""
+
+    spine_match = re.search(r"^## SPINE\b.*$", text, re.MULTILINE)
+    drilldown_match = re.search(r"^## DRILL-DOWNS\b.*$", text, re.MULTILINE)
+    content_match = re.search(r"^## CONTENT PER SLIDE\b.*$", text, re.MULTILINE)
+
+    if spine_match and drilldown_match:
+        spine_section = text[spine_match.start():drilldown_match.start()]
+    if drilldown_match and content_match:
+        drilldown_section = text[drilldown_match.start():content_match.start()]
+    if content_match:
+        content_section = text[content_match.start():]
+
+    # 3. Parse each section
+    spine_titles = parse_spine(spine_section)
+    drilldowns = parse_drilldowns(drilldown_section)
+    content_blocks = parse_content_blocks(content_section)
+
+    # Also pick up any spine slides that appear in content but not in the SPINE list
+    # (e.g. Spine 8 in the test outline)
+    content_spine_nums = sorted(
+        int(k) for k in content_blocks if "." not in k
+    )
+    for num in content_spine_nums:
+        if num > len(spine_titles):
+            # Extract title from content block header
+            pattern = rf"^### SPINE {num}\s*:\s*(.+?)(?:\s*\(.*\))?\s*$"
+            m = re.search(pattern, content_section, re.MULTILINE)
+            if m:
+                spine_titles.append(m.group(1).strip())
+
+    if not spine_titles:
+        print("ERROR  No spine nodes found in outline", file=sys.stderr)
+        sys.exit(1)
+
+    # 4. Build nodes and edges
+    nodes = []
+    edges = []
+    spine_node_ids = []
+    # Track x positions of spine nodes for drill-down placement
+    spine_x_positions = {}
+
+    for i, title in enumerate(spine_titles):
+        spine_num = i + 1
+        node_id = slugify(title)
+        x = i * 240
+        y = 0
+        spine_x_positions[spine_num] = x
+
+        block = content_blocks.get(str(spine_num), {})
+        content = build_content_markdown(block)
+        notes = block.get("speaker_notes", "")
+        transition = block.get("transition", "")
+        topic = f"{spine_num:02d} / {title}"
+
+        is_first = i == 0
+        is_last = i == len(spine_titles) - 1
+
+        node = build_node(
+            node_id, title, topic, content, notes, transition,
+            (x, y), is_first=is_first, is_last=is_last,
+        )
+        nodes.append(node)
+        spine_node_ids.append(node_id)
+
+    # Spine horizontal edges
+    for i in range(len(spine_node_ids) - 1):
+        edges.extend(make_edge_pair_horizontal(spine_node_ids[i], spine_node_ids[i + 1]))
+
+    # 5. Build drill-down nodes
+    for parent_num, children in sorted(drilldowns.items()):
+        parent_x = spine_x_positions.get(parent_num, 0)
+        parent_id = spine_node_ids[parent_num - 1] if parent_num <= len(spine_node_ids) else None
+        if parent_id is None:
+            continue
+
+        child_node_ids = []
+        for idx, (major, minor, title) in enumerate(children):
+            node_id = slugify(title)
+            x = parent_x + idx * 240
+            y = 150
+
+            slide_key = f"{major}.{minor}"
+            block = content_blocks.get(slide_key, {})
+            content = build_content_markdown(block)
+            notes = block.get("speaker_notes", "")
+            transition = block.get("transition", "")
+            topic = f"{major:02d}.{minor} / {title}"
+
+            node = build_node(node_id, title, topic, content, notes, transition, (x, y))
+            nodes.append(node)
+            child_node_ids.append(node_id)
+
+        # Parent to first child (vertical)
+        if child_node_ids:
+            edges.extend(make_edge_pair_vertical(parent_id, child_node_ids[0]))
+
+        # Sibling horizontal edges
+        for i in range(len(child_node_ids) - 1):
+            edges.extend(make_edge_pair_horizontal(child_node_ids[i], child_node_ids[i + 1]))
+
+    # 6. Build output
+    output = {
+        "meta": {
+            "name": deck_title,
+            "updatedAt": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.000Z"),
+        },
+        "nodes": nodes,
+        "edges": edges,
+    }
+
+    return output
+
+
+def run_validator(json_path):
+    """Run validate_draft.py against the output. Returns True if valid."""
+    validator_path = Path(__file__).parent / "validate_draft.py"
+    if not validator_path.exists():
+        print(f"WARNING  Validator not found at {validator_path}", file=sys.stderr)
+        return True
+
+    # Import and call validate directly
+    import importlib.util
+    spec = importlib.util.spec_from_file_location("validate_draft", validator_path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod.validate(str(json_path))
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Convert presentation outline markdown to ReactFlow graph JSON"
+    )
+    parser.add_argument("outline", help="Path to outline markdown file")
+    parser.add_argument("-o", "--output", help="Output JSON path (stdout if omitted)")
+    args = parser.parse_args()
+
+    outline_path = Path(args.outline)
+    if not outline_path.exists():
+        print(f"ERROR  Outline file not found: {outline_path}", file=sys.stderr)
+        sys.exit(1)
+
+    graph = parse_outline(outline_path)
+
+    # Write output
+    json_str = json.dumps(graph, indent=2, ensure_ascii=False)
+
+    if args.output:
+        out_path = Path(args.output)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(json_str + "\n", encoding="utf-8")
+        print(f"Wrote {out_path}")
+    else:
+        print(json_str)
+
+    # Summary
+    node_count = len(graph["nodes"])
+    edge_count = len(graph["edges"])
+    print(f"Summary: {node_count} nodes, {edge_count} edges", file=sys.stderr)
+
+    # Validate
+    if args.output:
+        valid = run_validator(args.output)
+    else:
+        # Write to temp file for validation
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            f.write(json_str)
+            tmp_path = f.name
+        valid = run_validator(tmp_path)
+        Path(tmp_path).unlink(missing_ok=True)
+
+    sys.exit(0 if valid else 1)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/validate_draft.py

@@ -21,6 +21,7 @@ ALLOWED_DATA_FIELDS = {
     "inlineVideoControls", "inlineVideoAutoplay", "inlineVideoLoop",
     "scene", "chart", "charts",
     "sceneGroup", "focus",
+    "transitionToNext",
 }
 
 VALID_SOURCE_HANDLES = {"s-right", "s-left", "s-top", "s-bottom"}
@@ -77,7 +78,7 @@ def validate(path):
                 errors.append(f"{p}: data must be an object")
                 continue
 
-            if not str(node_data.get("label", "")).strip():
+            if not str(node_data.get("label", "")).strip() and node_data.get("type") != "chart":
                 errors.append(f"{p}: data.label is missing or empty (this is the slide title)")
 
             unknown = set(node_data.keys()) - ALLOWED_DATA_FIELDS