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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.10.0
+Version: 0.10.1
 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.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "java-codebase-rag"
-version = "0.10.0"
+version = "0.10.1"
 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.1}/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.1}/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.1/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.1
 Summary: MCP server for semantic + structural search over Java codebases
 Author: HumanBean17
 License-Expression: MIT