cardbuddy 0.11.0 → 0.12.1

package/dist/vendored/skills/dsl-card-generator/scripts/inventory_schemas.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""
+Inventory exported FinMall/YNet card schemas.
+
+Use this after syncing cards into src/cards to discover component classes,
+properties, style groups, directives, events, action types, and representative
+examples. The output is JSON so it can be diffed or used to update the skill
+references without hand-counting large schema files.
+
+Usage:
+    python3 skills/dsl-card-generator/scripts/inventory_schemas.py src/cards
+    python3 skills/dsl-card-generator/scripts/inventory_schemas.py src/cards --examples
+"""
+
+import argparse
+import json
+import os
+from collections import Counter, defaultdict
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Inventory exported DSL card schemas")
+    parser.add_argument("root", help="Schema file, card directory, or cards root directory")
+    parser.add_argument("--examples", action="store_true", help="Include one compact example per component class and action type")
+    args = parser.parse_args()
+
+    files = list_schema_files(args.root)
+    inventory = build_inventory(files, include_examples=args.examples)
+    print(json.dumps(inventory, ensure_ascii=False, indent=2))
+
+
+def list_schema_files(root):
+    if os.path.isfile(root):
+        return [root]
+    files = []
+    for current, _, names in os.walk(root):
+        for name in names:
+            if name == "schema.json":
+                files.append(os.path.join(current, name))
+    return sorted(files)
+
+
+def build_inventory(files, include_examples=False):
+    stats = {
+        "schemaCount": len(files),
+        "topLevelKeys": Counter(),
+        "variableCounts": Counter(),
+        "variableTypes": Counter(),
+        "classNames": Counter(),
+        "propsByClass": defaultdict(Counter),
+        "styleByClass": defaultdict(Counter),
+        "styleSubByGroup": defaultdict(Counter),
+        "directiveKeys": Counter(),
+        "eventKeys": Counter(),
+        "actionTypes": Counter(),
+        "slotKeys": Counter(),
+        "slotScope": Counter(),
+        "itemValueFrom": Counter(),
+    }
+    examples = {"classes": {}, "actionTypes": {}}
+
+    for file_path in files:
+        with open(file_path, "r", encoding="utf-8") as handle:
+            schema = json.load(handle)
+        card_id = os.path.basename(os.path.dirname(file_path))
+        stats["topLevelKeys"].update(schema.keys())
+        params = schema.get("dictionary", {}).get("inputParams", [])
+        stats["variableCounts"].update([str(len(params))])
+        stats["variableTypes"].update(param.get("type", "") for param in params)
+
+        view = schema.get("view", {})
+        walk_component(view, card_id, "$.view", stats, examples, include_examples)
+        for index, child in enumerate(view.get("components", []) or []):
+            walk_component(child, card_id, f"$.view.components[{index}]", stats, examples, include_examples)
+
+    result = to_plain(stats)
+    if include_examples:
+        result["examples"] = examples
+    return result
+
+
+def walk_component(component, card_id, path, stats, examples, include_examples):
+    if not isinstance(component, dict):
+        return
+    class_name = component.get("className", "")
+    if class_name:
+        stats["classNames"].update([class_name])
+        if include_examples and class_name not in examples["classes"]:
+            examples["classes"][class_name] = compact_component_example(component, card_id, path)
+
+    for directive in component.get("directives", []) or []:
+        update_item(stats, directive)
+        stats["directiveKeys"].update([directive.get("itemKey", "")])
+        for child in directive.get("itemChildren", {}).get("properties", []) or []:
+            update_item(stats, child)
+
+    for prop in component.get("properties", []) or []:
+        key = prop.get("itemKey", "")
+        update_item(stats, prop)
+        if key:
+            stats["propsByClass"][class_name].update([key])
+
+    for group in component.get("style", {}).get("properties", []) or []:
+        group_key = group.get("itemKey", "")
+        update_item(stats, group)
+        if group_key:
+            stats["styleByClass"][class_name].update([group_key])
+        for child in group.get("itemChildren", {}).get("properties", []) or []:
+            child_key = child.get("itemKey", "")
+            update_item(stats, child)
+            if group_key and child_key:
+                stats["styleSubByGroup"][group_key].update([child_key])
+
+    for index, eventaction in enumerate(component.get("eventactions", []) or []):
+        event_key = eventaction.get("event", {}).get("eventKey", "")
+        action_type = eventaction.get("action", {}).get("actionType", "")
+        stats["eventKeys"].update([event_key])
+        stats["actionTypes"].update([action_type])
+        if include_examples and action_type and action_type not in examples["actionTypes"]:
+            examples["actionTypes"][action_type] = {
+                "card": card_id,
+                "path": f"{path}.eventactions[{index}]",
+                "componentId": component.get("componentId"),
+                "className": class_name,
+                "eventaction": eventaction,
+            }
+
+    for slot_index, slot in enumerate(component.get("slots", []) or []):
+        stats["slotKeys"].update([slot.get("slotKey", "")])
+        stats["slotScope"].update([str(bool(slot.get("slotScope")))])
+        for child_index, child in enumerate(slot.get("components", []) or []):
+            walk_component(child, card_id, f"{path}.slots[{slot_index}].components[{child_index}]", stats, examples, include_examples)
+
+
+def update_item(stats, item):
+    if not isinstance(item, dict):
+        return
+    if "itemValueFrom" in item:
+        stats["itemValueFrom"].update([str(item.get("itemValueFrom"))])
+
+
+def compact_component_example(component, card_id, path):
+    clone = json.loads(json.dumps(component, ensure_ascii=False))
+    for slot in clone.get("slots", []) or []:
+        slot["components"] = f"[{len(slot.get('components', []) or [])} components]"
+    return {"card": card_id, "path": path, "component": clone}
+
+
+def to_plain(value):
+    if isinstance(value, Counter):
+        return dict(sorted(value.items(), key=lambda item: (-item[1], item[0])))
+    if isinstance(value, defaultdict):
+        return {key: to_plain(inner) for key, inner in sorted(value.items())}
+    if isinstance(value, dict):
+        return {key: to_plain(inner) for key, inner in value.items()}
+    return value
+
+
+if __name__ == "__main__":
+    main()