cg-code-graph 0.23.9__tar.gz → 0.23.11__tar.gz

{cg_code_graph-0.23.9/cg_code_graph.egg-info → cg_code_graph-0.23.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.9
+Version: 0.23.11
 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.9 → cg_code_graph-0.23.11}/cg_code_graph/__init__.py

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

{cg_code_graph-0.23.9 → cg_code_graph-0.23.11}/cg_code_graph/cli.py

@@ -317,7 +317,8 @@ def main(argv=None):
     p.add_argument("--json", action="store_true"); p.add_argument("--tests", action="store_true", help="include test code")
     p = sub.add_parser("roundtrip", help="heuristic: writes of a stored property `Type.prop` through a lossy transform, "
                                          "read back to seed UI state (#88)")
-    p.add_argument("spec"); p.add_argument("--db", required=True); p.add_argument("--json", action="store_true")
+    p.add_argument("spec", nargs="?"); p.add_argument("--db", required=True); p.add_argument("--json", action="store_true")
+    p.add_argument("--all", action="store_true", help="every stored property in one pass: only the round trips")
     p.add_argument("--tests", action="store_true", help="include test code's reads and writes")
     p = sub.add_parser("viz-plan", help="self-contained HTML overlay of a plan on the real graph")
     p.add_argument("name"); p.add_argument("--db", required=True); p.add_argument("-o", "--out", required=True); p.add_argument("--plans-dir")
@@ -769,8 +770,14 @@ def main(argv=None):
         print(json.dumps(res, indent=1) if a.json else LA.render(res))
     elif a.cmd == "roundtrip":
         from . import roundtrip as RT
-        res = RT.roundtrip(st, a.spec, include_tests=a.tests)
-        print(RT.to_json(res) if a.json else RT.render(res))
+        if a.all or not a.spec:
+            if not a.all:
+                sys.exit("cg roundtrip: give a property `Type.prop`, or --all")
+            res = RT.roundtrip_all(st, include_tests=a.tests)
+            print(RT.to_json(res) if a.json else RT.render_all(res))
+        else:
+            res = RT.roundtrip(st, a.spec, include_tests=a.tests)
+            print(RT.to_json(res) if a.json else RT.render(res))
     elif a.cmd in ("writers", "readers"):
         groups = Q.access(st, a.spec, a.cmd, a.connection)
         rows = [r for g in groups for r in g["rows"]]

{cg_code_graph-0.23.9 → cg_code_graph-0.23.11}/cg_code_graph/lint_async.py

@@ -61,6 +61,24 @@ def _input_dependent(text: str) -> bool:
     t = re.sub(r"(?<![\w$])[A-Za-z_$][\w$]*\s*(?:<[^<>]*>)?\s*\(", " (", t)  # call names
     ids = re.findall(r"(?<![\w$])[A-Za-z_$][\w$]*", t)
     return any(i.startswith("SELFREF_") or (i not in KEYWORDS and not i[0].isupper()) for i in ids)
+_SUSP: dict = {}          # file -> lines with a call of a Kotlin `suspend` function (an await point with no marker)
+
+
+def _load_suspend(st: GraphStore) -> None:
+    """A plain call of a project `suspend` function inside `launch { }` (`val x = repo.load()`) suspends like
+    `.await()`: the indexed CALLS edges to nodes marked `suspend` give those lines."""
+    _SUSP.clear()
+    for r in st.q("""SELECT e.file, e.line FROM edges e JOIN nodes n ON n.id = e.dst
+                     WHERE e.kind = 'CALLS' AND n.attrs LIKE '%"suspend": true%' AND e.file IS NOT NULL"""):
+        _SUSP.setdefault(r["file"], set()).add(r["line"])
+
+
+def _aw(t: str, file: str | None = None, line: int | None = None) -> bool:
+    """Is there an await point in this line of source: a marker (`await`, `.await()`, `withContext`, `delay`) or,
+    in Kotlin, a call of a `suspend` function?"""
+    return bool(AWAIT_RE.search(t)) or (line is not None and line in _SUSP.get(file, ()))
+
+
 TEST_PATH_RE = re.compile(r"(?:^|/)(?:tests?|__tests__|spec|testing|fixtures?|factories|Tests|UITests)/|"
                           r"[._-](?:test|spec)s?\.\w+:|Tests?\.swift:|Test\.kt:|(?:^|/)test_\w+\.py:")
 
@@ -104,6 +122,7 @@ def _opener(ls: list[str], line: int, lo: int):
 
 
 def stale_async(st: GraphStore, include_tests: bool = False, limit: int = 500) -> list[dict]:
+    _load_suspend(st)
     root = st.meta().get("root")
     cache: dict = {}
     fields = {r["id"]: json.loads(r["attrs"] or "{}") for r in st.q("SELECT id, attrs FROM nodes WHERE kind IN ('field','property')")}
@@ -122,7 +141,8 @@ def stale_async(st: GraphStore, include_tests: bool = False, limit: int = 500) -
             continue
         kind, o = op
         body = ls[o - 1:r["line"] - 1]
-        aw = next((o + i for i, t in enumerate(body) if AWAIT_RE.search(t if i else t[t.find("{") + 1:] if "{" in t else t)), None)
+        aw = next((o + i for i, t in enumerate(body) if _aw(t if i else t[t.find("{") + 1:] if "{" in t else t,
+                                                           r["file"], o + i if i else None)), None)
         if aw is None:
             continue
         before = "\n".join(ls[o - 1:aw - 1]) + "\n" + ls[aw - 1].split("await")[0]
@@ -131,7 +151,10 @@ def stale_async(st: GraphStore, include_tests: bool = False, limit: int = 500) -
         if GUARD_RE.search(after) or SINGLE_FLIGHT_RE.search(ls[o - 1]):
             continue
         aw_line = ls[aw - 1]
-        k = max(aw_line.find("await"), 0)
+        k = aw_line.find("await")
+        if k < 0:                                  # a Kotlin suspend call: the request is the right-hand side
+            m = re.search(r"(?<![=!<>])=(?!=)", aw_line)
+            k = m.end() if m else 0
         stmt, depth = [], 0
         for i in range(aw - 1, min(len(ls), aw + 5)):
             x = ls[i][k:] if i == aw - 1 else ls[i]
@@ -144,10 +167,10 @@ def stale_async(st: GraphStore, include_tests: bool = False, limit: int = 500) -
         # the written value must come from the awaited result: a name bound on the await line (or derived from one
         # after it), or the await itself on the write line; a loading flag reset after the await is not a stale result
         res_vars = set()
-        for t in ls[aw - 1:r["line"] - 1]:
+        for j, t in enumerate(ls[aw - 1:r["line"] - 1]):
             m = DECL_RE.search(t) or re.search(r"^\s*(?:self\.)?([A-Za-z_$][\w$]*)\s*=(?!=)", t)
             nm = m and (m.group(1) or (m.group(2) if m.lastindex and m.lastindex >= 2 else None))
-            if nm and (AWAIT_RE.search(t) or any(re.search(rf"(?<![\w$.]){re.escape(v)}\b", t.split("=", 1)[-1]) for v in res_vars)):
+            if nm and (_aw(t, r["file"], aw + j) or any(re.search(rf"(?<![\w$.]){re.escape(v)}\b", t.split("=", 1)[-1]) for v in res_vars)):
                 res_vars.add(nm)
         wl = ls[r["line"] - 1]
         if r["line"] - 1 == aw - 1:
@@ -182,7 +205,8 @@ LIFECYCLE_RE = re.compile(r"\.onAppear\b|\bonAppear\s*\(|\.task\s*[({]|\bonMount
 CALLBACK_RE = re.compile(r"\.sink\s*\{|\.onReceive\s*\(|\.subscribe\s*[({]|\.collect(?:Latest)?\s*\{|\.observe\w*\s*\(|"
                          r"\bcompletion(?:Handler)?\s*:\s*\{|\{\s*\[?\s*(?:weak|unowned)\s+self\s*\]?|\.then\s*\(|\.on\s*\(\s*['\"]")
 LITERAL_RHS_RE = re.compile(r"(?<![=!<>])=\s*(?:\[\s*\]|\[:\]|\{\s*\}|nil|null|None|undefined|0(?:\.0+)?[fFdDL]?|false|False|true|True|"
-                            r"''|\"\"|emptyList\(\)|emptyMap\(\)|mutableListOf\(\)|\.init\(\)|\w+\(\)|\.\w+)\s*;?\s*$")
+                            r"''|\"\"|emptyList\(\)|emptyMap\(\)|mutableListOf\(\)|\.init\(\)|\w+\(\)|\.\w+|"
+                            r"[A-Z]\w*(?:\.[A-Z]\w*)+(?:\(\))?)\s*;?\s*$")     # a sentinel: `AsyncData.Loading()`, `UiState.Idle`
 LITERAL_ARG_RE = re.compile(r"\(\s*(?:nil|null|None|undefined|true|false|True|False|-?\d+(?:\.\d+)?|'[^']*'|\"[^\"]*\"|\[\s*\]|\{\s*\})\s*\)\s*;?\s*$")
 INIT_NAMES = {"init", "__init__", "constructor", "<init>", "viewDidLoad", "onCreate", "initState", "mounted", "created", "setup"}
 
@@ -198,7 +222,7 @@ def _lifecycle(st, ls, r, node) -> str | None:
     """Is this write lifecycle code: an initializer with a real (non-default) value, or code directly inside
     onAppear / .task (before any await) / onMounted / LaunchedEffect / useEffect / viewDidLoad?"""
     t = ls[r["line"] - 1]
-    if AWAIT_RE.search(t):
+    if _aw(t, r["file"], r["line"]):
         return None
     nm = ((node["name"] if node is not None else "") or "").split(".")[-1]
     if nm in INIT_NAMES or (node is not None and node["kind"] == "class"):
@@ -212,7 +236,7 @@ def _lifecycle(st, ls, r, node) -> str | None:
     lo = max(1, r["line"] - 6)
     for i in range(r["line"], lo - 1, -1):
         x = ls[i - 1]
-        if i < r["line"] and AWAIT_RE.search(x):
+        if i < r["line"] and _aw(x, r["file"], i):
             return None
         m = LIFECYCLE_RE.search(x)
         if m:
@@ -225,7 +249,8 @@ def _async_callback(ls, r, lo) -> str | None:
     op = _opener(ls, r["line"], lo)
     if op is not None:
         body = ls[op[1] - 1:r["line"] - 1]
-        if any(AWAIT_RE.search(x) for x in body[1:]) or AWAIT_RE.search(body[0][body[0].find("{") + 1:] if body else ""):
+        if any(_aw(x, r["file"], op[1] + j) for j, x in enumerate(body) if j) or \
+                (body and AWAIT_RE.search(body[0][body[0].find("{") + 1:])):
             return f"after await in {op[0]}"
     for i in range(r["line"] - 1, max(lo, r["line"] - 8) - 1, -1):
         m = CALLBACK_RE.search(ls[i - 1]) if i >= 1 else None
@@ -235,6 +260,7 @@ def _async_callback(ls, r, lo) -> str | None:
 
 
 def two_writers(st: GraphStore, include_tests: bool = False) -> list[dict]:
+    _load_suspend(st)
     root = st.meta().get("root")
     cache: dict = {}
     rows = st.q("""SELECT e.src, e.dst, e.file, e.line, e.attrs, n.line AS fl FROM edges e JOIN nodes n ON n.id = e.src
@@ -361,6 +387,14 @@ def incomplete_cache_key(st: GraphStore, include_tests: bool = False) -> list[di
         sig = "\n".join(body[:3])
         sig = sig[sig.find("("):] if "(" in sig else ""
         params = _idents(_split_args(sig[1:]) and ",".join(re.sub(r"[:=].*", "", a, flags=re.S) for a in _split_args(sig[1:])) or "")
+        # instance fields used without `self.` / `this.` (Swift, Kotlin): the READS_PROP edges bind them
+        own = {e["dst"].rsplit(".", 1)[-1] for e in st.q("SELECT dst, attrs FROM edges WHERE kind = 'READS_PROP' AND src = ?",
+                                                         (fn["id"],))
+               if json.loads(e["attrs"] or "{}").get("receiver") in (None, "self", "this")}
+        text = "\n".join(body)
+        # ... unless the field is an object the function calls (`client.get(…)`, `mediaLoader.load(…)`): a dependency,
+        # not an input of the cached value
+        own = {f for f in own if not re.search(rf"(?<![\w$.]){re.escape(f)}\s*[?!]?\.\s*\w+\s*[({{]", text)}
         assigns: dict = {}
         for off, t in enumerate(body):
             m = re.search(r"\b(?:let|var|val|const)\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=(?!=)(.*)|^\s*([a-z_$][\w$]*)\s*=(?!=)(.*)", t)
@@ -384,8 +418,10 @@ def incomplete_cache_key(st: GraphStore, include_tests: bool = False) -> list[di
                 vb = val.strip().rstrip(";")
                 if re.fullmatch(r"[A-Za-z_$][\w$]*", vb) and vb not in assigns:
                     continue                    # `put(key, value)` passes a value through; nothing is computed here
-                kids = _expand(_idents(key), assigns)
-                vids = _expand(_idents(val), assigns) - {vb}
+                bare = lambda ids: {f"self_{i}" if i in own and i not in params and i not in assigns else i  # noqa: E731
+                                    for i in ids}
+                kids = bare(_expand(_idents(key), assigns))
+                vids = bare(_expand(_idents(val), assigns)) - {vb}
                 setter = re.match(r"(?:set|put|insert|store|save|cache|add|update|write|remember|record)(?![a-z])",
                                   (fn["fqn"] or "").split(".")[-1].split("(")[0])
                 inputs = {i for i in vids if (i in params and not setter and not PAYLOAD_RE.fullmatch(i.lstrip("$")))
@@ -421,6 +457,7 @@ def echo_suppression(st: GraphStore, include_tests: bool = False, patterns: list
     programmatic writes of some state so the change observer, which checks the guard and returns early, does not
     echo them back. Reports state of that pattern that is also written from an async path / callback *without*
     setting the guard: that write reaches the observer and is sent back (a loop or a clobbered edit)."""
+    _load_suspend(st)
     root = st.meta().get("root")
     cache: dict = {}
     guards = [r["id"] for r in st.q("SELECT id, name FROM nodes WHERE kind = 'field'") if GUARD_FIELD_RE.fullmatch((r["name"] or "").rsplit(".", 1)[-1].replace("_", ""))]

{cg_code_graph-0.23.9 → cg_code_graph-0.23.11}/cg_code_graph/mcp_server.py

@@ -877,13 +877,16 @@ def _access_text(st, spec: str, what: str, limit: int, connection: str | None =
 
 
 @tool
-def roundtrip(prop: str, include_tests: bool = False) -> str:
+def roundtrip(prop: str = "", include_tests: bool = False) -> str:
     """Heuristic (#88): does a stored property `Type.prop` round-trip through a lossy transform? Each write site with
     the lossy call it passes through (clamp, min/max, round, truncating casts, `fit*`, `.cg.yaml` `lossy:` names,
     `@cg-lossy` functions; within the function plus one hop through direct callers), each read site that seeds UI
     state (init, onAppear, remember, useState(initial), mounted), and un-narrowed ranges drawn next to such a read.
-    Findings are heuristic evidence with file:line, not proof."""
+    Findings are heuristic evidence with file:line, not proof. An empty `prop` (or `*`) checks every stored property
+    in one pass and lists only the round trips."""
     from . import roundtrip as RT
+    if prop.strip() in ("", "*"):
+        return RT.render_all(RT.roundtrip_all(_st(), include_tests=include_tests))
     return RT.render(RT.roundtrip(_st(), prop, include_tests=include_tests))
 
 

{cg_code_graph-0.23.9 → cg_code_graph-0.23.11}/cg_code_graph/parity_structure.py

@@ -56,6 +56,11 @@ RES = re.compile(r"""\b(?:UI|NS)?Image\(\s*(?:named:\s*)?"([^"\n]+)"|\bAsset\.(?
                  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]+)"')
+ARM = re.compile(r"^(\s*)case\s+(?:let\s+|var\s+)?((?:\.\w+(?:\([^)]*\))?\s*,?\s*)+)(?:where\b[^:]*)?:")
+DISPATCH = {"receive", "perform", "handle", "handleaction", "onaction", "reduce", "send", "dispatch", "process"}
+MIN_MEMBER_SCORE = 0.35
+MIN_NAME_SCORE = 0.45
+MIN_BOTH_SCORE = 0.25
 EDGE_KINDS = ("CALLS", "INSTANTIATES", "NAVIGATES_TO", "HTTP_CALLS", "USES_VALUE", "REFERENCES_FN", "USES_TYPE")
 
 
@@ -140,9 +145,11 @@ class Side:
             self.by_file[r["file"]].append((r["line"], r["end_line"] or r["line"], r["id"]))
             self.span[r["id"]] = (r["file"], r["line"], r["end_line"] or r["line"])
         self.out = defaultdict(list)
-        q = f"SELECT src, dst, kind FROM edges WHERE kind IN ({','.join('?' * len(EDGE_KINDS))})"
+        self.out_at = defaultdict(list)        # src -> [(line, dst, kind)]
+        q = f"SELECT src, dst, kind, line FROM edges WHERE kind IN ({','.join('?' * len(EDGE_KINDS))})"
         for r in c.execute(q, EDGE_KINDS):
             self.out[r["src"]].append((r["dst"], r["kind"]))
+            self.out_at[r["src"]].append((r["line"] or 0, 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') "
@@ -202,21 +209,50 @@ class Side:
             for la, lb, nid in self.by_file.get(file, ()):
                 if a <= la <= b:
                     for dst, kind in self.out.get(nid, ()):
-                        if kind == "HTTP_CALLS" or dst in self.http:
-                            p = re.sub(r"\{[^}]*\}|(?<=/):\w+", "{}", self.http.get(dst, dst).split(" ")[-1])
-                            f.add("http:" + p.lstrip("/").lower())
-                            continue
-                        dq = self.fqn_of.get(dst)
-                        t = rename(dq)
-                        if t:
-                            f.add("sym:" + t)
-                        # the called member's own name (two words or more): `getDevices` on an AuthService and on
-                        # an AuthRepository is the same call even when the owners are not paired
-                        nm = _short(dq or "").split("(")[0]
-                        if kind == "CALLS" and len(_words(nm)) >= 2:
-                            f.add("call:" + re.sub(r"^(get|fetch|load)(?=[a-z])", "", _fold(nm)))
+                        self._edge(f, dst, kind, rename)
         return f
 
+    def _edge(self, f: set, dst: str, kind: str, rename) -> None:
+        if kind == "HTTP_CALLS" or dst in self.http:
+            p = re.sub(r"\{[^}]*\}|(?<=/):\w+", "{}", self.http.get(dst, dst).split(" ")[-1])
+            f.add("http:" + p.lstrip("/").lower())
+            return
+        dq = self.fqn_of.get(dst)
+        t = rename(dq)
+        if t:
+            f.add("sym:" + t)
+        # the called member's own name (two words or more): `getDevices` on an AuthService and on
+        # an AuthRepository is the same call even when the owners are not paired
+        nm = _short(dq or "").split("(")[0]
+        if kind == "CALLS" and len(_words(nm)) >= 2:
+            f.add("call:" + re.sub(r"^(get|fetch|load)(?=[a-z])", "", _fold(nm)))
+
+    def arms(self, sym: dict) -> list:
+        """The top-level `case .x:` arms of a Swift `receive(_:)` / `perform(_:)` style switch: [(case names,
+        features of what the arm calls)]."""
+        file, a, b = self.span.get(sym["id"], (None, 0, 0))
+        if not file or b <= a:
+            return []
+        rows = self.text(file, a, b).split("\n")
+        hits = [(i, len(m.group(1)), m.group(2)) for i, ln in enumerate(rows) for m in [ARM.match(ln)] if m]
+        if not hits:
+            return []
+        top = min(h[1] for h in hits)
+        hits = [h for h in hits if h[1] == top]
+        out = []
+        for k, (i, _, names) in enumerate(hits):
+            lo, hi = a + i, (a + hits[k + 1][0] - 1 if k + 1 < len(hits) else b)
+            f = set()
+            for ln, dst, kind in self.out_at.get(sym["id"], ()):
+                if lo <= ln <= hi:
+                    self._edge(f, dst, kind, lambda x: x)
+            for la, lb, nid in self.by_file.get(file, ()):
+                if lo <= la <= hi and nid != sym["id"]:
+                    for dst, kind in self.out.get(nid, ()):
+                        self._edge(f, dst, kind, lambda x: x)
+            out.append((re.findall(r"\.(\w+)", names), f))
+        return out
+
 
 def match(S: dict, T: dict, out: dict, sym_of: dict, cat_of: dict, t_syms: dict, t_cat: dict, learn: bool = True) -> dict:
     ui_s = {fq: is_ui(fq, sym, S["members"]) for fq, sym in sym_of.items()}
@@ -369,7 +405,8 @@ def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
         if sym is not None:
             src_f[row["symbol"]] = sS.features(sym, lambda x: pairs.get(x)) | name_words(row["symbol"])
     tgt_f = {fq: sT.features(sym, lambda x: x) | name_words(fq) for fq, sym in t_syms.items()
-             if fq not in used and not PREVIEW.search(_short(fq))}
+             if fq not in used and not PREVIEW.search(_short(fq))
+             and not (_fold(_short(fq).split("(")[0]) in DISPATCH and sT.arms(sym))}    # its arms are paired below
     src_f = {fq: f for fq, f in src_f.items() if not PREVIEW.search(_short(fq))}
     df = Counter()
     for fs in list(src_f.values()) + list(tgt_f.values()):
@@ -423,4 +460,88 @@ def _structure(S, T, out, sym_of, cat_of, t_syms, t_cat, used):
         else:
             keep.append(row)
     out["missing"] = keep
+    _members(sS, sT, out, sym_of, cat_of, t_syms, t_cat, used, S, T)
     _by_fields(sS, sT, out, sym_of, cat_of, t_syms, t_cat, used, S, T)
+
+
+def _members(sS, sT, out, sym_of, cat_of, t_syms, t_cat, used, S, T):
+    """Members of matched types still missing, paired inside the counterpart type (#227): with an unmatched member,
+    or a top-level function, that makes the same paired calls, or with a `case .x:` arm of its `receive(_:)` /
+    `perform(_:)` switch (`handleCopyClick` on a view model, `case .copyGeneratedValue:` in the processor). Uses are
+    weighed within the pair of types, so a call that is common across the project still tells two members apart."""
+    pairs = {r["symbol"]: r["target"] for r in out["matched"]}
+    by_owner = defaultdict(list)
+    for r in out["missing"]:
+        if r.get("owner_matched") and r["symbol"] in sym_of and not PREVIEW.search(_short(r["symbol"])):
+            by_owner[r["owner_matched"]].append(r)
+    if not by_owner:
+        return
+    ident = lambda x: x  # noqa: E731
+    top, top_inv = None, defaultdict(list)
+    taken_arms, best, cand_of = set(), {}, {}
+    for o, rows in by_owner.items():
+        units = []                                   # (key, target fqn, case name or None, category, features)
+        for nm, sym in T["members"].get(o, {}).items():
+            fq = f"{o}.{nm}"
+            arms = sT.arms(sym) if _fold(nm.split("(")[0]) in DISPATCH else []
+            for names, f in arms:                    # a dispatching switch stands for its arms, not as a whole
+                ws = set().union(*(name_words(n) for n in names))
+                units.append(((fq, names[0]), fq, names[0], "func", f | ws))
+            if not arms and fq not in used and not PREVIEW.search(nm):
+                units.append((fq, fq, None, t_cat.get(fq), sT.features(sym, ident) | name_words(fq)))
+        src = {r["symbol"]: sS.features(sym_of[r["symbol"]], pairs.get) | name_words(r["symbol"]) for r in rows}
+        if top is None:                              # top-level functions, met only through two paired uses
+            top = {}
+            for fq, sym in t_syms.items():
+                if t_cat.get(fq) == "func" and fq not in used and "." not in fq.replace(o, "") and fq in T["top"]:
+                    top[fq] = {f for f in sT.features(sym, ident) if f.startswith("sym:")} | name_words(fq)
+                    for f in top[fq]:
+                        if f.startswith("sym:"):
+                            top_inv[f].append(fq)
+        df = Counter()
+        for fs in list(src.values()) + [u[4] for u in units]:
+            df.update(fs)
+        n = len(src) + len(units)
+        for fq, fs in src.items():
+            extra = {t for f in fs if f.startswith("sym:") for t in top_inv.get(f, ())}
+            cands = [u for u in units if u[3] == cat_of.get(fq)] + [(t, t, None, "func", top[t]) for t in extra
+                                                                    if cat_of.get(fq) == "func"]
+            scored = []
+            for key, t, case, cat, tf in cands:
+                sh = fs & tf
+                uses = sum(1 for f in sh if not f.startswith("w:"))
+                words = len(sh) - uses
+                if case is None and t in top and uses < 2:
+                    continue
+                if not (uses >= 2 or (uses and words) or words >= 2):
+                    continue
+                wt = lambda f: math.log(1 + n / df[f]) if df[f] else math.log(1 + n)  # noqa: E731
+                sc = sum(wt(f) for f in sh) / math.sqrt(sum(wt(f) for f in fs) * sum(wt(f) for f in tf))
+                if sc < (MIN_NAME_SCORE if not uses else MIN_BOTH_SCORE if words else MIN_MEMBER_SCORE):
+                    continue                         # names alone must agree more; a use and a name word less
+                scored.append((sc, key, t, case, sh))
+            scored.sort(key=lambda x: -x[0])
+            if scored and (len(scored) == 1 or scored[1][0] < MARGIN * scored[0][0]):
+                best[fq] = scored[0]
+    by_key = defaultdict(list)
+    for fq, (sc, key, *_rest) in best.items():
+        by_key[key].append((sc, fq))
+    keep = []
+    for row in out["missing"]:
+        got = best.get(row["symbol"])
+        if not got:
+            keep.append(row)
+            continue
+        sc, key, t, case, sh = got
+        if max(by_key[key])[1] != row["symbol"] or (case is None and t in used) or key in taken_arms:
+            keep.append(row)
+            continue
+        if case is None:
+            used.add(t)
+        taken_arms.add(key)
+        ev = sorted(sh, key=lambda f: (f.startswith("w:"), f))[:6]
+        r = dict(row, target=t, confidence="structure", score=round(sc, 2), evidence=([f"case .{case}"] if case else []) + ev)
+        if case:
+            r["case"] = case
+        out["matched"].append(r)
+    out["missing"] = keep

{cg_code_graph-0.23.9 → cg_code_graph-0.23.11}/cg_code_graph/plugins/kotlin/plugin.py

@@ -207,6 +207,12 @@ def _suspend_lambdas(src: bytes) -> tuple[bytes, int]:
 # `get<T>` the whitespace character in front of `get` / `set` becomes `;`. That ends the declaration and keeps every
 # byte offset.
 _ROUTE_ACCESSOR = re.compile(rb"([ \t]*)[ \t]((?:get|set)\s*(?:\(\s*(?:\"|\"\"\")|\{|<))")
+# `var x by remember { mutableStateOf(..) }`, `by rememberSaveable { .. }`, `by mutableStateOf(..)`,
+# `by vm.state.collectAsState()` / `collectAsStateWithLifecycle()`, `by produceState(..)`, `by derivedStateOf { }`
+LOCAL_STATE = re.compile(r"\b(var|val)\s+(\w+)(?:\s*:\s*[^=\n]+?)?\s+by\s+(?:remember(?:Saveable)?\b[^\n{]*\{\s*"
+                         r"(mutable\w*StateOf|derivedStateOf|mutableStateListOf|mutableStateMapOf)"
+                         r"|(mutable\w*StateOf|derivedStateOf)\s*[({]|[\w.]*?\b(collectAs\w*State\w*)\s*\("
+                         r"|(produceState|observeAsState|subscribeAsState)\b|[\w.]*?\.(observeAsState|subscribeAsState)\s*\()")
 _DECL_LINE = re.compile(rb"^\s*(?:(?:private|internal|public|protected|const|lateinit|override|open)\s+)*(?:val|var)\s")
 
 
@@ -321,6 +327,7 @@ class KotlinPlugin(LanguagePlugin):
         # stored properties of a class / enum are `field:<Type>.<name>` nodes with READS_PROP / WRITES_PROP (#88)
         self.fields: dict[str, dict[str, str]] = defaultdict(dict)        # class fqn -> name -> field id
         self.field_names: set[str] = set()
+        self.local_state: dict[str, dict[str, str]] = defaultdict(dict)   # function id -> local state name -> field id
         self.copies: list[tuple] = []         # (owner, receiver (type, text), [(arg name, line)], kf, decl): `x.copy(a = 1)`
         self.frefs: list[tuple] = []          # (owner_id, name, receiver (type, text) | None, line, file, decl, write)
         self.reads: list[tuple] = []          # (owner_id, name, receiver node, line, file obj, decl, read | write)
@@ -617,6 +624,7 @@ class KotlinPlugin(LanguagePlugin):
                 if any(dflt for _n, dflt, _f in fparams):
                     self.fn_params[dc.id] = fparams
                 self._add_decl(dc, kind)
+                self._local_state(dc, kf, c)
                 self._local_fns(c, kf, dc)
             elif ty == "enum_entry" and cls is not None:
                 nm = self._name(c)
@@ -655,6 +663,30 @@ class KotlinPlugin(LanguagePlugin):
         self.field_names.add(nm)
         self.st["stored_property_nodes"] += 1
 
+    def _local_state(self, dc: Decl, kf: KFile, c):
+        """Compose state held in a local delegate (`var count by remember { mutableIntStateOf(0) }`, `val ui by
+        vm.state.collectAsStateWithLifecycle()`): a `field:<function>.<name>` node (`property: state`, `hook`) whose
+        reads and writes inside the function are READS_PROP / WRITES_PROP, like React `useState` (#105, #88)."""
+        txt = self.t(c)
+        if " by " not in txt:
+            return
+        for m in LOCAL_STATE.finditer(txt):
+            nm = m.group(2)
+            if nm in self.local_state[dc.id]:
+                continue
+            hook = next(g for g in m.groups()[2:] if g).split(".")[-1]
+            line = c.start_point[0] + 1 + txt.count("\n", 0, m.start(2))
+            a = {"property": "state", "hook": hook, "binding": m.group(1), "local": True}
+            if kf.test:
+                a["test"] = True
+            fid = self.b.add_node("field", f"{dc.fqn}.{nm}", name=nm, fqn=f"{dc.fqn}.{nm}", file=kf.rel, line=line,
+                                  end_line=line, module=getattr(self.b.nodes.get(dc.id), "module", None), lang="kotlin",
+                                  attrs=a)
+            self.b.add_edge(dc.id, fid, "CONTAINS", kf.rel, line, EXACT)
+            self.local_state[dc.id][nm] = fid
+            self.field_names.add(nm)
+            self.st["local_state_nodes"] += 1
+
     def _prop_kind(self, c) -> tuple | None:
         """(property kind, accessors) of a property that runs code when read or written (#89): a custom `get()` /
         `set(value)` (custom), `by lazy { }` (lazy) or another delegate (delegated); None for a stored property."""
@@ -1954,6 +1986,13 @@ class KotlinPlugin(LanguagePlugin):
                 decl if decl is not None and decl.kind == "class" else None)
             fid = None
             rt = recv[1] if recv is not None else None
+            loc = self.local_state.get(decl.id, {}).get(name) if recv is None and decl is not None else None
+            if loc:
+                if loc != owner:
+                    self.b.add_edge(owner, loc, "WRITES_PROP" if write else "READS_PROP", kf.rel, line, RESOLVED,
+                                    receiver="local", **({"via": write} if isinstance(write, str) else {}))
+                    self.st["local_state_writes" if write else "local_state_reads"] += 1
+                continue
             if recv is None or rt == "this":
                 if recv is None and self._shadowed_local(decl, name, kf):
                     continue

{cg_code_graph-0.23.9 → cg_code_graph-0.23.11}/cg_code_graph/plugins/ts/extractor/extract.mjs

@@ -983,6 +983,7 @@ const STATE_HOOKS = new Set(['useState', 'useReducer', 'ref', 'shallowRef', 'rea
 const optFields = new Map()       // options ObjectLiteralExpression -> Map(name -> field id)
 const storeFields = new Map()     // store VariableDeclaration -> Map(name -> field id)
 const optNames = new Set()
+const fileOptData = new Map()     // rel .vue path -> Map(data() key -> field id): bare names in its template
 function returnedObject(f) {
   if (!f) return null
   f = unwrap(f)
@@ -1013,6 +1014,7 @@ function optionsFields(sf, r, fid) {
     }
     optFields.set(obj, m)
     if (storeDecl) storeFields.set(storeDecl, m)
+    if (hook === 'data') { const f = fileOptData.get(r) || new Map(); for (const [k, v] of m) f.set(k, v); fileOptData.set(r, f) }
   }
   const scan = (n) => {
     if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === 'defineStore') {
@@ -1065,6 +1067,20 @@ function optionsRef(node, cur, sf, r) {
   addEdge(cur, fid, write ? 'WRITES_PROP' : 'READS_PROP', r, lineOf(node, sf), m === null ? 'resolved' : (recv === 'this' ? 'exact' : 'resolved'), { receiver: recv, ...(via ? { via } : {}) })
   stats[write ? 'state_field_writes' : 'state_field_reads'] = (stats[write ? 'state_field_writes' : 'state_field_reads'] || 0) + 1
 }
+// `{{ count }}` / `@click="count++"` in the template of an Options API component: a bare data() key (#88)
+function optionsTplRef(node, cur, sf, r) {
+  const m = fileOptData.get(r), fid = m && m.get(node.text)
+  if (!fid || fid === cur || !isTemplateLine(node, sf)) return
+  const p = node.parent
+  if (p && ((ts.isPropertyAccessExpression(p) && p.name === node) || (ts.isPropertyAssignment(p) && p.name === node)
+      || ts.isParameter(p) || ts.isFunctionDeclaration(p))) return
+  let s = null
+  try { s = checker.getSymbolAtLocation(node) } catch { }
+  if (s && (s.declarations || []).length) return          // a v-for variable / slot prop / import of that name
+  const [write, via] = writeOf(node)
+  addEdge(cur, fid, write ? 'WRITES_PROP' : 'READS_PROP', r, lineOf(node, sf), 'resolved', { template: true, ...(via ? { via } : {}) })
+  stats[write ? 'state_field_writes' : 'state_field_reads'] = (stats[write ? 'state_field_writes' : 'state_field_reads'] || 0) + 1
+}
 function stateDecl(d, cur, sf, r) {
   const init = unwrap(d.initializer)
   if (!init || !ts.isCallExpression(init)) return
@@ -2865,6 +2881,7 @@ for (const sf of sourceFiles) {
     if (ts.isVariableDeclaration(node) && node.initializer && cur) stateDecl(node, cur, sf, r)
     if (ts.isIdentifier(node) && stateNames.has(node.text) && cur) stateRef(node, cur, sf, r)
     if (ts.isPropertyAccessExpression(node) && optNames.has(node.name.text) && cur) optionsRef(node, cur, sf, r)
+    if (isVue && ts.isIdentifier(node) && optNames.has(node.text) && cur && fileOptData.has(r)) optionsTplRef(node, cur, sf, r)
     // .astro: `<a href>` inside a template expression (`{posts.map(p => <a href={`/blog/${p.slug}`}>)}`) is navigation,
     // like a top-level one (the scanner handles those)
     if (isAstro && ts.isJsxAttribute(node) && node.initializer && ts.isIdentifier(node.name) && node.name.text === 'href'

{cg_code_graph-0.23.9 → cg_code_graph-0.23.11}/cg_code_graph/roundtrip.py

@@ -119,6 +119,13 @@ def _bounds(text: str) -> tuple[float, float] | None:
 
 def _fn_bounds(st: GraphStore, src: _Src, name: str) -> tuple[float, float] | None:
     """Bounds inside a project function `name` (`func clamp(_ v: Double) -> Double { min(max(v, 0), 10) }`)."""
+    memo = src.__dict__.setdefault("bounds", {})
+    if name not in memo:
+        memo[name] = _fn_bounds1(st, src, name)
+    return memo[name]
+
+
+def _fn_bounds1(st: GraphStore, src: _Src, name: str) -> tuple[float, float] | None:
     for r in st.q("SELECT file, line, end_line FROM nodes WHERE kind IN ('function','method') AND name=? LIMIT 3", (name,)):
         ls = src.lines(r["file"])
         body = "\n".join(ls[(r["line"] or 1) - 1:(r["end_line"] or r["line"] or 1)])
@@ -273,8 +280,19 @@ def roundtrip(st: GraphStore, spec: str, include_tests: bool = False) -> dict:
     for r in Q.prop_access(st, spec, "READS_PROP"):
         if include_tests or not r.get("test"):
             res["reads"].append(_read_site(st, src, r))
-    lossy = [w for w in res["writes"] if w["lossy"]]
-    seeds = [x for x in res["reads"] if x["seeds"]]
+    res["findings"] = _pair(src, res["writes"], res["reads"], prop)
+    for x in res["writes"]:
+        x.pop("_span", None)
+    for x in res["reads"]:
+        x.pop("_src", None)
+    return res
+
+
+def _pair(src, writes, reads, prop) -> list[dict]:
+    """Findings: a lossy write and a read of the same property that seeds UI state."""
+    out = []
+    lossy = [w for w in writes if w["lossy"]]
+    seeds = [x for x in reads if x["seeds"]]
     for w in lossy:
         b = w["lossy"].get("bounds")
         for x in seeds:
@@ -287,14 +305,60 @@ def roundtrip(st: GraphStore, spec: str, include_tests: bool = False) -> dict:
                  "read": x["at"], "seeds": x["seeds"], "wider_ranges": []}
             if b:
                 f["wider_ranges"] = _ranges(src, x["at"].rsplit(":", 1)[0], tuple(b))[:5]
-            res["findings"].append(f)
-    for x in res["writes"]:
-        x.pop("_span", None)
-    for x in res["reads"]:
-        x.pop("_src", None)
+            out.append(f)
+    return out
+
+
+def roundtrip_all(st: GraphStore, include_tests: bool = False) -> dict:
+    """Every stored property in one pass (`cg roundtrip --all`): write sites are read once, file lines and callee
+    bounds are shared, and reads are looked at only for properties with a lossy write."""
+    root = st.meta().get("root")
+    globs, lsrc = lossy_names(st, root)
+    src = _Src(root)
+    stored = {r["id"]: r["fqn"] or r["name"] or r["id"] for r in st.q(
+        """SELECT id, fqn, name FROM nodes WHERE kind IN ('field', 'property') AND attrs LIKE '%"property": "stored"%'""")}
+
+    def rows(kind):
+        by: dict = {}
+        for r in st.q("""SELECT e.src, e.dst, e.kind, e.file, e.line, n.fqn FROM edges e JOIN nodes n ON n.id = e.src
+                         WHERE e.kind = ? OR (e.kind = 'TEST_USES' AND e.attrs LIKE ?) ORDER BY e.dst, e.file, e.line""",
+                      (kind, f'%"orig": "{kind}"%')):
+            if r["dst"] in stored and r["file"] and (include_tests or r["kind"] != "TEST_USES"):
+                d = dict(r)
+                d["test"] = r["kind"] == "TEST_USES"
+                by.setdefault(r["dst"], []).append(d)
+        return by
+
+    res = {"confidence": "heuristic", "lossy_sources": lsrc, "fields_with_writes": 0, "lossy_writes": 0, "findings": []}
+    writes = rows("WRITES_PROP")
+    res["fields_with_writes"] = len(writes)
+    lossy: dict = {}
+    for fid, ws in writes.items():
+        prop = re.split(r"[.$:#]", stored[fid])[-1]
+        sites = [_write_site(st, src, r, prop, globs) for r in ws]
+        if any(w["lossy"] for w in sites):
+            lossy[fid] = (prop, sites)
+            res["lossy_writes"] += sum(1 for w in sites if w["lossy"])
+    if lossy:
+        reads = rows("READS_PROP")
+        for fid, (prop, sites) in lossy.items():
+            for f in _pair(src, sites, [_read_site(st, src, r) for r in reads.get(fid, [])], prop):
+                res["findings"].append(dict(f, state=fid))
     return res
 
 
+def render_all(res: dict) -> str:
+    out = [f"roundtrip --all — heuristic; lossy names: {', '.join(res['lossy_sources'])}",
+           f"{res['fields_with_writes']} stored properties with writes, {res['lossy_writes']} lossy writes, "
+           f"{len(res['findings'])} round trips"]
+    for f in res["findings"]:
+        out.append(f"  {f['state']}: write @{f['write']} -> {'/'.join(f['lossy']['calls'])} @{f['lossy']['at']} "
+                   f"-> read @{f['read']} -> seeds {f['seeds']}")
+        for g in f["wider_ranges"]:
+            out.append(f"      un-narrowed range {_fmt(g['range'])} @{g['at']}: {g['code']}")
+    return "\n".join(out)
+
+
 def _read_back(src, w, x, prop) -> bool:
     """Is this read a read-back of the stored value rather than the same setup using what it just built? Not when
     the writer reads it a few lines later (`scrollBar = ScrollBarView(...)` then `addView(scrollBar)` in one init),

{cg_code_graph-0.23.9 → cg_code_graph-0.23.11/cg_code_graph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.9
+Version: 0.23.11
 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