codecortex 0.25.0__tar.gz → 0.26.0__tar.gz

{codecortex-0.25.0/src/codecortex.egg-info → codecortex-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.25.0
+Version: 0.26.0
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT

{codecortex-0.25.0 → codecortex-0.26.0/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.25.0
+Version: 0.26.0
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT

{codecortex-0.25.0 → codecortex-0.26.0}/src/codecortex.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ src/codeintel/graph_answer.py
 src/codeintel/graph_backend.py
 src/codeintel/graph_changed.py
 src/codeintel/graph_confidence.py
+src/codeintel/graph_dispatch.py
 src/codeintel/graph_edges.py
 src/codeintel/graph_ops.py
 src/codeintel/graph_render.py
@@ -90,6 +91,7 @@ tests/test_backend_reaper.py
 tests/test_background_index_failure.py
 tests/test_bench_corpus_typed.py
 tests/test_bench_gate.py
+tests/test_bench_graphify.py
 tests/test_bench_oracle.py
 tests/test_bench_oracle_ts.py
 tests/test_c4.py
@@ -108,6 +110,7 @@ tests/test_cold_process.py
 tests/test_config.py
 tests/test_corpus.py
 tests/test_could_not_ask_semantic.py
+tests/test_dispatch_callers.py
 tests/test_docs_ci_claims.py
 tests/test_docs_deadcode_withdrawal.py
 tests/test_docs_trust_claims.py

codecortex-0.26.0/src/codeintel/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.26.0"

{codecortex-0.25.0 → codecortex-0.26.0}/src/codeintel/graph_answer.py

@@ -605,7 +605,7 @@ class AnswerRendering:
                     guessed_by.add(str(r.get("strategy") or "").strip())
                     unverified += 1
                     continue
-                if evidence in ("lsp", "import", "same-module"):
+                if evidence in ("lsp", "import", "same-module", "self-mro"):
                     r["_evidence"] = evidence
                     if evidence == "same-module":
                         # `same_module` is a bare-name lookup inside the caller's own file, and it
@@ -806,7 +806,8 @@ class AnswerRendering:
         tally = " · ".join(f"{n} {b}" for b, n in present)
         return (
             f"**{tally}.** The heading counts rows, not confirmed {unit}s — only the `{_RESOLVED}` "
-            f"rows were bound by an import, a language server or the caller's own module scope. "
+            f"rows were bound by an import, a language server, the caller's own module scope or, for "
+            f"a `self.` call, the caller's own class hierarchy (`self_mro`, over INHERITS edges). "
             f"Per-row detail below.\n"
         )
 
@@ -905,10 +906,11 @@ class AnswerRendering:
         structured row and the printed row cannot disagree about a fact.
 
         `verified` is the field to filter on and the only one that is a VERDICT: true exactly when
-        a binding was followed — through an import, a language server, or (for a bare call to a
-        symbol the caller's own module defines) the module's own scope. `why` says WHICH, per
-        strategy, because the three are different strengths of claim and one sentence for the
-        bucket was false for one of them. An unstamped row is not verified — silence from the
+        a binding was followed — through an import, a language server, (for a bare call to a symbol
+        the caller's own module defines) the module's own scope, or (for a `self.m()` call) the
+        caller's own class hierarchy, over INHERITS edges. `why` says WHICH, per strategy, because
+        the four are different strengths of claim and one sentence for the bucket was false for one
+        of them. An unstamped row is not verified — silence from the
         backend is not evidence — and it is not `possible` either, which is why `evidence` keeps
         all three states rather than collapsing to a boolean pair.
 
@@ -926,7 +928,7 @@ class AnswerRendering:
         confidence = row.get("_low_confidence")
         scope = row.get("_module_scope")
         edge = str(row.get("type(c)") or "").strip()
-        return {
+        out: dict[str, Any] = {
             "relation": unit,
             "name": str(row.get(name_key) or ""),
             "qualified_name": _strip_project_prefix(
@@ -940,6 +942,16 @@ class AnswerRendering:
             "confidence": float(confidence) if confidence is not None else None,
             "why": _why(row, bucket),
         }
+        via = row.get("_via")
+        if via:
+            # Only on a row that reached the symbol through a base, so every other answer keeps the
+            # exact row shape it always had. `via` is the base method the call was actually resolved
+            # to; `via_kind` says whether that base is a Protocol the symbol satisfies structurally or
+            # a class it inherits from. Neither changes `verified`, which stays false: a call to the
+            # base is not a binding to this override.
+            out["via"] = str(via)
+            out["via_kind"] = str(row.get("_via_kind") or "")
+        return out
 
     def _record_rows(self, rendered: list[dict], row_keys: tuple[str, str, str], unit: str,
                      *, row_cap_hit: bool, withheld: int) -> None:
@@ -1046,6 +1058,13 @@ class AnswerRendering:
         if ev["verified"] or ev["possible"]:
             lines.append(f"> Verified {noun}s: {ev['verified']} · "
                          f"possible: {ev['possible']} · unstated: {ev['unstated']}")
+        # Said here because `possible` alone reads as "weak evidence about this symbol", and a row
+        # that called the BASE method is a different claim: it may be the only production caller
+        # there is, and no binding ties it to the symbol asked about.
+        through = sum(1 for r in self._pending_rows if r.get("via"))
+        if through:
+            lines.append(f"> Of the possible {noun}s, {through} call a base type or Protocol rather "
+                         "than this symbol, and reach it only by dispatch")
         if ev["truncated"]:
             total = ev["total"]
             shown = (f"{ev['returned']} shown, {total} in total" if total is not None

{codecortex-0.25.0 → codecortex-0.26.0}/src/codeintel/graph_changed.py

@@ -111,6 +111,9 @@ class _Lookup:
     detail: str = ""
     untouched: list[dict] = field(default_factory=list)
     also: list[dict] = field(default_factory=list)
+    # Callers of a BASE method (`graph_dispatch.py`). Kept out of the two lists above: whether the
+    # diff touched such a caller says nothing about whether its author considered THIS symbol.
+    through: list[dict] = field(default_factory=list)
     mentions: list[dict] = field(default_factory=list)
     quiet: int = 0                                # mentions that are only comments or definitions
     withheld: int = 0                             # rows found and not printed
@@ -396,15 +399,19 @@ class ChangedSince(AnswerRendering):
         if rows:
             lk.state = "ok"
             for r in rows:
-                (lk.also if self._caller_is_changed(r, touched) else lk.untouched).append(
-                    dict(r, module_scope_in_diff=bool(
-                        r.get("module_scope") and str(r.get("file") or "") in files)))
+                row = dict(r, module_scope_in_diff=bool(
+                    r.get("module_scope") and str(r.get("file") or "") in files))
+                if r.get("via"):
+                    lk.through.append(row)
+                else:
+                    (lk.also if self._caller_is_changed(r, touched) else lk.untouched).append(row)
             shown = self._RANGE_ROWS_SHOWN
             # Two different ways a known row goes unprinted, and both are WITHHELD: the rows this
             # group does not print (its own per-list limit), and the ones `callers` itself kept back
             # (its distinct-caller cap) — which it counts and does not publish. Counting only the
             # first made "120 callers, 50 kept" read as "50 in total" in the envelope.
             lk.withheld = (max(0, len(lk.untouched) - shown) + max(0, len(lk.also) - shown)
+                           + sum(max(0, len(rs) - shown) for rs in _by_base(lk.through).values())
                            + omitted)
             lk.complete = not lk.cap_hit and not lk.gaps
             if miss is not None:
@@ -638,7 +645,9 @@ class ChangedSince(AnswerRendering):
         if lk.source == "text":
             return [dict(r, group_class=klass) for r in lk.mentions[:shown]]
         out: list[dict[str, Any]] = []
-        for status, rows in (("untouched", lk.untouched), ("also-changed", lk.also)):
+        lists = [("untouched", lk.untouched), ("also-changed", lk.also),
+                 *(("through-base", rs) for rs in _by_base(lk.through).values())]
+        for status, rows in lists:
             out.extend(dict(r, changed_symbol=e.qn, change=e.change.change,
                             caller_status=status, group_class=klass) for r in rows[:shown])
         return out
@@ -653,7 +662,7 @@ class ChangedSince(AnswerRendering):
         graph lookup produced is `advisory`."""
         if lk.source == "text":
             return _DISCOVERY
-        rows = lk.untouched + lk.also
+        rows = lk.untouched + lk.also + lk.through
         if (lk.state == "ok" and lk.complete and rows and not lk.withheld
                 and all(r.get("verified") is True for r in rows)):
             return _EVIDENCE
@@ -670,11 +679,16 @@ class ChangedSince(AnswerRendering):
             raw["_module_scope"] = row.get("file")
         if row.get("evidence") == _NAME_MATCHED:
             raw["_low_confidence"] = row.get("confidence")
+            if row.get("via"):
+                # A caller of a BASE method (see `graph_dispatch.py`): the badge says which kind of
+                # base, and its strategy — whatever it is — is the account of how the call reached
+                # the base, so the `same_module` reading below must not be applied to it.
+                raw["_via"], raw["_via_kind"] = row.get("via"), row.get("via_kind")
             # A `same_module` edge is only ever name-matched because the call-site check found it
             # written through a receiver (see `_same_module_call`), so the strategy IS the verdict.
             # Without it the badge reads `[?0.90]` — the backend's high score behind a question
             # mark, which is the reading `callers` prints "qualified call" to prevent.
-            if _evidence_class(str(row.get("strategy") or "")) == "same-module":
+            elif _evidence_class(str(row.get("strategy") or "")) == "same-module":
                 raw["_same_module"] = _SAME_MODULE_FOREIGN
         line = self._display(raw, "a.name", "a.qualified_name", "a.file_path")
         if row.get("module_scope_in_diff"):
@@ -702,13 +716,24 @@ class ChangedSince(AnswerRendering):
         out = [self._group_heading(lk)]
         shown = self._RANGE_ROWS_SHOWN
         if lk.state == "ok":
-            for title, rows in (
-                ("Callers this diff did NOT touch — these may break", lk.untouched),
-                ("Callers also changed in this diff — probably updated together", lk.also),
-            ):
+            lists = [
+                (f"**Callers this diff did NOT touch — these may break ({len(lk.untouched)}):**",
+                 lk.untouched),
+                (f"**Callers also changed in this diff — probably updated together ({len(lk.also)}):**",
+                 lk.also),
+                # Apart from the two above, and one list per base: a caller of the BASE is not a
+                # caller of this symbol, and whether the diff touched it does not say that its
+                # author considered this override. It may be the only production caller there is.
+                *((f"**Callers through `{_short_base(via)}` — they call the "
+                   f"{'base class' if rs[0].get('via_kind') == 'base' else 'Protocol'}, not this symbol, "
+                   "and reach it only by dispatch; never counted as verified callers "
+                   f"({len(rs)}):**", rs)
+                  for via, rs in _by_base(lk.through).items()),
+            ]
+            for title, rows in lists:
                 if not rows:
                     continue
-                out.append(f"**{title} ({len(rows)}):**")
+                out.append(title)
                 out.extend(self._caller_line(r) for r in rows[:shown])
                 if len(rows) > shown:
                     out.append(f"… (+{len(rows) - shown} more, not shown)")
@@ -854,6 +879,20 @@ class ChangedSince(AnswerRendering):
 
 # ----------------------------------------------------------------------------- module helpers
 
+def _by_base(rows: list[dict]) -> dict[str, list[dict]]:
+    """Rows that reached a symbol through a base, grouped by the base method they called, in the
+    order the bases first appear."""
+    out: dict[str, list[dict]] = {}
+    for r in rows:
+        out.setdefault(str(r.get("via") or ""), []).append(r)
+    return out
+
+
+def _short_base(via: str) -> str:
+    """`Base.m` from the qualified name of a base method."""
+    return ".".join(via.split(".")[-2:])
+
+
 def _diff_change(root: str, base_sha: str, change: FileChange) -> FileSymbolDiff:
     """One file's symbol diff. A side that SHOULD exist and cannot be read is `unparsable`, not
     absent: passing `None` for it would classify every definition in the file as added or removed."""

{codecortex-0.25.0 → codecortex-0.26.0}/src/codeintel/graph_confidence.py

@@ -68,6 +68,11 @@ def _evidence_class(strategy: str) -> str:
         return "import"
     if st.startswith("same_module"):
         return "same-module"
+    # Not a strategy the backend reports: the label this project gives an edge it RE-RESOLVED from the
+    # class hierarchy (`self.m()` bound through the caller's own ancestry — `graph_dispatch.py`). It
+    # is classified here, with the others, so every reader of `strategy` agrees it is a resolution.
+    if st.startswith("self_mro"):
+        return "self-mro"
     if st.startswith("language_rule"):
         return "language-rule"
     if st.startswith("unresolved"):
@@ -227,7 +232,7 @@ def _edge_strength(row: dict) -> tuple[int, float]:
     """
     evidence = _evidence_class(str(row.get("strategy") or ""))
     conf = _edge_confidence(row)
-    if evidence in ("lsp", "import"):
+    if evidence in ("lsp", "import", "self-mro"):
         rank = 0
     elif evidence == "same-module":
         rank = 2 if _same_module_call(row) == _SAME_MODULE_FOREIGN else 0
@@ -246,6 +251,12 @@ def _callee_for_display(callee: str) -> str:
     return flat if len(flat) <= 60 else flat[:57] + "..."
 
 
+def _via_kind(row: dict) -> str:
+    """`protocol`, `protocol-undecided` or `base`: what kind of base method a `via` row called."""
+    kind = str(row.get("_via_kind") or "")
+    return kind if kind in ("protocol", "protocol-undecided") else "base"
+
+
 def _why(row: dict, bucket: str) -> str:
     """One sentence saying what ACTUALLY happened to produce this row's bucket.
 
@@ -256,8 +267,37 @@ def _why(row: dict, bucket: str) -> str:
     stronger.
     """
     strategy = str(row.get("strategy") or "").strip()
+    via = str(row.get("_via") or "")
+    if via:
+        # A caller of a BASE method listed under a symbol that overrides it. Whatever the edge's own
+        # strategy was, it bound the call to `via` and not to this symbol, so the row is never
+        # `resolved` for the symbol asked about; the strategy is kept here as the account of how it
+        # reached `via`, because that is the part of the claim the backend did make.
+        kind = "base class" if _via_kind(row) == "base" else "Protocol"
+        how = (f"the receiver's declared type (`{strategy}`)" if strategy == "field_type_hint"
+               else f"`{strategy}`" if strategy else "an edge the backend left unlabelled")
+        text = (f"resolved to the {kind} method `{via}` by {how}, not to this symbol; it reaches this "
+                "override only by dispatch, when the object is an instance of this symbol's class, "
+                "so no binding the index records ties it to this symbol")
+        # Each of these is a way the claim is weaker than the line above says, stated on the row so
+        # it is not only in a heading three screens up.
+        if _via_kind(row) == "protocol-undecided":
+            text += ("; and whether that class satisfies the Protocol is undecided — an attribute or "
+                     "property could supply a member it lacks as a method")
+        if row.get("_via_how") == "base_classes":
+            text += ("; and the link from this symbol's class to that base was found by resolving the "
+                     "base-class NAME its statement wrote, not from an INHERITS edge")
+        if row.get("_via_super"):
+            text += (f"; it is a `super()` call inside `{row['_via_super']}`, a class that descends from "
+                     "this symbol's class, so it can reach this symbol")
+        elif row.get("_via_super_unplaced"):
+            text += ("; it is a `super()` call from a class the index could not place in this symbol's "
+                     "hierarchy, so whether it can reach this symbol was not decided")
+        return text
     if bucket == _RESOLVED:
         evidence = str(row.get("_evidence") or "") or _evidence_class(strategy)
+        if evidence == "self-mro":
+            return str(row.get("_self_mro") or "resolved through the caller's own class hierarchy")
         if evidence == "lsp":
             return f"a language server resolved the call to this symbol ({strategy})"
         if evidence == "import":
@@ -295,8 +335,12 @@ def _why(row: dict, bucket: str) -> str:
             return (f"matched by name inside the caller's own module, but the call is written "
                     f"`{callee}` — through a receiver, not as this module's own symbol — so the "
                     f"match is a guess about what the receiver is ({strategy})")
-        return (f"matched by name ({strategy})" if strategy
+        text = (f"matched by name ({strategy})" if strategy
                 else "matched by bare symbol name, not by following a binding")
+        # A `self.m()` the class hierarchy would bind if one of its links were an edge: said here so
+        # a reader who sees a `self.` call still badged knows the rule looked and why it declined.
+        note = str(row.get("_hierarchy_note") or "")
+        return f"{text}; {note}" if note else text
     if bucket == _UNSTATED:
         return "the backend reported no provenance for this edge"
     return "unclassified"
@@ -311,6 +355,12 @@ def _confidence_badge(row: dict) -> str:
     if "_low_confidence" not in row:
         return ""
     conf = row.get("_low_confidence")
+    if row.get("_via"):
+        # The backend's score is for the edge to the BASE method — kept on show as detail, as every
+        # other badge does — but the verdict is about this symbol, and the glyph says which kind of
+        # base the call went through, since that is what a reader scanning the list needs to know.
+        kind = _via_kind(row)
+        return f" [?via {kind}]" if conf is None else f" [?via {kind} {float(conf):.2f}]"
     # A `same_module` edge this module refused to trust keeps the backend's own score on show — the
     # number is the backend's and is still detail — but the verdict is OURS, and a bare `[?0.90]`
     # reads as high confidence behind a question mark. Say what the doubt is about.