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

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
@@ -369,12 +389,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 +407,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,
     )
 

java_codebase_rag/lance_optimize.py

@@ -0,0 +1,148 @@
+"""Serialized post-flow LanceDB optimize with commit-conflict retry.
+
+cocoindex 1.0.7 schedules ``table.optimize()`` (a LanceDB **Rewrite**/compaction
+transaction) as a *background* ``asyncio`` task that races concurrent
+``table.delete()`` (**Delete**) transactions emitted by later mutation batches.
+LanceDB does not allow a Rewrite to commit concurrently with a Delete
+(upstream lancedb#1504 — "We do not support concurrent deletes right now"),
+which surfaces as a flood of::
+
+    RuntimeError: lance error: Retryable commit conflict for version N: \
+This Rewrite transaction was preempted by concurrent transaction Delete ...
+
+To eliminate the race, the flow (``java_index_flow_lancedb.py``) disables the
+in-flight background optimize entirely by raising
+``num_transactions_before_optimize`` to a value that is effectively never
+reached. This module then performs a *single*, serialized optimize after the
+flow returns (exit 0 → no concurrent writers), retrying the rare residual
+commit conflict that two internal compaction passes can still produce.
+"""
+from __future__ import annotations
+
+import asyncio
+import sys
+from pathlib import Path
+
+# 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).
+LANCE_TABLE_NAMES: tuple[str, ...] = (
+    "javacodeindex_java_code",
+    "sqlschemaindex_sql_schema",
+    "yamlconfigindex_yaml_config",
+)
+
+# 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
+# transiently preempt one another.
+_MAX_ATTEMPTS = 6
+_BASE_BACKOFF_S = 0.1
+
+# Substrings identifying the retryable Lance commit-conflict error. LanceDB
+# wraps the underlying lance error text into the raised ``RuntimeError`` str,
+# so a substring match is the robust detector (no dedicated exception type).
+_RETRYABLE_MARKERS = (
+    "Retryable commit conflict",
+    "preempted by concurrent transaction",
+)
+
+
+def _is_retryable(exc: BaseException) -> bool:
+    text = str(exc)
+    return any(marker in text for marker in _RETRYABLE_MARKERS)
+
+
+async def _list_table_names(db: object) -> set[str]:
+    """Existing table names across LanceDB API variants (``list_tables`` ≥ ``table_names``)."""
+    if hasattr(db, "list_tables"):
+        response = await db.list_tables()
+        return set(getattr(response, "tables", response))
+    return set(await db.table_names())
+
+
+async def optimize_lance_tables(index_dir: Path, *, quiet: bool = False) -> 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
+    exists in the DB. Retryable commit conflicts are retried with exponential
+    backoff; any other exception (or an exhausted retry budget) is captured
+    per-table in the returned dict and logged to **stderr** — never stdout,
+    since this is callable from stdio-MCP / JSON-stdout contexts.
+
+    Args:
+        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).
+
+    Returns:
+        Mapping of table name → status. Values are ``"ok"``, ``"skipped"``
+        (table absent — e.g. a repo with no SQL/YAML), or ``"error: <text>"``.
+    """
+    # Lazy import: the flow imports this module for LANCE_TABLE_NAMES and must
+    # not pay the lancedb import cost at flow-definition time.
+    import lancedb
+
+    results: dict[str, str] = {}
+    db = await lancedb.connect_async(str(index_dir))
+    try:
+        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)
+            except Exception as exc:
+                results[name] = f"error: open failed: {exc}"
+                print(
+                    f"java-codebase-rag: optimize: {name} open failed: {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}"
+                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