@mmerterden/multi-agent-pipeline 20.7.0 → 20.8.1

package/pipeline/skills/shared/external/localization-reuse-map/scripts/render-overlay.py

@@ -25,6 +25,8 @@ import urllib.error
 import urllib.parse
 import urllib.request
 
+from _shared import slug
+
 API = "https://api.figma.com/v1"
 SEP = "[:\\-\u2013]"
 TR_RE = re.compile("^(?:tr|tr[kc]e|t[\u00fcu]rk[\u00e7c]e)\\s*" + SEP + "\\s*(.+)$", re.IGNORECASE)
@@ -40,9 +42,10 @@ RIGHT_MARGIN = 40
 PINK = "#EC1E91"
 GRAY = "#9aa0a6"
 BACKGROUND = "#1e1e1e"
-LABEL_CMS = "\u0130\u00e7erik (CMS)"
-LABEL_PENDING = "\u00d6neri bekleniyor"
-LABEL_UNMATCHED = "(e\u015fle\u015fmedi)"
+LABELS = {
+    "en": {"cms": "CMS copy", "pending": "Awaiting copy", "unmatched": "(unmatched)"},
+    "tr": {"cms": "\u0130\u00e7erik (CMS)", "pending": "\u00d6neri bekleniyor", "unmatched": "(e\u015fle\u015fmedi)"},
+}
 
 PAGE_OPEN = "<!doctype html><html><head>"
 META_UTF8 = '<meta charset="utf-8">'
@@ -60,13 +63,12 @@ PATH_CHROMES = (
 )
 
 
-def canon_id(node_id):
-    return str(node_id or "").strip().replace("-", ":")
+URL_NODE_ID = re.compile(r"^\d+-\d+$")
 
 
-def slug(text):
-    value = re.sub(r"[\W_]+", "-", str(text or "").strip().lower()).strip("-")
-    return value or "screen"
+def canon_id(node_id):
+    text = str(node_id or "").strip()
+    return text.replace("-", ":") if URL_NODE_ID.match(text) else text
 
 
 def split_lang(text):
@@ -248,7 +250,7 @@ def page_from_rest(file_key, node_id, scale, token, ca_file):
     }
 
 
-def build_cards(page, rows):
+def build_cards(page, rows, labels):
     index = build_index(rows)
     cards = []
     taken = set()
@@ -273,7 +275,7 @@ def build_cards(page, rows):
         box = {axis: float(node.get(axis, 0)) for axis in ("x", "y", "w", "h")}
         cards.append({
             "num": number,
-            "key": new_key or LABEL_UNMATCHED,
+            "key": new_key or labels["unmatched"],
             "tr": tr,
             "en": en,
             "text": node.get("characters") or "",
@@ -302,9 +304,9 @@ def chip(kind, colour, content):
     return f'<span class="{kind}" style="background:{colour}">{content}</span>'
 
 
-def card_html(card, left):
+def card_html(card, left, labels):
     colour = PINK if card["annotated"] else GRAY
-    pill = LABEL_CMS if card["annotated"] else LABEL_PENDING
+    pill = labels["cms"] if card["annotated"] else labels["pending"]
     if card["annotated"]:
         body = "".join(
             f'<div class="line"><b>{label}</b> {html.escape(card[lang] or "-")}</div>'
@@ -336,7 +338,7 @@ def connector(card, lane, lane_count, start_x, target_x, from_left):
     )
 
 
-def build_html(page, cards):
+def build_html(page, cards, labels):
     fw, fh = page["frame"]["w"], page["frame"]["h"]
     sides = {"left": [], "right": []}
     for card in cards:
@@ -350,7 +352,7 @@ def build_html(page, cards):
     for card_x, group in ((COLUMN_X, sides["left"]), (right_x, sides["right"])):
         from_left = card_x == COLUMN_X
         for lane, card in enumerate(group):
-            boxes.append(card_html(card, card_x))
+            boxes.append(card_html(card, card_x, labels))
             if from_left:
                 wire = connector(card, lane, len(group), COLUMN_X + CARD_W, screen_x + card["x"], True)
             else:
@@ -430,12 +432,26 @@ def chrome_screenshot(chrome, html_text, out_png, width, height, scale):
             raise RuntimeError((log.read() or "no output").strip()[-300:])
 
 
+def is_number(value):
+    try:
+        float(value)
+    except (TypeError, ValueError):
+        return False
+    return True
+
+
 def load_spec_pages(path):
     with open(path, encoding="utf-8") as stream:
         spec = json.load(stream)
     folder = os.path.dirname(os.path.abspath(path))
     pages = spec.get("pages") or []
-    for page in pages:
+    for number, page in enumerate(pages, 1):
+        frame = page.get("frame") if isinstance(page, dict) else None
+        if not (isinstance(frame, dict) and all(is_number(frame.get(side)) for side in ("w", "h"))):
+            sys.exit(f"{path}: page {number} needs \"frame\": {{\"w\": <width>, \"h\": <height>}} in px")
+        for side in ("w", "h"):
+            if not isinstance(frame[side], (int, float)):
+                frame[side] = float(frame[side])
         page["image"] = image_source(page.get("image"), folder)
     return spec, pages
 
@@ -445,7 +461,7 @@ def split_nodes(flag, mapping):
     return given or list(mapping.get("figmaNodes") or [])
 
 
-def main():
+def build_cli():
     cli = argparse.ArgumentParser(description=__doc__.splitlines()[0])
     cli.add_argument("--mapping", required=True, help="the reuse-map JSON")
     cli.add_argument("--spec", help="geometry from MCP or measured by hand: {fileKey, pages:[{nodeId, image, frame, nodes}]}")
@@ -456,7 +472,14 @@ def main():
     cli.add_argument("--ca-file", help="PEM roots to trust when a proxy intercepts TLS")
     cli.add_argument("--out", dest="target_dir", default=".", help="folder that receives the generated files")
     cli.add_argument("--slug", help="stem for the file names; derived from the screen name when omitted")
+    cli.add_argument("--ui-lang", choices=sorted(LABELS), default="en", help="language of the card labels")
+    return cli
+
+
+def main():
+    cli = build_cli()
     opts = cli.parse_args()
+    labels = LABELS[opts.ui_lang]
 
     with open(opts.mapping, encoding="utf-8") as stream:
         mapping = json.load(stream)
@@ -467,6 +490,9 @@ def main():
         if not pages:
             sys.exit("--spec lists no pages")
         page = pages[0]
+        if len(pages) > 1:
+            print(f"# warning: {len(pages) - 1} extra page(s) in --spec ignored; the overlay draws the first page only "
+                  "(render-key-shots.py reads every page)", file=sys.stderr)
         file_key = spec.get("fileKey") or mapping.get("figmaFileKey")
     else:
         file_key = opts.file or mapping.get("figmaFileKey")
@@ -479,8 +505,8 @@ def main():
                      "Without one, measure the boxes on the screenshot and hand them over with --spec.")
         page = page_from_rest(file_key, canon_id(nodes[0]), opts.scale, token, opts.ca_file)
 
-    cards = build_cards(page, mapping.get("rows") or [])
-    document, width, height = build_html(page, cards)
+    cards = build_cards(page, mapping.get("rows") or [], labels)
+    document, width, height = build_html(page, cards, labels)
     os.makedirs(opts.target_dir, exist_ok=True)
 
     def output(suffix):

package/pipeline/skills/shared/external/localization-reuse-map/scripts/resolve-legacy-values.py

@@ -13,7 +13,8 @@ import plistlib
 import sys
 import urllib.request
 
-ALL_LANGS = ["en", "tr", "ar", "de", "es", "fr", "it", "ru"]
+from _shared import LANGS as ALL_LANGS
+
 
 
 def split_csv(value):
@@ -149,6 +150,8 @@ def main():
 
     keys = split_csv(args.keys)
     langs = parse_langs(args.langs)
+    if not (args.snapshot_root or args.plist_root or args.endpoint):
+        sys.exit("no source given: pass --snapshot-root, --plist-root, or --live with --endpoint")
 
     if args.snapshot_root and not args.live:
         result = from_snapshot(args.snapshot_root, keys, langs, args.prefix)
@@ -165,7 +168,7 @@ def main():
             elif args.plist_root:
                 result = from_plist(args.plist_root, keys, langs, args.prefix)
             else:
-                raise
+                sys.exit("no --snapshot-root or --plist-root to fall back on")
 
     json.dump(result, sys.stdout, indent=2, ensure_ascii=False)
     sys.stdout.write("\n")

package/pipeline/skills/shared/external/localization-reuse-map/scripts/resolve-new-values.py

@@ -11,7 +11,8 @@ import json
 import os
 import sys
 
-ALL_LANGS = ["en", "tr", "ar"] + sorted(["ru", "it", "fr", "es", "de"])
+from _shared import LANGS as ALL_LANGS, normalize_key
+
 
 DOMAIN_DIRS = {
     "localization": ("Suggested", "LocalizationStrings"),
@@ -25,10 +26,6 @@ def parse_langs(value):
     return [part.strip() for part in value.split(",") if part.strip()]
 
 
-def normalize_key(key):
-    return ".".join(seg[:1].upper() + seg[1:] for seg in key.split("."))
-
-
 def read_keys(opts):
     raw = [piece.strip() for piece in opts.keys.split(",")] if opts.keys else []
     if opts.keys_file:
@@ -85,12 +82,14 @@ def read_suggested(path, langs):
 
 
 def from_catalog(catalog, key, langs):
-    entry = catalog.get(key)
-    if entry is None:
-        entry = catalog.get(normalize_key(key))
-    if not isinstance(entry, dict):
-        return None
-    return {lang: entry.get(lang) for lang in langs}
+    for candidate in dict.fromkeys((key, normalize_key(key))):
+        entry = catalog.get(candidate)
+        if not isinstance(entry, dict):
+            continue
+        values = {lang: entry.get(lang) for lang in langs}
+        if any(value is not None for value in values.values()):
+            return values
+    return None
 
 
 def main():

package/pipeline/skills/shared/external/localization-reuse-map/scripts/scan-screen-keys.py

@@ -13,22 +13,17 @@ import os
 import re
 import sys
 
-EXTENSIONS = {".swift", ".kt", ".kts", ".xml", ".ts", ".tsx", ".js", ".jsx", ".vue"}
+from _shared import IDENT, WEB_DOLLAR_T, WEB_T, WORD, is_interpolated, lsk_keys, source_files
+
 ANDROID = {".kt", ".kts", ".xml"}
 WEB = {".ts", ".tsx", ".js", ".jsx", ".vue"}
-SKIP_PARTS = ("/.git", "/Generated/")
 
 ERROR_WORDS = ("toast", "snackbar", "alert", "warning", "failure", "exception", "showerror", "errormessage", "error", "validat")
 ERROR_CONTEXT = re.compile("|".join(ERROR_WORDS), re.IGNORECASE)
 
-WORD = "A-Za-z0-9_"
-IDENT = rf"[A-Za-z_][{WORD}]*"
-LSK = re.compile(rf"LocalizationStringKey((?:\.{IDENT}){{2,}})")
 LITERAL_LOCALIZED = re.compile(r"\"([^\"\\\n]+)\"\.localized\b")
 R_STRING = re.compile(rf"\bR\.string\.([{WORD}]+)")
 XML_STRING = re.compile(rf"@string/([{WORD}.]+)")
-WEB_T = re.compile(r"(?<![\w$])t\(\s*(['\"])([A-Za-z0-9_.\-]+)\1")
-WEB_DOLLAR_T = re.compile(r"\$t\(\s*(['\"])([A-Za-z0-9_.\-]+)\1")
 WEB_T_DYNAMIC = re.compile(r"(?<![\w$])t\(\s*[`$A-Za-z_]")
 WEB_DOLLAR_T_DYNAMIC = re.compile(r"\$t\(\s*[`$A-Za-z_]")
 LSK_DYNAMIC = re.compile(r"LocalizationStringKey\(")
@@ -38,13 +33,6 @@ INTERPOLATED_LOCALIZED = re.compile(r"\"([^\"\n]*(?:\\\(|\$\{|\$[A-Za-z_])[^\"\n
 RECEIVER_LOCALIZED = re.compile(rf"(?<![\w.\"])({IDENT}(?:\.{IDENT})*)\.localized\b")
 
 
-def strip_accessor(chain):
-    segments = chain.strip(".").split(".")
-    while segments and segments[-1].startswith("localized"):
-        segments.pop()
-    return ".".join(segments)
-
-
 def platform_of(path):
     ext = os.path.splitext(path)[1]
     if ext in ANDROID:
@@ -54,20 +42,6 @@ def platform_of(path):
     return "ios"
 
 
-def source_files(root):
-    if os.path.isfile(root):
-        yield root
-        return
-    for current, dirs, files in os.walk(root):
-        probe = current.replace(os.sep, "/") + "/"
-        if any(part in probe for part in SKIP_PARTS):
-            dirs[:] = []
-            continue
-        for name in sorted(files):
-            if os.path.splitext(name)[1] in EXTENSIONS:
-                yield os.path.join(current, name)
-
-
 def hits_in_line(line, ext):
     static, dynamic = [], []
     if ext == ".xml":
@@ -81,11 +55,8 @@ def hits_in_line(line, ext):
         if WEB_DOLLAR_T_DYNAMIC.search(line):
             dynamic.append("(dynamic: $t(...))")
         return static, dynamic
-    for match in LSK.finditer(line):
-        key = strip_accessor(match.group(1))
-        if key.count(".") >= 1:
-            static.append(key)
-    static.extend(m.group(1) for m in LITERAL_LOCALIZED.finditer(line))
+    static.extend(lsk_keys(line))
+    static.extend(m.group(1) for m in LITERAL_LOCALIZED.finditer(line) if not is_interpolated(m.group(1)))
     static.extend(m.group(1) for m in R_STRING.finditer(line))
     if LSK_DYNAMIC.search(line):
         dynamic.append("(dynamic: LocalizationStringKey(...))")

package/pipeline/skills/shared/external/localization-reuse-map/scripts/verify-map.py

@@ -11,42 +11,10 @@ import os
 import re
 import sys
 
-EXTENSIONS = {".swift", ".kt", ".kts", ".xml", ".ts", ".tsx", ".js", ".jsx", ".vue"}
-SKIP_PARTS = ("/.git", "/Generated/")
-
-WORD = "A-Za-z0-9_"
-LSK = re.compile(rf"LocalizationStringKey((?:\.[A-Za-z_][{WORD}]*)+)")
-LITERAL_LOCALIZED = re.compile(rf"\"([{WORD}.]+)\"\.localized\b")
-WEB_T = re.compile(r"(?<![\w$])t\(\s*(['\"])([A-Za-z0-9_.\-]+)\1")
-WEB_DOLLAR_T = re.compile(r"\$t\(\s*(['\"])([A-Za-z0-9_.\-]+)\1")
-TRAILING_MARKER = re.compile(r"\s*\([^()]*\)\s*$")
-COMPONENT_MARKER = re.compile(r"\([^)]*(owned by|bile\u015fen|component)[^)]*\)", re.IGNORECASE)
-PLACEHOLDER = re.compile(r"<[^<>]+>")
-
-
-def strip_accessor(chain):
-    segments = chain.strip(".").split(".")
-    while segments and segments[-1].startswith("localized"):
-        segments.pop()
-    return ".".join(segments)
-
-
-def normalize_key(key):
-    return ".".join(seg[:1].upper() + seg[1:] for seg in key.split("."))
-
-
-def source_files(root):
-    if os.path.isfile(root):
-        yield root
-        return
-    for current, dirs, files in os.walk(root):
-        probe = current.replace(os.sep, "/") + "/"
-        if any(part in probe for part in SKIP_PARTS):
-            dirs[:] = []
-            continue
-        for name in sorted(files):
-            if os.path.splitext(name)[1] in EXTENSIONS:
-                yield os.path.join(current, name)
+from _shared import (
+    LITERAL_KEY, WEB_DOLLAR_T, WEB_T, clean_key, is_component, is_dynamic, lsk_keys, normalize_key, raw_key,
+    source_files,
+)
 
 
 def scan_code(root):
@@ -61,28 +29,14 @@ def scan_code(root):
             continue
         scanned += 1
         corpus.append(text.lower())
-        chains = (strip_accessor(hit.group(1)) for hit in LSK.finditer(text))
-        keys.update(chain.lower() for chain in chains if chain)
-        for pattern, group in ((LITERAL_LOCALIZED, 1), (WEB_T, 2), (WEB_DOLLAR_T, 2)):
+        keys.update(key.lower() for key in lsk_keys(text))
+        for pattern, group in ((LITERAL_KEY, 1), (WEB_T, 2), (WEB_DOLLAR_T, 2)):
             keys.update(hit.group(group).lower() for hit in pattern.finditer(text))
     return keys, "\n".join(corpus), scanned
 
 
-def is_component(row):
-    text = " ".join(str(row.get(f) or "") for f in ("newKey", "element", "note"))
-    return bool(COMPONENT_MARKER.search(text))
-
-
-def is_dynamic(row, key):
-    element = str(row.get("element") or "").lower()
-    note = str(row.get("note") or "").lower()
-    return (
-        key.startswith("(dynamic")
-        or bool(PLACEHOLDER.search(key))
-        or "dinamik" in element
-        or "dynamic" in element
-        or "enumerate at runtime" in note
-    )
+def filled(value):
+    return bool(str(value or "").strip())
 
 
 def suggested_exists(root, key):
@@ -114,8 +68,7 @@ def main():
     map_keys = set()
 
     for row in rows:
-        raw_key = str(row.get("newKey") or "").strip()
-        key = raw_key if raw_key.startswith("(dynamic") else TRAILING_MARKER.sub("", raw_key)
+        key = clean_key(raw_key(row))
         component = is_component(row)
         dynamic = is_dynamic(row, key)
         if key:
@@ -136,11 +89,11 @@ def main():
         verdict = row.get("verdict")
         new = row.get("new") or {}
         legacy = row.get("legacy") or {}
-        if verdict != "new" and not new.get("tr") and not dynamic:
+        if verdict != "new" and not filled(new.get("tr")) and not dynamic:
             gaps.append({"key": key, "issue": "new.tr empty"})
-        if verdict in ("reuse", "review") and not (legacy.get("en") or legacy.get("tr")):
+        if verdict in ("reuse", "review") and not (filled(legacy.get("en")) or filled(legacy.get("tr"))):
             gaps.append({"key": key, "issue": f"verdict={verdict} but no legacy value"})
-        if new.get("tr") and new.get("tr") == new.get("en"):
+        if filled(new.get("tr")) and new.get("tr") == new.get("en"):
             untranslated.append(key)
         if args.resources_root and not component and not dynamic and key and not suggested_exists(args.resources_root, key):
             gaps.append({"key": key, "issue": f"no Suggested/{normalize_key(key)}.json"})