@mmerterden/multi-agent-pipeline 11.2.0 → 11.3.1

package/pipeline/skills/figma-ios/figma-to-component/scripts/lib/issue_sync_propagate.py

@@ -1,93 +0,0 @@
-"""Post-finalize propagation: invoke update-issue-from-registry.py for one node.
-
-Called at the end of each phase{4,5,6,7}-finalize.py so that completing a
-phase flips the matching Projects V2 Status column immediately, instead of
-waiting for the next figma-iteration-commit. Failures here are *logged
-but not fatal*  -  the registry write is the single source of truth; the
-issue sync is propagation, not a prerequisite.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-from typing import Optional
-
-SYNC_TIMEOUT_SECONDS = 120  # per-node upper bound on the full sync (4 flag + status + review writes)
-
-
-def _script_path() -> Path:
-    here = Path(__file__).resolve().parent
-    return here.parent / "update-issue-from-registry.py"
-
-
-def propagate_to_issue(
-    node_id: str,
-    platform: str = "ios",
-    registry_dir: Optional[Path] = None,
-    dry_run: bool = False,
-    timeout: int = SYNC_TIMEOUT_SECONDS,
-) -> dict:
-    """Run update-issue-from-registry.py for a single node.
-
-    Returns:
-        {"status": "ok", "result": <parsed json>}            on success
-        {"status": "skip", "reason": <str>}                  on skip_marked_skip / skip_icon
-        {"status": "error", "reason": <str>, "stderr": <str>} on failure
-
-    The finalize caller should include the returned dict in its own JSON
-    output under a key like "issue_sync" for visibility but should NOT
-    change its own exit code based on this result.
-    """
-    script = _script_path()
-    if not script.exists():
-        return {"status": "error", "reason": f"script not found: {script}"}
-
-    cmd = [sys.executable, str(script), "--node-id", node_id, "--platform", platform]
-    if registry_dir is not None:
-        cmd.extend(["--registry-dir", str(registry_dir)])
-    if dry_run:
-        cmd.append("--dry-run")
-
-    try:
-        proc = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-        )
-    except subprocess.TimeoutExpired:
-        return {"status": "error", "reason": f"timeout after {timeout}s"}
-    except OSError as e:
-        return {"status": "error", "reason": f"{type(e).__name__}: {e}"}
-
-    if proc.returncode != 0:
-        return {
-            "status": "error",
-            "reason": f"exit {proc.returncode}",
-            "stderr": (proc.stderr or "")[:400],
-        }
-
-    # Parse the JSON the sync script prints so the caller can see what happened.
-    stdout = proc.stdout.strip()
-    try:
-        result = json.loads(stdout)
-    except json.JSONDecodeError:
-        return {"status": "error", "reason": "non-json stdout", "stderr": stdout[:400]}
-
-    action = result.get("action") if isinstance(result, dict) else None
-    if action in ("skip_marked_skip", "skip_icon"):
-        return {"status": "skip", "reason": action}
-    return {"status": "ok", "result": result}
-
-
-def should_skip_sync(env_override: Optional[str] = None) -> bool:
-    """Check the FIGMA_SKIP_ISSUE_SYNC env var (for CI / tests).
-
-    Returns True if the env var is set to a truthy value ("1", "true", "yes").
-    """
-    val = env_override if env_override is not None else os.environ.get("FIGMA_SKIP_ISSUE_SYNC", "")
-    return val.strip().lower() in ("1", "true", "yes", "on")

package/pipeline/skills/figma-ios/figma-to-component/scripts/lib/registry_writer.py

@@ -1,299 +0,0 @@
-"""registry_writer.py  -  single writer for component registry JSON files.
-
-All phase finalize scripts (phase4/5/6/7) and the figma-update script MUST go
-through this module. No script writes to registry JSONs directly.
-
-Schema extension (additive, does not touch existing fields):
-
-    "figmaUpdatedAt": "2026-04-08T09:12:00Z",
-    "status": {
-        "ios": {
-            "stale": false,
-            "implemented": { "value": true, "version": 3, "hash": "sha256:...", "at": "..." },
-            "tested":      { "value": true, "against": 3, "at": "..." },
-            "codeConnect": { "value": true, "against": 3, "at": "..." },
-            "wiki":        { "value": true, "against": 3, "at": "..." }
-        },
-        "android": { ...same shape... }
-    }
-
-Yellow rule (enforced in get_flag_state):
-    A flag is YELLOW when its `against` value is less than
-    `implemented.version`. That means the implementation changed after this
-    flag was last validated, so the flag needs re-validation.
-
-Version bump rule (enforced in set_implemented):
-    - If source_file is provided, the file is hashed and compared to the
-      stored hash. Byte-identical content does NOT bump the version.
-    - If source_file is omitted, version always bumps on each call (caller
-      explicitly wants to record a change).
-
-Legacy compatibility:
-    The top-level `codeConnect: { ios, android }` field is mirrored whenever
-    set_flag(flag="codeConnect") is called, so existing readers
-    (register-icons-codeconnect.py, confluence-component-status.py) keep
-    working unchanged during the transition.
-"""
-
-import hashlib
-import json
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Optional
-
-FLAGS = ("tested", "codeConnect", "wiki")
-PLATFORMS = ("ios", "android")
-
-
-def now_iso() -> str:
-    """ISO 8601 UTC timestamp with Z suffix."""
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-
-def _hash_file(path: Path) -> str:
-    """SHA-256 hex digest of a file, truncated to 16 chars for readability."""
-    h = hashlib.sha256()
-    h.update(path.read_bytes())
-    return "sha256:" + h.hexdigest()[:16]
-
-
-def _blank_platform_status() -> dict:
-    return {
-        "stale": False,
-        "implemented": {"value": False, "version": 0, "hash": None, "at": None},
-        "tested": {"value": False, "against": 0, "at": None},
-        "codeConnect": {"value": False, "against": 0, "at": None},
-        "wiki": {"value": False, "against": 0, "at": None},
-    }
-
-
-def _registry_file(registry_dir: Path, node_id: str) -> Path:
-    return Path(registry_dir) / f"{node_id.replace(':', '-')}.json"
-
-
-def _load(path: Path) -> dict:
-    if path.exists():
-        return json.loads(path.read_text(encoding="utf-8"))
-    return {}
-
-
-def _save(path: Path, data: dict) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(
-        json.dumps(data, indent=2, ensure_ascii=False) + "\n",
-        encoding="utf-8",
-    )
-
-
-def _ensure_status_block(data: dict, platform: str) -> dict:
-    if platform not in PLATFORMS:
-        raise ValueError(f"platform must be one of {PLATFORMS}, got {platform!r}")
-    status = data.setdefault("status", {})
-    for p in PLATFORMS:
-        if p not in status:
-            status[p] = _blank_platform_status()
-    return status[platform]
-
-
-def set_implemented(
-    registry_dir: Path,
-    node_id: str,
-    platform: str,
-    updater: str = "phase-4-view",
-    source_file: Optional[Path] = None,
-) -> dict:
-    """Phase 4 finalize entry point. Bumps implemented.version iff content changed.
-
-    Returns the updated `implemented` block so the caller can log the new version.
-
-    Side effects:
-        - Creates the registry file if missing (with nodeId set).
-        - Adds a `status` block if missing (both ios + android blank).
-        - Clears `status.<platform>.stale` (re-impl acknowledges Figma update).
-        - Updates `lastUpdated` and `updatedBy` top-level fields.
-    """
-    path = _registry_file(registry_dir, node_id)
-    data = _load(path)
-    data.setdefault("nodeId", node_id)
-
-    ps = _ensure_status_block(data, platform)
-    current = ps["implemented"]
-    current_version = current.get("version", 0)
-    current_hash = current.get("hash")
-
-    new_hash = _hash_file(source_file) if source_file else None
-
-    # Byte-identical re-run with prior recording: no-op
-    if source_file and new_hash == current_hash and current.get("value"):
-        return current
-
-    # Bump: version increments by 1, or starts at 1 if first time
-    new_version = current_version + 1 if current.get("value") else max(current_version, 0) + 1
-
-    ps["implemented"] = {
-        "value": True,
-        "version": new_version,
-        "hash": new_hash,
-        "at": now_iso(),
-    }
-    ps["stale"] = False  # re-impl clears stale on this platform
-
-    data["lastUpdated"] = now_iso()
-    data["updatedBy"] = updater
-    _save(path, data)
-
-    return ps["implemented"]
-
-
-def set_flag(
-    registry_dir: Path,
-    node_id: str,
-    platform: str,
-    flag: str,
-    updater: str,
-) -> dict:
-    """Phase 5/6/7 finalize entry point. Records flag as validated against current impl.version.
-
-    flag must be one of: tested | codeConnect | wiki
-
-    Side effects:
-        - Writes `status.<platform>.<flag> = { value: true, against: <impl.version>, at }`
-        - For flag='codeConnect', mirrors to legacy `codeConnect.<platform> = true`
-        - Updates `lastUpdated` and `updatedBy`
-
-    Returns the updated flag block.
-    """
-    if flag not in FLAGS:
-        raise ValueError(f"flag must be one of {FLAGS}, got {flag!r}")
-
-    path = _registry_file(registry_dir, node_id)
-    data = _load(path)
-    data.setdefault("nodeId", node_id)
-
-    ps = _ensure_status_block(data, platform)
-    impl_version = ps["implemented"].get("version", 0)
-
-    ps[flag] = {
-        "value": True,
-        "against": impl_version,
-        "at": now_iso(),
-    }
-
-    # Legacy mirror for codeConnect
-    if flag == "codeConnect":
-        data.setdefault("codeConnect", {"ios": False, "android": False})
-        data["codeConnect"][platform] = True
-
-    data["lastUpdated"] = now_iso()
-    data["updatedBy"] = updater
-    _save(path, data)
-
-    return ps[flag]
-
-
-def set_implemented_by(
-    registry_dir: Path,
-    node_id: str,
-    platform: str,
-    author: str,
-    updater: str = "backfill-status",
-) -> None:
-    """Record who implemented a component (git author, most-commits-wins).
-
-    Writes `status.<platform>.implementedBy = <author_name>`. This is
-    metadata for issue assignment  -  does NOT affect any version or
-    flag-state computation.
-    """
-    if not isinstance(platform, str) or platform not in PLATFORMS:
-        raise ValueError(f"platform must be one of {PLATFORMS}, got {platform!r}")
-    if not author or not isinstance(author, str):
-        return
-
-    path = _registry_file(registry_dir, node_id)
-    data = _load(path)
-    data.setdefault("nodeId", node_id)
-
-    ps = _ensure_status_block(data, platform)
-    ps["implementedBy"] = author
-
-    data["lastUpdated"] = now_iso()
-    data["updatedBy"] = updater
-    _save(path, data)
-
-
-def mark_stale(
-    registry_dir: Path,
-    node_id: str,
-    figma_updated_at: str,
-) -> bool:
-    """figma-update script entry point.
-
-    If `figma_updated_at` is newer than the stored `figmaUpdatedAt`, sets
-    `status.<platform>.stale=true` for any platform that has been implemented.
-
-    Does NOT create new registry files  -  only updates existing ones.
-
-    Returns True if the registry was modified, False otherwise.
-    """
-    path = _registry_file(registry_dir, node_id)
-    if not path.exists():
-        return False
-
-    data = _load(path)
-
-    prev = data.get("figmaUpdatedAt")
-    if prev and prev >= figma_updated_at:
-        return False
-
-    data["figmaUpdatedAt"] = figma_updated_at
-    for platform in PLATFORMS:
-        ps = _ensure_status_block(data, platform)
-        # Only mark a platform stale if something was actually implemented there
-        if ps["implemented"].get("value"):
-            ps["stale"] = True
-
-    data["lastUpdated"] = now_iso()
-    data["updatedBy"] = "figma-update-script"
-    _save(path, data)
-    return True
-
-
-def get_flag_state(
-    registry_dir: Path,
-    node_id: str,
-    platform: str,
-    flag: str,
-) -> str:
-    """Returns 'gray' | 'yellow' | 'green' for dashboard/reader consumption.
-
-    Rules:
-        implemented:
-            value == False → 'gray'
-            value == True  → 'green'  (baseline, never yellow)
-
-        tested | codeConnect | wiki:
-            value == False                       → 'gray'
-            value == True, against <  impl.ver   → 'yellow'
-            value == True, against >= impl.ver   → 'green'
-
-    The `stale` flag is intentionally orthogonal  -  it signals "Figma changed"
-    and is surfaced separately to dashboards, not folded into the flag state.
-    """
-    path = _registry_file(registry_dir, node_id)
-    if not path.exists():
-        return "gray"
-
-    data = _load(path)
-    status = data.get("status", {}).get(platform, {})
-    f = status.get(flag, {"value": False})
-
-    if not f.get("value"):
-        return "gray"
-
-    if flag == "implemented":
-        return "green"
-
-    impl_version = status.get("implemented", {}).get("version", 0)
-    if f.get("against", 0) < impl_version:
-        return "yellow"
-    return "green"