java-codebase-rag 0.9.4__py3-none-any.whl → 0.9.6__py3-none-any.whl

server.py → java_codebase_rag/mcp/server.py

@@ -9,11 +9,17 @@ import time
 from pathlib import Path
 from typing import Literal
 
-import mcp_v2
-from index_common import SBERT_MODEL
+from java_codebase_rag.mcp import mcp_v2
+from java_codebase_rag.analysis import resolve_service
+from java_codebase_rag.search.index_common import SBERT_MODEL
 from java_codebase_rag.cli_progress import (
     accumulate_and_relay_subprocess_streams,
 )
+from java_codebase_rag.pipeline import (
+    VECTORS_SKIPPED_GRAPH_ONLY,
+    cocoindex_bin as resolve_cocoindex_bin,
+    vector_stack_installed,
+)
 from java_codebase_rag.progress import ProgressEvent
 from java_codebase_rag._fdlimit import raise_fd_limit
 from java_codebase_rag.config import (
@@ -23,13 +29,20 @@ from java_codebase_rag.config import (
     resolved_sbert_model_for_process_env,
     resolve_operator_config,
 )
-from ladybug_queries import LadybugGraph, resolve_ladybug_path
+from java_codebase_rag.graph.ladybug_queries import LadybugGraph, resolve_ladybug_path
 from mcp.server.fastmcp import FastMCP
 from pydantic import BaseModel, Field
 # NOTE: search_lancedb.TABLES is imported lazily in list_code_index_tables_payload() — it
 # pulls lancedb/torch and is unavailable on graph-only installs (macOS Intel).
 
 _COCOINDEX_TARGET = "java_index_flow_lancedb.py:JavaCodeIndexLance"
+
+# Package-internal locations of the cocoindex flow and the graph builder, both
+# executed by file path (see java_codebase_rag.pipeline). Derived from this
+# file's location so they resolve under editable and wheel installs alike.
+_PKG_DIR = Path(__file__).resolve().parent.parent
+_FLOW_FILE = _PKG_DIR / "index" / "java_index_flow_lancedb.py"
+_BUILDER_FILE = _PKG_DIR / "graph" / "build_ast_graph.py"
 _INSTRUCTIONS = (
     "Java codebase graph navigator over an indexed Java codebase. "
     "Tools: search (NL/code locate), find (structured NodeFilter), describe (one node + edge_summary: stored edge-label counts and optional composed keys for type Symbols and override-axis virtual keys for method Symbols), "
@@ -112,7 +125,7 @@ class ScopeManager:
         self._log_detection()
 
     def _detect_scope(self) -> str | None:
-        from graph_enrich import detect_microservice_from_path
+        from java_codebase_rag.graph.graph_enrich import detect_microservice_from_path
 
         candidate = detect_microservice_from_path(Path.cwd(), self.source_root)
         if candidate is None:
@@ -298,7 +311,7 @@ def _graph_meta_output() -> GraphMetaOutput:
 
 def list_code_index_tables_payload() -> IndexInfoOutput:
     try:
-        from search_lancedb import TABLES
+        from java_codebase_rag.search.search_lancedb import TABLES
 
         tables = dict(TABLES)
     except ImportError:
@@ -314,6 +327,61 @@ def list_code_index_tables_payload() -> IndexInfoOutput:
     )
 
 
+async def _run_graph_phase(
+    root: Path,
+    *,
+    quiet: bool,
+    verbose: bool,
+    on_progress: object | None,
+    on_progress_console: object | None,
+) -> tuple[int | None, str, str, bool]:
+    """Run ``build_ast_graph.py`` and return ``(code, stdout, stderr, started)``.
+
+    Shared by the vectors→graph refresh path and the graph-only path (macOS Intel,
+    where the vector stack is gated off). ``started`` is True only when the graph
+    subprocess was actually created, so callers set ``phases_run`` accurately — the
+    CLI maps an empty ``phases_run`` to a preflight exit code 2 (nothing spawned).
+    A missing builder or a spawn failure returns ``started=False`` with the graph
+    code carrying the reason (``None`` for missing builder, ``-1`` for spawn error).
+    """
+    builder = _BUILDER_FILE
+    if not builder.is_file():
+        return None, "", "", False
+    try:
+        graph_args = [
+            sys.executable,
+            str(builder),
+            "--source-root",
+            str(root),
+            "--ladybug-path",
+            resolve_ladybug_path(),
+        ]
+        if not quiet:
+            graph_args.append("--verbose")
+        gproc = await asyncio.create_subprocess_exec(
+            *graph_args,
+            cwd=str(root),
+            env=_cocoindex_subprocess_env(root),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        if quiet:
+            gout_b, gerr_b = await gproc.communicate()
+        else:
+            gout_b, gerr_b = await accumulate_and_relay_subprocess_streams(
+                gproc, relay=True, verbose=verbose,
+                on_progress=on_progress, on_progress_console=on_progress_console,
+            )
+        return (
+            gproc.returncode,
+            gout_b.decode(errors="replace"),
+            gerr_b.decode(errors="replace"),
+            True,
+        )
+    except Exception as exc:
+        return -1, "", f"graph builder spawn failed: {exc}", False
+
+
 async def run_refresh_pipeline(
     *,
     quiet: bool = False,
@@ -322,7 +390,51 @@ async def run_refresh_pipeline(
     on_progress_console: object | None = None,
 ) -> RefreshIndexOutput:
     root = _project_root()
-    cocoindex_bin = Path(sys.executable).parent / "cocoindex"
+    if not vector_stack_installed():
+        # Graph-only install (macOS Intel): the vector stack (cocoindex/lancedb/
+        # sentence-transformers) is gated off by PEP 508 markers and uninstallable,
+        # so the cocoindex binary is absent. Skip the vectors phase and build the
+        # graph only — mirroring init/increment, which treat cocoindex-absent as a
+        # skip, not a failure (the graph layer is the supported surface there). No
+        # vectors progress event is emitted, so the renderer's vectors task stays
+        # invisible (its "never spawned" invariant) instead of hanging at running.
+        print(VECTORS_SKIPPED_GRAPH_ONLY, file=sys.stderr, flush=True)
+        if not quiet:
+            print(file=sys.stderr, flush=True)
+        graph_code, graph_out, graph_err, started = await _run_graph_phase(
+            root, quiet=quiet, verbose=verbose,
+            on_progress=on_progress, on_progress_console=on_progress_console,
+        )
+        ok = graph_code == 0
+        if not ok:
+            message = (
+                f"graph builder exit {graph_code}"
+                if graph_code is not None
+                else (graph_err.strip() or "graph builder unavailable")
+            )
+        else:
+            message = "reprocess completed (graph-only; vectors skipped — vector stack not installed)"
+        return RefreshIndexOutput(
+            success=ok,
+            exit_code=None,
+            stdout="",
+            stderr="",
+            message=message,
+            graph_exit_code=graph_code,
+            graph_stdout=graph_out[-4000:] if len(graph_out) > 4000 else graph_out,
+            graph_stderr=graph_err[-4000:] if len(graph_err) > 4000 else graph_err,
+            phases_run=["graph"] if started else [],
+            optimize_error=None,
+        )
+    # Resolve cocoindex the same way the sync path does (pipeline.cocoindex_bin):
+    # next to the interpreter first, then via PATH (``shutil.which``). A console
+    # script legitimately lives away from the venv python — e.g. ``pip install
+    # --user`` places it in ``~/.local/bin``. Honoring PATH keeps ``reprocess``
+    # (no flags) consistent with init/increment/``reprocess --vectors-only``,
+    # which all resolve through cocoindex_bin(); previously this path checked
+    # only next-to-python and failed with "cocoindex not found next to Python"
+    # even though cocoindex was reachable on PATH.
+    cocoindex_bin = resolve_cocoindex_bin()
     if not cocoindex_bin.is_file():
         # 127 pre-spawn: emit a terminal failed vectors event so the renderer's
         # task doesn't hang at running (matches the sync pipeline path).
@@ -330,23 +442,21 @@ async def run_refresh_pipeline(
             on_progress(ProgressEvent(kind="vectors", phase=None, pass_=None, done=None, total=None, status="failed", elapsed_s=None))
         return RefreshIndexOutput(
             success=False,
-            message=f"cocoindex not found next to Python: {cocoindex_bin}",
+            message=(
+                f"cocoindex not found next to Python ({cocoindex_bin}) or on PATH; "
+                "install cocoindex[lancedb] into the same venv or add its bin/ to PATH."
+            ),
             phases_run=[],
         )
-    flow_path = root / "java_index_flow_lancedb.py"
-    bundle_dir = Path(__file__).resolve().parent
+    flow_path = _FLOW_FILE
     if not flow_path.is_file():
-        fallback = bundle_dir / "java_index_flow_lancedb.py"
-        if fallback.is_file():
-            flow_path = fallback
-        else:
-            if on_progress is not None:
-                on_progress(ProgressEvent(kind="vectors", phase=None, pass_=None, done=None, total=None, status="failed", elapsed_s=None))
-            return RefreshIndexOutput(
-                success=False,
-                message=f"java_index_flow_lancedb.py not found under {root} nor {bundle_dir}",
-                phases_run=[],
-            )
+        if on_progress is not None:
+            on_progress(ProgressEvent(kind="vectors", phase=None, pass_=None, done=None, total=None, status="failed", elapsed_s=None))
+        return RefreshIndexOutput(
+            success=False,
+            message=f"java_index_flow_lancedb.py not found at {flow_path}",
+            phases_run=[],
+        )
     proc: asyncio.subprocess.Process | None = None
     out_b, err_b = b"", b""
     # DROP the Lance target tables so the update takes the fast INSERT path
@@ -466,40 +576,12 @@ async def run_refresh_pipeline(
         except Exception as exc:
             optimize_error = f"lance optimize failed: {exc}"
             print(f"java-codebase-rag: {optimize_error}", file=sys.stderr)
-        builder = Path(__file__).resolve().parent / "build_ast_graph.py"
-        if builder.is_file():
-            try:
-                graph_args = [
-                    sys.executable,
-                    str(builder),
-                    "--source-root",
-                    str(root),
-                    "--ladybug-path",
-                    resolve_ladybug_path(),
-                ]
-                if not quiet:
-                    graph_args.append("--verbose")
-                gproc = await asyncio.create_subprocess_exec(
-                    *graph_args,
-                    cwd=str(root),
-                    env=_cocoindex_subprocess_env(root),
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                )
-                phases_run = ["vectors", "graph"]
-                if quiet:
-                    gout_b, gerr_b = await gproc.communicate()
-                else:
-                    gout_b, gerr_b = await accumulate_and_relay_subprocess_streams(
-                        gproc, relay=True, verbose=verbose,
-                        on_progress=on_progress, on_progress_console=on_progress_console,
-                    )
-                graph_code = gproc.returncode
-                graph_out = gout_b.decode(errors="replace")
-                graph_err = gerr_b.decode(errors="replace")
-            except Exception as exc:
-                graph_code = -1
-                graph_err = f"graph builder spawn failed: {exc}"
+        graph_code, graph_out, graph_err, graph_started = await _run_graph_phase(
+            root, quiet=quiet, verbose=verbose,
+            on_progress=on_progress, on_progress_console=on_progress_console,
+        )
+        if graph_started:
+            phases_run = ["vectors", "graph"]
     message: str | None = None
     if not ok:
         message = f"cocoindex exit {proc.returncode}"
@@ -788,6 +870,8 @@ def main() -> None:
     cfg = resolve_operator_config(source_root=_source_root_for_operator_config())
     cfg.apply_to_os_environ()
     mcp_v2.set_hints_enabled(cfg.hints_enabled)
+    mcp_v2.set_absence_config(cfg)
+    resolve_service.set_absence_config(cfg)
 
     # Initialize scope manager for automatic microservice detection
     global _scope_manager

java_codebase_rag/pipeline.py

@@ -18,9 +18,28 @@ from java_codebase_rag.progress import ProgressEvent, ProgressRelay, make_relay
 
 COCOINDEX_TARGET = "java_index_flow_lancedb.py:JavaCodeIndexLance"
 
-
-def bundle_dir() -> Path:
-    return Path(__file__).resolve().parent.parent
+# Operator-facing line printed when an indexing command skips the vectors phase
+# because the vector stack is absent (graph-only install, e.g. macOS Intel where
+# cocoindex[lancedb]/lancedb/sentence-transformers are gated off by PEP 508 markers).
+# Single source of truth — imported by cli.py (init/increment) and server.py
+# (reprocess) so the wording can't drift between the two paths.
+VECTORS_SKIPPED_GRAPH_ONLY = (
+    "java-codebase-rag: vectors skipped — vector stack not installed on this platform "
+    "(graph-only mode). The graph is built/refreshed; semantic search is unavailable."
+)
+
+
+# Package-internal locations of the cocoindex flow definition and the graph
+# builder. Both are executed *by file path* — cocoindex loads the flow via a
+# ``file:Class`` target (COCOINDEX_TARGET below) and the builder runs as
+# ``python <path>`` — so we must resolve their paths without importing them
+# (this module deliberately stays free of heavy ML imports at import time).
+# Derived from this file's location so they resolve under both editable and
+# wheel installs.
+_PKG_DIR = Path(__file__).resolve().parent
+_FLOW_DIR = _PKG_DIR / "index"
+_FLOW_FILE = _FLOW_DIR / "java_index_flow_lancedb.py"
+_BUILDER_FILE = _PKG_DIR / "graph" / "build_ast_graph.py"
 
 
 def cocoindex_bin() -> Path:
@@ -256,7 +275,7 @@ def _run_cocoindex_update_impl(
             stdout="",
             stderr=f"cocoindex not found: {exe}",
         )
-    bd = bundle_dir()
+    bd = _FLOW_DIR
     flow = bd / "java_index_flow_lancedb.py"
     if not flow.is_file():
         if on_progress is not None:
@@ -333,7 +352,7 @@ def run_cocoindex_drop(env: dict[str, str], *, quiet: bool) -> subprocess.Comple
             stdout="",
             stderr=f"cocoindex not found: {exe}",
         )
-    bd = bundle_dir()
+    bd = _FLOW_DIR
     cmd = [str(exe), "drop", COCOINDEX_TARGET, "-f"]
     if quiet:
         cmd.append("-q")
@@ -356,7 +375,7 @@ def run_build_ast_graph(
     on_progress: Callable[[ProgressEvent], None] | None = None,
     on_progress_console: object | None = None,
 ) -> subprocess.CompletedProcess[str]:
-    builder = bundle_dir() / "build_ast_graph.py"
+    builder = _BUILDER_FILE
     if not builder.is_file():
         return subprocess.CompletedProcess(
             args=[],
@@ -414,7 +433,7 @@ def run_incremental_graph(
     on_progress_console: object | None = None,
 ) -> subprocess.CompletedProcess[str]:
     """Run incremental graph rebuild by passing --incremental flag to build_ast_graph.py."""
-    builder = bundle_dir() / "build_ast_graph.py"
+    builder = _BUILDER_FILE
     if not builder.is_file():
         return subprocess.CompletedProcess(
             args=[],