java-codebase-rag 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

ast_java.py

@@ -83,7 +83,7 @@ _DTO_LOMBOK_ANNOTATIONS: frozenset[str] = frozenset({
 # Phase 11: `EDGE_SCHEMA` in `java_ontology.py` (canonical edge navigation schema; v14 re-index).
 # Phase 12: CALLS `callee_declaring_role`, supertype-walk dedup, pass3 unresolved counters (v15 re-index).
 # Bumps whenever extraction / enrichment semantics change.
-ONTOLOGY_VERSION = 15
+ONTOLOGY_VERSION = 16
 
 ROLE_ANNOTATIONS: dict[str, str] = {
     # Spring Web
@@ -2732,6 +2732,19 @@ def infer_role(annotation_names: Iterable[str]) -> str:
     return "OTHER"
 
 
+def _type_injects_messaging(type_decl: "TypeDecl") -> bool:
+    """True when the type injects a messaging template via field or constructor."""
+    for fld in type_decl.fields:
+        if fld.type_name in _INJECTED_TYPES_TO_CAPABILITY:
+            return True
+    for method in type_decl.methods:
+        if method.is_constructor:
+            for p in method.parameters:
+                if p.type_name in _INJECTED_TYPES_TO_CAPABILITY:
+                    return True
+    return False
+
+
 def infer_role_for_type(type_decl: "TypeDecl") -> str:
     """Role inference that also detects DTO-like passive data carriers.
 
@@ -2763,6 +2776,11 @@ def infer_role_for_type(type_decl: "TypeDecl") -> str:
         if name.endswith(suffix) and name != suffix:
             return "DTO"
 
+    # Types injecting messaging templates are outbound callers (CLIENT role),
+    # symmetric with CONTROLLER covering both HTTP and messaging inbound.
+    if _type_injects_messaging(type_decl):
+        return "CLIENT"
+
     return "OTHER"
 
 

build_ast_graph.py

@@ -70,13 +70,13 @@ log = logging.getLogger(__name__)
 
 _VERBOSE_STDERR_LOCK = threading.Lock()
 
-_PASS1_START = "[pass1] starting · parsing Java files under source root"
-_PASS2_START = "[pass2] starting · emitting EXTENDS / IMPLEMENTS / DECLARES rows"
-_PASS3_START = "[pass3] starting · call resolution (outgoing calls per site)"
-_PASS4_START = "[pass4] starting · route and EXPOSES extraction"
-_PASS5_START = "[pass5] starting · imperative HTTP_CALLS / ASYNC_CALLS edges"
-_PASS6_START = "[pass6] starting · cross-service call-edge matching"
-_WRITE_START = "[write] starting · writing Kuzu graph to disk"
+_PASS1_START = "[graph] pass 1 · parsing Java files"
+_PASS2_START = "[graph] pass 2 · emitting EXTENDS / IMPLEMENTS / DECLARES rows"
+_PASS3_START = "[graph] pass 3 · call resolution (outgoing calls per site)"
+_PASS4_START = "[graph] pass 4 · route and EXPOSES extraction"
+_PASS5_START = "[graph] pass 5 · imperative HTTP_CALLS / ASYNC_CALLS edges"
+_PASS6_START = "[graph] pass 6 · cross-service call-edge matching"
+_WRITE_START = "[graph] writing · Kuzu graph to disk"
 
 
 def _verbose_stderr_line(content: str) -> None:
@@ -104,7 +104,7 @@ class _VerbosePassHeartbeats:
             t0 = time.monotonic()
             while not stop.wait(timeout=5.0):
                 elapsed = int(time.monotonic() - t0)
-                _verbose_stderr_line(f"{tag} running … {elapsed}s elapsed")
+                _verbose_stderr_line(f"{tag} · {elapsed}s elapsed")
 
         self._thr = threading.Thread(target=worker, name=f"hb-{tag}", daemon=True)
         self._thr.start()
@@ -476,7 +476,7 @@ def pass1_parse(root: Path, tables: GraphTables, *, verbose: bool) -> dict[str,
             slow_sec = float(raw_slow)
         except ValueError:
             slow_sec = 0.0
-    with _VerbosePassHeartbeats("[pass1]", verbose=verbose):
+    with _VerbosePassHeartbeats("[graph] pass 1", verbose=verbose):
         if verbose and slow_sec > 0:
             time.sleep(slow_sec)
         for p in iter_java_source_files(root, ignore=ignore):
@@ -521,7 +521,7 @@ def pass1_parse(root: Path, tables: GraphTables, *, verbose: bool) -> dict[str,
     if verbose:
         elapsed = time.time() - t0
         _verbose_stderr_line(
-            f"[pass1] parsed {n_files} files in {elapsed:.2f}s: "
+            f"[graph] pass 1 · parsed {n_files} files in {elapsed:.2f}s: "
             f"{len(tables.types)} types, {len(tables.members)} members, "
             f"{tables.parse_errors} parse errors, {tables.skipped_files} skipped",
         )
@@ -759,7 +759,7 @@ def pass2_edges(tables: GraphTables, asts: dict[str, JavaFileAst], *, verbose: b
     seen_inj: set[tuple[str, str, str, str]] = set()
     if verbose:
         _verbose_stderr_line(_PASS2_START)
-    with _VerbosePassHeartbeats("[pass2]", verbose=verbose):
+    with _VerbosePassHeartbeats("[graph] pass 2", verbose=verbose):
         for fqn, entry in tables.types.items():
             ast = asts.get(entry.file_path)
             if ast is None:
@@ -769,7 +769,7 @@ def pass2_edges(tables: GraphTables, asts: dict[str, JavaFileAst], *, verbose: b
     if verbose:
         elapsed = time.time() - t0
         _verbose_stderr_line(
-            f"[pass2] emitted {len(tables.extends_rows)} EXTENDS, "
+            f"[graph] pass 2 · emitted {len(tables.extends_rows)} EXTENDS, "
             f"{len(tables.implements_rows)} IMPLEMENTS, "
             f"{len(tables.injects_rows)} INJECTS, "
             f"{len(tables.phantoms)} phantoms in {elapsed:.2f}s",
@@ -1432,7 +1432,7 @@ def pass3_calls(tables: GraphTables, asts: dict[str, JavaFileAst], *, verbose: b
         _verbose_stderr_line(_PASS3_START)
     _build_member_indexes(tables)
     stats = CallResolutionStats()
-    with _VerbosePassHeartbeats("[pass3]", verbose=verbose):
+    with _VerbosePassHeartbeats("[graph] pass 3", verbose=verbose):
         for rel_path, file_ast in asts.items():
             try:
                 _process_file_calls(file_ast, rel_path, tables, stats)
@@ -1455,7 +1455,7 @@ def pass3_calls(tables: GraphTables, asts: dict[str, JavaFileAst], *, verbose: b
     )
     log.info(msg)
     if verbose:
-        _verbose_stderr_line(f"[pass3] {msg}")
+        _verbose_stderr_line(f"[graph] pass 3 · {msg}")
 
 
 _PATH_VAR_SEG = re.compile(r"^\{([^:{}]+)(?::([^}]*))?\}$")  # whole path segment
@@ -1586,7 +1586,7 @@ def pass4_routes(
     meta_chain = collect_annotation_meta_chain(prs)
     if verbose:
         _verbose_stderr_line(_PASS4_START)
-    with _VerbosePassHeartbeats("[pass4]", verbose=verbose):
+    with _VerbosePassHeartbeats("[graph] pass 4", verbose=verbose):
 
         for ast in asts.values():
             stats.routes_skipped_unresolved += ast.routes_skipped_unresolved
@@ -1710,7 +1710,7 @@ def pass4_routes(
     )
     log.info(msg)
     if verbose:
-        _verbose_stderr_line(f"[pass4] {msg}")
+        _verbose_stderr_line(f"[graph] pass 4 · {msg}")
 
 
 def pass5_imperative_edges(
@@ -1763,7 +1763,7 @@ def pass5_imperative_edges(
 
     if verbose:
         _verbose_stderr_line(_PASS5_START)
-    with _VerbosePassHeartbeats("[pass5]", verbose=verbose):
+    with _VerbosePassHeartbeats("[graph] pass 5", verbose=verbose):
         for member in sorted(tables.members, key=lambda x: x.node_id):
             if member.decl.is_constructor:
                 continue
@@ -2018,7 +2018,7 @@ def pass5_imperative_edges(
         http_strategy = dict(sorted(tables.call_edge_stats.http_calls_by_strategy.items()))
         async_strategy = dict(sorted(tables.call_edge_stats.async_calls_by_strategy.items()))
         _verbose_stderr_line(
-            f"[pass5] HTTP_CALLS: {len(tables.http_call_rows)} edges, "
+            f"[graph] pass 5 · HTTP_CALLS: {len(tables.http_call_rows)} edges, "
             f"ASYNC_CALLS: {len(tables.async_call_rows)} edges; "
             f"http_by_client_kind={http_client}, async_by_client_kind={async_client}, "
             f"http_by_strategy={http_strategy}, async_by_strategy={async_strategy}",
@@ -2165,7 +2165,7 @@ def pass6_match_edges(
 
     if verbose:
         _verbose_stderr_line(_PASS6_START)
-    with _VerbosePassHeartbeats("[pass6]", verbose=verbose):
+    with _VerbosePassHeartbeats("[graph] pass 6", verbose=verbose):
         for row in tables.http_call_rows:
             if row.match != "unresolved":
                 continue
@@ -2317,14 +2317,14 @@ def pass6_match_edges(
             first_http = ", ".join(suppressed_auto_cross_http)
             first_async = ", ".join(suppressed_auto_cross_async)
             _verbose_stderr_line(
-                f"[pass6] cross_service_resolution=brownfield_only:\n"
+                f"[graph] pass 6 · cross_service_resolution=brownfield_only:\n"
                 f"        {n_bf} cross_service edges from brownfield layers,\n"
                 f"        {suppressed_auto_cross_count} auto-cross-service candidates suppressed -> unresolved\n"
                 f"        (first 5 http: {first_http})\n"
                 f"        (first 5 async: {first_async})",
             )
         _verbose_stderr_line(
-            f"[pass6] http_match={dict(sorted(tables.call_edge_stats.http_calls_match_breakdown.items()))}, "
+            f"[graph] pass 6 · http_match={dict(sorted(tables.call_edge_stats.http_calls_match_breakdown.items()))}, "
             f"async_match={dict(sorted(tables.call_edge_stats.async_calls_match_breakdown.items()))}, "
             f"cross_service_calls_total={tables.call_edge_stats.cross_service_calls_total}",
         )
@@ -3004,7 +3004,7 @@ def write_kuzu(
         )
     if verbose:
         _verbose_stderr_line(_WRITE_START)
-    with _VerbosePassHeartbeats("[write]", verbose=verbose):
+    with _VerbosePassHeartbeats("[graph] writing", verbose=verbose):
         db_path.parent.mkdir(parents=True, exist_ok=True)
         db = kuzu.Database(str(db_path))
         conn = kuzu.Connection(db)
@@ -3018,17 +3018,17 @@ def write_kuzu(
             meta_chain=meta_chain,
         )
         if verbose:
-            _verbose_stderr_line(f"[write] nodes written in {time.time() - t0:.2f}s")
+            _verbose_stderr_line(f"[graph] writing · nodes written in {time.time() - t0:.2f}s")
         _populate_declares_rows(tables)
         _populate_overrides_rows(tables)
         t1 = time.time()
         _write_edges(conn, tables)
         if verbose:
-            _verbose_stderr_line(f"[write] edges written in {time.time() - t1:.2f}s")
+            _verbose_stderr_line(f"[graph] writing · edges written in {time.time() - t1:.2f}s")
         t2 = time.time()
         _write_routes_and_exposes(conn, tables)
         if verbose:
-            _verbose_stderr_line(f"[write] routes/exposes written in {time.time() - t2:.2f}s")
+            _verbose_stderr_line(f"[graph] writing · routes/exposes written in {time.time() - t2:.2f}s")
         _write_meta(conn, tables, source_root)
         conn.close()
 
@@ -3073,7 +3073,7 @@ def main() -> int:
     pass6_match_edges(tables, verbose=args.verbose)
     write_kuzu(kuzu_path, tables, source_root=root, verbose=args.verbose)
     if args.verbose:
-        _verbose_stderr_line(f"[done] kuzu at {kuzu_path}")
+        _verbose_stderr_line(f"[graph] done · kuzu at {kuzu_path}")
     return 0
 
 

java_codebase_rag/cli.py

@@ -100,19 +100,25 @@ _PIPELINE_SEP = "\u00b7"
 
 
 def _pipeline_header(subcommand: str, cfg: ResolvedOperatorConfig) -> None:
+    from java_codebase_rag.cli_format import bold
+
     root = cfg.source_root.resolve()
     idx = cfg.index_dir.resolve()
     print(
-        f"java-codebase-rag {subcommand} {_PIPELINE_SEP} source={root} {_PIPELINE_SEP} index={idx}",
+        bold(f"java-codebase-rag {subcommand} {_PIPELINE_SEP} source={root} {_PIPELINE_SEP} index={idx}"),
         file=sys.stderr,
         flush=True,
     )
 
 
 def _pipeline_footer(subcommand: str, started: float, exit_code: int) -> None:
+    from java_codebase_rag.cli_format import bold, styled_check, styled_cross
+
     elapsed = time.perf_counter() - started
+    marker = styled_check() if exit_code == 0 else styled_cross()
     print(
-        f"java-codebase-rag {subcommand} {_PIPELINE_SEP} finished in {elapsed:.2f}s (exit={exit_code})",
+        f"{marker} {bold(f'java-codebase-rag {subcommand} {_PIPELINE_SEP} finished in {elapsed:.2f}s')}"
+        + (f" (exit={exit_code})" if exit_code != 0 else ""),
         file=sys.stderr,
         flush=True,
     )
@@ -205,6 +211,22 @@ def _add_index_embedding_flags(p: argparse.ArgumentParser) -> None:
     p.add_argument("--embedding-device", type=str, default=None, help="Override SBERT_DEVICE / YAML embedding.device")
 
 
+def _add_verbosity_flags(p: argparse.ArgumentParser) -> None:
+    g = p.add_mutually_exclusive_group()
+    g.add_argument(
+        "--quiet", "-q",
+        action="store_true",
+        dest="quiet",
+        help="Suppress stderr progress relay; stdout payload unchanged.",
+    )
+    g.add_argument(
+        "--verbose", "-v",
+        action="store_true",
+        dest="verbose",
+        help="Show full subprocess output (Lance warnings, brownfield events, progress bars).",
+    )
+
+
 def _cmd_init(args: argparse.Namespace) -> int:
     cfg = _resolved_from_ns(args)
     _startup_hints(cfg)
@@ -227,10 +249,12 @@ def _cmd_init(args: argparse.Namespace) -> int:
 
     def work() -> int:
         env = cfg.subprocess_env()
+        verbose = bool(args.verbose)
         coco = run_cocoindex_update(
             env,
             full_reprocess=False,
             quiet=bool(args.quiet),
+            verbose=verbose,
             lance_project_root=None if args.quiet else cfg.source_root,
         )
         if coco.returncode != 0:
@@ -244,10 +268,13 @@ def _cmd_init(args: argparse.Namespace) -> int:
                 }
             )
             return 1
+        if not args.quiet:
+            print(file=sys.stderr, flush=True)
         g = run_build_ast_graph(
             source_root=cfg.source_root,
             kuzu_path=cfg.kuzu_path,
-            verbose=not args.quiet,
+            verbose=verbose,
+            quiet=bool(args.quiet),
             env=env,
         )
         if g.returncode != 0:
@@ -279,6 +306,7 @@ def _cmd_increment(args: argparse.Namespace) -> int:
             env,
             full_reprocess=False,
             quiet=bool(args.quiet),
+            verbose=bool(args.verbose),
             lance_project_root=None if args.quiet else cfg.source_root,
         )
         if coco.returncode != 0:
@@ -305,11 +333,12 @@ def _cmd_reprocess(args: argparse.Namespace) -> int:
 
     def work() -> int:
         env = cfg.subprocess_env()
+        verbose = bool(args.verbose)
         vectors_only = bool(getattr(args, "vectors_only", False))
         graph_only = bool(getattr(args, "graph_only", False))
 
         if vectors_only:
-            coco = run_cocoindex_update(env, full_reprocess=True, quiet=bool(args.quiet))
+            coco = run_cocoindex_update(env, full_reprocess=True, quiet=bool(args.quiet), verbose=verbose)
             if _is_cocoindex_preflight_blocker(coco):
                 payload: dict[str, Any] = {
                     "success": False,
@@ -345,7 +374,8 @@ def _cmd_reprocess(args: argparse.Namespace) -> int:
             g = run_build_ast_graph(
                 source_root=cfg.source_root,
                 kuzu_path=cfg.kuzu_path,
-                verbose=not args.quiet,
+                verbose=verbose,
+                quiet=bool(args.quiet),
                 env=env,
             )
             if _is_graph_preflight_blocker(g):
@@ -381,7 +411,7 @@ def _cmd_reprocess(args: argparse.Namespace) -> int:
 
         import server  # lazy: pulls sentence_transformers/torch/lancedb/kuzu
 
-        result = asyncio.run(server.run_refresh_pipeline(quiet=bool(args.quiet)))
+        result = asyncio.run(server.run_refresh_pipeline(quiet=bool(args.quiet), verbose=verbose))
         payload = result.model_dump()
         _emit_reprocess_outcome(payload)
         return _reprocess_exit_code(payload)
@@ -473,6 +503,8 @@ def _cmd_meta(args: argparse.Namespace) -> int:
     payload["index_dir"] = str(cfg.index_dir.resolve())
     payload["kuzu_path"] = str(cfg.kuzu_path.resolve())
     payload["index_dir_source"] = cfg.index_dir_source
+    payload["hints_enabled"] = cfg.hints_enabled
+    payload["hints_enabled_source"] = cfg.hints_enabled_source
     _emit(payload)
     return 0 if payload.get("success") else 2
 
@@ -612,11 +644,7 @@ def build_parser() -> argparse.ArgumentParser:
         ),
     )
     _add_index_embedding_flags(init)
-    init.add_argument(
-        "--quiet",
-        action="store_true",
-        help="Suppress stderr progress relay; stdout payload unchanged.",
-    )
+    _add_verbosity_flags(init)
     init.set_defaults(handler=_cmd_init)
 
     increment = subparsers.add_parser(
@@ -625,11 +653,7 @@ def build_parser() -> argparse.ArgumentParser:
         description="Runs cocoindex catch-up (no full reprocess). Does not rebuild Kuzu; see stderr warning.",
     )
     _add_index_embedding_flags(increment)
-    increment.add_argument(
-        "--quiet",
-        action="store_true",
-        help="Suppress stderr progress relay; stdout payload unchanged.",
-    )
+    _add_verbosity_flags(increment)
     increment.set_defaults(handler=_cmd_increment)
 
     reprocess = subparsers.add_parser(
@@ -641,11 +665,7 @@ def build_parser() -> argparse.ArgumentParser:
         ),
     )
     _add_index_embedding_flags(reprocess)
-    reprocess.add_argument(
-        "--quiet",
-        action="store_true",
-        help="Suppress stderr progress relay; stdout payload unchanged.",
-    )
+    _add_verbosity_flags(reprocess)
     _rex = reprocess.add_mutually_exclusive_group()
     _rex.add_argument(
         "--vectors-only",
@@ -667,8 +687,9 @@ def build_parser() -> argparse.ArgumentParser:
     _add_index_embedding_flags(erase)
     erase.add_argument("--yes", action="store_true", help="Confirm destructive deletion (required in CI)")
     erase.add_argument(
-        "--quiet",
+        "--quiet", "-q",
         action="store_true",
+        dest="quiet",
         help="Suppress stderr progress relay; stdout payload unchanged.",
     )
     erase.set_defaults(handler=_cmd_erase)

java_codebase_rag/cli_format.py

@@ -0,0 +1,112 @@
+"""TTY-aware ANSI formatting for CLI stderr progress."""
+from __future__ import annotations
+
+import itertools
+import sys
+import threading
+import time
+
+_RESET = "\033[0m"
+_BOLD = "\033[1m"
+_DIM = "\033[2m"
+_GREEN = "\033[32m"
+_RED = "\033[31m"
+_CYAN = "\033[36m"
+
+CHECK = "✓"
+CROSS = "✗"
+
+_SPINNER_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+_NOISE_CONTAINS: tuple[bytes, ...] = (
+    b"lance::",
+    b"FutureWarning",
+    b"Loading weights:",
+    b'"event": "brownfield-',
+    b"unknown producer source strategy",
+    b"unknown client source strategy",
+)
+
+
+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
+
+
+class Spinner:
+    """Braille spinner that overwrites the current stderr line until stopped."""
+
+    def __init__(self, label: str) -> None:
+        self._label = label
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> None:
+        self._thread = threading.Thread(target=self._run, name="spinner", daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=2.0)
+        sys.stderr.buffer.write(b"\r\x1b[2K")
+        sys.stderr.buffer.flush()
+
+    def _run(self) -> None:
+        frames = itertools.cycle(_SPINNER_FRAMES)
+        t0 = time.monotonic()
+        while not self._stop.wait(0.3):
+            elapsed = time.monotonic() - t0
+            frame = next(frames)
+            line = f"\r{frame} {self._label} · {elapsed:.0f}s"
+            sys.stderr.buffer.write(line.encode())
+            sys.stderr.buffer.flush()

java_codebase_rag/cli_progress.py

@@ -3,32 +3,66 @@ from __future__ import annotations
 
 import asyncio
 import sys
-from pathlib import Path
 
+from java_codebase_rag.cli_format import bold_cyan, is_noise_line, styled_check, styled_cross
 
-def emit_lance_cocoindex_start(project_root: Path) -> None:
-    root = project_root.expanduser().resolve()
+
+def emit_vectors_start() -> None:
     print(
-        f"[lance] running cocoindex update (project_root={root})",
+        bold_cyan("[vectors]") + " running · cocoindex update",
         file=sys.stderr,
         flush=True,
     )
 
 
-def emit_lance_cocoindex_finish(*, elapsed_s: float, exit_code: int) -> None:
+def emit_vectors_finish(*, elapsed_s: float, exit_code: int) -> None:
+    marker = styled_check() if exit_code == 0 else styled_cross()
     print(
-        f"[lance] cocoindex update finished in {elapsed_s:.2f}s (exit={exit_code})",
+        f"{marker} {bold_cyan('[vectors]')} finished · {elapsed_s:.2f}s"
+        + (f" (exit={exit_code})" if exit_code != 0 else ""),
         file=sys.stderr,
         flush=True,
     )
 
 
+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,
 ) -> tuple[bytes, bytes]:
-    """Read stdout and stderr until EOF; optionally copy each chunk verbatim to stderr."""
+    """Read stdout and stderr until EOF; optionally copy non-noise stderr chunks to stderr."""
     stdout = proc.stdout
     stderr = proc.stderr
     if stdout is None or stderr is None:
@@ -36,17 +70,29 @@ async def accumulate_and_relay_subprocess_streams(
 
     out_buf = bytearray()
     err_buf = bytearray()
+    filt = _AsyncLineFilter() if (relay and not verbose) else 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(reader: asyncio.StreamReader, target: bytearray) -> None:
+    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 relay:
+            if filt is not None:
+                filt.feed(chunk)
+            elif relay:
                 sys.stderr.buffer.write(chunk)
                 sys.stderr.buffer.flush()
 
-    await asyncio.gather(drain(stdout, out_buf), drain(stderr, err_buf))
+    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)

java_codebase_rag/config.py

@@ -19,7 +19,7 @@ YAML_CONFIG_FILENAMES = (".java-codebase-rag.yml", ".java-codebase-rag.yaml")
 LEGACY_YAML_FILENAMES = (".lancedb-mcp.yml", ".lancedb-mcp.yaml")
 
 ENV_INDEX_DIR = "JAVA_CODEBASE_RAG_INDEX_DIR"
-# Public operator contract is five names: INDEX_DIR, DEBUG_CONTEXT, RUN_HEAVY, SBERT_MODEL, SBERT_DEVICE.
+# Public operator contract is six names: INDEX_DIR, DEBUG_CONTEXT, RUN_HEAVY, SBERT_MODEL, SBERT_DEVICE, HINTS_ENABLED.
 # SOURCE_ROOT is still required for MCP / subprocess Java tree resolution (see mcp.json.example); it is not folded into the headline "5".
 ENV_SOURCE_ROOT = "JAVA_CODEBASE_RAG_SOURCE_ROOT"
 ENV_DEBUG_CONTEXT = "JAVA_CODEBASE_RAG_DEBUG_CONTEXT"
@@ -146,9 +146,11 @@ class ResolvedOperatorConfig:
     cocoindex_db: Path
     embedding_model: str
     embedding_device: str | None
+    hints_enabled: bool
     index_dir_source: SettingSource
     embedding_model_source: SettingSource
     embedding_device_source: SettingSource
+    hints_enabled_source: SettingSource
 
     def apply_to_os_environ(self) -> None:
         """Make downstream modules (server, kuzu_queries, flows) see a consistent environment.
@@ -218,6 +220,29 @@ def _pick_optional_device(
     return None, "default"
 
 
+def _pick_bool(
+    *,
+    env_key: str,
+    yaml_dict: dict[str, Any],
+    yaml_path: tuple[str, ...],
+    default: bool,
+) -> tuple[bool, SettingSource]:
+    env_raw = os.environ.get(env_key, "").strip().lower()
+    if env_raw in ("1", "true", "yes"):
+        return True, "env"
+    if env_raw in ("0", "false", "no"):
+        return False, "env"
+    cur: Any = yaml_dict
+    for part in yaml_path:
+        if not isinstance(cur, dict) or part not in cur:
+            cur = None
+            break
+        cur = cur.get(part)
+    if isinstance(cur, bool):
+        return cur, "yaml"
+    return default, "default"
+
+
 def _resolve_index_dir_path(
     *,
     source_root: Path,
@@ -270,6 +295,12 @@ def resolve_operator_config(
         env_key="SBERT_DEVICE",
         yaml_dict=yaml_dict,
     )
+    hints, hints_src = _pick_bool(
+        env_key="JAVA_CODEBASE_RAG_HINTS_ENABLED",
+        yaml_dict=yaml_dict,
+        yaml_path=("hints", "enabled"),
+        default=True,
+    )
     ku = index_dir / "code_graph.kuzu"
     coco = index_dir / "cocoindex.db"
     return ResolvedOperatorConfig(
@@ -279,9 +310,11 @@ def resolve_operator_config(
         cocoindex_db=coco,
         embedding_model=model,
         embedding_device=device,
+        hints_enabled=hints,
         index_dir_source=index_src,
         embedding_model_source=model_src,
         embedding_device_source=device_src,
+        hints_enabled_source=hints_src,
     )
 
 

java_codebase_rag/pipeline.py

@@ -2,13 +2,15 @@
 from __future__ import annotations
 
 import os
+import shutil
 import subprocess
 import sys
 import threading
 import time
 from pathlib import Path
 
-from java_codebase_rag.cli_progress import emit_lance_cocoindex_finish, emit_lance_cocoindex_start
+from java_codebase_rag.cli_format import Spinner, is_noise_line, stderr_is_tty
+from java_codebase_rag.cli_progress import emit_vectors_finish, emit_vectors_start
 
 COCOINDEX_TARGET = "java_index_flow_lancedb.py:JavaCodeIndexLance"
 
@@ -18,14 +20,55 @@ def bundle_dir() -> Path:
 
 
 def cocoindex_bin() -> Path:
-    return Path(sys.executable).parent / "cocoindex"
+    candidate = Path(sys.executable).parent / "cocoindex"
+    if candidate.is_file():
+        return candidate
+    found = shutil.which("cocoindex")
+    if found:
+        return Path(found)
+    return candidate
+
+
+class _LineFilter:
+    """Buffer byte chunks and relay only non-noise lines to stderr."""
+
+    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
 
 
-def _popen_stream_to_stderr(
+def _popen_capturing_stderr(
     proc: subprocess.Popen[bytes],
+    *,
+    verbose: bool = True,
 ) -> tuple[str, str, int]:
+    """Capture stdout/stderr; relay stderr through noise filter (or verbatim in verbose mode)."""
     out_buf = bytearray()
     err_buf = bytearray()
+    filt = _LineFilter() if not verbose else None
 
     def drain_out() -> None:
         assert proc.stdout is not None
@@ -34,8 +77,6 @@ def _popen_stream_to_stderr(
             if not chunk:
                 break
             out_buf.extend(chunk)
-            sys.stderr.buffer.write(chunk)
-            sys.stderr.buffer.flush()
 
     def drain_err() -> None:
         assert proc.stderr is not None
@@ -44,8 +85,11 @@ def _popen_stream_to_stderr(
             if not chunk:
                 break
             err_buf.extend(chunk)
-            sys.stderr.buffer.write(chunk)
-            sys.stderr.buffer.flush()
+            if filt is not None:
+                filt.feed(chunk)
+            else:
+                sys.stderr.buffer.write(chunk)
+                sys.stderr.buffer.flush()
 
     t_out = threading.Thread(target=drain_out, name="stream-stdout", daemon=True)
     t_err = threading.Thread(target=drain_err, name="stream-stderr", daemon=True)
@@ -53,6 +97,8 @@ def _popen_stream_to_stderr(
     t_err.start()
     t_out.join()
     t_err.join()
+    if filt is not None:
+        filt.flush()
     code = proc.wait()
     return out_buf.decode(errors="replace"), err_buf.decode(errors="replace"), code
 
@@ -62,6 +108,7 @@ def run_cocoindex_update(
     *,
     full_reprocess: bool,
     quiet: bool,
+    verbose: bool = True,
     lance_project_root: Path | None = None,
 ) -> subprocess.CompletedProcess[str]:
     exe = cocoindex_bin()
@@ -70,7 +117,7 @@ def run_cocoindex_update(
             args=[str(exe)],
             returncode=127,
             stdout="",
-            stderr=f"cocoindex not found next to Python: {exe}",
+            stderr=f"cocoindex not found: {exe}",
         )
     bd = bundle_dir()
     flow = bd / "java_index_flow_lancedb.py"
@@ -96,9 +143,14 @@ def run_cocoindex_update(
             text=True,
         )
 
-    emit_lance = lance_project_root is not None
-    if emit_lance:
-        emit_lance_cocoindex_start(lance_project_root)
+    emit_progress = lance_project_root is not None
+    use_spinner = emit_progress and stderr_is_tty()
+    if emit_progress and not use_spinner:
+        emit_vectors_start()
+    spinner: Spinner | None = None
+    if use_spinner:
+        spinner = Spinner("[vectors] running · cocoindex update")
+        spinner.start()
     t0 = time.perf_counter()
     code = -1
     out_s, err_s = "", ""
@@ -111,10 +163,12 @@ def run_cocoindex_update(
             stderr=subprocess.PIPE,
             bufsize=0,
         )
-        out_s, err_s, code = _popen_stream_to_stderr(proc)
+        out_s, err_s, code = _popen_capturing_stderr(proc, verbose=verbose)
     finally:
-        if emit_lance:
-            emit_lance_cocoindex_finish(elapsed_s=time.perf_counter() - t0, exit_code=code)
+        if spinner is not None:
+            spinner.stop()
+        if emit_progress:
+            emit_vectors_finish(elapsed_s=time.perf_counter() - t0, exit_code=code)
     return subprocess.CompletedProcess(args=cmd, returncode=code, stdout=out_s, stderr=err_s)
 
 
@@ -125,7 +179,7 @@ def run_cocoindex_drop(env: dict[str, str], *, quiet: bool) -> subprocess.Comple
             args=[str(exe)],
             returncode=127,
             stdout="",
-            stderr=f"cocoindex not found next to Python: {exe}",
+            stderr=f"cocoindex not found: {exe}",
         )
     bd = bundle_dir()
     cmd = [str(exe), "drop", COCOINDEX_TARGET, "-f"]
@@ -145,6 +199,7 @@ def run_build_ast_graph(
     source_root: Path,
     kuzu_path: Path,
     verbose: bool,
+    quiet: bool = False,
     env: dict[str, str] | None = None,
 ) -> subprocess.CompletedProcess[str]:
     builder = bundle_dir() / "build_ast_graph.py"
@@ -163,9 +218,12 @@ def run_build_ast_graph(
         "--kuzu-path",
         str(kuzu_path),
     ]
-    if verbose:
+    # Three-tier: --quiet (silent) / default (filtered progress) / --verbose (raw).
+    # Default passes --verbose so the builder emits per-pass progress lines,
+    # which the parent filters via _LineFilter.  --verbose bypasses the filter.
+    if verbose or not quiet:
         cmd.append("--verbose")
-    if not verbose:
+    if quiet:
         return subprocess.run(
             cmd,
             cwd=str(source_root),
@@ -181,7 +239,11 @@ def run_build_ast_graph(
         stderr=subprocess.PIPE,
         bufsize=0,
     )
-    out_s, err_s, code = _popen_stream_to_stderr(proc)
+    out_s, err_s, code = _popen_capturing_stderr(proc, verbose=verbose)
+    if not verbose:
+        from java_codebase_rag.cli_format import bold_cyan, styled_check, styled_cross
+        marker = styled_check() if code == 0 else styled_cross()
+        print(f"{marker} {bold_cyan('[graph]')} done", file=sys.stderr, flush=True)
     return subprocess.CompletedProcess(args=cmd, returncode=code, stdout=out_s, stderr=err_s)
 
 

{java_codebase_rag-0.2.2.dist-info → java_codebase_rag-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.2.2
+Version: 0.3.1
 Summary: MCP server for semantic + structural search over Java codebases
 Author: HumanBean17
 License-Expression: MIT
@@ -27,7 +27,6 @@ Requires-Dist: pathspec<2,>=1.0.4
 Requires-Dist: pyarrow<24,>=23.0.1
 Requires-Dist: PyYAML<7,>=6.0.3
 Requires-Dist: sentence-transformers<6,>=5.4.0
-Requires-Dist: transformers<=5.5.3,>=4.48.3
 Requires-Dist: tree-sitter<0.26,>=0.25.2
 Requires-Dist: tree-sitter-java<0.24,>=0.23.5
 Requires-Dist: unidiff<1,>=0.7.3

{java_codebase_rag-0.2.2.dist-info → java_codebase_rag-0.3.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
-ast_java.py,sha256=QIldCwZVFlJUu3BwBjjoHYAhu5Eas4dxMaAb3MSBWDg,98174
+ast_java.py,sha256=NGs34vhoSypfHbKnNRpA9aj-gO4P6bED3ASmDWEVsZk,98881
 brownfield_events.py,sha256=yxXkKDgMb3VPtaiakGzncHM_EGnda8xIue6w90yYp8s,2055
-build_ast_graph.py,sha256=jF3EzHxZUWOYfghI0RQHZskKmYOzBzi8eFebqlq4kNg,118019
+build_ast_graph.py,sha256=oK2C94tZqCL6KVxOHkrXTLfeF29xWXuBDF49KQxCMZo,118133
 chunk_heuristics.py,sha256=aQk2NOKxzUdqoUAJUO3G3LE0MN_bYZWNLQ0tkmj5uts,1813
 graph_enrich.py,sha256=2-njD2alm7FFpLn217ZG3f3ln-zqbdtGwTghOpd44oo,62021
 index_common.py,sha256=HT6FKHFJ084eFvd3fR1j8z8gf4eWoPHVW8GXLpw464I,285
@@ -9,19 +9,20 @@ java_index_v1_common.py,sha256=nF1KrSqboF_RRvWerG9knRRFmWwsrG_CvhgnsoZ8KqA,1154
 java_ontology.py,sha256=nM-oY8_91rmUudv9hAss1AMus9BFY9s5tTpAWjlCz00,16424
 kuzu_queries.py,sha256=9bQzrU311AOw_BcUp_KSGiZgPVSaLSU7y63XfcT_vqI,90137
 mcp_hints.py,sha256=3swh05LSiWur3tm3-yssndBsLxIxFhy501kBtJI8jJ0,42509
-mcp_v2.py,sha256=KfOWxAUpgVFVA2xaQT-DO1wqCybor1lAi6koavuQ0Jo,78721
+mcp_v2.py,sha256=JFe62sYzJ2XiE6L3wAH8XG9_Ya2oOeJQ_hkiTmXFnSE,79065
 path_filtering.py,sha256=-oX16SYLWYwX9pcV1fu3vbVTIhY1GzFflT7J1E2tqPY,17122
 pr_analysis.py,sha256=Zaq90xYgMgrReV3vCGcFhOkK61gIRMAAIgs7ev-rJG4,18410
 search_lancedb.py,sha256=-XgtpbJ_3zDLiZ_vGKXjaLpl7RlvgyzUb7oAGoWkXO0,36754
-server.py,sha256=DGuRC1lSa0tfzDG6Z_JdRWzuTITEZsXwAWonTTVfQzs,25993
+server.py,sha256=6pw3g29o7SwVYmRZV0NxSc2d_eFg521LkUn9kUCzbJw,26470
 java_codebase_rag/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-java_codebase_rag/cli.py,sha256=hCjlmAXkS80noTX_bxm6BMiLIYEz_P5xfrw9C7LvkBE,27678
-java_codebase_rag/cli_progress.py,sha256=Vtio3RqJ3LkRoNpxrv8iGbEiX4klkTlJX-mR4l6oeBM,1586
-java_codebase_rag/config.py,sha256=h07zJrV8QoLv9hIhJZ2JgUI0Rh6uPBZUiPkGDEmTg_w,11687
-java_codebase_rag/pipeline.py,sha256=QyKNCrBsjdFU71N9Xygti-DdtMQQsrZ8aySisux46lI,5311
-java_codebase_rag-0.2.2.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
-java_codebase_rag-0.2.2.dist-info/METADATA,sha256=VWpfMNxxjvuY2x-rJviWa4pv-OlkX7R93ew-IkFyzjM,15112
-java_codebase_rag-0.2.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-java_codebase_rag-0.2.2.dist-info/entry_points.txt,sha256=mVVQJa0n73OWfhHXYCDoPRrWin_LJhH2Rn0CkJ2iax4,101
-java_codebase_rag-0.2.2.dist-info/top_level.txt,sha256=5aIYoMkvJvvfXvf4iHn2OeSIM7PZXP-0j94eNESnwMw,242
-java_codebase_rag-0.2.2.dist-info/RECORD,,
+java_codebase_rag/cli.py,sha256=7nwrnXdRGZvRKMYcHJDR0CecYsiBt1Fu1RJwrQAIMV0,28518
+java_codebase_rag/cli_format.py,sha256=arU7P9W6Fvm7X_wzR1wJ8EfyxK1rDP_ESEhdA0ub4Mo,2579
+java_codebase_rag/cli_progress.py,sha256=9jCqEagYOXs32SYVA31_sOCrONvYy7cl1CrdBD2Pg44,3168
+java_codebase_rag/config.py,sha256=F6NtbRAlcs9M96bhrkQVeptOkvCFdd0rt_UJFKNiRfA,12633
+java_codebase_rag/pipeline.py,sha256=p0u6yJlBYip2kr7LaCUYFHI4sv9inEgXpZTzcJK_rJ8,7583
+java_codebase_rag-0.3.1.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
+java_codebase_rag-0.3.1.dist-info/METADATA,sha256=o4nk9F_JRE6yX0Jv7O4A45c2vHPXIGVryjxPz8dWEDQ,15068
+java_codebase_rag-0.3.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+java_codebase_rag-0.3.1.dist-info/entry_points.txt,sha256=mVVQJa0n73OWfhHXYCDoPRrWin_LJhH2Rn0CkJ2iax4,101
+java_codebase_rag-0.3.1.dist-info/top_level.txt,sha256=5aIYoMkvJvvfXvf4iHn2OeSIM7PZXP-0j94eNESnwMw,242
+java_codebase_rag-0.3.1.dist-info/RECORD,,

mcp_v2.py

@@ -34,6 +34,18 @@ from kuzu_queries import KuzuGraph, OVERRIDE_AXIS_COMPOSED_EDGE_TYPES
 from mcp_hints import generate_hints, MCP_HINTS_STRUCTURED_FIELD_DESCRIPTION
 from search_lancedb import TABLES, run_search
 
+# Module-level flag set by server.py at startup from resolved config.
+_hints_enabled: bool = True
+
+
+def set_hints_enabled(enabled: bool) -> None:
+    global _hints_enabled
+    _hints_enabled = enabled
+
+
+def _hints_or_skip(tool: str, payload: dict) -> tuple[list, list]:
+    return generate_hints(tool, payload) if _hints_enabled else ([], [])
+
 DeclarationSymbolKind = Literal["class", "interface", "enum", "record", "annotation", "method", "constructor"]
 
 # Stored graph edge labels for one-hop neighbors. Composed DECLARES.* and OVERRIDDEN_BY.*
@@ -937,7 +949,7 @@ def search_v2(
             "limit": limit,
             "offset": offset,
         }
-        raw_struct, raw_advisories = generate_hints("search", hint_payload)
+        raw_struct, raw_advisories = _hints_or_skip("search", hint_payload)
         return SearchOutput(
             success=True,
             results=hits,
@@ -1028,7 +1040,7 @@ def find_v2(
             "filter": filter_dump,
             "has_more_results": has_more_results,
         }
-        raw_struct, raw_advisories = generate_hints("find", hint_payload)
+        raw_struct, raw_advisories = _hints_or_skip("find", hint_payload)
         return FindOutput(
             success=True,
             results=refs,
@@ -1108,7 +1120,7 @@ def describe_v2(
                         f"java-codebase-rag unresolved-calls list --method-id {node_id} for the full list"
                     )
         record = NodeRecord(id=ref.id, kind=kind, fqn=ref.fqn, data=data, edge_summary=edge_summary)
-        raw_struct, raw_advisories = generate_hints("describe", {"success": True, "record": record.model_dump()})
+        raw_struct, raw_advisories = _hints_or_skip("describe", {"success": True, "record": record.model_dump()})
         return DescribeOutput(
             success=True,
             record=record,
@@ -1438,7 +1450,7 @@ def _resolve_finalize_success(
         "path_prefix_seed": path_prefix_seed,
         "target_service_seed": target_service_seed,
     }
-    raw_struct, raw_advisories = generate_hints("resolve", hint_payload)
+    raw_struct, raw_advisories = _hints_or_skip("resolve", hint_payload)
     out = out.model_copy(update={
         "advisories": raw_advisories,
         "hints_structured": _to_structured_hints(raw_struct),
@@ -1972,7 +1984,7 @@ def neighbors_v2(
             "unresolved_count": unresolved_count,
             "calls_row_count": calls_row_count,
         }
-        raw_struct, raw_advisories = generate_hints("neighbors", neigh_payload)
+        raw_struct, raw_advisories = _hints_or_skip("neighbors", neigh_payload)
         return NeighborsOutput(
             success=True,
             results=sliced,

server.py

@@ -13,10 +13,10 @@ import mcp_v2
 from index_common import SBERT_MODEL
 from java_codebase_rag.cli_progress import (
     accumulate_and_relay_subprocess_streams,
-    emit_lance_cocoindex_finish,
-    emit_lance_cocoindex_start,
+    emit_vectors_finish,
+    emit_vectors_start,
 )
-from java_codebase_rag.config import emit_legacy_env_hints_if_present, resolved_sbert_model_for_process_env
+from java_codebase_rag.config import emit_legacy_env_hints_if_present, resolved_sbert_model_for_process_env, resolve_operator_config
 from kuzu_queries import KuzuGraph, resolve_kuzu_path
 from mcp.server.fastmcp import FastMCP
 from pydantic import BaseModel, Field
@@ -201,7 +201,7 @@ def list_code_index_tables_payload() -> IndexInfoOutput:
     )
 
 
-async def run_refresh_pipeline(*, quiet: bool = False) -> RefreshIndexOutput:
+async def run_refresh_pipeline(*, quiet: bool = False, verbose: bool = True) -> RefreshIndexOutput:
     root = _project_root()
     cocoindex_bin = Path(sys.executable).parent / "cocoindex"
     if not cocoindex_bin.is_file():
@@ -245,7 +245,7 @@ async def run_refresh_pipeline(*, quiet: bool = False) -> RefreshIndexOutput:
                 phases_run=[],
             )
     else:
-        emit_lance_cocoindex_start(root)
+        emit_vectors_start()
         t0 = time.perf_counter()
         code_c = -1
         try:
@@ -260,7 +260,7 @@ async def run_refresh_pipeline(*, quiet: bool = False) -> RefreshIndexOutput:
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
             )
-            out_b, err_b = await accumulate_and_relay_subprocess_streams(proc, relay=True)
+            out_b, err_b = await accumulate_and_relay_subprocess_streams(proc, relay=True, verbose=verbose)
             code_c = proc.returncode if proc.returncode is not None else -1
         except Exception as exc:
             return RefreshIndexOutput(
@@ -269,7 +269,7 @@ async def run_refresh_pipeline(*, quiet: bool = False) -> RefreshIndexOutput:
                 phases_run=[],
             )
         finally:
-            emit_lance_cocoindex_finish(elapsed_s=time.perf_counter() - t0, exit_code=code_c)
+            emit_vectors_finish(elapsed_s=time.perf_counter() - t0, exit_code=code_c)
     assert proc is not None
     out = out_b.decode(errors="replace")
     err = err_b.decode(errors="replace")
@@ -279,6 +279,8 @@ async def run_refresh_pipeline(*, quiet: bool = False) -> RefreshIndexOutput:
     graph_out = ""
     graph_err = ""
     if ok:
+        if not quiet:
+            print(file=sys.stderr, flush=True)
         builder = Path(__file__).resolve().parent / "build_ast_graph.py"
         if builder.is_file():
             try:
@@ -303,7 +305,7 @@ async def run_refresh_pipeline(*, quiet: bool = False) -> RefreshIndexOutput:
                 if quiet:
                     gout_b, gerr_b = await gproc.communicate()
                 else:
-                    gout_b, gerr_b = await accumulate_and_relay_subprocess_streams(gproc, relay=True)
+                    gout_b, gerr_b = await accumulate_and_relay_subprocess_streams(gproc, relay=True, verbose=verbose)
                 graph_code = gproc.returncode
                 graph_out = gout_b.decode(errors="replace")
                 graph_err = gerr_b.decode(errors="replace")
@@ -570,6 +572,14 @@ def create_mcp_server() -> FastMCP:
 
 def main() -> None:
     emit_legacy_env_hints_if_present()
+
+    # Load YAML config and apply embedding settings to environment
+    # This ensures SBERT_MODEL and SBERT_DEVICE from .java-codebase-rag.yml are available
+    # before any tool handler runs (same behavior as CLI path)
+    cfg = resolve_operator_config(source_root=_project_root())
+    cfg.apply_to_os_environ()
+    mcp_v2.set_hints_enabled(cfg.hints_enabled)
+
     asyncio.run(create_mcp_server().run_stdio_async())