codecortex 0.23.2__tar.gz → 0.23.3__tar.gz

{codecortex-0.23.2/src/codecortex.egg-info → codecortex-0.23.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.23.2
+Version: 0.23.3
 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.23.2 → codecortex-0.23.3/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.23.2
+Version: 0.23.3
 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.23.3/src/codeintel/__init__.py

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

{codecortex-0.23.2 → codecortex-0.23.3}/src/codeintel/gateway.py

@@ -174,7 +174,7 @@ class Gateway:
         self, result: Result, op: str, target: str, budget: Any,
         project_root: Any, was_auto: bool,
     ) -> Result:
-        """Ask the LSP when the graph's whole answer was resolved by name rather than by import.
+        """Ask the LSP when the graph's caller answer carries a known binding failure.
 
         This closes the routing gap that let the worst failure through. `_AUTO_ENGINE` is a static
         op→engine map, not a cascade: `callers` goes to the graph and, uniquely among the ops, has
@@ -185,48 +185,71 @@ class Gateway:
         being confidently wrong is a bug; no second engine ever being consulted is the design that
         let it reach the caller.
 
-        Deliberately narrow. It fires only when the graph itself raised `all-rows-name-resolved` —
-        every row a name guess, across enough rows for the pattern to mean something — which is the
-        collision signature and not the ordinary case of one unverified row among several. It
-        APPENDS rather than replaces: the LSP answers a related but different question (references,
-        not call edges), so presenting its list as the graph's would substitute one over-claim for
-        another. And it never fires for an explicitly pinned `--engine graph`, where the caller has
-        said which engine they want."""
+        Deliberately narrow. It fires when every graph row was name-resolved, or when a caller used
+        a file hint and the graph found same-named symbols but no edge for that exact definition.
+        The latter catches property calls that the TypeScript graph resolver failed to bind, while
+        avoiding an LSP call for ordinary healthy answers. It APPENDS rather than replaces: the LSP
+        answers a related but different question (references, not call edges), so presenting its
+        list as the graph's would substitute one over-claim for another. And it never fires for an
+        explicitly pinned `--engine graph`, where the caller has said which engine they want."""
         try:
             if not was_auto or op not in self._CROSS_CHECKED_OPS:
                 return result
             if result.get("result") is None or self.lsp is None:
                 return result
             gaps = result.get("gaps") or []
-            if not any(g.get("kind") == "all-rows-name-resolved"
-                       for g in gaps if isinstance(g, dict)):
+            kinds = {
+                str(g.get("kind") or "") for g in gaps if isinstance(g, dict)
+            }
+            all_name_resolved = "all-rows-name-resolved" in kinds
+            exact_target_unbound = "target-hint-unmatched" in kinds
+            if not (all_name_resolved or exact_target_unbound):
                 return result
+            graph_problem = (
+                "every graph row was resolved by name"
+                if all_name_resolved
+                else "the graph found no caller edge for the file-qualified symbol"
+            )
             probe = self._dispatch_single(
                 self.lsp, "symbol", target, budget, project_root, "lsp")
             body = probe.get("result")
-            if not body:
+            probe_gaps = probe.get("gaps") or []
+            reference_gap = next((
+                gap for gap in probe_gaps
+                if isinstance(gap, dict) and gap.get("section") == "references"
+            ), None)
+            if not body or reference_gap is not None:
                 # Silence from the LSP is not agreement. Say which check did not happen — and
                 # separate "not yet booted" from "had nothing", because only the first is fixed by
                 # asking again. A one-shot CLI process meets a cold serena on every invocation; the
                 # long-lived MCP server keeps the session warm and takes this branch once at most.
                 # Waiting here is deliberately NOT done: it would hold back a graph answer that is
                 # already complete, to append a section that is only advisory.
-                warming = probe.get("reason") == "warming"
-                why = ("the language server had not finished booting"
-                       if warming else "the LSP engine reported nothing for this symbol")
+                unavailable_reason = (
+                    str(reference_gap.get("kind") or "not-asked")
+                    if reference_gap is not None else str(probe.get("reason") or "no-result")
+                )
+                warming = unavailable_reason in {"warming", "timeout"}
+                why = (
+                    "the language server had not finished booting"
+                    if unavailable_reason == "warming"
+                    else str(reference_gap.get("detail") or "the reference lookup did not answer")
+                    if reference_gap is not None
+                    else "the LSP engine reported nothing for this symbol"
+                )
                 nxt = (" Ask again once it is warm and this section will be filled in."
                        if warming else
                        " Check it yourself with `--engine lsp --op symbol`.")
                 return {**result, "gaps": [*gaps, {
                     "section": op, "kind": "cross-check-unavailable",
                     "engine": "lsp",
-                    "reason": probe.get("reason") or "no-result",
-                    "detail": f"every graph row was name-resolved and the LSP could not confirm "
-                              f"them ({why}), so they remain unverified"
+                    "reason": unavailable_reason,
+                    "detail": f"{graph_problem} and the LSP could not provide an independent "
+                              f"reference check ({why}), so the graph answer remains unverified"
                               + (" — retry" if warming else ""),
                     **({"retry_after_s": 2} if warming else {}),
                 }], "result": str(result["result"]) + (
-                    f"\n\n> Cross-check unavailable: every row above was resolved by name, and "
+                    f"\n\n> Cross-check unavailable: {graph_problem}, and "
                     f"{why}, so nothing here has been confirmed against a second engine.{nxt}"
                 )}
             refs = self._reference_lines(str(body))
@@ -236,15 +259,15 @@ class Gateway:
             merged = (
                 f"{result['result']}\n\n## Cross-check — LSP references to `{target}` "
                 f"({len(refs)})\n"
-                f"_The rows above were all resolved by NAME by the graph engine. These come from the "
-                f"language server, which resolves through the file's imports. A caller listed above "
-                f"but absent here is very likely a name collision; a location here but missing above "
-                f"is a call the graph could not bind._\n" + listing + more
+                f"_The graph answer has a known binding gap: {graph_problem}. These locations come "
+                f"from the language server, which resolves the exact definition. A caller listed "
+                f"above but absent here is likely a name collision; a location here but missing "
+                f"above is a reference the graph could not bind._\n" + listing + more
             )
             return {**result, "result": merged, "gaps": [*gaps, {
                 "section": op, "kind": "cross-checked-with-lsp",
                 "engine": "lsp",
-                "detail": f"every graph row was name-resolved, so the LSP was consulted "
+                "detail": f"{graph_problem}, so the LSP was consulted "
                           f"independently and reported {len(refs)} reference location(s); the two "
                           f"lists answer related but different questions and are shown separately",
             }]}

{codecortex-0.23.2 → codecortex-0.23.3}/src/codeintel/providers/lsp.py

@@ -67,6 +67,30 @@ _BACKEND_ERROR_MARKERS = (
 )
 
 
+def _split_target_file_hint(target: str) -> tuple[str, str]:
+    """Return Serena's symbol pattern and an optional repo-relative file hint.
+
+    Graph operations accept ``name@path`` to disambiguate duplicate symbols. The gateway may pass
+    that exact target to the LSP for an independent reference cross-check, but Serena understands
+    only the name-path portion. Keep the syntax aligned here without coupling the LSP provider to
+    graph.py's private target parser.
+    """
+    raw = str(target or "").strip()
+    if "@" not in raw:
+        return raw, ""
+    head, _, tail = raw.rpartition("@")
+    if not head.strip() or not tail.strip():
+        return raw, ""
+    return head.strip(), tail.strip()
+
+
+def _file_hint_matches(file_path: Any, hint: str) -> bool:
+    """Match a file hint on path-segment boundaries, consistently with the graph provider."""
+    have = str(file_path or "").replace("\\", "/").strip().strip("/").lower()
+    want = str(hint or "").replace("\\", "/").strip().strip("/").lower()
+    return bool(have and want and (have == want or have.endswith("/" + want)))
+
+
 def _looks_like_backend_error(text: str) -> bool:
     """Whether *text* is a backend failure message rather than a result.
 
@@ -773,10 +797,18 @@ class LspProvider:
         self, session: _LspSession, target: str, root: str, timeout_s: float
     ) -> str | None:
         try:
+            symbol_target, file_hint = _split_target_file_hint(target)
             def_out = self._call_tool(
                 session,
                 "find_symbol",
-                {"name_path_pattern": target, "include_body": True, "max_matches": 5},
+                {
+                    "name_path_pattern": symbol_target,
+                    "include_body": True,
+                    # A file hint exists specifically because the name is ambiguous. Retrieve
+                    # enough definitions to find the requested file instead of silently selecting
+                    # whichever five Serena happens to return first.
+                    "max_matches": 50 if file_hint else 5,
+                },
                 timeout_s,
             )
             if isinstance(def_out, Missing):
@@ -789,6 +821,21 @@ class LspProvider:
             def_raw = def_out.value
             def_text = self._extract_text(def_raw)
             matches = self._loads(def_text)
+            if isinstance(matches, list) and file_hint:
+                matches = [
+                    match for match in matches
+                    if isinstance(match, dict)
+                    and _file_hint_matches(match.get("relative_path"), file_hint)
+                ]
+                if not matches:
+                    # Do not fall through and render the original JSON containing definitions
+                    # from other files. More importantly, the reference lookup below must remain
+                    # "not asked", rather than turning an unresolved exact definition into a
+                    # confident zero-reference answer.
+                    def_text = (
+                        f"> The language server found no definition for `{symbol_target}` in "
+                        f"`{file_hint}`."
+                    )
 
             first: dict | None = None
             if isinstance(matches, list) and matches:

{codecortex-0.23.2 → codecortex-0.23.3}/tests/test_lsp_provider.py

@@ -163,6 +163,64 @@ def test_lsp_provider_ready_symbol(monkeypatch):
     assert "parse_result" in r["result"]
 
 
+def test_file_qualified_symbol_selects_the_matching_definition(monkeypatch):
+    """A graph file hint must survive the LSP cross-check instead of selecting a same-name method."""
+    monkeypatch.setattr("codeintel.providers.lsp.shutil.which", lambda x: "/fake/uvx")
+    p = LspProvider()
+    p._sessions["/my/repo"] = _make_fake_session(_State.READY)
+    calls: list[tuple[str, dict]] = []
+
+    def _fake_call_tool(session, tool, args, timeout_s):
+        calls.append((tool, args))
+        if tool == "find_symbol":
+            return Ok('[{"name_path":"Other/createSession","kind":"Method",'
+                      '"relative_path":"src/other.ts","body_location":{"start_line":1,'
+                      '"end_line":2},"body":"wrong"},{"name_path":"WsSessionHandler/createSession",'
+                      '"kind":"Method","relative_path":"backend/src/session.handler.ts",'
+                      '"body_location":{"start_line":138,"end_line":177},"body":"right"}]')
+        if tool == "find_referencing_symbols":
+            assert args["name_path"] == "WsSessionHandler/createSession"
+            assert args["relative_path"] == "backend/src/session.handler.ts"
+            return Ok('{"backend/src/gateway.ts":{"Method":[{"name_path":"Gateway/routeMessage",'
+                      '"content_around_reference":"> 612: await handler.createSession()"}]}}')
+        return Missing("backend-error", "unstubbed tool")
+
+    monkeypatch.setattr(p, "_call_tool", _fake_call_tool)
+    r = p.build_result(
+        "symbol", "createSession@backend/src/session.handler.ts", [], 30000, "/my/repo"
+    )
+
+    assert r["confidence"] == "complete"
+    assert "right" in r["result"] and "wrong" not in r["result"]
+    assert "backend/src/gateway.ts:613" in r["result"]
+    assert calls[0][1]["name_path_pattern"] == "createSession"
+    assert calls[0][1]["max_matches"] == 50
+
+
+def test_file_qualified_symbol_does_not_use_a_definition_from_another_file(monkeypatch):
+    monkeypatch.setattr("codeintel.providers.lsp.shutil.which", lambda x: "/fake/uvx")
+    p = LspProvider()
+    p._sessions["/my/repo"] = _make_fake_session(_State.READY)
+    calls: list[str] = []
+
+    def _fake_call_tool(session, tool, args, timeout_s):
+        calls.append(tool)
+        return Ok('[{"name_path":"Other/createSession","kind":"Method",'
+                  '"relative_path":"src/other.ts","body_location":{"start_line":1,'
+                  '"end_line":2},"body":"wrong"}]')
+
+    monkeypatch.setattr(p, "_call_tool", _fake_call_tool)
+    r = p.build_result(
+        "symbol", "createSession@backend/src/session.handler.ts", [], 30000, "/my/repo"
+    )
+
+    assert r["confidence"] == "partial"
+    assert "found no definition" in r["result"] and "wrong" not in r["result"]
+    assert "References — not retrieved" in r["result"]
+    assert calls == ["find_symbol"]
+    assert any(g["section"] == "references" and g["kind"] == "not-asked" for g in r["gaps"])
+
+
 # ---------------------------------------------------------------------------
 # Group 8 — Unsupported op when READY
 # ---------------------------------------------------------------------------

{codecortex-0.23.2 → codecortex-0.23.3}/tests/test_null_reason_and_ripple.py

@@ -150,6 +150,70 @@ def test_an_all_guesses_answer_is_cross_checked_against_the_lsp():
     assert any(g["kind"] == "cross-checked-with-lsp" for g in env["gaps"]), env["gaps"]
 
 
+def test_a_file_qualified_graph_miss_is_cross_checked_against_the_lsp():
+    target = "createSession@backend/src/session.handler.ts"
+    graph = {
+        "ok": True,
+        "op": "callers",
+        "target": target,
+        "engine": "graph",
+        "result": "## Callers\nNo matching file-qualified symbol has callers in this index.",
+        "confidence": "partial",
+        "gaps": [{
+            "section": "callers",
+            "kind": "target-hint-unmatched",
+            "detail": "the exact symbol has no bound caller edge",
+        }],
+    }
+    lsp = {
+        "ok": True,
+        "result": f"## Symbol: {target}\n**Method** — backend/src/session.handler.ts:139\n"
+                  "```\nbody\n```\n\n## References (1)\n"
+                  "- backend/src/gateway.ts:613  (Gateway/routeMessage)\n",
+        "engine": "lsp",
+        "confidence": "complete",
+    }
+    calls: list[tuple[str, str]] = []
+
+    class _RecordingLsp(_StubLsp):
+        def build_result(self, op, asked_target, files, budget, project_root, **kw):
+            calls.append((op, asked_target))
+            return super().build_result(op, asked_target, files, budget, project_root, **kw)
+
+    gw = Gateway(graph=_StubGraph(graph), lsp=_RecordingLsp(lsp))
+    env = gw.query("callers", target, engine="auto", project_root=ROOT, budget=30000)
+
+    assert calls == [("symbol", target)]
+    assert "backend/src/gateway.ts:613" in env["result"]
+    assert "file-qualified symbol" in env["result"]
+    assert any(g["kind"] == "cross-checked-with-lsp" for g in env["gaps"])
+
+
+def test_an_unresolved_lsp_definition_does_not_claim_zero_references():
+    target = "createSession@backend/src/session.handler.ts"
+    graph = {
+        "ok": True, "op": "callers", "target": target, "engine": "graph",
+        "result": "No bound graph caller.", "confidence": "partial",
+        "gaps": [{"section": "callers", "kind": "target-hint-unmatched"}],
+    }
+    lsp = {
+        "ok": True, "engine": "lsp", "confidence": "partial",
+        "result": "## Symbol\nNo matching definition.\n\n## References — not retrieved",
+        "gaps": [{
+            "section": "references", "kind": "not-asked",
+            "detail": "the exact file-qualified definition was not resolved",
+        }],
+    }
+
+    env = Gateway(graph=_StubGraph(graph), lsp=_StubLsp(lsp)).query(
+        "callers", target, engine="auto", project_root=ROOT, budget=30000
+    )
+
+    assert "Cross-check unavailable" in env["result"]
+    assert "(no references reported)" not in env["result"]
+    assert any(g["kind"] == "cross-check-unavailable" for g in env["gaps"])
+
+
 def test_a_healthy_graph_answer_is_never_sent_to_the_lsp():
     """The escalation is for the collision signature only. Firing it on ordinary answers would
     double every callers query's cost for nothing."""

codecortex-0.23.2/src/codeintel/__init__.py

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