codecortex 0.14.0__tar.gz → 0.14.2__tar.gz

{codecortex-0.14.0/src/codecortex.egg-info → codecortex-0.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.14.0
+Version: 0.14.2
 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
@@ -439,6 +439,23 @@ docker build -t codeintel . && docker run -p 127.0.0.1:8766:8766 \
   -e CODEINTEL_HTTP_TOKEN="$(openssl rand -hex 32)" codeintel
 ```
 
+## Reporting a problem
+
+`codeintel doctor --json` prints a complete, machine-readable picture of what's installed, what's
+runnable, and whether this repo is indexed — per engine, with the remediation for each gap. Paste
+it into an issue and the report is actionable immediately instead of needing a round trip:
+
+```bash
+codeintel doctor --json
+```
+
+It reports only local engine and index state. Over the HTTP transport the `registrations` field —
+which names agent config files on the machine running the server — is deliberately omitted.
+
+If a *result* looks wrong rather than a command failing, include the exact `code.query` call and
+its full envelope. `reason`, `hint`, `engine`, `cached`, and `reindexing` between them explain
+which engine answered and how current its index was, which is usually the whole diagnosis.
+
 ## Development
 
 ```bash

{codecortex-0.14.0 → codecortex-0.14.2}/README.md

@@ -402,6 +402,23 @@ docker build -t codeintel . && docker run -p 127.0.0.1:8766:8766 \
   -e CODEINTEL_HTTP_TOKEN="$(openssl rand -hex 32)" codeintel
 ```
 
+## Reporting a problem
+
+`codeintel doctor --json` prints a complete, machine-readable picture of what's installed, what's
+runnable, and whether this repo is indexed — per engine, with the remediation for each gap. Paste
+it into an issue and the report is actionable immediately instead of needing a round trip:
+
+```bash
+codeintel doctor --json
+```
+
+It reports only local engine and index state. Over the HTTP transport the `registrations` field —
+which names agent config files on the machine running the server — is deliberately omitted.
+
+If a *result* looks wrong rather than a command failing, include the exact `code.query` call and
+its full envelope. `reason`, `hint`, `engine`, `cached`, and `reindexing` between them explain
+which engine answered and how current its index was, which is usually the whole diagnosis.
+
 ## Development
 
 ```bash

{codecortex-0.14.0 → codecortex-0.14.2/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.14.0
+Version: 0.14.2
 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
@@ -439,6 +439,23 @@ docker build -t codeintel . && docker run -p 127.0.0.1:8766:8766 \
   -e CODEINTEL_HTTP_TOKEN="$(openssl rand -hex 32)" codeintel
 ```
 
+## Reporting a problem
+
+`codeintel doctor --json` prints a complete, machine-readable picture of what's installed, what's
+runnable, and whether this repo is indexed — per engine, with the remediation for each gap. Paste
+it into an issue and the report is actionable immediately instead of needing a round trip:
+
+```bash
+codeintel doctor --json
+```
+
+It reports only local engine and index state. Over the HTTP transport the `registrations` field —
+which names agent config files on the machine running the server — is deliberately omitted.
+
+If a *result* looks wrong rather than a command failing, include the exact `code.query` call and
+its full envelope. `reason`, `hint`, `engine`, `cached`, and `reindexing` between them explain
+which engine answered and how current its index was, which is usually the whole diagnosis.
+
 ## Development
 
 ```bash

codecortex-0.14.2/src/codeintel/__init__.py

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

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/commands/_common.py

@@ -18,6 +18,17 @@ def resolve_root(args: Any) -> str:
     return getattr(args, "project_root", None) or os.getcwd()
 
 
+def require_dir(project_root: str, command: str) -> str | None:
+    """An error line when *project_root* is not a directory, else None.
+
+    A mistyped path used to produce confident, well-formed output about a directory that does not
+    exist — `setup /typo` rendered a full three-engine health table for it — which is the worst
+    possible response to a typo in a script, because it is indistinguishable from success."""
+    if os.path.isdir(project_root):
+        return None
+    return f"{command} failed: not a directory: {project_root}"
+
+
 def emit(report: dict, *, as_json: bool, render: Callable[[dict], str]) -> None:
     """Print a report as structured JSON (--json) or as its human-facing text rendering."""
     if as_json:

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/commands/graph.py

@@ -3,7 +3,7 @@
 import json
 from typing import Any
 
-from codeintel.commands._common import never_raise, resolve_root
+from codeintel.commands._common import never_raise, require_dir, resolve_root
 
 
 # code=1: this command's job is to WRITE A FILE. Exiting 0 after failing to write it
@@ -12,7 +12,12 @@ from codeintel.commands._common import never_raise, resolve_root
 def run(args: Any) -> int:
     from codeintel import grapher
 
-    payload = grapher.build_graph_payload(resolve_root(args), limit=args.limit)
+    project_root = resolve_root(args)
+    problem = require_dir(project_root, "graph")
+    if problem:
+        print(problem)
+        return 1
+    payload = grapher.build_graph_payload(project_root, limit=args.limit)
     nodes, edges = len(payload.get("nodes", [])), len(payload.get("edges", []))
 
     if not args.html:

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/commands/map.py

@@ -2,7 +2,7 @@
 
 from typing import Any
 
-from codeintel.commands._common import never_raise, resolve_root
+from codeintel.commands._common import never_raise, require_dir, resolve_root
 
 
 # Never-raise parity with the MCP code.map handler — degrade, don't crash.
@@ -15,6 +15,10 @@ def run(args: Any) -> int:
     from codeintel.providers.graph import GraphProvider
 
     project_root = resolve_root(args)
+    problem = require_dir(project_root, "map")
+    if problem:
+        print(problem)
+        return 1
     try:
         provider = GraphProvider()
     except Exception:

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/commands/setup.py

@@ -2,16 +2,21 @@
 
 from typing import Any
 
-from codeintel.commands._common import emit, never_raise, resolve_root
+from codeintel.commands._common import emit, never_raise, require_dir, resolve_root
 
 
 @never_raise("setup unavailable: {exc}")
 def run(args: Any) -> int:
     from codeintel import onboarding
 
+    project_root = resolve_root(args)
+    problem = require_dir(project_root, "setup")
+    if problem:
+        print(problem)
+        return 1
     all_steps = getattr(args, "all_steps", False)  # --all implies every automatable step
     report = onboarding.run_setup(
-        resolve_root(args),
+        project_root,
         install_uv=args.install_uv or all_steps,
         install_deps=args.install_deps or all_steps,
         do_index=args.index or all_steps,

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/commands/status.py

@@ -4,7 +4,7 @@ import datetime
 import os
 from typing import Any
 
-from codeintel.commands._common import never_raise, resolve_root
+from codeintel.commands._common import never_raise, require_dir, resolve_root
 
 # "available" alone was the misleading word: it meant "a binary is on PATH", which is not the same
 # as runnable, and not the same as usable on THIS repo. Say which.
@@ -16,6 +16,10 @@ def run(args: Any) -> int:
     from codeintel import server
 
     project_root = resolve_root(args)
+    problem = require_dir(project_root, "status")
+    if problem:
+        print(problem)
+        return 1
     status = server.code_status_handler({"project_root": project_root})
 
     readiness = status.get("readiness") or {}

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/gateway.py

@@ -40,6 +40,15 @@ _UNCACHED_OPS: frozenset[str] = frozenset({"changed", "changes"})
 _ADOPTABLE_ENGINES: frozenset[str] = frozenset({"graph", "lsp", "semantic"})
 
 
+def _mark_reindexing(result: Result, reindexing: bool) -> Result:
+    """Flag an answer served while a reindex for its project is still running."""
+    if not reindexing or result.get("result") is None:
+        return result
+    return {**result, "reindexing": True,
+            "hint": "a reindex is in progress — this answer reflects the index as of the last "
+                    "completed pass; re-ask shortly if you have just changed this code"}
+
+
 class Gateway:
     def __init__(self, graph=None, lsp=None, semantic=None, policy: TieringPolicy | None = None,
                  reindexer: Reindexer | None = None):
@@ -236,6 +245,16 @@ class Gateway:
             except Exception:
                 pass
 
+            # If a reindex is running, this answer comes from the PREVIOUS index. Structural
+            # answers (callers/impact/hotspots) hash a symbol name, not file bytes, so nothing
+            # else in the envelope can reveal that — and an agent that just edited and asked
+            # "what did I break?" lands precisely here. Busting the cache would not help: the
+            # index itself is behind, so re-asking refetches the same stale data.
+            try:
+                reindexing = self._reindexer.reindex_pending(str(project_root or ""))
+            except Exception:
+                reindexing = False
+
             # Legacy list-based path (backward compat with pre-Phase-2 tests)
             if self._legacy_providers is not None:
                 for p in self._legacy_providers:
@@ -324,7 +343,7 @@ class Gateway:
 
             if not uncacheable:
                 self._cache.put(op_str, target_str, cache_engine, root_str, result, freshness)
-            return result
+            return _mark_reindexing(result, reindexing)
 
         except Exception as exc:
             log_swallowed("Gateway.query", exc)

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/indexer.py

@@ -18,6 +18,10 @@ logger = logging.getLogger(__name__)
 # Generous enough that no hand-written function is affected.
 _MAX_CHUNK_CHARS = 200_000
 
+# Bytes examined when deciding whether a file is binary. A NUL in the first block is the classic
+# signal and is what `git` itself uses.
+_BINARY_SNIFF_BYTES = 8192
+
 _INDEXED_EXTS = frozenset({
     ".py", ".md",
     ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",       # TS/JS variants
@@ -108,6 +112,15 @@ def _ts_decl_is_function(node) -> bool:
     return False
 
 
+def _looks_binary(path) -> bool:
+    """Whether *path* is binary, by the same rule git uses: a NUL byte in the opening block."""
+    try:
+        with open(path, "rb") as fh:
+            return b"\x00" in fh.read(_BINARY_SNIFF_BYTES)
+    except OSError:
+        return True                        # unreadable → treat as unindexable rather than crash
+
+
 class Indexer:
     def __init__(
         self,
@@ -210,6 +223,10 @@ class Indexer:
         except Exception as exc:
             logger.warning("Cleanup pass failed: %s", exc)
 
+    @staticmethod
+    def _binary_check(path) -> bool:
+        return _looks_binary(path)
+
     def _walk_files(self, root: Path):
         """Indexable files inside *root* — and strictly inside it.
 
@@ -259,6 +276,13 @@ class Indexer:
                     logger.warning("skipping %s — %d hard links, so its content may also live "
                                    "outside the indexed root", candidate, links)
                     continue
+                # A source extension is not a promise of source. A compiled artifact or blob named
+                # `.py` was read with errors="replace" and embedded as replacement-character
+                # garbage — 196KB of /dev/urandom produced 162 chunks — which then competed for
+                # rank against real code in every search.
+                if _looks_binary(candidate):
+                    logger.warning("skipping %s — looks binary despite its extension", candidate)
+                    continue
                 yield candidate
 
     # ---- chunk-span computation ------------------------------------------------------------

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/installer.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import os
 import pathlib
+import re
 import shutil
 
 _AGENTS = ["claude", "codex", "gemini", "zed"]
@@ -308,10 +309,41 @@ class Installer:
             return None
         return None
 
+    @staticmethod
+    def _looks_like_jsonc(text: str) -> bool:
+        """Whether *text* is JSON-with-comments — valid for Zed, invalid for `json.loads`."""
+        stripped = re.sub(r"/\*.*?\*/", "", text, flags=re.S)
+        stripped = re.sub(r"(?m)^\s*//.*$", "", stripped)
+        stripped = re.sub(r",(\s*[}\]])", r"\1", stripped)
+        try:
+            json.loads(stripped)
+        except Exception:
+            return False
+        return True
+
     def _register_json(self, agent: str, config_path: pathlib.Path, spec: dict,
                        command: str) -> dict:
         if config_path.exists():
-            data = json.loads(config_path.read_text(encoding="utf-8"))
+            raw = config_path.read_text(encoding="utf-8")
+            try:
+                data = json.loads(raw)
+            except json.JSONDecodeError:
+                # Zed ships settings.json as JSONC — comments and trailing commas — so strict
+                # parsing fails and every Zed user was blocked with an opaque "Expecting value".
+                # Parsing the JSONC and writing back with json.dumps would be WORSE: it would
+                # silently delete the user's comments, which in Zed's default config is most of
+                # the file. Until this can insert textually (the way the Codex TOML path does),
+                # hand the user the exact block instead of damaging their editor config.
+                if self._looks_like_jsonc(raw):
+                    entry = json.dumps({spec["key"][-1] if spec.get("key") else "codeintel":
+                                        launch_value(command)}, indent=2)
+                    raise ValueError(
+                        f"{config_path} is JSONC (it has comments or trailing commas), which "
+                        f"codeintel will not rewrite because doing so would discard your "
+                        f"comments. Add this to \"{'.'.join(spec['key'][:-1]) or 'the root'}\" "
+                        f"by hand:\n{entry}"
+                    ) from None
+                raise
             if not isinstance(data, dict):
                 # Every other malformed-input path here fails safe (invalid JSON → failed, no
                 # write). Silently substituting {} made this the one branch that DESTROYED the

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/provider.py

@@ -33,6 +33,10 @@ class Result(TypedDict):
     cached: bool
     reason: NotRequired[str]
     hint: NotRequired[str]
+    # Set when the answer was served while a reindex for its project was still running, i.e. it
+    # reflects the last COMPLETED index rather than the current source. Optional, and the MCP
+    # tools deliberately return plain `dict` so this never becomes a required schema field.
+    reindexing: NotRequired[bool]
 
 
 @runtime_checkable

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/providers/graph.py

@@ -26,6 +26,28 @@ _GRAPH_OPS = frozenset({
 })
 
 
+def _strip_project_prefix(qualified_name: str) -> str:
+    """Drop the backend's project id from the head of a qualified name.
+
+    The backend prefixes every qualified name with its own project id, which for a path-slug
+    registration is the flattened absolute path — so each result line began
+    `Users-alice-Documents-project-myrepo.src.pkg.fn`. That is the author's home directory
+    layout repeated on every row: noise for a human, wasted tokens for the agent this tool
+    exists to serve, on results that can run to a hundred lines.
+
+    Only a leading path-slug-looking segment is removed. A qualified name that starts with a
+    real module (`src.codeintel.gateway.query`) is left exactly as it is.
+    """
+    head, sep, rest = qualified_name.partition(".")
+    if not sep:
+        return qualified_name
+    # A slug: no spaces, and hyphenated (the backend joins path components with "-"). A genuine
+    # Python package name cannot contain a hyphen, so this cannot eat a real module.
+    if "-" in head and " " not in head:
+        return rest
+    return qualified_name
+
+
 def _repo_display_name(root: str) -> str:
     """The repo's own directory name, for headings a human will read.
 
@@ -276,7 +298,7 @@ class GraphProvider:
     @staticmethod
     def _display(row: dict, name_key: str, qn_key: str, file_key: str) -> str:
         name = str(row.get(name_key) or "?")
-        qn = str(row.get(qn_key) or "")
+        qn = _strip_project_prefix(str(row.get(qn_key) or ""))
         file = str(row.get(file_key) or "")
         edge = str(row.get("type(c)") or "").strip()
         label = qn or name

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/reindexer.py

@@ -52,12 +52,27 @@ class Reindexer:
         # folds it into the cache key so a structural answer is invalidated once the
         # index actually moves (a symbol/free-text target has no file content to hash).
         self._generation: dict[str, int] = {}
+        # Roots with a reindex submitted but not yet finished. The index is KNOWN to be behind
+        # while this holds, and no amount of cache invalidation fixes that — re-asking just
+        # refetches the same stale index, more expensively. The only honest response is to say so.
+        self._in_flight: set[str] = set()
         self._executor = _DaemonPool(max_workers=2)
 
     def generation(self, project_root: str) -> int:
         with self._lock:
             return self._generation.get(project_root, 0)
 
+    def reindex_pending(self, project_root: str) -> bool:
+        """Whether this root has a reindex running right now.
+
+        Lets a caller distinguish "this is the current structure" from "this is the structure as
+        of the last completed index, and a newer one is being built". An agent's loop is edit →
+        ask what I broke, which lands exactly in that window."""
+        if not project_root:
+            return False
+        with self._lock:
+            return project_root in self._in_flight
+
     def maybe_reindex(self, project_root: str) -> None:
         if not self._enabled:
             return
@@ -66,6 +81,12 @@ class Reindexer:
 
         now = time.monotonic()
         with self._lock:
+            # Already running: skip. The debounce timestamp is set when a pass is SUBMITTED, not
+            # when it finishes, so on a repo whose reindex outlasts the window every later query
+            # stacked another concurrent pass — overlapping writers against one SQLite file and
+            # one graph subprocess, for no benefit.
+            if project_root in self._in_flight:
+                return
             last = self._last_fired.get(project_root, 0.0)
             if now - last < self._debounce_seconds:
                 return
@@ -77,6 +98,8 @@ class Reindexer:
         if self._reindex_disabled(project_root):
             return
 
+        with self._lock:
+            self._in_flight.add(project_root)
         self._executor.submit(self._do_reindex, project_root)
 
     def _reindex_disabled(self, project_root: str) -> bool:
@@ -113,6 +136,7 @@ class Reindexer:
         finally:
             with self._lock:
                 self._generation[project_root] = self._generation.get(project_root, 0) + 1
+                self._in_flight.discard(project_root)
 
     def _semantic_reindex(self, project_root: str) -> None:
         import pathlib

{codecortex-0.14.0 → codecortex-0.14.2}/src/codeintel/semantic_db.py

@@ -149,7 +149,11 @@ class SemanticDb:
             if self.dimension is not None:
                 logger.warning(
                     "embedding dimension %d != cache dimension %d — skipping write; run "
-                    "`codeintel reset` to rebuild the semantic index for the new model",
+                    # `reset` alone cannot fix this: the vec0 table's dimension is fixed at
+                    # creation and the table is SHARED across every project in this cache file,
+                    # so a project-scoped reset (which only DELETEs that project's rows) leaves
+                    # it in place and the warning repeats forever. `--all` drops the file.
+                    "`codeintel reset --all` to rebuild the semantic index for the new model",
                     dim, self.dimension,
                 )
                 return None

{codecortex-0.14.0 → codecortex-0.14.2}/tests/test_chunking.py

@@ -363,3 +363,39 @@ def test_switching_strategy_reconciles_stale_line_chunks(tmp_path):
 
     # 25-line def > max_chunk_lines(40)? no — 25 <= 40, so it becomes ONE def chunk at line 0.
     assert syntax_starts == {0}
+
+
+def test_a_binary_file_with_a_source_extension_is_not_indexed(tmp_path):
+    """A source extension is not a promise of source. A compiled artifact named `.py` was read
+    with errors="replace" and embedded as replacement-character garbage — 196KB of random bytes
+    produced 162 chunks — which then competed for rank against real code in every search."""
+    from codeintel.indexer import Indexer
+    from codeintel.semantic_db import SemanticDb
+
+    (tmp_path / "real.py").write_text("def hello():\n    return 1\n")
+    (tmp_path / "blob.py").write_bytes(b"\x7fELF\x00\x00\x00" + os.urandom(4096))
+
+    db = SemanticDb(str(tmp_path / "db.sqlite"))
+    db.init()
+    try:
+        names = sorted(f.name for f in Indexer(db)._walk_files(tmp_path))
+    finally:
+        db.close()
+
+    assert names == ["real.py"], f"a binary file was queued for embedding: {names}"
+
+
+def test_utf8_source_with_unusual_characters_is_still_indexed(tmp_path):
+    """Guard the guard: the NUL sniff must not reject legitimate non-ASCII source."""
+    from codeintel.indexer import Indexer
+    from codeintel.semantic_db import SemanticDb
+
+    (tmp_path / "unicode.py").write_text("# ünïcödé ✓ 日本語\ndef f():\n    return '→'\n",
+                                         encoding="utf-8")
+    db = SemanticDb(str(tmp_path / "db.sqlite"))
+    db.init()
+    try:
+        names = sorted(f.name for f in Indexer(db)._walk_files(tmp_path))
+    finally:
+        db.close()
+    assert names == ["unicode.py"]

{codecortex-0.14.0 → codecortex-0.14.2}/tests/test_cli_commands.py

@@ -792,3 +792,21 @@ def test_index_reports_an_unrecoverable_indexer_failure(monkeypatch, tmp_path, c
     assert import_module("codeintel.commands.index").run(_args(project_root=str(tmp_path))) == 1
     out = capsys.readouterr().out
     assert "index failed" in out and "Nothing new to index" not in out
+
+
+# --------------------------------------------------------------------------- root validation
+
+@pytest.mark.parametrize("command,args_", [
+    ("setup", {"project_root": None, "all_steps": False, "install_uv": False,
+               "install_deps": False, "index": False, "warm": False, "json": False}),
+    ("status", {"project_root": None}),
+    ("map", {"project_root": None, "inject": False, "budget": 32768}),
+    ("graph", {"project_root": None, "html": False, "out": None, "limit": 220}),
+])
+def test_a_nonexistent_project_root_fails_loudly(command, args_, tmp_path, capsys):
+    """A mistyped path produced confident, well-formed output about a directory that does not
+    exist — `setup /typo` rendered a full three-engine health table for it. In a script that is
+    indistinguishable from success, which is the worst possible response to a typo."""
+    args_ = {**args_, "project_root": str(tmp_path / "does-not-exist")}
+    assert import_module(f"codeintel.commands.{command}").run(_args(args_)) == 1
+    assert "not a directory" in capsys.readouterr().out

{codecortex-0.14.0 → codecortex-0.14.2}/tests/test_gateway.py

@@ -409,3 +409,96 @@ def test_cache_get_and_put_always_use_the_same_key():
 
     keys = {engine_arg(c) for c in gets} | {engine_arg(c) for c in puts}
     assert keys == {"cache_engine"}, f"cache key components disagree: {keys}"
+
+
+# --------------------------------------------------------------------------- staleness signalling
+
+class _Answering:
+    available = True
+
+    def build_result(self, op, target, files, budget, project_root):
+        return {"ok": True, "op": op, "target": target, "result": "ANSWER",
+                "engine": "graph", "cached": False}
+
+
+def test_an_answer_served_during_a_reindex_says_so():
+    """Structural answers hash a symbol NAME, not file bytes, so nothing else in the envelope can
+    reveal that the index is behind. An agent's loop is edit -> ask what I broke, which lands
+    exactly in that window. Invalidating the cache would not help: the index itself is stale, so
+    re-asking just refetches the same data more expensively. Saying so is the only honest fix."""
+    from codeintel.gateway import Gateway
+    from codeintel.reindexer import Reindexer
+
+    rx = Reindexer()
+    gw = Gateway(graph=_Answering(), lsp=None, semantic=None, reindexer=rx)
+    rx._in_flight.add("/repo")
+
+    res = gw.query(op="callers", target="f", role="", project_root="/repo")
+    assert res["result"] == "ANSWER"                 # still answers — this is a caveat, not a error
+    assert res["reindexing"] is True
+    assert "re-ask" in res["hint"]
+
+
+def test_a_settled_index_does_not_flag_an_answer():
+    """The signal must be rare enough to mean something — flagging every answer would train a
+    reader to ignore it. Steady state is: a reindex ran, the debounce window has not elapsed, so
+    no new pass fires and answers come back unqualified. (The FIRST query for a root does fire one
+    and is legitimately flagged while it runs — the index really is being rebuilt underneath.)"""
+    import time
+
+    from codeintel.gateway import Gateway
+    from codeintel.reindexer import Reindexer
+
+    rx = Reindexer()
+    rx._last_fired["/repo"] = time.monotonic()      # inside the debounce window: nothing re-fires
+    gw = Gateway(graph=_Answering(), lsp=None, semantic=None, reindexer=rx)
+
+    res = gw.query(op="callers", target="f", role="", project_root="/repo")
+    assert res["result"] == "ANSWER"
+    assert res.get("reindexing") is None
+
+
+def test_an_empty_result_is_not_flagged_as_reindexing():
+    """`reindexing` qualifies an answer. On a safe-null there is no answer to qualify, and the
+    `reason`/`hint` already carry the explanation."""
+    from codeintel.gateway import Gateway
+    from codeintel.provider import safe_null_result
+    from codeintel.reindexer import Reindexer
+
+    class _Empty(_Answering):
+        def build_result(self, op, target, files, budget, project_root):
+            return safe_null_result(op, target, engine="graph", reason="not-in-graph")
+
+    rx = Reindexer()
+    gw = Gateway(graph=_Empty(), lsp=None, semantic=None, reindexer=rx)
+    rx._in_flight.add("/repo")
+
+    res = gw.query(op="callers", target="f", role="", project_root="/repo")
+    assert res.get("reindexing") is None
+    assert res["reason"] == "not-in-graph"
+
+
+def test_reindex_pending_clears_once_the_pass_completes(monkeypatch):
+    from codeintel.reindexer import Reindexer
+
+    rx = Reindexer()
+    monkeypatch.setattr(rx, "_semantic_reindex", lambda root: None)
+    monkeypatch.setattr(rx, "_graph_reindex", lambda root: None)
+
+    rx._in_flight.add("/repo")
+    assert rx.reindex_pending("/repo") is True
+    rx._do_reindex("/repo")
+    assert rx.reindex_pending("/repo") is False, "a completed reindex must clear the flag"
+
+
+def test_reindex_pending_clears_even_when_both_passes_fail(monkeypatch):
+    """A stuck flag would mark every later answer stale and train the reader to ignore it."""
+    from codeintel.reindexer import Reindexer
+
+    rx = Reindexer()
+    for name in ("_semantic_reindex", "_graph_reindex"):
+        monkeypatch.setattr(rx, name, lambda root: (_ for _ in ()).throw(RuntimeError("down")))
+
+    rx._in_flight.add("/repo")
+    rx._do_reindex("/repo")
+    assert rx.reindex_pending("/repo") is False

{codecortex-0.14.0 → codecortex-0.14.2}/tests/test_graph_provider.py

@@ -308,3 +308,25 @@ def test_overview_falls_back_to_the_backend_name_without_a_root(monkeypatch):
         "project": "backend-id", "total_nodes": 5, "total_edges": 4})
 
     assert gp._op_overview("", "backend-id", 1000, "").splitlines()[0] == "## Architecture: backend-id"
+
+
+def test_result_lines_do_not_carry_the_backends_project_id(tmp_path):
+    """The backend prefixes every qualified name with its project id — for a path-slug
+    registration, the flattened ABSOLUTE PATH. Every result line therefore began
+    `Users-alice-Documents-project-myrepo.src.pkg.fn`: the author's home directory repeated per
+    row, on results that run to a hundred lines. Noise for a human, wasted tokens for the agent
+    this tool exists to serve."""
+    from codeintel.providers.graph import _strip_project_prefix
+
+    assert _strip_project_prefix(
+        "Users-alice-Documents-project-myrepo.src.pkg.fn") == "src.pkg.fn"
+    assert _strip_project_prefix("my-repo.src.pkg.fn") == "src.pkg.fn"
+
+
+def test_stripping_never_eats_a_real_module_path():
+    """A hyphen cannot appear in a Python package name, which is what makes the slug detectable —
+    so a genuine dotted module path must pass through untouched."""
+    from codeintel.providers.graph import _strip_project_prefix
+
+    for qn in ("src.codeintel.gateway.query", "codeintel.server.run", "main", "", "pkg.mod"):
+        assert _strip_project_prefix(qn) == qn

{codecortex-0.14.0 → codecortex-0.14.2}/tests/test_installer.py

@@ -561,3 +561,38 @@ def test_install_refuses_to_overwrite_a_non_object_config(tmp_path, monkeypatch)
 
     assert result["ok"] is False
     assert cfg.read_text() == "[1, 2, 3]\n", "the user's file was overwritten"
+
+
+def test_zed_jsonc_config_is_not_rewritten_and_the_error_is_actionable(tmp_path, monkeypatch):
+    """Zed ships settings.json as JSONC — comments and trailing commas — so strict parsing failed
+    and every Zed user was blocked by an opaque "Expecting value". Parsing the JSONC and writing
+    back with json.dumps would be WORSE: it would silently delete the user's comments, which in
+    Zed's default config is most of the file. Fail, keep the file intact, and hand over the block.
+    """
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "xdg"))
+    cfg = tmp_path / "xdg" / "zed" / "settings.json"
+    cfg.parent.mkdir(parents=True)
+    original = '{\n  // Font settings\n  "buffer_font_size": 14,\n  "theme": "One Dark",\n}\n'
+    cfg.write_text(original)
+
+    res = Installer().register("zed")
+
+    assert res["ok"] is False
+    assert cfg.read_text() == original, "the user's editor config was modified"
+    assert "JSONC" in res["reason"] and "context_servers" in res["reason"]
+    assert "codeintel" in res["reason"]                 # the block to paste is in the message
+
+
+def test_plain_invalid_json_still_reports_the_parse_error(tmp_path, monkeypatch):
+    """Only genuine JSONC gets the special path — a truly corrupt file must not be misdiagnosed."""
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(tmp_path))
+    cfg = tmp_path / ".claude.json"
+    cfg.write_text("{ this is not json at all ")
+
+    res = Installer().register("claude")
+
+    assert res["ok"] is False
+    assert "JSONC" not in res["reason"]
+    assert cfg.read_text() == "{ this is not json at all "

{codecortex-0.14.0 → codecortex-0.14.2}/tests/test_reindexer.py

@@ -260,3 +260,23 @@ def test_repeated_failures_keep_advancing_rather_than_pinning_at_zero(monkeypatc
     for _ in range(3):
         r._do_reindex("/repo")
     assert r.generation("/repo") == 3
+
+
+def test_a_reindex_already_running_is_not_submitted_again(monkeypatch):
+    """The debounce timestamp is set when a pass is SUBMITTED, not when it finishes, so on a repo
+    whose reindex outlasts the window every later query stacked another concurrent pass —
+    overlapping writers against one SQLite file and one graph subprocess, for no benefit."""
+    r = Reindexer(debounce_seconds=0)
+    submitted = []
+    monkeypatch.setattr(r._executor, "submit", lambda fn, root: submitted.append(root))
+
+    r.maybe_reindex("/repo")
+    assert submitted == ["/repo"]
+
+    r.maybe_reindex("/repo")          # still in flight (nothing cleared it)
+    r.maybe_reindex("/repo")
+    assert submitted == ["/repo"], "a second pass was stacked on a running one"
+
+    r._in_flight.discard("/repo")     # the running pass completes
+    r.maybe_reindex("/repo")
+    assert submitted == ["/repo", "/repo"]

codecortex-0.14.0/src/codeintel/__init__.py

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