@mmerterden/multi-agent-pipeline 14.2.1 → 14.2.2

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

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""Fidelity check  -  cross-verify a mapping against the REAL sources before publishing.
+
+The map can drift from reality (stale keys parsed from an old doc, hallucinated keys,
+a wired key that never made it into a row, an empty value). This script reconciles the
+mapping JSON against the live repos and reports what doesn't hold up  -  so the page you
+publish reflects the code, not a guess. Read-only.
+
+Checks (each reported, never auto-fixed):
+  1. newKey ∈ screen code  -  every row's `newKey` should appear as a wired
+     `LocalizationStringKey.<...>` call site (or `"Key".localized`, or a web
+     `t('Key')` / `$t('Key')` i18n call) in --screen-path.
+     Component-owned keys (`(owned by ...)` / `(DS bileşen...)`) are exempt (they live in the
+     component, not the screen file) and listed separately.
+  2. code keys ∉ map  -  `LocalizationStringKey.<...>` wired in the screen but with no
+     row → missing coverage (add a row or confirm it's out of scope).
+  3. value gaps  -  `new.tr` empty (verdict≠new), or legacy entirely empty where
+     the verdict claims reuse/review.
+  4. untranslated  -  a row whose `new.tr` == `new.en` (flag, as the renderer does).
+  5. resources (optional)  -  with --resources-root, the new key's Suggested/<Key>.json exists.
+
+Exit code 2 when any hard fidelity issue is found (unverified non-component key, code key
+missing from the map, or a reuse/review row with no legacy value), so it can gate a run.
+"""
+import argparse
+import json
+import os
+import re
+import sys
+
+EXTS = (".swift", ".kt", ".kts", ".xml", ".ts", ".tsx", ".js", ".jsx", ".vue")
+RE_LSK = re.compile(r"LocalizationStringKey\.([A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)+)")
+RE_LITERAL = re.compile(r'"([A-Za-z0-9_.]+)"\s*\.\s*localized')
+# Web (react-i18next / next-intl `t('key')`; vue-i18n `$t('key')`)
+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_LSK is greedy across dots, so `...StringKey.Ns.leaf.localized` captures the accessor
+# too. Strip it, or no call site ever matches its mapping row and every wired key is
+# reported unmapped.
+RE_ACCESSOR = re.compile(r"\.localized\w*$")
+MARKER = re.compile(r"\(.*(owned by|bileşen|component).*\)", re.I)
+
+
+def clean_key(k):
+    """Strip a trailing '(owned by ...)' / '(DS bileşene ait)' marker → bare dotted key."""
+    return re.sub(r"\s*\(.*\)\s*$", "", (k or "")).strip()
+
+
+def is_component(k):
+    return bool(MARKER.search(k or ""))
+
+
+def norm_key(k):
+    return clean_key(k).lower()
+
+
+def scan_code(screen_path):
+    """Return (set of wired dotted keys lowercased, full lowercased corpus text)."""
+    keys, corpus = set(), []
+    files = []
+    if os.path.isfile(screen_path):
+        files = [screen_path]
+    else:
+        for dp, _d, names in os.walk(screen_path):
+            if "/.git" in dp:
+                continue
+            files += [os.path.join(dp, n) for n in names if n.endswith(EXTS)]
+    for f in files:
+        try:
+            txt = open(f, encoding="utf-8", errors="replace").read()
+        except OSError:
+            continue
+        corpus.append(txt.lower())
+        for m in RE_LSK.finditer(txt):
+            keys.add(RE_ACCESSOR.sub("", m.group(1)).lower())
+        for m in RE_LITERAL.finditer(txt):
+            keys.add(m.group(1).lower())
+        for m in RE_WEB_T.finditer(txt):
+            keys.add(m.group(1).lower())
+        for m in RE_WEB_VUE_T.finditer(txt):
+            keys.add(m.group(1).lower())
+    return keys, "\n".join(corpus), len(files)
+
+
+def leaf_in_corpus(key, corpus):
+    """Weak check: the key's last segment appears as a word in the code corpus."""
+    leaf = clean_key(key).split(".")[-1]
+    return bool(leaf) and re.search(r"\b" + re.escape(leaf.lower()) + r"\b", corpus) is not None
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--mapping", required=True)
+    ap.add_argument("--screen-path", required=True, help="implemented screen dir/file")
+    ap.add_argument("--resources-root", help="resources / snapshot root (checks Suggested/<Key>.json)")
+    ap.add_argument("--out", help="write the full report JSON here (default: stdout summary only)")
+    args = ap.parse_args()
+
+    m = json.load(open(args.mapping, encoding="utf-8"))
+    rows = m.get("rows", [])
+    code_keys, corpus, nfiles = scan_code(args.screen_path)
+
+    verified, weak, unverified, component = [], [], [], []
+    value_gaps, untranslated = [], []
+    map_keys = set()
+
+    for r in rows:
+        k = r.get("newKey", "")
+        ck = clean_key(k)
+        map_keys.add(norm_key(k))
+        # 1. newKey in code
+        if is_component(k) or k.startswith("(dynamic") or "dinamik" in (r.get("element", "").lower()):
+            component.append(k)
+        elif norm_key(k) in code_keys:
+            verified.append(k)
+        elif leaf_in_corpus(k, corpus):
+            weak.append(k)
+        else:
+            unverified.append({"key": k, "element": r.get("element")})
+        # 3. value gaps
+        nw, lg, vd = r.get("new") or {}, r.get("legacy") or {}, r.get("verdict")
+        if vd != "new" and not (nw.get("tr") or "").strip() and not k.startswith("(dynamic"):
+            value_gaps.append({"key": k, "issue": "new.tr empty"})
+        if vd in ("reuse", "review") and not any((lg.get(l) or "").strip() for l in ("en", "tr")):
+            value_gaps.append({"key": k, "issue": f"verdict={vd} but no legacy value"})
+        # 4. untranslated
+        if (nw.get("tr") or "").strip() and nw.get("tr") == nw.get("en"):
+            untranslated.append(k)
+        # 5. resources
+        if args.resources_root and not is_component(k) and not k.startswith("(dynamic"):
+            seg = ".".join(s[:1].upper() + s[1:] if s else s for s in ck.split("."))
+            p1 = os.path.join(args.resources_root, "Localization", "Suggested", seg + ".json")
+            p2 = os.path.join(args.resources_root, "Resources", "Localization",
+                              "LocalizationStrings", "Sources", "Suggested", seg + ".json")
+            if not (os.path.isfile(p1) or os.path.isfile(p2)):
+                value_gaps.append({"key": k, "issue": "no Suggested/<Key>.json"})
+
+    # 2. code keys not in map
+    code_not_mapped = sorted(k for k in code_keys if k not in map_keys)
+
+    report = {
+        "screen": m.get("screen"), "rows": len(rows), "filesScanned": nfiles,
+        "newKeyInCode": {"verified": len(verified), "weak": weak,
+                         "unverified": unverified, "component_or_dynamic": len(component)},
+        "codeKeysNotInMap": code_not_mapped,
+        "valueGaps": value_gaps, "untranslated": untranslated,
+    }
+    hard = len(unverified) + len(code_not_mapped) + sum(1 for g in value_gaps if "no legacy" in g["issue"])
+
+    if args.out:
+        with open(args.out, "w", encoding="utf-8") as fh:
+            json.dump(report, fh, ensure_ascii=False, indent=2)
+            fh.write("\n")
+    # summary to stderr (always)
+    sys.stderr.write(
+        f"# fidelity: {len(rows)} rows · {nfiles} files\n"
+        f"#   newKey in code: {len(verified)} verified · {len(weak)} weak(leaf) · "
+        f"{len(unverified)} UNVERIFIED · {len(component)} component/dynamic (exempt)\n"
+        f"#   code keys not in map: {len(code_not_mapped)}\n"
+        f"#   value gaps: {len(value_gaps)} · untranslated(tr==en): {len(untranslated)}\n")
+    if unverified:
+        sys.stderr.write("#   UNVERIFIED keys: " + ", ".join(u["key"] for u in unverified[:12]) + "\n")
+    if code_not_mapped:
+        sys.stderr.write("#   wired-but-unmapped: " + ", ".join(code_not_mapped[:12]) + "\n")
+    if not args.out:
+        json.dump(report, sys.stdout, ensure_ascii=False, indent=2)
+        sys.stdout.write("\n")
+    sys.exit(2 if hard else 0)
+
+
+if __name__ == "__main__":
+    main()

package/pipeline/skills/skills-index.md

@@ -3,7 +3,7 @@
 > Auto-generated by `pipeline/scripts/build-skills-index.mjs`  -  do not hand-edit.
 > Regenerate with `node pipeline/scripts/build-skills-index.mjs`.
 
-**201 skills** across 2 groups.
+**202 skills** across 2 groups.
 
 | Group | Name | Platform | Description |
 |-------|------|----------|-------------|
@@ -84,6 +84,7 @@
 | external | `ios-simulator` |  -  | Manages iOS Simulator devices and tests app behaviour with xcrun simctl: device lifecycle, app install and launch, push notification and loc |
 | external | `kotlin-coroutines-expert` |  -  | Expert patterns for Kotlin Coroutines and Flow, covering structured concurrency, error handling, and testing. Use when writing or reviewing  |
 | external | `live-activities` |  -  | Implement, review, or improve Live Activities and Dynamic Island experiences in iOS apps using ActivityKit. Use when building real-time upda |
+| external | `localization-reuse-map` |  -  | >- |
 | external | `macos-menubar-tuist-app` |  -  | Build, refactor, or review SwiftUI macOS menubar apps that use Tuist. Use when building, refactoring or reviewing a SwiftUI macOS menubar ap |
 | external | `macos-spm-app-packaging` |  -  | Scaffold, build, sign, and package SwiftPM macOS apps without Xcode projects. Use when a SwiftPM macOS app has to be built, signed or packag |
 | external | `mapkit-location` |  -  | Implement, review, or improve maps and location features in iOS/macOS apps using MapKit and CoreLocation. Use when working with Map views, a |
@@ -109,7 +110,7 @@
 | core | `multi-agent-issue` |  -  | List unassigned GitHub issues, pick one, auto-assign, and launch the multi-agent pipeline. Use when a GitHub issue should be picked up and s |
 | core | `multi-agent-jira` |  -  | List open Jira issues, pick one, and launch the multi-agent pipeline. Use when a Jira issue should be picked up and started without knowing  |
 | core | `multi-agent-kill` |  -  | Stop the given task, then remove its worktree and branch. Asks for confirmation. Use when a running or stuck task should be stopped and its  |
-| core | `multi-agent-language` |  -  | Toggle outputLanguage (assistant explanations). promptLanguage is fixed to English. External payloads stay English. Use when the assistant s |
+| core | `multi-agent-language` |  -  | Toggle outputLanguage (assistant explanations, picker questions, PR/Jira/Confluence bodies). promptLanguage is fixed to English; commit mess |
 | core | `multi-agent-local` |  -  | Full pipeline in local mode  -  no worktree, runs directly on the current branch. Use when the full pipeline should run on the current branc |
 | core | `multi-agent-local-autopilot` |  -  | Full pipeline + local + autopilot  -  no worktree, no confirmations, all 8 phases run end-to-end on the current branch. Use when the full pi |
 | core | `multi-agent-log` |  -  | Show the agent-log.md for the given task. With no ID, shows the most recent task. Use when asked what a task did, or to read its log. |