codewave-openclaw-installer 2.1.13 → 2.2.0

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

@@ -1,366 +0,0 @@
-#!/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()