Skip to content

roxorlt/UEmaster / skills/flow-canvas

flow-canvas

Verified

把业务图渲染成横平竖直的规范 SVG:流程图(正交规范)、架构图(泳道分层)、ER 图、甘特图、时序图。触发:画流程图、业务流程图、架构图、ER 图、甘特图、时序图、把 mermaid 转规范图、流程图横平竖直、评审用图、render flowchart / orthogonal flowchart / architecture diagram / ER diagram / gantt / sequence diagram / draw a clean diagram from mermaid。不适用:只要 mermaid 源码文本、脑图、表格。

FileKindSize
LICENSEother1.0 KB
README.mdmarkdown3.7 KB
SKILL.mdskill md10.2 KB
agents/interface.yamlconfig1.4 KB
contract/archspec-v1.mdmarkdown2.1 KB
contract/archspec-v2.mdmarkdown3.0 KB
contract/archspec-v3.mdmarkdown5.1 KB
contract/archspec-v4.mdmarkdown5.0 KB
contract/archspec-v5.mdmarkdown3.5 KB
contract/blueprintspec-v1.mdmarkdown7.7 KB
contract/blueprintspec-v2.mdmarkdown4.0 KB
contract/blueprintspec-v4.mdmarkdown4.1 KB
contract/erspec-v1.mdmarkdown1.9 KB
contract/erspec-v2.mdmarkdown4.2 KB
contract/flowspec-v1.mdmarkdown3.0 KB
contract/ganttspec-v1.mdmarkdown1.9 KB
contract/seqspec-v1.mdmarkdown1.6 KB
examples/arch-3tier.mmdother289 B
examples/arch-logical.mmdother680 B
examples/arch-microservice.mmdother342 B
examples/arch-portal.mmdother262 B
examples/arch-skip.mmdother337 B
examples/blueprint-enterprise.mmdother2.0 KB
examples/blueprint-layered.mmdother794 B
examples/er-blog.mmdother324 B
examples/er-order.mmdother449 B
examples/er-school.mmdother409 B
examples/gantt-day-schedule.mmdother321 B
examples/gantt-infra.mmdother473 B
examples/gantt-release.mmdother483 B
examples/minimal.mmdother133 B
examples/pet-boarding.mmdother1.2 KB
examples/seq-login-auth.mmdother308 B
examples/seq-oauth-resource.mmdother386 B
examples/seq-order-pay.mmdother338 B
examples/seq-push-notify.mmdother414 B
manifest.jsonconfig288 B
scripts/flowcommon.pyexecutablescript21.3 KB
scripts/flowlayout.pyexecutablescript30.7 KB
scripts/layout_arch.pyexecutablescript60.6 KB
scripts/layout_blueprint.pyscript78.8 KB
scripts/layout_er.pyexecutablescript21.1 KB
scripts/layout_gantt.pyexecutablescript14.4 KB
scripts/layout_seq.pyexecutablescript13.5 KB
scripts/selftest.pyexecutablescript6.0 KB
scripts/selftest_arch.pyexecutablescript18.5 KB
scripts/selftest_blueprint.pyscript22.2 KB
scripts/selftest_er.pyexecutablescript10.5 KB
scripts/selftest_gantt.pyexecutablescript6.7 KB
scripts/selftest_seq.pyexecutablescript6.1 KB

scripts/layout_er.py

View on GitHub
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""ER 图布局模块(layout_er)。实现 erspec/2 契约,见 contract/erspec-v2.md。

布局要点:实体表格块在网格中向上/下/左/右扩展(行列对齐),
边在行间隙 / 列间隙中正交绕行,两端画乌鸦脚(crow's foot)基数记号。
"""
import re
import sys
from collections import deque

from flowcommon import (
    COMMON_STYLE, text_width, esc, ortho_crossings, box_overlaps,
    text_overflow_check, svg_open, svg_close, svg_text,
    render_html as _render_html, common_argparse, common_main)

SPEC_VERSION = "erspec/2"
DATA_ATTR = 'data-erspec="2"'

STYLE = dict(COMMON_STYLE)
STYLE.update({
    "header_fill": "#e9e9e9",
    "row_line": "#e0e0e0",
    "attr_h": 18,
    "header_h": 26,
    "col_gap": 80,
    "row_gap": 80,
    "margin": 60,
    "detour_step": 14,
})

MAX_ENTITIES = 8
CARDS = {"||", "o|", "|o", "o{", "}o", "|{", "}|"}
ENTITY_RE = re.compile(r'^([A-Za-z][A-Za-z0-9_]*)\s*\{\s*$')
REL_RE = re.compile(r'^([A-Za-z][A-Za-z0-9_]*)\s+(\S+)\s*--\s*(\S+)\s+([A-Za-z][A-Za-z0-9_]*)\s*:\s*(.*)$')
_ID_RE = re.compile(r'^[A-Za-z][A-Za-z0-9_]*$')
_COMMENT_TOKEN_RE = re.compile(r'^[\u4e00-\u9fffA-Za-z0-9_]+$')

# 四邻域(先上下左右)与对角(用于网格放置)
NEIGH4 = [(-1, 0), (1, 0), (0, -1), (0, 1)]
DIAG = [(-1, -1), (-1, 1), (1, -1), (1, 1)]
# 端口向外单位向量
OUT = {"L": (-1, 0), "R": (1, 0), "T": (0, -1), "B": (0, 1)}


def parse_mermaid(src):
    nodes, order = {}, []
    edges = []
    cur = None
    for raw in src.splitlines():
        line = raw.strip()
        if not line or line.startswith("%%") or line.startswith("erDiagram"):
            continue
        m = ENTITY_RE.match(line)
        if m:
            name = m.group(1)
            if name in nodes:
                raise SystemExit("错误:实体 %s 重复定义(形态超限)" % name)
            nodes[name] = {"id": name, "label": [name], "attrs": []}
            order.append(name)
            cur = name
            continue
        if line == "}":
            cur = None
            continue
        m = REL_RE.match(line)
        if m:
            a, cl, cr, b, label = m.groups()
            if cl not in CARDS or cr not in CARDS:
                raise SystemExit("错误:关系 %s--%s 基数记号无法识别(形态超限)" % (cl, cr))
            label = label.strip()
            if len(label) >= 2 and label[0] == '"' and label[-1] == '"':
                label = label[1:-1]
            edges.append({"from": a, "to": b, "cardL": cl, "cardR": cr,
                          "label": [label] if label else []})
            continue
        if cur:
            nodes[cur]["attrs"].append(_parse_attr(line, cur))
            continue
        raise SystemExit("错误:无法识别的行「%s」(形态超限,请改用 mermaid 原生渲染)" % line)

    for e in edges:
        for nid in (e["from"], e["to"]):
            if nid not in nodes:
                raise SystemExit("错误:关系引用了未定义实体 %s(形态超限)" % nid)
        if e["from"] == e["to"]:
            raise SystemExit("错误:实体自引用关系不支持(形态超限)")
    if len(order) > MAX_ENTITIES:
        raise SystemExit("错误:实体数 %d 超过上限 %d(形态超限)" % (len(order), MAX_ENTITIES))

    seen = set()
    for e in edges:
        key = (e["from"], e["to"], e["cardL"], e["cardR"])
        if key in seen:
            raise SystemExit("错误:关系 %s %s--%s %s 完全重复(形态超限)"
                             % (e["from"], e["cardL"], e["cardR"], e["to"]))
        seen.add(key)

    return {"spec": SPEC_VERSION, "nodes": [nodes[i] for i in order], "edges": edges}


def _parse_attr(line, cur):
    """属性行 = `类型 属性名 [PK|FK] ["注释"]`;注释可带引号也可不带。

    去掉引号注释后,剩余尾部分号/逗号分隔的 token:
      ∈ {PK, FK} → 修饰;由中文/字母数字/下划线组成 → 合并为注释;
      含其他字符 → 报「形态超限」。
    """
    parts = line.split(None, 2)
    if len(parts) < 2 or not (_ID_RE.match(parts[0]) and _ID_RE.match(parts[1])):
        raise SystemExit("错误:实体 %s 的属性行「%s」无法解析(形态超限)" % (cur, line))
    atype, aname = parts[0], parts[1]
    rest = parts[2] if len(parts) > 2 else ""

    comment = ""
    qm = re.search(r'"([^"]*)"', rest)
    if qm:
        comment = qm.group(1)
        rest = rest[:qm.start()] + " " + rest[qm.end():]

    flags, extra = [], []
    for tok in re.split(r'[;,\s]+', rest):
        tok = tok.strip()
        if not tok:
            continue
        if tok in ("PK", "FK"):
            flags.append(tok)
        elif _COMMENT_TOKEN_RE.match(tok):
            extra.append(tok)
        else:
            raise SystemExit("错误:实体 %s 的属性行「%s」无法解析(形态超限,含非法字符「%s」)"
                             % (cur, line, tok))
    if extra and not comment:
        comment = " ".join(extra)

    text = "%s %s" % (atype, aname)
    if comment:
        text += " (%s)" % comment
    return {"pk": "PK" in flags, "fk": "FK" in flags, "text": text}


def load_spec(path):
    text = open(path, encoding="utf-8").read()
    return parse_mermaid(text)


def iter_labels(spec):
    for n in spec["nodes"]:
        yield n["label"][0]
        for a in n["attrs"]:
            yield a["text"]
    for e in spec["edges"]:
        for l in e.get("label", []):
            yield l


# ── 网格放置 ────────────────────────────────────────────────────────
def _place_once(order, edges):
    """确定性贪心网格放置。order: [id](候选序,order[0] 为种子),edges: 边声明序。"""
    pos = {order[0]: (0, 0)}
    grid = {(0, 0): order[0]}

    def place_near(eid, r, c):
        for dr, dc in NEIGH4 + DIAG:
            cell = (r + dr, c + dc)
            if cell not in grid:
                pos[eid] = cell
                grid[cell] = eid
                return
        place_ring(eid)

    def place_ring(eid):
        q = deque([(0, 0)])
        seen = {(0, 0)}
        while q:
            r, c = q.popleft()
            if (r, c) not in grid:
                pos[eid] = (r, c)
                grid[(r, c)] = eid
                return
            for dr, dc in NEIGH4:
                cell = (r + dr, c + dc)
                if cell not in seen:
                    seen.add(cell)
                    q.append(cell)

    for e in edges:
        a, b = e["from"], e["to"]
        pa, pb = a in pos, b in pos
        if pa and not pb:
            place_near(b, *pos[a])
        elif pb and not pa:
            place_near(a, *pos[b])
    for eid in order:
        if eid not in pos:
            place_ring(eid)

    min_r = min(r for r, _ in pos.values())
    min_c = min(c for _, c in pos.values())
    return {eid: (r - min_r, c - min_c) for eid, (r, c) in pos.items()}


def _to_pixels(pos, ents, st):
    rows = sorted(set(r for r, _ in pos.values()))
    cols = sorted(set(c for _, c in pos.values()))
    by_col = {c: [eid for eid, (_, cc) in pos.items() if cc == c] for c in cols}
    by_row = {r: [eid for eid, (rr, _) in pos.items() if rr == r] for r in rows}
    col_w = {c: max(ents[e]["w"] for e in by_col[c]) + st["col_gap"] for c in cols}
    row_h = {r: max(ents[e]["h"] for e in by_row[r]) + st["row_gap"] for r in rows}
    margin = st["margin"]
    col_left, x = {}, margin
    for c in cols:
        col_left[c] = x
        x += col_w[c]
    row_top, y = {}, margin
    for r in rows:
        row_top[r] = y
        y += row_h[r]
    W = round(margin + sum(col_w.values()) + margin)
    H = round(margin + sum(row_h.values()) + margin)
    for eid, (r, c) in pos.items():
        ents[eid]["x"] = col_left[c] + col_w[c] / 2
        ents[eid]["y"] = row_top[r] + row_h[r] / 2
        ents[eid]["grid"] = (r, c)
    return W, H, cols, rows, col_left, row_top, col_w, row_h


# ── 路由 ────────────────────────────────────────────────────────────
def _span(card):
    return 15 if card in ("||", "o|", "|o") else 41


def _stagger(k, step):
    if k == 0:
        return 0
    sign = 1 if k % 2 == 1 else -1
    return sign * step * ((k + 1) // 2)


def _port(n, side, off):
    x, y, w, h = n["x"], n["y"], n["w"], n["h"]
    if side == "L":
        return (x - w / 2, y + off)
    if side == "R":
        return (x + w / 2, y + off)
    if side == "T":
        return (x + off, y - h / 2)
    return (x + off, y + h / 2)


def _indent(p, side, span, plus):
    dx, dy = OUT[side]
    return (p[0] + dx * (span + plus), p[1] + dy * (span + plus))


def _route(edges, ents, pos, cols, rows, col_left, row_top, col_w, row_h, st):
    edge_sides, usage = [], {}
    for idx, e in enumerate(edges):
        a, b = e["from"], e["to"]
        ra, ca = pos[a]
        rb, cb = pos[b]
        dr, dc = rb - ra, cb - ca
        if abs(dr) + abs(dc) == 1:
            if dc == 1:
                sa, ta = "R", "L"
            elif dc == -1:
                sa, ta = "L", "R"
            elif dr == 1:
                sa, ta = "B", "T"
            else:
                sa, ta = "T", "B"
        elif dr == 0:
            sa = ta = "T" if ra == 0 else "B"
        elif dc == 0:
            sa = ta = "L" if ca == 0 else "R"
        else:
            sa = "B" if dr > 0 else "T"
            ta = "T" if dr > 0 else "B"
        edge_sides.append((sa, ta))
        usage.setdefault((a, sa), []).append((idx, "s"))
        usage.setdefault((b, ta), []).append((idx, "t"))

    port_off = {}
    for lst in usage.values():
        for k, (idx, role) in enumerate(lst):
            port_off[(idx, role)] = _stagger(k, 8)

    row_bottom = {r: row_top[r] + row_h[r] for r in rows}
    col_right = {c: col_left[c] + col_w[c] for c in cols}
    hcorr, vcorr = {}, {}

    def hoff(yc):
        k = hcorr.get(yc, 0)
        hcorr[yc] = k + 1
        return _stagger(k, st["detour_step"])

    def voff(xc):
        k = vcorr.get(xc, 0)
        vcorr[xc] = k + 1
        return _stagger(k, st["detour_step"])

    routes, detours, label_overflow = [], 0, []
    for idx, e in enumerate(edges):
        a, b = e["from"], e["to"]
        na, nb = ents[a], ents[b]
        ra, ca = pos[a]
        rb, cb = pos[b]
        dr, dc = rb - ra, cb - ca
        sa, ta = edge_sides[idx]
        ps = _port(na, sa, port_off[(idx, "s")])
        pt = _port(nb, ta, port_off[(idx, "t")])
        spanL, spanR = _span(e["cardL"]), _span(e["cardR"])
        label = e.get("label", [])

        if abs(dr) + abs(dc) == 1:
            p1 = _indent(ps, sa, spanL, 2)
            p2 = _indent(pt, ta, spanR, 2)
            pts = [p1, p2]
            if dc != 0:
                lx, ly, anchor = (p1[0] + p2[0]) / 2, p1[1] - 6, "middle"
                gap = abs(pt[0] - ps[0])
            else:
                lx, ly, anchor = p1[0] + 8, (p1[1] + p2[1]) / 2, "middle"
                gap = abs(pt[1] - ps[1])
        else:
            detours += 1
            pts, lx, ly, gap = _detour_pts(
                ps, pt, sa, ta, spanL, spanR, ra, ca, rb, cb,
                row_top, row_bottom, col_left, col_right, hoff, voff, st)
            anchor = "middle"

        if label:
            for t in label:
                need = text_width(t, st["fs_label"])
                if need > gap + 8:
                    label_overflow.append({"id": "%s-%s" % (a, b), "line": 0,
                                           "text": t, "need": round(need),
                                           "avail": round(gap + 8)})

        routes.append({"pts": pts, "label": label, "lx": lx, "ly": ly, "anchor": anchor,
                       "ends": [{"card": e["cardL"], "x": ps[0], "y": ps[1], "side": sa},
                                {"card": e["cardR"], "x": pt[0], "y": pt[1], "side": ta}]})
    return routes, detours, label_overflow


def _detour_pts(ps, pt, sa, ta, spanL, spanR, ra, ca, rb, cb,
                row_top, row_bottom, col_left, col_right, hoff, voff, st):
    p1 = _indent(ps, sa, spanL, 4)
    pend = _indent(pt, ta, spanR, 4)
    dr, dc = rb - ra, cb - ca
    if dr == 0:
        ycorr = row_top[0] if ra == 0 else row_bottom[ra]
        y = ycorr + hoff(ycorr)
        pts = [p1, (p1[0], y), (pend[0], y), pend]
        lx, ly = (p1[0] + pend[0]) / 2, y - 6
        gap = st["col_gap"]
    elif dc == 0:
        xcorr = col_left[0] if ca == 0 else col_right[ca]
        x = xcorr + voff(xcorr)
        pts = [p1, (x, p1[1]), (x, pend[1]), pend]
        lx, ly = (p1[0] + x) / 2, p1[1] - 6
        gap = st["row_gap"]
    else:
        y1corr = row_bottom[ra] if dr > 0 else row_top[ra]
        xcorr = col_left[cb] if dc > 0 else col_right[cb]
        y2corr = row_top[rb] if dr > 0 else row_bottom[rb]
        y1 = y1corr + hoff(y1corr)
        x = xcorr + voff(xcorr)
        y2 = y2corr + hoff(y2corr)
        pts = [p1, (p1[0], y1), (x, y1), (x, y2), (pend[0], y2), pend]
        lx, ly = (p1[0] + x) / 2, y1 - 6
        gap = st["col_gap"]
    return pts, lx, ly, gap


# ── 布局 ────────────────────────────────────────────────────────────
def _layout_once(order, edges, base, decl_order, st, fs, fsub, fcard):
    ents = {eid: dict(base[eid]) for eid in base}
    pos = _place_once(order, edges)
    W, H, cols, rows, col_left, row_top, col_w, row_h = _to_pixels(pos, ents, st)
    routes, detours, label_overflow = _route(
        edges, ents, pos, cols, rows, col_left, row_top, col_w, row_h, st)

    crossings = ortho_crossings(routes)
    boxes = [(eid, ents[eid]["x"], ents[eid]["y"], ents[eid]["w"], ents[eid]["h"])
             for eid in decl_order]
    overlaps = box_overlaps(boxes)

    tmp = {}
    for eid in decl_order:
        n = ents[eid]
        tmp[eid] = {"w": n["w"], "label": [n["label"][0]] + [a["text"] for a in n["attrs"]]}

    def metrics(n, j):
        return (fs if j == 0 else fsub), n["w"] - 10

    overflow = text_overflow_check(tmp, decl_order, metrics) + label_overflow

    return {"nodes": ents, "order": list(decl_order), "routes": routes,
            "extra": {"grid": pos}, "W": W, "H": H, "style": st,
            "crossings": crossings, "overlaps": overlaps,
            "textOverflow": overflow, "warnings": [], "detours": detours}


def layout(spec, style=None, args=None):
    st = dict(STYLE)
    if style:
        st.update(style)
    base = {n["id"]: dict(n) for n in spec["nodes"]}
    decl_order = [n["id"] for n in spec["nodes"]]
    edges = [dict(e) for e in spec["edges"]]
    fs, fsub, fcard = st["fs_node"], st["fs_sub"], st["fs_label"]

    for eid in decl_order:
        n = base[eid]
        widths = [text_width(n["label"][0], fs)] + [text_width(a["text"], fsub) for a in n["attrs"]]
        n["w"] = round(max(widths) + 20)
        n["h"] = st["header_h"] + len(n["attrs"]) * st["attr_h"] + 10

    # 候选实体放置序:声明序 / 2 轮 barycenter / 逆声明序
    candidates = [list(decl_order)]
    order = list(decl_order)
    idx = {eid: i for i, eid in enumerate(order)}
    for _ in range(2):
        sums = {eid: 0.0 for eid in order}
        cnt = {eid: 0 for eid in order}
        for e in edges:
            sums[e["from"]] += idx[e["to"]]
            cnt[e["from"]] += 1
            sums[e["to"]] += idx[e["from"]]
            cnt[e["to"]] += 1
        order = sorted(order, key=lambda eid: (sums[eid] / cnt[eid] if cnt[eid] else idx[eid]))
        idx = {eid: k for k, eid in enumerate(order)}
        candidates.append(list(order))
    candidates.append(list(reversed(decl_order)))

    best = None
    for cand in candidates:
        lay = _layout_once(cand, edges, base, decl_order, st, fs, fsub, fcard)
        if best is None or len(lay["crossings"]) < len(best["crossings"]):
            best = lay

    if best["detours"] > 6:
        raise SystemExit("错误:绕行边数 %d 超过上限 6(形态超限,请简化关系或改用 mermaid 原生渲染)"
                         % best["detours"])
    if len(best["crossings"]) > 0:
        raise SystemExit("错误:网格布局后仍有 %d 处边交叉(形态超限,请简化关系或改用 mermaid 原生渲染)"
                         % len(best["crossings"]))
    return best


# ── 乌鸦脚渲染 ──────────────────────────────────────────────────────
def _card_svg(card, px, py, side, edge_color):
    out = []

    def tick(d):
        if side in ("L", "R"):
            xd = px - d if side == "L" else px + d
            return ('<line class="er-tick" x1="%g" y1="%g" x2="%g" y2="%g" '
                    'stroke="%s" stroke-width="1.4"/>' % (xd, py - 8, xd, py + 8, edge_color))
        yd = py - d if side == "T" else py + d
        return ('<line class="er-tick" x1="%g" y1="%g" x2="%g" y2="%g" '
                'stroke="%s" stroke-width="1.4"/>' % (px - 8, yd, px + 8, yd, edge_color))

    def circle(d):
        if side in ("L", "R"):
            cx = px - d if side == "L" else px + d
            cy = py
        else:
            cx = px
            cy = py - d if side == "T" else py + d
        return ('<circle class="er-circle" cx="%g" cy="%g" r="5" fill="#ffffff" '
                'stroke="%s" stroke-width="1.4"/>' % (cx, cy, edge_color))

    def fork():
        if side == "L":
            apex, legs = (px - 26, py), [(px - 14, py), (px - 14, py - 8), (px - 14, py + 8)]
        elif side == "R":
            apex, legs = (px + 26, py), [(px + 14, py), (px + 14, py - 8), (px + 14, py + 8)]
        elif side == "T":
            apex, legs = (px, py - 26), [(px, py - 14), (px - 8, py - 14), (px + 8, py - 14)]
        else:
            apex, legs = (px, py + 26), [(px, py + 14), (px - 8, py + 14), (px + 8, py + 14)]
        return "".join('<line class="er-fork" x1="%g" y1="%g" x2="%g" y2="%g" '
                       'stroke="%s" stroke-width="1.4"/>' % (apex[0], apex[1], lx, ly, edge_color)
                       for lx, ly in legs)

    if card == "||":
        out.append(tick(6))
        out.append(tick(13))
    elif card in ("o|", "|o"):
        out.append(tick(6))
        out.append(circle(16))
    elif card == "|{":
        out.append(fork())
        out.append(tick(34))
    elif card in ("o{", "}o"):
        out.append(fork())
        out.append(circle(34))
    elif card == "}|":
        out.append(fork())
        out.append(tick(34))
    return '<g class="er-card" data-card="%s">%s</g>' % (esc(card), "".join(out))


def render_svg(lay, title=""):
    st = lay["style"]
    out = svg_open(lay["W"], lay["H"], DATA_ATTR, st)
    for i, nid in enumerate(lay["order"]):
        n = lay["nodes"][nid]
        x0, y0 = n["x"] - n["w"] / 2, n["y"] - n["h"] / 2
        out.append('<g class="entity" id="er-%s-%d">' % (nid, i))
        out.append('<rect x="%g" y="%g" width="%g" height="%g" rx="3" fill="%s" stroke="%s" stroke-width="1.2"/>'
                   % (x0, y0, n["w"], n["h"], st["fill"], st["stroke"]))
        hy = y0 + st["header_h"]
        out.append('<rect x="%g" y="%g" width="%g" height="%g" fill="%s"/>'
                   % (x0, y0, n["w"], st["header_h"], st["header_fill"]))
        out.append('<line x1="%g" y1="%g" x2="%g" y2="%g" stroke="%s" stroke-width="0.8"/>'
                   % (x0, hy, x0 + n["w"], hy, st["row_line"]))
        out.append(svg_text(n["x"], y0 + st["header_h"] / 2 + 4, st["fs_node"], st["text"],
                            "middle", n["label"][0]))
        for k, a in enumerate(n["attrs"]):
            ay = hy + (k + 0.5) * st["attr_h"] + 4
            deco = ' text-decoration="underline"' if a["pk"] else ""
            style_attr = ' font-style="italic"' if a["fk"] else ""
            out.append('<text x="%g" y="%g" font-size="%d" fill="%s" text-anchor="middle"%s%s>%s</text>'
                       % (n["x"], ay, st["fs_sub"], st["text"], deco, style_attr, esc(a["text"])))
            if k:
                out.append('<line x1="%g" y1="%g" x2="%g" y2="%g" stroke="%s" stroke-width="0.6"/>'
                           % (x0 + 6, hy + k * st["attr_h"], x0 + n["w"] - 6, hy + k * st["attr_h"], st["row_line"]))
        out.append('</g>')
    for r in lay["routes"]:
        p = " ".join("%g,%g" % (px, py) for px, py in r["pts"])
        out.append('<polyline points="%s" fill="none" stroke="%s" stroke-width="1.4"/>'
                   % (p, st["edge_color"]))
        if r["label"] and r["lx"] is not None:
            for k, t in enumerate(r["label"]):
                out.append(svg_text(r["lx"], r["ly"] + k * 13, st["fs_label"], st["label_color"],
                                    r["anchor"], t))
        for end in r["ends"]:
            out.append(_card_svg(end["card"], end["x"], end["y"], end["side"], st["edge_color"]))
    out += svg_close()
    return "\n".join(out)


def render_html(lay, title):
    return _render_html(render_svg(lay, title), title, lay["style"]["font_family"])


def main_cli(args):
    return common_main(args, sys.modules[__name__])


if __name__ == "__main__":
    ap = common_argparse("flow-canvas ER 图布局器(erspec/2)")
    raise SystemExit(main_cli(ap.parse_args()))
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall