@mmerterden/multi-agent-pipeline 8.6.0

package/pipeline/skills/figma-ios/figma-to-component/scripts/remote-mcp-fetch.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""
+Remote MCP Fetch Script
+Calls Figma remote MCP tools at https://mcp.figma.com/mcp using OAuth token.
+
+Usage:
+    python3 remote-mcp-fetch.py \
+        --tool get_metadata \
+        --file-key "ps4xrJzhn7WNbfkZs895Bi" \
+        --node-id "5:17752" \
+        [--mcp-token TOKEN] \
+        [--output /path/to/output.json] \
+        [--extra-args '{"key": "value"}']
+
+    Tools: get_metadata, get_design_context, get_variable_defs,
+           get_code_connect_map, get_screenshot
+
+    --mcp-token: OAuth token. Falls back to macOS Keychain "FIGMA_MCP_TOKEN".
+    --output: Write text content to file. Omit to print to stdout.
+    --extra-args: Additional JSON arguments merged into tool call.
+
+Exit 0 = success, Exit 1 = failure (prints JSON error to stderr)
+"""
+
+import argparse
+import http.client
+import json
+import os
+import subprocess
+import sys
+
+
+REMOTE_MCP_URL = "mcp.figma.com"
+REMOTE_MCP_PATH = "/mcp"
+
+
+def log(msg):
+    print(f"[remote-mcp] {msg}", file=sys.stderr)
+
+
+def get_mcp_token(cli_token=None):
+    """Resolve MCP OAuth token: CLI arg > Keychain FIGMA_MCP_TOKEN > extract from Claude Code credentials."""
+    if cli_token:
+        return cli_token
+
+    # Try dedicated keychain entry
+    try:
+        token = subprocess.check_output(
+            ["security", "find-generic-password", "-a", os.environ["USER"],
+             "-s", "FIGMA_MCP_TOKEN", "-w"],
+            stderr=subprocess.DEVNULL,
+        ).decode().strip()
+        if token:
+            log("Token from Keychain: FIGMA_MCP_TOKEN")
+            return token
+    except (subprocess.CalledProcessError, KeyError):
+        pass
+
+    # Try extracting from Claude Code credentials
+    try:
+        import re
+        raw = subprocess.check_output(
+            ["security", "find-generic-password", "-s", "Claude Code-credentials",
+             "-a", os.environ["USER"], "-w"],
+            stderr=subprocess.DEVNULL,
+        ).decode()
+        match = re.search(
+            r'"figma-remote\|[^"]+":\{[^}]*"accessToken":"([^"]+)"', raw
+        )
+        if match:
+            token = match.group(1)
+            log("Token extracted from Claude Code credentials (figma-remote)")
+            return token
+    except (subprocess.CalledProcessError, KeyError):
+        pass
+
+    return None
+
+
+def mcp_call(token, tool_name, arguments):
+    """Call a remote MCP tool. Returns list of text content strings."""
+    conn = http.client.HTTPSConnection(REMOTE_MCP_URL, timeout=120)
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+        "Authorization": f"Bearer {token}",
+    }
+
+    # Init (stateless but required by protocol)
+    init_body = json.dumps({
+        "jsonrpc": "2.0",
+        "method": "initialize",
+        "params": {
+            "capabilities": {},
+            "clientInfo": {"name": "remote-mcp-fetch", "version": "1.0.0"},
+            "protocolVersion": "2025-03-26",
+        },
+        "id": 1,
+    })
+    conn.request("POST", REMOTE_MCP_PATH, body=init_body, headers=headers)
+    init_resp = conn.getresponse()
+    if init_resp.status != 200:
+        body = init_resp.read().decode()
+        conn.close()
+        raise RuntimeError(f"MCP init failed: HTTP {init_resp.status} — {body}")
+    init_resp.read()  # drain
+    conn.close()
+
+    # Tool call
+    conn2 = http.client.HTTPSConnection(REMOTE_MCP_URL, timeout=120)
+    call_body = json.dumps({
+        "jsonrpc": "2.0",
+        "method": "tools/call",
+        "params": {"name": tool_name, "arguments": arguments},
+        "id": 2,
+    })
+    conn2.request("POST", REMOTE_MCP_PATH, body=call_body, headers=headers)
+    resp = conn2.getresponse()
+    raw = resp.read().decode()
+    conn2.close()
+
+    if resp.status != 200:
+        raise RuntimeError(f"MCP {tool_name}: HTTP {resp.status} — {raw[:300]}")
+
+    # Parse SSE — extract JSON from "data: " lines
+    # The JSON payload may span multiple physical lines (text content with \n),
+    # so we extract everything after the first "data: " prefix until valid JSON.
+    texts = []
+    images = []
+    data_start = raw.find("\ndata: ")
+    if data_start == -1:
+        data_start = raw.find("data: ")  # might be at very start
+    if data_start != -1:
+        json_str = raw[raw.index("data: ", data_start) + 6:]
+        # Trim any trailing SSE noise (event lines after the JSON)
+        json_str = json_str.strip()
+        try:
+            j = json.loads(json_str)
+        except json.JSONDecodeError:
+            # Try to find the end of the JSON object
+            depth = 0
+            end = 0
+            for i, ch in enumerate(json_str):
+                if ch == "{":
+                    depth += 1
+                elif ch == "}":
+                    depth -= 1
+                    if depth == 0:
+                        end = i + 1
+                        break
+            if end > 0:
+                try:
+                    j = json.loads(json_str[:end])
+                except json.JSONDecodeError:
+                    j = None
+            else:
+                j = None
+
+        if j:
+            if "error" in j:
+                raise RuntimeError(f"MCP {tool_name}: {j['error']}")
+
+            content = (j.get("result") or {}).get("content", [])
+            for item in content:
+                if item.get("type") == "text":
+                    texts.append(item["text"])
+                elif item.get("type") == "image":
+                    images.append({
+                        "mimeType": item.get("mimeType", "image/png"),
+                        "data": item.get("data", ""),
+                    })
+
+    return texts, images
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Remote MCP Fetch")
+    parser.add_argument("--tool", required=True,
+                        choices=["get_metadata", "get_design_context",
+                                 "get_variable_defs", "get_code_connect_map",
+                                 "get_screenshot"])
+    parser.add_argument("--file-key", required=True)
+    parser.add_argument("--node-id", required=True)
+    parser.add_argument("--mcp-token", help="OAuth token (falls back to Keychain)")
+    parser.add_argument("--output", help="Write text output to file")
+    parser.add_argument("--output-image", help="Write screenshot image to file (PNG)")
+    parser.add_argument("--extra-args", help="Additional JSON args merged into tool call")
+    args = parser.parse_args()
+
+    # Resolve token
+    token = get_mcp_token(args.mcp_token)
+    if not token:
+        log("ERROR: No MCP OAuth token found.")
+        log("Run /figma-setup to extract and store the token, or pass --mcp-token.")
+        print(json.dumps({
+            "error": "no_mcp_token",
+            "message": "No MCP OAuth token. Run /figma-setup or pass --mcp-token.",
+        }), file=sys.stderr)
+        sys.exit(1)
+
+    # Build arguments
+    arguments = {
+        "fileKey": args.file_key,
+        "nodeId": args.node_id,
+        "clientLanguages": "swift",
+        "clientFrameworks": "swiftui",
+    }
+    # Disable Code Connect in design context — when Code Connect is enabled,
+    # the returned snippets override the original Tailwind reference code we
+    # need for layout/style extraction. We fetch Code Connect separately
+    # via get_code_connect_map.
+    if args.tool == "get_design_context":
+        arguments["disableCodeConnect"] = True
+    # Filter Code Connect by SwiftUI — without this, MCP returns all platforms
+    # (e.g. Compose) and we get Android snippets instead of iOS ones.
+    if args.tool == "get_code_connect_map":
+        arguments["codeConnectLabel"] = "SwiftUI"
+    if args.extra_args:
+        try:
+            extra = json.loads(args.extra_args)
+            arguments.update(extra)
+        except json.JSONDecodeError as e:
+            log(f"ERROR: --extra-args invalid JSON: {e}")
+            sys.exit(1)
+
+    log(f"Calling {args.tool} for node {args.node_id} in file {args.file_key}")
+
+    try:
+        texts, images = mcp_call(token, args.tool, arguments)
+    except RuntimeError as e:
+        log(f"ERROR: {e}")
+        print(json.dumps({"error": str(e)}), file=sys.stderr)
+        sys.exit(1)
+
+    # Handle screenshot (image output)
+    if args.tool == "get_screenshot" and images:
+        import base64
+        img_data = base64.b64decode(images[0]["data"])
+        if args.output_image:
+            with open(args.output_image, "wb") as f:
+                f.write(img_data)
+            log(f"Screenshot saved: {args.output_image} ({len(img_data)} bytes)")
+        else:
+            log(f"Screenshot: {len(img_data)} bytes (use --output-image to save)")
+
+    # Handle text output
+    combined = "\n".join(texts)
+    if args.output:
+        from pathlib import Path
+        Path(args.output).parent.mkdir(parents=True, exist_ok=True)
+        Path(args.output).write_text(combined)
+        log(f"Output saved: {args.output} ({len(combined)} chars)")
+    else:
+        print(combined)
+
+    log("Done")
+
+
+if __name__ == "__main__":
+    main()

package/pipeline/skills/figma-ios/figma-to-component/scripts/resolve-author-logins.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""resolve-author-logins.py — resolve the 26 distinct git-author names
+to real GitHub logins via the commits API.
+
+Reads temp/authors-registry.json (output of build-author-registry.py),
+finds every distinct git author name, and for each one:
+
+  1. Uses `git log --author='<name>' --format='%H' -n 1` inside the
+     uicomponents repo to get one SHA authored by them.
+  2. Calls `gh api repos/{owner}/{name}/commits/{sha}` to fetch the
+     commit. GitHub attaches `author.login` when the commit email is
+     registered to a user account.
+  3. Writes the resolved mapping to temp/author-login-map.json.
+
+For names where GitHub returns no login (email not registered), the
+entry is still written with `login: null` so the reviewer can fill it
+in manually.
+
+Output: temp/author-login-map.json
+    {
+      "meta": { "generated_at": "...", "resolved": N, "unresolved": N },
+      "mapping": {
+        "OZAN BARIS GUNAYDIN - ...": {
+          "login": "932986_tkgithub",
+          "resolved_via_sha": "b07442be...",
+          "lines_total": 1916,
+          "components": 11
+        },
+        "M-ISPIRLI_tkgithub": {
+          "login": "M-ISPIRLI_tkgithub",
+          "resolved_via_sha": null,
+          "resolution": "already_login_like",
+          ...
+        },
+        ...
+      }
+    }
+
+Idempotent — re-running uses the existing map file as a cache and
+only queries API for names that don't have a login yet. Pass
+--refresh to re-resolve everything.
+
+Usage:
+    python3 resolve-author-logins.py \\
+        [--authors-file temp/authors-registry.json] \\
+        [--uicomponents-repo ...] \\
+        [--repo OWNER/REPO] \\
+        [--output temp/author-login-map.json] \\
+        [--refresh]
+"""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+DEFAULT_REPO = "{github.componentsRepo}"
+
+_GH_LOGIN_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9\-_]{0,38}$")
+
+
+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 looks_like_github_login(name: str) -> bool:
+    return isinstance(name, str) and bool(_GH_LOGIN_RE.match(name))
+
+
+def find_commit_sha_for_author(
+    author_name: str,
+    uicomponents_repo: Path,
+) -> Optional[str]:
+    """Return one commit SHA authored by `author_name`, or None."""
+    try:
+        r = subprocess.run(
+            [
+                "git", "-C", str(uicomponents_repo),
+                "log", f"--author={author_name}", "--format=%H", "-n", "1",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=15,
+        )
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return None
+    if r.returncode != 0:
+        return None
+    sha = r.stdout.strip().split("\n")[0]
+    return sha or None
+
+
+def fetch_commit_author_login(sha: str, repo: str) -> Optional[str]:
+    """Call gh api repos/{repo}/commits/{sha} and return author.login."""
+    try:
+        r = subprocess.run(
+            ["gh", "api", f"repos/{repo}/commits/{sha}", "--jq", ".author.login // empty"],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=20,
+        )
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return None
+    if r.returncode != 0:
+        return None
+    login = r.stdout.strip()
+    return login or None
+
+
+def resolve_all(
+    authors_data: dict,
+    uicomponents_repo: Path,
+    repo: str,
+    existing_map: dict,
+    refresh: bool,
+) -> dict:
+    """Walk every author in authors_data, resolve each to a login.
+
+    `authors_data` is the dict loaded from authors-registry.json.
+    Returns a new mapping dict suitable for writing to
+    author-login-map.json.
+    """
+    authors = authors_data.get("authors", {})
+    mapping: dict = {}
+
+    for name, info in authors.items():
+        # Cached result?
+        cached = existing_map.get(name) if not refresh else None
+        if cached and cached.get("login"):
+            mapping[name] = cached
+            continue
+
+        entry = {
+            "login": None,
+            "lines_total": info.get("lines_total", 0),
+            "components": len(info.get("components", [])),
+            "resolved_via_sha": None,
+            "resolution": None,
+        }
+
+        # Already login-like? use verbatim
+        if looks_like_github_login(name):
+            entry["login"] = name
+            entry["resolution"] = "already_login_like"
+            mapping[name] = entry
+            print(f"  already-login:   {name}", file=sys.stderr)
+            continue
+
+        # Find a commit, query gh api
+        sha = find_commit_sha_for_author(name, uicomponents_repo)
+        if not sha:
+            entry["resolution"] = "no_commit_found"
+            mapping[name] = entry
+            print(f"  no commit:       {name}", file=sys.stderr)
+            continue
+
+        login = fetch_commit_author_login(sha, repo)
+        entry["resolved_via_sha"] = sha
+        if login:
+            entry["login"] = login
+            entry["resolution"] = "resolved_via_commit"
+            print(f"  resolved:        {name} -> {login}", file=sys.stderr)
+        else:
+            entry["resolution"] = "gh_api_returned_null"
+            print(f"  unresolved:      {name}", file=sys.stderr)
+
+        mapping[name] = entry
+
+    return mapping
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Resolve git author display names to GitHub logins",
+    )
+    parser.add_argument("--authors-file", help="Input: temp/authors-registry.json")
+    parser.add_argument("--uicomponents-repo", help="uicomponents repo path")
+    parser.add_argument("--repo", default=DEFAULT_REPO)
+    parser.add_argument("--output", help="temp/author-login-map.json")
+    parser.add_argument("--refresh", action="store_true", help="Ignore cache and re-resolve all")
+    args = parser.parse_args()
+
+    repo_root = find_repo_root()
+    authors_file = Path(args.authors_file) if args.authors_file else repo_root / "temp" / "authors-registry.json"
+    uicomponents_repo = (
+        Path(args.uicomponents_repo)
+        if args.uicomponents_repo
+        else repo_root / "{repos.packagesContainer}" / "Packages" / "{project.slug}-components"
+    )
+    output = Path(args.output) if args.output else repo_root / "temp" / "author-login-map.json"
+
+    if not authors_file.exists():
+        print(f"ERROR: missing {authors_file}. Run build-author-registry.py first.", file=sys.stderr)
+        return 1
+    if not uicomponents_repo.exists():
+        print(f"ERROR: uicomponents repo not found: {uicomponents_repo}", file=sys.stderr)
+        return 1
+
+    authors_data = json.loads(authors_file.read_text(encoding="utf-8"))
+
+    existing_map: dict = {}
+    if output.exists() and not args.refresh:
+        try:
+            prev = json.loads(output.read_text(encoding="utf-8"))
+            existing_map = prev.get("mapping", {})
+        except json.JSONDecodeError:
+            existing_map = {}
+
+    print(f"Resolving {len(authors_data.get('authors', {}))} distinct authors ...", file=sys.stderr)
+    mapping = resolve_all(
+        authors_data=authors_data,
+        uicomponents_repo=uicomponents_repo,
+        repo=args.repo,
+        existing_map=existing_map,
+        refresh=args.refresh,
+    )
+
+    resolved = sum(1 for v in mapping.values() if v.get("login"))
+    unresolved = len(mapping) - resolved
+
+    out_data = {
+        "meta": {
+            "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "total": len(mapping),
+            "resolved": resolved,
+            "unresolved": unresolved,
+        },
+        "mapping": mapping,
+    }
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(out_data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+    summary = {
+        "status": "ok",
+        "output": str(output),
+        "total": len(mapping),
+        "resolved": resolved,
+        "unresolved": unresolved,
+        "unresolved_list": [
+            {"name": n, "lines": v.get("lines_total", 0), "components": v.get("components", 0)}
+            for n, v in mapping.items() if not v.get("login")
+        ],
+    }
+    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/run-uicomponents-tests.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# run-uicomponents-tests.sh — Portable UIComponentsTests runner
+#
+# Runs tests via the UIComponents-Package scheme inside the SPM package directory.
+# This avoids the need to "show" the UIComponentsTests scheme in Xcode's Manage Schemes.
+#
+# Usage:
+#   bash run-uicomponents-tests.sh [--filter <TestClassName>] [--simulator <name>]
+#
+# Examples:
+#   bash run-uicomponents-tests.sh
+#   bash run-uicomponents-tests.sh --filter AvatarPassengersSnapshotTests
+#   bash run-uicomponents-tests.sh --filter LabelBadgeViewInspectorTests --simulator "iPhone 16 Pro"
+
+set -euo pipefail
+
+REPO_ROOT=$(git rev-parse --show-toplevel)
+PACKAGE_DIR="$REPO_ROOT/{repos.components.path}"
+
+# Parse arguments
+FILTER=""
+SIMULATOR=""
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --filter) FILTER="$2"; shift 2 ;;
+        --simulator) SIMULATOR="$2"; shift 2 ;;
+        *) echo "Unknown option: $1"; exit 1 ;;
+    esac
+done
+
+# --- STEP 1: Verify package directory exists ---
+if [[ ! -d "$PACKAGE_DIR" ]]; then
+    echo "ERROR: UIComponents package not found at: $PACKAGE_DIR"
+    exit 2
+fi
+
+# --- STEP 2: Auto-detect simulator ---
+if [[ -z "$SIMULATOR" ]]; then
+    SIMULATOR=$(xcrun simctl list devices available -j 2>/dev/null | python3 -c "
+import json, sys
+data = json.load(sys.stdin)
+for runtime in sorted(data.get('devices', {}).keys(), reverse=True):
+    if 'iOS' not in runtime: continue
+    for d in data['devices'][runtime]:
+        if d.get('isAvailable') and 'iPhone' in d.get('name', ''):
+            print(d['name']); sys.exit(0)
+" 2>/dev/null || echo "")
+
+    if [[ -z "$SIMULATOR" ]]; then
+        echo "ERROR: No available iPhone simulator found."
+        echo "Install an iOS Simulator runtime via Xcode > Settings > Platforms."
+        exit 3
+    fi
+fi
+
+echo "=== UIComponentsTests Runner ==="
+echo "Repo:      $REPO_ROOT"
+echo "Package:   $PACKAGE_DIR"
+echo "Simulator: $SIMULATOR"
+echo "Filter:    ${FILTER:-all tests}"
+echo ""
+
+# --- STEP 3: Run tests ---
+CMD=(xcodebuild test
+    -scheme UIComponents-Package
+    -destination "platform=iOS Simulator,name=$SIMULATOR"
+    -skipMacroValidation
+    -quiet
+)
+
+if [[ -n "$FILTER" ]]; then
+    CMD+=(-only-testing:"UIComponentsTests/$FILTER")
+fi
+
+cd "$PACKAGE_DIR"
+"${CMD[@]}"
+EXIT_CODE=$?
+
+echo ""
+if [[ $EXIT_CODE -eq 0 ]]; then
+    echo "=== TESTS PASSED ==="
+else
+    echo "=== TESTS FAILED (exit $EXIT_CODE) ==="
+fi
+
+exit $EXIT_CODE