codewave-openclaw-installer 2.1.10 → 2.1.12

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

@@ -0,0 +1,366 @@
+#!/usr/bin/env python3
+"""
+drawio_gen.py - Generate draw.io XML diagrams from JSON definitions.
+
+Produces .drawio files with automatic layout for architecture diagrams,
+flowcharts, sequence diagrams, etc.
+
+Usage:
+    python drawio_gen.py <json_file> -o <output.drawio>
+    python drawio_gen.py --from-stdin -o <output.drawio>
+    echo '{"nodes":[...], "edges":[...]}' | python drawio_gen.py --from-stdin -o out.drawio
+
+JSON Schema:
+{
+    "title": "System Architecture",           // optional
+    "diagram_type": "architecture",            // architecture|flowchart|sequence|network
+    "direction": "TB",                         // TB|LR|BT|RL (layout direction)
+    "nodes": [
+        {
+            "id": "client",
+            "label": "Client App",
+            "group": "frontend",              // optional, for grouping
+            "shape": "rounded",               // rounded|cylinder|cloud|hexagon|diamond|ellipse|rect|process|document|parallelogram
+            "color": "#dae8fc",               // fill color
+            "stroke": "#6c8ebf",             // stroke color
+            "icon": "mxgraph.aws3.lambda",   // optional mxGraph stencil
+            "width": 140,                     // optional, default 120
+            "height": 60                      // optional, default 60
+        }
+    ],
+    "edges": [
+        {
+            "source": "client",
+            "target": "server",
+            "label": "HTTPS",                // optional
+            "style": "dashed",               // solid|dashed|dotted
+            "arrow": "open",                 // open|block|classic|diamond|none
+            "color": "#666666"               // optional
+        }
+    ],
+    "groups": [                              // optional, for visual grouping
+        {
+            "id": "frontend",
+            "label": "Frontend Layer",
+            "color": "#f5f5f5",
+            "stroke": "#999999"
+        }
+    ]
+}
+"""
+
+import json
+import sys
+import argparse
+import hashlib
+import math
+from xml.etree.ElementTree import Element, SubElement, tostring
+from xml.dom.minidom import parseString
+
+# Shape style mappings
+SHAPE_STYLES = {
+    "rounded":       "rounded=1;whiteSpace=wrap;html=1;arcSize=12;",
+    "rect":          "whiteSpace=wrap;html=1;",
+    "cylinder":      "shape=cylinder3;whiteSpace=wrap;html=1;boundedLbl=1;backgroundOutline=1;size=15;",
+    "cloud":         "ellipse;shape=cloud;whiteSpace=wrap;html=1;",
+    "hexagon":       "shape=hexagon;perimeter=hexagonPerimeter2;whiteSpace=wrap;html=1;fixedSize=1;size=20;",
+    "diamond":       "rhombus;whiteSpace=wrap;html=1;",
+    "ellipse":       "ellipse;whiteSpace=wrap;html=1;",
+    "process":       "shape=process;whiteSpace=wrap;html=1;backgroundOutline=1;size=0.1;",
+    "document":      "shape=document;whiteSpace=wrap;html=1;boundedLbl=1;backgroundOutline=1;size=0.25;",
+    "parallelogram": "shape=parallelogram;perimeter=parallelogramPerimeter;whiteSpace=wrap;html=1;fixedSize=1;size=20;",
+    "database":      "shape=cylinder3;whiteSpace=wrap;html=1;boundedLbl=1;backgroundOutline=1;size=15;",
+    "server":        "shape=mxgraph.cisco.servers.standard_server;whiteSpace=wrap;html=1;",
+    "queue":         "shape=mxgraph.lean_mapping.fifo_sequence_lane;whiteSpace=wrap;html=1;",
+    "component":     "shape=component;align=left;spacingLeft=36;whiteSpace=wrap;html=1;",
+}
+
+ARROW_STYLES = {
+    "open":    "endArrow=open;endFill=0;",
+    "block":   "endArrow=block;endFill=1;",
+    "classic": "endArrow=classic;endFill=1;",
+    "diamond": "endArrow=diamond;endFill=0;",
+    "none":    "endArrow=none;",
+}
+
+LINE_STYLES = {
+    "solid":  "",
+    "dashed": "dashed=1;dashPattern=8 8;",
+    "dotted": "dashed=1;dashPattern=2 2;",
+}
+
+DEFAULT_COLORS = [
+    ("#dae8fc", "#6c8ebf"),  # blue
+    ("#d5e8d4", "#82b366"),  # green
+    ("#f8cecc", "#b85450"),  # red
+    ("#fff2cc", "#d6b656"),  # yellow
+    ("#e1d5e7", "#9673a6"),  # purple
+    ("#d0cee2", "#56517e"),  # indigo
+    ("#f5f5f5", "#666666"),  # gray
+    ("#ffe6cc", "#d79b00"),  # orange
+]
+
+
+def uid(text: str) -> str:
+    return hashlib.md5(text.encode()).hexdigest()[:16]
+
+
+def auto_layout(nodes: list, edges: list, groups: dict, direction: str = "TB") -> dict:
+    """Group-aware layered auto-layout. Returns {node_id: (x, y)}.
+
+    Strategy:
+    1. Determine group ordering by inter-group edge flow (topological sort on groups)
+    2. Within each group, arrange nodes in a compact horizontal row
+    3. Groups are stacked vertically, centered on the canvas
+    4. Ungrouped nodes placed in their topological layer
+    """
+    node_map = {n["id"]: n for n in nodes}
+    canvas_w = 1280  # target canvas width
+
+    # Separate grouped and ungrouped nodes
+    group_members = {}  # group_id -> [node_ids]
+    ungrouped = []
+    for n in nodes:
+        gid = n.get("group")
+        if gid and gid in groups:
+            group_members.setdefault(gid, []).append(n["id"])
+        else:
+            ungrouped.append(n["id"])
+
+    # Determine group order by inter-group edge flow
+    group_ids = list(groups.keys())
+    group_in_deg = {gid: 0 for gid in group_ids}
+    group_adj = {gid: set() for gid in group_ids}
+    for e in edges:
+        sg = node_map.get(e["source"], {}).get("group")
+        tg = node_map.get(e["target"], {}).get("group")
+        if sg and tg and sg != tg and sg in groups and tg in groups:
+            if tg not in group_adj[sg]:
+                group_adj[sg].add(tg)
+                group_in_deg[tg] += 1
+
+    # Topological sort groups
+    group_order = []
+    remaining_g = set(group_ids)
+    while remaining_g:
+        roots = [g for g in remaining_g if group_in_deg.get(g, 0) == 0]
+        if not roots:
+            roots = [min(remaining_g)]
+        # Sort roots by original list order for determinism
+        roots.sort(key=lambda g: group_ids.index(g) if g in group_ids else 999)
+        group_order.extend(roots)
+        for r in roots:
+            remaining_g.discard(r)
+            for t in group_adj.get(r, set()):
+                group_in_deg[t] = max(0, group_in_deg[t] - 1)
+
+    # Layout parameters
+    h_gap = 30       # horizontal gap between nodes in a group
+    v_gap = 100      # vertical gap between group rows
+    margin_x = 60    # left margin
+    margin_y = 40    # top margin
+
+    positions = {}
+    current_y = margin_y
+
+    for gid in group_order:
+        members = group_members.get(gid, [])
+        if not members:
+            continue
+
+        # Calculate total row width
+        total_w = sum(node_map[nid].get("width", 120) for nid in members) + h_gap * (len(members) - 1)
+        # Center the row on canvas
+        start_x = max(margin_x, (canvas_w - total_w) / 2)
+
+        x = start_x
+        max_h = 0
+        for nid in members:
+            n = node_map[nid]
+            w = n.get("width", 120)
+            h = n.get("height", 60)
+            positions[nid] = (x, current_y)
+            x += w + h_gap
+            max_h = max(max_h, h)
+
+        current_y += max_h + v_gap
+
+    # Place ungrouped nodes
+    if ungrouped:
+        # Simple topological layer for ungrouped
+        adj = {n["id"]: [] for n in nodes}
+        in_deg = {n["id"]: 0 for n in nodes}
+        for e in edges:
+            s, t = e["source"], e["target"]
+            if s in adj:
+                adj[s].append(t)
+            if t in in_deg:
+                in_deg[t] = in_deg.get(t, 0) + 1
+
+        for nid in ungrouped:
+            if nid not in positions:
+                total_w = node_map[nid].get("width", 120)
+                start_x = (canvas_w - total_w) / 2
+                positions[nid] = (start_x, current_y)
+                current_y += node_map[nid].get("height", 60) + v_gap
+
+    return positions
+
+
+def build_node_style(node: dict, color_idx: int = 0) -> str:
+    shape = node.get("shape", "rounded")
+    base = SHAPE_STYLES.get(shape, SHAPE_STYLES["rounded"])
+
+    fill = node.get("color", DEFAULT_COLORS[color_idx % len(DEFAULT_COLORS)][0])
+    stroke = node.get("stroke", DEFAULT_COLORS[color_idx % len(DEFAULT_COLORS)][1])
+
+    style = f"{base}fillColor={fill};strokeColor={stroke};fontFamily=Helvetica;fontSize=12;"
+
+    if node.get("icon"):
+        style = f"shape={node['icon']};{style}"
+
+    return style
+
+
+def build_edge_style(edge: dict) -> str:
+    arrow = ARROW_STYLES.get(edge.get("arrow", "classic"), ARROW_STYLES["classic"])
+    line = LINE_STYLES.get(edge.get("style", "solid"), "")
+    color = edge.get("color", "#666666")
+    return f"html=1;rounded=1;{arrow}{line}strokeColor={color};fontFamily=Helvetica;fontSize=11;"
+
+
+def generate_drawio(spec: dict) -> str:
+    """Generate a .drawio XML string from a diagram specification."""
+    nodes = spec.get("nodes", [])
+    edges = spec.get("edges", [])
+    groups_list = spec.get("groups", [])
+    direction = spec.get("direction", "TB")
+    title = spec.get("title", "Diagram")
+
+    groups = {g["id"]: g for g in groups_list}
+
+    # Auto layout
+    positions = auto_layout(nodes, edges, groups, direction)
+
+    # Build XML
+    root = Element("mxfile", type="device", compressed="false")
+    diagram = SubElement(root, "diagram", id="diagram-1", name=title)
+    model = SubElement(diagram, "mxGraphModel", dx="1360", dy="864",
+                       grid="1", gridSize="10", guides="1", tooltips="1",
+                       connect="1", arrows="1", fold="1", page="1",
+                       pageScale="1", pageWidth="1280", pageHeight="720",
+                       math="0", shadow="0")
+    mxroot = SubElement(model, "root")
+    SubElement(mxroot, "mxCell", id="0")
+    SubElement(mxroot, "mxCell", id="1", parent="0")
+
+    # Group containers
+    group_nodes = {}
+    for g in groups_list:
+        gid = f"group_{g['id']}"
+        cell = SubElement(mxroot, "mxCell",
+                          id=gid, value=g.get("label", ""),
+                          style=f"rounded=1;whiteSpace=wrap;html=1;fillColor={g.get('color', '#f5f5f5')};strokeColor={g.get('stroke', '#999999')};dashed=1;dashPattern=4 4;verticalAlign=top;fontStyle=1;fontSize=13;fontFamily=Helvetica;container=1;collapsible=0;",
+                          vertex="1", parent="1")
+        # Calculate group bounds from member nodes
+        member_ids = [n["id"] for n in nodes if n.get("group") == g["id"]]
+        if member_ids:
+            xs = [positions[mid][0] for mid in member_ids if mid in positions]
+            ys = [positions[mid][1] for mid in member_ids if mid in positions]
+            if xs and ys:
+                padding = 30
+                gx = min(xs) - padding
+                gy = min(ys) - padding - 20  # extra for label
+                gw = max(xs) - min(xs) + 180 + 2 * padding
+                gh = max(ys) - min(ys) + 80 + 2 * padding + 20
+                SubElement(cell, "mxGeometry", x=str(int(gx)), y=str(int(gy)),
+                           width=str(int(gw)), height=str(int(gh)),
+                           attrib={"as": "geometry"})
+        group_nodes[g["id"]] = gid
+
+    # Nodes
+    node_color_map = {}
+    for idx, n in enumerate(nodes):
+        nid = n["id"]
+        x, y = positions.get(nid, (100, 100))
+        w = n.get("width", 120)
+        h = n.get("height", 60)
+
+        # Assign color index by group or sequential
+        group_id = n.get("group")
+        if group_id:
+            if group_id not in node_color_map:
+                node_color_map[group_id] = len(node_color_map)
+            cidx = node_color_map[group_id]
+        else:
+            cidx = idx
+
+        style = build_node_style(n, cidx)
+        parent = group_nodes.get(group_id, "1")
+
+        cell = SubElement(mxroot, "mxCell",
+                          id=nid, value=n.get("label", nid),
+                          style=style, vertex="1", parent=parent)
+
+        # If inside a group, use relative coordinates
+        if group_id in group_nodes:
+            gid = group_nodes[group_id]
+            # Find group bounds to compute relative position
+            member_ids = [nd["id"] for nd in nodes if nd.get("group") == group_id]
+            gxs = [positions[mid][0] for mid in member_ids if mid in positions]
+            gys = [positions[mid][1] for mid in member_ids if mid in positions]
+            if gxs and gys:
+                rel_x = x - min(gxs) + 30
+                rel_y = y - min(gys) + 50
+                SubElement(cell, "mxGeometry", x=str(int(rel_x)), y=str(int(rel_y)),
+                           width=str(w), height=str(h),
+                           attrib={"as": "geometry"})
+            else:
+                SubElement(cell, "mxGeometry", x=str(int(x)), y=str(int(y)),
+                           width=str(w), height=str(h),
+                           attrib={"as": "geometry"})
+        else:
+            SubElement(cell, "mxGeometry", x=str(int(x)), y=str(int(y)),
+                       width=str(w), height=str(h),
+                       attrib={"as": "geometry"})
+
+    # Edges
+    for e in edges:
+        eid = uid(f"{e['source']}-{e['target']}-{e.get('label','')}")
+        style = build_edge_style(e)
+        cell = SubElement(mxroot, "mxCell",
+                          id=eid, value=e.get("label", ""),
+                          style=style, edge="1", parent="1",
+                          source=e["source"], target=e["target"])
+        SubElement(cell, "mxGeometry", relative="1",
+                   attrib={"as": "geometry"})
+
+    # Pretty print
+    xml_str = tostring(root, encoding="unicode")
+    return parseString(xml_str).toprettyxml(indent="  ", encoding=None)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate draw.io diagrams from JSON")
+    parser.add_argument("input", nargs="?", help="JSON input file")
+    parser.add_argument("--from-stdin", action="store_true", help="Read JSON from stdin")
+    parser.add_argument("-o", "--output", required=True, help="Output .drawio file")
+    args = parser.parse_args()
+
+    if args.from_stdin:
+        spec = json.load(sys.stdin)
+    elif args.input:
+        with open(args.input, "r", encoding="utf-8") as f:
+            spec = json.load(f)
+    else:
+        parser.error("Provide an input file or --from-stdin")
+
+    xml = generate_drawio(spec)
+    with open(args.output, "w", encoding="utf-8") as f:
+        f.write(xml)
+    print(f"✅ Generated: {args.output}")
+    print(f"   Nodes: {len(spec.get('nodes', []))}, Edges: {len(spec.get('edges', []))}")
+
+
+if __name__ == "__main__":
+    main()