java-codebase-rag 0.11.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

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/watch/lock.py

@@ -2,7 +2,7 @@
 
 ``ProjectLock`` is the single-writer primitive the watch daemon (Task 11)
 acquires so that at most one watcher — and no concurrent manual
-``java-codebase-rag increment`` — runs per project.
+``jrag increment`` — runs per project.
 
 The lock is keyed on the project's index dir: the pidfile path comes from
 ``paths.pid_path(index_dir)`` (Task 3). We hold an advisory exclusive flock on

java_codebase_rag/watch/watcher.py

@@ -3,10 +3,11 @@
 ``SourceWatcher`` observes the project source tree and, after a debounce window,
 re-runs the minimal reindex for the changed file types:
 
-  * a ``.java`` change -> vectors THEN graph. The graph reindex runs as a
-    subprocess under a copy-on-write snapshot (design §4.7) so concurrent graph
-    reads keep being served from a sidecar copy while the single-writer
-    subprocess overwrites the original. ``ladybug`` has no transactions and is
+  * a source-language change (``.java``; ``.kt`` when the kotlin grammar is
+    importable) -> vectors THEN graph. The graph reindex runs as a subprocess
+    under a copy-on-write snapshot (design §4.7) so concurrent graph reads keep
+    being served from a sidecar copy while the single-writer subprocess
+    overwrites the original. ``ladybug`` has no transactions and is
     single-writer, which is why graph builds are subprocesses and reads are
     served from a copy.
   * a matching ``.sql`` / ``.yml`` / ``.yaml`` resource change -> vectors only
@@ -20,7 +21,8 @@ the watchdog observer thread is never blocked.
 The cocoindex flow indexes three sets (``**/*.java``,
 ``**/src/main/resources/db/migration/*.sql``,
 ``**/src/main/resources/application*.yml``/``.yaml``). There is NO shared
-iterator (``iter_java_source_files`` yields ``.java`` only), so the watcher
+iterator (``iter_source_files`` yields the registered source suffixes —
+``.java`` and ``.kt`` when the Kotlin grammar is installed), so the watcher
 defines this UNION and classifies each event path into a reindex kind.
 
 All status is reported via ``on_event(kind, detail)`` callbacks (kinds:
@@ -39,8 +41,13 @@ from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
 from watchdog.observers.polling import PollingObserver
 
+from java_codebase_rag.ast.language import LANG_BACKENDS, backend_for
 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
@@ -48,9 +55,19 @@ if TYPE_CHECKING:
 
 log = logging.getLogger(__name__)
 
-# Suffixes the watcher treats as java sources. The non-java resource types are
-# matched by the glob helpers below (the cocoindex set has no shared iterator).
-INDEXED_SUFFIXES: tuple[str, ...] = (".java",)
+# Suffixes the watcher treats as source files — derived from the language
+# backend registry so this never drifts from what the graph builder parses.
+# ``(".java", ".kt")`` when the kotlin grammar is importable; just
+# ``(".java",)`` on a grammar-absent (e.g. graph-only) install. The non-source
+# resource types (sql/yaml) are matched by the glob helpers below (the cocoindex
+# set has no shared iterator).
+INDEXED_SUFFIXES: tuple[str, ...] = tuple(
+    suffix for backend in LANG_BACKENDS.values() for suffix in backend.suffixes
+)
+# Reindex kinds that trigger a graph rebuild. The graph indexes every registered
+# source language (java today, kotlin too when its grammar imports), so this is
+# the set of backend ``language_id``s. sql/yaml are vectors-only (no graph row).
+_GRAPH_INDEXED_KINDS: frozenset[str] = frozenset(LANG_BACKENDS.keys())
 _YAML_SUFFIXES: tuple[str, ...] = (".yml", ".yaml")
 
 # Project-relative anchored prefixes for the two non-java resource globs:
@@ -126,6 +143,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
@@ -199,13 +220,15 @@ class SourceWatcher:
 
     # -- event classification (observer thread) ------------------------------
     #
-    # The watcher fires on exactly the cocoindex-indexed set (``.java`` plus the
-    # SQL/YAML resource patterns below) filtered through ``LayeredIgnore``.
-    # ``target/generated-sources/**/*.java`` therefore correctly fires: generated
-    # sources are first-class, cocoindex does NOT exclude ``target/``, so the
-    # watcher must fire to keep them fresh. ``LayeredIgnore.is_ignored`` does NOT
-    # prune build-output dirs (``target/``/``build``/``out``) -- that pruning lives
-    # in ``iter_java_source_files``'s ``os.walk`` (``_is_build_output_dir``), used
+    # The watcher fires on exactly the indexed set: the source languages claimed
+    # by ``LANG_BACKENDS`` (``.java``; ``.kt`` when the kotlin grammar imports)
+    # plus the SQL/YAML resource patterns below, filtered through
+    # ``LayeredIgnore``. ``target/generated-sources/**/*.java`` therefore
+    # correctly fires: generated sources are first-class, cocoindex does NOT
+    # exclude ``target/``, so the watcher must fire to keep them fresh.
+    # ``LayeredIgnore.is_ignored`` does NOT prune build-output dirs
+    # (``target/``/``build``/``out``) -- that pruning lives in
+    # ``iter_source_files``'s ``os.walk`` (``_is_build_output_dir``), used
     # by the graph builder, not by cocoindex. (Compiled ``.class`` output under
     # ``target/`` doesn't match the ``.java`` suffix anyway.)
 
@@ -230,9 +253,16 @@ class SourceWatcher:
             rel = path.resolve().relative_to(self._source_root_resolved).as_posix()
         except ValueError:
             return set()
+        # Source languages (.java, .kt when registered) dispatch via the backend
+        # registry: a change yields its backend's ``language_id`` reindex kind,
+        # which triggers the graph rebuild (the subprocess graph builder re-walks
+        # the tree and parses each file through ``backend_for`` — so a ``.kt``
+        # change reprocesses via KotlinBackend). Unknown suffixes are not source
+        # files and fall through to the resource-glob checks below.
+        backend = backend_for(path)
+        if backend is not None:
+            return {backend.language_id}
         suffix = path.suffix.lower()
-        if suffix == ".java":
-            return {"java"}
         if suffix == ".sql":
             return {"sql"} if _is_migration_sql(rel) else set()
         if suffix in _YAML_SUFFIXES:
@@ -281,7 +311,8 @@ 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 a
+        registered source language (java/kotlin) 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,25 +321,36 @@ 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:
-                # Graph indexes java only; reindex under a COW snapshot so graph
-                # reads continue (from the sidecar) during the subprocess write.
+            if kinds & _GRAPH_INDEXED_KINDS:
+                # The graph indexes every registered source language (java,
+                # kotlin when its grammar imports); reindex under a COW snapshot
+                # so graph reads continue (from the sidecar) during the write.
                 self._emit("graph", {"kinds": kind_list})
                 try:
                     # begin/commit paired in this try/finally. begin_graph_snapshot
@@ -328,7 +370,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.dist-info → java_codebase_rag-0.12.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.11.1
-Summary: MCP server for semantic + structural search over Java codebases
+Version: 0.12.0
+Summary: jrag (formerly java-codebase-rag) — MCP server + jrag CLI for semantic + structural search over Java/Kotlin codebases
 Author: HumanBean17
 License-Expression: MIT
-Project-URL: Homepage, https://github.com/HumanBean17/java-codebase-rag
-Project-URL: Repository, https://github.com/HumanBean17/java-codebase-rag
-Project-URL: Issues, https://github.com/HumanBean17/java-codebase-rag/issues
-Keywords: mcp,java,rag,code-search,graph,lancedb,ladybug
+Project-URL: Homepage, https://github.com/HumanBean17/jrag
+Project-URL: Repository, https://github.com/HumanBean17/jrag
+Project-URL: Issues, https://github.com/HumanBean17/jrag/issues
+Keywords: jrag,java,mcp,rag,code-search,graph,lancedb,ladybug
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -35,6 +35,7 @@ Requires-Dist: rich<16,>=14
 Requires-Dist: sentence-transformers<6,>=5.4.0; sys_platform != "darwin" or platform_machine != "x86_64"
 Requires-Dist: tree-sitter<0.26,>=0.25.2
 Requires-Dist: tree-sitter-java<0.24,>=0.23.5
+Requires-Dist: tree-sitter-kotlin<2,>=1.1.0
 Requires-Dist: unidiff<1,>=0.7.3
 Requires-Dist: watchdog<7,>=6
 Provides-Extra: dev
@@ -44,7 +45,7 @@ Requires-Dist: pytest-xdist>=3; extra == "dev"
 Requires-Dist: ruff>=0.4; extra == "dev"
 Dynamic: license-file
 
-# java-codebase-rag
+# jrag
 
 A graph-native code intelligence layer for Java microservice estates, surfaced through the **`jrag` CLI** — one command per engineering intent. A **legacy MCP server** (`search` / `find` / `describe` / `neighbors` / `resolve`) is also available for existing setups. Both are thin surfaces over the same **AST Graph**: a deterministic property graph extracted from Java source with tree-sitter, stored **locally** in **LadybugDB** (graph) alongside a **LanceDB** vector index (chunks). There is no server to host and no cloud round-trip — the index lives on your disk and your source never leaves the machine. Both surfaces collapse onto three primitive operations: **locate**, **inspect**, **walk**.
 
@@ -82,15 +83,17 @@ The rest of this README is the install, the tool/command orientation, and the re
 ## Install
 
 ```bash
-pip install java-codebase-rag
+pip install jrag-cli
 ```
 
-Python **3.11+** required, on **Linux, macOS, and Windows**. On Linux, Windows, and **Apple Silicon** Macs every native dependency (LanceDB, LadybugDB, CocoIndex) ships a wheel and you get the full semantic + graph search. **Intel Macs (x86_64) install graph-only**: PyTorch ≥2.3 and LanceDB ≥0.26 dropped macOS Intel wheels, so the vector stack is auto-excluded via PEP 508 markers — `pip install java-codebase-rag` works out of the box, the graph layer (`find` / `describe` / `neighbors` / `resolve`) is fully usable, and the `search` tool falls back to **lexical search** over the symbol graph — BM25-ranked over a LadybugDB full-text index (same tool contract, keyword-ranked instead of semantic; an advisory notes the mode). Semantic/vector search needs Apple Silicon, Linux, or Windows. After install, `java-codebase-rag --help` should print the CLI groups.
+Python **3.11+** required, on **Linux, macOS, and Windows**. On Linux, Windows, and **Apple Silicon** Macs every native dependency (LanceDB, LadybugDB, CocoIndex) ships a wheel and you get the full semantic + graph search. **Intel Macs (x86_64) install graph-only**: PyTorch ≥2.3 and LanceDB ≥0.26 dropped macOS Intel wheels, so the vector stack is auto-excluded via PEP 508 markers — `pip install jrag-cli` works out of the box, the graph layer (`find` / `describe` / `neighbors` / `resolve`) is fully usable, and the `search` tool falls back to **lexical search** over the symbol graph — BM25-ranked over a LadybugDB full-text index (same tool contract, keyword-ranked instead of semantic; an advisory notes the mode). Semantic/vector search needs Apple Silicon, Linux, or Windows. After install, `jrag --help` should print the CLI groups.
 The package includes the CocoIndex lifecycle dependency used by `init`, `increment`, `reprocess`, and `erase` on platforms that have it (it is absent on Intel Mac).
 
+**Kotlin (`.kt`) is indexed alongside Java (`.java`)** — both feed one merged AST graph (a Kotlin class can implement a Java interface and vice versa). Kotlin parsing requires the `tree-sitter-kotlin` grammar; if it fails to import, `.kt` files are skipped and Java-only indexing proceeds. **Intel Mac note:** `tree-sitter-kotlin` currently ships a macOS x86_64 wheel, so Kotlin indexing works there today; if a future release drops that wheel, Kotlin indexing degrades off on Intel Mac while the Java graph keeps working. See `docs/CODEBASE_REQUIREMENTS.md` A.1 for the v1 Kotlin limitations (extension-function calls unresolved; non-Spring frameworks out of scope; generated-code classification Java-only).
+
 ### Interactive setup (recommended)
 
-Run `java-codebase-rag install` from your Java project root to launch an interactive setup wizard that:
+Run `jrag install` from your Java project root to launch an interactive setup wizard that:
 
 1. Detects Java source directories (Maven/Gradle modules)
 2. Configures the embedding model (auto-downloads ~90MB or uses a local path)
@@ -101,19 +104,19 @@ Run `java-codebase-rag install` from your Java project root to launch an interac
 
 ```bash
 # Interactive mode
-java-codebase-rag install
+jrag install
 
 # Non-interactive mode (for CI/automation)
-java-codebase-rag install --non-interactive --agent claude-code
+jrag install --non-interactive --agent claude-code
 ```
 
-After `pip install --upgrade java-codebase-rag`, run `java-codebase-rag update` to refresh shipped artifacts and catch up the index (Lance + graph).
+After `pip install --upgrade jrag-cli`, run `jrag update` to refresh shipped artifacts and catch up the index (Lance + graph).
 
 All indexing lifecycle commands (`init`, `increment`, `reprocess`, `install`, `update`) show a unified `Vectors → Optimize → Graph` progress bar on stderr during the index build (powered by `rich`); pass `--quiet` to suppress it.
 
 ### Manual registration
 
-If you prefer manual configuration, see [`docs/JAVA-CODEBASE-RAG-CLI.md`](./docs/JAVA-CODEBASE-RAG-CLI.md) for the full CLI reference.
+If you prefer manual configuration, see [`docs/JRAG-CLI.md`](./docs/JRAG-CLI.md) for the full CLI reference.
 
 > **Stability disclaimer.** This package does **not** promise backward compatibility. MCP tool contracts, env vars, Lance/LadybugDB schemas, config files, and Python APIs may change without a deprecation period. Track `main` and rebuild indexes when ontology or embedding settings change.
 
@@ -121,7 +124,7 @@ If you prefer manual configuration, see [`docs/JAVA-CODEBASE-RAG-CLI.md`](./docs
 
 ## Tools & commands at a glance
 
-`jrag` is the default and recommended surface (`java-codebase-rag install --surface cli`). The **MCP server** (`--surface mcp`) is kept as a **legacy** option for existing setups. Both surfaces walk the same LanceDB vectors + LadybugDB **AST Graph**. Switch an existing install later with `java-codebase-rag update --surface mcp|cli`.
+`jrag` is the default and recommended surface (`jrag install --surface cli`). The **MCP server** (`--surface mcp`) is kept as a **legacy** option for existing setups. Both surfaces walk the same LanceDB vectors + LadybugDB **AST Graph**. Switch an existing install later with `jrag update --surface mcp|cli`.
 
 **CLI surface — `jrag`, one command per engineering intent**
 
@@ -213,7 +216,7 @@ The operator-facing surface is small: pick an index dir, pick an embedding model
 
 ## CLI cheat sheet
 
-Run `java-codebase-rag --help` to list grouped subcommands. Operator playbook with workflows, exit codes, and env alignment lives in [`docs/JAVA-CODEBASE-RAG-CLI.md`](./docs/JAVA-CODEBASE-RAG-CLI.md).
+Run `jrag --help` to list grouped subcommands. Operator playbook with workflows, exit codes, and env alignment lives in [`docs/JRAG-CLI.md`](./docs/JRAG-CLI.md).
 
 | Group | Subcommand | What it does |
 |---|---|---|
@@ -230,8 +233,8 @@ Run `java-codebase-rag --help` to list grouped subcommands. Operator playbook wi
 
 ## jrag — agent CLI
 
-`jrag` is a separate console script (alongside `java-codebase-rag`) built for AI
-coding agents. It gives the agent **one command per engineering intent** and
+`jrag` is the unified console script (operator + agent verbs) built for AI
+coding agents and operators alike. It gives the agent **one command per engineering intent** and
 takes human-readable identifiers (FQN / simple name / route path / topic) —
 never raw node IDs. Every `<query>` command resolves the identifier via
 `resolve_v2` as the first step; on `many` it returns candidates and stops, on
@@ -285,7 +288,7 @@ A missing or stale index produces an actionable `status: error` envelope (exit
 2) rather than a traceback:
 
 ```
-error: No index at /path/to/code_graph.lbug. Run: java-codebase-rag init --source-root <root>
+error: No index at /path/to/code_graph.lbug. Run: jrag init --source-root <root>
 ```
 
 See [`plans/active/PLAN-JRAG-CLI.md`](./plans/active/PLAN-JRAG-CLI.md) for the
@@ -300,7 +303,7 @@ full design and per-PR breakdown.
 | [`docs/paper/paper.pdf`](./docs/paper/paper.pdf) | Architecture report — design rationale, GPS metaphor, three-layer architecture, design principles, future work. |
 | [`docs/AGENT-GUIDE.md`](./docs/AGENT-GUIDE.md) | Agent-facing guide. Copy-paste into `QWEN.md` / `CLAUDE.md` / `AGENTS.md`. |
 | [`docs/CONFIGURATION.md`](./docs/CONFIGURATION.md) | Environment variables, project YAML, graph ontology, brownfield overrides, ignore patterns. |
-| [`docs/JAVA-CODEBASE-RAG-CLI.md`](./docs/JAVA-CODEBASE-RAG-CLI.md) | CLI operator playbook: workflows, exit codes, env alignment. |
+| [`docs/JRAG-CLI.md`](./docs/JRAG-CLI.md) | CLI operator playbook: workflows, exit codes, env alignment. |
 | [`docs/EDGE-NAVIGATION.md`](./docs/EDGE-NAVIGATION.md) | MCP-traversable edges, directions, dot-key composition. |
 | [`skills/`](./skills/) | `/explore-codebase-cli` (CLI surface) + `/explore-codebase` (legacy MCP surface) skills — operating manuals for hosts with skill discovery (alternative to copy-pasting AGENT-GUIDE). See [`skills/README.md`](./skills/README.md). |
 | [`docs/MANUAL-VERIFICATION-CHECKLIST.md`](./docs/MANUAL-VERIFICATION-CHECKLIST.md) | 7-phase agent-driven verification after indexing your project. |
@@ -312,8 +315,8 @@ full design and per-PR breakdown.
 ## Install from source (contributors)
 
 ```bash
-git clone https://github.com/HumanBean17/java-codebase-rag
-cd java-codebase-rag
+git clone https://github.com/HumanBean17/jrag
+cd jrag
 python3 -m venv .venv
 .venv/bin/pip install -e ".[dev]"
 ```
@@ -329,3 +332,9 @@ The default embedding model is `sentence-transformers/all-MiniLM-L6-v2` (downloa
 - `get_service_topology` — microservice-level summary aggregating `HTTP_CALLS` / `ASYNC_CALLS`.
 - Agentic routing layer (query classifier → vector / graph / both).
 - Optional `codegraph_nodes` LanceDB table embedding symbol summaries so the graph itself is vector-searchable.
+
+---
+
+## Built on
+
+The indexing pipeline runs on [**CocoIndex**](https://github.com/cocoindex-io/cocoindex) — an open-source data indexing framework that powers the vector store lifecycle (`init`, `increment`, `reprocess`, `erase`) behind every `jrag` index.

{java_codebase_rag-0.11.1.dist-info → java_codebase_rag-0.12.0.dist-info}/RECORD

@@ -1,19 +1,21 @@
 java_codebase_rag/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+java_codebase_rag/_deprecation.py,sha256=qOxHM4AYUUBQPIgTMXODPmnxjrpMoYweMzjOoqBkQKc,4196
 java_codebase_rag/_fdlimit.py,sha256=vkwjsPbZfxzZ2DZTPWO5DxtuNlLzOADzIq07iYX7GCU,2465
 java_codebase_rag/_stdio.py,sha256=TDNbpt2EP0_Zd622ihdlKwlMfxkKHWOfgLVcU6TcNbo,1458
-java_codebase_rag/_version.py,sha256=Dnoh_a-c13fqPQ-HV9CsSPbFUkihUJl_z5CACW4qDyA,1365
-java_codebase_rag/cli.py,sha256=Sf5HWQ607cg8LoZ-xlNpKKK-RslOjj5DDDsZDpHnUj8,47721
+java_codebase_rag/_version.py,sha256=-6MchHEyRglldb52uN12r226NUEVAmks9PTK8U1t_Yc,1347
+java_codebase_rag/cli.py,sha256=nLBnGbbZhNNB6aO85LpnKdLJ9pBrWjaPhQcY1-kEb_I,47500
+java_codebase_rag/cli_dispatch.py,sha256=hYBVV5KAiftcdF9Kh3E_tIYBaeFfWAnr0ATQvxH01Ok,9690
 java_codebase_rag/cli_format.py,sha256=CT7-xdwZ0bMCdP68_UOwkvm-mnLluU3LutlM-mDNk60,1839
 java_codebase_rag/cli_progress.py,sha256=q6Wh97yzLGs1B8UFk_WAKivfQu7Y5RnUUE-T2YHWkIs,3237
-java_codebase_rag/config.py,sha256=4rlRQUj0gFM-StUvhMD61uB2hZd2zqVHeNNBRXJMfN4,33283
-java_codebase_rag/installer.py,sha256=c-_tR1Ct_O3yhmruFRnDoM1Wilz-igD9qdkDPsNqLMI,79934
-java_codebase_rag/jrag.py,sha256=0_Cne1LUGo6MmmiZEaOGSKGPXmHx5P-jC3gLBcrXTJA,197527
+java_codebase_rag/config.py,sha256=Snlj6z8pJD6OYZL8pz6bATunulyhJLpVymUORY2QUjA,33179
+java_codebase_rag/installer.py,sha256=efxkNxbcoxKFzqTe9-IeVlRlMxlcsYZY9Kve_HPxJO4,79734
+java_codebase_rag/jrag.py,sha256=t_QXmh-jmw1P7T7XaIydARNnxd12mpL6_5xSv0uWaSI,198220
 java_codebase_rag/jrag_envelope.py,sha256=I5q7E3DmuJBnDl1iv7bW2NucPJ2YxlmNEtM2dau18Vw,48730
 java_codebase_rag/jrag_hints.py,sha256=aazBRI3pOeyq2IjQuoMzDkA-1cB_tTGbVcguX3BzOiQ,9286
 java_codebase_rag/jrag_render.py,sha256=xYK-0YmUMwEb4w4o6rjkrn-maHhY2oEqKgLqKQqaliE,42829
-java_codebase_rag/lance_optimize.py,sha256=zLAJzWaLc4CONyure5_Bw5WhEgXF5tlQgYMJmFN3zrg,11970
-java_codebase_rag/pipeline.py,sha256=e8IzuAsSglqWyfRXqAqq0u23oH9l_kWsZbk5j929KQA,21419
-java_codebase_rag/progress.py,sha256=2IxdMALDM0wAQCyJrrfZ975zM_85C-4BfHxf4AtYifE,23212
+java_codebase_rag/lance_optimize.py,sha256=0yaCEgLc6MiBJpG2N1cNXQIEtKvBz2fSHQjDDRf9B-4,11879
+java_codebase_rag/pipeline.py,sha256=fwTAuIsMBGUGBWnp2xi9brlY8zTzJ1Szh6bztQ4jKg8,21367
+java_codebase_rag/progress.py,sha256=73uuL-wZYcdkkKCgRwdzVturT5FH1Ek2-PdxYHKg7ZI,23199
 java_codebase_rag/read_payloads.py,sha256=CCNdFYp_JDRQGnQh3mm9POUq4jG_FL2YsVARITsgsaU,31711
 java_codebase_rag/absence/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 java_codebase_rag/absence/absence_diagnosis.py,sha256=RJNlycQY28fL5h1e7Kupaff-xabLzfzbbXLM-VSReBc,27631
@@ -23,49 +25,51 @@ java_codebase_rag/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 java_codebase_rag/analysis/pr_analysis.py,sha256=A-nE5sftlcg02esQ-ZQxZvvepEUy07zbVUG-b-bgJlo,19711
 java_codebase_rag/analysis/resolve_service.py,sha256=vVnCRXDQlFhQfIZljh4Jk5lL63IXC7lEArRWk0Hcs34,28715
 java_codebase_rag/ast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-java_codebase_rag/ast/ast_java.py,sha256=ikMDBZGMYe0E2Doe6nf-Zw3k4MnwoNYvLqg3xsnfxmI,99614
+java_codebase_rag/ast/ast_java.py,sha256=UZtCtbt9DcC9QpDu4kThxWgALKyveyiBrbmxZCbWjlE,100738
+java_codebase_rag/ast/ast_kotlin.py,sha256=qDyqvdE5ORO9nJ2gXe_13ZJFI88IHpkoe52OK6R3vdA,70564
 java_codebase_rag/ast/brownfield_events.py,sha256=yxXkKDgMb3VPtaiakGzncHM_EGnda8xIue6w90yYp8s,2055
-java_codebase_rag/ast/chunk_heuristics.py,sha256=aQk2NOKxzUdqoUAJUO3G3LE0MN_bYZWNLQ0tkmj5uts,1813
+java_codebase_rag/ast/chunk_heuristics.py,sha256=sn0SvGPkXChM_Dxn7bIRZOWPfCAUviPntRa8t-U894s,2992
+java_codebase_rag/ast/language.py,sha256=6WssjRjYsqXX_64QVca65g_qMqVr5OPjUtHDjKmMy1Y,4259
 java_codebase_rag/eval/__init__.py,sha256=V49SsVzkfHmVhRGMl9KbzMlxDSI8aHZA1YmxzgzNtYo,30
 java_codebase_rag/eval/ground_truth.py,sha256=q0gzsCF6hqR-NcMRNDDMUlvOA13RCcGcVLWWqlA4syY,3246
 java_codebase_rag/eval/metrics.py,sha256=nEDbN3VjYLUwyAvNcd8w4Kmjm0PlgX_Mt6cfOmH7f9k,3118
-java_codebase_rag/eval/runner.py,sha256=k_A5TLi16qeqT8WQ2lGqtioDXBlSzjsj0mLv-7Tml1o,20193
+java_codebase_rag/eval/runner.py,sha256=6RzoWcYcf2ZHmytzq8wXEUqogkx580kqFW7BNmWSjWk,20154
 java_codebase_rag/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-java_codebase_rag/graph/build_ast_graph.py,sha256=-MitMiz23HjiRHTt9MDA39Q9gLTCE07QoFxGa2Xl4uI,181704
-java_codebase_rag/graph/graph_enrich.py,sha256=51Q8aE0Mw09SVYBESd3H57IftsOpfkwgJV2ibt0RzwE,72598
+java_codebase_rag/graph/build_ast_graph.py,sha256=U1JRR9PMmM9-oLttmYBsDrNVuA6KY58tDsl_TZhu0Bc,189081
+java_codebase_rag/graph/graph_enrich.py,sha256=GxptfAhc3Gd7liXtrn7m3rYQNMD57HFflRMPRrvDsQE,72725
 java_codebase_rag/graph/graph_types.py,sha256=VKTnJZL1_J4bsLGdXIKCsD0FkW6uvqoG8oJfvChm_SI,9057
 java_codebase_rag/graph/java_ontology.py,sha256=Fa6iCsrBLPc2lCl-6VR2qHN4Q9Ix8Gps3thQhIEGjrM,17241
-java_codebase_rag/graph/ladybug_queries.py,sha256=3P5DVMacylxC9OQp_--v0EHMmaKN4LZx7DesxptizIg,103063
-java_codebase_rag/graph/path_filtering.py,sha256=R--XzI51LXBu5IBKMCnJWbkNr6I5d-SDmltyQQnWco0,17674
+java_codebase_rag/graph/ladybug_queries.py,sha256=qdneNIYtJvNkMBfWub4hsB7iemXnfdiVbaZoWakplgk,103050
+java_codebase_rag/graph/path_filtering.py,sha256=odOH1lZXh3_uumcc8gvpE96ffUpGkRmUFDUL_vwaFVc,19099
 java_codebase_rag/index/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-java_codebase_rag/index/java_index_flow_lancedb.py,sha256=4uLZ6nbtbGy0RM5nrTLfVzakPs1VGaJAmS1WqV-Wsy8,29381
+java_codebase_rag/index/java_index_flow_lancedb.py,sha256=NnZkVhka_Ubbndv-rhvosyXZHxD028yDxsa7xTYFb_M,36159
 java_codebase_rag/index/java_index_v1_common.py,sha256=nF1KrSqboF_RRvWerG9knRRFmWwsrG_CvhgnsoZ8KqA,1154
 java_codebase_rag/install_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-java_codebase_rag/install_data/agents/explorer-rag-cli.md,sha256=dTZMbJ1XzTqDyBvGObGx5he5D8_9_nC9EjfYPbTzrds,11118
-java_codebase_rag/install_data/agents/explorer-rag-enhanced.md,sha256=gZsNFbuK0lSnOIlplbbS_muz2ozokJqvFUv65QM0NDM,10406
-java_codebase_rag/install_data/skills/explore-codebase/SKILL.md,sha256=A-v2dueVnxwBzBlxoRjZ2zOJk8DranLQ1TElwn94h0s,11529
-java_codebase_rag/install_data/skills/explore-codebase-cli/SKILL.md,sha256=Svih9hBctiUFFZa6EuOt-tsuILmXC8aU-ZfEneGNDTU,10885
+java_codebase_rag/install_data/agents/explorer-rag-cli.md,sha256=wWhK4gJkxBlW6gTB1mSdUpMqfGHrnNoEqNakPBkZLEg,11683
+java_codebase_rag/install_data/agents/explorer-rag-enhanced.md,sha256=q3tOSGHpnqYr06w48V9rMZxPAqGEDnvgio2Ih8JC0fY,10354
+java_codebase_rag/install_data/skills/explore-codebase/SKILL.md,sha256=uDz1eIDENx9nF-8qzHjktqVS7G8G9BiN2pX7cYTsfmg,11477
+java_codebase_rag/install_data/skills/explore-codebase-cli/SKILL.md,sha256=b-Ot3e0J4wv-RyJ6eevjrj7arY_R-Wzb-DSghneQxMU,11244
 java_codebase_rag/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 java_codebase_rag/mcp/mcp_hints.py,sha256=eJzm_HpfaEKblT4-FW_9bgvDemZYs3E6exGeznflrXM,42536
-java_codebase_rag/mcp/mcp_v2.py,sha256=q6FInC0gu9snU_4Rm2fNjrJx0uzF0RVPKJz4_hPqur8,80448
-java_codebase_rag/mcp/server.py,sha256=DJGlx8U5SD4Pe6Ro71OeFHi6HsYZ4r4uINn7R7uSKk4,40935
+java_codebase_rag/mcp/mcp_v2.py,sha256=70POeJ_O5U_Jjf0SGH9lyK1f5XCIRl25KRSrDxkUZuk,80422
+java_codebase_rag/mcp/server.py,sha256=w7q6z_yIbaFYd83KjSkY5XIR6-jL0_7Q-qWjMF31D-Y,40980
 java_codebase_rag/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 java_codebase_rag/search/index_common.py,sha256=HT6FKHFJ084eFvd3fR1j8z8gf4eWoPHVW8GXLpw464I,285
 java_codebase_rag/search/search_lancedb.py,sha256=MxfTivzeMbScmYIf9s8nKSGCmNr5gMGDXldZotAfW-8,49368
-java_codebase_rag/search/search_lexical.py,sha256=iVui6KneEiVA1TRkA5UhO8XI9toayMDOCU-tXYjwRe8,19961
-java_codebase_rag/search/search_scoring.py,sha256=OsaX6zWyl4BIcqB7nRJRjp3SBEatmGAQ5EZEtQDaww0,20804
+java_codebase_rag/search/search_lexical.py,sha256=wVG4tZ2pc7zX4vWewqj9ONMoZ0cZRJkcMZa3fEKUw6o,19935
+java_codebase_rag/search/search_scoring.py,sha256=SaLYiZP_udyAYUSfLhehX4J1Do8uA8kSlFoiLWYle6s,21374
 java_codebase_rag/watch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 java_codebase_rag/watch/client.py,sha256=PO1uyllGZWoYgYYgm6vToCvaILkp0coXfXCEitzWXMU,9258
-java_codebase_rag/watch/daemon.py,sha256=ZgQrhUkfAJaExCaMqP8QfnNWxLQaoJyxes-FUo-qr78,15698
-java_codebase_rag/watch/lock.py,sha256=E4WuEO_yGWpU1AeOOU91A9d1k4j71iIG9IMHfzorYPo,7564
+java_codebase_rag/watch/daemon.py,sha256=JusMIL_cWxnJXaC0Ix4pOhl-GKMH7Cj5ZBH9CSJtGyo,17633
+java_codebase_rag/watch/lock.py,sha256=-TlYIeXSOqxFKvPxFT9LH1aka5-YRNd5BHnJ1s9V9-M,7551
 java_codebase_rag/watch/paths.py,sha256=UXmw19O2ILr0_yWgeyd-j6Qn2y0MO4ejspfLBcLol0w,2368
 java_codebase_rag/watch/protocol.py,sha256=Vj16d0d0eA7XiLFX6o7JMY-I-mGva9VRxC41ZSbDVy4,3061
 java_codebase_rag/watch/server.py,sha256=GUyCDmbl30wm9GhWTBh-K_BEhFSCHiM2kahmncMGf5E,11168
 java_codebase_rag/watch/warm.py,sha256=EN_39jVV1Kohsq8OI2LqGdTz_X-OCy4s4GWykiDAK7k,5113
-java_codebase_rag/watch/watcher.py,sha256=flD17vjPYuUjae6eWzSYcN-lsZnJUWVoXXvywDD1J24,15272
-java_codebase_rag-0.11.1.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
-java_codebase_rag-0.11.1.dist-info/METADATA,sha256=-04PA-7KnhvSYMQMTTpWMrlsdecPcD433pfbCDIHMqg,20573
-java_codebase_rag-0.11.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-java_codebase_rag-0.11.1.dist-info/entry_points.txt,sha256=pa6yYHbHG7ZZ7G9ZJgYK1Fz6eR9okldPLo7qLY2THuo,190
-java_codebase_rag-0.11.1.dist-info/top_level.txt,sha256=u2i_IKLLOkYyNE32m4TIED0vtKtQDdPEVqRtNuhC1Hk,18
-java_codebase_rag-0.11.1.dist-info/RECORD,,
+java_codebase_rag/watch/watcher.py,sha256=M9MKBI2P8w3Os2I9JM_0oElk5eeJ-DCC5vB3aAoRrdQ,17827
+java_codebase_rag-0.12.0.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
+java_codebase_rag-0.12.0.dist-info/METADATA,sha256=Q4UEAjZ79KdVbd21YblRK0vmkgWmEZwREJ-OfE8P_YM,21365
+java_codebase_rag-0.12.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+java_codebase_rag-0.12.0.dist-info/entry_points.txt,sha256=S7ng8YydbGe97wugiCOgfI8xu04aKuLzSioSNH1rmcQ,252
+java_codebase_rag-0.12.0.dist-info/top_level.txt,sha256=u2i_IKLLOkYyNE32m4TIED0vtKtQDdPEVqRtNuhC1Hk,18
+java_codebase_rag-0.12.0.dist-info/RECORD,,

java_codebase_rag-0.12.0.dist-info/entry_points.txt

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

java_codebase_rag-0.11.1.dist-info/entry_points.txt

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