java-codebase-rag 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

java_codebase_rag-0.6.4.dist-info/RECORD

@@ -0,0 +1,34 @@
+ast_java.py,sha256=Paee3ZV9G5iy8LqfkVq0Ah_1fV0k632oS5JPkiWzwB8,99206
+brownfield_events.py,sha256=yxXkKDgMb3VPtaiakGzncHM_EGnda8xIue6w90yYp8s,2055
+build_ast_graph.py,sha256=vXWUuNC_k6-yKv6XawlHCXiC_dTNs1RoSKdZTXYBxgA,157374
+chunk_heuristics.py,sha256=aQk2NOKxzUdqoUAJUO3G3LE0MN_bYZWNLQ0tkmj5uts,1813
+graph_enrich.py,sha256=W_OQK7YRU1K8wi-vfrxZWUd-EErTqWx840UBrhVpNsM,62788
+index_common.py,sha256=HT6FKHFJ084eFvd3fR1j8z8gf4eWoPHVW8GXLpw464I,285
+java_index_flow_lancedb.py,sha256=HClxupO2uHpGw9GNVIDs24bjoCQzg3VLbOZoA0hE_Gc,23761
+java_index_v1_common.py,sha256=nF1KrSqboF_RRvWerG9knRRFmWwsrG_CvhgnsoZ8KqA,1154
+java_ontology.py,sha256=71bCLDNvMy0SpZPzSR5apJ0qJXNd6y5ggkLdBEw_PFo,16682
+ladybug_queries.py,sha256=7vSP7WsUKQYXHFenBMlCdpUFed39h3oul-WRkf55YVc,90330
+mcp_hints.py,sha256=3swh05LSiWur3tm3-yssndBsLxIxFhy501kBtJI8jJ0,42509
+mcp_v2.py,sha256=S8PiVGDlyI7cvTmeMdQobhKUxWqKoY2YxXXr4pu9lQI,80348
+path_filtering.py,sha256=cN_znZRXIY1CfTIWlfiOrnNqafb2BZs00oDaqjTxmFE,17169
+pr_analysis.py,sha256=zrmZZD5yotJtM02Kif6_jgI_oeformOao793akp0N6Y,18394
+search_lancedb.py,sha256=ga_qySeCzA6hCibxUPXpCbTxW9mCjTdwirMhMhfNCz4,36801
+server.py,sha256=DcJwocSknBy0vwsUvYiC5hr-hrD_rRT-u9_DmuRTC9k,35035
+java_codebase_rag/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+java_codebase_rag/_fdlimit.py,sha256=WroFdfSNbcriKok6q8znTf74dqlznxea_1Fd5bHl_3o,1930
+java_codebase_rag/cli.py,sha256=TIrKNQMxu3_dSF2LXKsRKWY5RqRnSLQMrbKAoN4uQBQ,38698
+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=bfwYI4R8PU9YV_M4r8-03iaUZ_0TW-qN_NuhIsDXy2M,18769
+java_codebase_rag/installer.py,sha256=sXsHPo24aoDFoTr0D_vYLg0MFdGAV2wdL05FqRaul6E,52861
+java_codebase_rag/lance_optimize.py,sha256=25Rwj7HNO8F-35MxhFK6naqgbjd3H-T0zKb3pXB4H0s,9268
+java_codebase_rag/pipeline.py,sha256=ydNktEGL1YniAjJsr37yKBo_bGV4cN_LTGVTmmrsrZw,14688
+java_codebase_rag/progress.py,sha256=2IxdMALDM0wAQCyJrrfZ975zM_85C-4BfHxf4AtYifE,23212
+java_codebase_rag/install_data/agents/explorer-rag-enhanced.md,sha256=BkdQpBEWqSdvGHgbqMdRb5CWfEiFRJK4Dgqbyal3l6s,14551
+java_codebase_rag/install_data/skills/explore-codebase/SKILL.md,sha256=YkRnrM7Wh5E8raFjAW3RrN2V9-ov8upaGC3UdpSx6U8,12346
+java_codebase_rag-0.6.4.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
+java_codebase_rag-0.6.4.dist-info/METADATA,sha256=FR0VQ3dS_OS2v-n_zxOqcE0pZsHRvhDAiOGLse0pAoI,17242
+java_codebase_rag-0.6.4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+java_codebase_rag-0.6.4.dist-info/entry_points.txt,sha256=wsPZwot0Ui4JI3TIgW8LcbN8bNtKFbwQAlHAAJXfYgQ,117
+java_codebase_rag-0.6.4.dist-info/top_level.txt,sha256=syQgi8XPBwY2ws_NZ1uRCxTf_s41NpshwEHNdcdnk3A,245
+java_codebase_rag-0.6.4.dist-info/RECORD,,

java_index_flow_lancedb.py

@@ -16,12 +16,16 @@ Usage:
 """
 from __future__ import annotations
 
+import asyncio
 import inspect
 import os
+import sys
+import threading
 import uuid
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
+from fnmatch import fnmatch
 from pathlib import Path
 from typing import Annotated, Any
 
@@ -47,7 +51,7 @@ from java_index_v1_common import (
 )
 from path_filtering import LayeredIgnore
 from ast_java import ONTOLOGY_VERSION, parse_java
-from graph_enrich import enrich_chunk
+from graph_enrich import collect_annotation_meta_chain, enrich_chunk, load_brownfield_overrides
 
 # Older cocoindex (e.g. 1.0.0a43) uses ``tracked=False``; newer releases renamed
 # the flag to ``detect_change`` (default False) and reject ``tracked``.
@@ -84,6 +88,138 @@ splitter = RecursiveSplitter()
 _NUM_TXN_BEFORE_OPTIMIZE = 10**12
 
 
+# --- Vectors-phase progress emission (JCIRAG_PROGRESS kind=vectors) -----------
+#
+# The flow runs in a CHILD cocoindex process; it prints structured progress to
+# its stderr and the parent (pipeline._popen_capturing_stderr /
+# cli_progress.accumulate_and_relay_subprocess_streams) parses it via
+# ProgressRelay and feeds the renderer. The flow CANNOT know when all files are
+# done (cocoindex offers no "all files done" hook in the flow), so it emits:
+#   - ONE ``total=N status=running`` line from ``app_main`` (approximate
+#     pre-walk: matcher includes + LayeredIgnore), and
+#   - per-file ``done=k status=running`` ticks (throttled every ~25 files) from
+#     ``process_*_file`` (shared atomic counter).
+# The PARENT emits the terminal ``status=done``/``failed`` vectors event on
+# cocoindex exit (drives clamp-on-completion + phase transition to Optimize).
+
+# Per-file tick cadence: bound stderr volume on huge trees without making the
+# bar feel stale. Every 25th file (and the modulo boundary is enough — the
+# parent clamps to total on the terminal event anyway).
+_VECTORS_TICK_EVERY = 25
+
+# Thread-safe counter: cocoindex may call process_*_file concurrently
+# (mount_each parallelism is implementation-defined). A module-level lock guards
+# both the counter and the emission so two threads never interleave a tick.
+_vectors_done_lock = threading.Lock()
+_vectors_done_count = 0
+
+
+def _emit_vectors_progress(
+    *,
+    done: int | None = None,
+    total: int | None = None,
+    status: str = "running",
+    elapsed_s: float | None = None,
+) -> None:
+    """Emit one ``JCIRAG_PROGRESS kind=vectors …`` line to stderr (flushed).
+
+    Field order is fixed (kind, done, total, status, elapsed_s) so the parser
+    and tests can pin substrings. Omitted fields are simply absent.
+    """
+    fields = ["kind=vectors"]
+    if done is not None:
+        fields.append(f"done={done}")
+    if total is not None:
+        fields.append(f"total={total}")
+    fields.append(f"status={status}")
+    if elapsed_s is not None:
+        fields.append(f"elapsed_s={elapsed_s:.2f}")
+    print("JCIRAG_PROGRESS " + " ".join(fields), file=sys.stderr, flush=True)
+
+
+def _tick_vectors_done() -> None:
+    """Increment the shared per-file counter and emit a throttled ``done=k`` tick.
+
+    Called once per successfully-processed file (after the ignore / empty
+    early-returns). The tick is emitted every ``_VECTORS_TICK_EVERY`` files so
+    stderr volume stays bounded on huge trees; the parent clamps to total on
+    the terminal event, so the exact tick cadence is not load-bearing.
+    """
+    global _vectors_done_count
+    with _vectors_done_lock:
+        _vectors_done_count += 1
+        n = _vectors_done_count
+        if n % _VECTORS_TICK_EVERY != 0:
+            return
+        # Emit under the lock: the docstring above promises the lock guards both
+        # the counter AND the emission, so two concurrent ticks can't emit their
+        # ``done=N`` lines out of order. Contention is negligible (fires every
+        # ~25 files).
+        _emit_vectors_progress(done=n, status="running")
+
+
+def _approximate_vectors_total(project_root: Path) -> int:
+    """Reproduce the matchers' include globs + LayeredIgnore for an approximate total.
+
+    The flow applies two filtering layers: (1) ``PatternFilePathMatcher``
+    excludes at walk time via ``LayeredIgnore.cocoindex_excluded_patterns()``,
+    then (2) ``LayeredIgnore.is_ignored()`` plus an early-return for empty /
+    undecodable files inside each ``process_*_file``. Files that early-return
+    never tick, so this pre-walk OVERSTATES the total by the ignored / empty
+    count. The parent clamps the bar to 100% on the terminal ``status=done``
+    event, so the over-count cannot stall the bar.
+
+    Mirrors the three ``localfs.walk_dir`` matchers in ``app_main``:
+      - ``**/*.java``
+      - ``**/src/main/resources/db/migration/*.sql``
+      - ``**/src/main/resources/application*.yml`` and ``.yaml``
+    """
+    ignore = LayeredIgnore(project_root)
+    excluded = ignore.cocoindex_excluded_patterns()
+
+    def _excluded(rel_posix: str) -> bool:
+        return any(fnmatch(rel_posix, pat) for pat in excluded)
+
+    total = 0
+    for dirpath, dirnames, filenames in os.walk(project_root):
+        # Prune the same universal nuisance dirs as iter_java_source_files /
+        # cocoindex walk. (build-output pruning is matcher-dependent in the
+        # real walk; for an APPROXIMATE total this cheap prune is sufficient
+        # — the clamp absorbs any residual divergence.)
+        dirnames[:] = [
+            d for d in dirnames if d not in (".git", ".hg", ".svn", "node_modules", ".venv", "venv")
+        ]
+        for fn in filenames:
+            full = Path(dirpath) / fn
+            try:
+                rel = full.resolve().relative_to(project_root).as_posix()
+            except ValueError:
+                continue
+            if _excluded(rel):
+                continue
+            # Java: **/*.java
+            if fn.endswith(".java"):
+                if not ignore.is_ignored(full):
+                    total += 1
+                continue
+            # SQL: **/src/main/resources/db/migration/*.sql
+            if fn.endswith(".sql") and "/db/migration/" in rel:
+                if not ignore.is_ignored(full):
+                    total += 1
+                continue
+            # YAML: **/src/main/resources/application*.yml / .yaml
+            # NOTE: ``fn`` is the bare filename (e.g. ``application-cloud.yml``), so
+            # the prefix predicate must be ``fn.startswith("application")`` —
+            # ``"/application" in fn`` was always False (no leading slash in a bare
+            # name) and under-counted every application YAML, driving the pre-walk
+            # total below the actual done count. The ``rel``-based
+            # ``"/src/main/resources/"`` gate stays (full path component).
+            if fn.endswith((".yml", ".yaml")) and fn.startswith("application") and "/src/main/resources/" in rel:
+                if not ignore.is_ignored(full):
+                    total += 1
+    return total
+
+
 @dataclass
 class JavaLanceChunk:
     id: str
@@ -171,6 +307,40 @@ async def coco_lifespan(builder: coco.EnvironmentBuilder) -> AsyncIterator[None]
     yield
 
 
+def _parse_and_enrich_java(
+    content_bytes: bytes,
+    chunks: list[Any],
+    rel: str,
+    project_root: Path,
+) -> list[Any]:
+    """Parse one Java file and enrich every chunk, off the event loop.
+
+    Returns a list of :class:`graph_enrich.ChunkEnrichment` aligned 1:1 with
+    ``chunks``. Intended to run via ``asyncio.to_thread`` from
+    ``process_java_file`` (vectors perf lever #2): while the worker thread
+    parses + enriches, the event loop is free to drive other files and keep the
+    embedder's batching queue fed.
+
+    Thread-safety: ``parse_java`` uses a per-thread tree-sitter ``Parser``
+    (see ``ast_java._parser``), so it is safe to call concurrently from these
+    worker threads — including the transitive ``parse_java`` that ``enrich_chunk``
+    triggers via ``collect_annotation_meta_chain`` → ``_collect_annotation_decl_index``.
+    ``enrich_chunk`` is otherwise pure-Python over the now-immutable AST; its
+    ``lru_cache`` reads are thread-safe under the GIL.
+    """
+    ast = parse_java(content_bytes)
+    return [
+        enrich_chunk(
+            ast,
+            chunk_start_byte=ch.start.byte_offset,
+            chunk_end_byte=ch.end.byte_offset,
+            file_path=rel,
+            project_root=project_root,
+        )
+        for ch in chunks
+    ]
+
+
 @coco.fn(memo=True)
 async def process_java_file(
     file: localfs.File,
@@ -178,7 +348,7 @@ async def process_java_file(
 ) -> None:
     embedder = coco.use_context(EMBEDDER)
     project_root = coco.use_context(PROJECT_ROOT)
-    if LayeredIgnore(project_root).is_ignored((project_root / file.file_path.path).resolve())[0]:
+    if LayeredIgnore(project_root).is_ignored((project_root / file.file_path.path).resolve()):
         return
     try:
         content = await file.read_text()
@@ -187,8 +357,13 @@ async def process_java_file(
     if not content.strip():
         return
 
+    _tick_vectors_done()
+
     language = detect_code_language(filename=file.file_path.path.name) or "text"
     cs, mn, ov = JAVA_CHUNK
+    # ``splitter.split`` stays inline: the module-level ``RecursiveSplitter``
+    # shares one Rust object, so keeping split on the event loop preserves its
+    # existing single-threaded access (no new cross-file concurrency hazard).
     chunks = splitter.split(
         content,
         cs,
@@ -198,18 +373,21 @@ async def process_java_file(
     )
     rel = file.file_path.path.as_posix()
     content_bytes = content.encode("utf-8", errors="replace")
-    ast = parse_java(content_bytes)
 
-    for ch in chunks:
+    # (vectors perf lever #2) parse + enrich off the event loop so the loop can
+    # keep the embedder's batching queue fed while this file is being parsed.
+    # parse_java is thread-safe (per-thread tree-sitter Parser in ast_java).
+    enrichments = await asyncio.to_thread(
+        _parse_and_enrich_java, content_bytes, chunks, rel, project_root
+    )
+    # (vectors perf lever #1) embed all chunks concurrently so the batched
+    # embedder groups them into one ``model.encode(...)`` (max_batch_size=64)
+    # instead of N serial batch-of-1 calls. Dominant win for ``increment``
+    # (few changed files → little cross-file concurrency → otherwise no batching).
+    embeddings = await asyncio.gather(*(embedder.embed(ch.text) for ch in chunks))
+
+    for ch, enrich, emb in zip(chunks, enrichments, embeddings):
         rs, re = chunk_key_range(ch)
-        enrich = enrich_chunk(
-            ast,
-            chunk_start_byte=ch.start.byte_offset,
-            chunk_end_byte=ch.end.byte_offset,
-            file_path=rel,
-            project_root=project_root,
-        )
-        emb = await embedder.embed(ch.text)
         table.declare_row(
             row=JavaLanceChunk(
                 id=str(uuid.uuid4()),
@@ -242,7 +420,7 @@ async def process_sql_file(
 ) -> None:
     embedder = coco.use_context(EMBEDDER)
     project_root = coco.use_context(PROJECT_ROOT)
-    if LayeredIgnore(project_root).is_ignored((project_root / file.file_path.path).resolve())[0]:
+    if LayeredIgnore(project_root).is_ignored((project_root / file.file_path.path).resolve()):
         return
     try:
         content = await file.read_text()
@@ -251,6 +429,8 @@ async def process_sql_file(
     if not content.strip():
         return
 
+    _tick_vectors_done()
+
     language = "sql"
     cs, mn, ov = SQL_CHUNK
     chunks = splitter.split(
@@ -262,9 +442,11 @@ async def process_sql_file(
     )
     rel = file.file_path.path.as_posix()
 
-    for ch in chunks:
+    # (vectors perf lever #1) embed chunks concurrently → batched encode.
+    embeddings = await asyncio.gather(*(embedder.embed(ch.text) for ch in chunks))
+
+    for ch, emb in zip(chunks, embeddings):
         rs, re = chunk_key_range(ch)
-        emb = await embedder.embed(ch.text)
         table.declare_row(
             row=SqlLanceChunk(
                 id=str(uuid.uuid4()),
@@ -286,7 +468,7 @@ async def process_yaml_file(
 ) -> None:
     embedder = coco.use_context(EMBEDDER)
     project_root = coco.use_context(PROJECT_ROOT)
-    if LayeredIgnore(project_root).is_ignored((project_root / file.file_path.path).resolve())[0]:
+    if LayeredIgnore(project_root).is_ignored((project_root / file.file_path.path).resolve()):
         return
     try:
         content = await file.read_text()
@@ -295,6 +477,8 @@ async def process_yaml_file(
     if not content.strip():
         return
 
+    _tick_vectors_done()
+
     ext = file.file_path.path.suffix.lower()
     language = "yaml" if ext in (".yml", ".yaml") else "text"
     cs, mn, ov = YAML_CHUNK
@@ -307,9 +491,11 @@ async def process_yaml_file(
     )
     rel = file.file_path.path.as_posix()
 
-    for ch in chunks:
+    # (vectors perf lever #1) embed chunks concurrently → batched encode.
+    embeddings = await asyncio.gather(*(embedder.embed(ch.text) for ch in chunks))
+
+    for ch, emb in zip(chunks, embeddings):
         rs, re = chunk_key_range(ch)
-        emb = await embedder.embed(ch.text)
         table.declare_row(
             row=YamlLanceChunk(
                 id=str(uuid.uuid4()),
@@ -360,8 +546,42 @@ async def app_main() -> None:
     )
 
     project_root = coco.use_context(PROJECT_ROOT)
+    # Warm per-project enrichment caches ONCE on the event-loop thread, BEFORE
+    # coco.mount_each fans files into worker threads. collect_annotation_meta_chain
+    # and load_brownfield_overrides are lru_cached per (resolved) project root;
+    # without warming, the first wave of concurrent process_java_file worker
+    # threads each cold-miss and redundantly walk+parse the ENTIRE project (a
+    # thundering herd that would offset the embedding-batching win on large
+    # repos — perf lever #2 made enrich concurrent). With warming, every worker
+    # hits a populated cache (lru_cache reads are thread-safe). Key derivation
+    # mirrors enrich_chunk exactly so the warmed entries are the ones workers hit.
+    try:
+        load_brownfield_overrides(project_root)
+        try:
+            prs = str(Path(project_root).resolve())
+        except OSError:
+            prs = str(project_root)
+        collect_annotation_meta_chain(prs)
+    except Exception:
+        # Warm-up must never break indexing — a failure just means workers
+        # cold-miss lazily (the pre-warming behavior). Swallow and continue.
+        pass
     _ignore = LayeredIgnore(project_root)
     _walk_excludes = _ignore.cocoindex_excluded_patterns()
+    # Emit ONE approximate total so the parent's renderer can show a determinate
+    # bar (clamps to 100% on the terminal vectors event the parent emits on
+    # cocoindex exit). Approximate — ignored / empty files over-state it; see
+    # ``_approximate_vectors_total``. ``--full-reprocess`` only: on incremental
+    # catch-up the @coco.fn(memo=True) cache skips unchanged files, so no total
+    # is knowable up front → the parent renders indeterminate from the absence.
+    try:
+        total = _approximate_vectors_total(project_root)
+        if total > 0:
+            _emit_vectors_progress(total=total, status="running")
+    except Exception:
+        # The pre-walk must never break indexing — a failure here just means
+        # the parent falls back to indeterminate. Swallow and continue.
+        pass
     java_files = localfs.walk_dir(
         PROJECT_ROOT,
         recursive=True,

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