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

java_codebase_rag/progress.py

@@ -0,0 +1,570 @@
+"""JCIRAG_PROGRESS protocol: parse, render, and relay subprocess progress.
+
+The five lifecycle commands (``init`` / ``increment`` / ``install`` /
+``reprocess`` / ``update``) drive two subprocesses — ``cocoindex update``
+(vectors → Lance) and ``build_ast_graph.py`` (graph → LadybugDB) — whose
+stderr output is inconsistent and shows no real progress. This module is the
+foundation of a unified progress surface.
+
+A subprocess prints lines of the form::
+
+    JCIRAG_PROGRESS kind=vectors phase=embed done=842 total=1240
+    JCIRAG_PROGRESS kind=graph phase=build pass=3/6 done=120 total=600 status=running
+    JCIRAG_PROGRESS kind=optimize status=done elapsed_s=42.1 total=1240
+
+to its **stderr**. The parent (``pipeline._LineFilter`` /
+``cli_progress._AsyncLineFilter`` drain path) feeds each stderr chunk to a
+:class:`ProgressRelay`, which:
+
+1. buffers chunks and splits on ``\\n`` (mirrors the existing line filters),
+2. parses each complete line with :func:`parse_progress_line`,
+3. if it is a progress line → forwards a :class:`ProgressEvent` to an
+   :class:`IndexProgressRenderer` and **suppresses** the raw line, else
+4. runs the existing noise matcher (``is_noise_line``) and routes the
+   surviving line to the active sink (console / raw stderr / drop).
+
+On a TTY the renderer drives a ``rich.progress.Live`` region; off-TTY it
+prints concise throttled lines (one per phase, ~every 5 s, plus a final
+terminal line). This module is pure library — no production caller is wired
+in yet.
+"""
+from __future__ import annotations
+
+import sys
+import time
+from dataclasses import dataclass
+from typing import Callable, Literal
+
+from rich.console import Console
+from rich.live import Live
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    SpinnerColumn,
+    TaskProgressColumn,
+    TextColumn,
+    TimeRemainingColumn,
+)
+from rich.text import Text
+
+from java_codebase_rag.cli_format import is_noise_line
+
+__all__ = [
+    "ProgressEvent",
+    "parse_progress_line",
+    "IndexProgressRenderer",
+    "ProgressRelay",
+    "CallbackRenderer",
+    "make_relay",
+    "build_index_progress_context",
+]
+
+ProgressKind = Literal["vectors", "graph", "optimize"]
+ProgressStatus = Literal["running", "done", "failed"]
+
+_PREFIX = "JCIRAG_PROGRESS"
+# Non-TTY concise-line throttle window, in seconds, per phase.
+_FALLBACK_THROTTLE_S = 5.0
+
+
+# ---------------------------------------------------------------------------
+# Protocol
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class ProgressEvent:
+    """A single parsed ``JCIRAG_PROGRESS`` line.
+
+    ``pass_`` carries a multi-pass label like ``"3/6"`` (graph builder passes).
+    All optional fields are ``None`` when the emitting line omits the token.
+    """
+
+    kind: ProgressKind
+    phase: str | None
+    pass_: str | None
+    done: int | None
+    total: int | None
+    status: ProgressStatus
+    elapsed_s: float | None
+
+
+def parse_progress_line(line: bytes) -> ProgressEvent | None:
+    """Parse one raw stderr line into a :class:`ProgressEvent`.
+
+    Returns ``None`` (never raises) when the line:
+
+    * does not start (after stripping a leading ``\\r``) with the exact
+      ``JCIRAG_PROGRESS`` prefix, or
+    * has the prefix but no usable tokens afterwards (malformed).
+
+    The remainder after the prefix is whitespace-separated ``key=value``
+    tokens. ``kind`` is required (omitting it → ``None``). ``status`` defaults
+    to ``"running"``. Double / extra spaces are tolerated.
+    """
+    try:
+        text = line.decode("utf-8", errors="replace")
+    except Exception:
+        return None
+    # Tolerate a carriage-return rewind before the prefix.
+    stripped = text.lstrip("\r")
+    if not stripped.startswith(_PREFIX):
+        return None
+    tail = stripped[len(_PREFIX):]
+    # Tokenize on whitespace; empty/whitespace-only tails are malformed.
+    tokens = tail.split()
+    if not tokens:
+        return None
+
+    fields: dict[str, str] = {}
+    for tok in tokens:
+        if "=" not in tok:
+            # A bare token is not a key=value pair → malformed line.
+            continue
+        key, _, value = tok.partition("=")
+        key = key.strip()
+        value = value.strip()
+        if key:
+            fields[key] = value
+
+    if not fields:
+        return None
+
+    kind_raw = fields.get("kind")
+    if kind_raw not in ("vectors", "graph", "optimize"):
+        # kind is required and must be one of the known kinds.
+        return None
+
+    def _maybe_int(name: str) -> int | None:
+        raw = fields.get(name)
+        if raw is None or raw == "":
+            return None
+        try:
+            return int(raw)
+        except ValueError:
+            return None
+
+    def _maybe_float(name: str) -> float | None:
+        raw = fields.get(name)
+        if raw is None or raw == "":
+            return None
+        try:
+            return float(raw)
+        except ValueError:
+            return None
+
+    status_raw = fields.get("status", "running")
+    if status_raw not in ("running", "done", "failed"):
+        status_raw = "running"
+
+    return ProgressEvent(
+        kind=kind_raw,  # type: ignore[arg-type]
+        phase=fields.get("phase") or None,
+        pass_=fields.get("pass") or None,
+        done=_maybe_int("done"),
+        total=_maybe_int("total"),
+        status=status_raw,  # type: ignore[arg-type]
+        elapsed_s=_maybe_float("elapsed_s"),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Renderer
+# ---------------------------------------------------------------------------
+
+
+def _build_progress(console: Console) -> Progress:
+    """Construct the rich.Progress with the canonical column layout.
+
+    The label TextColumn reads ``task.fields["label"]`` so the phase name
+    shown in the bar is independent of the (mutable) description, which we
+    repurpose for status suffixes (``✗`` on failure).
+    """
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[bold cyan]{task.fields[label]}"),
+        BarColumn(),
+        MofNCompleteColumn(),
+        TaskProgressColumn(),
+        TextColumn("{task.description}"),
+        TimeRemainingColumn(),
+        console=console,
+        transient=False,
+    )
+
+
+class IndexProgressRenderer:
+    """Owns the rich Progress region (TTY) or the concise-line fallback (non-TTY).
+
+    Construction registers one task per phase name, each ``total=None`` and
+    **invisible** (the "never spawned" invariant: no task is ``running`` until
+    its first :meth:`apply` arrives). The first event for a kind flips that
+    kind's task visible + started.
+
+    On a non-TTY console (``console.is_terminal is False``) no Live region is
+    used; instead concise lines are printed via :meth:`_fallback_print`,
+    throttled to once per ~5 s per phase, plus one terminal line per phase.
+    """
+
+    def __init__(self, phases: list[str], *, console: Console | None = None) -> None:
+        self._console: Console = console if console is not None else Console(stderr=True)
+        self._phases: list[str] = list(phases)
+        self._fallback: bool = not self._console.is_terminal
+        self._progress: Progress = _build_progress(self._console)
+        # kind -> rich task id. Start every task invisible + not started so the
+        # "never spawned" invariant holds until the first event arrives.
+        self._task_ids: dict[str, int] = {}
+        for phase in self._phases:
+            tid = self._progress.add_task(
+                phase,
+                total=None,
+                visible=False,
+                start=False,
+                label=phase,
+            )
+            self._task_ids[phase] = tid
+        self._live: Live | None = None
+        # Non-TTY throttle bookkeeping (monotonic seconds of last concise print).
+        self._last_print_at: dict[str, float] = {phase: 0.0 for phase in self._phases}
+        # Non-TTY carry-forward: a minimal ``done`` event may omit total /
+        # elapsed_s; fall back to the last-seen values so the concise terminal
+        # line never degrades (e.g. stays ``vectors done · 1240 · 42.1s``).
+        self._last_total: dict[str, int | None] = {phase: None for phase in self._phases}
+        self._last_elapsed: dict[str, float | None] = {phase: None for phase in self._phases}
+        self._started: bool = False
+
+    # -- lifecycle -------------------------------------------------------
+
+    def start(self) -> None:
+        """Enter the Live region (TTY) or no-op (non-TTY). Idempotent."""
+        if self._started:
+            return
+        self._started = True
+        if not self._fallback:
+            self._live = Live(
+                self._progress,
+                console=self._console,
+                refresh_per_second=10,
+                transient=False,
+            )
+            self._live.start()
+
+    def stop(self) -> None:
+        """Exit the Live region (TTY) or no-op (non-TTY). Safe to call once."""
+        if not self._started:
+            return
+        self._started = False
+        if self._live is not None:
+            self._live.stop()
+            self._live = None
+
+    # -- routing ---------------------------------------------------------
+
+    def apply(self, ev: ProgressEvent) -> None:
+        """Route a single :class:`ProgressEvent` to its matching phase task.
+
+        First event for a kind makes that task visible + started. ``total`` and
+        ``done`` are applied directly when present. ``done`` is clamped to be
+        non-decreasing (producers should emit monotonically non-decreasing
+        ``done``; this defensive clamp enforces it so a stray smaller value
+        can't rewind the bar). ``status == "done"`` unconditionally clamps
+        completed to the total in both directions (an approximate total can't
+        stall below 100%, nor can an approximate pre-walk over-count exceed it).
+        ``status == "failed"`` halts the task and marks the description with a
+        red ``✗`` (rich renders the spinner stopped). On non-TTY consoles this
+        delegates to the throttled concise-line printer.
+
+        Safe to call after :meth:`stop`: once the Live region is torn down a
+        drain thread may still feed a trailing event; this is a no-op then so
+        the apply/stop pair is atomic from the caller's view (PR-1 review
+        Minor #6 / cross-PR risk #10).
+        """
+        if not self._started:
+            # After stop() the Live region is gone and rich tasks are torn down;
+            # a trailing event from the drain thread must not mutate state.
+            return
+        if self._fallback:
+            self._fallback_apply(ev)
+            return
+        tid = self._task_ids.get(ev.kind)
+        if tid is None:
+            return
+        task = self._progress.tasks[tid]
+        # First event: promote from pending to running/visible.
+        if not task.started:
+            self._progress.start_task(tid)
+            self._progress.update(tid, visible=True)
+        if ev.total is not None:
+            self._progress.update(tid, total=ev.total)
+        if ev.done is not None:
+            # Set-based (not advance-based) for determinism: each event carries
+            # the absolute completed count, not a delta. Monotonic clamp: never
+            # let a smaller done rewind the bar.
+            new_completed = max(task.completed, ev.done)
+            self._progress.update(tid, completed=new_completed)
+        if ev.status == "done":
+            # Two-way clamp: completed must equal total on done. An approximate
+            # total can under-count (stall below 100%) or the propose's
+            # approximate pre-walk can over-count; both resolve to == total.
+            if task.total is not None and task.completed != task.total:
+                self._progress.update(tid, completed=task.total)
+            self._progress.update(tid, description=f"{ev.kind} ✓")
+            self._progress.stop_task(tid)
+        elif ev.status == "failed":
+            self._progress.update(tid, description=f"{ev.kind} ✗")
+            self._progress.stop_task(tid)
+
+    # -- non-TTY fallback ------------------------------------------------
+
+    def _now(self) -> float:
+        """Indirection for tests; returns the monotonic clock in seconds."""
+        return time.monotonic()
+
+    def _fallback_apply(self, ev: ProgressEvent) -> None:
+        """Concise-line path for non-TTY consoles."""
+        last = self._last_print_at.get(ev.kind, 0.0)
+        now = self._now()
+        terminal = ev.status in ("done", "failed")
+        throttle_ok = (now - last) >= _FALLBACK_THROTTLE_S
+        if not terminal and not throttle_ok and last != 0.0:
+            # Suppressed by the throttle window. (``last != 0.0`` lets the very
+            # first event for a phase print immediately.) Still track totals so
+            # a later terminal line can carry them forward.
+            if ev.total is not None:
+                self._last_total[ev.kind] = ev.total
+            if ev.elapsed_s is not None:
+                self._last_elapsed[ev.kind] = ev.elapsed_s
+            return
+        # Carry forward last-seen total / elapsed_s so a minimal ``done`` event
+        # that omits them still prints a complete terminal line.
+        carried_total = ev.total
+        if carried_total is None:
+            carried_total = self._last_total.get(ev.kind)
+        carried_elapsed = ev.elapsed_s
+        if carried_elapsed is None:
+            carried_elapsed = self._last_elapsed.get(ev.kind)
+        # Update the carry-forward state with whatever this event carried.
+        if ev.total is not None:
+            self._last_total[ev.kind] = ev.total
+        if ev.elapsed_s is not None:
+            self._last_elapsed[ev.kind] = ev.elapsed_s
+        self._last_print_at[ev.kind] = now
+        self._console.print(
+            self._format_concise(ev, total=carried_total, elapsed_s=carried_elapsed)
+        )
+
+    def _format_concise(
+        self,
+        ev: ProgressEvent,
+        *,
+        total: int | None = None,
+        elapsed_s: float | None = None,
+    ) -> Text:
+        """Render one concise line for the non-TTY fallback.
+
+        ``total`` / ``elapsed_s`` are the already-carry-forwarded values to show
+        (the caller resolves event-vs-last-seen before formatting); ``ev``'s own
+        fields are only used for status / done / phase.
+        """
+        kind = ev.kind
+        if ev.status == "done":
+            total_str = str(total) if total is not None else ""
+            elapsed = f"{elapsed_s:.1f}s" if elapsed_s is not None else ""
+            bits = [kind, "done"]
+            if total_str != "":
+                bits.append(total_str)
+            if elapsed:
+                bits.append(elapsed)
+            return Text(" · ".join(bits))
+        if ev.status == "failed":
+            return Text(f"{kind} failed")
+        if ev.done is not None and ev.total is not None and ev.total > 0:
+            pct = int(round(ev.done * 100.0 / ev.total))
+            return Text(f"{kind} {ev.done}/{ev.total} ({pct}%)")
+        if ev.done is not None:
+            return Text(f"{kind} {ev.done}")
+        return Text(kind)
+
+
+class CallbackRenderer:
+    """Adapter exposing a ``renderer.apply(ev)`` surface to :class:`ProgressRelay`.
+
+    ``ProgressRelay`` calls ``renderer.apply(ev)`` for each parsed progress line.
+    This adapter forwards to a caller-supplied ``on_progress`` callback (used by
+    the sync/async subprocess drains in ``pipeline`` / ``cli_progress`` to route
+    progress events up to the command-level renderer without owning a Live region
+    themselves). It carries a ``_console`` attribute so the relay can route
+    non-progress lines through ``console.print`` while a Live region is up.
+    """
+
+    def __init__(self, on_progress, console=None) -> None:  # type: ignore[no-untyped-def]
+        self._on_progress = on_progress
+        self._console = console
+
+    def apply(self, ev: ProgressEvent) -> None:
+        self._on_progress(ev)
+
+    def start(self) -> None:
+        pass
+
+    def stop(self) -> None:
+        pass
+
+
+def make_relay(
+    on_progress: Callable[[ProgressEvent], None],
+    *,
+    console: object | None,
+    verbose: bool,
+) -> ProgressRelay:
+    """Build the standard drain-side :class:`ProgressRelay`.
+
+    Both subprocess drains (``pipeline._popen_capturing_stderr`` sync path and
+    ``cli_progress.accumulate_and_relay_subprocess_streams`` async path) wire a
+    ``CallbackRenderer`` that forwards parsed events to the command-level
+    ``on_progress`` callback, and route non-progress lines through the same
+    caller-supplied ``console``. Centralizing the construction here keeps the
+    sync and async wiring identical (PR-3 forks the async path further).
+    """
+    return ProgressRelay(
+        CallbackRenderer(on_progress, console),
+        console=console,
+        verbose=verbose,
+    )
+
+
+# The canonical phase order shared by every lifecycle command that renders
+# progress. The operator commands (init/increment/reprocess) and the installer
+# sub-steps (install/update indexing) all render this same list so the
+# Vectors → Optimize → Graph shape is uniform across the CLI.
+_INDEX_PHASES = ["vectors", "optimize", "graph"]
+
+
+def build_index_progress_context(
+    phases: list[str] | None = None,
+) -> tuple["IndexProgressRenderer", Callable[[ProgressEvent], None], "Console"]:
+    """Construct the shared ``(renderer, on_progress, console)`` triple.
+
+    Both ``cli._run_with_pipeline_progress`` (operator commands, default TTY
+    mode) and the installer's indexing sub-step (``installer.run_init_if_needed``
+    / ``run_update``) use this so the phase list, the callback wiring, and the
+    single-writer console are defined in exactly one place. The returned
+    ``on_progress`` forwards each event to ``renderer.apply``; ``console`` is
+    the renderer's stderr ``rich.Console`` so the subprocess drain routes
+    non-progress lines through ``console.print`` while a Live region is up.
+
+    The caller owns ``renderer.start()``/``stop()`` lifecycle. In ``--quiet``
+    or ``--verbose`` mode the caller simply does not call this helper (quiet
+    is silent; verbose raw-relays).
+    """
+    renderer = IndexProgressRenderer(phases if phases is not None else _INDEX_PHASES)
+
+    def on_progress(ev: ProgressEvent) -> None:
+        renderer.apply(ev)
+
+    return renderer, on_progress, renderer._console  # noqa: SLF001 — shared console for the drain
+
+
+# ---------------------------------------------------------------------------
+# Relay
+# ---------------------------------------------------------------------------
+
+
+class ProgressRelay:
+    """Single-writer bridge between a subprocess stderr drain and the renderer.
+
+    Mirrors the byte-buffering of ``cli_progress._AsyncLineFilter`` /
+    ``pipeline._LineFilter``: accumulate chunks, split on ``\\n``, route each
+    complete line. When ``verbose`` is True (and no renderer is attached) the
+    relay writes raw bytes to ``sys.stderr.buffer`` (raw mode, no Live region).
+    """
+
+    def __init__(
+        self,
+        renderer: IndexProgressRenderer | None,
+        *,
+        console: Console | None = None,
+        verbose: bool = False,
+    ) -> None:
+        self._renderer = renderer
+        self._verbose = verbose
+        self._console: Console | None = console
+        self._buf = bytearray()
+        # Live region is only meaningful when a renderer is attached.
+        self._live_active: bool = renderer is not None
+        # Mirrors ``_LineFilter._suppress_next``: a noise header line (e.g. a
+        # ``FutureWarning:`` banner) suppresses the NEXT line too, which is its
+        # indented traceback frame(s). ``line[:1] in (b" ", b"\t")`` is the
+        # continuation signal. Progress lines reset this (they are consumed by
+        # the renderer, never noise).
+        self._suppress_next: bool = False
+
+    def feed(self, chunk: bytes) -> None:
+        """Buffer ``chunk`` and route each complete (``\\n``-terminated) line."""
+        self._buf.extend(chunk)
+        while b"\n" in self._buf:
+            line, self._buf = self._buf.split(b"\n", 1)
+            line += b"\n"
+            self._route_line(line)
+
+    def flush(self) -> None:
+        """Emit any trailing partial buffer (without a trailing newline)."""
+        if self._buf:
+            # Trailing partial line: continuation suppression does not apply
+            # (there is no following line). Route it directly.
+            self._route_line(bytes(self._buf))
+            self._buf.clear()
+
+    def _route_line(self, line: bytes) -> None:
+        ev = parse_progress_line(line)
+        if ev is not None and self._renderer is not None:
+            # Consumed by the protocol — never echoed to any sink. It is not
+            # noise, so it must not keep the suppression flag armed.
+            self._suppress_next = False
+            # Guard the render chain: a drain thread is a daemon, so an
+            # unhandled exception here dies silently and truncates the captured
+            # stderr, masking real bugs. Mirror the defensive ``except Exception``
+            # around the raw ``buffer.write`` path below: log a one-line note to
+            # real stderr and keep draining. Never re-raise.
+            try:
+                self._renderer.apply(ev)
+            except Exception as exc:
+                sys.stderr.write(
+                    f"java-codebase-rag: progress renderer error: {exc}\n"
+                )
+                sys.stderr.flush()
+            return
+        if ev is not None and self._renderer is None:
+            # Parsed as progress but no renderer attached: still reset the flag
+            # (a progress line is never noise) and drop quietly.
+            self._suppress_next = False
+            return
+        # Non-progress line: noise path, with continuation suppression.
+        if is_noise_line(line):
+            self._suppress_next = True
+            return
+        if self._suppress_next and line[:1] in (b" ", b"\t"):
+            # Indented continuation of the preceding noise header (e.g. a
+            # traceback frame). Drop without disarming: a multi-frame traceback
+            # has several such lines in a row.
+            return
+        self._suppress_next = False
+        text = line.decode("utf-8", errors="replace")
+        if self._renderer is not None and self._live_active:
+            # The drains always construct the relay with the caller's console
+            # (see make_relay), so ``self._console`` is authoritative here.
+            assert self._console is not None  # invariant: drains always supply it
+            # rich.Console over a Live region must suspend/resume to interleave
+            # a one-off line without corrupting the bar redraw; print() handles
+            # this correctly when the Live was started on the same console.
+            self._console.print(text, end="")
+            return
+        if self._verbose and self._renderer is None:
+            try:
+                sys.stderr.buffer.write(line)
+                sys.stderr.buffer.flush()
+            except Exception:
+                pass
+            return
+        # Neither verbose nor a renderer: drop quietly (quiet mode).

{java_codebase_rag-0.6.2.dist-info → java_codebase_rag-0.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.6.2
+Version: 0.6.3
 Summary: MCP server for semantic + structural search over Java codebases
 Author: HumanBean17
 License-Expression: MIT
@@ -28,6 +28,7 @@ Requires-Dist: pyarrow<24,>=23.0.1
 Requires-Dist: pydantic<3,>=2.0
 Requires-Dist: PyYAML<7,>=6.0.3
 Requires-Dist: questionary<3,>=2.0
+Requires-Dist: rich<15,>=14
 Requires-Dist: sentence-transformers<6,>=5.4.0
 Requires-Dist: tree-sitter<0.26,>=0.25.2
 Requires-Dist: tree-sitter-java<0.24,>=0.23.5
@@ -106,6 +107,8 @@ java-codebase-rag install --non-interactive --agent claude-code
 
 After `pip install --upgrade java-codebase-rag`, run `java-codebase-rag update` to refresh shipped artifacts and catch up the index (Lance + graph).
 
+All indexing lifecycle commands (`init`, `increment`, `reprocess`, `install`, `update`) show a unified `Vectors → Optimize → Graph` progress bar on stderr during the index build (powered by `rich`); pass `--quiet` to suppress it.
+
 ### Manual registration
 
 If you prefer manual configuration, see [`docs/JAVA-CODEBASE-RAG-CLI.md`](./docs/JAVA-CODEBASE-RAG-CLI.md) for the full CLI reference.

{java_codebase_rag-0.6.2.dist-info → java_codebase_rag-0.6.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
 ast_java.py,sha256=NQgZzstbsMq-PdowoD6r_ixJKxEEFzTP9xUzqDpiXeU,99661
 brownfield_events.py,sha256=yxXkKDgMb3VPtaiakGzncHM_EGnda8xIue6w90yYp8s,2055
-build_ast_graph.py,sha256=OKigswkUmWwUAKXXRNH4zplw2VonIdWUWzVjC-t5roo,152893
+build_ast_graph.py,sha256=LNU1rIHwgEpbrWnWoywg4JdqbwwT4UKcx1iDay_GemM,156776
 chunk_heuristics.py,sha256=aQk2NOKxzUdqoUAJUO3G3LE0MN_bYZWNLQ0tkmj5uts,1813
 graph_enrich.py,sha256=POT4LwSkTsrjUmP67bsm2UezUam70cunuPDYDh-v1Bs,63332
 index_common.py,sha256=HT6FKHFJ084eFvd3fR1j8z8gf4eWoPHVW8GXLpw464I,285
-java_index_flow_lancedb.py,sha256=MH9iTNF6HDHDTt5Jn7TOVE5hQ4WUPNt7PlQoh1tuh9o,13212
+java_index_flow_lancedb.py,sha256=7CS-sdbzhCkUsHfpCZ85uM7vy4aoZI8n-RowLocfiKc,20267
 java_index_v1_common.py,sha256=nF1KrSqboF_RRvWerG9knRRFmWwsrG_CvhgnsoZ8KqA,1154
 java_ontology.py,sha256=71bCLDNvMy0SpZPzSR5apJ0qJXNd6y5ggkLdBEw_PFo,16682
 ladybug_queries.py,sha256=912j9VAYDjcU4ReVorWQ6R4DZl0tteKic-Pqu0jyBS0,90837
@@ -13,21 +13,22 @@ mcp_v2.py,sha256=o94GJI7j6dLJDIA3R_1ZiQhjzQfMAEW3etdeZYnHOUc,80637
 path_filtering.py,sha256=-oX16SYLWYwX9pcV1fu3vbVTIhY1GzFflT7J1E2tqPY,17122
 pr_analysis.py,sha256=3-5L8_G5XupdJsl9RN73Lq-ejPoK11B3m_VzAx2fGG8,18413
 search_lancedb.py,sha256=scG6HBUrsgIeSWFrGcLcGdhWv1qODOx4JOBMAlLDY_E,36793
-server.py,sha256=Js3XDpV7ThAtj352StH6QdhHutf1D5qUkbR-8k3jO8g,31303
+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=HkzCP8-G3WlCzoXcVCI2K3forDOMpTmUSoxgx3jbKk4,34774
-java_codebase_rag/cli_format.py,sha256=arU7P9W6Fvm7X_wzR1wJ8EfyxK1rDP_ESEhdA0ub4Mo,2579
-java_codebase_rag/cli_progress.py,sha256=9jCqEagYOXs32SYVA31_sOCrONvYy7cl1CrdBD2Pg44,3168
+java_codebase_rag/cli.py,sha256=uTCpgsE3gbDPSqPDNJeJ7hZu_MhyKYm4tqHIMkM67LM,38650
+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=sE0l85K_o291PdpF1vpesefR9VgdvvVeARXrpTxa30A,46689
-java_codebase_rag/lance_optimize.py,sha256=MzACYlgwxmkJCK64qQLyIAdizSq5BARqaMYSZONlc1I,6069
-java_codebase_rag/pipeline.py,sha256=UcgluFAW9Ghnas8u40x45bVic0mQv6rjzcliDKsnYJI,11936
+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=APl9d-No12qZNZLjU7mwNRwxHIgnT3ZtQZiD4clWlyU,14413
 java_codebase_rag/install_data/skills/explore-codebase/SKILL.md,sha256=pIM-Xdwq_fXkhhBJCdb-fA2nes5c_mMPcdUXb7Adyxo,12040
-java_codebase_rag-0.6.2.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
-java_codebase_rag-0.6.2.dist-info/METADATA,sha256=X92kaZ5TbEacz0sznWtUtpYEJvBdWIXX0s8MlqOeRyg,16934
-java_codebase_rag-0.6.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-java_codebase_rag-0.6.2.dist-info/entry_points.txt,sha256=wsPZwot0Ui4JI3TIgW8LcbN8bNtKFbwQAlHAAJXfYgQ,117
-java_codebase_rag-0.6.2.dist-info/top_level.txt,sha256=syQgi8XPBwY2ws_NZ1uRCxTf_s41NpshwEHNdcdnk3A,245
-java_codebase_rag-0.6.2.dist-info/RECORD,,
+java_codebase_rag-0.6.3.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
+java_codebase_rag-0.6.3.dist-info/METADATA,sha256=zDwRolQN2GTSexo7J2ngIqB-RnqmsnTZLRQ-lWuqBL4,17197
+java_codebase_rag-0.6.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+java_codebase_rag-0.6.3.dist-info/entry_points.txt,sha256=wsPZwot0Ui4JI3TIgW8LcbN8bNtKFbwQAlHAAJXfYgQ,117
+java_codebase_rag-0.6.3.dist-info/top_level.txt,sha256=syQgi8XPBwY2ws_NZ1uRCxTf_s41NpshwEHNdcdnk3A,245
+java_codebase_rag-0.6.3.dist-info/RECORD,,