@mmerterden/multi-agent-pipeline 11.2.0 → 11.3.1

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

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

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

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