codewave-openclaw-installer 2.1.10 → 2.1.12

package/skills/ppt-master/scripts/drawio_to_svg.py

@@ -0,0 +1,458 @@
+#!/usr/bin/env python3
+"""
+drawio_to_svg.py - Convert draw.io XML to PPT Master compatible SVG.
+
+Parses a .drawio file and renders it as a standalone SVG at 1280x720
+(16:9 PPT format), compatible with the PPT Master pipeline.
+
+This does NOT require draw.io Desktop installed. It directly parses
+the mxGraph XML and renders nodes/edges as SVG elements.
+
+Usage:
+    python drawio_to_svg.py <input.drawio> -o <output.svg>
+    python drawio_to_svg.py <input.drawio> -o <output.svg> --width 1280 --height 720
+    python drawio_to_svg.py <input.drawio> -o <output.svg> --title "System Architecture"
+    python drawio_to_svg.py <input.drawio> -o <output.svg> --background "#ffffff" --padding 40
+"""
+
+import sys
+import re
+import argparse
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class NodeInfo:
+    id: str
+    label: str
+    x: float
+    y: float
+    width: float
+    height: float
+    style: dict = field(default_factory=dict)
+    parent: str = "1"
+
+
+@dataclass
+class EdgeInfo:
+    id: str
+    label: str
+    source: str
+    target: str
+    style: dict = field(default_factory=dict)
+
+
+def parse_style(style_str: str) -> dict:
+    """Parse mxGraph style string into dict."""
+    result = {}
+    if not style_str:
+        return result
+    for part in style_str.rstrip(";").split(";"):
+        if "=" in part:
+            k, v = part.split("=", 1)
+            result[k.strip()] = v.strip()
+        elif part.strip():
+            result[part.strip()] = True
+    return result
+
+
+def parse_drawio(filepath: str):
+    """Parse a .drawio file and return nodes and edges."""
+    with open(filepath, "r", encoding="utf-8") as f:
+        tree = ET.parse(f)
+    root = tree.getroot()
+
+    nodes = {}
+    edges = []
+    groups = {}
+
+    for diagram in root.findall(".//diagram"):
+        for cell in diagram.iter("mxCell"):
+            cell_id = cell.get("id", "")
+            if cell_id in ("0", "1"):
+                continue
+
+            parent = cell.get("parent", "1")
+            style = parse_style(cell.get("style", ""))
+            value = cell.get("value", "")
+            geo = cell.find("mxGeometry")
+
+            if cell.get("vertex") == "1":
+                x = float(geo.get("x", "0")) if geo is not None else 0
+                y = float(geo.get("y", "0")) if geo is not None else 0
+                w = float(geo.get("width", "120")) if geo is not None else 120
+                h = float(geo.get("height", "60")) if geo is not None else 60
+
+                if "container" in style:
+                    groups[cell_id] = NodeInfo(cell_id, value, x, y, w, h, style, parent)
+                else:
+                    nodes[cell_id] = NodeInfo(cell_id, value, x, y, w, h, style, parent)
+
+            elif cell.get("edge") == "1":
+                edges.append(EdgeInfo(cell_id, value,
+                                      cell.get("source", ""),
+                                      cell.get("target", ""),
+                                      style))
+
+        # Also check <object> elements (N2G format)
+        for obj in diagram.iter("object"):
+            obj_id = obj.get("id", "")
+            value = obj.get("label", "")
+            inner = obj.find("mxCell")
+            if inner is None:
+                continue
+
+            style = parse_style(inner.get("style", ""))
+            parent = inner.get("parent", "1")
+            geo = inner.find("mxGeometry")
+
+            if inner.get("vertex") == "1":
+                x = float(geo.get("x", "0")) if geo is not None else 0
+                y = float(geo.get("y", "0")) if geo is not None else 0
+                w = float(geo.get("width", "120")) if geo is not None else 120
+                h = float(geo.get("height", "60")) if geo is not None else 60
+                nodes[obj_id] = NodeInfo(obj_id, value, x, y, w, h, style, parent)
+
+            elif inner.get("edge") == "1":
+                edges.append(EdgeInfo(obj_id, value,
+                                      inner.get("source", obj.get("source", "")),
+                                      inner.get("target", obj.get("target", "")),
+                                      style))
+
+    # Resolve relative positions for grouped nodes
+    for nid, node in nodes.items():
+        if node.parent in groups:
+            g = groups[node.parent]
+            node.x += g.x
+            node.y += g.y
+
+    return nodes, edges, groups
+
+
+def color_from_style(style: dict, key: str, default: str) -> str:
+    return style.get(key, default)
+
+
+def get_shape_type(style: dict) -> str:
+    """Determine shape type from style dict."""
+    shape = style.get("shape", "")
+    if "cylinder" in shape or "cylinder3" in str(style):
+        return "cylinder"
+    if "cloud" in shape:
+        return "cloud"
+    if "rhombus" in style or "diamond" in str(style):
+        return "diamond"
+    if "ellipse" in style:
+        return "ellipse"
+    if "hexagon" in shape:
+        return "hexagon"
+    if style.get("rounded"):
+        return "rounded"
+    return "rect"
+
+
+def svg_shape(node: NodeInfo, svg_lines: list):
+    """Render a node as SVG elements."""
+    x, y, w, h = node.x, node.y, node.width, node.height
+    fill = color_from_style(node.style, "fillColor", "#dae8fc")
+    stroke = color_from_style(node.style, "strokeColor", "#6c8ebf")
+    shape = get_shape_type(node.style)
+    stroke_w = "1.5"
+
+    if shape == "cylinder":
+        # Cylinder: rect + top/bottom ellipse
+        ry = min(12, h * 0.15)
+        svg_lines.append(f'  <rect x="{x}" y="{y + ry}" width="{w}" height="{h - 2*ry}" '
+                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
+        svg_lines.append(f'  <ellipse cx="{x + w/2}" cy="{y + ry}" rx="{w/2}" ry="{ry}" '
+                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
+        svg_lines.append(f'  <ellipse cx="{x + w/2}" cy="{y + h - ry}" rx="{w/2}" ry="{ry}" '
+                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
+    elif shape == "ellipse" or shape == "cloud":
+        svg_lines.append(f'  <ellipse cx="{x + w/2}" cy="{y + h/2}" rx="{w/2}" ry="{h/2}" '
+                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
+    elif shape == "diamond":
+        cx, cy = x + w/2, y + h/2
+        points = f"{cx},{y} {x+w},{cy} {cx},{y+h} {x},{cy}"
+        svg_lines.append(f'  <polygon points="{points}" '
+                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
+    elif shape == "hexagon":
+        dx = w * 0.15
+        points = f"{x+dx},{y} {x+w-dx},{y} {x+w},{y+h/2} {x+w-dx},{y+h} {x+dx},{y+h} {x},{y+h/2}"
+        svg_lines.append(f'  <polygon points="{points}" '
+                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
+    elif shape == "rounded":
+        r = min(12, w * 0.1, h * 0.2)
+        svg_lines.append(f'  <rect x="{x}" y="{y}" width="{w}" height="{h}" rx="{r}" ry="{r}" '
+                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
+    else:
+        svg_lines.append(f'  <rect x="{x}" y="{y}" width="{w}" height="{h}" '
+                         f'fill="{fill}" stroke="{stroke}" stroke-width="{stroke_w}" />')
+
+    # Label
+    label = node.label.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+    if label:
+        font_size = 12
+        svg_lines.append(f'  <text x="{x + w/2}" y="{y + h/2}" '
+                         f'text-anchor="middle" dominant-baseline="central" '
+                         f'font-family="Helvetica, Arial, sans-serif" font-size="{font_size}" '
+                         f'fill="#333333">{label}</text>')
+
+
+def svg_edge(edge: EdgeInfo, nodes: dict, svg_lines: list):
+    """Render an edge as orthogonal polyline for cleaner look."""
+    src = nodes.get(edge.source)
+    tgt = nodes.get(edge.target)
+    if not src or not tgt:
+        return
+
+    # Center points
+    sx = src.x + src.width / 2
+    sy = src.y + src.height / 2
+    tx = tgt.x + tgt.width / 2
+    ty = tgt.y + tgt.height / 2
+
+    stroke = color_from_style(edge.style, "strokeColor", "#666666")
+    dash = ""
+    if edge.style.get("dashed"):
+        pattern = edge.style.get("dashPattern", "8 8")
+        dash = f' stroke-dasharray="{pattern}"'
+
+    # Determine best connection ports (top/bottom/left/right of each node)
+    dy = ty - sy
+    dx = tx - sx
+
+    # Choose vertical-first routing (most common for TB layouts)
+    if abs(dy) > 10:
+        # Connect bottom of src to top of tgt (or top to bottom if reversed)
+        if dy > 0:
+            # src above tgt
+            p1x, p1y = sx, src.y + src.height  # bottom of src
+            p4x, p4y = tx, tgt.y                # top of tgt
+        else:
+            # src below tgt
+            p1x, p1y = sx, src.y                # top of src
+            p4x, p4y = tx, tgt.y + tgt.height   # bottom of tgt
+
+        # Midpoint Y for the horizontal segment
+        mid_y = (p1y + p4y) / 2
+
+        # Build orthogonal path: vertical → horizontal → vertical
+        if abs(p1x - p4x) < 3:
+            # Nodes are vertically aligned, straight line
+            points = f"{p1x:.1f},{p1y:.1f} {p4x:.1f},{p4y:.1f}"
+        else:
+            points = f"{p1x:.1f},{p1y:.1f} {p1x:.1f},{mid_y:.1f} {p4x:.1f},{mid_y:.1f} {p4x:.1f},{p4y:.1f}"
+    else:
+        # Horizontal connection (same layer)
+        if dx > 0:
+            p1x, p1y = src.x + src.width, sy   # right of src
+            p4x, p4y = tgt.x, ty               # left of tgt
+        else:
+            p1x, p1y = src.x, sy               # left of src
+            p4x, p4y = tgt.x + tgt.width, ty   # right of tgt
+
+        if abs(p1y - p4y) < 3:
+            points = f"{p1x:.1f},{p1y:.1f} {p4x:.1f},{p4y:.1f}"
+        else:
+            mid_x = (p1x + p4x) / 2
+            points = f"{p1x:.1f},{p1y:.1f} {mid_x:.1f},{p1y:.1f} {mid_x:.1f},{p4y:.1f} {p4x:.1f},{p4y:.1f}"
+
+    # Arrow head (small triangle at end point)
+    has_arrow = edge.style.get("endArrow", "classic") != "none"
+    arrow_svg = ""
+    if has_arrow:
+        # Parse last two points to determine arrow direction
+        pts = points.strip().split()
+        if len(pts) >= 2:
+            last = pts[-1].split(",")
+            prev = pts[-2].split(",")
+            lx, ly = float(last[0]), float(last[1])
+            px, py = float(prev[0]), float(prev[1])
+            adx, ady = lx - px, ly - py
+            length = max((adx**2 + ady**2)**0.5, 0.001)
+            # Normalize
+            ux, uy = adx/length, ady/length
+            # Arrow triangle (size 8)
+            sz = 8
+            # Perpendicular
+            rx, ry = -uy * sz * 0.5, ux * sz * 0.5
+            # Arrow base point
+            bx, by = lx - ux * sz, ly - uy * sz
+            arrow_svg = (f'  <polygon points="{lx:.1f},{ly:.1f} {bx+rx:.1f},{by+ry:.1f} '
+                         f'{bx-rx:.1f},{by-ry:.1f}" fill="{stroke}" />')
+
+    svg_lines.append(f'  <polyline points="{points}" fill="none" '
+                     f'stroke="{stroke}" stroke-width="1.5"{dash} stroke-linejoin="round" />')
+    if arrow_svg:
+        svg_lines.append(arrow_svg)
+
+    # Edge label - position at midpoint of the polyline path
+    if edge.label:
+        pts = [tuple(map(float, p.split(","))) for p in points.strip().split()]
+        if len(pts) >= 2:
+            mid_idx = len(pts) // 2
+            if len(pts) % 2 == 0:
+                lx = (pts[mid_idx-1][0] + pts[mid_idx][0]) / 2
+                ly = (pts[mid_idx-1][1] + pts[mid_idx][1]) / 2
+            else:
+                lx, ly = pts[mid_idx]
+            ly -= 8
+            label = edge.label.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+            svg_lines.append(f'  <rect x="{lx-len(label)*3.5-4}" y="{ly-10}" '
+                             f'width="{len(label)*7+8}" height="16" rx="3" fill="white" fill-opacity="0.85" />')
+            svg_lines.append(f'  <text x="{lx}" y="{ly}" text-anchor="middle" dominant-baseline="central" '
+                             f'font-family="Helvetica, Arial, sans-serif" font-size="11" '
+                             f'fill="{stroke}">{label}</text>')
+
+
+def clip_to_rect(sx, sy, tx, ty, node):
+    """Clip a line from (sx,sy) toward (tx,ty) to the boundary of node's rect."""
+    cx = node.x + node.width / 2
+    cy = node.y + node.height / 2
+    dx = tx - sx
+    dy = ty - sy
+    if abs(dx) < 0.001 and abs(dy) < 0.001:
+        return sx, sy
+
+    hw = node.width / 2
+    hh = node.height / 2
+
+    # Find intersection with rect boundary
+    t_vals = []
+    if abs(dx) > 0.001:
+        t_vals.append(hw / abs(dx))
+    if abs(dy) > 0.001:
+        t_vals.append(hh / abs(dy))
+    if t_vals:
+        t = min(t_vals)
+        return cx + dx * t * (1 if dx > 0 else -1) / max(abs(dx), 0.001) * min(hw, abs(dx) * t), \
+               cy + dy * t * (1 if dy > 0 else -1) / max(abs(dy), 0.001) * min(hh, abs(dy) * t)
+    return sx, sy
+
+
+def clip_to_rect(sx, sy, tx, ty, node: NodeInfo):
+    """Clip point (sx, sy) to boundary of node rect, coming from direction of (tx, ty)."""
+    cx = node.x + node.width / 2
+    cy = node.y + node.height / 2
+    dx = tx - cx
+    dy = ty - cy
+
+    if abs(dx) < 0.01 and abs(dy) < 0.01:
+        return sx, sy
+
+    hw = node.width / 2
+    hh = node.height / 2
+
+    # Parametric intersection
+    scale_x = abs(dx / hw) if hw > 0 else 999
+    scale_y = abs(dy / hh) if hh > 0 else 999
+    scale = max(scale_x, scale_y)
+
+    if scale < 0.01:
+        return sx, sy
+
+    return cx + dx / scale, cy + dy / scale
+
+
+def render_svg(nodes: dict, edges: list, groups: dict,
+               width: int = 1280, height: int = 720,
+               title: str = "", bg: str = "#ffffff",
+               padding: int = 40) -> str:
+    """Render parsed drawio data as SVG string."""
+
+    # Auto-scale to fit canvas
+    if nodes:
+        all_items = list(nodes.values()) + list(groups.values())
+        min_x = min(n.x for n in all_items)
+        min_y = min(n.y for n in all_items)
+        max_x = max(n.x + n.width for n in all_items)
+        max_y = max(n.y + n.height for n in all_items)
+
+        content_w = max_x - min_x
+        content_h = max_y - min_y
+        avail_w = width - 2 * padding
+        avail_h = height - 2 * padding - (40 if title else 0)
+
+        scale = min(avail_w / max(content_w, 1), avail_h / max(content_h, 1), 2.0)
+
+        offset_x = padding + (avail_w - content_w * scale) / 2 - min_x * scale
+        offset_y = padding + (40 if title else 0) + (avail_h - content_h * scale) / 2 - min_y * scale
+
+        # Apply transform
+        for n in nodes.values():
+            n.x = n.x * scale + offset_x
+            n.y = n.y * scale + offset_y
+            n.width *= scale
+            n.height *= scale
+        for g in groups.values():
+            g.x = g.x * scale + offset_x
+            g.y = g.y * scale + offset_y
+            g.width *= scale
+            g.height *= scale
+
+    lines = [
+        f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {width} {height}" width="{width}" height="{height}">',
+        f'  <rect width="{width}" height="{height}" fill="{bg}" />',
+    ]
+
+    # Title
+    if title:
+        lines.append(f'  <text x="{width/2}" y="32" text-anchor="middle" '
+                     f'font-family="Helvetica, Arial, sans-serif" font-size="20" '
+                     f'font-weight="bold" fill="#333333">{title}</text>')
+
+    # Groups (background)
+    for g in groups.values():
+        r = 8
+        fill = color_from_style(g.style, "fillColor", "#f5f5f5")
+        stroke = color_from_style(g.style, "strokeColor", "#999999")
+        lines.append(f'  <rect x="{g.x}" y="{g.y}" width="{g.width}" height="{g.height}" '
+                     f'rx="{r}" fill="{fill}" stroke="{stroke}" stroke-width="1" '
+                     f'stroke-dasharray="4 4" />')
+        if g.label:
+            label = g.label.replace("&", "&amp;").replace("<", "&lt;")
+            lines.append(f'  <text x="{g.x + 10}" y="{g.y + 18}" '
+                         f'font-family="Helvetica, Arial, sans-serif" font-size="13" '
+                         f'font-weight="bold" fill="#666666">{label}</text>')
+
+    # Edges (behind nodes)
+    for e in edges:
+        svg_edge(e, nodes, lines)
+
+    # Nodes (on top)
+    for n in nodes.values():
+        svg_shape(n, lines)
+
+    lines.append('</svg>')
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert draw.io to PPT-compatible SVG")
+    parser.add_argument("input", help="Input .drawio file")
+    parser.add_argument("-o", "--output", required=True, help="Output .svg file")
+    parser.add_argument("--width", type=int, default=1280, help="SVG width (default: 1280)")
+    parser.add_argument("--height", type=int, default=720, help="SVG height (default: 720)")
+    parser.add_argument("--title", default="", help="Diagram title")
+    parser.add_argument("--background", default="#ffffff", help="Background color")
+    parser.add_argument("--padding", type=int, default=40, help="Padding around content")
+    args = parser.parse_args()
+
+    nodes, edges, groups = parse_drawio(args.input)
+    svg = render_svg(nodes, edges, groups,
+                     width=args.width, height=args.height,
+                     title=args.title, bg=args.background,
+                     padding=args.padding)
+
+    with open(args.output, "w", encoding="utf-8") as f:
+        f.write(svg)
+
+    print(f"✅ Converted: {args.output}")
+    print(f"   Canvas: {args.width}x{args.height}, Nodes: {len(nodes)}, Edges: {len(edges)}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/ppt-master/scripts/finalize_svg.py

@@ -238,6 +238,20 @@ def finalize_project(
 
 def main() -> None:
     """Run the CLI entry point."""
+    try:
+        _main_impl()
+    except KeyboardInterrupt:
+        print("\nInterrupted by user.")
+        sys.exit(130)
+    except SystemExit:
+        raise
+    except Exception as e:
+        safe_print(f"[ERROR] Fatal error: {type(e).__name__}: {e}")
+        sys.exit(1)
+
+
+def _main_impl() -> None:
+    """Internal implementation of main CLI logic."""
     parser = argparse.ArgumentParser(
         description='PPT Master - SVG Post-processing Tool',
         formatter_class=argparse.RawDescriptionHelpFormatter,