cardbuddy 0.11.0 → 0.12.1

package/dist/vendored/skills/card-skill-trainer/baselines/v3-r038n.json

@@ -0,0 +1,43 @@
+{
+  "baselineId": "v3-r038n",
+  "date": "2026-08-26",
+  "strategy": "v3",
+  "dataset": "training/datasets/v3/train-set.jsonl",
+  "datasetSha256": "33e0dddc26db72f4471c8d8f08b6983afe04ecaf01467ff97c8738ddb687e316",
+  "sampleCount": 48,
+  "metrics": {
+    "passRate": 1,
+    "passed": 48,
+    "validateErrors": 0,
+    "lintErrors": 0,
+    "avgPixelDiff": 0.11110358659080005,
+    "avgFidelity": 0.7756660799198527,
+    "avgFidelityComponents": 0.8986764532981638,
+    "avgColorFidelity": 0.9667358398437497,
+    "avgStructureFidelity": 0.6551878934800744,
+    "avgDimensionFidelity": 0.9717187946952559,
+    "renderFailures": 0,
+    "avgAnnotationCompleteness": 1,
+    "avgTextRetention": 1,
+    "upstreamFailures": 0
+  },
+  "gates": {
+    "passRateMinimum": 0.95,
+    "validateErrorsMaximum": 0,
+    "lintErrorsMaximum": 0,
+    "renderFailuresMaximum": 0,
+    "upstreamFailuresMaximum": 0,
+    "srcPollutionRequired": false
+  },
+  "artifacts": {
+    "runDir": "training/runs/r038n",
+    "summary": "training/runs/r038n/reports/summary.md"
+  },
+  "promotedLessons": [
+    "LESSON-20260826-039",
+    "LESSON-20260826-040",
+    "LESSON-20260826-041",
+    "LESSON-20260826-042",
+    "LESSON-20260826-043"
+  ]
+}

package/dist/vendored/skills/card-skill-trainer/baselines/v3-r039n.json

@@ -0,0 +1,47 @@
+{
+  "baselineId": "v3-r039n",
+  "date": "2026-08-26",
+  "strategy": "v3",
+  "dataset": "training/datasets/v3/train-set.jsonl",
+  "datasetSha256": "33e0dddc26db72f4471c8d8f08b6983afe04ecaf01467ff97c8738ddb687e316",
+  "sampleCount": 48,
+  "metrics": {
+    "passRate": 1,
+    "passed": 48,
+    "validateErrors": 0,
+    "lintErrors": 0,
+    "avgPixelDiff": 0.1178415490216939,
+    "avgFidelity": 0.7813162775989081,
+    "avgFidelityComponents": 0.9605243097951431,
+    "avgColorFidelity": 0.9669010416666665,
+    "avgStructureFidelity": 0.6553877132475057,
+    "avgDimensionFidelity": 0.9515361106243735,
+    "renderFailures": 0,
+    "avgAnnotationCompleteness": 1,
+    "avgTextRetention": 1,
+    "upstreamFailures": 0
+  },
+  "comparison": {
+    "previousBaseline": "v3-r038n",
+    "avgFidelityDelta": 0.0056501976790554,
+    "avgFidelityComponentsDelta": 0.0618478564969793
+  },
+  "gates": {
+    "passRateMinimum": 0.95,
+    "validateErrorsMaximum": 0,
+    "lintErrorsMaximum": 0,
+    "renderFailuresMaximum": 0,
+    "upstreamFailuresMaximum": 0,
+    "srcPollutionRequired": false
+  },
+  "artifacts": {
+    "runDir": "training/runs/r039n",
+    "summary": "training/runs/r039n/reports/summary.md"
+  },
+  "promotedLessons": [
+    "LESSON-20260826-044",
+    "LESSON-20260826-045",
+    "LESSON-20260826-046",
+    "LESSON-20260826-047"
+  ]
+}

package/dist/vendored/skills/card-skill-trainer/baselines/v3-r050n.json

@@ -0,0 +1,48 @@
+{
+  "baselineId": "v3-r050n",
+  "date": "2026-08-26",
+  "strategy": "v3",
+  "dataset": "training/datasets/v3/train-set.jsonl",
+  "datasetSha256": "33e0dddc26db72f4471c8d8f08b6983afe04ecaf01467ff97c8738ddb687e316",
+  "sampleCount": 48,
+  "metrics": {
+    "passRate": 1,
+    "passed": 48,
+    "validateErrors": 0,
+    "lintErrors": 0,
+    "avgPixelDiff": 0.11277390158817568,
+    "avgFidelity": 0.7952778246566923,
+    "avgFidelityComponents": 0.9559238061321395,
+    "avgColorFidelity": 0.9831754557291665,
+    "avgStructureFidelity": 0.7040960215045314,
+    "avgDimensionFidelity": 0.9620245001437465,
+    "renderFailures": 0,
+    "avgAnnotationCompleteness": 1,
+    "avgTextRetention": 1,
+    "upstreamFailures": 0,
+    "semanticReviewPending": 0
+  },
+  "comparison": {
+    "previousBaseline": "v3-r039n",
+    "avgFidelityDelta": 0.0139615470577862,
+    "avgStructureFidelityDelta": 0.0487083082574945,
+    "avgColorFidelityDelta": 0.0162744140625
+  },
+  "gates": {
+    "passRateMinimum": 0.95,
+    "validateErrorsMaximum": 0,
+    "lintErrorsMaximum": 0,
+    "renderFailuresMaximum": 0,
+    "upstreamFailuresMaximum": 0,
+    "srcPollutionRequired": false
+  },
+  "artifacts": {
+    "runDir": "training/runs/r050n",
+    "summary": "training/runs/r050n/reports/summary.json"
+  },
+  "promotedLessons": [
+    "LESSON-20260826-048",
+    "LESSON-20260826-049",
+    "LESSON-20260826-050"
+  ]
+}

package/dist/vendored/skills/card-skill-trainer/scripts/build_dataset.py

@@ -0,0 +1,472 @@
+#!/usr/bin/env python3
+import argparse
+import hashlib
+import json
+import re
+import shutil
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+from PIL import Image
+
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+PARSER = REPO_ROOT / "skills" / "sketch-spec-to-card" / "scripts" / "parse_meaxure.py"
+SPLITS = ("train", "dev", "eval", "holdout")
+POPUP_TYPES = {"subcard", "overlay_dialog", "alert_dialog"}
+
+
+def toolchain_rev() -> str:
+    """解析器所在的仓库版本：数据集产物不入库，靠它 + sourceRoot 才能判断可否复现。"""
+    try:
+        done = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"],
+            cwd=REPO_ROOT, capture_output=True, text=True, timeout=10,
+        )
+        rev = done.stdout.strip()
+        dirty = subprocess.run(
+            ["git", "status", "--porcelain", "--", "skills"],
+            cwd=REPO_ROOT, capture_output=True, text=True, timeout=10,
+        ).stdout.strip()
+        return f"{rev}-dirty" if dirty else rev
+    except Exception:
+        return "unknown"
+
+
+def safe_name(value: str) -> str:
+    value = re.sub(r"[^\w\u4e00-\u9fff.-]+", "_", value).strip("._")
+    return value or "untitled"
+
+
+def stable_hash(*parts: str) -> str:
+    return hashlib.sha256("\u241f".join(parts).encode("utf-8")).hexdigest()
+
+
+def split_for(case_id: str) -> str:
+    value = int(stable_hash(case_id, "card-skill-trainer-v1")[:8], 16) % 100
+    if value < 65:
+        return "train"
+    if value < 85:
+        return "dev"
+    if value < 95:
+        return "eval"
+    return "holdout"
+
+
+def discover_sources(root: Path):
+    for path in sorted(root.iterdir(), key=lambda p: p.name):
+        if path.is_dir() and (path / "index.html").exists():
+            yield path
+
+
+def parse_source(source: Path, raw_root: Path, force: bool, sample_size: int = 0) -> bool:
+    target = raw_root / safe_name(source.name)
+    if (target / "manifest.json").exists() and not force:
+        print(f"[skip] {source.name}")
+        return True
+    target.mkdir(parents=True, exist_ok=True)
+    command = [
+        sys.executable,
+        str(PARSER),
+        "--src",
+        str(source),
+        "--out",
+        str(target),
+        "--build",
+        # 无人值守训练 = 显式批量授权（rules.md §13.3 例外）：直接过 parse_meaxure 的多画板选择门禁
+        "--scope-all",
+    ]
+    if sample_size:
+        command.extend(["--sample", str(sample_size)])
+    print(f"[parse] {source.name}")
+    result = subprocess.run(command)
+    return result.returncode == 0 and (target / "manifest.json").exists()
+
+
+def first_image(spec_dir: Path, card: dict) -> Optional[Path]:
+    for key in ("image", "cardImage"):
+        rel = card.get(key)
+        if rel:
+            candidate = spec_dir / rel
+            if candidate.exists():
+                return candidate
+    artboard = spec_dir / "artboard.png"
+    return artboard if artboard.exists() else None
+
+
+def expected_from_spec(card: dict):
+    texts = []
+    components = []
+    for element in card.get("elements", []):
+        kind = element.get("type") or element.get("class") or ""
+        if kind.lower() == "text":
+            value = (element.get("value") or element.get("content") or "").strip()
+            if value:
+                texts.append(value)
+        name = (element.get("name") or "").lower()
+        if any(word in name for word in ("btn", "button", "input", "tab", "list")):
+            components.append({"signal": name})
+    return {"requiredTexts": list(dict.fromkeys(texts))[:80], "componentSignals": components[:80]}
+
+
+def is_popup_case(spec: dict, canvas: dict) -> bool:
+    if canvas.get("trainingEligible") is False:
+        return True
+    if spec.get("focusSkipReason") in {
+        "overlay_dialog_geometry", "bottom_sheet_geometry", "conversation_flow_geometry",
+    }:
+        return True
+    artboard_type = str(spec.get("artboardType") or canvas.get("artboardType") or "").lower()
+    if artboard_type in POPUP_TYPES:
+        return True
+    name = str(canvas.get("name") or "")
+    return any(keyword in name for keyword in ("弹窗", "弹框", "键盘弹窗", "二次确认"))
+
+
+def difference_hash(image_path: Path, hash_size: int = 16) -> int:
+    """生成尺寸无关的横向梯度指纹（dHash）。"""
+    with Image.open(image_path) as image:
+        gray = image.convert("L").resize(
+            (hash_size + 1, hash_size), Image.Resampling.LANCZOS
+        )
+    pixels = list(gray.getdata())
+    value = 0
+    for row in range(hash_size):
+        for column in range(hash_size):
+            left = pixels[row * (hash_size + 1) + column]
+            right = pixels[row * (hash_size + 1) + column + 1]
+            value = (value << 1) | (1 if left > right else 0)
+    return value
+
+
+def hamming_distance(left: int, right: int) -> int:
+    return bin(left ^ right).count("1")
+
+
+def artboard_richness(spec: dict) -> tuple:
+    return (
+        len(spec.get("cards") or []),
+        len(spec.get("elements") or []),
+        len(spec.get("slices") or []),
+    )
+
+
+def fingerprint_artboard(record: dict) -> dict:
+    preview = record["specDir"] / "artboard.png"
+    digest = hashlib.sha256(preview.read_bytes()).hexdigest() if preview.exists() else ""
+    perceptual = difference_hash(preview) if preview.exists() else 0
+    return {"sha256": digest, "dhash": perceptual, "layout": layout_signature(record["spec"])}
+
+
+def layout_signature(spec: dict) -> set:
+    """提取尺寸无关的元素布局签名，避免把不同状态误判为同一画板。"""
+    size = spec.get("size") or {}
+    canvas_width = float(size.get("width") or 0)
+    canvas_height = float(size.get("height") or 0)
+    if canvas_width <= 0 or canvas_height <= 0:
+        return set()
+
+    signature = set()
+    type_counts = {}
+    text_lengths = []
+    for element in spec.get("elements") or []:
+        rect = element.get("rect") or {}
+        width = float(rect.get("width") or 0)
+        height = float(rect.get("height") or 0)
+        x = float(rect.get("x") or 0)
+        y = float(rect.get("y") or 0)
+        if width <= 0 or height <= 0:
+            continue
+
+        kind = str(element.get("type") or "unknown").lower()
+        type_counts[kind] = type_counts.get(kind, 0) + 1
+        center_x = min(15, max(0, int((x + width / 2) / canvas_width * 16)))
+        center_y = min(15, max(0, int((y + height / 2) / canvas_height * 16)))
+        width_bucket = min(7, int(max(0.0, width / canvas_width) * 8))
+        height_bucket = min(7, int(max(0.0, height / canvas_height) * 8))
+        signature.add((kind, center_x, center_y, width_bucket, height_bucket))
+
+        text = element.get("text")
+        if kind == "text" and text:
+            value = str(text).strip()
+            if value:
+                text_lengths.append(len(value))
+
+    for kind, count in type_counts.items():
+        signature.add(("count", kind, min(20, count)))
+    for index, length in enumerate(sorted(text_lengths)[:40]):
+        signature.add(("text-length", index, min(80, length // 4)))
+    return signature
+
+
+def signature_similarity(left: set, right: set) -> float:
+    if not left or not right:
+        return 0.0
+    return len(left & right) / len(left | right)
+
+
+def deduplicate_artboards(records: list, threshold: int = 4):
+    """按整板视觉指纹抽样，富信息画板优先做簇代表。"""
+    for record in records:
+        record["fingerprint"] = fingerprint_artboard(record)
+        record["richness"] = artboard_richness(record["spec"])
+
+    ordered = sorted(
+        records,
+        key=lambda item: (
+            tuple(-value for value in item["richness"]),
+            item["source"],
+            item["name"],
+        ),
+    )
+    clusters = []
+    for record in ordered:
+        target = None
+        for cluster in clusters:
+            representative = cluster[0]
+            same_ratio = abs(
+                record["aspectRatio"] - representative["aspectRatio"]
+            ) <= max(0.02, 0.02 * representative["aspectRatio"])
+            exact = bool(
+                record["fingerprint"]["sha256"] and
+                record["fingerprint"]["sha256"] == representative["fingerprint"]["sha256"]
+            )
+            near = hamming_distance(
+                record["fingerprint"]["dhash"],
+                representative["fingerprint"]["dhash"],
+            ) <= threshold
+            layout_similarity = signature_similarity(
+                record["fingerprint"]["layout"],
+                representative["fingerprint"]["layout"],
+            )
+            structurally_same = (
+                record["richness"] == representative["richness"] and
+                layout_similarity >= 0.94
+            )
+            if same_ratio and (exact or (near and structurally_same)):
+                target = cluster
+                break
+        if target is None:
+            clusters.append([record])
+        else:
+            target.append(record)
+
+    representatives = {cluster[0]["key"] for cluster in clusters}
+    duplicate_clusters = [
+        {
+            "representative": cluster[0]["key"],
+            "duplicates": [item["key"] for item in cluster[1:]],
+            "hammingDistances": [
+                hamming_distance(
+                    item["fingerprint"]["dhash"],
+                    cluster[0]["fingerprint"]["dhash"],
+                )
+                for item in cluster[1:]
+            ],
+            "layoutSimilarities": [
+                round(signature_similarity(
+                    item["fingerprint"]["layout"],
+                    cluster[0]["fingerprint"]["layout"],
+                ), 4)
+                for item in cluster[1:]
+            ],
+        }
+        for cluster in clusters
+        if len(cluster) > 1
+    ]
+    return representatives, duplicate_clusters
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Build an unattended dsl-card training set")
+    parser.add_argument("--src", required=True)
+    parser.add_argument("--out", required=True)
+    parser.add_argument("--max-cases", type=int, default=160)
+    parser.add_argument("--max-sources", type=int, default=0)
+    parser.add_argument("--artboards-per-source", type=int, default=0)
+    parser.add_argument("--force", action="store_true")
+    parser.add_argument("--duplicate-threshold", type=int, default=4)
+    parser.add_argument("--no-artboard-dedup", action="store_true")
+    args = parser.parse_args()
+
+    source_root = Path(args.src).expanduser().resolve()
+    out_root = Path(args.out).resolve()
+    raw_root = out_root / "raw"
+    raw_root.mkdir(parents=True, exist_ok=True)
+
+    sources = list(discover_sources(source_root))
+    if args.max_sources:
+        sources = sources[: args.max_sources]
+    if not sources:
+        raise SystemExit(f"No Sketch exports found under {source_root}")
+
+    cases = []
+    failures = []
+    skippedPopups = []
+    skippedNoCards = []
+    focusAudit = []
+    eligibleRecords = []
+    generatedArtboards = 0
+    for source in sources:
+        ok = parse_source(source, raw_root, args.force, args.artboards_per_source)
+        if not ok:
+            failures.append({"source": source.name, "error": "parse-failed"})
+            continue
+        parsed_dir = raw_root / safe_name(source.name)
+        manifest = json.loads((parsed_dir / "manifest.json").read_text(encoding="utf-8"))
+        for canvas in manifest.get("canvases", []):
+            name = canvas.get("name", "")
+            status = canvas.get("status")
+            spec_dir = parsed_dir / name
+            spec_path = spec_dir / "spec.json"
+            if status == "skipped" or not spec_path.exists():
+                continue
+            generatedArtboards += 1
+            if canvas.get("trainingEligible") is False:
+                skippedPopups.append({"source": source.name, "canvas": name, "reason": "manifest-training-ineligible"})
+                continue
+            try:
+                spec = json.loads(spec_path.read_text(encoding="utf-8"))
+            except Exception as exc:
+                failures.append({"source": source.name, "canvas": name, "error": f"bad-spec:{exc}"})
+                continue
+            if is_popup_case(spec, canvas):
+                skippedPopups.append({"source": source.name, "canvas": name, "reason": "popup-card"})
+                continue
+            slug = canvas.get("slug") or name
+            usableCards = []
+            for card_index, card in enumerate(spec.get("cards", [])):
+                if card.get("trainingEligible") is False:
+                    continue
+                design = first_image(spec_dir, card)
+                if not design:
+                    continue
+                usableCards.append((card_index, card, design))
+            if not usableCards:
+                skippedNoCards.append({
+                    "source": source.name,
+                    "canvas": name,
+                    "reason": spec.get("focusSkipReason") or "no-usable-card-image",
+                })
+                continue
+            key = f"{source.name}\u241f{name}"
+            eligibleRecords.append({
+                "key": key,
+                "source": source.name,
+                "sourceDir": source,
+                "name": name,
+                "slug": slug,
+                "spec": spec,
+                "specDir": spec_dir,
+                "specPath": spec_path,
+                "canvas": canvas,
+                "cards": usableCards,
+                "aspectRatio": spec["size"]["width"] / max(spec["size"]["height"], 1),
+            })
+            focusAudit.append({
+                "source": source.name,
+                "canvas": name,
+                "focusSkipReason": spec.get("focusSkipReason") or "",
+                "acceptedCards": len(usableCards),
+                "rejectedCards": spec.get("rejectedCards") or [],
+            })
+
+    if args.no_artboard_dedup:
+        representatives = {record["key"] for record in eligibleRecords}
+        duplicateClusters = []
+    else:
+        representatives, duplicateClusters = deduplicate_artboards(
+            eligibleRecords, args.duplicate_threshold
+        )
+
+    for record in eligibleRecords:
+        if record["key"] not in representatives:
+            continue
+        source = record["sourceDir"]
+        name = record["name"]
+        spec = record["spec"]
+        spec_path = record["specPath"]
+        spec_dir = record["specDir"]
+        canvas = record["canvas"]
+        for card_index, card, design in record["cards"]:
+            case_id = stable_hash(source.name, name, str(card_index))[:16]
+            cases.append(
+                {
+                    "caseId": case_id,
+                    "source": source.name,
+                    "artboardName": name,
+                    "cardIndex": card_index,
+                    "cardImage": design.name,
+                    "taskType": "spec_to_card",
+                    "difficulty": "medium",
+                    "tags": [spec.get("artboardType", "card"), *(canvas.get("tags") or [])],
+                    "input": {
+                        "specJson": str(spec_path),
+                        "designImage": str(design),
+                        "slicesDir": str(spec_dir / "slices"),
+                    },
+                    "expected": expected_from_spec(card),
+                    "split": split_for(case_id),
+                }
+            )
+
+    # 同一源目录被重复发现（staging 里符号链接 + 真实目录同名）会产出逐字节相同的 case：
+    # 训练轮重复渲染同一张卡、passRate 分母失真（v4 实测 221 行 / 218 唯一）。按 caseId 去重。
+    seen_case_ids = set()
+    duplicate_case_ids = []
+    unique_cases = []
+    for case in cases:
+        if case["caseId"] in seen_case_ids:
+            duplicate_case_ids.append(case["caseId"])
+            continue
+        seen_case_ids.add(case["caseId"])
+        unique_cases.append(case)
+    cases = unique_cases
+
+    selected = cases[: args.max_cases]
+    dataset_path = out_root / "train-set.jsonl"
+    with dataset_path.open("w", encoding="utf-8") as handle:
+        for case in selected:
+            handle.write(json.dumps(case, ensure_ascii=False) + "\n")
+
+    counts = {split: sum(1 for case in selected if case["split"] == split) for split in SPLITS}
+    summary = {
+        "generatedAt": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "provenance": {
+            "sourceRoot": str(source_root),
+            "sourceNames": [source.name for source in sources],
+            "toolchainRev": toolchain_rev(),
+            "parser": str(PARSER.relative_to(REPO_ROOT)),
+            "duplicateThreshold": args.duplicate_threshold,
+            "artboardsPerSource": args.artboards_per_source,
+            "maxCases": args.max_cases,
+            "noArtboardDedup": bool(args.no_artboard_dedup),
+        },
+        "sources": len(sources),
+        "generatedArtboards": generatedArtboards,
+        "eligibleArtboards": len(eligibleRecords),
+        "selectedArtboards": len(representatives),
+        "duplicateArtboards": len(eligibleRecords) - len(representatives),
+        "candidates": len(cases),
+        "selected": len(selected),
+        "duplicateCases": sorted(set(duplicate_case_ids)),
+        "splits": counts,
+        "duplicateClusters": duplicateClusters,
+        "skippedPopups": skippedPopups,
+        "skippedNoCards": skippedNoCards,
+        "failures": failures,
+    }
+    (out_root / "dataset-summary.json").write_text(
+        json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+    (out_root / "focus-audit.json").write_text(
+        json.dumps(focusAudit, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()