@mmerterden/multi-agent-pipeline 11.2.0 → 11.3.0

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

@@ -1,332 +0,0 @@
-#!/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

@@ -1,261 +0,0 @@
-#!/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())