java-codebase-rag 0.6.1__tar.gz → 0.6.2__tar.gz

{java_codebase_rag-0.6.1/java_codebase_rag.egg-info → java_codebase_rag-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.6.1
+Version: 0.6.2
 Summary: MCP server for semantic + structural search over Java codebases
 Author: HumanBean17
 License-Expression: MIT

{java_codebase_rag-0.6.1 → java_codebase_rag-0.6.2}/java_codebase_rag/cli.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import argparse
 import asyncio
 import json
+import os
 import pprint
 import shutil
 import sys
@@ -930,5 +931,21 @@ def main(argv: list[str] | None = None) -> int:
         return 2
 
 
+def _console_script_main() -> None:
+    """Real CLI entry: terminate without interpreter finalization.
+
+    A pyarrow/lance worker thread (loaded via lancedb in lifecycle commands) can
+    outlive CPython finalization in a one-shot CLI subprocess and trip
+    ``PyGILState_Release`` (SIGABRT, exit -6). Flushing + ``os._exit`` skips that
+    racy teardown — the command has already done its work and emitted its result.
+    ``main()`` stays return-based so in-process test callers (``cli.main(...)``)
+    keep working.
+    """
+    rc = main()
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os._exit(rc)
+
+
 if __name__ == "__main__":
-    raise SystemExit(main())
+    _console_script_main()

{java_codebase_rag-0.6.1 → java_codebase_rag-0.6.2}/java_codebase_rag/config.py

@@ -52,14 +52,36 @@ _DEFAULT_EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
 _UNRESOLVED_VAR_RE = re.compile(r"\$(\w+|\{[^}]+\})")
 
 
-def maybe_expand_embedding_model_path(value: str) -> str:
-    """Expand ``~`` and ``$VAR`` when *value* is path-shaped.
+def maybe_expand_embedding_model_path(
+    value: str,
+    *,
+    config_dir: Path | None = None,
+    source_root: Path | None = None,
+    source: SettingSource | None = None,
+) -> str:
+    """Expand ``~`` / ``$VAR`` for path-shaped values and resolve relatives to absolute.
 
     Path-shape: starts with ``/``, ``./``, ``../``, ``~``, or contains ``$``.
     Plain ``org/name`` (hub id) does not match and is passed through unchanged.
 
-    Used for ``embedding.model`` after precedence resolution and for runtime
-    ``SBERT_MODEL`` reads (e.g. MCP) so the string matches ``ResolvedOperatorConfig``.
+    Relative resolution mirrors :func:`_resolve_index_dir_path` so a committed
+    config is portable regardless of process CWD:
+
+    * YAML values (``source == "yaml"``) resolve against ``config_dir`` (the
+      directory holding ``.java-codebase-rag.yml``).
+    * CLI / env values resolve against ``source_root``.
+
+    Only a result that still starts with ``./`` or ``../`` *after* ``~`` /
+    ``$VAR`` expansion is re-based — so hub ids (``org/name``), absolute paths,
+    ``~/``-expanded paths, and an env var that already yielded an absolute path
+    are all left untouched.
+
+    When no base is supplied (the runtime ``SBERT_MODEL`` read via
+    :func:`resolved_sbert_model_for_process_env`), relative resolution is
+    skipped: the value is returned ``expandvars`` / ``expanduser``-expanded but
+    not re-based, matching the prior best-effort behavior. The main resolution
+    path (:func:`resolve_operator_config`) supplies a base, so the absolute path
+    it stores is what downstream loaders receive.
     """
     needs_expand = value.startswith(("/", "./", "../", "~")) or "$" in value
     if not needs_expand:
@@ -70,9 +92,31 @@ def maybe_expand_embedding_model_path(value: str) -> str:
             f"java-codebase-rag: path-shaped model string contains unresolved variable: {expanded}",
             file=sys.stderr,
         )
+    if expanded.startswith(("./", "../")):
+        base = _embedding_model_base(
+            source=source, config_dir=config_dir, source_root=source_root
+        )
+        if base is not None:
+            return str((base / expanded).resolve())
     return expanded
 
 
+def _embedding_model_base(
+    *,
+    source: SettingSource | None,
+    config_dir: Path | None,
+    source_root: Path | None,
+) -> Path | None:
+    """Base directory for a relative ``embedding.model``.
+
+    Mirrors :func:`_resolve_index_dir_path`: YAML values anchor on the config
+    file's directory; CLI / env values anchor on the resolved ``source_root``.
+    """
+    if source == "yaml":
+        return config_dir
+    return source_root
+
+
 def resolved_sbert_model_for_process_env(import_time_default: str) -> str:
     """``SBERT_MODEL`` from the process environment, with the same expansion as YAML/CLI resolution.
 
@@ -387,7 +431,12 @@ def resolve_operator_config(
         yaml_path=("embedding", "model"),
         default=_DEFAULT_EMBEDDING_MODEL,
     )
-    model = maybe_expand_embedding_model_path(model)
+    model = maybe_expand_embedding_model_path(
+        model,
+        config_dir=config_dir,
+        source_root=root,
+        source=model_src,
+    )
     device, device_src = _pick_optional_device(
         cli_val=cli_embedding_device,
         env_key="SBERT_DEVICE",

{java_codebase_rag-0.6.1 → java_codebase_rag-0.6.2}/java_codebase_rag/installer.py

@@ -759,6 +759,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)
@@ -1250,9 +1255,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}")

{java_codebase_rag-0.6.1 → java_codebase_rag-0.6.2/java_codebase_rag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.6.1
+Version: 0.6.2
 Summary: MCP server for semantic + structural search over Java codebases
 Author: HumanBean17
 License-Expression: MIT

java_codebase_rag-0.6.2/java_codebase_rag.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+java-codebase-rag = java_codebase_rag.cli:_console_script_main
+java-codebase-rag-mcp = server:main

{java_codebase_rag-0.6.1 → java_codebase_rag-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "java-codebase-rag"
-version = "0.6.1"
+version = "0.6.2"
 description = "MCP server for semantic + structural search over Java codebases"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -53,7 +53,7 @@ Repository = "https://github.com/HumanBean17/java-codebase-rag"
 Issues = "https://github.com/HumanBean17/java-codebase-rag/issues"
 
 [project.scripts]
-java-codebase-rag = "java_codebase_rag.cli:main"
+java-codebase-rag = "java_codebase_rag.cli:_console_script_main"
 java-codebase-rag-mcp = "server:main"
 
 [tool.setuptools]

{java_codebase_rag-0.6.1 → java_codebase_rag-0.6.2}/tests/test_config.py

@@ -292,6 +292,155 @@ class TestSourceRootPrecedence:
         assert result.index_dir == tmp_path / ".java-codebase-rag"
 
 
+class TestEmbeddingModelRelativePath:
+    """``embedding.model`` relative paths resolve against a base directory.
+
+    Mirrors ``index_dir`` (see ``TestIndexDirRelativeToConfigDir``): a relative
+    model path in YAML resolves against the config file's directory; a relative
+    model path from CLI / env resolves against the resolved ``source_root``.
+    This makes a committed ``.java-codebase-rag.yml`` portable — the model loads
+    from the same absolute path for the CLI indexer and the MCP reader, instead
+    of resolving against an unreliable process CWD.
+    """
+
+    def test_yaml_relative_model_resolves_against_config_dir(self, tmp_path, monkeypatch):
+        """``embedding.model: ./models/minilm`` (YAML) -> <config_dir>/models/minilm."""
+        monkeypatch.delenv("SBERT_MODEL", raising=False)
+        monkeypatch.delenv("JAVA_CODEBASE_RAG_SOURCE_ROOT", raising=False)
+
+        config_dir = tmp_path / "ctx"
+        config_dir.mkdir()
+        (config_dir / YAML_CONFIG_FILENAMES[0]).write_text(
+            "embedding:\n  model: ./models/minilm\n"
+        )
+        monkeypatch.chdir(config_dir)
+
+        result = resolve_operator_config(source_root=None)
+        assert result.embedding_model == str((config_dir / "models/minilm").resolve())
+        assert result.embedding_model_source == "yaml"
+
+    def test_yaml_double_dot_model_resolves_against_config_dir(self, tmp_path, monkeypatch):
+        """``embedding.model: ../shared/minilm`` (YAML) -> <config_dir>/../shared/minilm."""
+        monkeypatch.delenv("SBERT_MODEL", raising=False)
+        monkeypatch.delenv("JAVA_CODEBASE_RAG_SOURCE_ROOT", raising=False)
+
+        config_dir = tmp_path / "ctx"
+        config_dir.mkdir()
+        (config_dir / YAML_CONFIG_FILENAMES[0]).write_text(
+            "embedding:\n  model: ../shared/minilm\n"
+        )
+        monkeypatch.chdir(config_dir)
+
+        result = resolve_operator_config(source_root=None)
+        assert result.embedding_model == str((tmp_path / "shared/minilm").resolve())
+
+    def test_env_relative_model_resolves_against_source_root(self, tmp_path, monkeypatch):
+        """``SBERT_MODEL=./models/minilm`` (env) -> <source_root>/models/minilm.
+
+        Config sets ``source_root: ../`` so source_root (tmp_path) differs from
+        config_dir (tmp_path/ctx); the env-sourced model must anchor on
+        source_root, not config_dir — matching ``index_dir``'s env base.
+        """
+        monkeypatch.delenv("JAVA_CODEBASE_RAG_SOURCE_ROOT", raising=False)
+
+        config_dir = tmp_path / "ctx"
+        config_dir.mkdir()
+        (config_dir / YAML_CONFIG_FILENAMES[0]).write_text("source_root: ../\n")
+        monkeypatch.chdir(config_dir)
+        monkeypatch.setenv("SBERT_MODEL", "./models/minilm")
+
+        result = resolve_operator_config(source_root=None)
+        assert result.source_root == tmp_path
+        assert result.embedding_model == str((tmp_path / "models/minilm").resolve())
+        assert result.embedding_model_source == "env"
+
+    def test_cli_relative_model_resolves_against_source_root(self, tmp_path, monkeypatch):
+        """``--embedding-model ./models/minilm`` (CLI) -> <source_root>/models/minilm."""
+        monkeypatch.delenv("SBERT_MODEL", raising=False)
+
+        result = resolve_operator_config(
+            source_root=tmp_path, cli_embedding_model="./models/minilm"
+        )
+        assert result.embedding_model == str((tmp_path / "models/minilm").resolve())
+        assert result.embedding_model_source == "cli"
+
+
+class TestMaybeExpandEmbeddingModelPath:
+    """Unit tests pinning the expansion/resolution helper's contract."""
+
+    def test_no_base_leaves_relative_unchanged(self):
+        """Without a base dir, relative paths are NOT resolved.
+
+        ``resolved_sbert_model_for_process_env`` (the MCP runtime read of
+        ``SBERT_MODEL``) calls this with no base; it must stay a no-op for
+        relative values so MCP behavior is unchanged there. The main resolution
+        path supplies a base, so the absolute path it produces is what reaches
+        the lazy loader in practice.
+        """
+        from java_codebase_rag.config import maybe_expand_embedding_model_path
+
+        assert maybe_expand_embedding_model_path("./models/minilm") == "./models/minilm"
+        assert maybe_expand_embedding_model_path("../shared/minilm") == "../shared/minilm"
+
+    def test_hub_id_passthrough(self):
+        from java_codebase_rag.config import maybe_expand_embedding_model_path
+
+        assert maybe_expand_embedding_model_path("org/name") == "org/name"
+        assert (
+            maybe_expand_embedding_model_path("sentence-transformers/all-MiniLM-L6-v2")
+            == "sentence-transformers/all-MiniLM-L6-v2"
+        )
+
+    def test_absolute_passthrough(self):
+        from java_codebase_rag.config import maybe_expand_embedding_model_path
+
+        assert maybe_expand_embedding_model_path("/opt/models/minilm") == "/opt/models/minilm"
+
+    def test_env_var_expansion_preserved(self, monkeypatch):
+        from java_codebase_rag.config import maybe_expand_embedding_model_path
+
+        monkeypatch.setenv("MODEL_DIR", "/opt/models")
+        assert maybe_expand_embedding_model_path("${MODEL_DIR}/minilm") == "/opt/models/minilm"
+        assert maybe_expand_embedding_model_path("$MODEL_DIR/minilm") == "/opt/models/minilm"
+
+    def test_tilde_expansion_preserved(self, monkeypatch):
+        from java_codebase_rag.config import maybe_expand_embedding_model_path
+
+        monkeypatch.setenv("HOME", "/home/user")
+        assert maybe_expand_embedding_model_path("~/models/minilm") == "/home/user/models/minilm"
+
+    def test_yaml_base_resolves_relative(self, tmp_path):
+        from java_codebase_rag.config import maybe_expand_embedding_model_path
+
+        out = maybe_expand_embedding_model_path(
+            "./models/minilm", config_dir=tmp_path, source="yaml"
+        )
+        assert out == str((tmp_path / "models/minilm").resolve())
+
+    def test_cli_env_base_is_source_root(self, tmp_path):
+        from java_codebase_rag.config import maybe_expand_embedding_model_path
+
+        for src in ("cli", "env"):
+            out = maybe_expand_embedding_model_path(
+                "./models/minilm", source_root=tmp_path, source=src
+            )
+            assert out == str((tmp_path / "models/minilm").resolve())
+
+    def test_absolute_after_env_var_not_rebased(self, tmp_path, monkeypatch):
+        """An env var that already yields an absolute path is left absolute.
+
+        Guards the ``${HUB_ID}`` edge: only ``./`` / ``../``-prefixed results are
+        re-based, so a var holding ``org/name`` or an absolute path is untouched.
+        """
+        from java_codebase_rag.config import maybe_expand_embedding_model_path
+
+        monkeypatch.setenv("MODEL_DIR", "/opt/models")
+        out = maybe_expand_embedding_model_path(
+            "${MODEL_DIR}/minilm", config_dir=tmp_path, source="yaml"
+        )
+        assert out == "/opt/models/minilm"
+
+
 def test_cocoindex_subprocess_env_defaults_uses_real_inflight_env_var() -> None:
     """The throttle must use CocoIndex's REAL env var name.
 

{java_codebase_rag-0.6.1 → java_codebase_rag-0.6.2}/tests/test_installer.py

@@ -696,6 +696,45 @@ class TestHandleRerun:
         assert result is None
 
 
+class TestGenerateYamlConfigCrossService:
+    """cross_service_resolution is seeded safe-by-default; an explicit choice is never overridden."""
+
+    def test_fresh_install_seeds_brownfield_only(self):
+        import yaml
+        from java_codebase_rag.installer import generate_yaml_config
+
+        out = generate_yaml_config(
+            Path("."), model="auto", microservice_roots=None, existing_yaml=None
+        )
+        assert yaml.safe_load(out)["cross_service_resolution"] == "brownfield_only"
+
+    def test_explicit_auto_is_preserved_on_rerun(self):
+        import yaml
+        from java_codebase_rag.installer import generate_yaml_config
+
+        out = generate_yaml_config(
+            Path("."),
+            model="auto",
+            microservice_roots=None,
+            existing_yaml={"cross_service_resolution": "auto"},
+        )
+        assert yaml.safe_load(out)["cross_service_resolution"] == "auto"
+
+    def test_absent_key_seeded_and_existing_keys_preserved_on_rerun(self):
+        import yaml
+        from java_codebase_rag.installer import generate_yaml_config
+
+        out = generate_yaml_config(
+            Path("."),
+            model="auto",
+            microservice_roots=None,
+            existing_yaml={"brownfield_overrides": {"svc-a": {}}},
+        )
+        config = yaml.safe_load(out)
+        assert config["cross_service_resolution"] == "brownfield_only"
+        assert config["brownfield_overrides"] == {"svc-a": {}}
+
+
 class TestInstallIntegration:
     """Integration tests for install command."""
 
@@ -1161,6 +1200,102 @@ class TestRunUpdate:
         # Should succeed (no hosts is fatal, but no index is just a warning)
         assert result == 0
 
+    def test_update_honors_yaml_source_root_for_nested_config_dir(
+        self, tmp_path, monkeypatch
+    ):
+        """run_update must resolve source_root exactly like increment.
+
+        Regression for the "update mass-deletes the index" bug. run_update passed
+        the discovered config dir as an explicit source_root, routing
+        resolve_operator_config into the branch that SKIPS the YAML source_root
+        field. With a config living in my-project-context/ next to
+        ``source_root: ../``, update then indexed my-project-context/ (no Java)
+        against the real index one level up — so cocoindex saw every indexed
+        file as removed and deleted it (the "_deletions keeps growing" symptom
+        after the run was ctrl+C'd mid-delete).
+
+        After the fix, the env handed to cocoindex carries the YAML-resolved
+        source_root (one level above the config dir), NOT the config dir itself.
+        """
+        import json
+        import shutil
+        from subprocess import CompletedProcess
+        from java_codebase_rag.installer import run_update
+
+        # Layout mirroring the reported bug:
+        #   tmp_path/
+        #     my-project-context/      <- cwd; config lives here
+        #       .java-codebase-rag.yml <- source_root: ../ ; index_dir: ../.java-codebase-rag
+        #     .java-codebase-rag/      <- real index, one level above the config
+        #       code_graph.lbug        <- marker so "index exists"
+        config_dir = tmp_path / "my-project-context"
+        config_dir.mkdir()
+        (config_dir / ".java-codebase-rag.yml").write_text(
+            "source_root: ../\nindex_dir: ../.java-codebase-rag\n",
+            encoding="utf-8",
+        )
+        index_dir = tmp_path / ".java-codebase-rag"
+        index_dir.mkdir()
+        (index_dir / "code_graph.lbug").write_text("", encoding="utf-8")
+
+        # A configured host so run_update reaches the index phase.
+        (config_dir / ".mcp.json").write_text(
+            json.dumps(
+                {
+                    "mcpServers": {
+                        "java-codebase-rag": {
+                            "command": "/usr/local/bin/java-codebase-rag-mcp",
+                            "type": "stdio",
+                        }
+                    }
+                }
+            )
+        )
+        monkeypatch.setattr(shutil, "which", lambda x: "/usr/local/bin/java-codebase-rag-mcp")
+        monkeypatch.setattr(
+            "java_codebase_rag.installer._read_package_artifact",
+            lambda path: "PACKAGE CONTENT",
+        )
+
+        # The CLI invokes update from the config dir, so the process cwd is the
+        # config dir — resolve_operator_config(source_root=None) discovers the
+        # config via Path.cwd(), exactly as increment/init/reprocess do.
+        # delenv: resolve_operator_config honors JAVA_CODEBASE_RAG_SOURCE_ROOT /
+        # _INDEX_DIR from os.environ first, and apply_to_os_environ() writes them
+        # unscoped — a sibling test can leak a value that overrides discovery.
+        monkeypatch.delenv("JAVA_CODEBASE_RAG_SOURCE_ROOT", raising=False)
+        monkeypatch.delenv("JAVA_CODEBASE_RAG_INDEX_DIR", raising=False)
+        monkeypatch.chdir(config_dir)
+
+        # Capture the subprocess env run_update hands cocoindex: it carries the
+        # resolved JAVA_CODEBASE_RAG_SOURCE_ROOT / _INDEX_DIR.
+        captured: dict = {}
+
+        def capture_coco(env, *, full_reprocess, quiet, verbose=True, lance_project_root=None):
+            captured["env"] = env
+            return CompletedProcess(["cocoindex"], 0)
+
+        def noop_graph(**kwargs):
+            return CompletedProcess(["build_ast_graph", "--incremental"], 0)
+
+        monkeypatch.setattr("java_codebase_rag.pipeline.run_cocoindex_update", capture_coco)
+        monkeypatch.setattr("java_codebase_rag.pipeline.run_incremental_graph", noop_graph)
+
+        result = run_update(force=False, dry_run=False, cwd=config_dir)
+
+        # The index phase must have run (env captured), not been skipped.
+        assert "env" in captured, "run_update did not reach the cocoindex update step"
+        env = captured["env"]
+        # source_root: ../ must resolve ONE level above the config dir (the real
+        # Java tree), NOT the config dir itself.
+        assert env["JAVA_CODEBASE_RAG_SOURCE_ROOT"] == str(tmp_path.resolve())
+        assert env["JAVA_CODEBASE_RAG_SOURCE_ROOT"] != str(config_dir.resolve())
+        # index_dir lands on the real index one level above the config dir.
+        assert env["JAVA_CODEBASE_RAG_INDEX_DIR"] == str(index_dir.resolve())
+        # result is independent of the source_root assertion (artifact refresh
+        # may report partial failure unrelated to this regression); tolerate it.
+        assert result in (0, 1)
+
     def test_install_then_update_cycle(self, tmp_path, monkeypatch):
         """install then update: artifacts refreshed, no errors"""
         from java_codebase_rag.installer import run_install, run_update

{java_codebase_rag-0.6.1 → java_codebase_rag-0.6.2}/tests/test_java_codebase_rag_cli.py

@@ -1174,3 +1174,59 @@ def test_mcp_server_yaml_config_precedence_env_over_yaml(
 
     server_mod.resolve_operator_config.assert_called_once()
     assert server_mod.resolve_operator_config.call_args.kwargs["source_root"] == server_mod._project_root()
+
+
+def test_console_script_main_propagates_rc_via_os_exit_after_flush(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """The installed CLI entry must flush streams and os._exit(rc) rather than
+    return into normal interpreter finalization.
+
+    A pyarrow/lance worker thread can outlive CPython finalization in a one-shot
+    CLI subprocess and trip ``PyGILState_Release`` (SIGABRT, exit -6). Routing the
+    real entry through ``_console_script_main`` skips that racy teardown; ``main()``
+    itself stays return-based so in-process test callers keep working.
+    """
+    import os as _os
+
+    from java_codebase_rag import cli as cli
+
+    class _StubStream:
+        def __init__(self) -> None:
+            self.flushed = False
+
+        def flush(self) -> None:
+            self.flushed = True
+
+    for fake_rc in (0, 2):
+        out = _StubStream()
+        err = _StubStream()
+        snapshot: dict[str, object] = {}
+
+        monkeypatch.setattr(cli, "main", lambda rc=fake_rc: rc)
+        monkeypatch.setattr(sys, "stdout", out)
+        monkeypatch.setattr(sys, "stderr", err)
+
+        def fake_exit(code: int) -> None:
+            snapshot["exit_code"] = code
+            snapshot["out_flushed_before_exit"] = out.flushed
+            snapshot["err_flushed_before_exit"] = err.flushed
+
+        monkeypatch.setattr(_os, "_exit", fake_exit)
+
+        result = cli._console_script_main()
+
+        assert snapshot["exit_code"] == fake_rc, fake_rc
+        assert snapshot["out_flushed_before_exit"] is True, fake_rc
+        assert snapshot["err_flushed_before_exit"] is True, fake_rc
+        assert result is None, fake_rc
+
+
+def test_console_script_entry_point_routes_through_wrapper() -> None:
+    """``[project.scripts]`` must point ``java-codebase-rag`` at
+    ``_console_script_main`` (not ``main``) so the deterministic-exit path is the
+    one the installed CLI actually uses."""
+    pyproject = (Path(__file__).resolve().parent.parent / "pyproject.toml").read_text(encoding="utf-8")
+    assert 'java-codebase-rag = "java_codebase_rag.cli:_console_script_main"' in pyproject
+    assert 'java-codebase-rag = "java-codebase-rag:main"' not in pyproject
+    assert 'java-codebase-rag = "java_codebase_rag.cli:main"' not in pyproject

java_codebase_rag-0.6.1/java_codebase_rag.egg-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-java-codebase-rag = java_codebase_rag.cli:main
-java-codebase-rag-mcp = server:main