codecortex 0.20.0__tar.gz → 0.21.0__tar.gz

{codecortex-0.20.0/src/codecortex.egg-info → codecortex-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.20.0
+Version: 0.21.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
@@ -281,7 +281,7 @@ Then it launches the exact command it registered and drives a real MCP handshake
 ```text
 v claude: registered at /Users/you/.claude.json
 
-v verified: codeintel 0.20.0 — 4 tools (code.query, code.status, code.doctor, code.map)
+v verified: codeintel 0.21.0 — 4 tools (code.query, code.status, code.doctor, code.map)
 ```
 
 If the command is not on `PATH`, or the server fails to start, install says so and exits non-zero

{codecortex-0.20.0 → codecortex-0.21.0}/README.md

@@ -244,7 +244,7 @@ Then it launches the exact command it registered and drives a real MCP handshake
 ```text
 v claude: registered at /Users/you/.claude.json
 
-v verified: codeintel 0.20.0 — 4 tools (code.query, code.status, code.doctor, code.map)
+v verified: codeintel 0.21.0 — 4 tools (code.query, code.status, code.doctor, code.map)
 ```
 
 If the command is not on `PATH`, or the server fails to start, install says so and exits non-zero

{codecortex-0.20.0 → codecortex-0.21.0/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.20.0
+Version: 0.21.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
@@ -281,7 +281,7 @@ Then it launches the exact command it registered and drives a real MCP handshake
 ```text
 v claude: registered at /Users/you/.claude.json
 
-v verified: codeintel 0.20.0 — 4 tools (code.query, code.status, code.doctor, code.map)
+v verified: codeintel 0.21.0 — 4 tools (code.query, code.status, code.doctor, code.map)
 ```
 
 If the command is not on `PATH`, or the server fails to start, install says so and exits non-zero

{codecortex-0.20.0 → codecortex-0.21.0}/src/codecortex.egg-info/SOURCES.txt

@@ -46,6 +46,7 @@ src/codeintel/server.py
 src/codeintel/source_kind.py
 src/codeintel/term.py
 src/codeintel/verify.py
+src/codeintel/wire_text.py
 src/codeintel/commands/__init__.py
 src/codeintel/commands/_common.py
 src/codeintel/commands/c4.py
@@ -128,4 +129,5 @@ tests/test_term.py
 tests/test_treesitter.py
 tests/test_verify.py
 tests/test_verify_call.py
-tests/test_version_skew.py
+tests/test_version_skew.py
+tests/test_wire_text.py

codecortex-0.21.0/src/codeintel/__init__.py

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

{codecortex-0.20.0 → codecortex-0.21.0}/src/codeintel/graph_backend.py

@@ -27,6 +27,7 @@ import threading
 import time
 from typing import Any
 
+from codeintel import wire_text
 from codeintel.outcome import Missing
 
 
@@ -162,18 +163,7 @@ class BackendClient:
             )
             if result.returncode != 0:
                 return self._FAIL  # unsupported / error → let the raw-JSON fallback try
-            try:
-                return json.loads(result.stdout)
-            except ValueError:
-                # The backend RAN and exited 0 — it simply did not answer in JSON. That is a
-                # dialect mismatch, not a failure, and it must not be folded into the same `None`
-                # as a crash: `codebase-memory-mcp` 0.10.x replaced the `{columns, rows}` payload
-                # this provider parses with a compact human-readable text format, so every op that
-                # is not `list_projects` (still JSON) silently returned "not in graph index" — on a
-                # repository that was fully indexed. Distinguishing it is what lets the caller say
-                # so instead of sending the user to re-index for the third time.
-                self._saw_unparsable = True
-                return self._UNPARSABLE
+            return self._decode(method, result.stdout)
         except Exception:
             return self._FAIL
 
@@ -190,14 +180,36 @@ class BackendClient:
             )
             if result.returncode != 0:
                 return self._FAIL
-            try:
-                return json.loads(result.stdout)
-            except ValueError:
-                self._saw_unparsable = True
-                return self._UNPARSABLE
+            return self._decode(method, result.stdout)
         except Exception:
             return self._FAIL
 
+    def _decode(self, method: str, stdout: bytes) -> Any:
+        """One backend reply, in whichever dialect the installed backend speaks.
+
+        Two are supported. 0.9.x answers in JSON. 0.10.x answers all but `list_projects` in a
+        compact human-readable text layout — passing `--json` does not undo that, it only wraps the
+        same text in an MCP envelope — and `wire_text` translates it back into the 0.9.x-shaped
+        dict every caller above this line already parses. Neither the ops nor the renderers learn
+        that a second dialect exists.
+
+        The ordering matters: JSON is tried first, so a 0.9.x backend never pays for the text path
+        and never risks a misparse. And the text path must still be able to FAIL — a reply that is
+        no longer in a shape this release understands has to reach `_UNPARSABLE`, because the
+        "your backend and this release do not agree on a wire format" answer is the only thing that
+        made the 0.9→0.10 break diagnosable instead of looking like an unindexed repository. A
+        parser that guessed rather than refused would take that away.
+        """
+        try:
+            return json.loads(stdout)
+        except ValueError:
+            pass
+        parsed = wire_text.parse(method, stdout.decode("utf-8", "replace"))
+        if parsed is not None:
+            return parsed
+        self._saw_unparsable = True
+        return self._UNPARSABLE
+
     def _clear_failure(self) -> None:
         """Reset the per-query failure record.
 

{codecortex-0.20.0 → codecortex-0.21.0}/src/codeintel/providers/graph.py

@@ -258,13 +258,14 @@ def _collapse_repeats(label: str) -> str:
 # with a compact human-readable text format; `list_projects` stayed JSON, so project resolution and
 # `doctor` still work while EVERY other op silently returns nothing. That combination is the worst
 # possible: the tool looks healthy and answers "not in the graph index" about a fully indexed repo.
-_SUPPORTED_BACKEND = "0.9.x"
+_SUPPORTED_BACKEND = "0.9.x and 0.10.x"
 _INCOMPATIBLE_HINT = (
     "the graph backend returned a response this release cannot parse — codebase-memory-mcp "
-    f"{_SUPPORTED_BACKEND} answers with JSON rows, and 0.10.x replaced that with a text format. "
-    "Pin the supported backend (pip/uv: `pip install 'codebase-memory-mcp==0.9.*'`; standalone "
-    "binary: re-install the 0.9.x build) or check for a newer "
-    "codeintel. This is NOT a statement about whether your repository is indexed."
+    f"{_SUPPORTED_BACKEND} are both understood (0.9.x answers in JSON rows, 0.10.x in a text "
+    "layout this release reads), so this is a THIRD shape: most likely a backend newer than this "
+    "codeintel. Check for a newer codeintel, or pin a known-good backend (pip/uv: "
+    "`pip install 'codebase-memory-mcp==0.10.*'`; standalone binary: re-install a 0.10.x build). "
+    "This is NOT a statement about whether your repository is indexed."
 )
 
 
@@ -733,19 +734,18 @@ class GraphProvider:
         if self._probe_wire_format(self._any_project_name(raw)) is False:
             return {
                 "installed": True, "runnable": False, "repo_indexed": False, "project": None,
-                "detail": f"incompatible codebase-memory-mcp — this release needs "
-                          f"{_SUPPORTED_BACKEND}, which answers queries with JSON rows; the "
-                          f"installed backend replies in a text format, so every graph op except "
-                          f"project resolution returns nothing",
+                "detail": f"incompatible codebase-memory-mcp — this release speaks "
+                          f"{_SUPPORTED_BACKEND}, and the installed backend answers in neither, "
+                          f"so every graph op except project resolution returns nothing",
                 # Two install shapes exist and only one takes a pip command: the PyPI launcher, and
                 # a standalone native binary that self-manages. Naming only pip left the binary
                 # users — including this project's own maintainer — with an instruction they could
                 # not run, which is the failure mode this whole check exists to avoid.
-                "remediation": "downgrade the backend to 0.9.x — pip/uv installs: "
-                               "`pip install 'codebase-memory-mcp==0.9.*'`; standalone binary: "
-                               "re-install the 0.9.x build for your platform (note `codebase-"
-                               "memory-mcp update` self-updates back to 0.10.x). Or check for a "
-                               "newer codeintel that speaks the new format.",
+                "remediation": "upgrade codeintel first — a backend newer than this release is "
+                               "the usual cause. If that does not resolve it, pin a known-good "
+                               "backend: pip/uv installs `pip install "
+                               "'codebase-memory-mcp==0.10.*'`; standalone binary: re-install a "
+                               "0.10.x build for your platform.",
             }
         resolution = self._match_project(raw, project_root)
         if resolution is None:
@@ -1824,7 +1824,13 @@ class GraphProvider:
             saw_any = False
             for label in ("Function", "Method"):
                 got = self._search_symbols(
-                    {"label": label, "min_degree": 1, "limit": 2000}, project, timeout_ms,
+                    # `fields` asks 0.10.x for the per-node metrics this op RANKS on. They are core
+                    # columns in 0.9.x and optional ones in 0.10.x, where omitting them yields rows
+                    # whose complexity is uniformly zero — a hotspots list sorted by nothing.
+                    # 0.9.x ignores the key, so one payload serves both.
+                    {"label": label, "min_degree": 1, "limit": 2000,
+                     "fields": ["complexity", "cognitive", "is_test"]},
+                    project, timeout_ms,
                 )
                 if got is None:
                     continue

codecortex-0.21.0/src/codeintel/wire_text.py

@@ -0,0 +1,362 @@
+"""Reader for codebase-memory-mcp 0.10.x's human-readable reply format.
+
+0.9.x answered every CLI call in JSON. 0.10.x replaced that with a compact text layout for all but
+`list_projects`, so a provider written against `{"columns": [...], "rows": [...]}` gets back
+something it cannot read and — before this module — reported a fully indexed repository as "not in
+the graph index". Passing `--json` does not undo it: that flag wraps the SAME text in an MCP
+envelope (`{"content":[{"type":"text","text":"rows: 2 …"}]}`), so the structured rows are genuinely
+gone rather than hidden behind a switch.
+
+This module translates that text back into the 0.9.x-shaped dicts the rest of the provider already
+parses, so exactly one layer knows two dialects exist and no op above the transport changes.
+
+**The format is not a contract.** It is human-readable output, and it can change in a patch release
+without anything announcing it. So every function here returns ``None`` rather than a half-filled
+dict the moment the text stops matching what it expects, and the caller keeps its existing
+"backend-incompatible" safe-null for that case. A wrong answer assembled from a format we no longer
+understand is far worse than the honest refusal this replaces — that refusal is what made the
+0.9→0.10 break diagnosable in the first place.
+
+The grammar, pinned against real captures from 0.10.8:
+
+    scalar          ``key: value``
+    list section    ``key: N`` followed by two-space-indented bare lines
+    row section     ``key: N  (cols: c1 c2 …)``  — or ``(rows: …)``; the count may be absent
+    group line      ``<qualified-prefix> (<file path>):`` introducing the rows beneath it, where
+                    each row's qualified name is ``prefix + "." + name`` (the header says so)
+    row             two-space indent, values separated by spaces, Go ``%q``-quoted when the value
+                    contains a space or a quote, bare otherwise
+    null            a single ``-``
+
+The `-` for null is the one genuine ambiguity: a value that is *literally* a hyphen is
+indistinguishable from an absent one. Nothing in the graph's own vocabulary (identifiers, paths,
+labels, line ranges) is a bare hyphen, so this is accepted rather than worked around, and recorded
+here so the next reader does not have to rediscover it.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+# `key: N  (cols: a b c)` / `(rows: a b c; qn = group prefix + "." + name)`. The count is optional
+# (`impacted_modules:` ships without one). Greedy to the LAST `)` on the line, because column names
+# are Cypher expressions carrying their own parens — `labels(a)`, `type(c)` — and stopping at the
+# first one truncated the name and silently dropped every column after it. Anything past the first
+# `;` inside the parens is prose for a human and is discarded where the group is read.
+_SECTION_RE = re.compile(r"^(?P<key>[a-z_]+):\s*(?P<count>\d+)?\s*\((?:cols|rows):\s*(?P<cols>.*)\)\s*$")
+_SCALAR_RE = re.compile(r"^(?P<key>[a-z_]+):\s*(?P<value>.*)$")
+# `<qualified.name> (<path>):` — a group header. The path may contain spaces, so anchor on the
+# trailing `):` rather than splitting on whitespace.
+_GROUP_RE = re.compile(r"^(?P<prefix>\S+)\s+\((?P<file>.+)\):$")
+_INDENT = "  "
+
+_NULL = "-"
+
+
+def _unquote(tok: str) -> str:
+    """A Go ``%q`` literal back to its value; a bare token unchanged."""
+    if len(tok) >= 2 and tok[0] == '"' and tok[-1] == '"':
+        body, out, i = tok[1:-1], [], 0
+        while i < len(body):
+            ch = body[i]
+            if ch == "\\" and i + 1 < len(body):
+                nxt = body[i + 1]
+                out.append({"n": "\n", "t": "\t", "r": "\r", '"': '"', "\\": "\\"}.get(nxt, nxt))
+                i += 2
+                continue
+            out.append(ch)
+            i += 1
+        return "".join(out)
+    return tok
+
+
+def split_row(line: str) -> list[str]:
+    """Split one row into its values, honouring ``%q`` quoting.
+
+    Not `shlex`: that treats a single quote as an opener, and these payloads carry apostrophes
+    inside quoted prose (`"Prompts — all six are done"` is fine, but a docstring with `don't` is
+    not). Only the double-quote form the backend actually emits opens a token here.
+    """
+    out: list[str] = []
+    i, n = 0, len(line)
+    while i < n:
+        while i < n and line[i] == " ":
+            i += 1
+        if i >= n:
+            break
+        if line[i] == '"':
+            j = i + 1
+            while j < n:
+                if line[j] == "\\":
+                    j += 2
+                    continue
+                if line[j] == '"':
+                    break
+                j += 1
+            out.append(_unquote(line[i:min(j + 1, n)]))
+            i = j + 1
+        else:
+            j = line.index(" ", i) if " " in line[i:] else n
+            out.append(_unquote(line[i:j]))
+            i = j
+    return out
+
+
+def _cell(value: str) -> Any:
+    """One parsed value, with the backend's null marker mapped to ``None``."""
+    return None if value == _NULL else value
+
+
+def is_text_dialect(text: str) -> bool:
+    """Whether *text* looks like a 0.10.x reply at all.
+
+    Deliberately weak — it only has to separate "the backend answered in the newer layout" from
+    "the backend produced something else entirely" (an error page, a usage banner, an empty
+    stream). Deciding whether the specific reply is USABLE is each parser's job below, and that
+    decision is the one allowed to fail.
+    """
+    for line in text.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        return bool(_SCALAR_RE.match(line) or _SECTION_RE.match(line))
+    return False
+
+
+class _Doc:
+    """One parsed reply: its top-level scalars, its list sections and its row sections."""
+
+    def __init__(self, text: str) -> None:
+        self.scalars: dict[str, str] = {}
+        self.lists: dict[str, list[str]] = {}
+        self.rows: dict[str, list[dict]] = {}
+        self._parse(text.splitlines())
+
+    def _parse(self, lines: list[str]) -> None:
+        i, n = 0, len(lines)
+        while i < n:
+            line = lines[i]
+            if not line.strip():
+                i += 1
+                continue
+            sec = _SECTION_RE.match(line)
+            if sec:
+                cols = sec.group("cols").split(";")[0].split()
+                i = self._read_rows(lines, i + 1, sec.group("key"), cols)
+                continue
+            scalar = _SCALAR_RE.match(line)
+            if scalar and not line.startswith(_INDENT):
+                key, value = scalar.group("key"), scalar.group("value").strip()
+                # `changed_files: 2` followed by indented bare lines is a LIST, not a scalar. The
+                # count alone is never what a caller wants, so the payload wins and the count is
+                # dropped — it is recoverable from the list, and keeping both invites them to
+                # disagree.
+                if i + 1 < n and lines[i + 1].startswith(_INDENT) and value.isdigit():
+                    i = self._read_list(lines, i + 1, key)
+                    continue
+                self.scalars[key] = _unquote(value)
+            i += 1
+
+    def _read_list(self, lines: list[str], i: int, key: str) -> int:
+        out: list[str] = []
+        while i < len(lines) and lines[i].startswith(_INDENT):
+            out.append(_unquote(lines[i].strip()))
+            i += 1
+        self.lists[key] = out
+        return i
+
+    def _read_rows(self, lines: list[str], i: int, key: str, cols: list[str]) -> int:
+        """Rows under one section header, flattening any group lines into per-row fields.
+
+        A group line carries the qualified-name prefix and the file path for every row beneath it —
+        the header states the rule (`qn = group prefix + "." + name`) — so each row is given a
+        `_qn` and `_file` here rather than leaving every adapter below to re-derive it and one of
+        them to forget.
+        """
+        out: list[dict] = []
+        prefix = file = ""
+        while i < len(lines):
+            line = lines[i]
+            if not line.strip():
+                i += 1
+                continue
+            if not line.startswith(_INDENT):
+                group = _GROUP_RE.match(line.strip())
+                if group:
+                    prefix, file = group.group("prefix"), group.group("file")
+                    i += 1
+                    continue
+                break                                   # a new top-level key ends this section
+            values = split_row(line.strip())
+            # NOT strict: a row with fewer values than columns is a format drift, and raising
+            # here would escape into a transport whose whole contract is that it never does. The
+            # short row simply yields fewer keys, and the adapter's required-key check decides.
+            row: dict[str, Any] = {c: _cell(v)
+                                   for c, v in zip(cols, values, strict=False)}
+            name = row.get(cols[0]) if cols else None
+            row["_qn"] = f"{prefix}.{name}" if prefix and name else (name or "")
+            row["_file"] = file
+            out.append(row)
+            i += 1
+        self.rows[key] = out
+        return i
+
+
+def _int(value: Any, default: int = 0) -> int:
+    try:
+        return int(str(value))
+    except (TypeError, ValueError):
+        return default
+
+
+def _span(value: Any) -> tuple[int, int]:
+    """`"60-111"` → `(60, 111)`; a bare number → `(n, n)`; anything else → `(0, 0)`."""
+    text = str(value or "")
+    if "-" in text:
+        head, _, tail = text.partition("-")
+        return _int(head), _int(tail)
+    return _int(text), _int(text)
+
+
+def _query_graph(doc: _Doc, text: str) -> dict | None:
+    """`rows: N  (cols: …)` → the 0.9.x `{"columns": [...], "rows": [[…]]}` payload."""
+    rows = doc.rows.get("rows")
+    if rows is None:
+        return None
+    cols = [c for c in (rows[0].keys() if rows else []) if not c.startswith("_")]
+    if not cols:
+        # A zero-row answer still carries its column list in the header, and an empty result is a
+        # real answer — returning None here would turn "nothing matched" back into "backend
+        # unreadable", which is the whole confusion this module exists to end.
+        header = next((line for line in text.splitlines() if _SECTION_RE.match(line)), "")
+        match = _SECTION_RE.match(header)
+        cols = match.group("cols").split(";")[0].split() if match else []
+    return {"columns": cols,
+            "rows": [[r.get(c) for c in cols] for r in rows],
+            "total": _int(doc.scalars.get("total"), len(rows))}
+
+
+def _search_graph(doc: _Doc) -> dict | None:
+    """`results: N  (rows: name label lines in out)` → `{"results": [ … ]}`."""
+    rows = doc.rows.get("results")
+    if rows is None:
+        return None
+    out = []
+    for r in rows:
+        start, end = _span(r.get("lines"))
+        out.append({
+            "name": r.get("name"), "qualified_name": r.get("_qn"),
+            "label": r.get("label"), "file_path": r.get("_file"),
+            "in_degree": _int(r.get("in")), "out_degree": _int(r.get("out")),
+            # `complexity`/`cognitive`/`is_test` are NOT core columns in 0.10.x — they arrive only
+            # when the caller asks for them through `fields`. `hotspots` does (it ranks on
+            # complexity, and `is_test` is how it drops spec files), so they are read by their real
+            # names here and default to 0/False when a caller did not request them.
+            "complexity": _int(r.get("complexity")), "cognitive": _int(r.get("cognitive")),
+            "is_test": r.get("is_test") == "true",
+            "lines": max(0, end - start + 1) if end >= start else 0,
+        })
+    return {"total": _int(doc.scalars.get("total"), len(out)), "results": out,
+            "has_more": doc.scalars.get("has_more") == "true"}
+
+
+def _search_code(doc: _Doc) -> dict | None:
+    """`results: N  (cols: qn label file lines matches in out)` → `{"results": [ … ]}`."""
+    rows = doc.rows.get("results")
+    if rows is None:
+        return None
+    out = []
+    for r in rows:
+        start, end = _span(r.get("lines"))
+        qn = r.get("qn") or r.get("_qn") or ""
+        raw = str(r.get("matches") or "")
+        out.append({
+            "node": qn.rsplit(".", 1)[-1], "qualified_name": qn,
+            "label": r.get("label"), "file": r.get("file"),
+            "start_line": start, "end_line": end,
+            "match_lines": [_int(p) for p in raw.split(";") if p.strip()],
+            "in_degree": _int(r.get("in")), "out_degree": _int(r.get("out")),
+        })
+    return {"results": out, "total_results": _int(doc.scalars.get("total_results"), len(out))}
+
+
+def _trace_path(doc: _Doc) -> dict | None:
+    """`callees:`/`callers:` sections → `{"function", "callees": [...], "callers": [...]}`."""
+    if "callees" not in doc.rows and "callers" not in doc.rows:
+        return None
+
+    def hops(key: str) -> list[dict]:
+        out = []
+        for r in doc.rows.get(key, []):
+            qn = r.get("qn") or r.get("_qn") or ""
+            out.append({"name": qn.rsplit(".", 1)[-1], "qualified_name": qn,
+                        "hop": _int(r.get("hop")), "risk": r.get("risk")})
+        return out
+
+    return {"function": doc.scalars.get("function", ""),
+            "direction": doc.scalars.get("direction", ""),
+            "mode": doc.scalars.get("mode", ""),
+            "callees": hops("callees"), "callers": hops("callers")}
+
+
+def _get_architecture(doc: _Doc) -> dict | None:
+    """Scalars plus the `node_labels` / `edge_types` / `languages` sections."""
+    if "total_nodes" not in doc.scalars and "node_labels" not in doc.rows:
+        return None
+    def pairs(key: str, name_key: str, count_key: str, out_name: str, out_count: str) -> list[dict]:
+        return [{out_name: r.get(name_key), out_count: _int(r.get(count_key))}
+                for r in doc.rows.get(key, [])]
+    return {
+        "project": doc.scalars.get("project", ""),
+        "total_nodes": _int(doc.scalars.get("total_nodes")),
+        "total_edges": _int(doc.scalars.get("total_edges")),
+        "node_labels": pairs("node_labels", "label", "count", "label", "count"),
+        "edge_types": pairs("edge_types", "type", "count", "type", "count"),
+        "languages": pairs("languages", "language", "files", "language", "file_count"),
+    }
+
+
+def _detect_changes(doc: _Doc) -> dict | None:
+    """`changed_files` list plus the grouped `impacted` rows.
+
+    0.10.x's `impacted` is already a transitive walk (it carries a `hop`), where 0.9.x returned only
+    the symbols defined in the changed files. Both are handed back under the key the provider
+    already reads; the extra reach is a straight improvement and needs no translation.
+    """
+    if "changed_files" not in doc.lists and "changed_files" not in doc.scalars:
+        return None
+    impacted = [
+        {"name": r.get("name"), "qualified_name": r.get("_qn"), "file_path": r.get("_file"),
+         "hop": _int(r.get("hop"))}
+        for r in doc.rows.get("impacted", [])
+    ]
+    files = doc.lists.get("changed_files", [])
+    return {"changed_files": files, "changed_count": len(files),
+            "impacted_symbols": impacted, "depth": _int(doc.scalars.get("depth"), 2)}
+
+
+_PARSERS = {
+    "query_graph": lambda doc, text: _query_graph(doc, text),
+    "search_graph": lambda doc, text: _search_graph(doc),
+    "search_code": lambda doc, text: _search_code(doc),
+    "trace_path": lambda doc, text: _trace_path(doc),
+    "get_architecture": lambda doc, text: _get_architecture(doc),
+    "detect_changes": lambda doc, text: _detect_changes(doc),
+}
+
+
+def parse(method: str, text: str) -> dict | None:
+    """A 0.10.x text reply as the 0.9.x-shaped dict *method*'s caller expects.
+
+    ``None`` for anything this module cannot vouch for — an unknown method, a reply that is not in
+    the text layout, a shape that no longer matches, or any exception at all. The caller treats
+    that exactly as it treated an unreadable reply before this module existed, which keeps the
+    honest "your backend and this release do not agree" answer available as the floor.
+    """
+    try:
+        handler = _PARSERS.get(method)
+        if handler is None or not text or not is_text_dialect(text):
+            return None
+        return handler(_Doc(text), text)
+    except Exception:
+        return None

{codecortex-0.20.0 → codecortex-0.21.0}/tests/test_graph_provider.py

@@ -721,21 +721,49 @@ def _provider_speaking(stdout_bytes):
     return gp, _fake
 
 
-def test_a_text_speaking_backend_is_reported_as_incompatible_not_as_missing_data(monkeypatch):
-    """The exact 0.10.x behaviour: exit 0, and a human-readable body where JSON was promised."""
-    text = b'rows: 2  (cols: a.name)\n  "codeintel"\n  "codeintel.viewer"\ntotal: 2\n'
+def test_a_text_speaking_backend_is_now_understood(monkeypatch):
+    """The exact 0.10.x reply shape — exit 0, a human-readable body where JSON was promised.
+
+    This used to be the incompatibility case, and it is now a supported dialect: `wire_text`
+    translates the layout back into the rows every op above the transport already parses. The
+    assertions below are deliberately about the ANSWER, not about the parse: a translation that
+    produced a well-formed envelope with the wrong rows in it would be worse than the refusal it
+    replaced."""
+    text = (b'rows: 2  (cols: a.name a.qualified_name a.file_path labels(a) type(c))\n'
+            b'  bar pkg.bar bar.py "[\\"Function\\"]" CALLS\n'
+            b'  baz pkg.baz baz.py "[\\"Function\\"]" CALLS\n'
+            b'total: 2\n')
     gp, fake = _provider_speaking(text)
     monkeypatch.setattr("codeintel.providers.graph.subprocess.run", fake)
     gp._lookup_project = lambda root: ProjectLookup(                # type: ignore[method-assign]
         ProjectResolution(name="proj", matched_root="/repo", scope="exact"), "ok")
 
+    res = gp.build_result("callers", "thing", [], 5000, "/repo")
+    assert res["ok"] is True
+    assert res["result"] is not None, res
+    assert res.get("reason") is None
+    assert "pkg.bar" in res["result"] and "pkg.baz" in res["result"]
+    assert "(2)" in res["result"]
+    assert gp._saw_unparsable is False
+
+
+def test_a_third_dialect_is_still_reported_as_incompatible_not_as_missing_data(monkeypatch):
+    """The protection the test above used to provide, kept for the shape nobody has parsed yet.
+
+    Supporting a second dialect must not cost the honest refusal for a third. A reply this release
+    cannot read has to stay distinguishable from "your symbol is not in the index" — that
+    distinction is the only reason the 0.9→0.10 break was diagnosable rather than looking like an
+    unindexed repository, and the next wire change will look exactly the same from here."""
+    gp, fake = _provider_speaking(b"<html><body>gateway timeout</body></html>")
+    monkeypatch.setattr("codeintel.providers.graph.subprocess.run", fake)
+    gp._lookup_project = lambda root: ProjectLookup(                # type: ignore[method-assign]
+        ProjectResolution(name="proj", matched_root="/repo", scope="exact"), "ok")
+
     res = gp.build_result("callers", "thing", [], 5000, "/repo")
     assert res["ok"] is True
     assert res["result"] is None
-    # The critical assertion: it must NOT claim the symbol is absent from the index.
     assert res["reason"] == "backend-incompatible"
     assert res["reason"] != "not-in-graph"
-    assert "0.9" in res["hint"]
     assert "NOT a statement about whether your repository is indexed" in res["hint"]
 
 

{codecortex-0.20.0 → codecortex-0.21.0}/tests/test_graph_real.py

@@ -482,8 +482,9 @@ def test_live_callers_of_safe_null_result():
     # test_graph_provider.py and the doctor probe) — but it makes this end-to-end answer test
     # meaningless, so name it rather than failing with a confusing "no callers".
     if p._probe_wire_format(p._any_project_name(p._run("list_projects", {}, 30000))) is False:
-        pytest.skip("installed codebase-memory-mcp speaks the 0.10.x text format, which this "
-                    "release cannot parse — pin 0.9.x to run the live graph tests")
+        pytest.skip("the installed codebase-memory-mcp speaks a dialect this release cannot "
+                    "parse — 0.9.x JSON and 0.10.x text are both supported, so this is a third "
+                    "shape and an end-to-end answer test here would be meaningless")
     if p._resolve_project(REPO_ROOT) is None:
         pytest.skip("codeintel project not indexed in this environment")