codecortex 0.8.4__tar.gz → 0.9.0__tar.gz

{codecortex-0.8.4/src/codecortex.egg-info → codecortex-0.9.0}/PKG-INFO

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

{codecortex-0.8.4 → codecortex-0.9.0/src/codecortex.egg-info}/PKG-INFO

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

codecortex-0.9.0/src/codeintel/__init__.py

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

{codecortex-0.8.4 → codecortex-0.9.0}/src/codeintel/doctor.py

@@ -102,11 +102,21 @@ def run_doctor(
                               "runnable": False, "repo_indexed": None,
                               "detail": "semantic provider unavailable", "remediation": None}
 
+    # Is def-aligned (tree-sitter) chunking active for non-Python files? The semantic engine works
+    # without it (line-window fallback) but SILENTLY — surface it so a broken/missing grammar pack
+    # doesn't degrade chunking invisibly. find_spec (not import) keeps this cheap + never-load.
+    try:
+        import importlib.util
+        treesitter = importlib.util.find_spec("tree_sitter_language_pack") is not None
+    except Exception:
+        treesitter = False
+
     ready = sum(1 for e in engines.values() if e.get("status") != "fail")
     return {
         "ok": True,
         "project_root": root,
         "deep": bool(deep),
+        "treesitter": treesitter,
         "summary": {"ready": ready, "total": len(engines),
                     "healthy": all(e.get("status") != "fail" for e in engines.values())},
         "engines": engines,
@@ -163,4 +173,9 @@ def render_doctor_text(report: dict) -> str:
             "tip: `codeintel setup --install-uv --install-deps --index` bootstraps the "
             "pip-installable backends; each fix: line above has the per-engine command."
         ))
+    if report.get("treesitter") is False:
+        out.append("  " + c.dim(
+            "def-aligned chunking: OFF for non-Python — tree-sitter-language-pack not importable, "
+            "so TS/JS/Go/Rust/… fall back to line windows. fix: pip install tree-sitter-language-pack"
+        ))
     return "\n".join(out)

{codecortex-0.8.4 → codecortex-0.9.0}/src/codeintel/gateway.py

@@ -20,11 +20,21 @@ _AUTO_ENGINE: dict[str, str] = {
     "chain": "graph",
     "pattern": "graph",
     "overview": "graph",
+    "changed": "graph",
+    "changes": "graph",
+    "deadcode": "graph",
+    "hotspots": "graph",
     "symbol": "lsp",
     "search": "semantic",
     "context": "both",  # fan-out; resolved in Phase 4
 }
 
+# Ops whose answer depends on live, unhashable state (the git worktree) rather than the indexed
+# content the cache key is built from — caching them would serve a stale answer within a freshness
+# generation. `changed` reads uncommitted edits; `deadcode`/`hotspots` are pure functions of the
+# index and stay cached (correctly keyed by the freshness generation).
+_UNCACHED_OPS: frozenset[str] = frozenset({"changed", "changes"})
+
 
 class Gateway:
     def __init__(self, graph=None, lsp=None, semantic=None, policy: TieringPolicy | None = None, reindexer: Reindexer | None = None):
@@ -199,9 +209,17 @@ class Gateway:
             except Exception:
                 freshness = 0
 
+            # Ops that read live, unhashable state (the git worktree) must never be served from the
+            # content-hash cache — it can't see uncommitted edits. Computed ONCE here so it covers
+            # BOTH the fan-out and the single-engine paths below (a miss on either serves a stale diff).
+            uncacheable = op_str in _UNCACHED_OPS
+
             # Fan-out: dispatch to multiple engines concurrently and merge
             if engine_str in _FANOUT_ENGINES:
-                cached_result = self._cache.get(op_str, target_str, engine_str, root_str, freshness)
+                cached_result = (
+                    None if uncacheable
+                    else self._cache.get(op_str, target_str, engine_str, root_str, freshness)
+                )
                 if cached_result is not None:
                     return {**cached_result, "cached": True}
                 if engine_str == "both":
@@ -210,11 +228,15 @@ class Gateway:
                     engines = ["graph", "lsp", "semantic"]
                 fan_results = self._fan_out(engines, op_str, target_str, budget, project_root)
                 result = self._merge(fan_results, op_str, target_str, engine_str)
-                self._cache.put(op_str, target_str, engine_str, root_str, result, freshness)
+                if not uncacheable:
+                    self._cache.put(op_str, target_str, engine_str, root_str, result, freshness)
                 return result
 
-            # Single-engine dispatch
-            cached_result = self._cache.get(op_str, target_str, engine_str, root_str, freshness)
+            # Single-engine dispatch (`uncacheable`, computed above, also guards this path).
+            cached_result = (
+                None if uncacheable
+                else self._cache.get(op_str, target_str, engine_str, root_str, freshness)
+            )
             if cached_result is not None:
                 return {**cached_result, "cached": True}
             provider = self._provider_for(engine_str)
@@ -236,7 +258,8 @@ class Gateway:
                 if lsp_result.get("result") is not None:
                     result = lsp_result
 
-            self._cache.put(op_str, target_str, engine_str, root_str, result, freshness)
+            if not uncacheable:
+                self._cache.put(op_str, target_str, engine_str, root_str, result, freshness)
             return result
 
         except Exception as exc:

{codecortex-0.8.4 → codecortex-0.9.0}/src/codeintel/indexer.py

@@ -85,6 +85,22 @@ _TS_CONTAINER_TYPES = {
     "c": set(),
     "cpp": {"class_specifier", "struct_specifier", "namespace_definition"},
 }
+# JS/TS assign functions to bindings — `const C = () => {}`, `export const f = function(){}` — which
+# is how React components and hooks (and most modern TS) are written. A lexical/variable declaration
+# counts as a def ONLY when a declarator's value is a function, not a plain `const x = 5`.
+_TS_ARROW_LANGS = frozenset({"typescript", "tsx", "javascript"})
+_TS_DECL_TYPES = frozenset({"lexical_declaration", "variable_declaration"})
+_TS_FUNC_VALUE_TYPES = frozenset({"arrow_function", "function_expression", "function",
+                                  "generator_function"})
+
+
+def _ts_decl_is_function(node) -> bool:
+    """True if a lexical/variable declaration binds a function (arrow or function expression)."""
+    for child in node.children:
+        if child.type == "variable_declarator":
+            if any(gc.type in _TS_FUNC_VALUE_TYPES for gc in child.children):
+                return True
+    return False
 
 
 class Indexer:
@@ -330,19 +346,26 @@ class Indexer:
         func_types = _TS_FUNC_TYPES.get(lang, set())
         cont_types = _TS_CONTAINER_TYPES.get(lang, set())
         all_types = func_types | cont_types
+        arrow_ok = lang in _TS_ARROW_LANGS
         if not all_types:
             return []  # unknown language -> caller windows the whole file
         spans: list[tuple[int, int]] = []
 
+        def is_def(c) -> bool:
+            if c.type in all_types:
+                return True
+            # a const/let bound to an arrow/function (React components, hooks, callbacks)
+            return arrow_ok and c.type in _TS_DECL_TYPES and _ts_decl_is_function(c)
+
         def nearest_defs(node):
-            """Def-type nodes reachable without crossing another def-type — top-level defs from the
-            root, a container's direct members from the container. Iterative, so deep nesting can't
-            blow the stack."""
+            """Def nodes reachable without crossing another def — top-level defs from the root, a
+            container's direct members from the container. Iterative, so deep nesting can't blow the
+            stack. Function-bound `const`/`let` declarations count as defs (is_def)."""
             found = []
             stack = [c for c in reversed(node.children) if c.is_named]
             while stack:
                 c = stack.pop()
-                if c.type in all_types:
+                if is_def(c):
                     found.append(c)
                 else:
                     stack.extend(g for g in reversed(c.children) if g.is_named)

{codecortex-0.8.4 → codecortex-0.9.0}/src/codeintel/providers/graph.py

@@ -28,6 +28,13 @@ class GraphProvider:
                              or ``{"status": "ambiguous", "suggestions": [...]}``.
       * ``search_code``    → ``{"results": [{node, qualified_name, label, file, match_lines}]}``.
       * ``get_architecture`` → ``{project, total_nodes, total_edges, node_labels, edge_types, languages}``.
+      * ``search_graph``   → ``{"total": N, "results": [{name, qualified_name, file_path, in_degree,
+                             out_degree, complexity, cognitive, lines, is_test, is_entry_point}, ...]}``
+                             — degree filters (max_degree/min_degree/exclude_entry_points) + metrics.
+      * ``detect_changes`` → ``{"changed_files": [path, ...], "impacted_symbols": [{qualified_name,
+                             name, file_path}, ...], "changed_count": N, "depth": D}``. changed_files
+                             come DUPLICATED (staged+unstaged); impacted_symbols interleaves bare file
+                             markers (label == file_path) with real symbols.
 
     Call graph: module-level function calls are recorded as ``USAGE`` edges from the calling
     ``Module`` node; method/function-to-method calls are ``CALLS`` edges. "Who calls X" therefore
@@ -226,6 +233,61 @@ class GraphProvider:
         badge = f" [{edge}]" if edge else ""
         return f"- {label}{badge}{tail}"
 
+    def _search_symbols(self, extra: dict, project: str, timeout_ms: int) -> Optional[list[dict]]:
+        """``search_graph`` → parsed result dicts. ``None`` = backend failed/malformed (→ safe-null
+        upstream); ``[]`` = backend answered but nothing matched (→ an informative empty render).
+        Preserving that distinction is why the repo-scan ops return a string on empty-success but
+        ``None`` on can't-answer. Never raises."""
+        raw = self._run("search_graph", {"project": project, **extra}, timeout_ms)
+        if raw is None:
+            return None
+        results = raw.get("results") if isinstance(raw, dict) else raw
+        if not isinstance(results, list):
+            return None
+        return [r for r in results if isinstance(r, dict)]
+
+    @staticmethod
+    def _looks_like_test(fp: str, name: str) -> bool:
+        """Heuristic test detection. The backend's own ``is_test`` flag comes back False for pytest
+        functions (verified by dogfooding), so dead-code / hotspot scans must filter by path+name
+        or drown in test noise — this is the single most load-bearing renderer detail."""
+        f = (fp or "").lower()
+        if f.startswith(("tests/", "test/")) or "/tests/" in f or "/test/" in f:
+            return True
+        base = f.rsplit("/", 1)[-1]
+        return (base.startswith("test_") or base.endswith("_test.py")
+                or base == "conftest.py" or (name or "").startswith("test_"))
+
+    @staticmethod
+    def _is_synthetic(fp: str) -> bool:
+        """Builtins / generated nodes carry an empty or ``<...>`` file_path (e.g. <python-builtins>)."""
+        return (not fp) or fp.startswith("<")
+
+    @classmethod
+    def _is_noise(cls, r: dict) -> bool:
+        """Rows a code-quality scan should hide: builtins/generated nodes and test code (the backend's
+        own ``is_test`` is unreliable — see ``_looks_like_test``). Shared by deadcode + hotspots."""
+        fp = str(r.get("file_path") or "")
+        return cls._is_synthetic(fp) or cls._looks_like_test(fp, str(r.get("name") or ""))
+
+    def _render_scan(self, kept: list[dict], title: str, cap: int, meta_fn) -> str:
+        """Render a repo-scan op's markdown from filtered+sorted rows: ``## title (count)`` + one
+        ``- label (file)  [meta]`` line per row (top ``cap``) + a ``+N more`` note when truncated.
+        ``meta_fn(row) -> list[str]`` supplies the per-op metric badge, so deadcode/hotspots share
+        the row format and truncation note (the drift-prone parts) and differ only in their metrics."""
+        lines = []
+        for r in kept[:cap]:
+            label = str(r.get("qualified_name") or r.get("name") or "?")
+            fp = str(r.get("file_path") or "")
+            meta = meta_fn(r)
+            badge = f"  [{', '.join(meta)}]" if meta else ""
+            tail = f"  ({fp})" if fp else ""
+            lines.append(f"- {label}{tail}{badge}")
+        body = "\n".join(lines)
+        if len(kept) > cap:
+            body += f"\n… (+{len(kept) - cap} more)"
+        return f"## {title} ({len(kept)})\n" + body
+
     # ------------------------------------------------------------------ ops
 
     def _op_callers(self, target: str, project: str, timeout_ms: int) -> Optional[str]:
@@ -269,7 +331,7 @@ class GraphProvider:
             return None
         raw = self._run(
             "trace_path",
-            {"project": project, "function_name": src, "mode": "calls"},
+            {"project": project, "function_name": src, "mode": "calls", "risk_labels": True},
             timeout_ms,
         )
         if not isinstance(raw, dict):
@@ -291,9 +353,11 @@ class GraphProvider:
                     nm = str(it.get("name") or "?")
                     qn = str(it.get("qualified_name") or "")
                     hop = it.get("hop")
+                    risk = it.get("risk")
                     label = qn or nm
                     hop_s = f" [hop {hop}]" if hop is not None else ""
-                    out.append(f"- {label}{hop_s}")
+                    risk_s = f" [risk: {risk}]" if risk else ""
+                    out.append(f"- {label}{hop_s}{risk_s}")
             return out
 
         callees = _fmt(raw.get("callees"))
@@ -378,6 +442,125 @@ class GraphProvider:
         except Exception:
             return None
 
+    # -------------------------------------------------- repo-scan ops (no target)
+    # These key on the whole index / git worktree, not a symbol — `target` is ignored. A clean/empty
+    # scan is a TRUE answer ("nothing changed", "no dead code"), not a lookup miss, so they return an
+    # informative string; only a backend failure returns None (→ safe-null upstream).
+
+    def _op_changed(self, project: str, timeout_ms: int) -> Optional[str]:
+        """Impact of the working tree's UNCOMMITTED changes: changed files → impacted symbols. The
+        flagship pre-edit op. detect_changes drives a backend-side reindex of the changed files, so
+        it gets a higher timeout floor than a plain read."""
+        try:
+            raw = self._run("detect_changes", {"project": project}, max(timeout_ms, 15000))
+            if not isinstance(raw, dict):
+                return None
+            files_raw = raw.get("changed_files")
+            syms_raw = raw.get("impacted_symbols")
+            # Guard against a non-detect_changes dict (e.g. a backend error object): if NEITHER key
+            # is a list, this isn't a real response — degrade to safe-null, NOT a false "clean tree".
+            if not isinstance(files_raw, list) and not isinstance(syms_raw, list):
+                return None
+            # The backend returns DUPLICATE changed_files (staged + unstaged views) — dedupe,
+            # order-preserving (dogfooding showed 6 real files reported as 11).
+            files, seen_f = [], set()
+            for f in files_raw if isinstance(files_raw, list) else []:
+                if isinstance(f, str) and f not in seen_f:
+                    seen_f.add(f)
+                    files.append(f)
+            # impacted_symbols interleaves real symbols with bare file/module markers whose label IS
+            # its own path (name == qualified_name == file_path). Drop those structurally by comparing
+            # label to file_path — this catches a root-level marker (`main.py`, no "/") AND avoids
+            # dropping a real symbol whose qualified name legitimately contains "/" (e.g. Go's
+            # github.com/org/pkg.Func). Files are already listed above; dedupe the rest.
+            syms, seen_s = [], set()
+            for s in syms_raw if isinstance(syms_raw, list) else []:
+                if not isinstance(s, dict):
+                    continue
+                label = str(s.get("qualified_name") or s.get("name") or "").strip()
+                fp = str(s.get("file_path") or s.get("file") or "")
+                if not label or label == fp:
+                    continue
+                key = (label, fp)
+                if key in seen_s:
+                    continue
+                seen_s.add(key)
+                syms.append((label, fp))
+            if not files and not syms:
+                return "## Changes impact\n(working tree clean — no uncommitted changes)"
+            parts = [f"## Changes impact ({len(files)} files → {len(syms)} symbols)"]
+            if files:
+                parts.append(f"### Changed files ({len(files)})")
+                parts.extend(f"- {f}" for f in files[:40])
+                if len(files) > 40:
+                    parts.append(f"… (+{len(files) - 40} more)")
+            if syms:
+                parts.append(f"### Impacted symbols ({len(syms)})")
+                for label, fp in syms[:40]:
+                    tail = f"  ({fp})" if fp and fp != label else ""
+                    parts.append(f"- {label}{tail}")
+                if len(syms) > 40:
+                    parts.append(f"… (+{len(syms) - 40} more)")
+            return "\n".join(parts)
+        except Exception:
+            return None
+
+    def _op_deadcode(self, project: str, timeout_ms: int) -> Optional[str]:
+        """Unreferenced non-test symbols (dead-code candidates): in-degree 0 Functions, entry points
+        excluded server-side, tests/builtins filtered client-side, biggest first."""
+        try:
+            rows = self._search_symbols(
+                {"label": "Function", "max_degree": 0, "exclude_entry_points": True, "limit": 200},
+                project, timeout_ms,
+            )
+            if rows is None:
+                return None
+            # `is_entry_point` is deliberate belt-and-suspenders on top of the server-side
+            # exclude_entry_points flag: it's an external-backend flag we don't independently verify,
+            # and main() shown as "dead" would be a visible embarrassment — one cheap client check.
+            kept = [r for r in rows if not self._is_noise(r) and not r.get("is_entry_point")]
+            if not kept:
+                return "## Dead-code candidates\n(none found)"
+            kept.sort(key=lambda r: r.get("lines") or 0, reverse=True)
+
+            def _meta(r: dict) -> list[str]:
+                m = []
+                if r.get("out_degree") is not None:
+                    m.append(f"out:{r.get('out_degree')}")
+                if r.get("lines") is not None:
+                    m.append(f"{r.get('lines')} lines")
+                return m
+
+            return self._render_scan(kept, "Dead-code candidates", 30, _meta)
+        except Exception:
+            return None
+
+    def _op_hotspots(self, project: str, timeout_ms: int) -> Optional[str]:
+        """Highest complexity / fan-in symbols (refactor-risk hotspots). search_graph returns rows
+        UNSORTED (name order) and caps at ``limit``, so we over-request then sort CLIENT-SIDE by
+        (complexity, in_degree). Tests/builtins filtered out."""
+        try:
+            rows = self._search_symbols(
+                {"label": "Function", "min_degree": 1, "limit": 200}, project, timeout_ms,
+            )
+            if rows is None:
+                return None
+            kept = [r for r in rows if not self._is_noise(r)]
+            if not kept:
+                return "## Complexity / fan-in hotspots\n(none found)"
+            kept.sort(key=lambda r: (r.get("complexity") or 0, r.get("in_degree") or 0), reverse=True)
+
+            def _meta(r: dict) -> list[str]:
+                m = [f"in:{r.get('in_degree') or 0} out:{r.get('out_degree') or 0}",
+                     f"cx:{r.get('complexity') or 0} cog:{r.get('cognitive') or 0}"]
+                if r.get("lines") is not None:
+                    m.append(f"{r.get('lines')} lines")
+                return m
+
+            return self._render_scan(kept, "Complexity / fan-in hotspots", 25, _meta)
+        except Exception:
+            return None
+
     def build_result(
         self,
         op: Any,
@@ -439,4 +622,10 @@ class GraphProvider:
             return self._op_pattern(target, project, timeout_ms)
         if op == "overview":
             return self._op_overview(target, project, timeout_ms)
+        if op == "changed" or op == "changes":
+            return self._op_changed(project, timeout_ms)
+        if op == "deadcode":
+            return self._op_deadcode(project, timeout_ms)
+        if op == "hotspots":
+            return self._op_hotspots(project, timeout_ms)
         return None

{codecortex-0.8.4 → codecortex-0.9.0}/src/codeintel/server.py

@@ -230,6 +230,8 @@ _MCP_INSTRUCTIONS = (
     "(callees), impact of a change, where-a-symbol-is-defined, how a call chain flows, and "
     "natural-language 'find the code that does Y' search. It is graph-augmented and ranked, so it "
     "beats raw grep for locating and relating code.\n\n"
+    "Before you edit, run `changed` to see which symbols your uncommitted edits ripple into; reach "
+    "for `hotspots` (complexity/fan-in risk) and `deadcode` when planning a refactor.\n\n"
     "Orient on a new repo with `code.map` (ranked architecture: top symbols, entry points, routes). "
     "If results look empty, call `code.doctor` — it says exactly what to index or install. "
     "`code.status` reports engine health.\n\n"
@@ -269,7 +271,9 @@ def run() -> None:
         "Understand code across graph + LSP + semantic engines — prefer this over grep/file-read "
         "for locating and relating code. ops: `search` (natural-language or symbol semantic search), "
         "`symbol` (definition/signature), `callers`, `callees`, `impact`, `chain` (\"A->B\" call "
-        "path), `pattern` (graph-augmented grep), `overview` (architecture), `context` (fan-out). "
+        "path, risk-labeled), `pattern` (graph-augmented grep), `overview` (architecture), "
+        "`context` (fan-out), `changed` (impact of your uncommitted git edits — no target needed), "
+        "`deadcode` (unreferenced non-test symbols), `hotspots` (highest fan-in/complexity symbols). "
         "`target` is the symbol/query; optional `engine` (auto|graph|lsp|semantic), `project_root`. "
         "Never raises: `ok` is always true; a null `result` + `reason` means not-found/not-indexed."
     ))

{codecortex-0.8.4 → codecortex-0.9.0}/tests/test_doctor.py

@@ -64,6 +64,25 @@ def test_setup_tip_footer_only_when_unhealthy():
     assert "codeintel setup" in unhealthy      # actionable guidance only when something is missing
 
 
+def test_treesitter_advisory_only_when_missing():
+    # the silent tree-sitter fallback (found by dogfooding) must be visible: an advisory when
+    # def-aligned chunking is OFF, nothing when it's on
+    base = {"project_root": "/repo", "deep": False,
+            "summary": {"ready": 3, "total": 3, "healthy": True},
+            "engines": {"semantic": {"engine": "semantic", "status": "ok", "installed": True,
+                                     "runnable": True, "repo_indexed": True, "detail": "ok",
+                                     "remediation": None}}}
+    off = doctor.render_doctor_text({**base, "treesitter": False})
+    on = doctor.render_doctor_text({**base, "treesitter": True})
+    assert "def-aligned chunking: OFF" in off and "tree-sitter-language-pack" in off
+    assert "def-aligned chunking" not in on   # no noise when it's active
+
+
+def test_run_doctor_reports_treesitter_availability():
+    r = doctor.run_doctor("/tmp/x", deep=False)
+    assert isinstance(r.get("treesitter"), bool)   # always reported (bool), never raises
+
+
 # --------------------------------------------------------------------------- #
 # never-raise + no-hang orchestration
 # --------------------------------------------------------------------------- #

{codecortex-0.8.4 → codecortex-0.9.0}/tests/test_gateway.py

@@ -198,6 +198,36 @@ def test_cache_miss_after_content_change(tmp_path):
     assert r3["cached"] is False
 
 
+def test_changed_op_is_never_cached_but_hotspots_is():
+    # `changed` reads the live git worktree — which the content-hash cache key can't see — so it must
+    # bypass the cache or it serves a stale diff. `hotspots` is a pure function of the index → cached.
+    graph = _StubProvider("graph", "graph-data")
+    gw = Gateway(graph=graph)
+
+    c1 = gw.query(op="changed", target="", engine="graph")
+    c2 = gw.query(op="changed", target="", engine="graph")
+    assert c1["cached"] is False and c2["cached"] is False   # never a cache hit
+    assert graph.call_count == 2                              # provider re-invoked every call
+
+    graph.call_count = 0
+    h1 = gw.query(op="hotspots", target="", engine="graph")
+    h2 = gw.query(op="hotspots", target="", engine="graph")
+    assert h1["cached"] is False and h2["cached"] is True     # second served from cache
+    assert graph.call_count == 1
+
+
+def test_changed_not_cached_on_fanout_path():
+    # Regression for the reviewer's HIGH finding: the fan-out path (engine="both"/"all") must ALSO
+    # bypass the cache for `changed` — else an explicit engine="both" serves a stale diff.
+    graph = _StubProvider("graph", "graph-data")
+    lsp = _StubProvider("lsp", "lsp-data")
+    gw = Gateway(graph=graph, lsp=lsp)
+    r1 = gw.query(op="changed", target="", engine="both")
+    r2 = gw.query(op="changed", target="", engine="both")
+    assert r1["cached"] is False and r2["cached"] is False   # never a cache hit on fan-out either
+    assert graph.call_count == 2                              # re-dispatched each call, not cached
+
+
 # ---------------------------------------------------------------------------
 # Test 11: tiering off — role ignored, all ops pass
 # ---------------------------------------------------------------------------

{codecortex-0.8.4 → codecortex-0.9.0}/tests/test_graph_real.py

@@ -97,6 +97,58 @@ CAP_TRACE_AMBIGUOUS = {
 }
 
 
+# detect_changes — real shape (verbatim from `codebase-memory-mcp cli detect_changes`).
+CAP_DETECT_CHANGES = {
+    "changed_files": ["src/codeintel/providers/graph.py"],
+    "changed_count": 1, "depth": 2,
+    "impacted_symbols": [
+        {"qualified_name": "codeintel.src.codeintel.providers.graph.GraphProvider._dispatch",
+         "name": "_dispatch", "file_path": "src/codeintel/providers/graph.py"}],
+}
+CAP_DETECT_CHANGES_CLEAN = {"changed_files": [], "changed_count": 0, "impacted_symbols": [], "depth": 2}
+
+# Real backend quirk (caught by dogfooding): changed_files come back DUPLICATED (staged + unstaged),
+# and impacted_symbols interleaves bare file/module markers (label is a path) with real symbols.
+CAP_DETECT_CHANGES_DUPES = {
+    "changed_files": ["src/codeintel/gateway.py", "src/codeintel/gateway.py", "src/codeintel/server.py"],
+    "impacted_symbols": [
+        {"name": "src/codeintel/gateway.py", "qualified_name": "src/codeintel/gateway.py",
+         "file_path": "src/codeintel/gateway.py"},                       # module marker → dropped
+        {"name": "Gateway", "qualified_name": "codeintel.src.codeintel.gateway.Gateway",
+         "file_path": "src/codeintel/gateway.py"},
+        {"name": "Gateway", "qualified_name": "codeintel.src.codeintel.gateway.Gateway",
+         "file_path": "src/codeintel/gateway.py"},                       # exact dup → deduped
+    ],
+}
+
+# search_graph — real envelope {"total","has_more","results":[{…rich metrics…}]}. The `is_test:false`
+# on a pytest function is the real trap the client-side path filter exists to catch.
+CAP_DEADCODE = {"total": 8, "has_more": False, "results": [
+    {"name": "test_x", "qualified_name": "codeintel.tests.test_a.test_x", "file_path": "tests/test_a.py",
+     "in_degree": 0, "out_degree": 0, "complexity": 0, "lines": 3, "is_test": False, "is_entry_point": False},
+    {"name": "unused_helper", "qualified_name": "codeintel.src.codeintel.foo.unused_helper",
+     "file_path": "src/codeintel/foo.py", "in_degree": 0, "out_degree": 2, "complexity": 4, "lines": 18,
+     "is_test": False, "is_entry_point": False},
+]}
+# Deliberately NOT complexity-sorted (backend returns name order) — proves the client-side sort.
+CAP_HOTSPOTS = {"total": 3, "has_more": False, "results": [
+    {"name": "code_status_handler", "qualified_name": "codeintel.src.codeintel.server.code_status_handler",
+     "file_path": "src/codeintel/server.py", "in_degree": 5, "out_degree": 5, "complexity": 15,
+     "cognitive": 34, "lines": 61},
+    {"name": "len", "qualified_name": "builtins.len", "file_path": "<python-builtins>",
+     "in_degree": 12, "out_degree": 0, "complexity": 0},
+    {"name": "main", "qualified_name": "codeintel.src.codeintel.__main__.main",
+     "file_path": "src/codeintel/__main__.py", "in_degree": 1, "out_degree": 41, "complexity": 33,
+     "cognitive": 110, "lines": 220},
+]}
+CAP_TRACE_RISK = {
+    "function": "code_status_handler", "direction": "both",
+    "callees": [{"name": "str", "qualified_name": "builtins.str", "hop": 2, "risk": "HIGH"}],
+    "callers": [{"name": "main", "qualified_name": "codeintel.src.codeintel.__main__.main",
+                 "hop": 1, "risk": "CRITICAL"}],
+}
+
+
 def _provider(monkeypatch, responses):
     """A GraphProvider whose _run replays captured responses keyed by method."""
     monkeypatch.setattr(
@@ -253,6 +305,174 @@ def test_run_raising_is_caught(monkeypatch):
     assert r["ok"] is True  # never-raise holds even when _run throws mid-query
 
 
+# --------------------------------------------------------------------------- #
+# 5 — repo-scan ops: changed / deadcode / hotspots + risk-labeled chain (0.9.0)
+# --------------------------------------------------------------------------- #
+
+ROOT = "/Users/x/Documents/project/codeintel"
+
+
+def _capturing_provider(monkeypatch, method_response):
+    """Provider that records the (method, payload, timeout) of the non-list_projects call."""
+    seen: dict = {}
+    monkeypatch.setattr("codeintel.providers.graph.shutil.which", lambda x: "/fake/codebase-memory-mcp")
+    p = GraphProvider()
+
+    def _cap(method, payload, timeout_ms):
+        if method == "list_projects":
+            return CAP_LIST_PROJECTS
+        seen["method"], seen["payload"], seen["timeout"] = method, payload, timeout_ms
+        return method_response
+    monkeypatch.setattr(p, "_run", _cap)
+    return p, seen
+
+
+def test_changed_renders_files_and_impacted_symbols(monkeypatch):
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "detect_changes": CAP_DETECT_CHANGES})
+    r = p.build_result("changed", "", [], 0, ROOT)
+    assert r["ok"] is True and r["result"] is not None
+    assert "Changes impact (1 files → 1 symbols)" in r["result"]
+    assert "src/codeintel/providers/graph.py" in r["result"]
+    assert "GraphProvider._dispatch" in r["result"]
+
+
+def test_changed_clean_tree_is_informative_not_null(monkeypatch):
+    # A clean tree is a TRUE answer, not a lookup miss — a string, NOT safe-null (else the op looks broken).
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "detect_changes": CAP_DETECT_CHANGES_CLEAN})
+    r = p.build_result("changed", "", [], 0, ROOT)
+    assert r["result"] is not None and "working tree clean" in r["result"]
+
+
+def test_changed_dedupes_files_and_drops_module_markers(monkeypatch):
+    # Regression for the dogfood finding: 3→2 files (gateway dedup'd); 3→1 symbols (path-marker
+    # dropped, Gateway dedup'd). The header count encodes both fixes.
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "detect_changes": CAP_DETECT_CHANGES_DUPES})
+    r = p.build_result("changed", "", [], 0, ROOT)
+    assert "Changes impact (2 files → 1 symbols)" in r["result"]
+    assert "Gateway" in r["result"]
+
+
+def test_changed_backend_failure_is_safe_null(monkeypatch):
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "detect_changes": None})
+    r = p.build_result("changed", "", [], 0, ROOT)
+    assert r["ok"] is True and r["result"] is None
+
+
+def test_changed_malformed_dict_is_safe_null(monkeypatch):
+    # A dict that isn't a detect_changes shape (e.g. a backend error object) must degrade to
+    # safe-null, NOT render a false "working tree clean". (reviewer warning)
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "detect_changes": {"error": "boom"}})
+    r = p.build_result("changed", "", [], 0, ROOT)
+    assert r["ok"] is True and r["result"] is None
+
+
+def test_changed_drops_root_level_file_markers(monkeypatch):
+    # A changed file at the project ROOT yields a marker whose label has no "/". The structural
+    # label==file_path filter drops it (a "/"-in-label check would leak it as a fake symbol).
+    resp = {"changed_files": ["main.py"], "impacted_symbols": [
+        {"name": "main.py", "qualified_name": "main.py", "file_path": "main.py"},   # root marker → dropped
+        {"name": "run", "qualified_name": "main.run", "file_path": "main.py"},      # real symbol → kept
+    ]}
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "detect_changes": resp})
+    r = p.build_result("changed", "", [], 0, ROOT)
+    assert "Changes impact (1 files → 1 symbols)" in r["result"]   # marker dropped, real symbol kept
+    assert "main.run" in r["result"]
+
+
+def test_changed_keeps_symbol_with_slash_in_qualified_name(monkeypatch):
+    # Go-style qualified names contain "/". The old "/"-in-label filter would wrongly drop them;
+    # label != file_path so the structural filter keeps them. (reviewer inverse-direction finding)
+    resp = {"changed_files": ["pkg/svc.go"], "impacted_symbols": [
+        {"name": "Serve", "qualified_name": "github.com/org/repo/pkg.Serve", "file_path": "pkg/svc.go"},
+    ]}
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "detect_changes": resp})
+    r = p.build_result("changed", "", [], 0, ROOT)
+    assert "github.com/org/repo/pkg.Serve" in r["result"]          # kept despite "/" in qualified name
+    assert "Changes impact (1 files → 1 symbols)" in r["result"]
+
+
+def test_changed_payload_ignores_target_and_raises_timeout_floor(monkeypatch):
+    p, seen = _capturing_provider(monkeypatch, CAP_DETECT_CHANGES_CLEAN)
+    p.build_result("changed", "ignored-target", [], 0, ROOT)
+    assert seen["method"] == "detect_changes"
+    assert seen["payload"] == {"project": "codeintel"}   # target never leaks into the payload
+    assert seen["timeout"] >= 15000                        # higher floor: it drives a backend reindex
+
+
+def test_deadcode_filters_tests_and_synthetic(monkeypatch):
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "search_graph": CAP_DEADCODE})
+    r = p.build_result("deadcode", "", [], 0, ROOT)
+    assert r["result"] is not None
+    assert "unused_helper" in r["result"]     # real dead code kept
+    assert "test_x" not in r["result"]        # pytest fn dropped despite backend is_test:false
+
+
+def test_deadcode_all_filtered_is_informative(monkeypatch):
+    only_tests = {"total": 1, "results": [CAP_DEADCODE["results"][0]]}  # just test_x
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "search_graph": only_tests})
+    r = p.build_result("deadcode", "", [], 0, ROOT)
+    assert r["result"] is not None and "none found" in r["result"]
+
+
+def test_deadcode_malformed_is_safe_null(monkeypatch):
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "search_graph": {"results": "nope"}})
+    r = p.build_result("deadcode", "", [], 0, ROOT)
+    assert r["ok"] is True and r["result"] is None
+
+
+def test_deadcode_payload_has_degree_filters(monkeypatch):
+    p, seen = _capturing_provider(monkeypatch, CAP_DEADCODE)
+    p.build_result("deadcode", "", [], 0, ROOT)
+    assert seen["payload"].get("max_degree") == 0
+    assert seen["payload"].get("exclude_entry_points") is True
+    assert seen["payload"].get("label") == "Function"
+
+
+def test_hotspots_sorts_by_complexity_client_side(monkeypatch):
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "search_graph": CAP_HOTSPOTS})
+    r = p.build_result("hotspots", "", [], 0, ROOT)
+    assert r["result"] is not None
+    # main (cx33) must rank above code_status_handler (cx15) despite the backend's name order.
+    assert r["result"].index("__main__.main") < r["result"].index("code_status_handler")
+    assert "builtins.len" not in r["result"]   # synthetic builtin filtered out
+    assert "cx:33" in r["result"]
+
+
+def test_hotspots_payload_has_min_degree(monkeypatch):
+    p, seen = _capturing_provider(monkeypatch, CAP_HOTSPOTS)
+    p.build_result("hotspots", "", [], 0, ROOT)
+    assert seen["payload"].get("min_degree") is not None
+    assert seen["payload"].get("label") == "Function"
+
+
+def test_chain_carries_risk_labels(monkeypatch):
+    p = _provider(monkeypatch, {"list_projects": CAP_LIST_PROJECTS, "trace_path": CAP_TRACE_RISK})
+    r = p.build_result("chain", "code_status_handler", [], 0, ROOT)
+    assert r["result"] is not None
+    assert "[risk: CRITICAL]" in r["result"] and "[risk: HIGH]" in r["result"]
+
+
+def test_chain_requests_risk_labels(monkeypatch):
+    p, seen = _capturing_provider(monkeypatch, CAP_TRACE_RISK)
+    p.build_result("chain", "code_status_handler", [], 0, ROOT)
+    assert seen["method"] == "trace_path" and seen["payload"].get("risk_labels") is True
+
+
+def test_new_ops_never_raise_when_run_throws(monkeypatch):
+    monkeypatch.setattr("codeintel.providers.graph.shutil.which", lambda x: "/fake/codebase-memory-mcp")
+    p = GraphProvider()
+
+    def _boom(method, payload, timeout_ms):
+        if method == "list_projects":
+            return CAP_LIST_PROJECTS
+        raise RuntimeError("backend exploded")
+
+    monkeypatch.setattr(p, "_run", _boom)
+    for op in ("changed", "deadcode", "hotspots"):
+        r = p.build_result(op, "", [], 0, ROOT)
+        assert r["ok"] is True, f"{op} must never raise"
+
+
 @pytest.mark.skipif(
     shutil.which("codebase-memory-mcp") is None,
     reason="codebase-memory-mcp backend not installed",

{codecortex-0.8.4 → codecortex-0.9.0}/tests/test_treesitter.py

@@ -97,6 +97,29 @@ def test_java_class_method():
     assert 0 in starts and 1 in starts   # class header + method m
 
 
+def test_arrow_function_consts_are_def_aligned():
+    # React components / hooks / callbacks are `const X = () => {}`, not `function` declarations —
+    # they must def-align too (the common modern-TS/React case); a plain data const must NOT.
+    src = (
+        "import x from 'y';\n"              # 0
+        "\n"                                # 1
+        "export const Header = () => {\n"   # 2  arrow component
+        "  return null;\n"                  # 3
+        "};\n"                              # 4
+        "\n"                                # 5
+        "const useThing = (id) => {\n"      # 6  arrow hook
+        "  return id;\n"                    # 7
+        "};\n"                              # 8
+        "\n"                                # 9
+        "const PLAIN = 42;\n"               # 10 plain data const — NOT a def
+    )
+    spans, n = _spans("c.tsx", src)
+    _assert_gapless_cover(spans, n)
+    starts = {s for s, _ in spans}
+    assert 2 in starts and 6 in starts   # both arrow consts are their own chunks
+    assert 10 not in starts              # a plain `const x = 42` is not a def chunk
+
+
 def test_cpp_class_and_free_function():
     src = ("class C {\npublic:\n  int m() { return 1; }\n};\nint free_fn() { return 2; }\n")
     spans, n = _spans("e.cpp", src)

codecortex-0.8.4/src/codeintel/__init__.py

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