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

graph_enrich.py

@@ -334,7 +334,7 @@ def collect_annotation_meta_chain(
 ) -> dict[str, frozenset[str]]:
     """Map annotation simple name → built-in simple names reachable via meta-annotations.
 
-    Single source of truth for Layer A: both the Kuzu writer and Lance chunk
+    Single source of truth for Layer A: both the LadybugDB writer and Lance chunk
     enrichment must use this; they must not derive `meta_chain` from separate
     filesystem walks. See ``PLAN-BROWNFIELD-ROLE-OVERRIDES`` §
     *Single source of truth (REQUIRED — read before implementation)*.
@@ -350,7 +350,7 @@ def annotation_meta_decls_from_graph_tables(
     """From `build_ast_graph.GraphTables.types`, map @interface simple name -> meta anns.
 
     Used for diagnostics; Layer A in production uses `collect_annotation_meta_chain`
-    (disk) so Kuzu and Lance share one index.
+    (disk) so LadybugDB and Lance share one index.
     """
     decls: dict[str, tuple[str, ...]] = {}
     first_fqn: dict[str, str] = {}
@@ -1702,7 +1702,7 @@ def enrich_chunk(
 
 
 def symbol_id(kind: str, fqn: str, file_path: str = "", start_byte: int = 0) -> str:
-    """Deterministic SHA1-based id for Kuzu Symbol nodes."""
+    """Deterministic SHA1-based id for LadybugDB Symbol nodes."""
     key = f"{kind}|{fqn}|{file_path}|{start_byte}".encode("utf-8")
     return hashlib.sha1(key).hexdigest()
 

java_codebase_rag/_fdlimit.py

@@ -0,0 +1,48 @@
+"""Raise the process soft file-descriptor limit to avoid LanceDB EMFILE.
+
+LanceDB's merge-insert path opens many file handles concurrently; under the
+default OS soft ``RLIMIT_NOFILE`` (256 on macOS processes launched by GUI /
+launchd / IDE hosts, *not* the shell's raised limit) this exhausts file
+descriptors and surfaces as::
+
+    RuntimeError: lance error: LanceError(IO): ... Too many open files (os error 24)
+        lance-io-4.0.0/src/local.rs:133:24
+
+``raise_fd_limit`` raises the process's *own* soft limit toward its hard limit.
+``RLIMIT_NOFILE`` is inherited across ``fork``+``exec``, so every CocoIndex /
+``cocoindex-code`` child spawned afterwards inherits the headroom. This fixes the
+failure regardless of launch context (shell vs IDE vs MCP host) and regardless of
+Lance's internal IO concurrency.
+
+Never raise to ``RLIM_INFINITY`` — that breaks ``select()``/kqueue and Python
+selectors on macOS; ``cap`` bounds the target to a safe value.
+
+See https://github.com/HumanBean17/java-codebase-rag/issues/306
+"""
+
+from __future__ import annotations
+
+import resource
+
+# Safe ceiling well above LanceDB's appetite, comfortably below macOS libc
+# quirks. The hard limit caps it further if lower (locked-down servers).
+_DEFAULT_CAP = 65536
+
+
+def raise_fd_limit(cap: int = _DEFAULT_CAP) -> None:
+    """Raise this process's soft ``RLIMIT_NOFILE`` toward its hard limit.
+
+    Best-effort and silent: never raises. No-op where ``RLIMIT_NOFILE`` is
+    unsupported (Windows) or where the soft limit already meets ``min(hard, cap)``.
+    """
+    if not hasattr(resource, "RLIMIT_NOFILE"):
+        return
+    soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
+    target = min(hard, cap)
+    if soft >= target:
+        return
+    try:
+        resource.setrlimit(resource.RLIMIT_NOFILE, (target, hard))
+    except (ValueError, OSError):
+        # Best-effort: a locked-down environment shouldn't fail the run.
+        pass

java_codebase_rag/cli.py

@@ -21,13 +21,14 @@ from java_codebase_rag.config import (
     index_dir_has_existing_artifacts,
     resolve_operator_config,
 )
+from java_codebase_rag._fdlimit import raise_fd_limit
 from java_codebase_rag.pipeline import clip, run_build_ast_graph, run_cocoindex_drop, run_cocoindex_update, run_incremental_graph
 from java_ontology import VALID_UNRESOLVED_CALL_REASONS
 
-KUZU_INCREMENTAL_TRACKING_ISSUE_URL = "https://github.com/HumanBean17/java-codebase-rag/issues/73"
+LADYBUG_INCREMENTAL_TRACKING_ISSUE_URL = "https://github.com/HumanBean17/java-codebase-rag/issues/73"
 
 _INCREMENT_WARNING_LINES = (
-    "WARNING: AST graph (Kuzu) incremental rebuild is not yet implemented.",
+    "WARNING: AST graph (LadybugDB) incremental rebuild is not yet implemented.",
     "The graph reflects the index state from the last `init` or `reprocess`,",
     "which means `find`, `neighbors`, and `describe` may return stale results",
     "for files changed since then.",
@@ -37,8 +38,8 @@ _INCREMENT_WARNING_LINES = (
     "For an up-to-date graph, run:",
     "    java-codebase-rag reprocess",
     "",
-    "Track progress on Kuzu incremental rebuild:",
-    f"    {KUZU_INCREMENTAL_TRACKING_ISSUE_URL}",
+    "Track progress on LadybugDB incremental rebuild:",
+    f"    {LADYBUG_INCREMENTAL_TRACKING_ISSUE_URL}",
 )
 
 _REFRESH_DEPRECATION = (
@@ -47,7 +48,7 @@ _REFRESH_DEPRECATION = (
 )
 
 _REPROCESS_DRIFT_VECTORS_ONLY = (
-    "java-codebase-rag reprocess: rebuilt vectors only; graph (code_graph.kuzu) was NOT rebuilt "
+    "java-codebase-rag reprocess: rebuilt vectors only; graph (code_graph.lbug) was NOT rebuilt "
     "and may now reflect a stale source snapshot."
 )
 
@@ -178,7 +179,7 @@ def _emit(value: Any) -> None:
     print(json.dumps(payload, default=_jsonable, sort_keys=True, indent=None))
 
 
-def _emit_increment_kuzu_warning() -> None:
+def _emit_increment_ladybug_warning() -> None:
     for line in _INCREMENT_WARNING_LINES:
         print(line, file=sys.stderr)
 
@@ -289,7 +290,7 @@ def _cmd_init(args: argparse.Namespace) -> int:
             print(file=sys.stderr, flush=True)
         g = run_build_ast_graph(
             source_root=cfg.source_root,
-            kuzu_path=cfg.kuzu_path,
+            ladybug_path=cfg.ladybug_path,
             verbose=verbose,
             quiet=bool(args.quiet),
             env=env,
@@ -319,7 +320,7 @@ def _cmd_increment(args: argparse.Namespace) -> int:
     # Check for --vectors-only flag
     vectors_only = bool(getattr(args, "vectors_only", False))
     if vectors_only:
-        _emit_increment_kuzu_warning()
+        _emit_increment_ladybug_warning()
 
     def work() -> int:
         env = cfg.subprocess_env()
@@ -350,7 +351,7 @@ def _cmd_increment(args: argparse.Namespace) -> int:
         # Run incremental graph update
         g = run_incremental_graph(
             source_root=cfg.source_root,
-            kuzu_path=cfg.kuzu_path,
+            ladybug_path=cfg.ladybug_path,
             verbose=bool(args.verbose),
             quiet=bool(args.quiet),
             env=env,
@@ -437,7 +438,7 @@ def _cmd_reprocess(args: argparse.Namespace) -> int:
         if graph_only:
             g = run_build_ast_graph(
                 source_root=cfg.source_root,
-                kuzu_path=cfg.kuzu_path,
+                ladybug_path=cfg.ladybug_path,
                 verbose=verbose,
                 quiet=bool(args.quiet),
                 env=env,
@@ -509,7 +510,7 @@ def _cmd_erase(args: argparse.Namespace) -> int:
     cfg = _resolved_from_ns(args)
     _startup_hints(cfg)
     cfg.apply_to_os_environ()
-    to_describe: list[Path] = [cfg.kuzu_path, cfg.cocoindex_db]
+    to_describe: list[Path] = [cfg.ladybug_path, cfg.cocoindex_db]
     if cfg.index_dir.is_dir():
         try:
             import lancedb
@@ -546,8 +547,8 @@ def _cmd_erase(args: argparse.Namespace) -> int:
             )
         elif drop.returncode != 0:
             print(clip(drop.stderr, 4000), file=sys.stderr)
-        if cfg.kuzu_path.exists():
-            shutil.rmtree(cfg.kuzu_path, ignore_errors=True)
+        if cfg.ladybug_path.exists():
+            shutil.rmtree(cfg.ladybug_path, ignore_errors=True)
         if cfg.cocoindex_db.exists():
             try:
                 cfg.cocoindex_db.unlink()
@@ -577,17 +578,17 @@ def _cmd_meta(args: argparse.Namespace) -> int:
     cfg = _resolved_from_ns(args)
     _startup_hints(cfg)
     cfg.apply_to_os_environ()
-    from kuzu_queries import KuzuGraph  # lazy
+    from ladybug_queries import LadybugGraph  # lazy
 
-    KuzuGraph._instance = None
-    KuzuGraph._instance_path = None
+    LadybugGraph._instance = None
+    LadybugGraph._instance_path = None
     payload = server._graph_meta_output().model_dump()
     payload["embedding_model"] = cfg.embedding_model
     payload["embedding_device"] = cfg.embedding_device
     payload["embedding_model_source"] = cfg.embedding_model_source
     payload["embedding_device_source"] = cfg.embedding_device_source
     payload["index_dir"] = str(cfg.index_dir.resolve())
-    payload["kuzu_path"] = str(cfg.kuzu_path.resolve())
+    payload["ladybug_path"] = str(cfg.ladybug_path.resolve())
     payload["index_dir_source"] = cfg.index_dir_source
     payload["hints_enabled"] = cfg.hints_enabled
     payload["hints_enabled_source"] = cfg.hints_enabled_source
@@ -637,12 +638,12 @@ def _cmd_unresolved_calls_list(args: argparse.Namespace) -> int:
     cfg = _resolved_from_ns(args)
     _startup_hints(cfg)
     cfg.apply_to_os_environ()
-    from kuzu_queries import KuzuGraph  # lazy
+    from ladybug_queries import LadybugGraph  # lazy
 
-    if not KuzuGraph.exists():
+    if not LadybugGraph.exists():
         _emit({"success": False, "message": "Kuzu graph not found"})
         return 1
-    graph = KuzuGraph.get()
+    graph = LadybugGraph.get()
     rows = graph.list_unresolved_call_sites(
         method_id=args.method_id,
         reason=args.reason,
@@ -658,12 +659,12 @@ def _cmd_unresolved_calls_stats(args: argparse.Namespace) -> int:
     cfg = _resolved_from_ns(args)
     _startup_hints(cfg)
     cfg.apply_to_os_environ()
-    from kuzu_queries import KuzuGraph  # lazy
+    from ladybug_queries import LadybugGraph  # lazy
 
-    if not KuzuGraph.exists():
+    if not LadybugGraph.exists():
         _emit({"success": False, "message": "Kuzu graph not found"})
         return 1
-    graph = KuzuGraph.get()
+    graph = LadybugGraph.get()
     buckets = graph.stats_unresolved_call_sites(by=args.by)
     total = sum(int(r.get("n") or 0) for r in buckets)
     _emit({"success": True, "total": total, "by": args.by, "buckets": buckets})
@@ -683,12 +684,12 @@ def _cmd_analyze_pr(args: argparse.Namespace) -> int:
         _emit({"success": False, "message": "Diff is empty"})
         return 1
     import pr_analysis  # lazy
-    from kuzu_queries import KuzuGraph  # lazy
+    from ladybug_queries import LadybugGraph  # lazy
 
-    if not KuzuGraph.exists():
+    if not LadybugGraph.exists():
         _emit({"success": False, "message": "Kuzu graph not found"})
         return 1
-    graph = KuzuGraph.get()
+    graph = LadybugGraph.get()
     report = pr_analysis.analyze_pr_pipeline(graph, diff_text)
     _emit(pr_analysis.pr_report_to_dict(report))
     return 0
@@ -774,8 +775,9 @@ def build_parser() -> argparse.ArgumentParser:
         help="Refresh shipped artifacts (skill, agent, MCP entry) after pip upgrade.",
         description=(
             "Post-upgrade refresh: overwrites skill and agent files with the latest "
-            "shipped versions and updates the MCP command path. Use --dry-run to "
-            "preview changes without writing. Requires a prior `install` run."
+            "shipped versions and updates the MCP command path. If an index exists, "
+            "also runs an incremental Lance + graph catch-up (same as `increment`). "
+            "Use --dry-run to preview changes without writing. Requires a prior `install` run."
         ),
     )
     update.add_argument(
@@ -902,6 +904,7 @@ def build_parser() -> argparse.ArgumentParser:
 
 
 def main(argv: list[str] | None = None) -> int:
+    raise_fd_limit()
     raw = list(argv if argv is not None else sys.argv[1:])
     if raw and raw[0] == "refresh":
         print(_REFRESH_DEPRECATION, file=sys.stderr)

java_codebase_rag/config.py

@@ -25,6 +25,27 @@ ENV_SOURCE_ROOT = "JAVA_CODEBASE_RAG_SOURCE_ROOT"
 ENV_DEBUG_CONTEXT = "JAVA_CODEBASE_RAG_DEBUG_CONTEXT"
 ENV_RUN_HEAVY = "JAVA_CODEBASE_RAG_RUN_HEAVY"
 
+# CocoIndex inflight-component throttle. CocoIndex's default is 1024 inflight
+# components (cocoindex/_internal/app.py: ``_ENV_MAX_INFLIGHT_COMPONENTS``),
+# which spawns enough concurrent LanceDB merge-inserts to exhaust OS file
+# descriptors under default ulimits -> "Too many open files (os error 24)".
+# NOTE: this is the REAL env var. An earlier fix (#293) set the non-existent
+# ``COCOINDEX_SOURCE_MAX_INFLIGHT_ROWS`` — CocoIndex never reads it, so it was a
+# no-op and the EMFILE error recurred (#306).
+COCOINDEX_MAX_INFLIGHT_COMPONENTS_ENV = "COCOINDEX_MAX_INFLIGHT_COMPONENTS"
+COCOINDEX_DEFAULT_MAX_INFLIGHT_COMPONENTS = "256"
+
+
+def cocoindex_subprocess_env_defaults() -> dict[str, str]:
+    """Env defaults applied to every CocoIndex subprocess to bound concurrency.
+
+    Apply with ``env.setdefault(...)`` so a caller-provided (operator) value
+    always wins. See :issue:`306`.
+    """
+    return {
+        COCOINDEX_MAX_INFLIGHT_COMPONENTS_ENV: COCOINDEX_DEFAULT_MAX_INFLIGHT_COMPONENTS
+    }
+
 _DEFAULT_EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
 
 # Matches either $VAR or ${VAR} (POSIX shell variable syntax).
@@ -67,10 +88,9 @@ def resolved_sbert_model_for_process_env(import_time_default: str) -> str:
 # Legacy env keys: never honored; detection-only hints name the replacement (if any).
 _LEGACY_ENV_HINTS: tuple[tuple[str, str], ...] = (
     ("LANCEDB_URI", "JAVA_CODEBASE_RAG_INDEX_DIR"),
-    ("KUZU_DB_PATH", "JAVA_CODEBASE_RAG_INDEX_DIR (Kuzu lives at <index_dir>/code_graph.kuzu)"),
     ("LANCEDB_MCP_PROJECT_ROOT", "cwd or --source-root (no env replacement)"),
     ("LANCEDB_MCP_ALLOW_REFRESH", "(removed; use init / increment / reprocess / erase)"),
-    ("LANCEDB_MCP_GRAPH_ENABLED", "(removed; graph is used when code_graph.kuzu exists)"),
+    ("LANCEDB_MCP_GRAPH_ENABLED", "(removed; graph is used when code_graph.lbug exists)"),
     ("LANCEDB_MCP_MICROSERVICE_ROOTS", "microservice_roots: in .java-codebase-rag.yml"),
     ("LANCEDB_MCP_DEBUG_CONTEXT", ENV_DEBUG_CONTEXT),
     ("LANCEDB_MCP_RUN_HEAVY", ENV_RUN_HEAVY),
@@ -182,7 +202,7 @@ def load_yaml_mapping(source_root: Path) -> dict[str, Any]:
 class ResolvedOperatorConfig:
     source_root: Path
     index_dir: Path
-    kuzu_path: Path
+    ladybug_path: Path
     cocoindex_db: Path
     embedding_model: str
     embedding_device: str | None
@@ -193,7 +213,7 @@ class ResolvedOperatorConfig:
     hints_enabled_source: SettingSource
 
     def apply_to_os_environ(self) -> None:
-        """Make downstream modules (server, kuzu_queries, flows) see a consistent environment.
+        """Make downstream modules (server, ladybug_queries, flows) see a consistent environment.
 
         When ``embedding_device`` is unset, ``SBERT_DEVICE`` is not removed from ``os.environ`` so
         a long-lived host process is not mutated for unrelated callers; subprocesses still use
@@ -286,9 +306,19 @@ def _pick_bool(
 def _resolve_index_dir_path(
     *,
     source_root: Path,
+    config_dir: Path,
     cli_index_dir: str | None,
     yaml_dict: dict[str, Any],
 ) -> tuple[Path, SettingSource]:
+    # Bases for relative paths:
+    #   - YAML ``index_dir``  -> the config file's directory (``config_dir``),
+    #     the SAME base used for YAML ``source_root``. Paths written in the
+    #     config file are relative to the file, so both keys stay consistent.
+    #   - CLI / env ``index_dir`` -> ``source_root`` (unchanged). These are not
+    #     "in the config file"; preserving the existing base avoids a semantics
+    #     change for operators who pass ``--index-dir`` on the command line.
+    #   - Default ``./.java-codebase-rag`` -> ``source_root`` so the index sits
+    #     beside the Java tree (the layout ``discover_project_root`` anchors on).
     raw_cli = cli_index_dir.strip() if isinstance(cli_index_dir, str) else None
     if raw_cli:
         p = Path(raw_cli).expanduser()
@@ -304,7 +334,7 @@ def _resolve_index_dir_path(
     idx = yaml_dict.get("index_dir")
     if isinstance(idx, str) and idx.strip():
         p = Path(idx.strip()).expanduser()
-        out = p.resolve() if p.is_absolute() else (source_root / p).resolve()
+        out = p.resolve() if p.is_absolute() else (config_dir / p).resolve()
         return out, "yaml"
 
     return (source_root / ".java-codebase-rag").resolve(), "default"
@@ -348,7 +378,7 @@ def resolve_operator_config(
                 root = config_dir
 
     index_dir, index_src = _resolve_index_dir_path(
-        source_root=root, cli_index_dir=cli_index_dir, yaml_dict=yaml_dict
+        source_root=root, config_dir=config_dir, cli_index_dir=cli_index_dir, yaml_dict=yaml_dict
     )
     model, model_src = _pick_str(
         cli_val=cli_embedding_model,
@@ -369,12 +399,12 @@ def resolve_operator_config(
         yaml_path=("hints", "enabled"),
         default=True,
     )
-    ku = index_dir / "code_graph.kuzu"
+    ku = index_dir / "code_graph.lbug"
     coco = index_dir / "cocoindex.db"
     return ResolvedOperatorConfig(
         source_root=root,
         index_dir=index_dir,
-        kuzu_path=ku,
+        ladybug_path=ku,
         cocoindex_db=coco,
         embedding_model=model,
         embedding_device=device,
@@ -387,9 +417,9 @@ def resolve_operator_config(
 
 
 def index_dir_has_existing_artifacts(index_dir: Path) -> tuple[bool, list[str]]:
-    """True if Kuzu graph dir or any Lance table already exists under index_dir."""
+    """True if graph dir or any Lance table already exists under index_dir."""
     paths: list[str] = []
-    ku = index_dir / "code_graph.kuzu"
+    ku = index_dir / "code_graph.lbug"
     if ku.exists():
         paths.append(str(ku.resolve()))
     if index_dir.is_dir():

java_codebase_rag/installer.py

@@ -325,6 +325,66 @@ def select_hosts(*, non_interactive: bool, cli_agents: list[str] | None) -> list
     return [HOSTS[name] for name in selected]
 
 
+def select_microservices(
+    java_dirs: list[Path],
+    *,
+    non_interactive: bool,
+    preselected: list[str] | None = None,
+) -> list[str] | None:
+    """Show an interactive checklist of detected microservices, all pre-checked.
+
+    Returns None when all are selected (-> microservice_roots omitted, index
+    everything) or a non-empty subset list. Never returns [].
+
+    Args:
+        java_dirs: Detected module roots (relative Path names) from
+            detect_java_directories. Caller must pass len >= 2.
+        non_interactive: If True, return None (all) without prompting.
+        preselected: On re-run, the prior microservice_roots subset to pre-check.
+    """
+    # Defensive guard: caller gates on len >= 2, but stay safe if called directly.
+    if len(java_dirs) < 2:
+        return None
+
+    dir_names = [str(d) for d in java_dirs]
+
+    if non_interactive:
+        return None
+
+    preselected_set = set(preselected) if preselected else None
+    choices = [
+        {
+            "name": name,
+            "value": name,
+            "checked": (name in preselected_set) if preselected_set is not None else True,
+        }
+        for name in dir_names
+    ]
+
+    print("Note: Select which modules to index. Toggle with Space, confirm with Enter.")
+    selected = prompt(
+        "checkbox",
+        "Select microservices to index:",
+        choices=choices,
+        default=dir_names,  # non-TTY fallback returns all -> caller omits key
+    )
+
+    if not selected:
+        retry = prompt(
+            "confirm",
+            "At least one module is required. Re-select?",
+        )
+        if retry:
+            return select_microservices(java_dirs, non_interactive=False, preselected=preselected)
+        raise SystemExit(2)
+
+    selected_set = set(selected)
+    if selected_set == set(dir_names):
+        return None
+    # Preserve detection order for deterministic YAML output.
+    return [name for name in dir_names if name in selected_set]
+
+
 def select_scope(*, non_interactive: bool, cli_scope: str | None) -> Scope:
     """Select 'project' or 'user' scope.
 
@@ -791,7 +851,7 @@ def run_init_if_needed(
     # Run AST graph build
     g = run_build_ast_graph(
         source_root=cfg.source_root,
-        kuzu_path=cfg.kuzu_path,
+        ladybug_path=cfg.ladybug_path,
         verbose=not quiet,
         quiet=quiet,
         env=env,
@@ -1182,7 +1242,7 @@ def run_update(
         index_dir_has_existing_artifacts,
         resolve_operator_config,
     )
-    from java_codebase_rag.pipeline import run_cocoindex_update
+    from java_codebase_rag.pipeline import run_cocoindex_update, run_incremental_graph
 
     project_root = discover_project_root(cwd)
     if project_root is None:
@@ -1207,22 +1267,37 @@ def run_update(
         print("Run `java-codebase-rag install` to create one.")
         return EXIT_PARTIAL if has_artifact_failures else EXIT_SUCCESS
 
-    # Run increment (LanceDB catch-up)
+    # Run increment: LanceDB catch-up + incremental graph rebuild.
+    # Mirrors `java-codebase-rag increment` so both index layers stay current.
+    # 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 (incremental LanceDB update)...")
+        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: Index update failed with code {coco.returncode}")
+            print(f"Error: Lance index update failed with code {coco.returncode}")
             return 1
 
-        # Print graph staleness warning
-        from java_codebase_rag.cli import _INCREMENT_WARNING_LINES
-        print("\n" + "\n".join(_INCREMENT_WARNING_LINES))
+        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."
+            )
     else:
-        print("\nWould run incremental index update.")
+        print("\nWould run incremental index update (Lance + graph).")
 
     # Print summary
     print("\nUpdate complete.")
@@ -1270,6 +1345,20 @@ def run_install(
     except SystemExit as e:
         return e.code
 
+    # Stage 1 (Case B): interactive microservice selection (only when 2+ detected)
+    try:
+        selected_roots = (
+            select_microservices(
+                java_dirs,
+                non_interactive=non_interactive,
+                preselected=existing_config.get("microservice_roots") if existing_config else None,
+            )
+            if len(java_dirs) >= 2
+            else None
+        )
+    except SystemExit as e:
+        return e.code
+
     # Stage 2: Embedding model
     resolved_model = resolve_model(model, non_interactive=non_interactive)
 
@@ -1312,7 +1401,7 @@ def run_install(
     yaml_content = generate_yaml_config(
         source_root,
         resolved_model,
-        microservice_roots=[str(d) for d in java_dirs] if len(java_dirs) > 1 else None,
+        microservice_roots=selected_roots,
         existing_yaml=existing_config,
     )