@littledragon_wxl/drawio-style-graph 1.0.0

package/scripts/rustimports.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""Extract a Rust crate's module-use graph as autolayout graph JSON.
+
+The Rust counterpart to pyimports.py / jsimports.py / goimports.py. Treats each
+.rs file as a module (path-derived: src/foo/bar.rs -> module foo::bar; main.rs /
+lib.rs / mod.rs name the enclosing module), and records intra-crate `use` edges
+resolved through Rust's path roots:
+
+  use crate::a::b::C;   -> edge to module a::b
+  use super::sibling;   -> resolved against the current module's parent
+  use self::child::Item;-> resolved against the current module
+  use other_crate::...; / use std::...;  -> external, ignored
+
+Brace groups (`use crate::a::{B, C};`, `use crate::{a, b};`) are expanded.
+Transitive reduction is on by default so the diagram stays readable.
+
+  python3 rustimports.py ./mycrate --group -o graph.json
+  python3 autolayout.py graph.json -o diagram.drawio
+
+Parsing is regex-based, not a full parser: inline `mod { ... }` blocks are not
+split out, `#[cfg]`-gated modules are always included, and 2015-edition bare
+intra-crate paths (without `crate::`) are not resolved.
+
+Usage: python3 rustimports.py <crate_dir> [-o graph.json] [--direction TB|LR]
+                                           [--group] [--no-reduce]
+"""
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+
+USE = re.compile(r"\buse\s+([^;]+);")
+
+
+def crate_name(root):
+    cargo = os.path.join(root, "Cargo.toml")
+    if os.path.exists(cargo):
+        m = re.search(r'(?m)^\s*name\s*=\s*"([^"]+)"',
+                      open(cargo, encoding="utf-8", errors="ignore").read())
+        if m:
+            return m.group(1)
+    return "crate"
+
+
+def discover(root):
+    """Map module path (tuple of segments; () is the crate root) -> file path."""
+    root = os.path.abspath(root)
+    src = os.path.join(root, "src") if os.path.isdir(os.path.join(root, "src")) else root
+    modules = {}
+    for dirpath, dirs, files in os.walk(src):
+        dirs[:] = [d for d in dirs if d != "target" and not d.startswith(".")]
+        for fn in files:
+            if not fn.endswith(".rs"):
+                continue
+            parts = os.path.relpath(os.path.join(dirpath, fn), src)[:-3].split(os.sep)
+            if parts[-1] == "mod":
+                parts = parts[:-1]
+            if len(parts) == 1 and parts[0] in ("main", "lib"):
+                parts = []                                   # crate root
+            modules[tuple(parts)] = os.path.join(dirpath, fn)
+    return modules, src
+
+
+def split_top(inner):
+    """Split a brace group on top-level commas, ignoring nested braces."""
+    out, depth, cur = [], 0, ""
+    for ch in inner:
+        if ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+        if ch == "," and depth == 0:
+            out.append(cur)
+            cur = ""
+        else:
+            cur += ch
+    if cur.strip():
+        out.append(cur)
+    return out
+
+
+def base_segments(prefix, current):
+    """Classify a `use` path prefix into intra-crate base segments, or None."""
+    segs = [s for s in (p.strip() for p in prefix.split("::")) if s]
+    if not segs:
+        return None
+    if segs[0] == "crate":
+        return segs[1:]
+    if segs[0] == "self":
+        return list(current) + segs[1:]
+    if segs[0] == "super":
+        n = 0
+        while segs and segs[0] == "super":
+            n += 1
+            segs = segs[1:]
+        if n > len(current):
+            return None                                      # climbs above the crate root
+        return list(current)[: len(current) - n] + segs
+    return None                                              # std / external crate
+
+
+def resolve(parts, modules, current):
+    """Longest known module prefix of `parts` (a tuple), or None."""
+    if not parts:
+        return () if () in modules and () != tuple(current) else None
+    p = list(parts)
+    while p:
+        if tuple(p) in modules and tuple(p) != tuple(current):
+            return tuple(p)
+        p = p[:-1]
+    return None
+
+
+def edges_of(current, path, modules):
+    """Intra-crate module paths used by the module at `current`."""
+    found = set()
+    try:
+        src = open(path, encoding="utf-8", errors="ignore").read()
+    except OSError:
+        return found
+    for stmt in USE.findall(src):
+        if "{" in stmt:
+            prefix = stmt[: stmt.index("{")]
+            inner = stmt[stmt.index("{") + 1: stmt.rindex("}")] if "}" in stmt else ""
+            leaves = split_top(inner)
+        else:
+            prefix, leaves = stmt, [None]
+        base = base_segments(prefix, current)
+        if base is None:
+            continue
+        for leaf in leaves:
+            segs = list(base)
+            if leaf:
+                first = leaf.strip().split("::")[0].split()[0]
+                if first and first not in ("self", "*"):
+                    segs.append(first)
+            target = resolve(tuple(segs), modules, current)
+            if target is not None and target != current:
+                found.add(target)
+    return found
+
+
+def transitive_reduce(nodes, edges):
+    """Drop edges implied by a longer path, via Graphviz `tred`."""
+    idx = {n: i for i, n in enumerate(nodes)}
+    dot = "digraph{" + "".join(f"{idx[s]}->{idx[t]};" for s, t in edges) + "}"
+    try:
+        out = subprocess.run(["tred"], input=dot, capture_output=True,
+                             text=True, check=True).stdout
+    except (FileNotFoundError, subprocess.CalledProcessError) as exc:
+        sys.stderr.write(f"warning: tred unavailable, keeping all edges ({exc})\n")
+        return edges
+    rev = {i: n for n, i in idx.items()}
+    return [(rev[int(a)], rev[int(b)]) for a, b in re.findall(r"(\d+)\s*->\s*(\d+)", out)]
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Rust module-use graph -> autolayout graph JSON.")
+    ap.add_argument("crate", help="crate directory (contains Cargo.toml and/or src/)")
+    ap.add_argument("-o", "--output", help="output JSON path (default: stdout)")
+    ap.add_argument("--direction", default="TB", choices=["TB", "LR"])
+    ap.add_argument("--group", action="store_true",
+                    help="box modules by their parent module path (nested)")
+    ap.add_argument("--no-reduce", action="store_true",
+                    help="keep every edge (skip transitive reduction)")
+    args = ap.parse_args()
+
+    modules, _ = discover(args.crate)
+    if not modules:
+        sys.exit(f"error: no .rs modules found under {args.crate}")
+    name = crate_name(args.crate)
+    mid = lambda parts: name if not parts else "::".join(parts)
+    edges = sorted({(mid(m), mid(t)) for m, path in modules.items()
+                    for t in edges_of(m, path, modules)})
+    raw = len(edges)
+    if not args.no_reduce:
+        edges = transitive_reduce([mid(m) for m in modules], edges)
+
+    def node(parts):
+        d = {"id": mid(parts), "label": name if not parts else parts[-1]}
+        if args.group and len(parts) > 1:
+            d["group"] = "/".join(parts[:-1])                # parent module path -> nested boxes
+        return d
+
+    graph = {
+        "direction": args.direction,
+        "nodes": [node(m) for m in modules],
+        "edges": [{"source": s, "target": t} for s, t in edges],
+    }
+    text = json.dumps(graph, indent=2)
+    if args.output:
+        open(args.output, "w", encoding="utf-8").write(text)
+        sys.stderr.write(f"wrote {args.output}\n")
+    else:
+        sys.stdout.write(text)
+    note = "" if args.no_reduce else f" (reduced from {raw})"
+    sys.stderr.write(f"{len(modules)} modules, {len(edges)} edges{note}\n")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/shapesearch.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""Search 10k+ official draw.io shapes for their exact style strings.
+
+Resolves a keyword query (e.g. "aws lambda", "uml actor", "k8s pod") to the
+matching palette shapes so a diagram can use the real draw.io `style=` string
+instead of a hand-guessed one. Covers AWS / Azure / GCP / Cisco / Kubernetes /
+UML / BPMN / P&ID / electrical / flowchart / network / general shape sets.
+
+Based on the search in jgraph/drawio-mcp (Apache-2.0): tag map with exact +
+Soundex matching, strict AND first, scored OR fallback. The matched set is
+identical to upstream; the one addition is a tiebreaker that, among shapes with
+the same tag score, prefers ones whose title contains the query terms verbatim
+(so "dynamodb" returns the shape titled "DynamoDB", not a neighbor merely tagged
+with it). The bundled index (data/shape-index.json.gz) is the upstream draw.io
+shape data — see data/SHAPE-INDEX-NOTICE.md.
+
+Usage:
+  python3 shapesearch.py "aws lambda" [--limit N] [--json]
+"""
+import argparse
+import gzip
+import json
+import os
+import re
+import sys
+
+INDEX = os.path.join(os.path.dirname(__file__), "..", "data", "shape-index.json.gz")
+_SOUNDEX_MAP = "01230120022455012603010202"   # A..Z digit codes
+_TRAIL = re.compile(r"\.*\d*$")               # strip trailing digits/dots before soundex
+
+
+def soundex(name):
+    if not name:
+        return ""
+    s = [name[0].upper()]
+    si = 1
+    for ch in name[1:]:
+        c = ord(ch.upper()) - 65
+        if 0 <= c <= 25 and _SOUNDEX_MAP[c] != "0":
+            code = _SOUNDEX_MAP[c]
+            if code != s[si - 1]:
+                s.append(code)
+                si += 1
+                if si > 3:
+                    break
+    s += ["0"] * (4 - len(s))
+    return "".join(s[:4])
+
+
+def build_tag_map(shapes):
+    """tag (and its Soundex) -> set of shape indices."""
+    tag_map = {}
+    for i, shape in enumerate(shapes):
+        raw = shape.get("tags")
+        if not raw:
+            continue
+        seen = set()
+        for token in re.sub(r"[/,()]", " ", raw.lower()).split(" "):
+            if len(token) < 2 or token in seen:
+                continue
+            seen.add(token)
+            tag_map.setdefault(token, set()).add(i)
+            sx = soundex(_TRAIL.sub("", token))
+            if sx and sx != token and sx not in seen:
+                seen.add(sx)
+                tag_map.setdefault(sx, set()).add(i)
+    return tag_map
+
+
+def split_compound(token):
+    """'pid2misc' -> ['pid','misc']; 'discInst' -> ['disc','inst']."""
+    spaced = re.sub(r"([a-z])([A-Z])", r"\1 \2", token)
+    spaced = re.sub(r"([a-zA-Z])(\d)", r"\1 \2", spaced)
+    spaced = re.sub(r"(\d)([a-zA-Z])", r"\1 \2", spaced)
+    return [p for p in spaced.lower().split() if len(p) >= 2]
+
+
+def match_term(tag_map, term):
+    exact = set(tag_map.get(term, set()))
+    phonetic = set()
+    sx = soundex(_TRAIL.sub("", term))
+    if sx and sx != term:
+        phonetic = {i for i in tag_map.get(sx, set()) if i not in exact}
+    return exact, phonetic
+
+
+def search(shapes, tag_map, query, limit):
+    if not query:
+        return []
+    terms, seen = [], set()
+    for raw in query.lower().split():
+        subs = split_compound(raw) or ([raw] if len(raw) >= 2 else [])
+        for t in subs:
+            if t not in seen:
+                seen.add(t)
+                terms.append(t)
+    if not terms:
+        return []
+
+    term_matches = [match_term(tag_map, t) for t in terms]
+
+    # Strict AND across all terms first.
+    and_set = None
+    for exact, phonetic in term_matches:
+        combined = exact | phonetic
+        and_set = combined if and_set is None else (and_set & combined)
+        if not and_set:
+            break
+
+    # Score: +1.0 exact, +0.5 Soundex-only, per term. AND results if any, else OR.
+    scores = {}
+    pool = and_set if and_set else None
+    for exact, phonetic in term_matches:
+        for idx in exact:
+            if pool is None or idx in pool:
+                scores[idx] = scores.get(idx, 0) + 1.0
+        for idx in phonetic:
+            if (pool is None or idx in pool) and idx not in exact:
+                scores[idx] = scores.get(idx, 0) + 0.5
+
+    # Rank by tag score desc, then by how many query terms appear verbatim in the
+    # title, then casefolded title, then index. The title-hit tiebreak (our one
+    # addition over upstream) only reorders *within* an equal tag-score group, so
+    # e.g. the shape literally titled "DynamoDB" ranks above a neighbor that is
+    # merely tagged `dynamodb` (like "Attribute"). The trailing index keeps ties
+    # deterministic.
+    term_set = set(terms)
+
+    def title_hits(idx):
+        toks = set(re.split(r"[^a-z0-9]+", shapes[idx].get("title", "").casefold()))
+        return len(term_set & toks)
+
+    ranked = sorted(scores, key=lambda i: (-scores[i], -title_hits(i),
+                                           shapes[i].get("title", "").casefold(), i))
+    return [{"style": shapes[i]["style"], "w": shapes[i]["w"],
+             "h": shapes[i]["h"], "title": shapes[i]["title"]} for i in ranked[:limit]]
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Search official draw.io shapes for their style strings.")
+    ap.add_argument("query", help='keywords, e.g. "aws lambda" or "uml actor"')
+    ap.add_argument("--limit", type=int, default=10)
+    ap.add_argument("--json", action="store_true", help="emit JSON instead of a table")
+    args = ap.parse_args()
+
+    if not os.path.exists(INDEX):
+        sys.exit(f"error: shape index not found at {INDEX}")
+    with gzip.open(INDEX, "rt", encoding="utf-8") as f:
+        shapes = json.load(f)
+
+    results = search(shapes, build_tag_map(shapes), args.query, args.limit)
+    if not results:
+        sys.exit(f"no shapes matched {args.query!r}")
+    if args.json:
+        print(json.dumps(results, indent=2, ensure_ascii=False))
+    else:
+        for r in results:
+            print(f"{r['title']}  ({r['w']}x{r['h']})\n  {r['style']}")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/validate.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Deterministic structural linter for .drawio files.
+
+Catches the class of mistakes a vision self-check is slow and unreliable at:
+dangling edge endpoints, duplicate or reserved ids, broken parent references,
+and (as warnings) off-grid geometry and overlapping sibling nodes. Runs without
+launching draw.io, so it is a fast pre-check before the visual review step.
+
+  python3 validate.py diagram.drawio
+
+Exit status is non-zero when any error (or, with --strict, any warning) is
+found, so it can gate a workflow. Compressed (non-XML) diagram pages are
+skipped with a warning — this skill always writes uncompressed XML.
+
+Usage: python3 validate.py <file.drawio> [--strict]
+"""
+import argparse
+import sys
+import xml.etree.ElementTree as ET
+
+RESERVED = {"0", "1"}
+
+
+def rect(cell):
+    """Return (x, y, w, h) floats for a cell's geometry, or None if absent/bad.
+
+    x/y default to 0 when omitted: draw.io treats a missing position as the
+    origin, and container-managed children (table rows, swimlane/UML-class
+    lines under tableLayout) legitimately omit x/y while keeping width/height.
+    Only width/height are required to be present and numeric.
+    """
+    g = cell.find("mxGeometry")
+    if g is None:
+        return None
+    try:
+        return (float(g.get("x", "0")), float(g.get("y", "0")),
+                float(g.get("width", "nan")), float(g.get("height", "nan")))
+    except ValueError:
+        return None
+
+
+def is_edge_label(cell):
+    """True for a draw.io edge label / relative-positioned child vertex.
+
+    These legitimately omit width/height: their position is given relative to a
+    parent edge (style ``edgeLabel``) or via ``relative="1"`` geometry. Treating
+    them as normal vertices wrongly flags them as missing/invalid geometry.
+    """
+    if "edgeLabel" in (cell.get("style") or ""):
+        return True
+    g = cell.find("mxGeometry")
+    return g is not None and g.get("relative") == "1"
+
+
+def overlap(a, b):
+    ax, ay, aw, ah = a
+    bx, by, bw, bh = b
+    return ax < bx + bw and bx < ax + aw and ay < by + bh and by < ay + ah
+
+
+def check_page(diagram):
+    """Return (errors, warnings) for one <diagram> page."""
+    name = diagram.get("name", "?")
+    model = diagram.find("mxGraphModel")
+    if model is None:
+        if (diagram.text or "").strip():
+            return [], [f"page {name!r}: compressed, skipped (cannot lint)"]
+        return [f"page {name!r}: no <mxGraphModel>"], []
+    root = model.find("root")
+    cells = root.findall("mxCell") if root is not None else []
+    errors, warns = [], []
+    ids = {}
+    for c in cells:
+        cid = c.get("id")
+        if cid in ids:
+            errors.append(f"duplicate id {cid!r}")
+        ids[cid] = c
+    parents = {c.get("parent") for c in cells}            # ids that have children
+    for c in cells:
+        cid, parent = c.get("id"), c.get("parent")
+        is_v, is_e = c.get("vertex") == "1", c.get("edge") == "1"
+        if parent is not None and parent not in ids:
+            errors.append(f"cell {cid!r} parent {parent!r} does not exist")
+        for end in ("source", "target"):
+            ref = c.get(end)
+            if ref and ref not in ids:
+                errors.append(f"edge {cid!r} {end} {ref!r} does not exist")
+        if (is_v or is_e) and cid in RESERVED:
+            errors.append(f"cell {cid!r} reuses reserved id 0/1")
+        if is_v and not is_edge_label(c):
+            r = rect(c)
+            if r is None or any(v != v for v in r):       # None or NaN
+                errors.append(f"vertex {cid!r} has missing/invalid geometry")
+            else:
+                x, y, w, h = r
+                if w <= 0 or h <= 0:
+                    warns.append(f"vertex {cid!r} non-positive size {w:g}x{h:g}")
+                if x < 0 or y < 0:
+                    warns.append(f"vertex {cid!r} negative position ({x:g},{y:g})")
+    # Sibling overlap: only leaf vertices (containers legitimately wrap children).
+    boxes = [(c.get("id"), c.get("parent"), rect(c)) for c in cells
+             if c.get("vertex") == "1" and c.get("id") not in parents and rect(c)
+             and not any(v != v for v in rect(c))]
+    for i in range(len(boxes)):
+        for j in range(i + 1, len(boxes)):
+            (ia, pa, ra), (ib, pb, rb) = boxes[i], boxes[j]
+            if pa == pb and overlap(ra, rb):
+                warns.append(f"vertices {ia!r} and {ib!r} overlap")
+    return errors, warns
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Lint a .drawio file for structural errors.")
+    ap.add_argument("file")
+    ap.add_argument("--strict", action="store_true", help="treat warnings as failure too")
+    args = ap.parse_args()
+    try:
+        tree = ET.parse(args.file)
+    except (ET.ParseError, OSError) as exc:
+        sys.exit(f"error: cannot parse {args.file}: {exc}")
+    pages = tree.getroot().findall("diagram") or [tree.getroot()]
+    errors, warns = [], []
+    for page in pages:
+        e, w = check_page(page)
+        errors += e
+        warns += w
+    for w in warns:
+        print(f"warning: {w}")
+    for e in errors:
+        print(f"error: {e}")
+    print(f"{len(errors)} error(s), {len(warns)} warning(s)")
+    if errors or (args.strict and warns):
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/styles/built-in/corporate.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "../schema.json",
+  "name": "corporate",
+  "version": 1,
+  "default": false,
+  "source": { "type": "built-in" },
+  "confidence": "high",
+  "palette": {
+    "primary":   { "fillColor": "#e3f2fd", "strokeColor": "#1565c0" },
+    "success":   { "fillColor": "#e8f5e9", "strokeColor": "#2e7d32" },
+    "warning":   { "fillColor": "#fff9c4", "strokeColor": "#f57c00" },
+    "accent":    { "fillColor": "#fff3e0", "strokeColor": "#e65100" },
+    "danger":    { "fillColor": "#ffebee", "strokeColor": "#c62828" },
+    "neutral":   { "fillColor": "#eceff1", "strokeColor": "#455a64" },
+    "secondary": { "fillColor": "#f3e5f5", "strokeColor": "#6a1b9a" }
+  },
+  "roles": {
+    "service":  "primary",
+    "database": "success",
+    "queue":    "warning",
+    "gateway":  "accent",
+    "error":    "danger",
+    "external": "neutral",
+    "security": "secondary"
+  },
+  "shapes": {
+    "service":   "rounded=0",
+    "database":  "shape=cylinder3",
+    "queue":     "rounded=0",
+    "decision":  "rhombus",
+    "external":  "rounded=0;dashed=1",
+    "container": "swimlane;startSize=30"
+  },
+  "font": {
+    "fontFamily": "Arial",
+    "fontSize": 11,
+    "titleFontSize": 13,
+    "titleBold": true
+  },
+  "edges": {
+    "style": "edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1",
+    "arrow": "endArrow=classic;endFill=1",
+    "dashedFor": ["optional", "async"]
+  },
+  "extras": {
+    "sketch": false,
+    "globalStrokeWidth": 1
+  }
+}

package/styles/built-in/default.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "../schema.json",
+  "name": "default",
+  "version": 1,
+  "default": false,
+  "source": { "type": "built-in" },
+  "confidence": "high",
+  "palette": {
+    "primary":   { "fillColor": "#dae8fc", "strokeColor": "#6c8ebf" },
+    "success":   { "fillColor": "#d5e8d4", "strokeColor": "#82b366" },
+    "warning":   { "fillColor": "#fff2cc", "strokeColor": "#d6b656" },
+    "accent":    { "fillColor": "#ffe6cc", "strokeColor": "#d79b00" },
+    "danger":    { "fillColor": "#f8cecc", "strokeColor": "#b85450" },
+    "neutral":   { "fillColor": "#f5f5f5", "strokeColor": "#666666" },
+    "secondary": { "fillColor": "#e1d5e7", "strokeColor": "#9673a6" }
+  },
+  "roles": {
+    "service":  "primary",
+    "database": "success",
+    "queue":    "warning",
+    "gateway":  "accent",
+    "error":    "danger",
+    "external": "neutral",
+    "security": "secondary"
+  },
+  "shapes": {
+    "service":   "rounded=1",
+    "database":  "shape=cylinder3",
+    "queue":     "rounded=1",
+    "decision":  "rhombus",
+    "external":  "rounded=1;dashed=1",
+    "container": "swimlane;startSize=30"
+  },
+  "font": {
+    "fontFamily": "Helvetica",
+    "fontSize": 12,
+    "titleFontSize": 14,
+    "titleBold": true
+  },
+  "edges": {
+    "style": "edgeStyle=orthogonalEdgeStyle;rounded=1;orthogonalLoop=1;jettySize=auto;html=1",
+    "arrow": "endArrow=classic;endFill=1",
+    "dashedFor": []
+  },
+  "extras": {
+    "sketch": false,
+    "globalStrokeWidth": 1
+  }
+}

package/styles/built-in/handdrawn.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "../schema.json",
+  "name": "handdrawn",
+  "version": 1,
+  "default": false,
+  "source": { "type": "built-in" },
+  "confidence": "high",
+  "palette": {
+    "primary":   { "fillColor": "#ffe4b5", "strokeColor": "#b8651e" },
+    "success":   { "fillColor": "#def0dc", "strokeColor": "#5c8a49" },
+    "warning":   { "fillColor": "#fff4cc", "strokeColor": "#b8901a" },
+    "accent":    { "fillColor": "#ffd9b3", "strokeColor": "#c25100" },
+    "danger":    { "fillColor": "#ffcdbf", "strokeColor": "#a53d3d" },
+    "neutral":   { "fillColor": "#f5e6d3", "strokeColor": "#8b7355" },
+    "secondary": { "fillColor": "#e6d7e8", "strokeColor": "#7b4397" }
+  },
+  "roles": {
+    "service":  "primary",
+    "database": "success",
+    "queue":    "warning",
+    "gateway":  "accent",
+    "error":    "danger",
+    "external": "neutral",
+    "security": "secondary"
+  },
+  "shapes": {
+    "service":   "rounded=1",
+    "database":  "shape=cylinder3",
+    "queue":     "rounded=1",
+    "decision":  "rhombus",
+    "external":  "rounded=1;dashed=1",
+    "container": "swimlane;startSize=30"
+  },
+  "font": {
+    "fontFamily": "Helvetica",
+    "fontSize": 12,
+    "titleFontSize": 14,
+    "titleBold": true
+  },
+  "edges": {
+    "style": "edgeStyle=orthogonalEdgeStyle;curved=1;rounded=1;orthogonalLoop=1;jettySize=auto;html=1",
+    "arrow": "endArrow=classic;endFill=1",
+    "dashedFor": ["optional"]
+  },
+  "extras": {
+    "sketch": true,
+    "globalStrokeWidth": 2
+  }
+}