java-codebase-rag 0.11.1__tar.gz → 0.11.2__tar.gz

{java_codebase_rag-0.11.1/src/java_codebase_rag.egg-info → java_codebase_rag-0.11.2}/PKG-INFO

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

{java_codebase_rag-0.11.1 → java_codebase_rag-0.11.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "java-codebase-rag"
-version = "0.11.1"
+version = "0.11.2"
 description = "MCP server for semantic + structural search over Java codebases"
 readme = "README.md"
 requires-python = ">=3.11"

{java_codebase_rag-0.11.1 → java_codebase_rag-0.11.2}/src/java_codebase_rag/install_data/agents/explorer-rag-cli.md

@@ -95,7 +95,7 @@ The Decision Framework above tells you *which* command; reach for `--help` only
 
 **Prerequisite.** `jrag` needs an index — unindexed, every command exits 2 (`jrag status` checks; the file-system tools work without one).
 
-**Tip.** Run `jrag watch` once per session for fast, fresh queries — it keeps the index fresh on file change and serves every read command warm (no per-call model load). Optional; with no daemon running, all reads take the cold path byte-identically.
+**Tip.** Run `jrag watch` once per session for fast, fresh queries — it keeps the index fresh on file change and serves every read command warm (no per-call model/graph load; warm lexical + graph on Intel Mac). Optional; with no daemon running, all reads take the cold path byte-identically.
 
 **Resolve-first contract.** Every `<query>` command resolves the identifier first, then maps `one` / `many` / `none` onto one envelope: `one` → run; `many` → return candidates and stop, **no silent guess across distinct types** (a class sharing its simple name with its own constructor still resolves to the type — narrow with `--kind` / `--role` / `--fqn-contains` / `--service`); `none` → `status: not_found` (exit 0), fall back to `search` or `Grep`. Pass names (FQN / simple name / route path / topic) or prior `sym:`/`route:`/`client:`/`producer:` ids — never raw node ids. `--kind` is a true resolve input; `--role` / `--java-kind` / `--fqn-contains` post-filter client-side.
 

{java_codebase_rag-0.11.1 → java_codebase_rag-0.11.2}/src/java_codebase_rag/install_data/skills/explore-codebase-cli/SKILL.md

@@ -94,7 +94,7 @@ The Decision Framework above tells you *which* command; reach for `--help` only
 
 **Prerequisite.** `jrag` needs an index — unindexed, every command exits 2 (`jrag status` checks; the file-system tools work without one).
 
-**Tip.** Run `jrag watch` once per session for fast, fresh queries — it keeps the index fresh on file change and serves every read command warm (no per-call model load). Optional; with no daemon running, all reads take the cold path byte-identically.
+**Tip.** Run `jrag watch` once per session for fast, fresh queries — it keeps the index fresh on file change and serves every read command warm (no per-call model/graph load; warm lexical + graph on Intel Mac). Optional; with no daemon running, all reads take the cold path byte-identically.
 
 **Resolve-first contract.** Every `<query>` command resolves the identifier first, then maps `one` / `many` / `none` onto one envelope: `one` → run; `many` → return candidates and stop, **no silent guess across distinct types** (a class sharing its simple name with its own constructor still resolves to the type — narrow with `--kind` / `--role` / `--fqn-contains` / `--service`); `none` → `status: not_found` (exit 0), fall back to `search` or `Grep`. Pass names (FQN / simple name / route path / topic) or prior `sym:`/`route:`/`client:`/`producer:` ids — never raw node ids. `--kind` is a true resolve input; `--role` / `--java-kind` / `--fqn-contains` post-filter client-side.
 

{java_codebase_rag-0.11.1 → java_codebase_rag-0.11.2}/src/java_codebase_rag/jrag.py

@@ -1462,6 +1462,8 @@ def _cmd_watch_status(cfg) -> int:
     if alive:
         print(f"jrag watch: up (pid {pid}, socket {sock})")
         if state:
+            if state.get("mode") == "lexical":
+                print("  mode: lexical (graph-only)")
             kind = state.get("last_reindex_kind")
             at = state.get("last_reindex_at")
             count = state.get("reindex_count", 0)

{java_codebase_rag-0.11.1 → java_codebase_rag-0.11.2}/src/java_codebase_rag/watch/daemon.py

@@ -15,8 +15,12 @@ Lifecycle (``run_foreground``):
 
   1. Acquire the project lock. Held elsewhere -> stderr line + ``return 2``.
      Unsupported platform -> stderr line + ``return 2``.
-  2. EAGERLY warm the embedding model so a load failure fails fast (stderr +
-     ``on_event("error", …)`` + lock release + ``return 2``).
+  2. EAGERLY warm the embedding model — but ONLY when the vector stack is
+     installed — so a load failure fails fast (stderr + ``on_event("error", …)``
+     + lock release + ``return 2``). On graph-only installs (macOS Intel: PEP
+     508 excludes sentence_transformers/lancedb) this step is skipped and the
+     daemon serves warm lexical/graph-only search instead; the read path
+     (``mcp_v2.search_v2``) degrades to lexical on its own.
   3. Install SIGINT/SIGTERM handlers that set a stop flag.
   4. ``server.start()`` then ``watcher.start()``.
   5. Write the state file (``paths.state_path``) so ``--status``/``--stop`` from
@@ -42,6 +46,7 @@ import threading
 import time
 from typing import TYPE_CHECKING, Any
 
+from java_codebase_rag.pipeline import vector_stack_installed
 from java_codebase_rag.watch import paths
 from java_codebase_rag.watch.lock import (
     LockHeldError,
@@ -75,6 +80,10 @@ class WatchDaemon:
 
     def __init__(self, cfg: "ResolvedOperatorConfig") -> None:
         self.cfg = cfg
+        # Probed once (cheap: 3x importlib.util.find_spec). When False (graph-only
+        # install — macOS Intel), the daemon skips the embedding-model warm-up and
+        # the cocoindex vectors reindex; the read path degrades to lexical on its own.
+        self._vector_enabled = vector_stack_installed()
         self.lock = ProjectLock(cfg.index_dir)
         self.warm = WarmResources(cfg)
         self.server = WatchServer(self.warm, cfg)
@@ -94,6 +103,13 @@ class WatchDaemon:
             "started_at": None,
             "pid": None,
             "socket": str(paths.socket_path(cfg.index_dir)),
+            # Display label derived from the install-time probe above, NOT a live
+            # search-capability check — the read path's actual lexical/vector choice
+            # is mcp_v2's (``_ensure_vector_backend``). The two agree under the PEP
+            # 508 markers (the vector trio is present or absent together). Surfaced
+            # in the status panel and ``jrag watch --status``; omitted from display
+            # on the normal (vector) path to avoid noise.
+            "mode": "lexical" if not self._vector_enabled else "vector",
             "last_reindex_at": None,
             "last_reindex_kind": None,
             "reindex_count": 0,
@@ -128,16 +144,26 @@ class WatchDaemon:
             print("jrag watch: watch mode requires macOS/Linux", file=sys.stderr)
             return 2
 
-        # 2. Eagerly warm the model so a load failure fails fast (before the
-        #    server accepts a single query). The model is the only heavy,
-        #    failure-prone resource that is not lazy on the read path.
-        try:
-            self.warm.model()
-        except Exception as exc:  # noqa: BLE001 — report any load failure, then bail
-            print(f"jrag watch: failed to load embedding model: {exc}", file=sys.stderr)
-            self._record("error", {"phase": "model_load", "error": repr(exc)})
-            self.lock.release()
-            return 2
+        # 2. Eagerly warm the embedding model so a load failure fails fast (before
+        #    the server accepts a single query) — but ONLY when the vector stack is
+        #    installed. The model is the only heavy, failure-prone resource that is
+        #    not lazy on the read path. On a graph-only install (macOS Intel) there
+        #    is no vector stack to warm; the daemon serves lexical/graph-only search
+        #    and ``mcp_v2.search_v2`` degrades on its own, so we skip straight to
+        #    serving rather than failing on a missing ``sentence_transformers``.
+        if self._vector_enabled:
+            try:
+                self.warm.model()
+            except Exception as exc:  # noqa: BLE001 — report any load failure, then bail
+                print(f"jrag watch: failed to load embedding model: {exc}", file=sys.stderr)
+                self._record("error", {"phase": "model_load", "error": repr(exc)})
+                self.lock.release()
+                return 2
+        else:
+            print(
+                "jrag watch: vector stack unavailable — serving lexical (graph-only) search",
+                file=sys.stderr,
+            )
 
         # 3. Install stop-signal handlers (main thread only).
         signal.signal(signal.SIGINT, self._on_signal)
@@ -279,6 +305,8 @@ class WatchDaemon:
             state = dict(self._state)
         table = Table(title=f"jrag watch (pid {os.getpid()})", show_header=False, box=None)
         table.add_row("socket", str(state.get("socket")))
+        if state.get("mode") == "lexical":
+            table.add_row("mode", "lexical (graph-only)")
         table.add_row("reindex count", str(state.get("reindex_count", 0)))
         last_kind = state.get("last_reindex_kind")
         last_at = state.get("last_reindex_at")

{java_codebase_rag-0.11.1 → java_codebase_rag-0.11.2}/src/java_codebase_rag/watch/watcher.py

@@ -40,7 +40,11 @@ from watchdog.observers import Observer
 from watchdog.observers.polling import PollingObserver
 
 from java_codebase_rag.graph.path_filtering import LayeredIgnore
-from java_codebase_rag.pipeline import run_cocoindex_update, run_incremental_graph
+from java_codebase_rag.pipeline import (
+    run_cocoindex_update,
+    run_incremental_graph,
+    vector_stack_installed,
+)
 
 if TYPE_CHECKING:
     from java_codebase_rag.config import ResolvedOperatorConfig
@@ -126,6 +130,10 @@ class SourceWatcher:
     ) -> None:
         self.cfg = cfg
         self.warm = warm
+        # Probed once: when False (graph-only install — macOS Intel) the vectors
+        # (cocoindex) reindex step is skipped entirely, so the graph reindex still
+        # completes and fires ``indexing_done`` instead of bailing on a 127 stub.
+        self._vector_enabled = vector_stack_installed()
         self._debounce_s = max(int(debounce_ms), 1) / 1000.0
         self._backend = backend
         # watchdog's PollingObserver takes a float timeout in SECONDS (it flows
@@ -281,7 +289,7 @@ class SourceWatcher:
     # -- reindex (runs on the debounce worker thread) ------------------------
 
     def reindex(self, kinds: set[str]) -> None:
-        """Run one debounced reindex: vectors always; graph only when java changed.
+        """Run one debounced reindex: vectors always (when installed); graph only when java changed.
 
         COW lifecycle (design §4.7): the graph subprocess writes the ORIGINAL
         graph while reads are served from a sidecar copy. ``begin_graph_snapshot``
@@ -290,20 +298,30 @@ class SourceWatcher:
         graph failure the existing ``.graph_increment_in_progress`` crash marker
         drives the next full rebuild. Lance needs no snapshot (commits are atomic
         per version; fresh per-query reads are fine).
+
+        Graph-only installs (macOS Intel) have no vector stack: the cocoindex
+        step is skipped (``vres=None``) so the graph reindex completes and fires
+        ``indexing_done`` instead of bailing on a 127 cocoindex-not-found stub.
         """
         if not kinds:
             return
         kind_list = sorted(kinds)
         self._emit("indexing_started", {"kinds": kind_list})
         try:
-            # Vectors run for every indexed type (java/sql/yaml all flow through cocoindex).
-            self._emit("vectors", {"kinds": kind_list})
-            vres = run_cocoindex_update(
-                self.cfg.subprocess_env(),
-                full_reprocess=False,
-                quiet=True,
-                verbose=False,
-            )
+            # Vectors run for every indexed type (java/sql/yaml all flow through
+            # cocoindex) — but only when the vector stack is installed. On a
+            # graph-only install cocoindex is absent and the call would return a
+            # 127 stub; skipping it keeps ``indexing_done`` reachable.
+            if self._vector_enabled:
+                self._emit("vectors", {"kinds": kind_list})
+                vres = run_cocoindex_update(
+                    self.cfg.subprocess_env(),
+                    full_reprocess=False,
+                    quiet=True,
+                    verbose=False,
+                )
+            else:
+                vres = None
 
             graph_rc = 0
             if "java" in kinds:
@@ -328,7 +346,7 @@ class SourceWatcher:
                     # is never left dangling. No-ops when no snapshot is active.
                     self.warm.commit_graph_snapshot()
 
-            if vres.returncode != 0:
+            if vres is not None and vres.returncode != 0:
                 self._emit("error", {"phase": "vectors", "returncode": vres.returncode})
                 return
             if graph_rc != 0:

{java_codebase_rag-0.11.1 → java_codebase_rag-0.11.2/src/java_codebase_rag.egg-info}/PKG-INFO

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