@mmerterden/multi-agent-pipeline 20.8.1 → 20.8.2

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

@@ -4,17 +4,23 @@ Every script that scans keys, names output files or orders languages imports
 this module, so the scanner, the gate, the CMS sheet and the overlay agree on
 what a wired key is, which rows are component-owned or dynamic, which files are
 source, how a screen name becomes a file slug and which order languages take.
+The key accessor type (`--key-type`, default `L10n`) and the language list
+(`--langs`, default the languages present in the data) are inputs, never a
+built-in list of one app's.
 """
+import argparse
 import os
 import re
 
 EXTENSIONS = {".swift", ".kt", ".kts", ".xml", ".ts", ".tsx", ".js", ".jsx", ".vue"}
 SKIP_DIRS = {".git", "Generated"}
-LANGS = ["en", "tr", "ar"] + sorted(["ru", "it", "fr", "es", "de"])
+FALLBACK_LANG = "en"
+RTL_LANGS = {"ar", "fa", "he", "ur"}
 
 WORD = "A-Za-z0-9_"
 IDENT = rf"[A-Za-z_][{WORD}]*"
-LSK = re.compile(rf"LocalizationStringKey((?:\.{IDENT})+)")
+DEFAULT_KEY_TYPES = ("L10n",)
+KEY_TYPE_NAME = re.compile(rf"^{IDENT}$")
 LITERAL_KEY = 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")
@@ -28,6 +34,13 @@ RUNTIME_NOTE = "enumerate at runtime"
 
 XML_INVALID = re.compile("[\x00-\x08\x0b\x0c\x0e-\x1f]")
 
+ACCESSOR_EXTENSIONS = {".swift", ".kt", ".kts"}
+COMMON_ACCESSORS = (
+    "L10n", "LocalizationKey", "LocalizationKeys",
+    "LocalizedStringKey", "LocalizedStrings", "Localizable", "Localization", "Strings", "Loc",
+)
+ACCESSOR_CHAIN = re.compile(rf"(?<![{WORD}.])([A-Z][{WORD}]*)((?:\.{IDENT}){{2,}})")
+
 
 def strip_accessor(chain):
     segments = chain.strip(".").split(".")
@@ -36,13 +49,101 @@ def strip_accessor(chain):
     return ".".join(segments)
 
 
-def lsk_keys(text):
-    for hit in LSK.finditer(text):
+def key_types(values, fallback=DEFAULT_KEY_TYPES):
+    """The accessor type names from repeated or comma-separated --key-type values.
+
+    Raises ValueError on a name that is not an identifier.
+    """
+    names = [part.strip() for value in values or [] for part in str(value).split(",") if part.strip()]
+    for name in names:
+        if not KEY_TYPE_NAME.match(name):
+            raise ValueError(f"--key-type expects an identifier, got {name!r}")
+    return tuple(dict.fromkeys(names)) or tuple(fallback)
+
+
+def key_type_alternation(types):
+    return "|".join(re.escape(name) for name in sorted(types, key=len, reverse=True))
+
+
+def key_chain_pattern(types):
+    return re.compile(rf"(?:{key_type_alternation(types)})((?:\.{IDENT})+)")
+
+
+def lsk_keys(text, types=DEFAULT_KEY_TYPES):
+    for hit in key_chain_pattern(types).finditer(text):
         key = strip_accessor(hit.group(1))
         if key.count(".") >= 1:
             yield key
 
 
+def accessor_roots(texts, types=DEFAULT_KEY_TYPES):
+    """Roots of key-like member chains that are not one of `types`, with their counts.
+
+    A chain counts when its root is a common accessor name or when it ends in
+    `.localized`, and it keeps two or more segments once that suffix is dropped.
+    """
+    counts = {}
+    for text in texts:
+        for hit in ACCESSOR_CHAIN.finditer(text):
+            root, members = hit.group(1), hit.group(2)
+            if root in types:
+                continue
+            segments = members.strip(".").split(".")
+            localized = segments[-1].startswith("localized")
+            if strip_accessor(members).count(".") < 1:
+                continue
+            if root in COMMON_ACCESSORS or localized:
+                counts[root] = counts.get(root, 0) + 1
+    return dict(sorted(counts.items(), key=lambda item: (-item[1], item[0])))
+
+
+def key_type_warning(texts, types=DEFAULT_KEY_TYPES, mapping_hint=False):
+    """A warning when no chain of `types` is found but chains of another accessor are.
+
+    `texts` are the Swift and Kotlin sources read. Returns None when the
+    configured type matched at least once or nothing resembles an accessor.
+    """
+    texts = list(texts)
+    if any(True for text in texts for _ in lsk_keys(text, types)):
+        return None
+    roots = accessor_roots(texts, types)
+    if not roots:
+        return None
+    seen = ", ".join(f"{root} ({count})" for root, count in list(roots.items())[:5])
+    where = "--key-type <Name> (or \"keyType\" in the mapping)" if mapping_hint else "--key-type <Name>"
+    return (
+        f"WARNING: no key chain of {', '.join(types)} was found, but the code has accessor chains rooted at "
+        f"{seen}. Set {where} to the project's key accessor type; until then its keys are "
+        f"missed or counted as weak."
+    )
+
+
+def order_langs(langs):
+    """en first when present, then the rest sorted; en alone when nothing is given."""
+    unique = list(dict.fromkeys(lang for lang in langs if lang))
+    rest = sorted(lang for lang in unique if lang != FALLBACK_LANG)
+    ordered = ([FALLBACK_LANG] if FALLBACK_LANG in unique else []) + rest
+    return ordered or [FALLBACK_LANG]
+
+
+def parse_langs(value, present=()):
+    """A comma list in the order given, or for 'all' every language in `present`."""
+    text = str(value or "all").strip()
+    if text == "all":
+        return order_langs(present)
+    return [part.strip() for part in text.split(",") if part.strip()]
+
+
+def reject_token_flag(cli, opts, env_hint):
+    """Exit 2 when a credential was passed on argv, which other processes can read."""
+    if getattr(opts, "token", None) is not None:
+        cli.error(f"--token is not accepted, because other processes can read argv; {env_hint}")
+
+
+def add_token_flag(cli):
+    cli.add_argument("--token", help=argparse.SUPPRESS)
+
+
 def is_interpolated(literal):
     return bool(INTERPOLATION.search(literal))
 

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

@@ -23,7 +23,7 @@ import zipfile
 from collections import namedtuple
 from xml.sax.saxutils import escape, quoteattr
 
-from _shared import LANGS, slug, xml_text
+from _shared import RTL_LANGS, order_langs, parse_langs, slug, xml_text
 
 WARN = "\u26a0\ufe0f"
 DASH = "-"
@@ -210,14 +210,23 @@ def storage_image(filename, dimension, pixels):
     return node("ac:image", [(f"ac:{dimension}", pixels)], target)
 
 
+def mapping_langs(rows):
+    found = []
+    for row in rows:
+        for side in ("new", "legacy", "cms"):
+            found.extend((row.get(side) or {}).keys())
+    return order_langs(found)
+
+
 class Doc:
-    def __init__(self, mapping, t, prefix, shots, out_dir):
+    def __init__(self, mapping, t, prefix, shots, out_dir, langs=None):
         self.m = mapping
         self.t = t
         self.prefix = prefix
         self.shots = shots
         self.out = out_dir
         self.rows = mapping.get("rows") or []
+        self.langs = list(langs) if langs else mapping_langs(self.rows)
         self.counts = {v: sum(1 for r in self.rows if r.get("verdict") == v) for v in VERDICTS}
         self.cms_rows = sum(1 for r in self.rows if (r.get("cms") or {}).get("tr") or (r.get("cms") or {}).get("en"))
         self.drift_rows = sum(1 for r in self.rows if row_drifts(r))
@@ -246,7 +255,7 @@ class Doc:
         ]
 
     def detail_langs(self, row):
-        return LANGS + [lang for lang in (row.get("cms") or {}) if lang not in LANGS]
+        return self.langs + [lang for lang in (row.get("cms") or {}) if lang not in self.langs]
 
     def md(self):
         t, m = self.t, self.m
@@ -572,7 +581,7 @@ def detail_blocks(doc, t):
         blocks.append(para(f"{t['key']}: {row.get('newKey') or ''}"))
         lines = [table_row(tcell(c, fill="F5F6F8") for c in t["detail_columns"])]
         for lang in doc.detail_langs(row):
-            lines.append(table_row(tcell(v, rtl=lang == "ar") for v in (lang, *lang_values(row, lang))))
+            lines.append(table_row(tcell(v, rtl=lang in RTL_LANGS) for v in (lang, *lang_values(row, lang))))
         blocks.append(table(lines))
     return blocks
 
@@ -785,6 +794,11 @@ def main():
     cli.add_argument("--pdf", action="store_true", help="add a PDF to the outputs")
     cli.add_argument("--all", action="store_true", help="shorthand for --docx plus --pdf")
     cli.add_argument("--print-upload", action="store_true", help="show the publish command and a hand-rolled curl version of it")
+    cli.add_argument(
+        "--langs", default="all",
+        help="languages of the details tables, comma list in display order; 'all' (default) takes every language "
+             "in the mapping, en first then the rest sorted",
+    )
     opts = cli.parse_args()
 
     mapping, mapping_dir = read_mapping(opts.mapping)
@@ -795,7 +809,8 @@ def main():
     out_dir = os.path.abspath(opts.target_dir)
     os.makedirs(out_dir, exist_ok=True)
     shots = load_keyshots(mapping, mapping_dir, out_dir)
-    doc = Doc(mapping, T[opts.ui_lang], mapping.get("legacyKeyPrefix") or "", shots, out_dir)
+    langs = None if opts.langs.strip() == "all" else parse_langs(opts.langs)
+    doc = Doc(mapping, T[opts.ui_lang], mapping.get("legacyKeyPrefix") or "", shots, out_dir, langs)
     doc.base = mapping_dir
 
     renderers = [("md", doc.md), ("confluence.xml", doc.xml), ("preview.html", doc.preview)]

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

@@ -17,6 +17,8 @@ import urllib.parse
 import urllib.request
 from datetime import datetime, timezone
 
+from _shared import add_token_flag, reject_token_flag
+
 API = "https://api.figma.com/v1"
 BATCH = 4
 SEP = "[:\\-\u2013]"
@@ -117,9 +119,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")
 
@@ -210,11 +210,11 @@ def pick_source(opts, cli, file_key, nodes):
     if opts.source == "rest":
         if not have_target:
             cli.error("--source rest needs a file key and node-ids (--file/--nodes or --mapping)")
-        token = figma_token(opts.token)
+        token = figma_token()
         if not token:
-            sys.exit("No Figma token found. Export FIGMA_ACCESS_TOKEN or FIGMA_TOKEN, keep it in the keychain under FIGMA_ACCESS_TOKEN, or use --token.")
+            sys.exit("No Figma token found. Export FIGMA_ACCESS_TOKEN or FIGMA_TOKEN, or keep it in the keychain under FIGMA_ACCESS_TOKEN.")
         return ("rest",) + from_rest(file_key, nodes, token, opts.ca_file)
-    token = figma_token(opts.token) if have_target else None
+    token = figma_token() if have_target else None
     if have_target and token:
         try:
             return ("rest",) + from_rest(file_key, nodes, token, opts.ca_file)
@@ -236,10 +236,11 @@ def main():
     cli.add_argument("--from-mcp", help="JSON dump of annotations taken through MCP")
     cli.add_argument("--local", help="screen folder of a design export that contains tree.json")
     cli.add_argument("--source", default="auto", choices=["auto", "rest", "mcp", "local"])
-    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", help="file to write; stdout when omitted")
     opts = cli.parse_args()
+    reject_token_flag(cli, opts, "export FIGMA_ACCESS_TOKEN (or FIGMA_TOKEN), or keep it in the macOS keychain under FIGMA_ACCESS_TOKEN")
 
     file_key = opts.file
     nodes = [piece for piece in (opts.nodes or "").split(",") if piece.strip()]

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

@@ -11,14 +11,13 @@ import os
 import sys
 import urllib.request
 
-from _shared import LANGS as ALL_LANGS
+from _shared import parse_langs
 
 
-
-def parse_langs(value):
-    if value.strip() == "all":
-        return list(ALL_LANGS)
-    return [part.strip() for part in value.split(",") if part.strip()]
+def snapshot_langs(snapshot_dir):
+    if not os.path.isdir(snapshot_dir):
+        return []
+    return [name[:-5] for name in os.listdir(snapshot_dir) if name.endswith(".json")]
 
 
 def parse_pairs(pairs, flag):
@@ -81,7 +80,7 @@ def main():
     cli.add_argument("--endpoint", required=True, help="URL template containing {lang} and, if needed, {env}")
     cli.add_argument("--header", action="append", help="additional request header as K=V; may be repeated")
     cli.add_argument("--headers-file", help="request headers as a JSON object, so secrets stay out of argv")
-    cli.add_argument("--langs", default="all", help="languages separated by commas, or 'all'")
+    cli.add_argument("--langs", default="all", help="languages separated by commas, or 'all' for every language already in the snapshot (en when it is empty)")
     cli.add_argument("--env", default="", help="text put in place of {env}")
     cli.add_argument("--status-field", default="statusCode", help="name of the response field that holds a status code")
     cli.add_argument("--fail-status", action="append", help="CODE=message pair that marks a failed response; may be repeated")
@@ -93,7 +92,7 @@ def main():
 
     headers = build_headers(opts)
     fail_status = parse_pairs(opts.fail_status, "--fail-status")
-    langs = parse_langs(opts.langs)
+    langs = parse_langs(opts.langs, snapshot_langs(opts.snapshot_dir))
     os.makedirs(opts.snapshot_dir, exist_ok=True)
 
     total = 0

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

@@ -18,9 +18,14 @@ import tempfile
 import urllib.parse
 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 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:
@@ -111,7 +120,7 @@ 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")
@@ -163,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}"
 
@@ -185,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,7 +25,9 @@ import urllib.error
 import urllib.parse
 import urllib.request
 
-from _shared import slug
+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]"
@@ -137,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")
 
@@ -468,7 +468,7 @@ def build_cli():
     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")
@@ -479,6 +479,7 @@ def build_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:
@@ -499,9 +500,9 @@ def main():
         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)
 

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

@@ -13,7 +13,7 @@ import plistlib
 import sys
 import urllib.request
 
-from _shared import LANGS as ALL_LANGS
+from _shared import parse_langs
 
 
 
@@ -21,10 +21,17 @@ 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):
@@ -134,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}")
@@ -145,11 +152,11 @@ 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")
 

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

@@ -11,7 +11,7 @@ import json
 import os
 import sys
 
-from _shared import LANGS as ALL_LANGS, normalize_key
+from _shared import normalize_key, parse_langs
 
 
 DOMAIN_DIRS = {
@@ -20,12 +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 read_keys(opts):
     raw = [piece.strip() for piece in opts.keys.split(",")] if opts.keys else []
     if opts.keys_file:
@@ -81,6 +75,20 @@ 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):
     for candidate in dict.fromkeys((key, normalize_key(key))):
         entry = catalog.get(candidate)
@@ -101,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)
@@ -113,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: