cg-code-graph 0.23.7__tar.gz → 0.23.8__tar.gz

{cg_code_graph-0.23.7/cg_code_graph.egg-info → cg_code_graph-0.23.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.7
+Version: 0.23.8
 Summary: cg: a code graph of routes, calls, data access and platform boundaries for agents and humans (CLI + MCP server)
 Author: cyberchronos00
 License-Expression: MIT

{cg_code_graph-0.23.7 → cg_code_graph-0.23.8}/cg_code_graph/__init__.py

@@ -1,2 +1,2 @@
 """code-graph: deterministic code knowledge graph (beta)."""
-__version__ = "0.23.7"
+__version__ = "0.23.8"

{cg_code_graph-0.23.7 → cg_code_graph-0.23.8}/cg_code_graph/cli.py

@@ -301,9 +301,12 @@ def main(argv=None):
     p.add_argument("--strip-prefix", action="append", default=[], help="a name prefix one side adds (`Vault` in "
                    "VaultAddEditState for AddEditState), ignored when matching (repeatable)")
     p.add_argument("--structure", action="store_true", help="also pair symbols whose names differ by what they use: "
-                   "shared strings, localization keys, endpoints and already-paired callees, plus rename rules learned "
-                   "from the pairs found (#93); matches carry their evidence")
+                   "shared strings, localization keys, resources, endpoints and already-paired callees, then types by "
+                   "their declared fields, plus rename rules learned from the pairs found (#93); matches carry their "
+                   "evidence")
     p.add_argument("--no-learn", action="store_true", help="with --structure: no learned rename rules")
+    p.add_argument("--both-sides", action="store_true", help="also list the matched pairs and what only --against "
+                   "has (target symbols no source symbol matched)")
     p.add_argument("--write-map", help="with --structure: write the inferred pairs as a --map JSON file to review")
     p.add_argument("--json", action="store_true"); p.add_argument("--max-items", type=int, default=200)
     p = sub.add_parser("lint", help="heuristic lints (#88): `lint async-state` flags stale async results, state with "
@@ -574,7 +577,7 @@ def main(argv=None):
         from . import parity as PA
         mapping = json.loads(open(a.map, encoding="utf-8").read()) if a.map else None
         res = PA.parity(a.db, a.against, mapping=mapping, fuzzy=not a.no_fuzzy, strip_prefixes=a.strip_prefix,
-                        structure=a.structure, learn=not a.no_learn)
+                        structure=a.structure, learn=not a.no_learn, both_sides=a.both_sides)
         if a.write_map:
             with open(a.write_map, "w", encoding="utf-8") as fh:
                 json.dump(PA.rename_map(res), fh, indent=1, sort_keys=True)

{cg_code_graph-0.23.7 → cg_code_graph-0.23.8}/cg_code_graph/parity.py

@@ -220,21 +220,27 @@ def _cat(sym: dict, is_type: bool) -> str:
     return "type" if is_type else "const" if sym["kind"] in ("constant", "enum_case") else "func"
 
 
+INFERRED = ("structure", "fields", "learned")
+PREVIEW_NAME = re.compile(r"Preview")
+
+
 def parity(source_db: str, target_db: str, mapping: dict | None = None, fuzzy: bool = True,
-           strip_prefixes: list[str] | None = None, structure: bool = False, learn: bool = True) -> dict:
+           strip_prefixes: list[str] | None = None, structure: bool = False, learn: bool = True,
+           both_sides: bool = False) -> dict:
     """See the module docstring. `strip_prefixes`: name prefixes one side adds (`Vault` in `VaultAddEditState`
     for `AddEditState`), dropped before normalized matching on both sides. `structure` (#93): after the name rules,
     pair the rest by shared strings, localization keys, endpoints and paired callees, and (`learn`) apply rename
-    rules learned from the pairs found (cg_code_graph/parity_structure.py); off, the output is the name matching alone."""
+    rules learned from the pairs found (cg_code_graph/parity_structure.py); off, the output is the name matching alone.
+    `both_sides`: also list what only the target has (`target_only`)."""
     _PREFIXES[:] = [p.lower() for p in strip_prefixes or ()]
     try:
-        return _parity(source_db, target_db, mapping, fuzzy, structure, learn)
+        return _parity(source_db, target_db, mapping, fuzzy, structure, learn, both_sides)
     finally:
         _PREFIXES.clear()
 
 
 def _parity(source_db: str, target_db: str, mapping: dict | None, fuzzy: bool, structure: bool = False,
-            learn: bool = True) -> dict:
+            learn: bool = True, both_sides: bool = False) -> dict:
     S, T = load(source_db), load(target_db)
     mapping = mapping or {}
     exact_ix, norm_ix, comp_ix, all_short = defaultdict(list), defaultdict(list), defaultdict(list), defaultdict(list)
@@ -357,7 +363,7 @@ def _parity(source_db: str, target_db: str, mapping: dict | None, fuzzy: bool, s
                 tm.setdefault(_short(nt), T["types"][nt])
             tm_norm = {norm_member(k): k for k in tm}
             for nm, sym in sorted(S["members"].get(sfq, {}).items()):
-                if nm in ("body", "init", "deinit", "hash", "description", "encode", "hashValue") or sym["override"]:
+                if nm in BOILERPLATE or sym["override"]:
                     out["skipped"] += 1          # lifecycle / platform overrides (viewDidLoad, onCreate) and boilerplate
                     continue
                 if nm in tm:
@@ -375,7 +381,7 @@ def _parity(source_db: str, target_db: str, mapping: dict | None, fuzzy: bool, s
     match_members(tmap)
     if structure:
         _structure(S, T, out, tmap, learn)
-        inferred = {r["symbol"]: r["target"] for r in out["matched"] if r.get("confidence") in ("structure", "learned")
+        inferred = {r["symbol"]: r["target"] for r in out["matched"] if r.get("confidence") in INFERRED
                     and r["symbol"] in S["types"] and r["target"] in T["types"]}
         match_members(inferred)
     counts = defaultdict(int)
@@ -387,10 +393,44 @@ def _parity(source_db: str, target_db: str, mapping: dict | None, fuzzy: bool, s
                       "missing": len(out["missing"]), "unknown": len(out["unknown"]),
                       "platform_only": len(out["platform_only"])}
     if structure:
-        out["summary"]["inferred"] = sum(1 for r in out["matched"] if r["confidence"] in ("structure", "learned"))
+        out["summary"]["inferred"] = sum(1 for r in out["matched"] if r["confidence"] in INFERRED)
+    if both_sides:
+        _target_only(T, out, t_nested)
+        out["summary"]["target_only"] = len(out["target_only"])
     return out
 
 
+BOILERPLATE = ("body", "init", "deinit", "hash", "description", "encode", "hashValue")
+
+
+def _target_only(T, out, t_nested):
+    """`--both-sides`: target types and top-level symbols no source symbol matched, and the unmatched members of
+    target types that were matched. Members of an unmatched type are counted under it, not listed."""
+    used = {r["target"] for r in out["matched"]}
+    rows, hidden = [], 0
+    for coll in (T["types"], T["top"]):
+        for fq, sym in sorted(coll.items()):
+            if fq in used:
+                continue
+            owner = fq.rsplit(".", 1)[0] if "." in fq else None
+            if owner in T["types"] and owner not in used:
+                continue                       # a nested type of an unmatched type: the type is listed
+            if PREVIEW_NAME.search(_short(fq)) or sym["file"] in T["err_files"]:
+                hidden += 1
+                continue
+            rows.append(_row(sym, None, None))
+    for o in sorted(o for o in T["members"] if o in used):
+        for nm, sym in sorted(T["members"][o].items()):
+            if f"{o}.{nm}" in used:
+                continue
+            if nm in BOILERPLATE or sym["override"] or sym["file"] in T["err_files"]:
+                hidden += 1
+                continue
+            rows.append(_row(sym, None, None))
+    out["target_only"] = rows
+    out["target_only_hidden"] = hidden
+
+
 def _structure(S, T, out, tmap, learn):
     from . import parity_structure as PS
     sym_of, cat_of, t_syms, t_cat = {}, {}, {}, {}
@@ -409,7 +449,7 @@ def _structure(S, T, out, tmap, learn):
 
 def rename_map(res: dict) -> dict:
     """The structure / learned matches as a `--map` file ({source: target}) to review and commit."""
-    return {r["symbol"]: r["target"] for r in res["matched"] if r.get("confidence") in ("structure", "learned")}
+    return {r["symbol"]: r["target"] for r in res["matched"] if r.get("confidence") in INFERRED}
 
 
 def _row(sym, target, how, owner_match=None) -> dict:
@@ -435,6 +475,25 @@ def _group(file: str) -> str:
     return "/".join(parts[:2]) if len(parts) > 2 else (parts[0] if parts else "")
 
 
+def _grouped(lines, title, rows, total, max_items):
+    by = defaultdict(list)
+    for r in rows:
+        by[r["module"]].append(r)
+    if not by:
+        return
+    lines += ["", f"== {title}: {total}"]
+    shown = 0
+    for mod in sorted(by, key=lambda k: -len(by[k])):
+        lines.append(f"  {mod or '.'}  ({len(by[mod])})")
+        for r in by[mod]:
+            if shown >= max_items:
+                break
+            shown += 1
+            lines.append(f"    {r['symbol']}  [{r['kind']}] {r['file']}:{r['line']}")
+    if shown < total:
+        lines.append(f"  ... {total - shown} more (--json for all)")
+
+
 def render(res: dict, max_items: int = 200) -> str:
     s = res["summary"]
     m = s["matched"]
@@ -457,7 +516,14 @@ def render(res: dict, max_items: int = 200) -> str:
                 lines.append(f"    {r['symbol']}  [{r['kind']}] {r['file']}:{r['line']}")
         if shown < s["missing"]:
             lines.append(f"  ... {s['missing'] - shown} more (--json for all)")
-    inferred = [r for r in res["matched"] if r.get("confidence") in ("structure", "learned")]
+    if "target_only" in res:
+        lines[1] += f"; {s['target_only']} only in the target"
+        lines += ["", f"== MATCHED pairs: {sum(m.values())}"]
+        for r in sorted(res["matched"], key=lambda r: (r["confidence"] != "explicit", r["symbol"]))[:max_items]:
+            lines.append(f"    {r['symbol']} -> {r['target']}  [{r['confidence']}]")
+        if sum(m.values()) > max_items:
+            lines.append(f"  ... {sum(m.values()) - max_items} more (--json for all)")
+    inferred = [r for r in res["matched"] if r.get("confidence") in INFERRED]
     if inferred:
         lines += ["", f"== INFERRED matches (not by name): {len(inferred)}"]
         for r in inferred[:max_items]:
@@ -467,6 +533,8 @@ def render(res: dict, max_items: int = 200) -> str:
         if rule is (res.get("learned_rules") or [None])[0]:
             lines += ["", "== LEARNED rename rules"]
         lines.append(f"    {rule['at']}: {rule['from']!r} -> {rule['to']!r} (seen {rule['support']}x)")
+    if "target_only" in res:
+        _grouped(lines, "ONLY IN TARGET (no source counterpart)", res["target_only"], s["target_only"], max_items)
     if res["unknown"]:
         lines += ["", f"== UNKNOWN (file parsed with syntax errors): {s['unknown']}"]
         lines += [f"    {r['symbol']}  {r['file']}:{r['line']}" for r in res["unknown"][:max_items]]

{cg_code_graph-0.23.7 → cg_code_graph-0.23.8}/cg_code_graph/parity_structure.py

@@ -11,8 +11,21 @@ its outgoing edges:
   sym:<target> symbols it calls / instantiates / navigates to that are already paired (the source side is
                rewritten to the target's name, so a call to a paired API on both sides is a shared feature)
   call:<name>  the names of the members it calls (two words or more)
+  res:<name>   image and raw resources it uses (`Image("ic_lock")`, `UIImage(named:)`, `Asset.Images.icLock`,
+               `Image(.icLock)`, `R.drawable.ic_lock`, `Res.drawable.x`), case and `_` folded; colors are design
+               tokens shared by every screen and are left out
   w:<stem>     the stemmed content words of its own name
 
+A use is specific when it appears in at most SPECIFIC_FILES files on each side (files, not symbols, since a type's span
+holds its members'); a pair whose shared uses are all generic needs two shared name words, so two screens that only
+share `l10n:cancel` / `l10n:yes` and one word do not pair.
+
+Types that are still missing after that are paired by their declared fields (`fields`): stored properties, each under
+its wire name when one is declared (Swift `CodingKeys` raw values, Kotlin `@SerialName` / `@SerializedName` /
+`@Json(name =)`), and enum cases, kept apart from properties; case and `_` folded. A pair needs MIN_FIELDS shared
+fields, an IDF-weighted overlap of at least MIN_FIELD_SCORE, a shared name word or a higher overlap, mutual best and
+the margin.
+
 A pair is accepted when it shares a use (any feature but w:) and either two uses or two name words, its IDF-weighted
 cosine is at least MIN_SCORE, both symbols are each other's best candidate, the runner-up scores below MARGIN times
 the best, and category, UI-ness and architecture role agree (`compatible`). Learned rules come from the
@@ -21,6 +34,7 @@ MIN_SUPPORT times, two thirds of the time for that source tail, is applied to th
 top-level symbols. Every match carries its evidence; name matches are left as they are."""
 from __future__ import annotations
 
+import json
 import math
 import re
 import sqlite3
@@ -32,9 +46,16 @@ MIN_SHARED = 2
 MARGIN = 0.8                 # the runner-up must score below MARGIN * best
 MIN_SUPPORT = 2
 MAX_DF = 40
+SPECIFIC_FILES = 3           # a shared use found in more files than this on either side is generic (`l10n:cancel`)
+MIN_FIELDS = 3
+MIN_FIELD_SCORE = 0.5
 PREVIEW = re.compile(r"Preview")           # Compose @Preview functions / PreviewParameterProviders, SwiftUI previews                  # features shared by more symbols than this do not propose candidates
 L10N = re.compile(r"\b(?:Localizations|L10n|R\.string|BitwardenString|CommonStrings|[A-Z]\w*Strings)\.([A-Za-z_]\w*)")
 STR = re.compile(r'"((?:[^"\\\n]|\\.){5,80})"')
+RES = re.compile(r"""\b(?:UI|NS)?Image\(\s*(?:named:\s*)?"([^"\n]+)"|\bAsset\.(?:Images|Assets)\.(\w+)|"""
+                 r"""\bImage\(\s*\.(\w+)\s*\)|\b(?:R|Res)\.(?:drawable|mipmap|raw)\.(\w+)""")
+WIRE = re.compile(r'@(?:SerialName|SerializedName|JsonProperty|Json\(\s*name\s*=)\s*\(?\s*(?:value\s*=\s*)?"([^"\n]+)"')
+RAW_CASE = re.compile(r'\bcase\s+`?(\w+)`?\s*=\s*"([^"\n]+)"')
 EDGE_KINDS = ("CALLS", "INSTANTIATES", "NAVIGATES_TO", "HTTP_CALLS", "USES_VALUE", "REFERENCES_FN", "USES_TYPE")
 
 
@@ -123,8 +144,40 @@ class Side:
         for r in c.execute(q, EDGE_KINDS):
             self.out[r["src"]].append((r["dst"], r["kind"]))
         self.http = {r["id"]: (r["name"] or r["id"]) for r in c.execute("SELECT id, name FROM nodes WHERE kind='http'")}
+        self.decl = defaultdict(list)          # owner fqn -> [(name, kind, file, line)] of stored fields / enum cases
+        for r in c.execute("SELECT kind, fqn, file, line, attrs FROM nodes WHERE kind IN ('field', 'enum_case') "
+                           "AND fqn IS NOT NULL AND file IS NOT NULL"):
+            if ".Companion." in r["fqn"] or "." not in r["fqn"]:
+                continue
+            if r["kind"] == "field" and (json.loads(r["attrs"] or "{}").get("property") or "stored") != "stored":
+                continue
+            o, nm = r["fqn"].rsplit(".", 1)
+            self.decl[o].append((nm, r["kind"], r["file"], r["line"]))
         c.close()
 
+    def fields(self, fq: str) -> set:
+        """`field:<wire name>` for each stored property declared directly on the type: the explicit wire name
+        (`@SerialName("item_title")`, a `CodingKeys` case `title = "item_title"`) or else the property name; `case:<name>`
+        for each enum case, so an enum of field names does not meet the type that has those fields."""
+        raw = {}
+        for nm, kind, file, line in self.decl.get(fq + ".CodingKeys", ()):
+            m = RAW_CASE.search(self.text(file, line, line))
+            if m:
+                raw[m.group(1)] = m.group(2)
+        out = set()
+        for nm, kind, file, line in self.decl.get(fq, ()):
+            wire = raw.get(nm)
+            if not wire and kind == "field":
+                m = WIRE.search(self.text(file, line, line))
+                if not m and line > 1:            # an annotation on its own line above
+                    prev = self.text(file, line - 1, line - 1)
+                    m = None if re.search(r"\b(?:val|var|let)\s", prev) else WIRE.search(prev)
+                wire = m.group(1) if m else None
+            k = _fold(wire or nm)
+            if len(k) > 1:
+                out.add(("case:" if kind == "enum_case" else "field:") + k)
+        return out
+
     def text(self, file: str, a: int, b: int) -> str:
         if file not in self.lines:
             try:
@@ -139,6 +192,9 @@ class Side:
         if file and a:
             src = self.text(file, a, b)
             f |= {"l10n:" + _fold(m) for m in L10N.findall(src)}
+            for m in RES.finditer(src):
+                f.add("res:" + _fold(next(g for g in m.groups() if g)))
+            src = RES.sub(" ", src)
             for m in STR.findall(src):
                 s = m.strip().lstrip("/")
                 if len(s) >= 5 and re.search(r"[A-Za-z]{3}", s) and not re.search(r"\\\(|\$\{|%[@sd]", s):
@@ -250,6 +306,60 @@ def _apply_rules(rules, out, sym_of, cat_of, t_syms, t_cat, used):
     out["missing"] = keep
 
 
+def _by_fields(sS, sT, out, sym_of, cat_of, t_syms, t_cat, used, S, T):
+    """Types still missing, paired by the fields they declare (`ViewItemState` / `VaultItemState`, a Swift
+    `Codable` model and its Kotlin `@Serializable` port)."""
+    src = {r["symbol"]: sS.fields(r["symbol"]) for r in out["missing"] if cat_of.get(r["symbol"]) == "type"
+           and "owner_matched" not in r}
+    src = {k: v for k, v in src.items() if len(v) >= MIN_FIELDS and _short(k) != "CodingKeys"}
+    tgt = {fq: sT.fields(fq) for fq in t_syms if t_cat.get(fq) == "type" and fq not in used}
+    tgt = {k: v for k, v in tgt.items() if len(v) >= MIN_FIELDS and _short(k) != "CodingKeys"}
+    if not src or not tgt:
+        return
+    df = Counter()
+    for fs in list(src.values()) + list(tgt.values()):
+        df.update(fs)
+    n = len(src) + len(tgt)
+    w = {f: math.log(1 + n / c) for f, c in df.items()}
+    inv = defaultdict(list)
+    for fq, fs in tgt.items():
+        for f in fs:
+            inv[f].append(fq)
+
+    def score(fq, t):
+        a, b = src[fq], tgt[t]
+        sh = a & b
+        if len(sh) < MIN_FIELDS:
+            return 0.0, sh
+        sc = sum(w[f] for f in sh) / sum(w[f] for f in a | b)
+        words = name_words(fq) & name_words(t)
+        if sc < MIN_FIELD_SCORE or (not words and sc < 0.75):
+            return 0.0, sh
+        return sc, sh | words
+
+    best = {}
+    for fq, fs in src.items():
+        cands = {t for f in fs if df[f] <= MAX_DF for t in inv[f]
+                 if compatible(fq, "type", t, "type", S["_ui"].get(fq), T["_ui"].get(t))}
+        scored = sorted(((score(fq, t), t) for t in cands), key=lambda x: -x[0][0])
+        if scored and scored[0][0][0] > 0 and (len(scored) == 1 or scored[1][0][0] < MARGIN * scored[0][0][0]):
+            best[fq] = (scored[0][1], scored[0][0][0], scored[0][0][1])
+    by_t = defaultdict(list)
+    for fq, (t, sc, sh) in best.items():
+        by_t[t].append((sc, fq))
+    keep = []
+    for row in out["missing"]:
+        got = best.get(row["symbol"])
+        if got and max(by_t[got[0]])[1] == row["symbol"] and got[0] not in used:
+            t, sc, sh = got
+            used.add(t)
+            ev = sorted(sh, key=lambda f: (f.startswith("w:"), -w.get(f, 0), f))[:6]
+            out["matched"].append(dict(row, target=t, confidence="fields", score=round(sc, 2), evidence=ev))
+        else:
+            keep.append(row)
+    out["missing"] = keep
+
+
 def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
     sS, sT = Side(S), Side(T)
     pairs = {r["symbol"]: r["target"] for r in out["matched"]}
@@ -264,6 +374,12 @@ def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
     df = Counter()
     for fs in list(src_f.values()) + list(tgt_f.values()):
         df.update(fs)
+    spread = [defaultdict(set), defaultdict(set)]          # feature -> files having it, per side
+    for k, (fsets, syms) in enumerate(((src_f, sym_of), (tgt_f, t_syms))):
+        for fq, fs in fsets.items():
+            for f in fs:
+                spread[k][f].add(syms[fq]["file"])
+    specific = {f for f in df if len(spread[0][f]) <= SPECIFIC_FILES and len(spread[1][f]) <= SPECIFIC_FILES}
     n = max(1, len(src_f) + len(tgt_f))
     w = {f: math.log(1 + n / c) for f, c in df.items()}
     inv = defaultdict(list)
@@ -278,6 +394,8 @@ def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
         # what they use must carry the match: two shared uses, or one use and two shared name words
         if nw < 1 or (nw < MIN_SHARED and len(sh) - nw < 2):
             return 0.0, sh
+        if len(sh) - nw < 2 and not any(f in specific for f in sh if not f.startswith("w:")):
+            return 0.0, sh                      # only generic uses (`l10n:cancel`, `l10n:yes`) and one name word
         return sum(w[f] for f in sh) / math.sqrt(sum(w[f] for f in a) * sum(w[f] for f in b)), sh
 
     best_s = {}
@@ -305,3 +423,4 @@ def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
         else:
             keep.append(row)
     out["missing"] = keep
+    _by_fields(sS, sT, out, sym_of, cat_of, t_syms, t_cat, used, S, T)

{cg_code_graph-0.23.7 → cg_code_graph-0.23.8/cg_code_graph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.7
+Version: 0.23.8
 Summary: cg: a code graph of routes, calls, data access and platform boundaries for agents and humans (CLI + MCP server)
 Author: cyberchronos00
 License-Expression: MIT

{cg_code_graph-0.23.7 → cg_code_graph-0.23.8}/cg_code_graph.egg-info/SOURCES.txt

@@ -331,6 +331,7 @@ tests/test_nuxt_rootsrc.py
 tests/test_nuxt_side_dirs.py
 tests/test_packaging.py
 tests/test_parity.py
+tests/test_parity_fields.py
 tests/test_parity_structure.py
 tests/test_php_http.py
 tests/test_php_props.py

cg_code_graph-0.23.8/tests/test_parity_fields.py

@@ -0,0 +1,125 @@
+"""`cg parity --structure` part 2 (#93): types paired by their declared fields and wire names, views paired by the
+image resources they use, generic shared keys not enough, and `--both-sides` (matched pairs plus what only the
+target has). Invented app: a hiking app in Swift and its Kotlin port."""
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent))
+pytest.importorskip("tree_sitter_swift")
+pytest.importorskip("tree_sitter_kotlin")
+from test_parity import ROOT, build  # noqa: E402
+from cg_code_graph import parity as P  # noqa: E402
+from cg_code_graph import parity_structure as PS  # noqa: E402
+
+IOS = {
+ "Trails/Models/TrailSummaryResponse.swift":
+     "struct TrailSummaryResponse: Codable {\n    let trailId: String\n    let displayName: String\n"
+     "    let elevationGain: Int\n    let loopKind: String\n\n    enum CodingKeys: String, CodingKey {\n"
+     '        case trailId = "trail_id"\n        case displayName = "display_name"\n'
+     '        case elevationGain = "elevation_gain"\n        case loopKind = "loop_kind"\n    }\n}\n',
+ "Trails/Detail/HikeDetailState.swift":
+     "struct HikeDetailState {\n    var title: String = \"\"\n    var isFavorite = false\n    var distanceText = \"\"\n"
+     "    var difficulty = 0\n    var photoCount = 0\n}\n",
+ "Trails/Badges/BadgeShelfView.swift":
+     "import SwiftUI\n\nstruct BadgeShelfView: View {\n    var body: some View {\n        HStack {\n"
+     '            Image("badge_summit")\n            Image("badge_sunrise")\n        }\n    }\n}\n',
+ "Trails/Trip/HikeShareSheet.swift":
+     "import SwiftUI\n\nstruct HikeShareSheet: View {\n    var body: some View {\n        HStack {\n"
+     "            Text(Localizations.cancel)\n            Text(Localizations.yes)\n        }\n    }\n}\n",
+ "Trails/Settings/SettingsStore.swift":
+     "final class SettingsStore {\n    func reset() {}\n}\n",
+ "Trails/Widgets/LiveActivityWidget.swift":
+     'struct LiveActivityWidget {\n    func kind() -> String { "live-activity-hike" }\n}\n',
+}
+ANDROID = {
+ "app/src/main/java/com/trailmate/data/TrailOverviewJson.kt":
+     "package com.trailmate.data\n\n@Serializable\ndata class TrailOverviewJson(\n"
+     '    @SerialName("trail_id") val id: String,\n    @SerialName("display_name") val name: String,\n'
+     '    @SerialName("elevation_gain") val gain: Int,\n    @SerialName("loop_kind") val loop: String,\n)\n',
+ "app/src/main/java/com/trailmate/detail/RouteDetailViewState.kt":
+     "package com.trailmate.detail\n\ndata class RouteDetailViewState(\n    val title: String,\n"
+     "    val isFavorite: Boolean,\n    val distanceText: String,\n    val difficulty: Int,\n    val elevationText: String,\n)\n",
+ "app/src/main/java/com/trailmate/badges/AchievementRow.kt":
+     "package com.trailmate.badges\n\nimport androidx.compose.runtime.Composable\n\n@Composable\nfun AchievementRow() {\n"
+     "    Image(painterResource(R.drawable.badge_summit), null)\n    Image(painterResource(R.drawable.badge_sunrise), null)\n}\n",
+ "app/src/main/java/com/trailmate/trip/HikeDeleteDialog.kt":
+     "package com.trailmate.trip\n\nimport androidx.compose.runtime.Composable\n\n@Composable\nfun HikeDeleteDialog() {\n"
+     "    Text(stringResource(R.string.cancel))\n    Text(stringResource(R.string.yes))\n}\n",
+ # cancel / yes are on every prompt: generic keys
+ **{f"app/src/main/java/com/trailmate/common/{n}Prompt.kt":
+    f"package com.trailmate.common\n\nclass {n}Prompt {{\n    fun confirm{n}() {{\n        show(R.string.cancel)\n"
+    f"        show(R.string.yes)\n    }}\n}}\n" for n in ("Exit", "Logout", "Unfollow", "Archive")},
+ "app/src/main/java/com/trailmate/settings/SettingsStore.kt":
+     "package com.trailmate.settings\n\nclass SettingsStore {\n    fun reset() {}\n    fun exportBackup() {}\n}\n",
+ "app/src/main/java/com/trailmate/wear/WearTileService.kt":
+     "package com.trailmate.wear\n\nclass WearTileService {\n    fun onTileRequest() {}\n}\n",
+}
+
+
+@pytest.fixture(scope="module")
+def dbs():
+    return build(IOS, "fios"), build(ANDROID, "fandroid")
+
+
+def test_default_output_unchanged(dbs):
+    res = P.parity(*dbs)
+    assert "target_only" not in res and "inferred" not in res["summary"]
+    assert not [r for r in res["matched"] if r["confidence"] in P.INFERRED]
+
+
+def test_fields_resources_and_generic_keys(dbs):
+    res = P.parity(*dbs, structure=True)
+    m = {r["symbol"]: r for r in res["matched"]}
+    # wire names: CodingKeys raw values meet @SerialName, although every property is renamed
+    t = m["TrailSummaryResponse"]
+    assert t["target"] == "com.trailmate.data.TrailOverviewJson", t
+    assert {"str:trail_id", "field:trailid"} & set(t["evidence"]), t
+    # screen state by its stored properties
+    h = m["HikeDetailState"]
+    assert h["target"] == "com.trailmate.detail.RouteDetailViewState" and h["confidence"] == "fields", h
+    # image resources: Image("badge_summit") / R.drawable.badge_summit
+    b = m["BadgeShelfView"]
+    assert b["target"] == "com.trailmate.badges.AchievementRow" and b["confidence"] == "structure", b
+    assert "res:badgesummit" in b["evidence"]
+    # only generic keys (cancel / yes on every prompt) in common: no match
+    missing = {r["symbol"] for r in res["missing"]}
+    assert "HikeShareSheet" in missing and "LiveActivityWidget" in missing, missing
+
+
+def test_generic_guard_is_what_keeps_them_apart(dbs, monkeypatch):
+    monkeypatch.setattr(PS, "SPECIFIC_FILES", 10 ** 6)
+    m = {r["symbol"]: r["target"] for r in P.parity(*dbs, structure=True)["matched"]}
+    # one name word and two generic keys in common: IDF alone would pair a share sheet with a delete dialog
+    assert m.get("HikeShareSheet") == "com.trailmate.trip.HikeDeleteDialog"
+
+
+def test_both_sides(dbs):
+    res = P.parity(*dbs, structure=True, both_sides=True)
+    only = {r["symbol"] for r in res["target_only"]}
+    assert "com.trailmate.wear.WearTileService" in only
+    assert "com.trailmate.settings.SettingsStore.exportBackup" in only      # member of a matched type
+    assert "com.trailmate.wear.WearTileService.onTileRequest" not in only   # counted under its type
+    assert "com.trailmate.data.TrailOverviewJson" not in only
+    assert res["summary"]["target_only"] == len(res["target_only"])
+
+
+def test_cli_both_sides(dbs):
+    r = subprocess.run([sys.executable, "-m", "cg_code_graph.cli", "parity", "--db", dbs[0], "--against", dbs[1],
+                        "--structure", "--both-sides"], capture_output=True, text=True, cwd=ROOT)
+    assert r.returncode == 0, r.stderr
+    assert "== MATCHED pairs:" in r.stdout and "== ONLY IN TARGET (no source counterpart):" in r.stdout
+    assert "SettingsStore -> com.trailmate.settings.SettingsStore  [exact]" in r.stdout
+    assert "[fields" in r.stdout
+    j = json.loads(subprocess.run([sys.executable, "-m", "cg_code_graph.cli", "parity", "--db", dbs[0], "--against",
+                                   dbs[1], "--both-sides", "--json"], capture_output=True, text=True, cwd=ROOT).stdout)
+    assert "target_only" in j and "inferred" not in j["summary"]
+
+
+def test_wire_names(dbs):
+    want = {"field:trailid", "field:displayname", "field:elevationgain", "field:loopkind"}
+    assert PS.Side(P.load(dbs[0])).fields("TrailSummaryResponse") == want            # CodingKeys raw values
+    assert PS.Side(P.load(dbs[1])).fields("com.trailmate.data.TrailOverviewJson") == want   # @SerialName