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

{cg_code_graph-0.23.10/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.10
+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.10 → 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.10"
+__version__ = "0.23.11"

{cg_code_graph-0.23.10 → 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.10 → 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.10 → 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.10 → 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.10 → 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.10 → 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.10 → 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.10
+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.10 → cg_code_graph-0.23.11}/cg_code_graph.egg-info/SOURCES.txt

@@ -304,6 +304,7 @@ tests/test_kotlin.py
 tests/test_kotlin_binding.py
 tests/test_kotlin_exact.py
 tests/test_kotlin_fields.py
+tests/test_kotlin_local_state.py
 tests/test_kotlin_mixed.py
 tests/test_kotlin_nav_consts.py
 tests/test_kotlin_props.py

cg_code_graph-0.23.11/tests/test_kotlin_local_state.py

@@ -0,0 +1,77 @@
+"""Compose state held in a local delegate (#105, #88): `var count by remember { mutableIntStateOf(0) }`,
+`by rememberSaveable { mutableStateOf("") }`, `by vm.state.collectAsStateWithLifecycle()` and `by mutableStateOf()`
+are `field:<function>.<name>` nodes (`property: state`, `hook`, `local`); bare reads and writes inside the function
+(including lambdas such as `onClick = { count++ }`) are READS_PROP / WRITES_PROP. A plain local of the same name in
+another function binds nothing."""
+import json
+import sqlite3
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from cg_code_graph.indexer import index_project  # noqa: E402
+
+pytest.importorskip("tree_sitter_kotlin")
+
+SRC = """\
+package app
+
+import androidx.compose.runtime.*
+
+class CounterViewModel {
+    val state = MutableStateFlow(0)
+}
+
+@Composable
+fun CounterScreen(vm: CounterViewModel) {
+    var count by remember { mutableIntStateOf(0) }
+    var name by rememberSaveable { mutableStateOf("") }
+    val total by vm.state.collectAsStateWithLifecycle()
+    var shown by mutableStateOf(false)
+    Button(onClick = { count++ }) {
+        Text(label(count, total))
+    }
+    TextField(value = name, onValueChange = { name = it })
+    if (shown) Dialog(onDismiss = { shown = false })
+}
+
+@Composable
+fun Other() {
+    val count = 3
+    Text(label(count, 0))
+}
+
+fun label(a: Int, b: Int): String = ""
+"""
+
+
+@pytest.fixture(scope="module")
+def g():
+    d = Path(tempfile.mkdtemp(prefix="cg-kt-local-state-"))
+    (d / "p/src/main/kotlin/app").mkdir(parents=True)
+    (d / "p/src/main/kotlin/app/Counter.kt").write_text(SRC)
+    index_project(d / "p", d / "g.db", "kls")
+    return sqlite3.connect(d / "g.db")
+
+
+def test_local_state_nodes(g):
+    n = {i: json.loads(a or "{}") for i, a in g.execute("select id, attrs from nodes where kind='field'")}
+    f = "field:app.CounterScreen."
+    assert n[f + "count"] == {"property": "state", "hook": "mutableIntStateOf", "binding": "var", "local": True}
+    assert n[f + "name"]["hook"] == "mutableStateOf" and n[f + "total"]["hook"] == "collectAsStateWithLifecycle"
+    assert n[f + "shown"]["binding"] == "var"
+    assert not [i for i in n if i.startswith("field:app.Other.")]
+
+
+def test_local_state_reads_and_writes(g):
+    e = {(d.rsplit(".", 1)[-1], k, ln) for s, d, k, ln in g.execute(
+        "select src, dst, kind, line from edges where kind in ('READS_PROP','WRITES_PROP') and dst like 'field:app.CounterScreen.%'")}
+    assert {("count", "READS_PROP", 15), ("count", "WRITES_PROP", 15), ("count", "READS_PROP", 16),
+            ("total", "READS_PROP", 16), ("name", "READS_PROP", 18), ("name", "WRITES_PROP", 18),
+            ("shown", "READS_PROP", 19), ("shown", "WRITES_PROP", 19)} <= e, e
+    srcs = {s for (s,) in g.execute("select src from edges where dst like 'field:app.CounterScreen.%' and kind like '%PROP'")}
+    assert srcs == {"function:app.CounterScreen"}

{cg_code_graph-0.23.10 → cg_code_graph-0.23.11}/tests/test_lint_async.py

@@ -45,7 +45,10 @@ def test_swift():
 
 
 def test_kotlin():
-    assert found("kotlin") == [("src/main/kotlin/app/Search.kt:10", "launch", "heuristic")]  # not :19 (requestId)
+    # not :19 (requestId); SuspendSearch.kt:9 awaits a plain `suspend` call (no marker), :16 is a fixed request and
+    # :23 calls a non-suspend function
+    assert found("kotlin") == [("src/main/kotlin/app/Search.kt:10", "launch", "heuristic"),
+                               ("src/main/kotlin/app/SuspendSearch.kt:9", "launch", "heuristic")]
 
 
 def test_react():
@@ -87,8 +90,8 @@ def test_mcp_tool(monkeypatch):
 
 
 @pytest.mark.parametrize("lang,at,missing", [
-    ("swift", "Sources/App/Cache.swift:9", ["size"]),
-    ("kotlin", "src/main/kotlin/app/Cache.kt:8", ["size"]),
+    ("swift", "Sources/App/Cache.swift:9", ["self.scale", "size"]),      # `scale` is a field used without `self.`
+    ("kotlin", "src/main/kotlin/app/Cache.kt:9", ["size"]),
     ("react", "src/Cache.tsx:5", ["size"]),
     ("python", "app/cache.py:8", ["self.theme"]),
 ])
@@ -102,7 +105,7 @@ def test_incomplete_cache_key(lang, at, missing):
         pytest.skip("node not installed")
     got = [(f["at"], f["missing"], f["confidence"]) for f in LA.lint(GraphStore(db(lang)))["findings"]
            if f["rule"] == "incomplete-cache-key"]
-    assert got == [(at, missing, "heuristic")]
+    assert got[0] == (at, missing, "heuristic") and len(got) == (2 if lang == "kotlin" else 1)   # + Kotlin `icon`
 
 
 def test_cache_key_idents():
@@ -142,3 +145,17 @@ def test_rules_subset():
     out = subprocess.run([sys.executable, "-m", "cg_code_graph.cli", "lint", "async-state", "--db", str(db("python")),
                           "--rules", "incomplete-cache-key"], capture_output=True, text=True, check=True, cwd=ROOT).stdout
     assert "[incomplete-cache-key]" in out and "[echo-suppression]" not in out
+
+
+def test_incomplete_cache_key_bare_kotlin_field():
+    """`render(url, size * density)` keyed by url and size: `density` is a field used without `this.`."""
+    got = [(f["at"], f["missing"]) for f in LA.lint(GraphStore(db("kotlin")))["findings"] if f["rule"] == "incomplete-cache-key"]
+    assert ("src/main/kotlin/app/Cache.kt:21", ["self.density"]) in got, got
+
+
+def test_sentinel_reset_is_a_default():
+    """`searchResults = AsyncData.Loading()` / `= UiState.Idle` reset state to a sentinel: not a competing value."""
+    assert LA.LITERAL_RHS_RE.search("searchResults = AsyncData.Loading()")
+    assert LA.LITERAL_RHS_RE.search("state = UiState.Idle")
+    assert not LA.LITERAL_RHS_RE.search("results = Search.run(query)")
+    assert not LA.LITERAL_RHS_RE.search("now = clock.now()")

{cg_code_graph-0.23.10 → cg_code_graph-0.23.11}/tests/test_roundtrip.py

@@ -126,3 +126,15 @@ def test_call_args_scopes_caller_hop():
     stmt = "rooms.insert(Room(spaceRoom: spaceRoom), at: Int(index))"
     assert _call_args(St(), stmt, "method:Room.init", "spaceRoom").strip() == "spaceRoom"
     assert _call_args(St(), "x = Room(spaceRoom: Int(v), other: 1)", "method:Room.init", "spaceRoom") == "Int(v)"
+
+
+@pytest.mark.parametrize("lang", ["swift", "kotlin", "python"])
+def test_all_properties_one_pass(lang):
+    """`cg roundtrip --all` finds the same round trips as asking for the property, in one pass over every field."""
+    pytest.importorskip("tree_sitter_swift" if lang == "swift" else "tree_sitter_kotlin" if lang == "kotlin" else "json")
+    one = rt(lang)["findings"]
+    allr = RT.roundtrip_all(GraphStore(db(lang)))
+    got = [(f["write"], f["read"]) for f in allr["findings"] if f["state"] in rt(lang)["fields"]]
+    assert one and got == [(f["write"], f["read"]) for f in one]
+    assert allr["fields_with_writes"] >= 1 and allr["lossy_writes"] >= 1
+    assert "round trips" in RT.render_all(allr)

{cg_code_graph-0.23.10 → cg_code_graph-0.23.11}/tests/test_ts_fields_js_vue.py

@@ -72,7 +72,18 @@ def test_pinia_options_store_and_vue_data():
     add, comp = "function:src/stores/cart.ts#useCartStore.add", "component:src/components/Counter.vue"
     assert e[(add, s + "items", "WRITES_PROP", 7)]["via"] == "mutating"
     assert (add, s + "total", "WRITES_PROP", 8) in e and (add, s + "total", "READS_PROP", 9) in e
-    assert e[(comp, v + "count", "WRITES_PROP", 14)] == {"receiver": "this"}
-    assert e[(comp, s + "total", "WRITES_PROP", 16)] == {"receiver": "cart"}
-    assert (comp, s + "items", "READS_PROP", 17) in e
-    assert e[(comp, s + "total", "READS_PROP", 17)] == {"receiver": "useCartStore()"}
+    assert e[(comp, v + "count", "WRITES_PROP", 17)] == {"receiver": "this"}
+    assert e[(comp, s + "total", "WRITES_PROP", 19)] == {"receiver": "cart"}
+    assert (comp, s + "items", "READS_PROP", 20) in e
+    assert e[(comp, s + "total", "READS_PROP", 20)] == {"receiver": "useCartStore()"}
+
+
+def test_vue_options_template_reads_and_writes():
+    """`{{ count }}`, `:title="label"` and `@click="count++"` in an Options API template read / write the data() key;
+    a v-for variable of the same name (`label in labels`) does not."""
+    e = edges("vue_options_fixture", ("READS_PROP", "WRITES_PROP"))
+    comp, v = "component:src/components/Counter.vue", "field:src/components/Counter.vue#"
+    assert e[(comp, v + "count", "READS_PROP", 2)] == {"template": True}
+    assert (comp, v + "labels", "READS_PROP", 3) in e and (comp, v + "label", "READS_PROP", 3) not in e
+    assert (comp, v + "label", "WRITES_PROP", 4) in e and (comp, v + "label", "READS_PROP", 4) in e
+    assert (comp, v + "count", "WRITES_PROP", 5) in e