codecortex 0.15.2__tar.gz → 0.15.3__tar.gz

{codecortex-0.15.2/src/codecortex.egg-info → codecortex-0.15.3}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.15.2
+Version: 0.15.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.15.2 → codecortex-0.15.3}/src/codecortex.egg-info/SOURCES.txt

@@ -61,6 +61,7 @@ tests/test_chunking.py
 tests/test_cli_commands.py
 tests/test_cli_help.py
 tests/test_config.py
+tests/test_corpus.py
 tests/test_doctor.py
 tests/test_e2e.py
 tests/test_engine_adoption.py

codecortex-0.15.3/src/codeintel/__init__.py

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

{codecortex-0.15.2 → codecortex-0.15.3}/src/codeintel/providers/lsp.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import enum
 import json
+import logging
 import os
 import re
 import shutil
@@ -16,6 +17,8 @@ from mcp.client.stdio import stdio_client
 
 from codeintel.provider import Result, log_swallowed, safe_null_result
 
+logger = logging.getLogger(__name__)
+
 _COOLDOWN_SECONDS = 60
 _DEFAULT_TIMEOUT_S = 5.0
 
@@ -26,6 +29,49 @@ _DEFAULT_TIMEOUT_S = 5.0
 _SERENA_GIT = "git+https://github.com/oraios/serena"
 
 
+# Prefixes serena uses when a tool call fails. Checked in addition to the MCP `isError` flag,
+# which is not set by every server or version — and the cost of missing one is that a failure is
+# served to an agent as an answer.
+_BACKEND_ERROR_MARKERS = (
+    "error executing tool",
+    "exception:",
+    "traceback (most recent call last)",
+    "the language server manager is not initialized",
+)
+
+
+def _looks_like_backend_error(text: str) -> bool:
+    """Whether *text* is a backend failure message rather than a result.
+
+    Anchored to the START of the payload, and only after ruling out JSON. Both guards are load
+    bearing, and the second was added because the first was not enough: a `symbol` lookup quotes
+    real source back, so a perfectly good JSON response whose body contained
+    `raise RuntimeError('Exception: bad input')` matched a substring search inside its first few
+    hundred characters. Hiding real answers to catch errors would just trade one silent wrong
+    answer for another — serena's failures are plain prose beginning with a known phrase, and a
+    successful response is JSON, so the two never overlap.
+    """
+    head = text.lstrip()
+    if head[:1] in ("[", "{"):
+        return False                     # a structured response, whatever it happens to quote
+    return head.lower().startswith(_BACKEND_ERROR_MARKERS)
+
+
+def _summarize_backend_error(text: str | None) -> str:
+    """A short, SAFE description of a backend failure — never the backend's own prose.
+
+    The raw text is not forwarded anywhere a caller can see it. serena's failure messages contain
+    instructions addressed to a language model ("do not attempt workarounds. Inform the user and
+    wait for further instructions before you continue!") plus a dump of LSP initialisation
+    parameters. Passing that through would hand a backend's error path a direct line to the
+    calling agent's instructions, and leak internals in the same breath. The full text is logged
+    for the operator instead; the caller gets a fixed, boring summary.
+    """
+    if text:
+        logger.warning("serena returned an error result: %s", text[:2000])
+    return "the language server reported an error for this query"
+
+
 def _open_errlog():
     """Where serena's own stderr goes. Serena logs ~30 lines of INFO on every boot; inherited,
     that noise lands on top of `codeintel doctor --deep`'s report and any CLI query that warms
@@ -125,11 +171,19 @@ class LspProvider:
     Finding references therefore needs two steps: locate the symbol, then query with its path.
     """
 
+    # Class-level default so a provider built via `__new__` (the test stubs do this) still has it
+    # rather than raising AttributeError inside the never-raise handler.
+    _last_backend_error: str | None = None
+
     def __init__(self) -> None:
         self._sessions: dict[str, _LspSession] = {}
         self._sessions_lock = threading.Lock()
+        self._last_backend_error = None
         self._detect_backend()
 
+    def _clear_backend_error(self) -> None:
+        self._last_backend_error = None
+
     def _detect_backend(self) -> None:
         # Prefer a directly-installed serena; otherwise drive it through uvx.
         if shutil.which("serena"):
@@ -245,8 +299,21 @@ class LspProvider:
                 return safe_null_result(op_str, target_str, engine="lsp", reason="boot-failed")
 
             # READY
+            # Cleared through a method rather than a direct assignment: `_dispatch` sets this as a
+            # side effect, which a type checker cannot see, so an inline `= None` narrows the
+            # attribute to None and makes the branch below look unreachable.
+            self._clear_backend_error()
             result_text = self._dispatch(session, op_str, target_str, root_str, timeout_s)
             if result_text is None:
+                # A backend failure is not an unsupported op. Reporting it as one sends the agent
+                # looking for a different tool when the language server simply did not start —
+                # the same misleading string the graph provider already had to stop emitting.
+                if self._last_backend_error:
+                    return safe_null_result(
+                        op_str, target_str, engine="lsp", reason="backend-error",
+                        hint=f"{self._last_backend_error} — run `codeintel doctor --deep` to boot-"
+                             f"check serena; the full backend message is in the server log",
+                    )
                 return safe_null_result(op_str, target_str, engine="lsp", reason="unsupported-op")
 
             return {
@@ -294,11 +361,38 @@ class LspProvider:
             return None
 
     def _extract_text(self, raw: Any) -> str | None:
+        """The text payload of a tool result, or None — including when the result is an ERROR.
+
+        An MCP `CallToolResult` carries `isError`, and this read straight past it: serena's failure
+        text was harvested like any other content and handed back as the answer. What an agent then
+        received for "where is this symbol defined?" was `ok: true`, no `reason`, and a body reading
+
+            Error executing tool find_symbol: Exception: The language server manager is not
+            initialized … do not attempt workarounds. Inform the user and wait for further
+            instructions before you continue!
+
+        followed by a dump of the LSP initialisation params. Three separate problems in one string:
+        it is a failure presented as a result, it leaks internals, and — worst — it carries
+        imperative instructions aimed at a language model into a field an agent reads as data. A
+        backend's error path must never become a channel for telling the caller's agent what to do.
+        """
         if raw is None:
             return None
         if isinstance(raw, str):
-            return raw
-        # mcp CallToolResult has a .content list of TextContent
+            return None if _looks_like_backend_error(raw) else raw
+        if getattr(raw, "isError", False):
+            self._last_backend_error = _summarize_backend_error(self._raw_text(raw))
+            return None
+        text = self._raw_text(raw)
+        # `isError` is not always set by every server/version, so the text shape is a second gate.
+        if text is not None and _looks_like_backend_error(text):
+            self._last_backend_error = _summarize_backend_error(text)
+            return None
+        return text
+
+    @staticmethod
+    def _raw_text(raw: Any) -> str | None:
+        """Concatenated text of an MCP result's content blocks, with no error interpretation."""
         try:
             parts = [item.text for item in raw.content if hasattr(item, "text")]
             return "\n".join(parts) if parts else None
@@ -375,15 +469,28 @@ class LspProvider:
                 {"name_path_pattern": target, "include_body": True, "max_matches": 5},
                 timeout_s,
             )
+            if def_raw is None:
+                # The tool call itself failed or timed out. Rendering "(not found)" here — which is
+                # what this did — states that the symbol does not exist, on no evidence whatsoever.
+                # For an agent deciding whether to create something, "I could not ask" and "it is
+                # not there" are opposite answers.
+                self._last_backend_error = "the language server did not respond to this query"
+                return None
             def_text = self._extract_text(def_raw)
             matches = self._loads(def_text)
 
             first: dict | None = None
             if isinstance(matches, list) and matches:
                 def_section, first = self._format_matches(target, matches)
+            elif def_text is None:
+                # `_extract_text` returns None for an error result, and there is nothing to render
+                # from a failure. Returning None here routes to a safe-null carrying a real reason
+                # rather than dressing the failure up as "## Symbol: x" with the error underneath.
+                return None
             else:
-                # Non-JSON / degenerate response — surface whatever serena returned.
-                def_section = f"## Symbol: {target}\n{def_text or '(not found)'}"
+                # Non-JSON but not an error — surface what serena returned, which is how a
+                # degenerate-but-real response still reaches the caller.
+                def_section = f"## Symbol: {target}\n{def_text}"
 
             # References require the located symbol's own path (two-step contract).
             ref_section = "## References\n(none)"

codecortex-0.15.3/tests/test_corpus.py

@@ -0,0 +1,335 @@
+"""Corpus harness — run the engines against REAL repositories and assert invariants.
+
+Every other fixture in this suite is a synthetic two-to-five-file micro-repo, including the release
+canary's. That is precisely the world in which none of this project's real bugs are visible: they
+were all properties of scale and mess — a vendored tree, a minified bundle, a repo nested inside
+another, a language server that fails to start — and a hand-built fixture cannot produce those by
+construction. Every one of them was found by a person deciding to point the tool at an unfamiliar
+codebase, and the recurring lesson of this project is that the technique works and nobody had
+automated it.
+
+So this file automates it, with three deliberate design choices:
+
+* **Real repositories, pinned by commit SHA.** Not vendored (too large), not floating on a branch
+  (an upstream commit must never turn CI red for reasons unrelated to this project).
+* **Invariants, not golden answers.** Asserting exact output over a real repo means the assertions
+  churn on every backend update and get rubber-stamped. Each check below states something that must
+  hold on ANY repository, so it keeps its meaning when the corpus grows.
+* **Planted adversarial artifacts.** Real repos supply structure and scale; a controlled canary
+  supplies a known right answer. Both are needed — "no result escaped the root" is only meaningful
+  when something worth finding sits outside it.
+
+Opt-in, because it clones over the network and takes minutes:
+
+    CODEINTEL_CORPUS=1 pytest tests/test_corpus.py -v
+
+Individual checks skip when the engine they need is unavailable, so this is useful with any subset
+of the backends installed. A skip is reported, never silently passed.
+"""
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+import shutil
+import subprocess
+import sys
+
+import pytest
+
+pytestmark = pytest.mark.skipif(
+    os.environ.get("CODEINTEL_CORPUS", "").strip() not in ("1", "true", "on", "yes"),
+    reason="corpus harness is opt-in: set CODEINTEL_CORPUS=1 (clones real repositories)",
+)
+
+# Pinned by SHA. Chosen for being small enough to clone quickly while still being real code with
+# real structure — packages, tests, docs, examples — which is the property the synthetic fixtures
+# lack. Add to this list rather than replacing: breadth is the whole point.
+CORPUS = [
+    {
+        "name": "click",
+        "url": "https://github.com/pallets/click.git",
+        "sha": "cbd7a4109da16ce58f54c2a618b4c986e3041fcf",
+    },
+]
+
+_CACHE = os.environ.get("CODEINTEL_CORPUS_CACHE") or "/tmp/codeintel-corpus"
+
+# Content planted OUTSIDE every indexed root. If this string ever appears in a result, something
+# read past the boundary — the concrete form of the containment bug that shipped.
+CANARY = "sk-live-CORPUS-CANARY-MUST-NEVER-APPEAR"
+
+
+def _clone(spec: dict) -> str:
+    """Clone (or reuse) a pinned corpus repo. Skips the test when the network is unavailable —
+    an unreachable GitHub is not a defect in this project."""
+    dest = os.path.join(_CACHE, spec["name"])
+    if os.path.isdir(os.path.join(dest, ".git")):
+        head = subprocess.run(["git", "-C", dest, "rev-parse", "HEAD"],
+                              capture_output=True, text=True).stdout.strip()
+        if head == spec["sha"]:
+            return dest
+        shutil.rmtree(dest, ignore_errors=True)
+    os.makedirs(_CACHE, exist_ok=True)
+    try:
+        subprocess.run(["git", "clone", "--quiet", spec["url"], dest],
+                       check=True, capture_output=True, timeout=600)
+        subprocess.run(["git", "-C", dest, "checkout", "--quiet", spec["sha"]],
+                       check=True, capture_output=True, timeout=120)
+    except (OSError, subprocess.SubprocessError) as exc:
+        pytest.skip(f"could not fetch corpus repo {spec['name']}: {exc}")
+    return dest
+
+
+@pytest.fixture(scope="session", params=CORPUS, ids=lambda s: s["name"])
+def corpus_repo(request):
+    """A pinned real repository, with adversarial artifacts planted around and inside it."""
+    repo = _clone(request.param)
+
+    # A secret OUTSIDE the repo, and a symlink inside pointing at it. Containment is enforced at
+    # index time and at read time; this is the shape that defeated the index-time-only version.
+    outside = os.path.join(_CACHE, "_outside")
+    os.makedirs(outside, exist_ok=True)
+    secret = os.path.join(outside, "secret.py")
+    with open(secret, "w", encoding="utf-8") as fh:
+        fh.write(f'SECRET_TOKEN = "{CANARY}"\n')
+    link = os.path.join(repo, "_planted_link.py")
+    if not os.path.islink(link):
+        try:
+            os.symlink(secret, link)
+        except OSError:
+            pass
+
+    # A minified bundle in a directory on no skip list anywhere — the case a name-based rule
+    # structurally cannot catch, and the one that put a webpack chunk in a repo's top hotspots.
+    assets = os.path.join(repo, "assets")
+    os.makedirs(assets, exist_ok=True)
+    with open(os.path.join(assets, "chunk.js"), "w", encoding="utf-8") as fh:
+        fh.write("!function(e,t){" + ("a=1;" * 4000) + "}();")
+
+    return repo
+
+
+# --------------------------------------------------------------------------- helpers
+
+def _graph():
+    from codeintel.providers.graph import GraphProvider
+
+    p = GraphProvider()
+    if not p.available:
+        pytest.skip("codebase-memory-mcp not installed")
+    return p
+
+
+def _indexed_graph(repo: str):
+    """A graph provider with *repo* indexed, or a skip explaining why not."""
+    p = _graph()
+    p._run("index_repository", {"repo_path": repo}, 300_000)
+    lookup = p._lookup_project(repo)
+    if lookup.reason == "backend-unreachable":
+        pytest.skip("graph backend did not respond")
+    if lookup.resolution is None:
+        pytest.skip("graph backend did not register the corpus repo")
+    return p
+
+
+def _all_text(result: dict) -> str:
+    """Everything in an envelope a caller can read."""
+    return " ".join(str(result.get(k) or "") for k in ("result", "reason", "hint"))
+
+
+def _paths_in(text: str) -> list[str]:
+    """Every path-looking token in a rendered result."""
+    import re
+
+    return re.findall(r"[\w./-]+\.(?:py|js|ts|tsx|jsx|go|rs|java|c|h|cpp|md)", text or "")
+
+
+GRAPH_OPS = ["hotspots", "deadcode", "overview", "changed"]
+SYMBOL_OPS = ["callers", "callees", "impact", "chain"]
+
+
+# --------------------------------------------------------------------------- invariants
+
+def test_no_op_ever_raises_on_a_real_repository(corpus_repo):
+    """The never-raise contract, against real input rather than a three-file fixture."""
+    p = _indexed_graph(corpus_repo)
+    for op in GRAPH_OPS + SYMBOL_OPS + ["pattern"]:
+        r = p.build_result(op, "Command", [], 30000, corpus_repo)
+        assert r["ok"] is True, f"{op} broke the never-raise contract"
+        assert set(r).issuperset({"ok", "op", "target", "result", "engine", "cached"})
+
+
+def test_no_result_ever_carries_content_from_outside_the_root(corpus_repo):
+    """The containment invariant, with something real to find: a secret outside the repo, reachable
+    through a symlink planted inside it."""
+    p = _indexed_graph(corpus_repo)
+    for op in GRAPH_OPS + SYMBOL_OPS:
+        r = p.build_result(op, "Command", [], 30000, corpus_repo)
+        assert CANARY not in _all_text(r), f"{op} returned content from outside the indexed root"
+
+
+def test_no_result_cites_a_generated_or_ignored_file(corpus_repo):
+    """Generated content must not appear in a ranking. Checked against two oracles the project did
+    not previously consult — its own shape heuristic, and `git check-ignore`, which is the
+    repository's own statement about what is not source."""
+    from codeintel.source_kind import looks_generated_path
+
+    p = _indexed_graph(corpus_repo)
+    offenders: list[str] = []
+    for op in GRAPH_OPS:
+        r = p.build_result(op, "", [], 30000, corpus_repo)
+        for path in _paths_in(str(r.get("result") or "")):
+            if looks_generated_path(path):
+                offenders.append(f"{op}: {path} (generated by shape)")
+                continue
+            full = os.path.join(corpus_repo, path)
+            if os.path.exists(full):
+                ignored = subprocess.run(
+                    ["git", "-C", corpus_repo, "check-ignore", "-q", path],
+                    capture_output=True,
+                )
+                if ignored.returncode == 0:
+                    offenders.append(f"{op}: {path} (git-ignored)")
+    assert not offenders, "generated/ignored files surfaced as results:\n  " + "\n  ".join(offenders)
+
+
+def test_the_graph_actually_answered(corpus_repo):
+    """Non-vacuity guard, and it must come first.
+
+    Every invariant below is of the form "X never appears in a result". All of them pass trivially
+    against an engine that returns nothing — which is exactly the state this project shipped in for
+    a whole release. A corpus harness that goes green on a dead backend would be worse than no
+    harness, because it would certify the outage. So: assert the engine produced substantial output
+    before believing anything it did not produce.
+    """
+    p = _indexed_graph(corpus_repo)
+    hotspots = p.build_result("hotspots", "", [], 60000, corpus_repo)
+    overview = p.build_result("overview", "", [], 60000, corpus_repo)
+    assert hotspots.get("result"), "hotspots returned nothing — the invariants below prove nothing"
+    assert overview.get("result"), "overview returned nothing"
+    assert len(str(hotspots["result"]).splitlines()) > 10, "implausibly few hotspots for a real repo"
+    assert "nodes" in str(overview["result"])
+
+
+def test_the_planted_bundle_never_ranks_as_a_hotspot(corpus_repo):
+    """A minified bundle is by far the most "complex" function in any tree containing one, and
+    `assets/` is on no skip list in this codebase.
+
+    Note this is a REGRESSION guard rather than a live check today: the graph backend does its own
+    file selection and never offers the `.js` to codeintel at all, so the assertion is currently
+    satisfied upstream. It earns its place by failing if that ever changes — but the corresponding
+    live check for codeintel's OWN filtering is `test_generated_content_stays_out_of_the_corpus`
+    below, which exercises the indexer directly.
+    """
+    p = _indexed_graph(corpus_repo)
+    r = p.build_result("hotspots", "", [], 60000, corpus_repo)
+    assert "chunk.js" not in str(r.get("result") or "")
+
+
+def test_generated_content_stays_out_of_the_corpus(corpus_repo):
+    """codeintel's own file selection, over a real repository.
+
+    This is the check the graph one cannot be: it drives `Indexer._walk_files`, which is where this
+    project decides what is hand-written source, and needs neither backend nor embedding model. The
+    planted bundle sits in `assets/` — a name on no skip list — so only the content-shape heuristic
+    can exclude it, and the symlink resolves outside the root so only containment can.
+    """
+    from codeintel.indexer import Indexer
+    from codeintel.semantic_db import SemanticDb
+
+    db = SemanticDb(os.path.join(_CACHE, "walk.sqlite"))
+    db.init()
+    try:
+        walked = {os.path.relpath(str(f), corpus_repo)
+                  for f in Indexer(db)._walk_files(pathlib.Path(corpus_repo))}
+    finally:
+        db.close()
+
+    # Non-vacuity first, again: an empty walk would satisfy every exclusion below.
+    assert len(walked) > 40, f"implausibly few files walked for a real repo: {len(walked)}"
+    assert any(p.endswith(".py") and p.startswith("src/") for p in walked), "no real source walked"
+
+    assert "assets/chunk.js" not in walked, "a minified bundle entered the corpus"
+    assert "_planted_link.py" not in walked, "a symlink out of the root entered the corpus"
+
+    # And nothing the repository itself declares as non-source.
+    ignored = [p for p in walked
+               if subprocess.run(["git", "-C", corpus_repo, "check-ignore", "-q", p],
+                                 capture_output=True).returncode == 0]
+    assert not ignored, f"git-ignored files entered the corpus: {ignored[:10]}"
+
+
+def test_deadcode_hits_have_no_textual_reference_in_the_tree(corpus_repo):
+    """`deadcode` names symbols an agent may delete, so its output gets checked against the source
+    rather than trusted. A name that appears anywhere beyond its own definition is not dead."""
+    import re
+
+    p = _indexed_graph(corpus_repo)
+    r = p.build_result("deadcode", "", [], 60000, corpus_repo)
+    text = str(r.get("result") or "")
+    if not text or "(0)" in text:
+        pytest.skip("no deadcode candidates reported for this repo")
+
+    names = re.findall(r"^- ([\w.]+)", text, re.MULTILINE)[:10]
+    live: list[str] = []
+    for qualified in names:
+        name = qualified.rsplit(".", 1)[-1]
+        if len(name) < 4:            # too short to grep meaningfully
+            continue
+        hits = subprocess.run(
+            ["git", "-C", corpus_repo, "grep", "-c", "-w", name],
+            capture_output=True, text=True,
+        ).stdout.strip().splitlines()
+        total = sum(int(line.rsplit(":", 1)[-1]) for line in hits if ":" in line)
+        if total > 1:                # more than its own definition
+            live.append(f"{qualified}: {total} textual references")
+    assert not live, "deadcode named symbols that are referenced in the tree:\n  " + "\n  ".join(live)
+
+
+def test_a_nonsense_target_is_reported_as_absent_not_as_a_failure(corpus_repo):
+    """Reason fidelity. With the backend present and working, a target that genuinely does not
+    exist must land in the asked-and-found-nothing family — never in the could-not-ask family,
+    which would tell an agent the engine is broken when the answer is simply "no"."""
+    p = _indexed_graph(corpus_repo)
+    r = p.build_result("callers", "zzz_no_such_symbol_anywhere_zzz", [], 30000, corpus_repo)
+    assert r["result"] is None
+    assert r.get("reason") in ("not-in-graph", "no-result"), r.get("reason")
+    assert r.get("reason") not in (
+        "engine-unavailable", "backend-unreachable", "backend-incompatible",
+        "project-not-indexed", "project-not-indexed-standalone", "error",
+    )
+
+
+def test_no_result_leaks_an_absolute_host_path(corpus_repo):
+    """The home-path disclosure class. Renderers were swept for it once and a third and fourth site
+    turned up later; this asserts the property over real output instead of enumerating sites."""
+    p = _indexed_graph(corpus_repo)
+    home = os.path.expanduser("~")
+    for op in GRAPH_OPS + SYMBOL_OPS:
+        r = p.build_result(op, "Command", [], 30000, corpus_repo)
+        text = _all_text(r)
+        assert home not in text, f"{op} leaked the host home directory"
+        # The backend's path-slug project id is the flattened absolute path; it must not appear.
+        assert corpus_repo.strip("/").replace("/", "-") not in text, f"{op} leaked the project id"
+
+
+def test_the_same_query_gives_the_same_answer_in_a_fresh_process(corpus_repo):
+    """Determinism. A ranking that reorders between runs cannot be reviewed, and a cached answer
+    that differs from an uncached one is a silent staleness bug."""
+    _indexed_graph(corpus_repo)          # ensure indexed before the subprocesses run
+    prog = (
+        "import json,sys;"
+        "from codeintel.providers.graph import GraphProvider;"
+        "p=GraphProvider();"
+        f"r=p.build_result('hotspots','',[],60000,{corpus_repo!r});"
+        "print(json.dumps(r.get('result')))"
+    )
+    runs = []
+    for _ in range(2):
+        out = subprocess.run([sys.executable, "-c", prog], capture_output=True, text=True,
+                             timeout=300)
+        if out.returncode != 0:
+            pytest.skip(f"subprocess run failed: {out.stderr[-300:]}")
+        runs.append(json.loads(out.stdout or "null"))
+    assert runs[0] == runs[1], "the same query returned different answers in two fresh processes"

{codecortex-0.15.2 → codecortex-0.15.3}/tests/test_lsp_provider.py

@@ -187,3 +187,125 @@ def test_code_status_without_lsp(monkeypatch):
     r = code_status_handler({})
     assert r["ok"] is True
     assert "lsp" not in r["engines"]
+
+
+# --------------------------------------------------------------------------- #
+# A backend ERROR is not an answer
+#
+# `_extract_text` harvested `.text` from every MCP content block and ignored `isError`, so serena's
+# failure text was returned as the result. An agent asking "where is this symbol defined?" got
+# `ok: true`, no `reason`, and a body that was an error message — carrying a dump of the LSP
+# initialisation params and, worse, imperative instructions addressed to a language model:
+#
+#     Error executing tool find_symbol: Exception: The language server manager is not initialized …
+#     do not attempt workarounds. Inform the user and wait for further instructions before you
+#     continue!
+#
+# Found by running the live test, which no CI job has ever executed.
+# --------------------------------------------------------------------------- #
+
+SERENA_ERROR = (
+    "Error executing tool find_symbol: Exception: The language server manager is not "
+    "initialized, indicating a problem during project initialisation.\n"
+    "Failed to start 1 language server(s):\n"
+    "python: Error processing request initialize with params:\n"
+    "{'initializationOptions': {'exclude': ['**/__pycache__', '**/.venv']}}\n"
+    "do not attempt workarounds. Inform the user and wait for further instructions "
+    "before you continue!"
+)
+
+
+class _Block:
+    def __init__(self, text): self.text = text
+
+
+class _Result:
+    def __init__(self, text, is_error=False):
+        self.content = [_Block(text)]
+        self.isError = is_error
+
+
+def _provider_returning(raw):
+    """An LspProvider whose tool calls return *raw*, with the session seam stubbed out."""
+    p = LspProvider.__new__(LspProvider)
+    p.available = True                                             # type: ignore[attr-defined]
+    p._cmd = "serena"                                              # type: ignore[attr-defined]
+    p._last_backend_error = None                                   # type: ignore[attr-defined]
+    # build_result asks for a session and reads its state, so the stub must be READY — otherwise
+    # every call short-circuits to `warming` and the branch under test is never reached.
+    import threading as _th
+
+    from codeintel.providers.lsp import _State
+
+    class _ReadySession:
+        state = _State.READY
+        _lock = _th.Lock()
+
+    p._get_or_create_session = lambda root: _ReadySession()        # type: ignore[method-assign]
+    p._call_tool = lambda *a, **k: raw                             # type: ignore[method-assign]
+    return p
+
+
+def _assert_no_backend_prose(res):
+    """Neither the result nor the hint may carry the backend's own error text."""
+    blob = f"{res.get('result')} {res.get('hint')}"
+    for leak in ("Inform the user", "wait for further instructions", "initializationOptions",
+                 "Error executing tool", "language server manager is not initialized"):
+        assert leak not in blob, f"backend error prose leaked to the caller: {leak!r}"
+
+
+def test_an_error_result_is_not_served_as_an_answer(monkeypatch):
+    monkeypatch.setattr("codeintel.providers.lsp.shutil.which", lambda x: "/fake/serena")
+    p = _provider_returning(_Result(SERENA_ERROR, is_error=True))
+    res = p.build_result("symbol", "safe_null_result", [], 0, "/repo")
+
+    assert res["ok"] is True
+    assert res["result"] is None, "a backend failure must not be returned as the answer"
+    assert res["reason"] == "backend-error"
+    # Not `unsupported-op`: that sends the agent looking for a different tool when the language
+    # server simply did not start.
+    assert res["reason"] != "unsupported-op"
+    _assert_no_backend_prose(res)
+
+
+def test_an_error_shaped_response_without_the_flag_is_still_caught(monkeypatch):
+    """`isError` is not set by every server or version, and the cost of missing one is that a
+    failure reaches an agent as data. The text shape is a second gate."""
+    monkeypatch.setattr("codeintel.providers.lsp.shutil.which", lambda x: "/fake/serena")
+    p = _provider_returning(_Result(SERENA_ERROR, is_error=False))
+    res = p.build_result("symbol", "safe_null_result", [], 0, "/repo")
+
+    assert res["result"] is None
+    assert res["reason"] == "backend-error"
+    _assert_no_backend_prose(res)
+
+
+def test_real_source_that_merely_mentions_exceptions_is_not_mistaken_for_an_error(monkeypatch):
+    """The guard against over-detection: a `symbol` lookup quotes real code back, and plenty of
+    real functions contain the word "Exception:". Hiding those would trade one silent wrong answer
+    for another."""
+    from codeintel.providers.lsp import _looks_like_backend_error
+
+    body = (
+        '[{"name_path": "handle", "relative_path": "src/app.py", '
+        '"body": "def handle():\\n    raise RuntimeError(\'Exception: bad input\')\\n"}]'
+    )
+    assert _looks_like_backend_error(body) is False
+
+    monkeypatch.setattr("codeintel.providers.lsp.shutil.which", lambda x: "/fake/serena")
+    p = _provider_returning(_Result(body))
+    res = p.build_result("symbol", "handle", [], 0, "/repo")
+    assert res["result"] is not None
+    assert res.get("reason") is None
+
+
+def test_the_error_summary_never_quotes_the_backend(monkeypatch):
+    """The summary handed to a caller is fixed text. The backend's prose is logged for the
+    operator and goes nowhere an agent can read it — an error path must not become a channel for
+    instructing the caller's model."""
+    from codeintel.providers.lsp import _summarize_backend_error
+
+    summary = _summarize_backend_error(SERENA_ERROR)
+    assert "Inform the user" not in summary
+    assert "initializationOptions" not in summary
+    assert summary == "the language server reported an error for this query"

{codecortex-0.15.2 → codecortex-0.15.3}/tests/test_lsp_real.py

@@ -245,9 +245,12 @@ def test_symbol_tool_returns_none_degrades(monkeypatch):
     monkeypatch.setattr(p, "_call_tool", lambda *a, **k: None)  # every tool call fails
     r = p.build_result("symbol", "safe_null_result", [], 0, "/repo")
     assert r["ok"] is True
-    # No JSON to parse → definition falls back to "(not found)", references empty, no crash.
-    assert r["result"] is not None
-    assert "(not found)" in r["result"]
+    # This used to render "## Symbol: x\n(not found)" — a claim that the symbol does not exist,
+    # made when every tool call had FAILED. For an agent deciding whether to create something,
+    # "I could not ask" and "it is not there" are opposite answers, so a dead backend degrades to
+    # a safe-null carrying a reason rather than to a confident negative.
+    assert r["result"] is None
+    assert r["reason"] == "backend-error"
 
 
 def test_symbol_tool_raising_is_caught(monkeypatch):
@@ -282,9 +285,20 @@ def test_live_symbol_returns_definition_and_references():
         if r["result"] is not None:
             result = r["result"]
             break
-        assert r["reason"] in ("warming", "boot-failed")
+        assert r["reason"] in ("warming", "boot-failed", "backend-error")
         if r["reason"] == "boot-failed":
             pytest.skip("serena failed to boot in this environment")
+        if r["reason"] == "backend-error":
+            # serena started but its language server did not (commonly a missing runtime, or no
+            # network to fetch one). The ANSWER cannot be checked here — but the invariant that
+            # made this test worth running still can, and it is the one that was broken: a backend
+            # failure must not reach the caller dressed as data. Assert that, then skip.
+            assert r["result"] is None
+            blob = f"{r.get('result')} {r.get('hint')}"
+            for leak in ("Inform the user", "initializationOptions", "Error executing tool"):
+                assert leak not in blob, f"backend error prose reached the caller: {leak!r}"
+            pytest.skip("serena's language server did not start here — error correctly reported, "
+                        "but the symbol answer cannot be verified in this environment")
         time.sleep(0.5)
 
     assert result is not None, "serena never returned a definition"

codecortex-0.15.2/src/codeintel/__init__.py

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