java-codebase-rag 0.10.2__py3-none-any.whl → 0.11.0__py3-none-any.whl

java_codebase_rag/search/search_lancedb.py

@@ -20,6 +20,7 @@ from sentence_transformers import SentenceTransformer
 
 from java_codebase_rag.ast.chunk_heuristics import analyze_chunk, looks_like_code_identifier
 from java_codebase_rag.search.index_common import SBERT_MODEL
+from java_codebase_rag.search import search_lexical
 from java_codebase_rag.config import maybe_expand_embedding_model_path, resolved_sbert_model_for_process_env
 
 # Scoring & dedup primitives live in `search_scoring` (dependency-free — no
@@ -27,7 +28,11 @@ from java_codebase_rag.config import maybe_expand_embedding_model_path, resolved
 # graph-only (macOS Intel) installs where this module is unimportable. Re-exported
 # here for backward compatibility (`from search_lancedb import _clamp01`, etc.).
 from java_codebase_rag.search.search_scoring import (  # noqa: F401
+    BASELINE_2LIST_CONFIG,
+    DEFAULT_RANK_CONFIG,
     DEDUP_OVERFETCH,
+    RankConfig,
+    build_fts_query,
     _ACTION_VERB_BONUS,
     _ACTION_VERB_PREFIXES,
     _HYBRID_SCORE_MAX,
@@ -632,9 +637,150 @@ def _attach_neighbor_context(
     _debug_ctx(f"attached context to {attached}/{len(java_rows)} java rows")
 
 
+def _bm25_candidate_rows(
+    *,
+    g: object,
+    query: str,
+    uri: str,
+    db: object,
+    extra_predicates: list[str],
+    columns: set[str],
+    limit: int = 100,
+) -> list[dict]:
+    """Fetch BM25-ranked Symbol candidates from the FTS index and resolve them to
+    chunk rows in BM25 rank order. Returns ``[]`` on any failure (silent degradation).
+
+    Pipeline:
+      1. ``search_lexical.fetch_fts_candidates(g, query)`` → BM25-ranked Symbols +
+         a ``{symbol_node_id: bm25_score}`` map. ``None`` / empty → return ``[]``.
+      2. Map each Symbol fqn to its enclosing TYPE fqn (``primary_type_fqn`` has no
+         ``#``; a member ``Type#method`` maps to ``Type``). Dedupe by type fqn,
+         keeping the MAX BM25 score among same-type symbols.
+      3. Order type fqns by BM25 desc (fqn asc tiebreak — deterministic).
+      4. Fetch chunk rows from LanceDB with a FILTER-ONLY query (no vector ranking,
+         so BM25 order is preserved). Predicates = caller's ``extra_predicates`` +
+         the ``primary_type_fqn IN (...)`` built from the ordered types — preserving
+         filter parity with the vector path.
+      5. Group fetched chunks by ``primary_type_fqn``; emit in BM25 rank order,
+         each chunk carrying ``_score_components["bm25"]``.
+      6. Apply ``_apply_chunk_hints`` + ``_refine_java_start_lines`` for consistency
+         with graph_rows handling.
+
+    Any exception (FTS or LanceDB) → ``_debug_ctx`` log + return ``[]`` (silent
+    degradation; the vector path is unaffected).
+    """
+    # 1. BM25 candidate fetch via the FTS index.
+    # Pre-split the query with the same tokenizer the ``sym_fts`` index uses
+    # (``search_text`` stores ``_split_identifier`` tokens). LadybugDB FTS's own
+    # tokenizer does NOT split camelCase, so a raw ``DistributionChunkService``
+    # would match nothing — ``build_fts_query`` mirrors what the lexical backend
+    # does at search_lexical.py (run_lexical_search), keeping index/query token
+    # spaces aligned. An empty split (degenerate / stopword-only query) → no FTS
+    # candidates → degrade silently to the vector path.
+    fts_query = build_fts_query(query)
+    if not fts_query or not fts_query.strip():
+        return []
+    try:
+        fts = search_lexical.fetch_fts_candidates(g, fts_query, filter=None, path_contains=None)
+    except Exception as exc:  # noqa: BLE001 — silent degradation
+        _debug_ctx(f"bm25 FTS fetch raised: {exc!r}")
+        return []
+    if not fts or not fts.get("rows"):
+        return []
+    sym_rows = fts["rows"]
+    scores = fts.get("scores") or {}
+
+    # 2. Map symbol fqns → enclosing type fqns; keep MAX bm25 per type.
+    type_fqn_to_bm25: dict[str, float] = {}
+    for r in sym_rows:
+        fqn = r.get("fqn")
+        if not fqn:
+            continue
+        type_fqn = search_lexical.enclosing_type_fqn(str(fqn))
+        if not type_fqn:
+            continue
+        score = float(scores.get(r.get("id"), 0.0))
+        prev = type_fqn_to_bm25.get(type_fqn)
+        if prev is None or score > prev:
+            type_fqn_to_bm25[type_fqn] = score
+    if not type_fqn_to_bm25:
+        return []
+
+    # 3. Deterministic ordering: BM25 desc, fqn asc.
+    ordered_types = sorted(
+        type_fqn_to_bm25.keys(),
+        key=lambda f: (-type_fqn_to_bm25[f], f),
+    )
+
+    # 4. Filter-only chunk fetch (NO vector ranking → BM25 order preserved). The
+    # ``primary_type_fqn IN (...)`` predicate must be buildable; if the index is so
+    # old that the column is absent, we can't restrict the fetch and degrade to [].
+    if "primary_type_fqn" not in columns:
+        _debug_ctx("bm25 fetch skipped: primary_type_fqn column absent from schema")
+        return []
+    preds = list(extra_predicates) + _build_extra_predicates(
+        columns=columns,
+        role=None, module=None, microservice=None,
+        package_prefix=None, fqn_in=ordered_types,
+    )
+    combined_pred = _combine_predicates(preds)
+    base_cols = ["filename", "text", "start", "end"]
+    for col in ("range_start", "range_end"):
+        if col in columns:
+            base_cols.append(col)
+    java_extra = [c for c in JAVA_ENRICHED_COLUMNS if c in columns]
+    select_cols = [*base_cols, "language", *java_extra]
+
+    try:
+        tbl = db.open_table(TABLES["java"])
+        # LanceDB 0.34 filter-only path: search() with no vector arg issues a
+        # non-vector scan; .where/.select/.limit/.to_list returns rows in table
+        # order without re-ranking by similarity. (tbl.query() is NOT available in
+        # 0.34; to_lance().scanner() requires pylance, which isn't installed on the
+        # PEP 508 graph-only profile — search() with no vector is the supported API.)
+        q = tbl.search().select(select_cols).limit(
+            max(limit, len(ordered_types) * 4)
+        )
+        if combined_pred:
+            q = q.where(combined_pred, prefilter=True)
+        with _silence_lance_autoproj_warnings():
+            fetched = q.to_list()
+    except Exception as exc:  # noqa: BLE001 — silent degradation
+        _debug_ctx(f"bm25 chunk fetch failed: {exc!r}")
+        return []
+
+    # 5. Group by primary_type_fqn; emit in BM25 rank order.
+    by_type: dict[str, list[dict]] = {}
+    for ch in fetched:
+        tf = ch.get("primary_type_fqn")
+        if tf is None:
+            continue
+        by_type.setdefault(str(tf), []).append(ch)
+
+    out: list[dict] = []
+    for type_fqn in ordered_types:
+        chunks = by_type.get(type_fqn)
+        if not chunks:
+            continue  # filtered out by extra_predicates / absent from index
+        bm25_val = round(float(type_fqn_to_bm25[type_fqn]), 4)
+        for ch in chunks:
+            ch["_kind"] = "java"
+            ch["_hybrid"] = False
+            ch.setdefault("_score_components", {})["bm25"] = bm25_val
+            ch["start"] = coerce_position_field(ch.get("start"))
+            ch["end"] = coerce_position_field(ch.get("end"))
+            out.append(ch)
+
+    # 6. Consistency with graph_rows handling.
+    _apply_chunk_hints(out)
+    _refine_java_start_lines(out)
+    return out
+
+
 def _graph_expand_merge(
     vector_rows: list[dict],
     *,
+    query: str,
     query_vec: np.ndarray,
     db: object,
     uri: str,
@@ -642,8 +788,24 @@ def _graph_expand_merge(
     extra_predicates: list[str],
     expand_depth: int,
     ladybug_path: str | None,
+    rank_config: RankConfig = DEFAULT_RANK_CONFIG,
 ) -> list[dict]:
-    """Expand vector top-k through the LadybugDB graph and fuse (RRF) with the original list."""
+    """Expand vector top-k through the graph and/or fuse BM25, then RRF-merge.
+
+    Which lists contribute is controlled by ``rank_config.lists``:
+      - ``"vector"``  — always present (the backbone; validated by RankConfig).
+      - ``"graph"``   — graph expand + fetch (skipped entirely when absent).
+      - ``"bm25"``    — LadybugDB FTS candidate fetch fused as a third list.
+
+    Silent degradation: any failure in the graph or BM25 path drops just that list;
+    the vector list is never lost. Returns ``vector_rows`` unchanged when no
+    auxiliary list yields rows.
+    """
+    want_graph = "graph" in rank_config.lists
+    want_bm25 = "bm25" in rank_config.lists
+    if not want_graph and not want_bm25:
+        return vector_rows
+
     # Lazy import so the module works without ladybug installed when graph_expand=False.
     try:
         from java_codebase_rag.graph.ladybug_queries import LadybugGraph
@@ -653,67 +815,97 @@ def _graph_expand_merge(
     if not LadybugGraph.exists(ladybug_path):
         return vector_rows
 
-    seed_fqns = sorted({r.get("primary_type_fqn") for r in vector_rows if r.get("primary_type_fqn")})
-    if not seed_fqns:
-        return vector_rows
+    java_cols = _table_columns(uri, TABLES["java"], db)
 
-    try:
-        graph = LadybugGraph.get(ladybug_path)
-        structural = graph.expand_fqns(seed_fqns, depth=expand_depth)
-        method_pairs = graph.expand_methods(
-            seed_fqns, depth=expand_depth, exclude_external=True,
-        )
-        expand_weight_by_fqn: dict[str, float] = {}
-        for f in structural:
-            if f:
-                expand_weight_by_fqn[f] = max(expand_weight_by_fqn.get(f, 0.0), 1.0)
-        for f, conf in method_pairs:
-            if f:
-                expand_weight_by_fqn[f] = max(expand_weight_by_fqn.get(f, 0.0), conf)
-        neighbor_fqns = list(dict.fromkeys(
-            list(structural) + [f for f, _ in method_pairs],
-        ))
-    except Exception:
-        return vector_rows
+    # --- graph list ---
+    graph_rows: list[dict] = []
+    expand_weight_by_fqn: dict[str, float] = {}
+    if want_graph:
+        seed_fqns = sorted({r.get("primary_type_fqn") for r in vector_rows if r.get("primary_type_fqn")})
+        neighbor_fqns: list[str] = []
+        if seed_fqns:
+            try:
+                graph_obj = LadybugGraph.get(ladybug_path)
+                structural = graph_obj.expand_fqns(seed_fqns, depth=expand_depth)
+                method_pairs = graph_obj.expand_methods(
+                    seed_fqns, depth=expand_depth, exclude_external=True,
+                )
+                for f in structural:
+                    if f:
+                        expand_weight_by_fqn[f] = max(expand_weight_by_fqn.get(f, 0.0), 1.0)
+                for f, conf in method_pairs:
+                    if f:
+                        expand_weight_by_fqn[f] = max(expand_weight_by_fqn.get(f, 0.0), conf)
+                neighbor_fqns = list(dict.fromkeys(
+                    list(structural) + [f for f, _ in method_pairs],
+                ))
+            except Exception:
+                neighbor_fqns = []
+
+            novel = [fqn for fqn in neighbor_fqns if fqn and fqn not in set(seed_fqns)]
+            if novel:
+                extra = list(extra_predicates)
+                extra.extend(_build_extra_predicates(
+                    columns=java_cols,
+                    role=None, module=None, microservice=None,
+                    package_prefix=None, fqn_in=novel,
+                ))
+                try:
+                    graph_rows = _search_one_table(
+                        TABLES["java"],
+                        uri=uri, db=db, query_vec=query_vec,
+                        limit=max(limit, 20),
+                        path_predicate=None, kind="java",
+                        hybrid=False, fts_text=None,
+                        extra_predicates=extra,
+                    )
+                except Exception:
+                    graph_rows = []
+                _apply_chunk_hints(graph_rows)
+                _refine_java_start_lines(graph_rows)
+                graph_rows.sort(key=_vector_sort_key)
+                for r in graph_rows:
+                    r["_graph_expanded"] = True
+                    r["_graph_expand_weight"] = expand_weight_by_fqn.get(
+                        r.get("primary_type_fqn"), 1.0,
+                    )
+
+    # --- bm25 list ---
+    bm25_rows: list[dict] = []
+    if want_bm25:
+        try:
+            graph_obj = LadybugGraph.get(ladybug_path)
+        except Exception:
+            graph_obj = None
+        if graph_obj is not None:
+            bm25_rows = _bm25_candidate_rows(
+                g=graph_obj,
+                query=query,
+                uri=uri,
+                db=db,
+                extra_predicates=extra_predicates,
+                columns=java_cols,
+                limit=limit,
+            )
 
-    novel = [fqn for fqn in neighbor_fqns if fqn and fqn not in set(seed_fqns)]
-    if not novel:
+    # --- RRF fusion (only lists that yielded rows beyond vector) ---
+    lists: list[list[dict]] = [vector_rows]
+    row_weights: list[Callable[[dict], float] | None] = [None]
+    if want_graph and graph_rows:
+        lists.append(graph_rows)
+        row_weights.append(lambda row: float(row.get("_graph_expand_weight", 1.0)))
+    if want_bm25 and bm25_rows:
+        lists.append(bm25_rows)
+        row_weights.append(None)
+
+    if len(lists) == 1:
         return vector_rows
 
-    extra = list(extra_predicates)
-    extra.extend(_build_extra_predicates(
-        columns=_table_columns(uri, TABLES["java"], db),
-        role=None, module=None, microservice=None,
-        package_prefix=None, fqn_in=novel,
-    ))
-
-    try:
-        graph_rows = _search_one_table(
-            TABLES["java"],
-            uri=uri, db=db, query_vec=query_vec,
-            limit=max(limit, 20),
-            path_predicate=None, kind="java",
-            hybrid=False, fts_text=None,
-            extra_predicates=extra,
-        )
-    except Exception:
-        return vector_rows
-    _apply_chunk_hints(graph_rows)
-    _refine_java_start_lines(graph_rows)
-    graph_rows.sort(key=_vector_sort_key)
-    for r in graph_rows:
-        r["_graph_expanded"] = True
-        r["_graph_expand_weight"] = expand_weight_by_fqn.get(
-            r.get("primary_type_fqn"), 1.0,
-        )
-    fused = _rrf_merge(
-        [vector_rows, graph_rows],
-        row_weight_for_list_index=[
-            None,
-            lambda row: float(row.get("_graph_expand_weight", 1.0)),
-        ],
+    return _rrf_merge(
+        lists,
+        k=rank_config.rrf_k,
+        row_weight_for_list_index=row_weights,
     )
-    return fused
 
 
 def _rrf_merge(
@@ -790,6 +982,7 @@ def run_search(
     generated_only: bool = False,
     exclude_generated: bool = False,
     dedup_by_fqn: bool = False,
+    rank_config: RankConfig = DEFAULT_RANK_CONFIG,
 ) -> list[dict]:
     effective_hybrid = hybrid
     effective_fts = fts_text
@@ -887,6 +1080,7 @@ def run_search(
         if graph_expand and key == "java" and expand_depth > 0:
             rows = _graph_expand_merge(
                 rows,
+                query=query,
                 query_vec=query_vec,
                 db=db,
                 uri=uri,
@@ -894,6 +1088,7 @@ def run_search(
                 extra_predicates=extra_java,
                 expand_depth=expand_depth,
                 ladybug_path=ladybug_path,
+                rank_config=rank_config,
             )
 
         # Dedup by primary_type_fqn after all sorting/merging, before windowing

java_codebase_rag/search/search_lexical.py

@@ -127,6 +127,11 @@ def _enclosing_type_fqn(fqn: str) -> str:
     return fqn.split("#", 1)[0] if fqn else fqn
 
 
+# Non-underscore aliases for cross-module callers (search_lancedb's BM25 fusion).
+# Behavior is identical; the leading-underscore originals stay module-private.
+enclosing_type_fqn = _enclosing_type_fqn
+
+
 def _resolve_source_root(graph: LadybugGraph) -> str:
     """Authoritative source root is the one cached on the graph at index time."""
     try:
@@ -255,6 +260,11 @@ def _try_fts_candidates(
     return {"rows": rows, "scores": scores}
 
 
+# Non-underscore alias for cross-module callers (search_lancedb's BM25 fusion on the
+# vector path). Behavior is identical to the leading-underscore original.
+fetch_fts_candidates = _try_fts_candidates
+
+
 def run_lexical_search(
     query: str,
     *,

java_codebase_rag/search/search_scoring.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import json
 import re
+from dataclasses import dataclass
 
 # Name of the LadybugDB FTS (Okapi BM25) index over Symbol.search_text (fork A).
 # Shared by the build path (build_ast_graph._ensure_symbol_fts_index) and the
@@ -84,13 +85,86 @@ _ROLE_SCORE_WEIGHTS: dict[str, float] = {
     "DTO": -0.08,
 }
 
+
+def _rrf_max(num_lists: int, k: int = 60) -> float:
+    """Return the theoretical maximum RRF score for N-list fusion.
+
+    Reciprocal Rank Fusion (RRF) bounds each contribution to ≤ 1/(rank + k).
+    For N fused lists, the maximum possible sum is N/(k + 1) (achieved when
+    an item ranks #1 across all lists).
+
+    Args:
+        num_lists: Number of ranked lists being fused (e.g., 2 for vector+lexical).
+        k: The RRF constant (default 60 per the original paper).
+
+    Returns:
+        The maximum RRF contribution: num_lists / (k + 1).
+    """
+    return num_lists / (k + 1)
+
+
+# Allowed list names in a RankConfig: vector is always required (it is the
+# backbone retrieval signal); graph and bm25 are optional fusion participants.
+# The "bm25" list is wired in ``search_lancedb._graph_expand_merge`` (LadybugDB
+# FTS candidate fetch), which fuses BM25-ranked Symbol candidates as a third
+# RRF list alongside vector and graph.
+_RANK_LIST_NAMES: frozenset[str] = frozenset({"vector", "graph", "bm25"})
+
+
+@dataclass(frozen=True)
+class RankConfig:
+    """Which ranked lists to fuse and the RRF constant to fuse them with.
+
+    This is a dep-free value object (no lancedb/torch) so it can be constructed
+    on every install flavor, including graph-only (macOS Intel). It is plumbed
+    through ``run_search`` → ``_graph_expand_merge`` to control (a) which lists
+    contribute to the final RRF fusion and (b) the ``k`` constant passed into
+    ``_rrf_merge``.
+
+    Attributes:
+        lists: Subset of ``{"vector", "graph", "bm25"}``. Must contain
+            ``"vector"`` (the backbone retrieval signal) and be non-empty.
+        rrf_k: The RRF constant (default 60 per the original paper). Must be ≥ 1.
+    """
+
+    lists: frozenset[str]
+    rrf_k: int = 60
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.lists, frozenset) or not self.lists:
+            raise ValueError("RankConfig.lists must be a non-empty frozenset")
+        if "vector" not in self.lists:
+            raise ValueError(
+                "RankConfig.lists must contain 'vector' (the backbone signal)"
+            )
+        unknown = self.lists - _RANK_LIST_NAMES
+        if unknown:
+            raise ValueError(
+                f"RankConfig.lists has unknown names {sorted(unknown)!r}; "
+                f"allowed: {sorted(_RANK_LIST_NAMES)!r}"
+            )
+        if not isinstance(self.rrf_k, int) or self.rrf_k < 1:
+            raise ValueError(f"RankConfig.rrf_k must be an int >= 1, got {self.rrf_k!r}")
+
+
+# Production default: ship the 3-list config (vector+graph+bm25). The BM25 list
+# is wired in ``search_lancedb._graph_expand_merge``; on installs without the
+# vector stack, or when the FTS index is unavailable, it degrades silently to
+# the 2-list (vector+graph) fusion.
+DEFAULT_RANK_CONFIG = RankConfig(lists=frozenset({"vector", "graph", "bm25"}), rrf_k=60)
+
+# Eval convenience: the historical 2-list (vector+graph) fusion, used by
+# evaluation harnesses that isolate the vector+graph baseline from the bm25 list.
+BASELINE_2LIST_CONFIG = RankConfig(lists=frozenset({"vector", "graph"}), rrf_k=60)
+
+
 # Theoretical maximum for hybrid composite score (used for display normalization).
 # Hybrid sort metric: raw_rrf * (import_factor if import_heavy else 1)
 #                   + role_weight + symbol_bonus
 # where raw_rrf ≤ 2/(k+1) for 2-list RRF, role_weight ≤ max(_ROLE_SCORE_WEIGHTS),
 # and symbol_bonus ≤ _SYMBOL_MATCH_BONUS_CAP + _TYPE_MATCH_BONUS_CAP + _ACTION_VERB_BONUS.
-# The import factor is ≤ 1, so we use the raw max (2/61).
-_HYBRID_SCORE_MAX = (2.0 / 61.0) + max(_ROLE_SCORE_WEIGHTS.values()) + _SYMBOL_MATCH_BONUS_CAP + _TYPE_MATCH_BONUS_CAP + _ACTION_VERB_BONUS
+# The import factor is ≤ 1, so we use the raw max (derived via _rrf_max(2)).
+_HYBRID_SCORE_MAX = _rrf_max(2) + max(_ROLE_SCORE_WEIGHTS.values()) + _SYMBOL_MATCH_BONUS_CAP + _TYPE_MATCH_BONUS_CAP + _ACTION_VERB_BONUS
 
 
 def _query_tokens(query: str) -> set[str]:
@@ -374,6 +448,9 @@ def explain_score_components(
         rrf = comps.get("rrf_raw") or comps.get("hybrid_rrf")
         if rrf is not None:
             parts.append(f"rrf={float(rrf):.3f}")
+        bm25 = comps.get("bm25")
+        if bm25:
+            parts.append(f"bm25={float(bm25):.3f}")
     else:
         d = comps.get("distance")
         if d is not None:

{java_codebase_rag-0.10.2.dist-info → java_codebase_rag-0.11.0.dist-info}/METADATA

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

{java_codebase_rag-0.10.2.dist-info → java_codebase_rag-0.11.0.dist-info}/RECORD

@@ -2,7 +2,7 @@ java_codebase_rag/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs
 java_codebase_rag/_fdlimit.py,sha256=vkwjsPbZfxzZ2DZTPWO5DxtuNlLzOADzIq07iYX7GCU,2465
 java_codebase_rag/_stdio.py,sha256=TDNbpt2EP0_Zd622ihdlKwlMfxkKHWOfgLVcU6TcNbo,1458
 java_codebase_rag/_version.py,sha256=Dnoh_a-c13fqPQ-HV9CsSPbFUkihUJl_z5CACW4qDyA,1365
-java_codebase_rag/cli.py,sha256=5gDLwKM7EPjdoTQMB0-WM2b2FVWIyGbtRJxyhIjhzq8,46404
+java_codebase_rag/cli.py,sha256=Sf5HWQ607cg8LoZ-xlNpKKK-RslOjj5DDDsZDpHnUj8,47721
 java_codebase_rag/cli_format.py,sha256=CT7-xdwZ0bMCdP68_UOwkvm-mnLluU3LutlM-mDNk60,1839
 java_codebase_rag/cli_progress.py,sha256=q6Wh97yzLGs1B8UFk_WAKivfQu7Y5RnUUE-T2YHWkIs,3237
 java_codebase_rag/config.py,sha256=4rlRQUj0gFM-StUvhMD61uB2hZd2zqVHeNNBRXJMfN4,33283
@@ -26,6 +26,10 @@ java_codebase_rag/ast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 java_codebase_rag/ast/ast_java.py,sha256=ikMDBZGMYe0E2Doe6nf-Zw3k4MnwoNYvLqg3xsnfxmI,99614
 java_codebase_rag/ast/brownfield_events.py,sha256=yxXkKDgMb3VPtaiakGzncHM_EGnda8xIue6w90yYp8s,2055
 java_codebase_rag/ast/chunk_heuristics.py,sha256=aQk2NOKxzUdqoUAJUO3G3LE0MN_bYZWNLQ0tkmj5uts,1813
+java_codebase_rag/eval/__init__.py,sha256=V49SsVzkfHmVhRGMl9KbzMlxDSI8aHZA1YmxzgzNtYo,30
+java_codebase_rag/eval/ground_truth.py,sha256=q0gzsCF6hqR-NcMRNDDMUlvOA13RCcGcVLWWqlA4syY,3246
+java_codebase_rag/eval/metrics.py,sha256=nEDbN3VjYLUwyAvNcd8w4Kmjm0PlgX_Mt6cfOmH7f9k,3118
+java_codebase_rag/eval/runner.py,sha256=k_A5TLi16qeqT8WQ2lGqtioDXBlSzjsj0mLv-7Tml1o,20193
 java_codebase_rag/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 java_codebase_rag/graph/build_ast_graph.py,sha256=-MitMiz23HjiRHTt9MDA39Q9gLTCE07QoFxGa2Xl4uI,181704
 java_codebase_rag/graph/graph_enrich.py,sha256=51Q8aE0Mw09SVYBESd3H57IftsOpfkwgJV2ibt0RzwE,72598
@@ -47,9 +51,9 @@ java_codebase_rag/mcp/mcp_v2.py,sha256=w9kqz0AcWu9SqC1GuXZbLjRe0j9XhM3uONI4RB3ro
 java_codebase_rag/mcp/server.py,sha256=DJGlx8U5SD4Pe6Ro71OeFHi6HsYZ4r4uINn7R7uSKk4,40935
 java_codebase_rag/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 java_codebase_rag/search/index_common.py,sha256=HT6FKHFJ084eFvd3fR1j8z8gf4eWoPHVW8GXLpw464I,285
-java_codebase_rag/search/search_lancedb.py,sha256=wag0xrtmZZxdjVCMmINm3faSf0FCc9AHwEZk2kFZE24,40855
-java_codebase_rag/search/search_lexical.py,sha256=DsOYJiLpR9YhzCoW_IPRKIa7FWi_gBVvcUoRHImkDoI,19553
-java_codebase_rag/search/search_scoring.py,sha256=-qKU4LWf-meobSdhaKBNdukEeQsDAwPELXfr3cvwtkM,17528
+java_codebase_rag/search/search_lancedb.py,sha256=MxfTivzeMbScmYIf9s8nKSGCmNr5gMGDXldZotAfW-8,49368
+java_codebase_rag/search/search_lexical.py,sha256=iVui6KneEiVA1TRkA5UhO8XI9toayMDOCU-tXYjwRe8,19961
+java_codebase_rag/search/search_scoring.py,sha256=OsaX6zWyl4BIcqB7nRJRjp3SBEatmGAQ5EZEtQDaww0,20804
 java_codebase_rag/watch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 java_codebase_rag/watch/client.py,sha256=PO1uyllGZWoYgYYgm6vToCvaILkp0coXfXCEitzWXMU,9258
 java_codebase_rag/watch/daemon.py,sha256=ZgQrhUkfAJaExCaMqP8QfnNWxLQaoJyxes-FUo-qr78,15698
@@ -59,9 +63,9 @@ java_codebase_rag/watch/protocol.py,sha256=Vj16d0d0eA7XiLFX6o7JMY-I-mGva9VRxC41Z
 java_codebase_rag/watch/server.py,sha256=GUyCDmbl30wm9GhWTBh-K_BEhFSCHiM2kahmncMGf5E,11168
 java_codebase_rag/watch/warm.py,sha256=EN_39jVV1Kohsq8OI2LqGdTz_X-OCy4s4GWykiDAK7k,5113
 java_codebase_rag/watch/watcher.py,sha256=flD17vjPYuUjae6eWzSYcN-lsZnJUWVoXXvywDD1J24,15272
-java_codebase_rag-0.10.2.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
-java_codebase_rag-0.10.2.dist-info/METADATA,sha256=GA0Kkn7JPyGGP4gn_aw6V4gOHBs2MsK25qh9UokFxWA,20573
-java_codebase_rag-0.10.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-java_codebase_rag-0.10.2.dist-info/entry_points.txt,sha256=pa6yYHbHG7ZZ7G9ZJgYK1Fz6eR9okldPLo7qLY2THuo,190
-java_codebase_rag-0.10.2.dist-info/top_level.txt,sha256=u2i_IKLLOkYyNE32m4TIED0vtKtQDdPEVqRtNuhC1Hk,18
-java_codebase_rag-0.10.2.dist-info/RECORD,,
+java_codebase_rag-0.11.0.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
+java_codebase_rag-0.11.0.dist-info/METADATA,sha256=mVrkmI3Fdj9YcFkj-vSJmoP-LrWgLDjQN4kmY-cmUEE,20573
+java_codebase_rag-0.11.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+java_codebase_rag-0.11.0.dist-info/entry_points.txt,sha256=pa6yYHbHG7ZZ7G9ZJgYK1Fz6eR9okldPLo7qLY2THuo,190
+java_codebase_rag-0.11.0.dist-info/top_level.txt,sha256=u2i_IKLLOkYyNE32m4TIED0vtKtQDdPEVqRtNuhC1Hk,18
+java_codebase_rag-0.11.0.dist-info/RECORD,,