@mmerterden/multi-agent-pipeline 8.6.0

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

@@ -0,0 +1,332 @@
+"""Unit tests for registry_writer.py.
+
+Run: python3 -m unittest test_registry_writer.py
+Or:  python3 test_registry_writer.py
+
+Uses tempfile for isolation — no network, no repo writes, no dependencies
+beyond the Python standard library.
+"""
+
+import json
+import sys
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from registry_writer import (  # noqa: E402
+    FLAGS,
+    PLATFORMS,
+    _blank_platform_status,
+    get_flag_state,
+    mark_stale,
+    set_flag,
+    set_implemented,
+)
+
+
+class RegistryWriterTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.registry_dir = Path(self.tmp.name)
+        self.node_id = "10447:6925"
+        self.path = self.registry_dir / "10447-6925.json"
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def _load(self):
+        return json.loads(self.path.read_text())
+
+    def _write_seed(self, data):
+        self.path.write_text(json.dumps(data, indent=2) + "\n")
+
+    # ------------------------------------------------------------------
+    # set_implemented
+    # ------------------------------------------------------------------
+
+    def test_set_implemented_creates_new_file(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        data = self._load()
+        self.assertEqual(data["nodeId"], self.node_id)
+        impl = data["status"]["ios"]["implemented"]
+        self.assertTrue(impl["value"])
+        self.assertEqual(impl["version"], 1)
+        self.assertIsNotNone(impl["at"])
+        self.assertEqual(data["updatedBy"], "phase-4-view")
+
+    def test_set_implemented_creates_both_platform_blocks(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        data = self._load()
+        # ios written, android exists but untouched
+        self.assertTrue(data["status"]["ios"]["implemented"]["value"])
+        self.assertFalse(data["status"]["android"]["implemented"]["value"])
+        self.assertEqual(data["status"]["android"]["implemented"]["version"], 0)
+
+    def test_set_implemented_preserves_existing_top_level_fields(self):
+        seed = {
+            "nodeId": self.node_id,
+            "componentName": {"ios": "Button", "android": "Button"},
+            "fileKey": "abc123",
+            "skip": False,
+            "codeConnect": {"ios": False, "android": True},
+            "confluence": {"page": "https://x", "ios": None, "android": None},
+            "lastUpdated": "2025-01-01",
+            "updatedBy": "manual",
+            "testingIdentifiers": [{"key": "foo"}],
+            "localizationKeys": [],
+            "accessibilityKeys": [],
+            "analyticsEvents": [],
+        }
+        self._write_seed(seed)
+
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        data = self._load()
+
+        self.assertEqual(data["componentName"], {"ios": "Button", "android": "Button"})
+        self.assertEqual(data["fileKey"], "abc123")
+        self.assertEqual(data["skip"], False)
+        self.assertEqual(data["confluence"]["page"], "https://x")
+        self.assertEqual(data["testingIdentifiers"], [{"key": "foo"}])
+        # Legacy codeConnect UNTOUCHED by set_implemented
+        self.assertEqual(data["codeConnect"], {"ios": False, "android": True})
+        # New block present
+        self.assertTrue(data["status"]["ios"]["implemented"]["value"])
+
+    def test_set_implemented_second_call_without_source_bumps(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        data = self._load()
+        self.assertEqual(data["status"]["ios"]["implemented"]["version"], 2)
+
+    def test_set_implemented_no_bump_on_byte_identical_source(self):
+        src = self.registry_dir / "Button.swift"
+        src.write_text("struct Button {}\n")
+
+        set_implemented(self.registry_dir, self.node_id, "ios", source_file=src, updater="phase-4-view")
+        first = self._load()["status"]["ios"]["implemented"]
+        self.assertEqual(first["version"], 1)
+        self.assertIsNotNone(first["hash"])
+
+        # Identical re-run
+        time.sleep(0.01)
+        set_implemented(self.registry_dir, self.node_id, "ios", source_file=src, updater="phase-4-view")
+        second = self._load()["status"]["ios"]["implemented"]
+
+        self.assertEqual(second["version"], 1)  # no bump
+        self.assertEqual(second["hash"], first["hash"])
+        self.assertEqual(second["at"], first["at"])  # at unchanged on no-op
+
+    def test_set_implemented_bumps_on_content_change(self):
+        src = self.registry_dir / "Button.swift"
+        src.write_text("struct Button {}\n")
+        set_implemented(self.registry_dir, self.node_id, "ios", source_file=src, updater="phase-4-view")
+        v1 = self._load()["status"]["ios"]["implemented"]["version"]
+
+        src.write_text("struct Button { let label: String }\n")
+        set_implemented(self.registry_dir, self.node_id, "ios", source_file=src, updater="phase-4-view")
+        v2 = self._load()["status"]["ios"]["implemented"]["version"]
+
+        self.assertEqual(v1, 1)
+        self.assertEqual(v2, 2)
+
+    def test_set_implemented_clears_stale_on_same_platform_only(self):
+        seed = {
+            "nodeId": self.node_id,
+            "status": {
+                "ios": {
+                    "stale": True,
+                    "implemented": {"value": True, "version": 1, "hash": None, "at": "2026-04-01T00:00:00Z"},
+                    "tested": {"value": False, "against": 0, "at": None},
+                    "codeConnect": {"value": False, "against": 0, "at": None},
+                    "wiki": {"value": False, "against": 0, "at": None},
+                },
+                "android": {
+                    "stale": True,
+                    "implemented": {"value": True, "version": 1, "hash": None, "at": "2026-04-01T00:00:00Z"},
+                    "tested": {"value": False, "against": 0, "at": None},
+                    "codeConnect": {"value": False, "against": 0, "at": None},
+                    "wiki": {"value": False, "against": 0, "at": None},
+                },
+            },
+        }
+        self._write_seed(seed)
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        data = self._load()
+        self.assertFalse(data["status"]["ios"]["stale"])
+        self.assertTrue(data["status"]["android"]["stale"])  # untouched
+
+    def test_set_implemented_rejects_unknown_platform(self):
+        with self.assertRaises(ValueError):
+            set_implemented(self.registry_dir, self.node_id, "windows", updater="phase-4-view")
+
+    # ------------------------------------------------------------------
+    # set_flag
+    # ------------------------------------------------------------------
+
+    def test_set_flag_records_against_current_impl_version(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        # impl is now version 2
+        set_flag(self.registry_dir, self.node_id, "ios", "tested", updater="phase-5-test")
+        data = self._load()
+        self.assertTrue(data["status"]["ios"]["tested"]["value"])
+        self.assertEqual(data["status"]["ios"]["tested"]["against"], 2)
+
+    def test_set_flag_rejects_unknown_flag(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        with self.assertRaises(ValueError):
+            set_flag(self.registry_dir, self.node_id, "ios", "bogus", updater="x")
+
+    def test_set_flag_rejects_implemented_as_flag(self):
+        # 'implemented' is not in FLAGS — use set_implemented instead
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        with self.assertRaises(ValueError):
+            set_flag(self.registry_dir, self.node_id, "ios", "implemented", updater="x")
+
+    def test_set_flag_codeconnect_mirrors_legacy_field(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        set_flag(self.registry_dir, self.node_id, "ios", "codeConnect", updater="phase-6")
+        data = self._load()
+        self.assertTrue(data["codeConnect"]["ios"])
+        self.assertFalse(data["codeConnect"]["android"])
+
+    def test_set_flag_tested_does_not_touch_legacy_codeconnect(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        # Pre-seed a legacy codeConnect=True
+        data = self._load()
+        data["codeConnect"] = {"ios": True, "android": False}
+        self.path.write_text(json.dumps(data, indent=2) + "\n")
+
+        set_flag(self.registry_dir, self.node_id, "ios", "tested", updater="phase-5")
+        data = self._load()
+        # Legacy unchanged
+        self.assertTrue(data["codeConnect"]["ios"])
+
+    def test_set_flag_all_three_flags_work(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        for flag in FLAGS:
+            set_flag(self.registry_dir, self.node_id, "ios", flag, updater=f"phase-{flag}")
+        data = self._load()
+        for flag in FLAGS:
+            self.assertTrue(data["status"]["ios"][flag]["value"], f"{flag} should be true")
+            self.assertEqual(data["status"]["ios"][flag]["against"], 1)
+
+    # ------------------------------------------------------------------
+    # mark_stale
+    # ------------------------------------------------------------------
+
+    def test_mark_stale_updates_when_figma_is_newer(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        updated = mark_stale(self.registry_dir, self.node_id, "2026-04-15T10:00:00Z")
+        self.assertTrue(updated)
+        data = self._load()
+        self.assertEqual(data["figmaUpdatedAt"], "2026-04-15T10:00:00Z")
+        self.assertTrue(data["status"]["ios"]["stale"])
+
+    def test_mark_stale_noop_when_figma_is_older(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        mark_stale(self.registry_dir, self.node_id, "2026-04-15T10:00:00Z")
+
+        updated = mark_stale(self.registry_dir, self.node_id, "2026-04-10T00:00:00Z")
+        self.assertFalse(updated)
+        data = self._load()
+        self.assertEqual(data["figmaUpdatedAt"], "2026-04-15T10:00:00Z")
+
+    def test_mark_stale_only_marks_implemented_platforms(self):
+        # Seed: ios implemented, android not
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+
+        mark_stale(self.registry_dir, self.node_id, "2026-04-15T10:00:00Z")
+        data = self._load()
+        self.assertTrue(data["status"]["ios"]["stale"])
+        self.assertFalse(data["status"]["android"]["stale"])  # nothing to make stale
+
+    def test_mark_stale_returns_false_for_missing_registry(self):
+        updated = mark_stale(self.registry_dir, "9999:9999", "2026-04-15T10:00:00Z")
+        self.assertFalse(updated)
+        self.assertFalse((self.registry_dir / "9999-9999.json").exists())
+
+    # ------------------------------------------------------------------
+    # get_flag_state (yellow rule)
+    # ------------------------------------------------------------------
+
+    def test_get_flag_state_gray_for_missing_file(self):
+        state = get_flag_state(self.registry_dir, self.node_id, "ios", "implemented")
+        self.assertEqual(state, "gray")
+
+    def test_get_flag_state_green_after_impl(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        self.assertEqual(get_flag_state(self.registry_dir, self.node_id, "ios", "implemented"), "green")
+
+    def test_get_flag_state_gray_for_unset_tested(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        self.assertEqual(get_flag_state(self.registry_dir, self.node_id, "ios", "tested"), "gray")
+
+    def test_get_flag_state_green_after_set_flag(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        set_flag(self.registry_dir, self.node_id, "ios", "tested", updater="phase-5")
+        self.assertEqual(get_flag_state(self.registry_dir, self.node_id, "ios", "tested"), "green")
+
+    def test_get_flag_state_yellow_when_impl_ahead(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        set_flag(self.registry_dir, self.node_id, "ios", "tested", updater="phase-5")
+        set_flag(self.registry_dir, self.node_id, "ios", "codeConnect", updater="phase-6")
+        set_flag(self.registry_dir, self.node_id, "ios", "wiki", updater="phase-7")
+        # All green against version 1
+        for flag in FLAGS:
+            self.assertEqual(get_flag_state(self.registry_dir, self.node_id, "ios", flag), "green")
+
+        # Re-implement — version bumps to 2
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+
+        # Everything downstream is now yellow
+        for flag in FLAGS:
+            self.assertEqual(
+                get_flag_state(self.registry_dir, self.node_id, "ios", flag),
+                "yellow",
+                f"{flag} should be yellow after impl bump",
+            )
+        # impl itself stays green
+        self.assertEqual(get_flag_state(self.registry_dir, self.node_id, "ios", "implemented"), "green")
+
+    def test_yellow_clears_when_flag_re_set(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        set_flag(self.registry_dir, self.node_id, "ios", "tested", updater="phase-5")
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        self.assertEqual(get_flag_state(self.registry_dir, self.node_id, "ios", "tested"), "yellow")
+
+        set_flag(self.registry_dir, self.node_id, "ios", "tested", updater="phase-5")
+        self.assertEqual(get_flag_state(self.registry_dir, self.node_id, "ios", "tested"), "green")
+
+    # ------------------------------------------------------------------
+    # Platform isolation + invariants
+    # ------------------------------------------------------------------
+
+    def test_ios_and_android_independent(self):
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+        set_implemented(self.registry_dir, self.node_id, "ios", updater="phase-4-view")
+
+        data = self._load()
+        self.assertEqual(data["status"]["ios"]["implemented"]["version"], 2)
+        self.assertEqual(data["status"]["android"]["implemented"]["version"], 0)
+        self.assertFalse(data["status"]["android"]["implemented"]["value"])
+
+    def test_blank_platform_shape_matches_flags_constant(self):
+        blank = _blank_platform_status()
+        self.assertIn("stale", blank)
+        self.assertIn("implemented", blank)
+        for flag in FLAGS:
+            self.assertIn(flag, blank)
+            self.assertFalse(blank[flag]["value"])
+            self.assertEqual(blank[flag]["against"], 0)
+            self.assertIsNone(blank[flag]["at"])
+
+    def test_platforms_constant_is_complete(self):
+        self.assertEqual(set(PLATFORMS), {"ios", "android"})
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

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

@@ -0,0 +1,176 @@
+"""Execute the embedded Python block from figma-issue/SKILL.md STEP 1.5a.
+
+The readiness check is a Python one-liner embedded inside a bash heredoc.
+This test extracts it, substitutes ${FIGMA_DIR} and <NODE_ID>, runs it
+against a fixture registry, and asserts the output JSON matches the
+expected per-component status.
+
+This is the *only* automated test that proves Step 6's blocker-logic
+edit actually works. If my edit has a syntax error or wrong field
+access, this fails.
+
+Run: python3 -m unittest test_skill_figma_issue.py
+"""
+
+import json
+import re
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[5]
+SKILL_MD = REPO_ROOT / ".instructions" / "figma" / "figma-issue" / "SKILL.md"
+
+
+def extract_readiness_python(skill_md: Path) -> str:
+    """Pull the Python block from STEP 1.5a out of the SKILL.md.
+
+    The block is inside a bash heredoc:
+        python3 -c "
+        import json, os, glob
+        ...
+        "
+    We find the opening `python3 -c "` and read until the closing `"` on
+    its own line before the code fence.
+    """
+    text = skill_md.read_text(encoding="utf-8")
+    m = re.search(
+        r'python3 -c "\n(.*?)\n"\n```',
+        text,
+        re.DOTALL,
+    )
+    if not m:
+        raise RuntimeError("Could not locate readiness Python block in SKILL.md")
+    return m.group(1)
+
+
+class SkillFigmaIssueReadinessTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.code = extract_readiness_python(SKILL_MD)
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+        self.figma_dir = self.root / "Figma"
+        self.components_dir = self.figma_dir / "Components"
+        self.components_dir.mkdir(parents=True)
+
+        # Graph with one parent that depends on several sub-components
+        graph = {
+            "graph": {
+                "1:1": {
+                    "subComponents": [
+                        "NewStyleButton",       # new status block, implemented
+                        "LegacyButton",         # legacy codeConnect=true
+                        "SkipButton",           # skip=true
+                        "UnimplementedButton",  # has entry but no impl
+                        "UnknownButton",        # not in registry
+                    ],
+                },
+            },
+        }
+        (self.figma_dir / "sub-component-graph.json").write_text(json.dumps(graph))
+
+        self._write_component("1-101.json", {
+            "nodeId": "1:101",
+            "componentName": {"ios": "NewStyleButton", "android": "NewStyleButton"},
+            "skip": False,
+            "codeConnect": {"ios": False, "android": False},
+            "status": {
+                "ios": {
+                    "stale": False,
+                    "implemented": {"value": True, "version": 1, "hash": None, "at": "..."},
+                    "tested": {"value": False, "against": 0, "at": None},
+                    "codeConnect": {"value": False, "against": 0, "at": None},
+                    "wiki": {"value": False, "against": 0, "at": None},
+                },
+                "android": {
+                    "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},
+                },
+            },
+        })
+
+        self._write_component("1-102.json", {
+            "nodeId": "1:102",
+            "componentName": {"ios": "LegacyButton", "android": "LegacyButton"},
+            "skip": False,
+            "codeConnect": {"ios": True, "android": False},
+            # No status block at all — pure legacy shape
+        })
+
+        self._write_component("1-103.json", {
+            "nodeId": "1:103",
+            "componentName": {"ios": "SkipButton", "android": "SkipButton"},
+            "skip": True,
+            "codeConnect": {"ios": False, "android": False},
+        })
+
+        self._write_component("1-104.json", {
+            "nodeId": "1:104",
+            "componentName": {"ios": "UnimplementedButton", "android": "UnimplementedButton"},
+            "skip": False,
+            "codeConnect": {"ios": False, "android": False},
+        })
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def _write_component(self, filename: str, data: dict):
+        (self.components_dir / filename).write_text(json.dumps(data))
+
+    def _run_readiness(self, node_id: str = "1:1") -> dict:
+        """Substitute placeholders and run the embedded block."""
+        code = self.code.replace("${FIGMA_DIR}", str(self.figma_dir)).replace("<NODE_ID>", node_id)
+        r = subprocess.run(
+            ["python3", "-c", code],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if r.returncode != 0:
+            raise AssertionError(f"Readiness block crashed:\nSTDERR:\n{r.stderr}\nSTDOUT:\n{r.stdout}")
+        return json.loads(r.stdout)
+
+    def test_block_can_be_extracted(self):
+        self.assertIn("status", self.code)
+        self.assertIn("codeConnect", self.code)
+
+    def test_new_status_implemented_is_implemented(self):
+        out = self._run_readiness("1:1")
+        subs = {s["name"]: s["status"] for s in out["subComponents"]}
+        self.assertEqual(subs["NewStyleButton"], "implemented")
+
+    def test_legacy_codeconnect_true_is_implemented(self):
+        out = self._run_readiness("1:1")
+        subs = {s["name"]: s["status"] for s in out["subComponents"]}
+        self.assertEqual(subs["LegacyButton"], "implemented")
+
+    def test_skip_true_is_skipped(self):
+        out = self._run_readiness("1:1")
+        subs = {s["name"]: s["status"] for s in out["subComponents"]}
+        self.assertEqual(subs["SkipButton"], "skipped")
+
+    def test_no_impl_is_not_implemented(self):
+        out = self._run_readiness("1:1")
+        subs = {s["name"]: s["status"] for s in out["subComponents"]}
+        self.assertEqual(subs["UnimplementedButton"], "not_implemented")
+
+    def test_unknown_component_is_unresolved(self):
+        out = self._run_readiness("1:1")
+        subs = {s["name"]: s["status"] for s in out["subComponents"]}
+        self.assertEqual(subs["UnknownButton"], "unresolved")
+
+    def test_no_deps_case(self):
+        out = self._run_readiness("9:99")  # not in graph
+        self.assertEqual(out["status"], "no_deps")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

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

@@ -0,0 +1,98 @@
+"""Execute the embedded Python block from figma-review/SKILL.md STEP 0.
+
+Step 8 added a registry lookup block to figma-review/SKILL.md that
+resolves a ComponentName to a Figma nodeId so the issue can be found
+by `"{nodeId}" in:body` search. This test extracts that block,
+substitutes placeholders, and runs it against a fixture registry.
+
+Run: python3 -m unittest test_skill_figma_review.py
+"""
+
+import json
+import re
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[5]
+SKILL_MD = REPO_ROOT / ".instructions" / "figma" / "figma-review" / "SKILL.md"
+
+
+def extract_nodeid_lookup_python(skill_md: Path) -> str:
+    """Pull the Python block that resolves ComponentName → nodeId."""
+    text = skill_md.read_text(encoding="utf-8")
+    m = re.search(
+        r'NODE_ID=\$\(python3 -c "\n(.*?)\n"\)',
+        text,
+        re.DOTALL,
+    )
+    if not m:
+        raise RuntimeError("Could not locate node-id lookup block in figma-review SKILL.md")
+    return m.group(1)
+
+
+class SkillFigmaReviewLookupTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.code = extract_nodeid_lookup_python(SKILL_MD)
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+        self.figma_dir = self.root / "Figma"
+        self.components_dir = self.figma_dir / "Components"
+        self.components_dir.mkdir(parents=True)
+
+        # Fixture: three components with different shapes
+        (self.components_dir / "5-17752.json").write_text(json.dumps({
+            "nodeId": "5:17752",
+            "componentName": {"ios": "TurkishButton", "android": "TurkishButton"},
+        }))
+        (self.components_dir / "1-100.json").write_text(json.dumps({
+            "nodeId": "1:100",
+            "componentName": {"ios": "FlightCard", "android": "FlightCard"},
+        }))
+        # Legacy bare-string componentName
+        (self.components_dir / "7-200.json").write_text(json.dumps({
+            "nodeId": "7:200",
+            "componentName": "InputArea",
+        }))
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def _run_lookup(self, component_name: str) -> str:
+        code = self.code.replace("${FIGMA_DIR}", str(self.figma_dir)).replace("{ComponentName}", component_name)
+        r = subprocess.run(
+            ["python3", "-c", code],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if r.returncode != 0:
+            raise AssertionError(f"Lookup crashed:\nSTDERR:\n{r.stderr}\nSTDOUT:\n{r.stdout}")
+        return r.stdout.strip()
+
+    def test_block_can_be_extracted(self):
+        self.assertIn("componentName", self.code)
+        self.assertIn("nodeId", self.code)
+
+    def test_dict_component_name_resolves(self):
+        self.assertEqual(self._run_lookup("TurkishButton"), "5:17752")
+
+    def test_different_component_resolves(self):
+        self.assertEqual(self._run_lookup("FlightCard"), "1:100")
+
+    def test_unknown_component_returns_empty(self):
+        self.assertEqual(self._run_lookup("NonExistent"), "")
+
+    def test_bare_string_component_name_resolves(self):
+        # Real registry data has entries where componentName is "InputArea"
+        # instead of {"ios": "InputArea", "android": "InputArea"}
+        self.assertEqual(self._run_lookup("InputArea"), "7:200")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)