@mmerterden/multi-agent-pipeline 14.2.1 → 15.0.0

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.
+**205 skills** across 2 groups.
 
 | Group | Name | Platform | Description |
 |-------|------|----------|-------------|
@@ -79,11 +79,13 @@
 | external | `ios-debugger-agent` |  -  | Debug the current iOS project on a booted simulator with XcodeBuildMCP. Use when an iOS bug has to be reproduced and diagnosed on a booted s |
 | external | `ios-developer` |  -  | Develop native iOS applications with Swift/SwiftUI. Masters iOS 18, SwiftUI, UIKit integration, Core Data, networking, and App Store optimiz |
 | external | `ios-localization` |  -  | Implement, review, or improve localization and internationalization in iOS/macOS apps  -  String Catalogs (.xcstrings), generated localizabl |
+| external | `ios-module-structure` |  -  | The ios-module-structure rule registry: stable-ID rules over where a declaration lives, what its file is called and what its folder must con |
 | external | `ios-networking` |  -  | Build, review, or improve networking code in iOS/macOS apps using URLSession with async/await, structured concurrency, and modern Swift patt |
 | external | `ios-security` |  -  | Secure iOS apps with Keychain Services, CryptoKit encryption, biometric authentication (Face ID, Touch ID), Secure Enclave key storage, LACo |
 | 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 |
@@ -91,10 +93,11 @@
 | external | `monorepo-architect` |  -  | Expert in monorepo architecture, build systems, and dependency management at scale. Masters Nx, Turborepo, Bazel, and Lerna for efficient mu |
 | core | `multi-agent` |  -  | Task orchestrator: runs the full pipeline from a Jira ID or GitHub Issue URL  -  analysis → plan → TDD development → parallel review (Fable  |
 | core | `multi-agent-analysis` |  -  | Standalone feature-spec analysis (v3 template). Platform-agnostic concept layer with repo-driven convention extraction and per-platform Pass |
-| core | `multi-agent-analysis-resolve` |  -  | Resolve the Section 20 Risks and Open Questions of an analysis v3 document one row at a time. Proposes up to 3 source-labeled answer candida |
+| core | `multi-agent-analysis-resolve` |  -  | Resolve the Section 20 Risks and Open Questions of an analysis v3 document one row at a time: up to 3 source-labeled answer candidates per r |
 | core | `multi-agent-autopilot` |  -  | Launch any task in autopilot mode: skips every confirmation, runs end-to-end autonomously. Use when a task should run end to end with no con |
 | core | `multi-agent-build-optimize` |  -  | Wrapper that dispatches to xcode-build-orchestrator on iOS repos. Benchmarks the current Xcode build, runs compilation / project / SPM analy |
 | core | `multi-agent-channels` |  -  | Multi-channel reporter  -  Jira/Confluence/Wiki/PR description. Multi-select channels + content, humanizer pass, reviewer-preserving Bitbuck |
+| core | `multi-agent-complaint-analysis` |  -  | Customer-complaint triage. Ingests complaints (paste, csv/xlsx/txt/json file, Jira issue, Confluence URL), fetches Graylog evidence per trx/ |
 | core | `multi-agent-create-jira` |  -  | Create a standards-compliant Jira issue (Task / Bug / Story): asks the type, mines project conventions, drafts from a standard template with |
 | core | `multi-agent-design-check` |  -  | Mock-mode vs Figma design audit (iOS / Android, local-only). Pick repo + module, gate on mock support, enumerate every state driver into a c |
 | core | `multi-agent-dev` |  -  | Fast development mode: Init → Dev (Opus) → Review → Test → Commit → Report. Analysis and planning are skipped, review is not. Use when the w |
@@ -109,15 +112,17 @@
 | 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. |
 | core | `multi-agent-manual-test` |  -  | Switch to the active task's branch and prepare it for manual testing in Xcode. Phase 5 standalone (the UI Bug Hunter lives at multi-agent-te |
 | core | `multi-agent-prune-logs` |  -  | Delete per-task project logs under ~/.claude/logs/multi-agent (filter by age/project/task). Audit trail + metrics are preserved. Dry-run fir |
+| core | `multi-agent-prune-prompts` |  -  | Zero-base prompt review: measure the always-on instruction footprint, classify every rule block, propose keep/trial-removal/delete; applies  |
 | core | `multi-agent-purge` |  -  | ⚠️ Wipes every worktree, branch, log, and state file. Irreversible; asks for double confirmation. Use when every worktree, branch, log and s |
 | core | `multi-agent-refactor` |  -  | Analyse the project: extract adapted best-practices, hunt real bugs + improvement areas, check upstream drift of derived skills, research th |
 | core | `multi-agent-resume` |  -  | Resume a stopped or failed task from the phase where it left off. Use when a task stopped or failed and should carry on from where it left o |
+| core | `multi-agent-resume-local` |  -  | Continue already-done LOCAL work through the pipeline tail: Review → Build+Test → Commit/PR → Report (technical analysis + Jira test-scenari |
 | core | `multi-agent-review` |  -  | Run parallel review on a branch diff or a Pull Request: 2 models on Claude Code (Fable + Sonnet), 3 models on Copilot CLI (GPT + Opus + Sonn |
 | core | `multi-agent-review-issue` |  -  | Assess whether a GitHub issue is ready for multi-agent development: fetch it, grade scope / acceptance criteria / repro / design / API / sta |
 | core | `multi-agent-review-jira` |  -  | Assess whether a Jira issue is ready for multi-agent development: fetch it, grade scope / acceptance criteria / repro / design / API / stack |
@@ -126,8 +131,7 @@
 | core | `multi-agent-scan` |  -  | Skill security scan: walks local skill directories against a tiered pattern catalog. Use when local skill directories need checking for unsa |
 | core | `multi-agent-search` |  -  | Log search across every agent-log.md with smart ranking and filters. Optional --semantic flag queries the per-repo triage corpus. Use when s |
 | core | `multi-agent-setup` |  -  | First-run setup wizard: keychain token discovery, Git Identity onboarding, and pipeline preparation. Use when the pipeline is being set up f |
-| core | `multi-agent-ship` |  -  | Continue already-done LOCAL work through the pipeline tail: Review → Build+Test → Commit/PR → Report (technical analysis + Jira test-scenari |
-| core | `multi-agent-stack` |  -  | Select the active stack for this repo by enabling the matching marketplace plugin(s) in .claude/settings.json (ios/android/mobile/backend/fr |
+| core | `multi-agent-stack` |  -  | Select the active stack(s) for this repo by enabling the matching marketplace plugin(s) in .claude/settings.json. Multi-select: pass several |
 | core | `multi-agent-status` |  -  | Show every multi-agent task's ID, phase, branch, and status. Use when asked what is running, or for an overview of every task. |
 | core | `multi-agent-store-ready` |  -  | Pre-submission store readiness for a built package, iOS and Android, local-only. Three symmetric gates per platform: a static package audit, |
 | core | `multi-agent-sync` |  -  | One-shot sync of the entire multi-agent ecosystem: Claude Code, Copilot CLI, pipeline repo, website, and the dev-toolkit MCP server. Use whe |