@mmerterden/multi-agent-pipeline 8.6.0

package/pipeline/skills/figma-ios/figma-to-component/scripts/build-author-registry.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+"""build-author-registry.py — walk registry components, git-blame each
+swift file, build a reviewable author registry before ANY issue touch.
+
+For every registry entry that has a swift file under Sources/, runs
+`git blame --line-porcelain` and counts the number of lines attributed
+to each author. Outputs two artifacts:
+
+  temp/authors-registry.json
+      {
+        "meta": { "generated_at": "...", "component_count": N, "distinct_authors": N },
+        "authors": {
+          "<author-name>": {
+            "lines_total": int,
+            "components": [<componentName>, ...],
+            "looks_like_github_login": bool  # heuristic
+          },
+          ...
+        },
+        "per_component": {
+          "<node_id>": {
+            "componentName": str,
+            "swift_file": str,
+            "primary_author": str,
+            "primary_lines": int,
+            "all_authors": [
+              { "name": str, "lines": int },
+              ...
+            ]
+          },
+          ...
+        }
+      }
+
+  temp/authors-needing-mapping.json
+      Just the authors whose display name doesn't look like a GitHub
+      login (has spaces, too long, etc). Provided for the human
+      reviewer to add a mapping to real GitHub usernames later.
+
+No writes to component registry JSONs, no writes to GitHub. This is a
+pure observation pass that produces two files in temp/ for review.
+
+Usage:
+    python3 build-author-registry.py \\
+        [--registry-dir /path] \\
+        [--uicomponents-repo /path] \\
+        [--limit N]
+
+Exit codes:
+    0 — success (even with some per-component errors)
+    1 — setup error (bad paths)
+"""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+def find_repo_root() -> Path:
+    p = Path.cwd()
+    while p != p.parent:
+        if (p / ".git").exists():
+            return p
+        p = p.parent
+    return Path.cwd()
+
+
+def default_registry_dir() -> Path:
+    return (
+        find_repo_root()
+        / "{repos.packagesContainer}"
+        / "Packages"
+        / "{project.slug}-common"
+        / "Shared"
+        / "Figma"
+        / "Components"
+    )
+
+
+def default_uicomponents_repo() -> Path:
+    return (
+        find_repo_root()
+        / "{repos.packagesContainer}"
+        / "Packages"
+        / "{project.slug}-components"
+    )
+
+
+def default_temp_dir() -> Path:
+    return find_repo_root() / "temp"
+
+
+# --------------------------------------------------------------------
+# Heuristic — does a git author name look like a GitHub login?
+# --------------------------------------------------------------------
+
+_GH_LOGIN_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9\-_]{0,38}$")
+
+
+def looks_like_github_login(name: str) -> bool:
+    if not isinstance(name, str):
+        return False
+    return bool(_GH_LOGIN_RE.match(name))
+
+
+# --------------------------------------------------------------------
+# git blame parsing
+# --------------------------------------------------------------------
+
+def git_blame_line_counts(source_file: Path, repo_root: Path) -> Counter:
+    """Return {author_name: line_count} for one file via git blame.
+
+    Uses --line-porcelain for stable parsing. Returns an empty Counter
+    if the file is missing, git fails, or the blame output is empty.
+    """
+    if not source_file.exists():
+        return Counter()
+    try:
+        rel = source_file.relative_to(repo_root)
+    except ValueError:
+        rel = source_file
+    try:
+        r = subprocess.run(
+            ["git", "-C", str(repo_root), "blame", "--line-porcelain", "--", str(rel)],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=30,
+        )
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return Counter()
+    if r.returncode != 0:
+        return Counter()
+
+    counts: Counter = Counter()
+    for line in r.stdout.splitlines():
+        if line.startswith("author "):
+            author = line[len("author "):].strip()
+            if author:
+                counts[author] += 1
+    return counts
+
+
+# --------------------------------------------------------------------
+# Component discovery
+# --------------------------------------------------------------------
+
+def build_swift_file_index(sources_dir: Path) -> Dict[str, Path]:
+    """Walk Sources/, return { base_name: first_matching_path }."""
+    index: Dict[str, Path] = {}
+    if not sources_dir.exists():
+        return index
+    for swift in sources_dir.rglob("*.swift"):
+        base = swift.stem
+        if base not in index:
+            index[base] = swift
+    return index
+
+
+def component_name_ios(raw) -> Optional[str]:
+    if isinstance(raw, dict):
+        return raw.get("ios")
+    if isinstance(raw, str) and raw:
+        return raw
+    return None
+
+
+# --------------------------------------------------------------------
+# Main pass
+# --------------------------------------------------------------------
+
+def build(
+    registry_dir: Path,
+    uicomponents_repo: Path,
+    limit: Optional[int] = None,
+) -> dict:
+    sources_dir = uicomponents_repo / "Sources"
+    swift_index = build_swift_file_index(sources_dir)
+
+    registry_files = sorted(registry_dir.glob("*.json"))
+    if limit is not None:
+        registry_files = registry_files[:limit]
+
+    per_component: Dict[str, dict] = {}
+    authors_global: Dict[str, dict] = {}
+    skipped_no_swift: List[str] = []
+    errors: List[dict] = []
+
+    for idx, path in enumerate(registry_files, 1):
+        try:
+            entry = json.loads(path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError) as e:
+            errors.append({"file": path.name, "error": str(e)})
+            continue
+
+        node_id = entry.get("nodeId") or path.stem.replace("-", ":")
+        if entry.get("skip"):
+            continue
+
+        cn = component_name_ios(entry.get("componentName"))
+        if not cn:
+            continue
+
+        swift_path = swift_index.get(cn)
+        if not swift_path:
+            skipped_no_swift.append(node_id)
+            continue
+
+        line_counts = git_blame_line_counts(swift_path, uicomponents_repo)
+        if not line_counts:
+            continue
+
+        # Sort by line count desc
+        all_authors_sorted = sorted(line_counts.items(), key=lambda kv: -kv[1])
+        primary_name, primary_lines = all_authors_sorted[0]
+
+        per_component[node_id] = {
+            "componentName": cn,
+            "swift_file": str(swift_path.relative_to(uicomponents_repo)),
+            "primary_author": primary_name,
+            "primary_lines": primary_lines,
+            "all_authors": [
+                {"name": name, "lines": lines}
+                for name, lines in all_authors_sorted
+            ],
+        }
+
+        for name, lines in line_counts.items():
+            record = authors_global.setdefault(name, {
+                "lines_total": 0,
+                "components": [],
+                "looks_like_github_login": looks_like_github_login(name),
+            })
+            record["lines_total"] += lines
+            if cn not in record["components"]:
+                record["components"].append(cn)
+
+        if idx % 25 == 0:
+            print(f"  processed {idx}/{len(registry_files)} ...", file=sys.stderr)
+
+    return {
+        "meta": {
+            "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "component_count": len(per_component),
+            "distinct_authors": len(authors_global),
+            "skipped_no_swift": len(skipped_no_swift),
+            "read_errors": len(errors),
+        },
+        "authors": authors_global,
+        "per_component": per_component,
+        "errors": errors,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Build a reviewable author registry via git blame",
+    )
+    parser.add_argument("--registry-dir")
+    parser.add_argument("--uicomponents-repo")
+    parser.add_argument("--temp-dir")
+    parser.add_argument("--limit", type=int, help="Process at most N components (smoke-test)")
+    args = parser.parse_args()
+
+    registry_dir = Path(args.registry_dir) if args.registry_dir else default_registry_dir()
+    uicomponents_repo = Path(args.uicomponents_repo) if args.uicomponents_repo else default_uicomponents_repo()
+    temp_dir = Path(args.temp_dir) if args.temp_dir else default_temp_dir()
+
+    if not registry_dir.exists():
+        print(f"ERROR: registry directory does not exist: {registry_dir}", file=sys.stderr)
+        return 1
+    if not uicomponents_repo.exists():
+        print(f"ERROR: uicomponents repo does not exist: {uicomponents_repo}", file=sys.stderr)
+        return 1
+
+    temp_dir.mkdir(parents=True, exist_ok=True)
+
+    result = build(registry_dir=registry_dir, uicomponents_repo=uicomponents_repo, limit=args.limit)
+
+    registry_file = temp_dir / "authors-registry.json"
+    registry_file.write_text(
+        json.dumps(result, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+    # Second artifact: just the authors needing mapping
+    needing = {
+        name: info
+        for name, info in result["authors"].items()
+        if not info.get("looks_like_github_login")
+    }
+    # Sort by lines_total desc for reviewer convenience
+    needing_sorted = dict(
+        sorted(needing.items(), key=lambda kv: -kv[1]["lines_total"])
+    )
+    mapping_file = temp_dir / "authors-needing-mapping.json"
+    mapping_file.write_text(
+        json.dumps({
+            "meta": result["meta"],
+            "authors": needing_sorted,
+            "suggestions": (
+                "Each author above has a display name that doesn't look "
+                "like a GitHub login (contains spaces or exceeds login "
+                "length). Add a mapping here before running issue sync:\n"
+                "  {display_name} → {github_login}"
+            ),
+        }, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+    summary = {
+        "status": "ok",
+        "registry_file": str(registry_file),
+        "mapping_file": str(mapping_file),
+        "meta": result["meta"],
+        "top_authors_by_lines": [
+            {"name": n, "lines": info["lines_total"], "components": len(info["components"]), "login_like": info["looks_like_github_login"]}
+            for n, info in sorted(result["authors"].items(), key=lambda kv: -kv[1]["lines_total"])[:15]
+        ],
+    }
+    print(json.dumps(summary, indent=2, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/pipeline/skills/figma-ios/figma-to-component/scripts/bulk-sync-issues.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+"""bulk-sync-issues.py — sync every backfilled component's GitHub issue.
+
+Walks the component registry, picks every entry where
+`status.ios.implemented.value == true`, and invokes
+`update-issue-from-registry.py` for each node-id.
+
+By default runs with `--no-comment` so a 268-node bulk migration
+doesn't spam 268 notifications to reviewers. Pass `--with-comment`
+to override.
+
+Usage:
+    # Dry-run — no gh calls, just print what would happen
+    python3 bulk-sync-issues.py --dry-run
+
+    # Real run on first 5 (smoke test)
+    python3 bulk-sync-issues.py --limit 5
+
+    # Full bulk migration (labels only, no comments)
+    python3 bulk-sync-issues.py
+
+    # Full bulk with sync comments
+    python3 bulk-sync-issues.py --with-comment
+
+Exit codes:
+    0 — success (maybe with some per-node failures logged)
+    1 — setup error (bad path, missing dependency)
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import List
+
+SCRIPTS_DIR = Path(__file__).parent
+UPDATER = SCRIPTS_DIR / "update-issue-from-registry.py"
+
+
+def find_repo_root() -> Path:
+    p = Path.cwd()
+    while p != p.parent:
+        if (p / ".git").exists():
+            return p
+        p = p.parent
+    return Path.cwd()
+
+
+def default_registry_dir() -> Path:
+    return (
+        find_repo_root()
+        / "{repos.packagesContainer}"
+        / "Packages"
+        / "{project.slug}-common"
+        / "Shared"
+        / "Figma"
+        / "Components"
+    )
+
+
+def _is_icon(data: dict) -> bool:
+    cn = data.get("componentName")
+    if isinstance(cn, dict):
+        ios_name = cn.get("ios") or ""
+        android_name = cn.get("android") or ""
+    elif isinstance(cn, str):
+        ios_name = cn
+        android_name = ""
+    else:
+        return False
+    if isinstance(ios_name, str) and ios_name.startswith("Image."):
+        return True
+    if isinstance(android_name, str) and android_name.startswith("Images."):
+        return True
+    return False
+
+
+def collect_backfilled_nodes(registry_dir: Path, platform: str) -> List[str]:
+    """Return every node-id whose status.<platform>.implemented.value is true.
+
+    Excludes:
+      - entries with skip:true
+      - icon entries (componentName starts with Image. or Images.)
+    """
+    result: List[str] = []
+    for path in sorted(registry_dir.glob("*.json")):
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            continue
+        if data.get("skip"):
+            continue
+        if _is_icon(data):
+            continue
+        status = data.get("status")
+        if not isinstance(status, dict):
+            continue
+        ps = status.get(platform, {})
+        if not isinstance(ps, dict):
+            continue
+        impl = ps.get("implemented", {})
+        if isinstance(impl, dict) and impl.get("value"):
+            node_id = data.get("nodeId")
+            if node_id:
+                result.append(node_id)
+    return result
+
+
+def run_updater_for_node(
+    node_id: str,
+    platform: str,
+    repo: str,
+    registry_dir: Path,
+    dry_run: bool,
+    team_label: str = "team:core",
+) -> dict:
+    """Invoke update-issue-from-registry.py for one node-id. Return parsed JSON."""
+    args = [
+        "python3", str(UPDATER),
+        "--node-id", node_id,
+        "--platform", platform,
+        "--registry-dir", str(registry_dir),
+        "--repo", repo,
+        "--team-label", team_label,
+    ]
+    if dry_run:
+        args.append("--dry-run")
+
+    r = subprocess.run(args, capture_output=True, text=True, check=False)
+    if r.returncode != 0:
+        return {
+            "node_id": node_id,
+            "status": "error",
+            "stderr": r.stderr.strip(),
+            "stdout": r.stdout.strip(),
+        }
+    try:
+        out = json.loads(r.stdout)
+        out["node_id"] = node_id
+        return out
+    except json.JSONDecodeError:
+        return {
+            "node_id": node_id,
+            "status": "error",
+            "stderr": "could not parse updater output",
+            "stdout": r.stdout,
+        }
+
+
+def classify(result: dict) -> str:
+    """Bucket the per-node result into a summary category."""
+    if result.get("status") == "error":
+        return "error"
+    action = result.get("action")
+    if action == "synced":
+        return "synced"
+    if action == "created":
+        return "created"
+    if action == "skip_marked_skip":
+        return "skip_marked_skip"
+    if action == "skip_icon":
+        return "skip_icon"
+    if result.get("dry_run"):
+        return "dry_run"
+    return "other"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Bulk-sync GitHub issues from the backfilled registry",
+    )
+    parser.add_argument("--registry-dir", help="Override registry directory path")
+    parser.add_argument("--platform", default="ios", choices=["ios", "android"])
+    parser.add_argument(
+        "--repo",
+        default="{github.componentsRepo}",
+    )
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--limit", type=int, help="Process at most N nodes")
+    parser.add_argument(
+        "--team-label",
+        default="team:core",
+        help="Team label to apply when creating missing issues (default: team:core)",
+    )
+    parser.add_argument(
+        "--log-file",
+        help="Write per-node JSON results to this file",
+    )
+    args = parser.parse_args()
+
+    registry_dir = Path(args.registry_dir) if args.registry_dir else default_registry_dir()
+    if not registry_dir.exists():
+        print(f"ERROR: registry directory does not exist: {registry_dir}", file=sys.stderr)
+        return 1
+    if not UPDATER.exists():
+        print(f"ERROR: updater script missing: {UPDATER}", file=sys.stderr)
+        return 1
+
+    nodes = collect_backfilled_nodes(registry_dir, args.platform)
+    if args.limit is not None:
+        nodes = nodes[: args.limit]
+
+    print(f"Processing {len(nodes)} backfilled nodes (dry_run={args.dry_run})...",
+          file=sys.stderr)
+
+    results: List[dict] = []
+    counts = {
+        "synced": 0,
+        "created": 0,
+        "skip_marked_skip": 0,
+        "skip_icon": 0,
+        "dry_run": 0,
+        "error": 0,
+        "other": 0,
+    }
+
+    for i, node_id in enumerate(nodes, 1):
+        result = run_updater_for_node(
+            node_id=node_id,
+            platform=args.platform,
+            repo=args.repo,
+            registry_dir=registry_dir,
+            dry_run=args.dry_run,
+            team_label=args.team_label,
+        )
+        bucket = classify(result)
+        counts[bucket] = counts.get(bucket, 0) + 1
+        results.append(result)
+
+        if i % 25 == 0 or i == len(nodes):
+            print(
+                f"  [{i}/{len(nodes)}] synced={counts['synced']} "
+                f"created={counts['created']} "
+                f"skip={counts['skip_marked_skip']} "
+                f"dry_run={counts['dry_run']} "
+                f"errors={counts['error']}",
+                file=sys.stderr,
+            )
+
+    summary = {
+        "status": "ok" if counts["error"] == 0 else "partial",
+        "dry_run": args.dry_run,
+        "total": len(nodes),
+        "counts": counts,
+        "errors": [r for r in results if r.get("status") == "error"][:10],
+    }
+    print(json.dumps(summary, indent=2, ensure_ascii=False))
+
+    if args.log_file:
+        Path(args.log_file).write_text(
+            json.dumps(results, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+        print(f"\nPer-node results written to {args.log_file}", file=sys.stderr)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())