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

java_codebase_rag/installer.py

@@ -14,6 +14,7 @@ import os
 import shutil
 import sys
 import tempfile
+import time
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal, NamedTuple
@@ -759,6 +760,11 @@ def generate_yaml_config(
         else:
             config["embedding"].pop("model", None)
 
+    # Seed cross-service resolution safe-by-default: only evidence-backed cross-service
+    # edges survive (see _is_brownfield_sourced in build_ast_graph). setdefault preserves
+    # an explicit user choice (e.g. `auto`) on re-run update.
+    config.setdefault("cross_service_resolution", "brownfield_only")
+
     # Keys NOT written by installer (preserved if present):
     # - source_root (config.py resolves from walk-up discovery)
     # - index_dir (config.py defaults to <source_root>/.java-codebase-rag)
@@ -801,6 +807,38 @@ def update_gitignore(cwd: Path) -> None:
         gitignore_path.write_text("\n".join(lines), encoding="utf-8")
 
 
+def _index_progress_header(subcommand: str, source_root: Path, index_dir: Path) -> None:
+    """Print the stderr header framing the indexing sub-step (install/update).
+
+    Mirrors the operator commands' ``_pipeline_header`` but lives in the
+    installer because the wizard's stdout framing differs. This brackets ONLY
+    the indexing sub-step — the wizard's prompts stay outside it on stdout.
+    """
+    from java_codebase_rag.cli_format import bold
+
+    print(
+        bold(
+            f"java-codebase-rag {subcommand} · source={source_root.resolve()} "
+            f"· index={index_dir.resolve()}"
+        ),
+        file=sys.stderr,
+        flush=True,
+    )
+
+
+def _index_progress_footer(subcommand: str, started: float, *, ok: bool) -> None:
+    """Print the stderr footer closing the indexing sub-step framing."""
+    from java_codebase_rag.cli_format import bold, styled_check, styled_cross
+
+    elapsed = time.perf_counter() - started
+    marker = styled_check() if ok else styled_cross()
+    print(
+        f"{marker} {bold(f'java-codebase-rag {subcommand} · finished in {elapsed:.2f}s')}",
+        file=sys.stderr,
+        flush=True,
+    )
+
+
 def run_init_if_needed(
     source_root: Path,
     index_dir: Path,
@@ -808,15 +846,25 @@ def run_init_if_needed(
     *,
     non_interactive: bool,
     quiet: bool,
+    verbose: bool = False,
 ) -> bool:
     """Run init if index directory has no artifacts. Return True if init was run.
 
+    The indexing sub-step (CocoIndex update + AST graph build) renders the
+    unified ``Vectors → Optimize → Graph`` progress on **stderr** in default
+    mode (same renderer the operator commands use); the wizard's conversational
+    stdout is untouched by this function. ``--quiet`` is silent; ``--verbose``
+    raw-relays subprocess output. The indexing chatter that used to print to
+    stdout (``Creating index…`` / ``Index created successfully.``) now lives
+    on stderr framing so stdout stays the wizard payload.
+
     Args:
         source_root: Source root directory
         index_dir: Index directory path
         model: Embedding model path or "auto"
         non_interactive: If True, suppress prompts
-        quiet: If True, suppress output
+        quiet: If True, suppress progress output
+        verbose: If True, raw-relay subprocess output (no Live region)
 
     Returns:
         True if init was run, False if skipped
@@ -832,36 +880,71 @@ def run_init_if_needed(
         print("Index already exists. Run `java-codebase-rag reprocess` to rebuild.")
         return False
 
-    print("Creating index...")
     cfg = resolve_operator_config(
         source_root=source_root,
         cli_index_dir=None,  # use default (<source_root>/.java-codebase-rag)
         cli_embedding_model=model if model != "auto" else None,
     )
     cfg.apply_to_os_environ()
-
     env = cfg.subprocess_env()
 
-    # Run CocoIndex update
-    coco = run_cocoindex_update(env, full_reprocess=False, quiet=quiet)
-    if coco.returncode != 0:
-        print(f"Error: CocoIndex update failed with code {coco.returncode}")
-        return False
-
-    # Run AST graph build
-    g = run_build_ast_graph(
-        source_root=cfg.source_root,
-        ladybug_path=cfg.ladybug_path,
-        verbose=not quiet,
-        quiet=quiet,
-        env=env,
-    )
-    if g.returncode != 0:
-        print(f"Error: AST graph build failed with code {g.returncode}")
-        return False
-
-    print("Index created successfully.")
-    return True
+    # Indexing sub-step: render unified progress on stderr in default mode only
+    # (quiet = silent; verbose = raw relay, no Live region). The renderer wraps
+    # just this sub-step, not the surrounding wizard.
+    on_progress, on_progress_console = None, None
+    renderer = None
+    if not quiet and not verbose:
+        from java_codebase_rag.progress import build_index_progress_context
+
+        renderer, on_progress, on_progress_console = build_index_progress_context()
+
+    started = time.perf_counter()
+    if renderer is not None:
+        _index_progress_header("install", cfg.source_root, cfg.index_dir)
+        renderer.start()
+    index_ok = True
+    try:
+        coco = run_cocoindex_update(
+            env,
+            full_reprocess=False,
+            quiet=quiet,
+            verbose=verbose,
+            on_progress=on_progress,
+            on_progress_console=on_progress_console,
+        )
+        if coco.returncode != 0:
+            print(
+                f"Error: CocoIndex update failed with code {coco.returncode}",
+                file=sys.stderr,
+            )
+            index_ok = False
+        else:
+            g = run_build_ast_graph(
+                source_root=cfg.source_root,
+                ladybug_path=cfg.ladybug_path,
+                verbose=verbose,
+                quiet=quiet,
+                env=env,
+                on_progress=on_progress,
+                on_progress_console=on_progress_console,
+            )
+            if g.returncode != 0:
+                print(
+                    f"Error: AST graph build failed with code {g.returncode}",
+                    file=sys.stderr,
+                )
+                index_ok = False
+    except BaseException:
+        # An exception from cocoindex/graph means the index did not succeed;
+        # flip the footer marker before re-raising so it renders a red cross
+        # (mirrors cli._run_with_pipeline_progress's BaseException handler).
+        index_ok = False
+        raise
+    finally:
+        if renderer is not None:
+            renderer.stop()
+            _index_progress_footer("install", started, ok=index_ok)
+    return index_ok
 
 
 def handle_rerun(cwd: Path, *, non_interactive: bool) -> dict | None:
@@ -1196,13 +1279,25 @@ def run_update(
     force: bool,
     dry_run: bool,
     cwd: Path | None = None,
+    quiet: bool = False,
+    verbose: bool = False,
 ) -> int:
     """Run the update pipeline. Returns exit code.
 
+    The indexing sub-step (Lance catch-up + incremental graph) renders the
+    unified ``Vectors → Optimize → Graph`` progress on **stderr** in default
+    mode and no longer runs with ``quiet=True`` (the reason ``update`` was
+    silent). ``--quiet`` is silent; ``--verbose`` raw-relays subprocess output.
+    The wizard's host-detection / refresh / summary stdout is preserved; only
+    the indexing chatter that used to print to stdout moves onto the stderr
+    renderer framing.
+
     Args:
         force: If True, overwrite all artifacts even if matching
         dry_run: If True, print changes without writing
         cwd: Current working directory (defaults to Path.cwd())
+        quiet: If True, suppress progress output
+        verbose: If True, raw-relay subprocess output (no Live region)
 
     Returns:
         Exit code (0=success, 1=partial, 2=fatal)
@@ -1250,9 +1345,14 @@ def run_update(
         print("Skipping index update.")
         return EXIT_PARTIAL if has_artifact_failures else EXIT_SUCCESS
 
-    # Resolve configuration
+    # Resolve configuration. Pass source_root=None so the YAML ``source_root``
+    # field is honored exactly like increment/init/reprocess — passing the
+    # discovered config dir here routes resolve_operator_config into the
+    # explicit-override branch that SKIPS the YAML field, which made `update`
+    # point cocoindex at the config dir (no Java) against the real index and
+    # mass-delete it. Discovery still runs against the CLI's cwd.
     try:
-        cfg = resolve_operator_config(source_root=project_root, cli_index_dir=None)
+        cfg = resolve_operator_config(source_root=None, cli_index_dir=None)
         index_dir = cfg.index_dir
     except Exception as e:
         print(f"\nWarning: Failed to resolve configuration: {e}")
@@ -1272,30 +1372,74 @@ def run_update(
     # The "graph not implemented" warning belongs only on the vectors-only path
     # (increment --vectors-only), where the graph step is deliberately skipped.
     if not dry_run:
-        print("\nUpdating index (Lance + graph)...")
         cfg.apply_to_os_environ()
         env = cfg.subprocess_env()
 
-        coco = run_cocoindex_update(env, full_reprocess=False, quiet=True)
-        if coco.returncode != 0:
-            print(f"Error: Lance index update failed with code {coco.returncode}")
-            return 1
-
-        g = run_incremental_graph(
-            source_root=cfg.source_root,
-            ladybug_path=cfg.ladybug_path,
-            verbose=False,
-            quiet=True,
-            env=env,
-        )
-        if g.returncode != 0:
-            # Artifacts above already refreshed; the graph catch-up is best-effort
-            # here. Surface a truthful, actionable message instead of leaving the
-            # graph silently stale or claiming the feature is unimplemented.
-            print(
-                f"\nWarning: incremental graph update failed (exit {g.returncode}). "
-                "Run `java-codebase-rag reprocess` for a full rebuild."
+        # Indexing sub-step: render unified progress on stderr in default mode
+        # only (quiet = silent; verbose = raw relay). No longer runs quiet=True
+        # — that was why `update` was silent. The renderer wraps just this
+        # sub-step; the wizard's summary stdout below is outside it.
+        on_progress, on_progress_console = None, None
+        renderer = None
+        if not quiet and not verbose:
+            from java_codebase_rag.progress import build_index_progress_context
+
+            renderer, on_progress, on_progress_console = build_index_progress_context()
+
+        started = time.perf_counter()
+        if renderer is not None:
+            _index_progress_header("update", cfg.source_root, cfg.index_dir)
+            renderer.start()
+        index_ok = True
+        try:
+            coco = run_cocoindex_update(
+                env,
+                full_reprocess=False,
+                quiet=quiet,
+                verbose=verbose,
+                on_progress=on_progress,
+                on_progress_console=on_progress_console,
             )
+            if coco.returncode != 0:
+                print(
+                    f"Error: Lance index update failed with code {coco.returncode}",
+                    file=sys.stderr,
+                )
+                index_ok = False
+            else:
+                g = run_incremental_graph(
+                    source_root=cfg.source_root,
+                    ladybug_path=cfg.ladybug_path,
+                    verbose=verbose,
+                    quiet=quiet,
+                    env=env,
+                    on_progress=on_progress,
+                    on_progress_console=on_progress_console,
+                )
+                if g.returncode != 0:
+                    # The graph catch-up is best-effort: `update`'s primary job
+                    # is refreshing shipped artifacts + vectors (cocoindex). A
+                    # graph failure surfaces a truthful, actionable Warning on
+                    # stderr but does NOT flip index_ok (which drives both the
+                    # footer marker and the return code) — exit 0 with a green
+                    # check + the Warning line carrying the graph caveat.
+                    print(
+                        f"\nWarning: incremental graph update failed (exit {g.returncode}). "
+                        "Run `java-codebase-rag reprocess` for a full rebuild.",
+                        file=sys.stderr,
+                    )
+        except BaseException:
+            # An exception from cocoindex/graph means the index did not succeed;
+            # flip the footer marker before re-raising so it renders a red cross
+            # (mirrors cli._run_with_pipeline_progress's BaseException handler).
+            index_ok = False
+            raise
+        finally:
+            if renderer is not None:
+                renderer.stop()
+                _index_progress_footer("update", started, ok=index_ok)
+        if not index_ok:
+            return 1
     else:
         print("\nWould run incremental index update (Lance + graph).")
 
@@ -1315,6 +1459,7 @@ def run_install(
     model: str | None,
     source_root: Path | None = None,
     quiet: bool = False,
+    verbose: bool = False,
 ) -> int:
     """Run the install pipeline. Returns exit code.
 
@@ -1325,6 +1470,7 @@ def run_install(
         model: Model from CLI flag
         source_root: Source root path (defaults to cwd if None)
         quiet: If True, suppress output
+        verbose: If True, raw-relay subprocess indexing output (no Live region)
 
     Returns:
         Exit code (0=success, 1=partial, 2=fatal)
@@ -1423,6 +1569,7 @@ def run_install(
         resolved_model,
         non_interactive=non_interactive,
         quiet=quiet,
+        verbose=verbose,
     )
 
     return 0

java_codebase_rag/lance_optimize.py

@@ -21,7 +21,14 @@ from __future__ import annotations
 
 import asyncio
 import sys
+import time
 from pathlib import Path
+from typing import Callable, Literal
+
+# Mirrors ``ProgressStatus`` in ``progress.py``; kept local (rather than imported)
+# so this module never pays the ``rich`` cost at import time — see
+# ``_make_optimize_event``.
+_OptimizeStatus = Literal["running", "done", "failed"]
 
 # Single source of truth for the three Lance table names created by the flow.
 # Keep in sync with ``search_lancedb.TABLES`` (the values there mirror these).
@@ -31,6 +38,33 @@ LANCE_TABLE_NAMES: tuple[str, ...] = (
     "yamlconfigindex_yaml_config",
 )
 
+
+def _make_optimize_event(
+    *,
+    status: _OptimizeStatus,
+    elapsed_s: float | None = None,
+):
+    """Build a ``ProgressEvent(kind="optimize", …)`` lazily (progress is parent-side).
+
+    ``lance_optimize`` runs in-process in the parent (called by
+    ``pipeline._maybe_run_serialized_optimize`` and
+    ``server.run_refresh_pipeline``); it routes progress to the renderer via the
+    in-process ``on_progress`` callback — NOT via stderr (which would corrupt
+    the Live region). The import is local so the flow (which imports
+    ``LANCE_TABLE_NAMES`` at definition time) never pays the ``rich`` cost.
+    """
+    from java_codebase_rag.progress import ProgressEvent
+
+    return ProgressEvent(
+        kind="optimize",
+        phase=None,
+        pass_=None,
+        done=None,
+        total=None,
+        status=status,
+        elapsed_s=elapsed_s,
+    )
+
 # Commit conflicts are transient; a handful of exponential-backoff retries is
 # enough because, post-flow, there are no concurrent writers — only successive
 # optimize/compaction passes within this single serialized call can still
@@ -60,7 +94,12 @@ async def _list_table_names(db: object) -> set[str]:
     return set(await db.table_names())
 
 
-async def optimize_lance_tables(index_dir: Path, *, quiet: bool = False) -> dict[str, str]:
+async def optimize_lance_tables(
+    index_dir: Path,
+    *,
+    quiet: bool = False,
+    on_progress: Callable | None = None,
+) -> dict[str, str]:
     """Optimize all known Lance tables under *index_dir*, serially, with retry.
 
     Runs ``table.optimize()`` for each name in :data:`LANCE_TABLE_NAMES` that
@@ -73,6 +112,13 @@ async def optimize_lance_tables(index_dir: Path, *, quiet: bool = False) -> dict
         index_dir: directory holding the Lance tables (the flow's LanceDB URI).
         quiet: when True, suppress the per-table success/skip info lines on
             stderr (errors are always logged).
+        on_progress: optional in-process progress callback (the parent's
+            renderer ``on_progress``). When given, emits
+            ``ProgressEvent(kind="optimize", status="running")`` on entry and a
+            terminal ``status="done"``/``"failed"`` event on exit (covers BOTH
+            call sites: ``pipeline._maybe_run_serialized_optimize`` and
+            ``server.run_refresh_pipeline``). In-process only — NEVER prints to
+            stderr (that would corrupt the Live region).
 
     Returns:
         Mapping of table name → status. Values are ``"ok"``, ``"skipped"``
@@ -82,67 +128,95 @@ async def optimize_lance_tables(index_dir: Path, *, quiet: bool = False) -> dict
     # not pay the lancedb import cost at flow-definition time.
     import lancedb
 
+    if on_progress is not None:
+        on_progress(_make_optimize_event(status="running"))
+    t0 = time.perf_counter()
     results: dict[str, str] = {}
-    db = await lancedb.connect_async(str(index_dir))
+    failed = False
     try:
+        db = await lancedb.connect_async(str(index_dir))
         try:
-            existing = await _list_table_names(db)
-        except Exception as exc:
-            print(
-                f"java-codebase-rag: optimize: failed to list tables in "
-                f"{index_dir}: {exc}",
-                file=sys.stderr,
-            )
-            return {name: f"error: list failed: {exc}" for name in LANCE_TABLE_NAMES}
-
-        for name in LANCE_TABLE_NAMES:
-            if name not in existing:
-                results[name] = "skipped"
-                if not quiet:
-                    print(
-                        f"java-codebase-rag: optimize: {name} absent, skipped",
-                        file=sys.stderr,
-                    )
-                continue
             try:
-                table = await db.open_table(name)
+                existing = await _list_table_names(db)
             except Exception as exc:
-                results[name] = f"error: open failed: {exc}"
                 print(
-                    f"java-codebase-rag: optimize: {name} open failed: {exc}",
+                    f"java-codebase-rag: optimize: failed to list tables in "
+                    f"{index_dir}: {exc}",
                     file=sys.stderr,
                 )
-                continue
-
-            last_exc: BaseException | None = None
-            for attempt in range(_MAX_ATTEMPTS):
+                failed = True
+                return {name: f"error: list failed: {exc}" for name in LANCE_TABLE_NAMES}
+
+            for name in LANCE_TABLE_NAMES:
+                if name not in existing:
+                    results[name] = "skipped"
+                    if not quiet:
+                        print(
+                            f"java-codebase-rag: optimize: {name} absent, skipped",
+                            file=sys.stderr,
+                        )
+                    continue
                 try:
-                    await table.optimize()
-                    last_exc = None
-                    break
+                    table = await db.open_table(name)
                 except Exception as exc:
-                    last_exc = exc
-                    if _is_retryable(exc) and attempt < _MAX_ATTEMPTS - 1:
-                        await asyncio.sleep(_BASE_BACKOFF_S * (2**attempt))
-                        continue
-                    # Non-retryable, or retries exhausted: stop the loop and
-                    # surface below — do not swallow silently.
-                    break
-
-            if last_exc is None:
-                results[name] = "ok"
-                if not quiet:
+                    results[name] = f"error: open failed: {exc}"
+                    failed = True
                     print(
-                        f"java-codebase-rag: optimize: {name} ok",
+                        f"java-codebase-rag: optimize: {name} open failed: {exc}",
                         file=sys.stderr,
                     )
-            else:
-                results[name] = f"error: {last_exc}"
-                print(
-                    f"java-codebase-rag: optimize: {name} failed: {last_exc}",
-                    file=sys.stderr,
-                )
+                    continue
+
+                last_exc: BaseException | None = None
+                for attempt in range(_MAX_ATTEMPTS):
+                    try:
+                        await table.optimize()
+                        last_exc = None
+                        break
+                    except Exception as exc:
+                        last_exc = exc
+                        if _is_retryable(exc) and attempt < _MAX_ATTEMPTS - 1:
+                            await asyncio.sleep(_BASE_BACKOFF_S * (2**attempt))
+                            continue
+                        # Non-retryable, or retries exhausted: stop the loop and
+                        # surface below — do not swallow silently.
+                        break
+
+                if last_exc is None:
+                    results[name] = "ok"
+                    if not quiet:
+                        print(
+                            f"java-codebase-rag: optimize: {name} ok",
+                            file=sys.stderr,
+                        )
+                else:
+                    results[name] = f"error: {last_exc}"
+                    failed = True
+                    print(
+                        f"java-codebase-rag: optimize: {name} failed: {last_exc}",
+                        file=sys.stderr,
+                    )
+        finally:
+            # ``AsyncConnection.close`` is a *sync* method in lancedb 0.30.x.
+            db.close()
+        return results
+    except Exception:
+        # An unexpected exception (e.g. ``connect_async`` raised, or a table-
+        # independent failure) must still flip the terminal event to failed so
+        # the renderer's task doesn't render a green check on a crash. Re-raise
+        # after marking — the caller (``_maybe_run_serialized_optimize`` /
+        # ``run_refresh_pipeline``) treats optimize failure as non-fatal and
+        # logs it, but the renderer must reflect the truth.
+        failed = True
+        raise
     finally:
-        # ``AsyncConnection.close`` is a *sync* method in lancedb 0.30.x.
-        db.close()
-    return results
+        # Always emit a terminal optimize event so the renderer's task never
+        # hangs at "running" — even on exception (the parent treats a failed
+        # optimize as non-fatal: the index is still searchable un-compacted).
+        if on_progress is not None:
+            on_progress(
+                _make_optimize_event(
+                    status="failed" if failed else "done",
+                    elapsed_s=time.perf_counter() - t0,
+                )
+            )