@mmerterden/multi-agent-pipeline 20.8.0 → 20.8.2

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

@@ -16,11 +16,16 @@ import subprocess
 import sys
 import tempfile
 import urllib.parse
-from xml.sax.saxutils import quoteattr
+from xml.sax.saxutils import escape, quoteattr
+
+from _shared import add_token_flag, reject_token_flag
 
 EMBED_EXTENSIONS = {".xlsx", ".xls", ".csv", ".docx", ".pdf"}
-EMBED_HEADING = "CMS Aktar\u0131m Dosyas\u0131"
+EMBED_HEADING = "CMS Import File"
 CONTENT = "/rest/api/content"
+CONNECT_TIMEOUT = 15
+REQUEST_TIMEOUT = 120
+PROCESS_TIMEOUT = 150
 
 
 class Client:
@@ -39,7 +44,10 @@ class Client:
         os.rmdir(self.tmp)
 
     def call(self, method, path, body=None, form_file=None):
-        argv = ["curl", "-sS", "-K", self.config, "-X", method]
+        argv = [
+            "curl", "-sS", "--connect-timeout", str(CONNECT_TIMEOUT), "--max-time", str(REQUEST_TIMEOUT),
+            "-K", self.config, "-X", method,
+        ]
         if body is not None:
             payload = os.path.join(self.tmp, "body.json")
             with open(payload, "w", encoding="utf-8") as sink:
@@ -48,7 +56,10 @@ class Client:
         if form_file is not None:
             argv += ["-F", "file=@" + form_file, "-H", "X-Atlassian-Token: nocheck"]
         argv.append(self.base + path)
-        done = subprocess.run(argv, text=True, capture_output=True)
+        try:
+            done = subprocess.run(argv, text=True, capture_output=True, timeout=PROCESS_TIMEOUT)
+        except subprocess.TimeoutExpired:
+            sys.exit(f"curl did not finish within {PROCESS_TIMEOUT}s: {method} {path}")
         if done.returncode != 0:
             sys.exit(f"curl did not complete: {done.stderr.strip()}")
         try:
@@ -60,9 +71,7 @@ class Client:
         return reply
 
 
-def resolve_token(explicit, keychain_name):
-    if explicit:
-        return explicit
+def resolve_token(keychain_name):
     if os.environ.get("CONFLUENCE_API_TOKEN"):
         return os.environ["CONFLUENCE_API_TOKEN"]
     try:
@@ -82,8 +91,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):
@@ -111,8 +120,9 @@ def build_cli():
     cli.add_argument("--base", "--base-url", dest="base", default=os.environ.get("CONFLUENCE_BASE_URL"))
     cli.add_argument("--space", default=os.environ.get("CONFLUENCE_SPACE"))
     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")
+    add_token_flag(cli)
     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
 
@@ -162,6 +172,10 @@ def upload(client, page_id, path):
 def main():
     cli = build_cli()
     opts = cli.parse_args()
+    reject_token_flag(
+        cli, opts,
+        f"export CONFLUENCE_API_TOKEN, or keep it in the macOS keychain under the --keychain-name service ({opts.keychain_name})",
+    )
     check_inputs(cli, opts)
     title = opts.title or f"{opts.title_prefix} - {opts.screen}"
 
@@ -174,7 +188,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 = {
@@ -184,7 +198,7 @@ def main():
         print(json.dumps(plan, indent=2, ensure_ascii=False))
         return
 
-    token = resolve_token(opts.token, opts.keychain_name)
+    token = resolve_token(opts.keychain_name)
     if not token:
         sys.exit(
             "No Confluence token available. Put a Server/DC personal access token in the keychain "

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

@@ -145,11 +145,12 @@ def main():
     cli.add_argument("--nodes", help="frame node-ids separated by commas; falls back to figmaNodes")
     cli.add_argument("--pad", default=150, type=int, help="pixels of surrounding context kept over and under the element")
     cli.add_argument("--scale", default=2, type=int)
-    cli.add_argument("--token", help="Figma token; FIGMA_ACCESS_TOKEN or the keychain is safer since other processes can read argv")
+    ov.add_token_flag(cli)
     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 for the manifest; the crops go into <out>/keyshots/")
     cli.add_argument("--slug", help="stem of the manifest name; derived from the screen name when omitted")
     opts = cli.parse_args()
+    ov.reject_token_flag(cli, opts, ov.FIGMA_TOKEN_HINT)
 
     with open(opts.mapping, encoding="utf-8") as stream:
         mapping = json.load(stream)
@@ -163,9 +164,9 @@ def main():
         nodes = ov.split_nodes(opts.nodes, mapping)
         if not (file_key and nodes):
             cli.error("need a Figma file key and frame node-ids (flags or mapping), or --spec")
-        token = ov.figma_token(opts.token)
+        token = ov.figma_token()
         if not token:
-            sys.exit("No Figma token found (FIGMA_ACCESS_TOKEN, FIGMA_TOKEN, keychain FIGMA_ACCESS_TOKEN or --token). "
+            sys.exit("No Figma token found (FIGMA_ACCESS_TOKEN, FIGMA_TOKEN or keychain FIGMA_ACCESS_TOKEN). "
                      "Without one, build --spec files from the screenshots instead.")
         pages = rest_pages(file_key, nodes, opts.scale, token, opts.ca_file)
 

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

@@ -25,6 +25,10 @@ import urllib.error
 import urllib.parse
 import urllib.request
 
+from _shared import add_token_flag, reject_token_flag, slug
+
+FIGMA_TOKEN_HINT = "export FIGMA_ACCESS_TOKEN (or FIGMA_TOKEN), or keep it in the macOS keychain under FIGMA_ACCESS_TOKEN"
+
 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 +44,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 +65,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):
@@ -135,9 +139,7 @@ def keychain_secret(service):
     return secret if lookup.returncode == 0 and secret else None
 
 
-def figma_token(explicit):
-    if explicit:
-        return explicit
+def figma_token():
     from_env = next((os.environ[v] for v in ("FIGMA_ACCESS_TOKEN", "FIGMA_TOKEN") if os.environ.get(v)), None)
     return from_env or keychain_secret("FIGMA_ACCESS_TOKEN")
 
@@ -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,18 +461,26 @@ 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}]}")
     cli.add_argument("--file", help="Figma file key; falls back to figmaFileKey in the mapping")
     cli.add_argument("--nodes", help="node-ids separated by commas, the screen frame first; falls back to figmaNodes")
     cli.add_argument("--scale", default=2, type=int)
-    cli.add_argument("--token", help="Figma token; FIGMA_ACCESS_TOKEN or the keychain is safer since other processes can read argv")
+    add_token_flag(cli)
     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()
+    reject_token_flag(cli, opts, FIGMA_TOKEN_HINT)
+    labels = LABELS[opts.ui_lang]
 
     with open(opts.mapping, encoding="utf-8") as stream:
         mapping = json.load(stream)
@@ -467,20 +491,23 @@ 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")
         nodes = split_nodes(opts.nodes, mapping)
         if not (file_key and nodes):
             cli.error("need a Figma file key and frame node-id (flags or mapping), or --spec")
-        token = figma_token(opts.token)
+        token = figma_token()
         if not token:
-            sys.exit("No Figma token found (FIGMA_ACCESS_TOKEN, FIGMA_TOKEN, keychain FIGMA_ACCESS_TOKEN or --token). "
+            sys.exit("No Figma token found (FIGMA_ACCESS_TOKEN, FIGMA_TOKEN or keychain FIGMA_ACCESS_TOKEN). "
                      "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,17 +13,25 @@ import plistlib
 import sys
 import urllib.request
 
-ALL_LANGS = ["en", "tr", "ar", "de", "es", "fr", "it", "ru"]
+from _shared import parse_langs
+
 
 
 def split_csv(value):
     return [part.strip() for part in value.split(",") if part.strip()]
 
 
-def parse_langs(value):
-    if value.strip() == "all":
-        return list(ALL_LANGS)
-    return split_csv(value)
+def present_langs(snapshot_root, plist_root):
+    found = []
+    if snapshot_root and os.path.isdir(snapshot_root):
+        found += [name[:-5] for name in os.listdir(snapshot_root) if name.endswith(".json")]
+    if plist_root and os.path.isdir(plist_root):
+        for name in os.listdir(plist_root):
+            if name.endswith(".lproj") and os.path.isfile(os.path.join(plist_root, name, "language.plist")):
+                found.append(name[: -len(".lproj")])
+            elif name.endswith(".plist") and name != "language.plist":
+                found.append(name[: -len(".plist")])
+    return found
 
 
 def parse_pairs(pairs, flag):
@@ -133,7 +141,7 @@ def from_live(args, keys, langs):
 def main():
     parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
     parser.add_argument("--keys", required=True, help="legacy keys separated by commas; leave off the backend prefix")
-    parser.add_argument("--langs", default="en,tr", help="comma list or 'all'")
+    parser.add_argument("--langs", default="all", help="comma list, or 'all' for every language the snapshot or plist root holds")
     parser.add_argument("--snapshot-root", help="directory holding <lang>.json flat snapshots")
     parser.add_argument("--live", action="store_true", help="query the label endpoint instead of the snapshot")
     parser.add_argument("--endpoint", help="URL template with {lang} and optional {env}")
@@ -144,11 +152,13 @@ def main():
     parser.add_argument("--fail-status", action="append", help="CODE=message treated as a failure (repeatable)")
     parser.add_argument("--timeout", type=int, default=30)
     parser.add_argument("--plist-root", help="last resort: directory of bundled <lang>.lproj/language.plist")
-    parser.add_argument("--prefix", default="", help="backend key prefix the app strips, e.g. Mobile-")
+    parser.add_argument("--prefix", default="", help="backend key prefix the app strips, e.g. App-")
     args = parser.parse_args()
 
     keys = split_csv(args.keys)
-    langs = parse_langs(args.langs)
+    langs = parse_langs(args.langs, present_langs(args.snapshot_root, args.plist_root))
+    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 +175,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 normalize_key, parse_langs
+
 
 DOMAIN_DIRS = {
     "localization": ("Suggested", "LocalizationStrings"),
@@ -19,16 +20,6 @@ DOMAIN_DIRS = {
 }
 
 
-def parse_langs(value):
-    if value.strip() == "all":
-        return list(ALL_LANGS)
-    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:
@@ -84,13 +75,29 @@ def read_suggested(path, langs):
     return {lang: value_of(lang) for lang in langs}
 
 
+def present_langs(directory, catalog, keys):
+    found = []
+    for key in keys:
+        path = os.path.join(directory, normalize_key(key) + ".json")
+        if os.path.isfile(path):
+            data = read_json(path)
+            found.extend(data.keys() if isinstance(data, dict) else [])
+        for candidate in dict.fromkeys((key, normalize_key(key))):
+            entry = (catalog or {}).get(candidate)
+            if isinstance(entry, dict):
+                found.extend(entry.keys())
+    return found
+
+
 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():
@@ -102,7 +109,7 @@ def main():
     cli.add_argument("--domain", default="localization", choices=sorted(DOMAIN_DIRS))
     cli.add_argument("--catalog", help="string catalog the app ships (.xcstrings or flat JSON), consulted when a key has no Suggested file")
     cli.add_argument("--report-source", action="store_true", help="return {source, values} per key instead of the bare values")
-    cli.add_argument("--langs", default="en,tr", help="languages separated by commas, or 'all'")
+    cli.add_argument("--langs", default="all", help="languages separated by commas, or 'all' for every language the sources hold")
     opts = cli.parse_args()
 
     keys = read_keys(opts)
@@ -114,8 +121,8 @@ def main():
     if not os.path.isdir(directory):
         cli.error(f"no Suggested folder at {directory} (check --resources-root / --suggested-dir / --domain)")
 
-    langs = parse_langs(opts.langs)
     catalog = load_catalog(opts.catalog) if opts.catalog else None
+    langs = parse_langs(opts.langs, present_langs(directory, catalog, keys) if opts.langs.strip() == "all" else ())
 
     result, via_catalog, unresolved = {}, [], []
     for key in keys:

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

@@ -13,38 +13,28 @@ import os
 import re
 import sys
 
-EXTENSIONS = {".swift", ".kt", ".kts", ".xml", ".ts", ".tsx", ".js", ".jsx", ".vue"}
+from _shared import (
+    ACCESSOR_EXTENSIONS, DEFAULT_KEY_TYPES, IDENT, WEB_DOLLAR_T, WEB_T, WORD, is_interpolated, key_type_alternation,
+    key_type_warning, key_types, 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\(")
 FORMAT_DYNAMIC = re.compile(r"String\(format:")
 GETSTRING_DYNAMIC = re.compile(r"\bgetString\(\s*[A-Za-z_]")
 INTERPOLATED_LOCALIZED = re.compile(r"\"([^\"\n]*(?:\\\(|\$\{|\$[A-Za-z_])[^\"\n]*)\"\.localized\b")
 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,21 +44,11 @@ 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 dynamic_key_pattern(types):
+    return re.compile(rf"({key_type_alternation(types)})\(")
 
 
-def hits_in_line(line, ext):
+def hits_in_line(line, ext, types=DEFAULT_KEY_TYPES):
     static, dynamic = [], []
     if ext == ".xml":
         static.extend(m.group(1) for m in XML_STRING.finditer(line))
@@ -81,15 +61,13 @@ 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, types))
+    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(...))")
-    mentions_key = any(marker in line for marker in (".localized", "LocalizationStringKey"))
+    constructed = dynamic_key_pattern(types).search(line)
+    if constructed:
+        dynamic.append(f"(dynamic: {constructed.group(1)}(...))")
+    mentions_key = any(marker in line for marker in (".localized", *types))
     if mentions_key and FORMAT_DYNAMIC.search(line):
         dynamic.append("(dynamic: String(format:...))")
     if "R.string." not in line and GETSTRING_DYNAMIC.search(line):
@@ -98,26 +76,30 @@ def hits_in_line(line, ext):
         dynamic.append(f'(dynamic: "{match.group(1)}".localized)')
     for match in RECEIVER_LOCALIZED.finditer(line):
         receiver = match.group(1)
-        if not receiver.startswith("LocalizationStringKey"):
+        if not receiver.startswith(tuple(types)):
             dynamic.append(f"(dynamic: {receiver}.localized)")
     return static, dynamic
 
 
-def scan(root):
+def scan(root, types=DEFAULT_KEY_TYPES):
     keys = []
     seen = set()
+    accessor_texts = []
     scanned = 0
     for path in source_files(root):
         try:
             with open(path, encoding="utf-8") as stream:
-                lines = stream.read().splitlines()
+                text = stream.read()
         except (OSError, UnicodeDecodeError):
             continue
+        lines = text.splitlines()
         scanned += 1
         ext = os.path.splitext(path)[1]
+        if ext in ACCESSOR_EXTENSIONS:
+            accessor_texts.append(text)
         platform = platform_of(path)
         for number, line in enumerate(lines, 1):
-            static, dynamic = hits_in_line(line, ext)
+            static, dynamic = hits_in_line(line, ext, types)
             in_error = bool(ERROR_CONTEXT.search(line))
             found = [(k, "error" if in_error else "static") for k in static] + [(k, "dynamic") for k in dynamic]
             for key, category in found:
@@ -133,7 +115,7 @@ def scan(root):
                     "line": number,
                     "snippet": line.strip()[:200],
                 })
-    return scanned, keys
+    return scanned, keys, key_type_warning(accessor_texts, types)
 
 
 CATEGORIES = ("static", "error", "dynamic")
@@ -144,22 +126,31 @@ def main():
     cli.add_argument("--screen-path", required=True, help="folder or single file of the built screen")
     cli.add_argument("--out", help="JSON destination; stdout when omitted")
     cli.add_argument("--category", default="all", choices=["all", "error", "dynamic", "static"])
+    cli.add_argument(
+        "--key-type", action="append", metavar="NAME",
+        help="type whose member chains are keys, e.g. the project's generated key enum; repeatable or comma list "
+             f"(default {', '.join(DEFAULT_KEY_TYPES)})",
+    )
     opts = cli.parse_args()
 
     if not os.path.exists(opts.screen_path):
         cli.error(f"--screen-path not found: {opts.screen_path}")
+    try:
+        types = key_types(opts.key_type)
+    except ValueError as exc:
+        cli.error(str(exc))
 
-    scanned, keys = scan(opts.screen_path)
+    scanned, keys, type_warning = scan(opts.screen_path, types)
     if opts.category != "all":
         keys = [entry for entry in keys if entry["category"] == opts.category]
     keys.sort(key=lambda entry: (entry["category"], entry["file"], entry["line"]))
     per_category = [entry["category"] for entry in keys]
     counts = {name: per_category.count(name) for name in CATEGORIES}
 
-    text = json.dumps(
-        {"screenPath": opts.screen_path, "filesScanned": scanned, "counts": counts, "keys": keys},
-        indent=2, ensure_ascii=False,
-    ) + "\n"
+    report = {"screenPath": opts.screen_path, "filesScanned": scanned, "counts": counts, "keys": keys}
+    if type_warning:
+        report["keyTypeWarning"] = type_warning
+    text = json.dumps(report, indent=2, ensure_ascii=False) + "\n"
     if opts.out:
         with open(opts.out, "w", encoding="utf-8") as sink:
             sink.write(text)
@@ -167,6 +158,8 @@ def main():
         sys.stdout.write(text)
     summary = ", ".join(f"{counts[name]} {name}" for name in CATEGORIES)
     print(f"# {scanned} file(s) read: {summary}", file=sys.stderr)
+    if type_warning:
+        print(f"# {type_warning}", file=sys.stderr)
 
 
 if __name__ == "__main__":