java-codebase-rag 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

ladybug_queries.py

@@ -1161,8 +1161,11 @@ class LadybugGraph:
         )
         return [str(r["id"]) for r in rows2 if r.get("id")]
 
-    def find_callers(
-        self, needle: str, *,
+    def _walk_calls(
+        self,
+        needle: str,
+        *,
+        side: str,
         depth: int = 1,
         limit: int = 100,
         min_confidence: float = 0.0,
@@ -1170,6 +1173,17 @@ class LadybugGraph:
         module: str | None = None,
         microservice: str | None = None,
     ) -> list[CallEdge]:
+        """BFS the CALLS graph outward from ``needle`` along one relationship end.
+
+        ``side="callers"`` treats the needle as the callee: the frontier matches
+        the ``callee`` end and discovered/expanded/external-filtered nodes are the
+        ``caller`` (src) end. ``side="callees"`` is the mirror. The two public
+        methods differ only in that orientation, so the BFS body is shared here.
+        """
+        if side == "callers":
+            scope_alias, frontier_end, discovered = "caller", "callee", "src"
+        else:
+            scope_alias, frontier_end, discovered = "callee", "caller", "dst"
         frontier = self._method_ids_for_call_graph_needle(needle, limit=max(limit, 50))
         if not frontier:
             return []
@@ -1182,8 +1196,8 @@ class LadybugGraph:
                 "frontier": list(frontier),
                 "minc": float(min_confidence),
             }
-            sc = _scope_filters("caller", module=module, microservice=microservice, params=params)
-            wh_parts = ["callee.id IN $frontier", "c.confidence >= $minc"]
+            sc = _scope_filters(scope_alias, module=module, microservice=microservice, params=params)
+            wh_parts = [f"{frontier_end}.id IN $frontier", "c.confidence >= $minc"]
             wh_parts.extend(sc)
             wh = " AND ".join(wh_parts)
             q = (
@@ -1197,16 +1211,19 @@ class LadybugGraph:
             next_frontier: list[str] = []
             for row in self._rows(q, params):
                 ce = _row_to_call_edge(row)
-                # Filter only discovered callers (src). Needle may be external
-                # (e.g. java.util.List#add) while still listing internal callers.
-                if exclude_external and _is_external_fqn(ce.src.fqn):
+                # The needle itself may be external (e.g. java.util.List#add);
+                # filter only the discovered end so internal callers/callees
+                # that touch it are still surfaced.
+                disc_fqn = ce.src.fqn if discovered == "src" else ce.dst.fqn
+                disc_id = ce.src.id if discovered == "src" else ce.dst.id
+                if exclude_external and _is_external_fqn(disc_fqn):
                     continue
                 key = (ce.src.id, ce.dst.id, ce.call_site_line, ce.call_site_byte)
                 if key in seen:
                     continue
                 seen.add(key)
                 out.append(ce)
-                next_frontier.append(ce.src.id)
+                next_frontier.append(disc_id)
                 if len(out) >= limit:
                     return out
             frontier = list(dict.fromkeys(next_frontier))
@@ -1214,6 +1231,21 @@ class LadybugGraph:
                 break
         return out
 
+    def find_callers(
+        self, needle: str, *,
+        depth: int = 1,
+        limit: int = 100,
+        min_confidence: float = 0.0,
+        exclude_external: bool = True,
+        module: str | None = None,
+        microservice: str | None = None,
+    ) -> list[CallEdge]:
+        return self._walk_calls(
+            needle, side="callers", depth=depth, limit=limit,
+            min_confidence=min_confidence, exclude_external=exclude_external,
+            module=module, microservice=microservice,
+        )
+
     def find_callees(
         self, needle: str, *,
         depth: int = 1,
@@ -1223,49 +1255,11 @@ class LadybugGraph:
         module: str | None = None,
         microservice: str | None = None,
     ) -> list[CallEdge]:
-        frontier = self._method_ids_for_call_graph_needle(needle, limit=max(limit, 50))
-        if not frontier:
-            return []
-        caller_proj = ", ".join(f"caller.{c} AS caller_{c}" for c in _SYM_COLS)
-        callee_proj = ", ".join(f"callee.{c} AS callee_{c}" for c in _SYM_COLS)
-        out: list[CallEdge] = []
-        seen: set[tuple[str, str, int, int]] = set()
-        for _ in range(max(1, int(depth))):
-            params: dict[str, Any] = {
-                "frontier": list(frontier),
-                "minc": float(min_confidence),
-            }
-            sc = _scope_filters("callee", module=module, microservice=microservice, params=params)
-            wh_parts = ["caller.id IN $frontier", "c.confidence >= $minc"]
-            wh_parts.extend(sc)
-            wh = " AND ".join(wh_parts)
-            q = (
-                f"MATCH (caller:Symbol)-[c:CALLS]->(callee:Symbol) WHERE {wh} "
-                f"RETURN {caller_proj}, {callee_proj}, "
-                f"c.call_site_line AS call_site_line, c.call_site_byte AS call_site_byte, "
-                f"c.arg_count AS arg_count, c.confidence AS confidence, c.strategy AS strategy, "
-                f"c.source AS source, c.resolved AS resolved "
-                f"LIMIT {int(limit) * 8}"
-            )
-            next_frontier: list[str] = []
-            for row in self._rows(q, params):
-                ce = _row_to_call_edge(row)
-                # Filter only discovered callees (dst). Needle may be external while
-                # still listing non-external outbound calls when any exist.
-                if exclude_external and _is_external_fqn(ce.dst.fqn):
-                    continue
-                key = (ce.src.id, ce.dst.id, ce.call_site_line, ce.call_site_byte)
-                if key in seen:
-                    continue
-                seen.add(key)
-                out.append(ce)
-                next_frontier.append(ce.dst.id)
-                if len(out) >= limit:
-                    return out
-            frontier = list(dict.fromkeys(next_frontier))
-            if not frontier:
-                break
-        return out
+        return self._walk_calls(
+            needle, side="callees", depth=depth, limit=limit,
+            min_confidence=min_confidence, exclude_external=exclude_external,
+            module=module, microservice=microservice,
+        )
 
     def expand_methods(
         self, fqns: list[str], *, depth: int = 1,

mcp_v2.py

@@ -817,7 +817,7 @@ def _merge_overrides_edge_summary(
     """Reconcile `OVERRIDES` with `override_axis_rollup_for` without clobbering stored `in`.
 
     Rollup rows reuse the ``OVERRIDES`` key for dispatch-up counts only (``in`` is always
-    zero there). Stored ``[:OVERRIDES]`` edges contribute real ``in``/``out`` from Kuzu;
+    zero there). Stored ``[:OVERRIDES]`` edges contribute real ``in``/``out`` from LadybugDB;
     merge per direction with ``max`` so inbound override edges stay visible.
     """
     roll = _incident_counts(summary_after_rollups.get("OVERRIDES"))
@@ -1095,9 +1095,9 @@ def describe_v2(
         has_id = bool(id and str(id).strip())
         has_fqn = bool(fqn and str(fqn).strip())
         if not has_id and not has_fqn:
-            return DescribeOutput(success=False, message="id or fqn required", hints=[])
+            return DescribeOutput(success=False, message="id or fqn required")
         if has_id and str(id).strip().startswith("ucs:"):
-            return DescribeOutput(success=False, message=_DESCRIBE_UCS_ID_MESSAGE, hints=[])
+            return DescribeOutput(success=False, message=_DESCRIBE_UCS_ID_MESSAGE)
         hint_message: str | None = None
         node_id: str
         if has_id:
@@ -1109,7 +1109,7 @@ def describe_v2(
                 {"fqn": fqn_val},
             )
             if not rows:
-                return DescribeOutput(success=False, message=f"No Symbol found for fqn='{fqn_val}'", hints=[])
+                return DescribeOutput(success=False, message=f"No Symbol found for fqn='{fqn_val}'")
             node_id = str(rows[0]["id"] or "")
             if len(rows) > 1:
                 hint_message = (
@@ -1784,7 +1784,7 @@ def neighbors_v2(
             )
         except ValueError as exc:
             _log_fail_loud("edge_filter")
-            return NeighborsOutput(success=False, message=str(exc), hints=[], requested_edge_types=[])
+            return NeighborsOutput(success=False, message=str(exc), requested_edge_types=[])
         if include_unresolved and ef is not None:
             return NeighborsOutput(
                 success=False,
@@ -1792,21 +1792,18 @@ def neighbors_v2(
                     "include_unresolved=True is incompatible with edge_filter; "
                     "UnresolvedCallSite rows have no edge attributes to filter on"
                 ),
-                hints=[],
                 requested_edge_types=requested_edge_types,
             )
         if include_unresolved and requested_edge_types != ["CALLS"]:
             return NeighborsOutput(
                 success=False,
                 message="include_unresolved requires edge_types=['CALLS']",
-                hints=[],
                 requested_edge_types=requested_edge_types,
             )
         if include_unresolved and direction != "out":
             return NeighborsOutput(
                 success=False,
                 message='include_unresolved requires direction="out"',
-                hints=[],
                 requested_edge_types=requested_edge_types,
             )
         if ef and (err := _edgefilter_applicability_error(requested_edge_types, ef)):
@@ -1814,17 +1811,15 @@ def neighbors_v2(
             return NeighborsOutput(
                 success=False,
                 message=err,
-                hints=[],
                 requested_edge_types=requested_edge_types,
             )
         if nf and (err := _validate_no_wildcards(nf)):
             _log_fail_loud("wildcard")
-            return NeighborsOutput(success=False, message=err, hints=[], requested_edge_types=[])
+            return NeighborsOutput(success=False, message=err, requested_edge_types=[])
         if composed_keys and direction != "out":
             return NeighborsOutput(
                 success=False,
                 message='Composed edge types require direction="out"',
-                hints=[],
                 requested_edge_types=requested_edge_types,
             )
         use_calls_path = flat_labels == ["CALLS"] and not composed_keys
@@ -1849,7 +1844,6 @@ def neighbors_v2(
                     return NeighborsOutput(
                         success=False,
                         message=axis_msg,
-                        hints=[],
                         requested_edge_types=requested_edge_types,
                     )
                 origin_row = _load_node_record(g, origin_id, "symbol")
@@ -1865,7 +1859,6 @@ def neighbors_v2(
                     return NeighborsOutput(
                         success=False,
                         message=err,
-                        hints=[],
                         requested_edge_types=requested_edge_types,
                     )
             if use_calls_path:
@@ -1891,7 +1884,6 @@ def neighbors_v2(
                     return NeighborsOutput(
                         success=False,
                         message=str(exc),
-                        hints=[],
                         requested_edge_types=requested_edge_types,
                     )
                 if (
@@ -1904,7 +1896,7 @@ def neighbors_v2(
                 results.extend(origin_edges)
                 continue
             if flat_labels:
-                # Kuzu 0.11.x can drop `label(e) IN $list` in WHERE; use OR of scalar equalities.
+                # Some Cypher binders can drop `label(e) IN $list` in WHERE; use OR of scalar equalities.
                 label_params = [f"l{i}" for i in range(len(flat_labels))]
                 label_predicate = "(" + " OR ".join(f"label(e) = ${name}" for name in label_params) + ")"
                 q_params = {"id": origin_id, **dict(zip(label_params, flat_labels, strict=True))}
@@ -1941,7 +1933,7 @@ def neighbors_v2(
                     if nf and (err := _nodefilter_applicability_error(other_kind, nf)):
                         _log_fail_loud("applicability")
                         return NeighborsOutput(
-                            success=False, message=err, hints=[], requested_edge_types=[]
+                            success=False, message=err, requested_edge_types=[]
                         )
                     if not _node_matches_filter(other_kind, other_rec, nf):
                         continue
@@ -1968,7 +1960,7 @@ def neighbors_v2(
                     if nf and (err := _nodefilter_applicability_error(other_kind, nf)):
                         _log_fail_loud("applicability")
                         return NeighborsOutput(
-                            success=False, message=err, hints=[], requested_edge_types=[]
+                            success=False, message=err, requested_edge_types=[]
                         )
                     if not _node_matches_filter(other_kind, other_rec, nf):
                         continue

path_filtering.py

@@ -300,6 +300,7 @@ class LayeredIgnore:
             _scan_negation_any_bundle_ignore(self.project_root)
             or (use_gitignore and _scan_negation_any_gitignore(self.project_root))
         )
+        self._mega_cache: dict[str, tuple[list[str], GitIgnoreSpec, list[tuple[str, Path | None, int, str]]]] = {}
 
     def cocoindex_excluded_patterns(self) -> list[str]:
         """Patterns for CocoIndex ``PatternFilePathMatcher.excluded_patterns``.
@@ -332,6 +333,11 @@ class LayeredIgnore:
                 return path.as_posix()
 
     def _mega(self, rel_project: str) -> tuple[list[str], GitIgnoreSpec, list[tuple[str, Path | None, int, str]]]:
+        # Cache by directory (parent of rel_project). _mega_build_for_rel reads only dir_parts,
+        # so files in the same directory share the same mega/spec/meta tuple.
+        cache_key = Path(rel_project).parent.as_posix()
+        if cache_key in self._mega_cache:
+            return self._mega_cache[cache_key]
         mega, meta = _mega_build_for_rel(
             self.project_root,
             rel_project,
@@ -340,26 +346,26 @@ class LayeredIgnore:
             project_ignore_path=self._project_ignore_path,
             project_lines=self._project_lines,
         )
-        return mega, GitIgnoreSpec.from_lines(mega), meta
-
-    def is_ignored(self, path: Path) -> tuple[bool, IgnoreLayer | None]:
-        """Return whether ``path`` is ignored and which layer last matched."""
+        result = (mega, GitIgnoreSpec.from_lines(mega), meta)
+        self._mega_cache[cache_key] = result
+        return result
+
+    def is_ignored(self, path: Path) -> bool:
+        """Return whether ``path`` is ignored by any configured layer.
+
+        Boolean-only fast path for the per-file index walk. It deliberately does
+        not compute *which* layer/source last matched: that attribution is
+        O(rules²) via :func:`_winning_row` (one ``GitIgnoreSpec`` rebuild per
+        rule prefix) and is only needed for ``diagnose-ignore``, so it lives in
+        :meth:`diagnose_dict` and is never paid on the hot path.
+        """
         rel = self._rel_project(path)
         if rel is None:
-            return False, None
-        mega, spec, meta = self._mega(rel)
+            return False
+        mega, spec, _ = self._mega(rel)
         if not mega:
-            return False, None
-        ignored = spec.match_file(rel)
-        if not ignored:
-            return False, None
-        src, fp, ln, _pat = _winning_row(rel, mega, meta)
-        return True, IgnoreLayer(
-            root=self.project_root,
-            spec=spec,
-            source=src,
-            ignore_file=fp,
-        )
+            return False
+        return spec.match_file(rel)
 
     def diagnose(self, path: Path) -> str:
         """Human-readable, multi-line explanation of the ignore decision."""
@@ -466,7 +472,6 @@ def iter_java_source_files(
             if not fn.endswith(".java"):
                 continue
             p = Path(dirpath) / fn
-            ign, _ = ignore_ctx.is_ignored(p)
-            if ign:
+            if ignore_ctx.is_ignored(p):
                 continue
             yield p

pr_analysis.py

@@ -152,7 +152,7 @@ def _resolve_graph_filename(
     *,
     ambiguity_notes: list[str] | None = None,
 ) -> str | None:
-    """Map a diff path to `Symbol.filename` values stored in Kuzu."""
+    """Map a diff path to `Symbol.filename` values stored in LadybugDB."""
     variants = {_strip_ab_prefix(path)}
     for v in list(variants):
         if v.startswith("./"):
@@ -362,7 +362,7 @@ def _is_public_interface_method(graph: Any, sym: SymbolHit) -> bool:
 
 
 def _route_ids_for_symbol(graph: Any, symbol_id: str) -> list[str]:
-    # Note: Kuzu rejects `ORDER BY r.id` together with `RETURN DISTINCT r.id` (binder loses `r`).
+    # Note: LadybugDB rejects `ORDER BY r.id` together with `RETURN DISTINCT r.id` (binder loses `r`).
     q = (
         "MATCH (s:Symbol)-[e:EXPOSES]->(r:Route) WHERE s.id = $sid "
         "RETURN r.id AS id ORDER BY id"
@@ -384,7 +384,6 @@ def compute_risk(graph: Any, changed: list[ChangedSymbol]) -> PrRiskReport:
     bump (up to +1.0) after normalization so they influence rank while
     preserving the public scalar contract.
     """
-    notes: list[str] = []
     blast_by: dict[str, int] = {}
     blast_total = 0
     routes: list[str] = []
@@ -495,7 +494,7 @@ def compute_risk(graph: Any, changed: list[ChangedSymbol]) -> PrRiskReport:
         routes_touched=routes,
         risk_score=score,
         risk_band=band,
-        notes=notes,
+        notes=[],
     )
 
 

search_lancedb.py

@@ -677,8 +677,8 @@ def _graph_expand_merge(
     expand_depth: int,
     ladybug_path: str | None,
 ) -> list[dict]:
-    """Expand vector top-k through the Kuzu graph and fuse (RRF) with the original list."""
-    # Lazy import so the module works without kuzu installed when graph_expand=False.
+    """Expand vector top-k through the LadybugDB graph and fuse (RRF) with the original list."""
+    # Lazy import so the module works without ladybug installed when graph_expand=False.
     try:
         from ladybug_queries import LadybugGraph
     except Exception: