java-codebase-rag 0.10.0__tar.gz → 0.10.2__tar.gz

{java_codebase_rag-0.10.0/src/java_codebase_rag.egg-info → java_codebase_rag-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.10.0
+Version: 0.10.2
 Summary: MCP server for semantic + structural search over Java codebases
 Author: HumanBean17
 License-Expression: MIT

{java_codebase_rag-0.10.0 → java_codebase_rag-0.10.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "java-codebase-rag"
-version = "0.10.0"
+version = "0.10.2"
 description = "MCP server for semantic + structural search over Java codebases"
 readme = "README.md"
 requires-python = ">=3.11"

{java_codebase_rag-0.10.0 → java_codebase_rag-0.10.2}/src/java_codebase_rag/mcp/mcp_v2.py

@@ -50,15 +50,49 @@ from java_codebase_rag.graph.ladybug_queries import LadybugGraph, OVERRIDE_AXIS_
 from java_codebase_rag.mcp.mcp_hints import MCP_HINTS_STRUCTURED_FIELD_DESCRIPTION
 
 # The vector stack (lancedb/torch, reached via search_lancedb) is optional — it is absent on
-# graph-only installs (macOS Intel). Import eagerly when available so ``run_search``/``TABLES``
-# exist as module attributes (tests monkeypatch ``mcp_v2.run_search``; callers use ``TABLES``);
-# fall back to sentinels on ImportError so importing this module never fails and ``search_v2``
-# can return a clean "vector search unavailable" envelope instead of crashing.
-try:
-    from java_codebase_rag.search.search_lancedb import TABLES, run_search
-except ImportError:  # graph-only install: no torch/lancedb
-    TABLES = {}
-    run_search = None
+# graph-only installs (macOS Intel). It is imported LAZILY on the first ``search_v2`` call via
+# ``_ensure_vector_backend``, NOT at module load. Reason: ``search_lancedb`` imports
+# ``sentence_transformers``/``torch`` at its own top level (~2.8s), and the warm ``jrag watch``
+# client reconstructs ``SearchOutput`` from this module (see ``watch/client._reconstruct``)
+# without ever calling the vector backend — an eager import here would force every warm CLI
+# read to pay that ~2.8s, masking the daemon's win.
+#
+# ``run_search`` uses a distinct ``_NOT_LOADED`` sentinel (not ``None``) for the unloaded state,
+# so ``None`` unambiguously means "lexical/disabled". This lets tests force the lexical path by
+# monkeypatching ``run_search=None`` (``_ensure_vector_backend`` treats that as authoritative and
+# will not overwrite it), while a non-None monkeypatch drives the vector path. ``TABLES`` is
+# ``{}`` until first successful load (only read in the vector path, where it is guaranteed set).
+_NOT_LOADED = object()
+run_search: Any = _NOT_LOADED
+TABLES: dict = {}
+_vector_backend_lock = threading.Lock()
+
+
+def _ensure_vector_backend() -> None:
+    """Populate ``run_search``/``TABLES`` from ``search_lancedb`` on first use.
+
+    No-op once ``run_search`` has left the ``_NOT_LOADED`` state — real callable (vector path),
+    ``None`` (graph-only install or a test-forced lexical mode), or a test monkeypatch.
+    Thread-safe (double-checked locking): the MCP server dispatches ``search_v2`` via
+    ``asyncio.to_thread``, so two concurrent first-batch searches could otherwise race the
+    sentinel mutation. On ImportError (graph-only) ``run_search`` becomes ``None`` and
+    ``search_v2`` takes the lexical fallback path. A non-ImportError propagates (caught by
+    ``search_v2``'s outer handler) and leaves ``run_search`` as ``_NOT_LOADED`` so the next
+    call retries rather than poisoning the process.
+    """
+    global run_search, TABLES
+    if run_search is not _NOT_LOADED:
+        return
+    with _vector_backend_lock:
+        if run_search is not _NOT_LOADED:
+            return
+        try:
+            from java_codebase_rag.search.search_lancedb import TABLES as _TABLES, run_search as _run_search
+        except ImportError:  # graph-only install: no torch/lancedb — lexical fallback
+            run_search = None
+        else:
+            run_search = _run_search
+            TABLES = _TABLES
 __all__ = [
     "search_v2",
     "find_v2",
@@ -913,6 +947,7 @@ def search_v2(
         if nf and (err := _nodefilter_applicability_error("symbol", nf)):
             _log_fail_loud("applicability")
             return SearchOutput(success=False, message=err, advisories=[], limit=None, offset=None)
+        _ensure_vector_backend()
         advisories: list[str] = []
         lexical_mode = run_search is None
         if lexical_mode:

{java_codebase_rag-0.10.0 → java_codebase_rag-0.10.2}/src/java_codebase_rag/search/search_lexical.py

@@ -32,6 +32,7 @@ from java_codebase_rag.search.search_scoring import (
     _dedup_by_fqn,
     _query_tokens,
     _split_identifier,
+    build_fts_query,
 )
 
 if TYPE_CHECKING:
@@ -272,8 +273,10 @@ def run_lexical_search(
     BM25-first (fork A): when the LadybugDB ``sym_fts`` index exists, candidates are
     fetched DB-side via Okapi BM25 over ``Symbol.search_text`` (killing the bounded
     Python scan that silently missed matches past the cap on large repos) and then
-    re-ranked here by the name/type/fqn/role heuristic. Falls back to that heuristic
-    scan when the FTS index or extension is unavailable (older graph, offline first run).
+    re-ranked here by the name/type/fqn/role heuristic. The query is pre-split with the
+    same tokenizer as ``search_text`` so pasted camelCase identifiers match. Falls back
+    to the heuristic scan when the FTS index or extension is unavailable (older graph,
+    offline first run), or when the query is degenerate / the BM25 result is empty.
 
     Raises ``RuntimeError`` (message contains "lexical search unavailable") if no
     symbol graph exists — the caller maps that to a clean failure envelope. Returns
@@ -292,14 +295,23 @@ def run_lexical_search(
     g = graph or LadybugGraph.get()
 
     # --- candidate fetch: BM25 (FTS) preferred, heuristic scan fallback ---
+    # FTS indexes Symbol.search_text (camelCase-split tokens); pre-split the query the
+    # same way (build_fts_query) so a pasted identifier like "DistributionChunkService"
+    # matches — LadybugDB FTS's own tokenizer does not split camelCase. An empty split
+    # (degenerate / stopword-only query), an unavailable FTS index, OR an empty BM25
+    # result all fall back to the heuristic scan, which yields role-ranked output for
+    # degenerate queries and covers selective filters where BM25's top-K thins to nil.
     bm25_scores: dict[str, float] = {}
     use_fts = False
-    fts = _try_fts_candidates(g, query, filter, path_contains)
-    if fts is not None:
-        rows = fts["rows"]
-        bm25_scores = fts["scores"]
-        use_fts = True
-    else:
+    rows: list[dict] | None = None
+    q_fts = build_fts_query(query)
+    if q_fts:
+        fts = _try_fts_candidates(g, q_fts, filter, path_contains)
+        if fts is not None and fts["rows"]:
+            rows = fts["rows"]
+            bm25_scores = fts["scores"]
+            use_fts = True
+    if rows is None:
         where, params = _lexical_where(filter, path_contains=path_contains)
         # Always exclude structural Symbol nodes. Files and packages are :Symbol-labeled
         # (kind='file'/'package') but aren't searchable code declarations — without this

{java_codebase_rag-0.10.0 → java_codebase_rag-0.10.2}/src/java_codebase_rag/search/search_scoring.py

@@ -136,6 +136,32 @@ def _split_identifier(name: str) -> list[str]:
     return [p for p in parts if p]
 
 
+# Alphanumeric-word extractor for FTS query building (mirrors the index side, which
+# runs the same regex over name/fqn/signature/annotations/capabilities/package fields).
+_FTS_WORD_RE = re.compile(r"[A-Za-z][A-Za-z0-9]*")
+
+
+def build_fts_query(text: str) -> str:
+    """Tokenize a search query into the ``Symbol.search_text`` token space (fork A).
+
+    ``search_text`` is indexed from ``_split_identifier`` tokens (camelCase / snake_case
+    split, lowercased). LadybugDB FTS's own tokenizer does NOT split camelCase, so a raw
+    pasted identifier like ``DistributionChunkService`` would match nothing — this
+    extracts alphanumeric words from the query and splits each via ``_split_identifier``
+    so the query lands in the index's token space. Tokens shorter than 2 chars are
+    dropped (mirrors the index side); duplicates collapse. Returns ``""`` for a query
+    with no usable tokens — the caller then falls back to the heuristic / role listing.
+    """
+    out: list[str] = []
+    seen: set[str] = set()
+    for word in _FTS_WORD_RE.findall(text or ""):
+        for tok in _split_identifier(word):
+            if len(tok) >= 2 and tok not in seen:
+                seen.add(tok)
+                out.append(tok)
+    return " ".join(out)
+
+
 def _symbol_bonus(r: dict, query_toks: set[str]) -> float:
     """Symbol-name overlap + action-verb bump for java chunks.
 

{java_codebase_rag-0.10.0 → java_codebase_rag-0.10.2/src/java_codebase_rag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.10.0
+Version: 0.10.2
 Summary: MCP server for semantic + structural search over Java codebases
 Author: HumanBean17
 License-Expression: MIT