java-codebase-rag 0.11.2__py3-none-any.whl → 0.12.1__py3-none-any.whl

java_codebase_rag/cli_format.py

@@ -1,85 +0,0 @@
-"""TTY-aware ANSI formatting for CLI stderr progress."""
-from __future__ import annotations
-
-import sys
-
-_RESET = "\033[0m"
-_BOLD = "\033[1m"
-_DIM = "\033[2m"
-_GREEN = "\033[32m"
-_RED = "\033[31m"
-_CYAN = "\033[36m"
-
-CHECK = "✓"
-CROSS = "✗"
-
-_NOISE_CONTAINS: tuple[bytes, ...] = (
-    b"lance::",
-    b"FutureWarning",
-    b"Loading weights:",
-    b'"event": "brownfield-',
-    b"unknown producer source strategy",
-    b"unknown client source strategy",
-    # Builder verbose heartbeats / pass banners: in default mode the renderer's
-    # bar subsumes these, so they must NOT also appear as raw lines above the
-    # Live region. --verbose raw-relay bypasses this filter and still shows them.
-    b"[graph] pass ",
-    b"[graph] scoped write ",
-    b"[graph] writing ",
-    b"[graph] done ",
-    b"[increment] ",
-)
-
-
-def is_noise_line(line: bytes) -> bool:
-    return any(p in line for p in _NOISE_CONTAINS)
-
-
-def stderr_is_tty() -> bool:
-    return hasattr(sys.stderr, "isatty") and sys.stderr.isatty()
-
-
-def _styled(text: str, *codes: str) -> str:
-    if not stderr_is_tty():
-        return text
-    return "".join(codes) + text + _RESET
-
-
-def bold(text: str) -> str:
-    return _styled(text, _BOLD)
-
-
-def dim(text: str) -> str:
-    return _styled(text, _DIM)
-
-
-def green(text: str) -> str:
-    return _styled(text, _GREEN)
-
-
-def red(text: str) -> str:
-    return _styled(text, _RED)
-
-
-def cyan(text: str) -> str:
-    return _styled(text, _CYAN)
-
-
-def bold_green(text: str) -> str:
-    return _styled(text, _BOLD, _GREEN)
-
-
-def bold_red(text: str) -> str:
-    return _styled(text, _BOLD, _RED)
-
-
-def bold_cyan(text: str) -> str:
-    return _styled(text, _BOLD, _CYAN)
-
-
-def styled_check() -> str:
-    return green(CHECK) if stderr_is_tty() else CHECK
-
-
-def styled_cross() -> str:
-    return red(CROSS) if stderr_is_tty() else CROSS

java_codebase_rag/cli_progress.py

@@ -1,94 +0,0 @@
-"""CLI-owned stderr progress lines (shared by server reprocess path and pipeline helpers)."""
-from __future__ import annotations
-
-import asyncio
-import sys
-from typing import Callable
-
-from java_codebase_rag.cli_format import is_noise_line
-from java_codebase_rag.progress import ProgressEvent, make_relay
-
-
-class _AsyncLineFilter:
-    """Buffers byte chunks and relays only non-noise lines to stderr (async drain path)."""
-
-    def __init__(self) -> None:
-        self._buf = bytearray()
-        self._suppress_next = False
-
-    def feed(self, chunk: bytes) -> None:
-        self._buf.extend(chunk)
-        while b"\n" in self._buf:
-            line, self._buf = self._buf.split(b"\n", 1)
-            line += b"\n"
-            noise = is_noise_line(line)
-            if noise:
-                self._suppress_next = True
-                continue
-            if self._suppress_next and line[:1] in (b" ", b"\t"):
-                continue
-            self._suppress_next = False
-            sys.stderr.buffer.write(line)
-            sys.stderr.buffer.flush()
-
-    def flush(self) -> None:
-        if self._buf:
-            if not is_noise_line(self._buf):
-                sys.stderr.buffer.write(bytes(self._buf))
-                sys.stderr.buffer.flush()
-            self._buf.clear()
-        self._suppress_next = False
-
-
-async def accumulate_and_relay_subprocess_streams(
-    proc: asyncio.subprocess.Process,
-    *,
-    relay: bool,
-    verbose: bool = True,
-    on_progress: Callable[[ProgressEvent], None] | None = None,
-    on_progress_console: object | None = None,
-) -> tuple[bytes, bytes]:
-    """Read stdout and stderr until EOF; optionally copy non-noise stderr chunks to stderr.
-
-    When ``on_progress`` is set, stderr is drained through a :class:`ProgressRelay`
-    so ``JCIRAG_PROGRESS`` lines are parsed and routed to ``on_progress`` (and
-    suppressed from the relay), matching the sync ``pipeline._popen_capturing_stderr``.
-    """
-    stdout = proc.stdout
-    stderr = proc.stderr
-    if stdout is None or stderr is None:
-        raise RuntimeError("subprocess must be created with stdout=PIPE and stderr=PIPE")
-
-    out_buf = bytearray()
-    err_buf = bytearray()
-    if on_progress is not None:
-        filt = make_relay(on_progress, console=on_progress_console, verbose=verbose)
-    elif relay and not verbose:
-        filt = _AsyncLineFilter()
-    else:
-        filt = None
-
-    async def drain_stdout(reader: asyncio.StreamReader, target: bytearray) -> None:
-        while True:
-            chunk = await reader.read(65536)
-            if not chunk:
-                break
-            target.extend(chunk)
-
-    async def drain_stderr(reader: asyncio.StreamReader, target: bytearray) -> None:
-        while True:
-            chunk = await reader.read(65536)
-            if not chunk:
-                break
-            target.extend(chunk)
-            if filt is not None:
-                filt.feed(chunk)
-            elif relay:
-                sys.stderr.buffer.write(chunk)
-                sys.stderr.buffer.flush()
-
-    await asyncio.gather(drain_stdout(stdout, out_buf), drain_stderr(stderr, err_buf))
-    await proc.wait()
-    if filt is not None:
-        filt.flush()
-    return bytes(out_buf), bytes(err_buf)