@mmerterden/multi-agent-pipeline 20.8.0 → 20.8.1

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

@@ -11,6 +11,7 @@ import html
 import json
 import os
 import re
+import shlex
 import shutil
 import struct
 import subprocess
@@ -22,7 +23,8 @@ import zipfile
 from collections import namedtuple
 from xml.sax.saxutils import escape, quoteattr
 
-LANGS = ["en", "tr", "ar"] + sorted(["ru", "it", "fr", "es", "de"])
+from _shared import LANGS, slug, xml_text
+
 WARN = "\u26a0\ufe0f"
 DASH = "-"
 VERDICTS = ("reuse", "review", "new")
@@ -120,11 +122,6 @@ def look(row):
     return LOOKS.get(row.get("verdict"), UNKNOWN_LOOK)
 
 
-def slug(text):
-    value = re.sub(r"[\W_]+", "-", str(text or "").strip().lower()).strip("-")
-    return value or "screen"
-
-
 def norm(value):
     text = unicodedata.normalize("NFC", str(value or "")).strip()
     text = re.sub(r"\s+", " ", text)
@@ -189,8 +186,12 @@ def load_keyshots(mapping, mapping_dir, out_dir):
     return shots
 
 
+def xml_escape(value):
+    return escape(xml_text(value))
+
+
 def node(name, attrs=(), *children):
-    opening = name + "".join(f" {k}={quoteattr(str(v))}" for k, v in attrs)
+    opening = name + "".join(f" {k}={quoteattr(xml_text(v))}" for k, v in attrs)
     if not children:
         return f"<{opening}/>"
     return f"<{opening}>{''.join(children)}</{name}>"
@@ -291,12 +292,12 @@ class Doc:
         return storage_macro(
             "status",
             node("ac:parameter", [("ac:name", "colour")], look(row).status),
-            node("ac:parameter", [("ac:name", "title")], escape(self.verdict(row))),
+            node("ac:parameter", [("ac:name", "title")], xml_escape(self.verdict(row))),
         )
 
     def xml(self):
         t, m = self.t, self.m
-        e = escape
+        e = xml_escape
 
         def heading(label):
             return f"<h2>{e(t[label])}</h2>"
@@ -504,7 +505,7 @@ def para(text, bold=False, size=None, rtl=False):
     if rtl:
         styling.append(w("rtl"))
     run = [w("rPr", *styling)] if styling else []
-    run.append(node("w:t", [("xml:space", "preserve")], escape(str(text))))
+    run.append(node("w:t", [("xml:space", "preserve")], xml_escape(text)))
     lead = [w("pPr", w("bidi"))] if rtl else []
     return w("p", *lead, w("r", *run))
 
@@ -663,17 +664,21 @@ def chrome_candidates():
 
 def pdf_libreoffice(docx_path, out_dir):
     binaries = [shutil.which("soffice"), shutil.which("libreoffice"), mac_app("LibreOffice", "soffice")]
-    expected = os.path.splitext(docx_path)[0] + ".pdf"
+    name = os.path.splitext(os.path.basename(docx_path))[0] + ".pdf"
     for binary in binaries:
         if not (binary and os.path.isfile(binary)):
             continue
-        try:
-            subprocess.run([binary, "--headless", "--convert-to", "pdf", "--outdir", out_dir, docx_path],
-                           capture_output=True, timeout=180)
-        except (OSError, subprocess.SubprocessError):
-            continue
-        if os.path.isfile(expected) and os.path.getsize(expected) > 0:
-            return expected
+        with tempfile.TemporaryDirectory() as scratch:
+            try:
+                subprocess.run([binary, "--headless", "--convert-to", "pdf", "--outdir", scratch, docx_path],
+                               capture_output=True, timeout=180)
+            except (OSError, subprocess.SubprocessError):
+                continue
+            rendered = os.path.join(scratch, name)
+            if os.path.isfile(rendered) and os.path.getsize(rendered) > 0:
+                target = os.path.join(out_dir, name)
+                shutil.copyfile(rendered, target)
+                return target
     return None
 
 
@@ -698,7 +703,7 @@ def pdf_chrome(preview_path, pdf_path):
             with tempfile.TemporaryDirectory() as profile:
                 if os.path.exists(pdf_path):
                     os.remove(pdf_path)
-                argv = [chrome, headless, "--disable-gpu", f"--user-data-dir={profile}", "--no-pdf-header-footer",
+                argv = [chrome, headless, "--no-sandbox", "--disable-gpu", f"--user-data-dir={profile}", "--no-pdf-header-footer",
                         f"--print-to-pdf={pdf_path}", page]
                 try:
                     proc = subprocess.Popen(argv, stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)
@@ -721,17 +726,31 @@ def pdf_wkhtml(preview_path, pdf_path):
     return pdf_path if os.path.isfile(pdf_path) and os.path.getsize(pdf_path) > 0 else None
 
 
-def print_upload(name, mapping, screen):
+def upload_path(name, mapping_dir, out_dir):
+    if os.path.isabs(name):
+        return name
+    for folder in (mapping_dir, out_dir):
+        if os.path.exists(os.path.join(folder, name)):
+            return os.path.join(folder, name)
+    return os.path.join(out_dir, name)
+
+
+def print_upload(name, mapping, screen, mapping_dir, out_dir):
     prefix = os.environ.get("LOCALIZATION_PAGE_PREFIX", "Localization")
-    flags = [f"--xml {name}.confluence.xml", f'--screen "{screen}"']
-    flags += [f"--{field} {mapping[field]}" for field in ("screenshot", "overlay", "keyshots") if mapping.get(field)]
-    flags.append(f"--attach {name}.localization.xlsx")
+    quote = shlex.quote
+    flags = [f"--xml {quote(os.path.join(out_dir, name + '.confluence.xml'))}", f"--screen {quote(str(screen))}"]
+    flags += [
+        f"--{field} {quote(upload_path(str(mapping[field]), mapping_dir, out_dir))}"
+        for field in ("screenshot", "overlay", "keyshots") if mapping.get(field)
+    ]
+    flags.append(f"--attach {quote(os.path.join(out_dir, name + '.localization.xlsx'))}")
     print(" \\\n  ".join(["python3 scripts/publish-confluence.py"] + flags))
     print()
+    title = json.dumps(f"{prefix} - {screen}", ensure_ascii=False).replace("'", "'\\''")
     print("# The same call by hand, for Server/DC with a Bearer PAT read from the keychain (argv never sees the token):")
-    print("#   printf 'header = \"Authorization: Bearer %s\"\\n' \"$(security find-generic-password -s CONFLUENCE_API_TOKEN -w)\" > auth.curlrc; chmod 600 auth.curlrc")
+    print("#   (umask 077 && rm -f auth.curlrc && printf 'header = \"Authorization: Bearer %s\"\\n' \"$(security find-generic-password -s CONFLUENCE_API_TOKEN -w)\" > auth.curlrc)")
     print("#   curl -sS -K auth.curlrc -X POST -H 'Content-Type: application/json' \"$CONFLUENCE_BASE_URL/rest/api/content\" \\")
-    print(f"#     --data '{{\"type\":\"page\",\"title\":\"{prefix} - {screen}\",\"space\":{{\"key\":\"'$CONFLUENCE_SPACE'\"}},"
+    print(f"#     --data '{{\"type\":\"page\",\"title\":{title},\"space\":{{\"key\":\"'$CONFLUENCE_SPACE'\"}},"
           "\"ancestors\":[{\"id\":\"'$CONFLUENCE_PARENT'\"}],\"body\":{\"storage\":{\"value\":\"...\",\"representation\":\"storage\"}}}'")
     print("#   rm auth.curlrc")
 
@@ -797,7 +816,7 @@ def main():
         make_pdf(docx_path, out_dir, stem, keep_docx)
 
     if opts.print_upload:
-        print_upload(stem, mapping, mapping.get("screen"))
+        print_upload(stem, mapping, mapping.get("screen"), mapping_dir, out_dir)
 
 
 if __name__ == "__main__":

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

@@ -15,6 +15,8 @@ import sys
 import zipfile
 from xml.sax.saxutils import escape
 
+from _shared import clean_key, key_is_dynamic, slug, xml_text
+
 COLUMNS = [
     "Channel", "Property Group", "Property Module", "Key",
     "EN Value", "TR Value", "AR Value", "Anotation EN", "Anotation TR",
@@ -37,11 +39,6 @@ DEFAULT_TAXONOMY = {
 }
 
 
-def slug(text):
-    value = re.sub(r"[\W_]+", "-", str(text or "").strip().lower()).strip("-")
-    return value or "screen"
-
-
 def read_json(source):
     with open(source, encoding="utf-8") as stream:
         return json.load(stream)
@@ -62,12 +59,6 @@ def load_taxonomy(path):
     return taxonomy
 
 
-def clean_key(new_key):
-    text = str(new_key or "")
-    cut = text.find("(owned by")
-    return (text[:cut] if cut >= 0 else text).strip()
-
-
 def bucket(key, taxonomy):
     lowered = key.lower()
     if "error" in lowered:
@@ -88,9 +79,12 @@ def bucket(key, taxonomy):
 
 
 def table_rows(mapping, channel, taxonomy):
-    out = []
-    for row in mapping.get("rows") or []:
+    out, skipped = [], []
+    for number, row in enumerate(mapping.get("rows") or [], 1):
         key = clean_key(row.get("newKey"))
+        if not key or key_is_dynamic(key):
+            skipped.append((number, key))
+            continue
         group, module = bucket(key, taxonomy)
         if row.get("propertyGroup"):
             group = row["propertyGroup"]
@@ -103,7 +97,7 @@ def table_rows(mapping, channel, taxonomy):
             new.get("en") or "", new.get("tr") or "", new.get("ar") or "",
             cms.get("en") or "", cms.get("tr") or "",
         ])
-    return out
+    return out, skipped
 
 
 def column_letter(index):
@@ -137,7 +131,7 @@ def part(root, attrs, *children):
 
 
 def cell(ref, value, style):
-    text = escape(str(value)).replace("\n", "
")
+    text = escape(xml_text(value)).replace("\n", "
")
     attrs = [("r", ref), ("t", "inlineStr")]
     if style:
         attrs.append(("s", style))
@@ -276,7 +270,7 @@ def main():
     if not isinstance(mapping, dict) or "rows" not in mapping:
         cli.error("mapping must be a JSON object with rows")
 
-    rows = table_rows(mapping, opts.channel, load_taxonomy(opts.taxonomy))
+    rows, skipped = table_rows(mapping, opts.channel, load_taxonomy(opts.taxonomy))
     stem = opts.slug or slug(mapping.get("screen"))
     os.makedirs(opts.target_dir, exist_ok=True)
 
@@ -294,6 +288,10 @@ def main():
     summary = {"slug": stem, "rows": len(rows), "columns": COLUMNS, "channel": opts.channel, "written": produced}
     json.dump(summary, sys.stdout, indent=2, ensure_ascii=False)
     sys.stdout.write("\n")
+    if skipped:
+        print(f"# {len(skipped)} row(s) left out of the sheet: no literal key (empty, dynamic or <placeholder>)", file=sys.stderr)
+        for number, key in skipped:
+            print(f"#   row {number}: {key or '(empty)'}", file=sys.stderr)
 
 
 if __name__ == "__main__":

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

@@ -24,8 +24,12 @@ TR_RE = re.compile("^(?:tr|tr[kc]e|t[\u00fcu]rk[\u00e7c]e)\\s*" + SEP + "\\s*(.+
 EN_RE = re.compile("^(?:en|eng|ing|[i\u0130]ngilizce)\\s*" + SEP + "\\s*(.+)$", re.IGNORECASE)
 
 
+URL_NODE_ID = re.compile(r"^\d+-\d+$")
+
+
 def canon_id(node_id):
-    return str(node_id).strip().replace("-", ":")
+    text = "" if node_id is None else str(node_id).strip()
+    return text.replace("-", ":") if URL_NODE_ID.match(text) else text
 
 
 def split_lang(text):
@@ -68,7 +72,7 @@ def pick_label(labels):
 def record(node_id, name, node_type, design_text, labels):
     raw, parsed = pick_label(labels)
     return {
-        "nodeId": canon_id(node_id),
+        "nodeId": canon_id(node_id) or None,
         "name": name,
         "type": node_type,
         "designText": design_text,
@@ -246,10 +250,13 @@ def main():
 
     source, found, files, audited = pick_source(opts, cli, file_key, nodes)
 
-    first_seen = {}
+    unique, seen = [], set()
     for item in found:
-        first_seen.setdefault(item["nodeId"], item)
-    unique = list(first_seen.values())
+        if item["nodeId"]:
+            if item["nodeId"] in seen:
+                continue
+            seen.add(item["nodeId"])
+        unique.append(item)
 
     def having(lang):
         return sum(1 for entry in unique if entry[lang])

package/pipeline/skills/shared/external/localization-reuse-map/scripts/fetch-legacy-labels.py

@@ -11,7 +11,8 @@ import os
 import sys
 import urllib.request
 
-ALL_LANGS = ["en", "tr", "ar"] + sorted(["ru", "it", "fr", "es", "de"])
+from _shared import LANGS as ALL_LANGS
+
 
 
 def parse_langs(value):

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

@@ -16,10 +16,10 @@ import subprocess
 import sys
 import tempfile
 import urllib.parse
-from xml.sax.saxutils import quoteattr
+from xml.sax.saxutils import escape, quoteattr
 
 EMBED_EXTENSIONS = {".xlsx", ".xls", ".csv", ".docx", ".pdf"}
-EMBED_HEADING = "CMS Aktar\u0131m Dosyas\u0131"
+EMBED_HEADING = "CMS Import File"
 CONTENT = "/rest/api/content"
 
 
@@ -82,8 +82,8 @@ def view_file_macro(path):
     return f'<p><ac:structured-macro ac:name="view-file">{parameter}</ac:structured-macro></p>'
 
 
-def embed_block(files):
-    return f"<h2>{EMBED_HEADING}</h2>" + "".join(map(view_file_macro, files))
+def embed_block(files, heading):
+    return f"<h2>{escape(heading)}</h2>" + "".join(map(view_file_macro, files))
 
 
 def keyshot_files(manifest_path):
@@ -113,6 +113,7 @@ def build_cli():
     cli.add_argument("--parent", default=os.environ.get("CONFLUENCE_PARENT"), help="id of the parent page")
     cli.add_argument("--token", help="Bearer PAT; CONFLUENCE_API_TOKEN or the keychain is safer since other processes can read argv")
     cli.add_argument("--keychain-name", default="CONFLUENCE_API_TOKEN", help="keychain service that stores the PAT")
+    cli.add_argument("--embed-heading", default=EMBED_HEADING, help="heading above the embedded spreadsheet / document previews")
     cli.add_argument("--dry-run", action="store_true", help="report the planned actions without touching Confluence")
     return cli
 
@@ -174,7 +175,7 @@ def main():
         body = stream.read()
     embedded = [p for p in opts.attach if os.path.splitext(p)[1].lower() in EMBED_EXTENSIONS]
     if embedded:
-        body += embed_block(embedded)
+        body += embed_block(embedded, opts.embed_heading)
 
     if opts.dry_run:
         plan = {

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(...))")