codecortex 0.8.4__tar.gz → 0.8.5__tar.gz

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.8.4
+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.5/src/codeintel/__init__.py

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

{codecortex-0.8.4 → 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.4 → 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.4 → 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.4 → 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.4/src/codeintel/__init__.py

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