Altium - the Altium Bridge

@@ -1714,6 +1714,96 @@ def _chk_schematic_placeholders(board, sheet):     return out  ++# Altium's TRuleKind ordinals, read off a live AD26 default rule set (each default rule is named+# after its own kind, which makes the mapping observable rather than guessed). Unknown ordinals are+# rendered as "kind <n>" — never invented.+RULE_KIND_NAMES = {+    0: "Clearance", 2: "Width", 6: "PlaneConnect", 7: "RoutingTopology", 8: "RoutingPriority",+    9: "RoutingLayers", 10: "RoutingCorners", 11: "RoutingVias", 12: "PlaneClearance",+    13: "SolderMaskExpansion", 14: "PasteMaskExpansion", 15: "ShortCircuit", 16: "UnRoutedNet",+    20: "PolygonConnect", 24: "ComponentClearance", 42: "HoleSize", 43: "FabricationTestpoint",+    44: "FabricationTestPointUsage", 48: "LayerPairs", 49: "Fanout", 50: "Height",+    51: "DiffPairsRouting", 52: "HoleToHoleClearance", 53: "MinimumSolderMaskSliver",+    54: "SilkToSolderMaskClearance", 55: "SilkToSilkClearance", 56: "NetAntennae",+    57: "AssemblyTestpoint", 58: "AssemblyTestPointUsage", 59: "SilkToBoardRegionClearance",+    62: "UnpouredPolygon",+}+# Rules whose absence a fabricator will notice before you do.+CRITICAL_RULE_KINDS = {0: "Clearance", 2: "Width", 42: "HoleSize", 15: "ShortCircuit"}+++def _rule_kind_name(k):+    return RULE_KIND_NAMES.get(k, f"kind {k}")+++def _chk_disabled_design_rules(board, sheet):+    """warning — a design rule that exists but is switched OFF.++    A disabled Clearance or ShortCircuit rule is worse than a missing one: the board LOOKS ruled,+    DRC passes, and the constraint was never applied."""+    out = []+    for r in (board.get("rules") or {}).get("rules") or []:+        if r.get("enabled") is False:+            kind = _rule_kind_name(r.get("kind"))+            sev = "error" if r.get("kind") in CRITICAL_RULE_KINDS else "warning"+            out.append({"check": "disabled_design_rules", "severity": sev, "rule": r.get("name"),+                        "message": f"Design rule {r.get('name')!r} ({kind}) is DISABLED — DRC will pass "+                                   f"without ever applying it."})+    return out+++def _chk_missing_critical_rules(board, sheet):+    """error — no ENABLED rule of a kind a fabricator relies on."""+    rules = (board.get("rules") or {}).get("rules") or []+    if not rules:+        return []  # no rule data at all is not the same as no rules+    have = {r.get("kind") for r in rules if r.get("enabled") is not False}+    out = []+    for kind, name in sorted(CRITICAL_RULE_KINDS.items()):+        if kind not in have:+            out.append({"check": "missing_critical_rules", "severity": "error", "rule": name,+                        "message": f"No enabled {name} rule on this board."})+    return out+++def _chk_duplicate_rule_priority(board, sheet):+    """info — two enabled rules of the same kind sharing a priority.++    Altium resolves ties by internal order, so which one wins is not something you can read off the+    board. Usually a copy-paste that was never re-prioritised."""+    seen = {}+    for r in (board.get("rules") or {}).get("rules") or []:+        if r.get("enabled") is False:+            continue+        key = (r.get("kind"), r.get("priority"))+        seen.setdefault(key, []).append(r.get("name"))+    out = []+    for (kind, prio), names in sorted(seen.items(), key=lambda kv: (str(kv[0][0]), str(kv[0][1]))):+        if len(names) > 1:+            out.append({"check": "duplicate_rule_priority", "severity": "info",+                        "rule": ", ".join(sorted(names)),+                        "message": f"{len(names)} enabled {_rule_kind_name(kind)} rules share priority "+                                   f"{prio} ({', '.join(sorted(names))}) — which one wins is not readable "+                                   f"from the board."})+    return out+++def _chk_components_without_footprint(board, sheet):+    """warning — a placed component whose footprint PATTERN is empty.++    A placed part always has geometry, but an empty pattern name means the footprint has no identity:+    it cannot be matched back to a library, compared across a project, or checked for updates."""+    out = []+    for c in (board.get("components") or {}).get("components") or []:+        if not (c.get("pattern") or "").strip():+            out.append({"check": "components_without_footprint", "severity": "warning",+                        "designator": c.get("designator"),+                        "message": f"{c.get('designator')} has no footprint pattern name — it cannot be "+                                   f"matched back to a library."})+    return out++ # (id, fn). The ID is what appears in a finding's `check` field, so `checks:["..."]` filters on the # name the caller actually sees. Deriving it from the Python function name instead was a trap: the # function is `_chk_components_outside_board`, the finding says `components_outside_board_outline`,@@ -1730,6 +1820,11 @@ BOARD_CHECKS = [     ("vendor_part_numbers", _chk_vendor_part_numbers),     ("missing_datasheets", _chk_missing_datasheets),     ("schematic_placeholder_values", _chk_schematic_placeholders),+    # design-rule hygiene, from the rules the board read already carries+    ("disabled_design_rules", _chk_disabled_design_rules),+    ("missing_critical_rules", _chk_missing_critical_rules),+    ("duplicate_rule_priority", _chk_duplicate_rule_priority),+    ("components_without_footprint", _chk_components_without_footprint), ]  # Named so a clean result is not mistaken for a complete one.@@ -1774,7 +1869,7 @@ def h_review_board(args):         e = _open(args["board"])         if e:             return {"success": False, "stage": "board", **e}-    r = agent.call("read_board", {"sections": "components,nets,layers,copper,occupancy,outline",+    r = agent.call("read_board", {"sections": "components,nets,layers,copper,rules,occupancy,outline",                                   "limit": args.get("limit", 2000)}, timeout=timeout)     bd = r.get("data") or {}     if bd.get("ok"):