codecortex 0.8.3__tar.gz → 0.8.5__tar.gz

{codecortex-0.8.3/src/codecortex.egg-info → codecortex-0.8.5}/PKG-INFO

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

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

@@ -53,6 +53,7 @@ tests/test_integration.py
 tests/test_lsp_provider.py
 tests/test_lsp_real.py
 tests/test_mapper.py
+tests/test_mcp_server.py
 tests/test_model_dimension.py
 tests/test_never_raise.py
 tests/test_onboarding.py

codecortex-0.8.5/src/codeintel/__init__.py

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

{codecortex-0.8.3 → codecortex-0.8.5}/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.3 → codecortex-0.8.5}/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.3 → codecortex-0.8.5}/src/codeintel/server.py

@@ -218,10 +218,32 @@ def code_map_handler(args: dict) -> dict:
         return {"ok": True, "path": None, "size_bytes": 0, "note": "map-error"}
 
 
+# Surfaced by the MCP client to the model on connect (the standard `instructions` field): this is
+# how codeintel becomes the *default* way an agent understands code after `codeintel install`,
+# rather than just an available tool the agent may ignore in favor of grep/file-read.
+_MCP_INSTRUCTIONS = (
+    "codeintel unifies three code-intelligence engines — graph (call/import structure), LSP "
+    "(precise symbols/references), and semantic (embedding search) — behind one never-raise "
+    "`code.query` tool.\n\n"
+    "Prefer `code.query` as your FIRST step for understanding an unfamiliar or large codebase, "
+    "instead of grepping or reading files one by one: use it for who-calls-X (callers), what-X-calls "
+    "(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"
+    "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"
+    "Every result is a safe envelope: `ok` is always true; a null `result` with a `reason` means "
+    "'nothing found / not indexed yet', NOT an error — read the `reason`/`hint` and, if it says the "
+    "repo isn't indexed, that resolves on the first query or via `codeintel index`."
+)
+
+
 def run() -> None:
+    from codeintel import __version__
     from codeintel.logconfig import configure_logging
     configure_logging()  # logs to stderr; stdout is the MCP protocol channel
-    mcp = MCPServer(name="codeintel")
+    mcp = MCPServer(name="codeintel", version=__version__, instructions=_MCP_INSTRUCTIONS)
 
     async def _code_query(
         op: str = "",
@@ -243,9 +265,26 @@ def run() -> None:
     async def _code_map(project_root: str = "", budget: int = 32768, inject: bool = False) -> dict:
         return code_map_handler({"project_root": project_root, "budget": budget, "inject": inject})
 
-    mcp.add_tool(_code_query, name="code.query", description="Query the code intelligence engine")
-    mcp.add_tool(_code_status, name="code.status", description="Return engine status")
-    mcp.add_tool(_code_doctor, name="code.doctor", description="Diagnose engine health + repo index status with remediation")
-    mcp.add_tool(_code_map, name="code.map", description="Generate or refresh CODE_INTEL.md orientation file")
+    mcp.add_tool(_code_query, name="code.query", description=(
+        "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). "
+        "`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."
+    ))
+    mcp.add_tool(_code_status, name="code.status", description=(
+        "Which engines (graph/LSP/semantic) are available and whether this repo is indexed. Check "
+        "this first if code.query keeps returning nothing."
+    ))
+    mcp.add_tool(_code_doctor, name="code.doctor", description=(
+        "Diagnose engine health + this repo's index status, with a concrete fix for each gap (what "
+        "to install or index). Run when code.query results look empty or an engine seems missing."
+    ))
+    mcp.add_tool(_code_map, name="code.map", description=(
+        "Generate/refresh CODE_INTEL.md — a ranked architecture overview (node/edge counts, top "
+        "symbols by caller count, entry points, routes). A great first call to orient on an "
+        "unfamiliar repo."
+    ))
 
     anyio.run(mcp.run_stdio_async)

{codecortex-0.8.3 → codecortex-0.8.5}/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.5/tests/test_mcp_server.py

@@ -0,0 +1,42 @@
+"""MCP server advertisement (0.8.4).
+
+`codeintel install` only makes the tools *available*; for an agent to actually reach for them
+instead of grep/file-read, the server must advertise itself — the standard MCP `instructions`
+field plus tool descriptions that say when to use each. These assert that wiring.
+"""
+from __future__ import annotations
+
+import codeintel.server as srv
+
+
+def test_server_advertises_instructions_and_rich_tool_descriptions(monkeypatch):
+    captured: dict = {"kwargs": None, "tools": {}}
+
+    class _FakeMCP:
+        def __init__(self, **kwargs):
+            captured["kwargs"] = kwargs
+
+        def add_tool(self, fn, name=None, description=None):
+            captured["tools"][name] = description or ""
+
+        async def run_stdio_async(self):  # pragma: no cover - never awaited (anyio.run stubbed)
+            pass
+
+    monkeypatch.setattr(srv, "MCPServer", _FakeMCP)
+    monkeypatch.setattr(srv.anyio, "run", lambda *a, **k: None)  # don't block on stdio
+
+    srv.run()
+
+    kw = captured["kwargs"]
+    assert kw["name"] == "codeintel"
+    assert kw.get("version")  # server reports its version
+    instr = kw.get("instructions") or ""
+    assert "code.query" in instr
+    assert "grep" in instr.lower()          # explicitly steers the agent away from grep/file-read
+    assert "reason" in instr                # explains the never-raise safe-null envelope
+
+    tools = captured["tools"]
+    assert set(tools) == {"code.query", "code.status", "code.doctor", "code.map"}
+    # the primary tool sells when to use it, not the old throwaway one-liner
+    q = tools["code.query"]
+    assert "callers" in q and "grep" in q.lower() and len(q) > 100

{codecortex-0.8.3 → codecortex-0.8.5}/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.3/src/codeintel/__init__.py

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