@mmerterden/multi-agent-pipeline 14.2.1 → 14.2.2

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

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""Resolve LEGACY translation values for a list of keys.
+
+PRIMARY source  -  the in-repo legacy snapshot (`--snapshot-root`): one flat
+`<lang>.json` of `{key: value}` per language, refreshed offline by
+`fetch-legacy-labels.py`. No network per run.
+
+`--live` re-reads the project's label endpoint directly, to refresh or to verify the
+snapshot. That endpoint is project-specific, so nothing about it is baked in  -  supply
+it the same way `fetch-legacy-labels.py` takes it:
+
+    resolve-legacy-values.py --keys Continue,Cancel --langs all --live \\
+      --endpoint 'https://labels.example.internal/{env}/labels/{lang}' \\
+      --headers-file .secrets/label-headers.json
+
+Prefer --headers-file (JSON object) over repeated --header for anything secret.
+
+`--prefix` covers backends that store keys under a namespace prefix the app strips
+(e.g. a stored `Mobile-Continue` for the app's `Continue`); pass keys WITHOUT it.
+
+LAST-RESORT offline fallback (`--plist-root`): a legacy iOS app's shipped
+`<lang>.lproj/language.plist`. It is typically a stale subset  -  the snapshot and the
+service are authoritative; a plist hit deserves a note in the map.
+
+Output: `{key: {lang: value|null}}`. Never invent a value  -  `null` is a valid answer.
+"""
+import argparse
+import json
+import os
+import sys
+import urllib.request
+
+LANGS_ALL = ["en", "tr", "ar", "de", "es", "fr", "it", "ru"]
+
+
+def _largest_str_map(obj):
+    best, stack = {}, [obj]
+    while stack:
+        cur = stack.pop()
+        if isinstance(cur, dict):
+            strs = {k: v for k, v in cur.items() if isinstance(v, str)}
+            if len(strs) > len(best):
+                best = strs
+            stack.extend(cur.values())
+        elif isinstance(cur, list):
+            stack.extend(cur)
+    return best
+
+
+def _parse_headers(a):
+    headers = {"Accept": "application/json"}
+    if a.headers_file:
+        with open(a.headers_file, encoding="utf-8") as fh:
+            loaded = json.load(fh)
+        if not isinstance(loaded, dict):
+            raise SystemExit(f"--headers-file must be a JSON object, got {type(loaded).__name__}")
+        headers.update({str(k): str(v) for k, v in loaded.items()})
+    for pair in a.header or []:
+        if "=" not in pair:
+            raise SystemExit(f"--header expects K=V, got {pair!r}")
+        k, v = pair.split("=", 1)
+        headers[k.strip()] = v.strip()
+    return headers
+
+
+def _parse_fail_statuses(values):
+    out = {}
+    for pair in values or []:
+        if "=" not in pair:
+            raise SystemExit(f"--fail-status expects CODE=message, got {pair!r}")
+        code, message = pair.split("=", 1)
+        out[code.strip()] = message.strip()
+    return out
+
+
+def fetch(lang, a):
+    if not a.endpoint:
+        raise RuntimeError("--live needs --endpoint (no label endpoint is built in)")
+    url = a.endpoint.format(env=a.env, lang=lang)
+    headers = _parse_headers(a)
+    headers.setdefault("Accept-Language", lang)
+    req = urllib.request.Request(url, headers=headers)
+    with urllib.request.urlopen(req, timeout=a.timeout) as r:
+        data = json.loads(r.read().decode("utf-8"))
+    fail_statuses = _parse_fail_statuses(a.fail_status)
+    if isinstance(data, dict) and a.status_field in data:
+        code = str(data.get(a.status_field))
+        if code in fail_statuses:
+            raise RuntimeError(f"{url}: {fail_statuses[code]} (status {code})")
+    m = _largest_str_map(data)
+    if not m:
+        raise RuntimeError(f"no label map found in the response for '{lang}' ({url})")
+    return m
+
+
+def resolve_api(keys, langs, a):
+    out = {k: {} for k in keys}
+    for lang in langs:
+        m = fetch(lang, a)
+        for k in keys:
+            out[k][lang] = m.get(a.prefix + k, m.get(k))
+    return out
+
+
+def resolve_snapshot(keys, langs, root, prefix):
+    """Read the in-repo legacy snapshot (<root>/<lang>.json, flat {key: value})  -  
+    offline, no network. Refresh it with fetch-legacy-labels.py."""
+    maps = {}
+    for l in langs:
+        p = os.path.join(root, f"{l}.json")
+        if os.path.isfile(p):
+            with open(p, encoding="utf-8") as fh:
+                maps[l] = json.load(fh)
+        else:
+            sys.stderr.write(f"# no legacy snapshot for '{l}' under {root}\n")
+    return {k: {l: maps.get(l, {}).get(prefix + k, maps.get(l, {}).get(k)) for l in langs} for k in keys}
+
+
+def resolve_plist(keys, langs, root, prefix):
+    import plistlib
+    pl = {}
+    for l in langs:
+        for cand in (os.path.join(root, f"{l}.lproj", "language.plist"), os.path.join(root, f"{l}.plist")):
+            if os.path.isfile(cand):
+                with open(cand, "rb") as fh:
+                    pl[l] = plistlib.load(fh)
+                break
+        else:
+            sys.stderr.write(f"# no plist for '{l}' under {root}\n")
+    return {k: {l: pl.get(l, {}).get(prefix + k, pl.get(l, {}).get(k)) for l in langs} for k in keys}
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--keys", required=True,
+                    help="comma-separated legacy keys, WITHOUT the --prefix")
+    ap.add_argument("--langs", default="en,tr", help="comma-separated langs, or 'all'")
+    ap.add_argument("--snapshot-root", help="PRIMARY: in-repo legacy snapshot dir  -  offline, no network")
+    ap.add_argument("--live", action="store_true",
+                    help="bypass the snapshot and read --endpoint live (to refresh / verify)")
+    ap.add_argument("--endpoint", help="URL template for the legacy label map; may contain {lang} and {env}")
+    ap.add_argument("--header", action="append",
+                    help="extra request header as K=V (repeatable); avoid for secrets")
+    ap.add_argument("--headers-file", help="JSON object of request headers  -  use this for tokens")
+    ap.add_argument("--env", default="", help="value substituted for {env} in --endpoint")
+    ap.add_argument("--status-field", default="statusCode",
+                    help="response field carrying a provider status code")
+    ap.add_argument("--fail-status", action="append",
+                    help="CODE=message for a provider error code that must abort (repeatable)")
+    ap.add_argument("--timeout", type=int, default=30)
+    ap.add_argument("--plist-root", help="last-resort offline fallback: dir with <lang>.lproj/language.plist")
+    ap.add_argument("--prefix", default="", help="prefix the backend stores keys under (default none)")
+    a = ap.parse_args()
+
+    langs = LANGS_ALL if a.langs.strip() == "all" else [l.strip() for l in a.langs.split(",") if l.strip()]
+    keys = [k.strip() for k in a.keys.split(",") if k.strip()]
+
+    # Preference: in-repo snapshot (offline) → live endpoint → plist.
+    if a.snapshot_root and not a.live:
+        out = resolve_snapshot(keys, langs, a.snapshot_root, a.prefix)
+    elif a.plist_root and not a.live and not a.snapshot_root:
+        sys.stderr.write("# OFFLINE plist fallback  -  the snapshot/service are the source of truth.\n")
+        out = resolve_plist(keys, langs, a.plist_root, a.prefix)
+    else:
+        try:
+            out = resolve_api(keys, langs, a)
+        except Exception as exc:
+            sys.stderr.write(f"# live label fetch failed ({exc}).\n")
+            if a.snapshot_root:
+                sys.stderr.write("# falling back to --snapshot-root.\n")
+                out = resolve_snapshot(keys, langs, a.snapshot_root, a.prefix)
+            elif a.plist_root:
+                sys.stderr.write("# falling back to --plist-root.\n")
+                out = resolve_plist(keys, langs, a.plist_root, a.prefix)
+            else:
+                raise
+
+    json.dump(out, sys.stdout, ensure_ascii=False, indent=2)
+    sys.stdout.write("\n")
+    absent = [k for k, v in out.items() if not any(v.values())]
+    if absent:
+        sys.stderr.write(f"\n# {len(absent)} key(s) with no value: " + ", ".join(absent) + "\n")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""Bulk-resolve the redesign (new) translation values for a list of localization keys.
+
+Reads the per-key authored source under
+`<resources>/Resources/Localization/LocalizationStrings/Sources/Suggested/<Key>.json`
+(SSOT in the resources repo) and prints `{key: {lang: value|null}}`.
+
+Why a script: the model otherwise hand-copies 8 languages x N keys out of JSON
+files  -  slow, token-heavy, and error-prone. This is pure file IO, so it is a
+script. Read-only; touches nothing.
+
+Key-form handling: code often references a key as `AddPassenger.continueButton`
+(camelCase leaf) while the Suggested filename PascalCases every dotted segment
+(`AddPassenger.ContinueButton.json`). We normalise the first character of
+each segment to upper-case before resolving, so either form works as input.
+Accessibility keys live under `AccessibilityStrings/Sources/Suggested/`  -  pass
+`--domain accessibility` for those.
+
+`--catalog <file>`: the SHIPPED string catalog, checked whenever a key has no Suggested
+file. Pass it. A missing Suggested file means "not in this snapshot", NOT "this key is
+unauthored"  -  the snapshot is a generated mirror and goes stale the moment a key is added
+upstream. Concluding "unauthored" from the snapshot alone has already produced a batch of
+pointless authoring requests for keys that were shipping in all eight languages. With
+`--catalog`, each key reports where its values came from (`suggested` / `catalog`), and
+only keys absent from BOTH are reported as genuinely unauthored.
+
+Accepts an Apple `.xcstrings` (`{"strings": {key: {"localizations": {lang: {"stringUnit":
+{"value": ...}}}}}}`) or a flat `{key: {lang: value}}` map.
+"""
+import argparse
+import json
+import os
+import sys
+
+DOMAIN_DIR = {
+    "localization": "LocalizationStrings",
+    "accessibility": "AccessibilityStrings",
+}
+
+
+def normalise(key: str) -> str:
+    """PascalCase the first char of every dotted segment (file naming convention)."""
+    return ".".join(s[:1].upper() + s[1:] if s else s for s in key.split("."))
+
+
+SNAPSHOT_SUBDIR = {"localization": "Suggested", "accessibility": "AccessibilitySuggested"}
+
+
+def suggested_dir(resources_root: str, domain: str) -> str:
+    # In-repo snapshot layout first (specs/resources/Localization/Suggested)  -  single-repo, offline;
+    # else the full the resources repo layout.
+    snap = os.path.join(resources_root, "Localization", SNAPSHOT_SUBDIR[domain])
+    if os.path.isdir(snap):
+        return snap
+    return os.path.join(
+        resources_root, "Resources", "Localization",
+        DOMAIN_DIR[domain], "Sources", "Suggested",
+    )
+
+
+def resolve(key: str, sug_dir: str, langs):
+    path = os.path.join(sug_dir, normalise(key) + ".json")
+    if not os.path.isfile(path):
+        return None  # absent from THIS snapshot  -  see load_catalog before concluding
+    with open(path, encoding="utf-8") as fh:
+        data = json.load(fh)
+    out = {}
+    for lang in langs:
+        entry = data.get(lang)
+        out[lang] = entry.get("value") if isinstance(entry, dict) else None
+    return out
+
+
+def load_catalog(path):
+    """{key: {lang: value}} from an .xcstrings or an already-flat catalog."""
+    if not path:
+        return {}
+    with open(path, encoding="utf-8") as fh:
+        raw = json.load(fh)
+    strings = raw.get("strings") if isinstance(raw, dict) else None
+    if not isinstance(strings, dict):
+        return raw if isinstance(raw, dict) else {}
+    out = {}
+    for key, entry in strings.items():
+        locs = (entry or {}).get("localizations") or {}
+        out[key] = {lang: ((v or {}).get("stringUnit") or {}).get("value")
+                    for lang, v in locs.items()}
+    return out
+
+
+def resolve_from_catalog(key, catalog, langs):
+    for cand in (key, normalise(key)):
+        vals = catalog.get(cand)
+        if vals:
+            return {lang: vals.get(lang) for lang in langs}
+    return None
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--keys", help="comma-separated keys (code- or file-form)")
+    ap.add_argument("--keys-file", help="file with one key per line (- for stdin)")
+    ap.add_argument("--resources-root",
+                    help="resources checkout OR the in-repo snapshot root (specs/resources)")
+    ap.add_argument("--suggested-dir", help="explicit Suggested dir (overrides --resources-root detection)")
+    ap.add_argument("--domain", choices=list(DOMAIN_DIR), default="localization")
+    ap.add_argument("--catalog", help="shipped string catalog (.xcstrings or flat JSON) used "
+                                     "whenever a key has no Suggested file  -  pass it, or a "
+                                     "stale snapshot reads as 'unauthored'")
+    ap.add_argument("--report-source", action="store_true",
+                    help="emit {key: {source, values}} instead of {key: values}")
+    ap.add_argument("--langs", default="en,tr",
+                    help="comma-separated langs, or 'all' (ar,de,en,es,fr,it,ru,tr)")
+    args = ap.parse_args()
+
+    if args.langs.strip() == "all":
+        langs = ["ar", "de", "en", "es", "fr", "it", "ru", "tr"]
+    else:
+        langs = [l.strip() for l in args.langs.split(",") if l.strip()]
+
+    keys = []
+    if args.keys:
+        keys += [k.strip() for k in args.keys.split(",") if k.strip()]
+    if args.keys_file:
+        src = sys.stdin if args.keys_file == "-" else open(args.keys_file, encoding="utf-8")
+        keys += [ln.strip() for ln in src if ln.strip()]
+    if not keys:
+        ap.error("supply --keys and/or --keys-file")
+
+    if args.suggested_dir:
+        sug_dir = args.suggested_dir
+    elif args.resources_root:
+        sug_dir = suggested_dir(args.resources_root, args.domain)
+    else:
+        ap.error("supply --resources-root or --suggested-dir")
+    if not os.path.isdir(sug_dir):
+        ap.error(f"Suggested dir not found: {sug_dir} (is --resources-root / --suggested-dir correct?)")
+
+    catalog = load_catalog(args.catalog)
+    result, source = {}, {}
+    for k in keys:
+        vals = resolve(k, sug_dir, langs)
+        src = "suggested" if vals is not None else None
+        if vals is None and catalog:
+            vals = resolve_from_catalog(k, catalog, langs)
+            src = "catalog" if vals is not None else None
+        result[k] = vals
+        source[k] = src
+
+    if args.report_source:
+        json.dump({k: {"source": source[k], "values": result[k]} for k in keys},
+                  sys.stdout, ensure_ascii=False, indent=2)
+    else:
+        json.dump(result, sys.stdout, ensure_ascii=False, indent=2)
+    sys.stdout.write("\n")
+
+    from_catalog = [k for k in keys if source[k] == "catalog"]
+    unauthored = [k for k in keys if source[k] is None]
+    if from_catalog:
+        sys.stderr.write(
+            f"\n# {len(from_catalog)} key(s) resolved from the CATALOG, not the snapshot  -  "
+            "the snapshot is stale, refresh it with snapshot-resources.sh: "
+            + ", ".join(from_catalog) + "\n")
+    if unauthored:
+        label = ("with no authored source" if catalog else
+                 "absent from the snapshot (no --catalog given, so 'unauthored' is UNVERIFIED)")
+        sys.stderr.write(f"\n# {len(unauthored)} key(s) {label}: " + ", ".join(unauthored) + "\n")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""Scan an *implemented* screen for the localization keys the registry×code union misses.
+
+The mapper's primary new-key recipe is a STATIC cross-reference (design-export
+components × component-registry `localizationKeys` × the screen's wired call sites).
+That recipe is structurally blind to three things, which this scanner recovers by
+reading the screen's actual source tree:
+
+  1. **Error / validation / alert strings**  -  copy that lives in validators, error
+     mappers, alert/toast builders, or ViewModel error branches, not in the
+     VC→VM→cell chain the static recipe walks.
+  2. **Dynamic / interpolated keys**  -  keys built at runtime: `String(format:)`,
+     interpolated/variable `.localized` receivers, `LocalizationStringKey(<expr>)`,
+     Android `getString(<var>)`  -  none of which are string literals, so the literal
+     greps never see them.
+  3. **Keys wired in code but absent from the component registry** (and the inverse
+     is the agent's job to confirm)  -  surfaced here as plain `static` call sites so
+     the agent can diff them against the registry union.
+
+Heuristic + read-only: it greps `.swift`/`.kt`/`.xml`/`.ts`/`.tsx`/`.js`/`.jsx`/`.vue`
+under --screen-path and classifies each hit `static | error | dynamic` with
+file:line provenance. It does
+NOT resolve values or invent keys  -  it hands the agent a categorized worklist to
+fold into the mapping (errors and dynamics especially), where each still gets the
+normal new/legacy/CMS resolution.
+
+Output (to --out or stdout): { screenPath, counts:{static,error,dynamic},
+  keys:[ {key, category, platform, file, line, snippet} ] }.
+"""
+import argparse
+import json
+import os
+import re
+import sys
+
+EXTS = (".swift", ".kt", ".kts", ".xml", ".ts", ".tsx", ".js", ".jsx", ".vue")
+ERROR_CTX = re.compile(
+    r"alert|error|validat|warning|toast|snackbar|failure|exception|errorMessage|showError",
+    re.I)
+
+# iOS
+RE_LSK = re.compile(r"LocalizationStringKey\.([A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)+)")
+RE_LSK_DYN = re.compile(r"LocalizationStringKey\s*\(")
+RE_LITERAL_LOCALIZED = re.compile(r'"([^"\\]+)"\s*\.\s*localized')
+RE_VAR_LOCALIZED = re.compile(r'(?<!")\b([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z0-9_]+)*)\s*\.\s*localized')
+RE_STRING_FORMAT = re.compile(r"String\s*\(\s*format\s*:")
+# Android
+RE_R_STRING = re.compile(r"R\.string\.([A-Za-z0-9_]+)")
+RE_AT_STRING = re.compile(r"@string/([A-Za-z0-9_]+)")
+RE_GETSTRING_DYN = re.compile(r"getString\s*\(\s*[A-Za-z_]")  # variable, not R.string.literal
+# Web (react-i18next / next-intl `t('key')`; vue-i18n `$t('key')`); `(?<!\$)\bt\(`
+# keeps a plain t(...) call from also matching inside a $t(...) call.
+RE_WEB_T = re.compile(r"(?<!\$)\bt\(\s*['\"]([A-Za-z0-9_.\-]+)['\"]")
+RE_WEB_VUE_T = re.compile(r"\$t\(\s*['\"]([A-Za-z0-9_.\-]+)['\"]")
+RE_WEB_T_DYN = re.compile(r"(?<!\$)\bt\(\s*[`$A-Za-z_]")   # template literal or variable, not a literal
+RE_WEB_VUE_T_DYN = re.compile(r"\$t\(\s*[`$A-Za-z_]")
+
+
+def platform_of(path):
+    if path.endswith((".kt", ".kts")):
+        return "android"
+    if path.endswith(".xml"):
+        return "android"
+    if path.endswith((".ts", ".tsx", ".js", ".jsx", ".vue")):
+        return "web"
+    return "ios"
+
+
+def classify(line):
+    return "error" if ERROR_CTX.search(line) else None
+
+
+def scan_line(path, lineno, line, out, seen):
+    plat = platform_of(path)
+    err = classify(line)
+
+    def add(key, category, dyn=False):
+        cat = "dynamic" if dyn else (category or "static")
+        # error context upgrades a static/dynamic hit's category to error only when
+        # it isn't already dynamic (dynamic is the more actionable label)
+        if err and cat == "static":
+            cat = "error"
+        sig = (key, cat, path, lineno)
+        if sig in seen:
+            return
+        seen.add(sig)
+        out.append({
+            "key": key, "category": cat, "platform": plat,
+            "file": path, "line": lineno, "snippet": line.strip()[:200],
+        })
+
+    if path.endswith(".xml"):
+        for m in RE_AT_STRING.finditer(line):
+            add(m.group(1), err)
+        return
+
+    if plat == "web":
+        for m in RE_WEB_T.finditer(line):
+            add(m.group(1), err)
+        for m in RE_WEB_VUE_T.finditer(line):
+            add(m.group(1), err)
+        if RE_WEB_T_DYN.search(line):
+            add("(dynamic: t(...))", err, dyn=True)
+        if RE_WEB_VUE_T_DYN.search(line):
+            add("(dynamic: $t(...))", err, dyn=True)
+        return
+
+    # iOS / Kotlin source
+    for m in RE_LSK.finditer(line):
+        add(m.group(1), err)
+    for m in RE_LITERAL_LOCALIZED.finditer(line):
+        add(m.group(1), err)
+    for m in RE_R_STRING.finditer(line):
+        add(m.group(1), err)
+
+    # dynamic constructions  -  record the expression, not a resolvable key
+    if RE_LSK_DYN.search(line):
+        add("(dynamic: LocalizationStringKey(...))", err, dyn=True)
+    if RE_STRING_FORMAT.search(line) and (".localized" in line or "LocalizationStringKey" in line):
+        add("(dynamic: String(format:...))", err, dyn=True)
+    if RE_GETSTRING_DYN.search(line) and "R.string." not in line:
+        add("(dynamic: getString(var))", err, dyn=True)
+    # variable .localized receiver (not a string literal, not the iOS key enum)
+    for m in RE_VAR_LOCALIZED.finditer(line):
+        recv = m.group(1)
+        if recv.startswith("LocalizationStringKey"):
+            continue
+        add(f"(dynamic: {recv}.localized)", err, dyn=True)
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--screen-path", required=True,
+                    help="dir (or file) of the implemented screen to scan")
+    ap.add_argument("--out", help="write JSON here (default: stdout)")
+    ap.add_argument("--category", choices=["all", "error", "dynamic", "static"], default="all",
+                    help="filter the emitted keys (default all)")
+    args = ap.parse_args()
+
+    root = args.screen_path
+    if not os.path.exists(root):
+        ap.error(f"--screen-path not found: {root}")
+
+    files = []
+    if os.path.isfile(root):
+        files = [root]
+    else:
+        for dirpath, _dirs, names in os.walk(root):
+            if "/.git" in dirpath or "/Generated/" in dirpath:
+                continue
+            for n in names:
+                if n.endswith(EXTS):
+                    files.append(os.path.join(dirpath, n))
+
+    out, seen = [], set()
+    for path in sorted(files):
+        try:
+            with open(path, encoding="utf-8", errors="replace") as fh:
+                for i, line in enumerate(fh, 1):
+                    scan_line(path, i, line, out, seen)
+        except OSError:
+            continue
+
+    if args.category != "all":
+        out = [k for k in out if k["category"] == args.category]
+    out.sort(key=lambda k: (k["category"], k["file"], k["line"]))
+
+    counts = {c: sum(1 for k in out if k["category"] == c) for c in ("static", "error", "dynamic")}
+    result = {"screenPath": root, "filesScanned": len(files), "counts": counts, "keys": out}
+
+    text = json.dumps(result, ensure_ascii=False, indent=2)
+    if args.out:
+        with open(args.out, "w", encoding="utf-8") as fh:
+            fh.write(text + "\n")
+    else:
+        sys.stdout.write(text + "\n")
+    sys.stderr.write(f"# scanned {len(files)} file(s): "
+                     f"{counts['static']} static · {counts['error']} error · "
+                     f"{counts['dynamic']} dynamic\n")
+
+
+if __name__ == "__main__":
+    main()

package/pipeline/skills/shared/external/localization-reuse-map/scripts/snapshot-resources.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Snapshot the redesign resources (component registry + Suggested translations) from
+# the resources repo into specs/resources, so the localization
+# mapper reads everything from one repo (like design-export). Generated, not authored  -  
+# refresh from resources; never hand-edit the snapshot. See reference/publish-and-snapshot.md.
+#
+# Usage: snapshot-resources.sh <resources-root> <specs-root>
+set -euo pipefail
+
+SRC="${1:?resources root}"; DST="${2:?specs root}"
+REG_SRC="$SRC/Resources/Figma/Components"
+SUG_SRC="$SRC/Resources/Localization/LocalizationStrings/Sources/Suggested"
+REG_DST="$DST/resources/Figma/Components"
+SUG_DST="$DST/resources/Localization/Suggested"
+
+for d in "$REG_SRC" "$SUG_SRC"; do
+  [ -d "$d" ] || { echo "missing source dir: $d" >&2; exit 1; }
+done
+mkdir -p "$REG_DST" "$SUG_DST"
+
+# --delete keeps the snapshot a faithful mirror (drops removed keys/components).
+rsync -a --delete "$REG_SRC/" "$REG_DST/"
+rsync -a --delete "$SUG_SRC/" "$SUG_DST/"
+
+echo "snapshot: $(ls "$REG_DST" | wc -l | tr -d ' ') components, $(ls "$SUG_DST" | wc -l | tr -d ' ') suggested keys"
+echo "→ $DST/resources  (commit like a design-export refresh)"