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

server.py

@@ -7,7 +7,7 @@ import os
 import sys
 import time
 from pathlib import Path
-from typing import Any, Literal
+from typing import Literal
 
 import mcp_v2
 from index_common import SBERT_MODEL
@@ -16,27 +16,29 @@ from java_codebase_rag.cli_progress import (
     emit_vectors_finish,
     emit_vectors_start,
 )
+from java_codebase_rag._fdlimit import raise_fd_limit
 from java_codebase_rag.config import (
+    cocoindex_subprocess_env_defaults,
     discover_project_root,
     emit_legacy_env_hints_if_present,
     resolved_sbert_model_for_process_env,
     resolve_operator_config,
 )
-from kuzu_queries import KuzuGraph, resolve_kuzu_path
+from ladybug_queries import LadybugGraph, resolve_ladybug_path
 from mcp.server.fastmcp import FastMCP
 from pydantic import BaseModel, Field
 from search_lancedb import TABLES
 
 _COCOINDEX_TARGET = "java_index_flow_lancedb.py:JavaCodeIndexLance"
 _INSTRUCTIONS = (
-    "Java codebase graph navigator (LanceDB + Kuzu). "
+    "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), "
     "neighbors (one hop; you MUST pass direction in|out AND edge_types list — no defaults), "
-    "resolve (identifier-shaped lookup for symbol/route/client/producer — three statuses one|many|none). "
-    "NodeFilter `filter` is a JSON object (preferred); a JSON-encoded string is also accepted as a fallback. "
+    "resolve (identifier-shaped lookup for symbol/route/client/producer — three statuses: one | many | none). "
     "Unknown filter keys and populated fields not applicable to the effective node kind fail with success=false and message. "
+    "Successful responses from any tool may include `hints_structured` (tool call suggestions with a `reason` field) and `advisories` (pure informational text) when hints are enabled. "
     "Edge labels: EXTENDS, IMPLEMENTS, INJECTS, OVERRIDES, DECLARES, DECLARES_CLIENT, DECLARES_PRODUCER, CALLS, EXPOSES, HTTP_CALLS, ASYNC_CALLS; "
-    "type Symbols may also use composed neighbors edge_types DECLARES.DECLARES_CLIENT, DECLARES.DECLARES_PRODUCER, DECLARES.EXPOSES (out only). "
+    "type Symbols may also use composed neighbors edge_types DECLARES.DECLARES_CLIENT, DECLARES.DECLARES_PRODUCER, DECLARES.EXPOSES (out only, type Symbol origin). "
     "Reprocess/init, meta, tables, diagnose-ignore, analyze-pr: use java-codebase-rag CLI — not MCP."
 )
 
@@ -85,6 +87,7 @@ class RefreshIndexOutput(BaseModel):
     graph_stdout: str = ""
     graph_stderr: str = ""
     phases_run: list[Literal["vectors", "graph"]] = Field(default_factory=list)
+    optimize_error: str | None = None
 
 
 class IndexInfoOutput(BaseModel):
@@ -120,19 +123,15 @@ class ScopeManager:
             print("[scope] No microservice detected (at project root)", file=sys.stderr)
             print("[scope] Queries will span all microservices", file=sys.stderr)
 
-    def apply_auto_scope(self, node_filter: dict[str, Any] | None) -> dict[str, Any] | None:
+    def apply_auto_scope(self, node_filter: mcp_v2.NodeFilter | None) -> mcp_v2.NodeFilter | None:
         """Apply auto-detected scope to filter if no explicit microservice is set."""
         if self.default_scope is None:
             return node_filter
-        # Convert to dict for manipulation
         if node_filter is None:
-            filter_dict = {}
-        else:
-            filter_dict = dict(node_filter)
-        # Only inject if user didn't specify microservice
-        if "microservice" not in filter_dict:
-            filter_dict["microservice"] = self.default_scope
-        return filter_dict
+            return mcp_v2.NodeFilter(microservice=self.default_scope)
+        if node_filter.microservice is None:
+            return node_filter.model_copy(update={"microservice": self.default_scope})
+        return node_filter
 
 
 def _resolve_lancedb_uri() -> str:
@@ -156,45 +155,67 @@ def _project_root() -> Path:
     return discovered if discovered is not None else Path.cwd().resolve()
 
 
+def _source_root_for_operator_config() -> Path | None:
+    """``source_root`` arg to hand ``resolve_operator_config`` from the MCP server.
+
+    Returns ``JAVA_CODEBASE_RAG_SOURCE_ROOT`` when set (an explicit operator
+    override that wins and suppresses the YAML ``source_root`` field, exactly
+    like CLI ``--source-root``), otherwise ``None`` — so
+    ``resolve_operator_config`` runs its OWN walk-up discovery and HONORS the
+    YAML ``source_root`` field, matching the CLI (``init`` / ``increment`` /
+    ``reprocess``) path.
+
+    Do NOT pass ``_project_root()`` (the walk-up-discovered dir) here: a
+    non-``None`` value routes into the "explicit source root" branch that
+    skips the YAML ``source_root`` field, which made the MCP server and the
+    CLI resolve different ``source_root`` / ``index_dir`` from the same config
+    file (the init-vs-MCP index_dir divergence). ``_project_root()`` is kept
+    only for the ``_resolve_lancedb_uri()`` fallback below.
+    """
+    env = os.environ.get("JAVA_CODEBASE_RAG_SOURCE_ROOT", "").strip()
+    return Path(env).expanduser().resolve() if env else None
+
+
 def _cocoindex_subprocess_env(project_root: Path) -> dict[str, str]:
     sub_env = os.environ.copy()
     sub_env["JAVA_CODEBASE_RAG_SOURCE_ROOT"] = str(project_root)
     idx = os.environ.get("JAVA_CODEBASE_RAG_INDEX_DIR", "").strip()
     if idx:
         sub_env["JAVA_CODEBASE_RAG_INDEX_DIR"] = str(Path(idx).expanduser().resolve())
-    # Set CocoIndex concurrency limits to prevent "too many open files" error
-    # See: https://github.com/HumanBean17/java-codebase-rag/issues/293
-    sub_env.setdefault("COCOINDEX_SOURCE_MAX_INFLIGHT_ROWS", "256")
+    # Cap CocoIndex concurrency to avoid EMFILE ("too many open files") under
+    # default OS fd limits. See: https://github.com/HumanBean17/java-codebase-rag/issues/306
+    for _k, _v in cocoindex_subprocess_env_defaults().items():
+        sub_env.setdefault(_k, _v)
     return sub_env
 
 
 def _graph_enabled() -> bool:
-    return KuzuGraph.exists()
+    return LadybugGraph.exists()
 
 
 def _graph_meta_output() -> GraphMetaOutput:
-    if not KuzuGraph.exists():
+    if not LadybugGraph.exists():
         return GraphMetaOutput(
             success=True,
             enabled=False,
-            db_path=resolve_kuzu_path(),
-            message="Kuzu graph not present; run java-codebase-rag reprocess or build_ast_graph.py",
+            db_path=resolve_ladybug_path(),
+            message="Ladybug graph not present; run java-codebase-rag reprocess or build_ast_graph.py",
         )
     try:
-        graph = KuzuGraph.get()
+        graph = LadybugGraph.get()
         meta = graph.meta()
     except Exception as e:
         return GraphMetaOutput(
             success=False,
             enabled=_graph_enabled(),
-            db_path=resolve_kuzu_path(),
-            message=f"Kuzu open failed: {e}",
+            db_path=resolve_ladybug_path(),
+            message=f"Ladybug open failed: {e}",
         )
     if "error" in meta:
         return GraphMetaOutput(
             success=False,
             enabled=_graph_enabled(),
-            db_path=meta.get("db_path", resolve_kuzu_path()),
+            db_path=meta.get("db_path", resolve_ladybug_path()),
             message=str(meta["error"]),
         )
     try:
@@ -212,7 +233,7 @@ def _graph_meta_output() -> GraphMetaOutput:
     return GraphMetaOutput(
         success=True,
         enabled=_graph_enabled(),
-        db_path=meta.get("db_path", resolve_kuzu_path()),
+        db_path=meta.get("db_path", resolve_ladybug_path()),
         ontology_version=int(meta.get("ontology_version") or 0),
         built_at=int(meta.get("built_at") or 0),
         source_root=str(meta.get("source_root") or ""),
@@ -326,9 +347,29 @@ async def run_refresh_pipeline(*, quiet: bool = False, verbose: bool = True) ->
     graph_code: int | None = None
     graph_out = ""
     graph_err = ""
+    optimize_error: str | None = None
     if ok:
         if not quiet:
             print(file=sys.stderr, flush=True)
+        # Serialized post-flow Lance optimize: the flow disabled its background
+        # optimize, so with cocoindex returned exit 0 there are no concurrent
+        # writers — this is the safe window to compact. An optimize failure is
+        # surfaced via optimize_error / stderr and must NOT flip the success of
+        # a vectors phase that succeeded; the index is still searchable.
+        try:
+            from java_codebase_rag.lance_optimize import optimize_lance_tables
+
+            idx_raw = os.environ.get("JAVA_CODEBASE_RAG_INDEX_DIR", "").strip()
+            if idx_raw and not idx_raw.startswith(("s3://", "gs://", "az://")):
+                idx_dir = Path(idx_raw).expanduser().resolve()
+            elif idx_raw:
+                idx_dir = Path(idx_raw)
+            else:
+                idx_dir = (root / ".java-codebase-rag").resolve()
+            await optimize_lance_tables(idx_dir, quiet=quiet)
+        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:
@@ -337,8 +378,8 @@ async def run_refresh_pipeline(*, quiet: bool = False, verbose: bool = True) ->
                     str(builder),
                     "--source-root",
                     str(root),
-                    "--kuzu-path",
-                    resolve_kuzu_path(),
+                    "--ladybug-path",
+                    resolve_ladybug_path(),
                 ]
                 if not quiet:
                     graph_args.append("--verbose")
@@ -365,6 +406,10 @@ async def run_refresh_pipeline(*, quiet: bool = False, verbose: bool = True) ->
         message = f"cocoindex exit {proc.returncode}"
     elif graph_code is not None and graph_code != 0:
         message = f"graph builder exit {graph_code}"
+    # Surface a post-flow optimize failure in the message too (success is not
+    # flipped — the vectors phase succeeded and the index is still usable).
+    if optimize_error is not None:
+        message = optimize_error if message is None else f"{message}; {optimize_error}"
     return RefreshIndexOutput(
         success=ok and (graph_code is None or graph_code == 0),
         exit_code=proc.returncode,
@@ -375,6 +420,7 @@ async def run_refresh_pipeline(*, quiet: bool = False, verbose: bool = True) ->
         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=phases_run,
+        optimize_error=optimize_error,
     )
 
 
@@ -384,14 +430,15 @@ def create_mcp_server() -> FastMCP:
     @mcp.tool(
         name="search",
         description=(
-            "Ranked chunk retrieval: `query` is opaque text (natural language or code fragments); "
-            "results are score-ranked, not boolean-matched. Optional `filter` uses the same NodeFilter "
-            "schema as `find` but only **symbol-applicable** fields apply (strict frame). Wildcards "
+            "Ranked chunk retrieval over content tables (java/sql/yaml); `query` is opaque text (natural language or code "
+            "fragments) and results are score-ranked, not boolean-matched. For graph-structured listing "
+            "(symbols/routes/clients/producers) use `find`, not `search`. Optional `filter` uses the same NodeFilter "
+            "schema as `find` but only **symbol-applicable** fields apply — others return success=false. Wildcards "
             "(`*`, `?`) in prefix fields are rejected—use ranked `query` text instead. There is **no** "
             "structured DSL inside `query`; structured predicates belong in `find`. "
             "For identifier-shaped lookups (FQN, id prefix, route/client identifiers, …), use `resolve` first; "
             "use `search` for natural-language or ranked fuzzy discovery. "
-            "Successful responses echo `limit`/`offset` and may include `hints_structured` (tool call suggestions with `reason` field) and `advisories` (pure informational text)."
+            "Successful responses echo `limit`/`offset`."
         ),
     )
     async def search(
@@ -402,7 +449,7 @@ def create_mcp_server() -> FastMCP:
         ),
         hybrid: bool = Field(
             default=False,
-            description="If true, fuse FTS + vector (single-table java/sql/yaml only)",
+            description="If true, fuse FTS + vector. Requires a single table (java/sql/yaml); hybrid with table='all' returns success=false.",
         ),
         limit: int = Field(default=5, ge=1, le=50, description="Max hits to return"),
         offset: int = Field(default=0, ge=0, le=500, description="Skip this many hits (pagination)"),
@@ -410,11 +457,11 @@ def create_mcp_server() -> FastMCP:
             default=None,
             description="Substring match on file path (pre-filter from index)",
         ),
-        filter: dict[str, Any] | str | None = Field(
+        filter: mcp_v2.NodeFilter | None = Field(
             default=None,
             description=(
-                "Optional NodeFilter post-filter on symbol-oriented hit rows. Unknown keys or populated fields not "
-                "applicable to symbols return success=false. Prefer a JSON object; a JSON-encoded string is accepted."
+                "Optional NodeFilter post-filter on symbol-oriented hit rows. An empty object or omitted means no "
+                "predicate. Unknown keys or populated fields not applicable to symbols return success=false."
             ),
         ),
     ) -> mcp_v2.SearchOutput:
@@ -439,9 +486,11 @@ def create_mcp_server() -> FastMCP:
             "**route** — microservice, module, http_method, path_prefix, framework; **client** — microservice, module, "
             "source_layer, client_kind, target_service, target_path_prefix, http_method; **producer** — microservice, "
             "module, source_layer, producer_kind, topic_prefix. "
+            "`role` is singular and `exclude_roles` plural; `capability` is a functional tag assigned during indexing. "
+            "`fqn_prefix` is a prefix predicate — for exact FQN or id lookup use `resolve`/`describe`. "
             "Wildcards in prefix fields are rejected. An empty filter (`{}`) or `filter=None` means no predicate (all nodes of "
             "that kind; use pagination). Unknown keys or inapplicable populated fields return success=false. "
-            "Successful responses echo `limit`/`offset` and may include `hints_structured` (tool call suggestions with `reason` field) and `advisories` (pure informational text)."
+            "Successful responses echo `limit`/`offset`."
         ),
     )
     async def find(
@@ -452,11 +501,10 @@ def create_mcp_server() -> FastMCP:
                 "'producer' = outbound async producers."
             )
         ),
-        filter: dict[str, Any] | str = Field(
+        filter: mcp_v2.NodeFilter = Field(
             ...,
             description=(
-                "Required NodeFilter dict (extra keys forbidden). Fields must be applicable to `kind`. "
-                "Prefer a JSON object; a JSON-encoded string is accepted."
+                "Required NodeFilter object (extra keys forbidden). Fields must be applicable to `kind`."
             ),
         ),
         limit: int = Field(default=25, ge=1, le=500, description="Max nodes to return"),
@@ -468,17 +516,14 @@ def create_mcp_server() -> FastMCP:
     @mcp.tool(
         name="describe",
         description=(
-            "Full node record plus `edge_summary` (in/out counts per stored edge label, plus optional describe-time keys). Type Symbols may add "
-            "composed keys DECLARES.DECLARES_CLIENT, DECLARES.DECLARES_PRODUCER, and DECLARES.EXPOSES (navigable on type Symbols via neighbors, out only); "
-            "method Symbols may add override-axis virtual keys (OVERRIDDEN_BY, OVERRIDDEN_BY.DECLARES_CLIENT, OVERRIDDEN_BY.DECLARES_PRODUCER, "
-            "OVERRIDDEN_BY.EXPOSES, plus an `OVERRIDES` map entry that merges stored `[:OVERRIDES]` counts with the dispatch-up rollup per direction). "
-            "Override-axis virtual keys are navigable via neighbors on non-static method Symbol origins "
-            "(out only; composed keys include via_id in attrs). The stored `OVERRIDES` relationship "
-            "is also a normal edge label (e.g. direction in from declaration toward overriders). "
+            "Full node record plus `edge_summary` (in/out counts per stored edge label). For type Symbols, `edge_summary` "
+            "also exposes composed keys (DECLARES.DECLARES_CLIENT, DECLARES.DECLARES_PRODUCER, DECLARES.EXPOSES); for "
+            "non-static method Symbols it adds override-axis virtual keys (OVERRIDDEN_BY and its composed forms, plus an "
+            "`OVERRIDES` map merging stored `[:OVERRIDES]` counts with the dispatch-up rollup). These composed/override keys "
+            "are out-only and navigable via `neighbors`; the stored `OVERRIDES` is also a normal edge label (in toward declaration). "
             "Pass `id` for any kind, or exact `fqn` for Symbol lookup (`id` wins when both are set). "
             "`describe(fqn=…)` keeps the first graph row when multiple symbols share that FQN; when an FQN may collide, "
-            "prefer `resolve(identifier=…, hint_kind='symbol')` first, then `describe(id=…)` on the chosen node. "
-            "Successful responses may include `hints_structured` (tool call suggestions with `reason` field) and `advisories` (pure informational text)."
+            "prefer `resolve(identifier=…, hint_kind='symbol')` first, then `describe(id=…)` on the chosen node."
         ),
     )
     async def describe(
@@ -502,18 +547,19 @@ def create_mcp_server() -> FastMCP:
     @mcp.tool(
         name="neighbors",
         description=(
-            "Graph walk: **direction** (`in` | `out`) and non-empty **edge_types** are required (stored labels for one hop; "
-            "type Symbol origins may also pass composed DECLARES.DECLARES_CLIENT, DECLARES.DECLARES_PRODUCER, or DECLARES.EXPOSES "
-            "for 2-hop member rollups; method Symbol origins may pass OVERRIDDEN_BY, OVERRIDDEN_BY.DECLARES_CLIENT, "
-            "OVERRIDDEN_BY.DECLARES_PRODUCER, OVERRIDDEN_BY.EXPOSES for override-axis rollups — out only, via_id in "
-            "attrs on composed keys). "
+            "Graph walk: **direction** (`in` | `out`) and non-empty **edge_types** are required (one hop over stored edge "
+            "labels; type/method Symbol origins may also pass composed or override-axis keys — see `edge_types`). From a "
+            "type Symbol, `direction='out'` with EXPOSES yields route nodes and HTTP_CALLS/ASYNC_CALLS yield client/producer "
+            "nodes; `direction='in'` reverses each relationship. "
+            "`direction` and `edge_types` have no defaults; an empty `edge_types` fails. The CALLS-only features — "
+            "`edge_filter`, `include_unresolved`, `dedup_calls` — each require `edge_types=['CALLS']`; `edge_filter` and "
+            "`include_unresolved` are mutually exclusive. Violating a precondition (wrong CALLS context, composed/override "
+            "keys on an ineligible origin or with `direction='in'`, wildcards in prefix fields, unknown filter keys) returns "
+            "success=false with a message; `dedup_calls` with other edge_types is a silent no-op. "
             "Optional `filter` applies to each neighbor endpoint row; populated fields must be applicable to that "
-            "neighbor's kind—mixed-kind result sets fail on the first inapplicable neighbor (strict frame). "
-            "Optional `edge_filter` requires edge_types=['CALLS'] only (no composed dot-keys or extra stored "
-            "labels); projects the ordered CALLS stream by edge attributes (min_confidence, strategies, "
-            "callee_declaring_role). Wildcards in prefix fields are rejected. Unknown filter keys return success=false. "
-            "Successful responses echo `requested_edge_types` and may include `hints_structured` (tool call suggestions with `reason` field) and `advisories` (pure informational text). "
-            "Each edge's `attrs.strategy` indicates resolution quality (brownfield/fallback vs primary paths)."
+            "neighbor's kind—mixed-kind result sets fail on the first inapplicable neighbor (per-neighbor strict frame). "
+            "Each edge's `attrs.strategy` indicates resolution quality (brownfield/fallback vs primary paths). "
+            "Successful responses echo `requested_edge_types`."
         ),
     )
     async def neighbors(
@@ -544,19 +590,19 @@ def create_mcp_server() -> FastMCP:
             le=1000,
             description="Skip this many edges after merge (pagination)",
         ),
-        filter: dict[str, Any] | str | None = Field(
+        filter: mcp_v2.NodeFilter | None = Field(
             default=None,
             description=(
-                "Optional NodeFilter on the neighbor node. Same applicability rules as `find` for that node's kind. "
-                "Prefer a JSON object; a JSON-encoded string is accepted."
+                "Optional NodeFilter on the neighbor node. An empty object or omitted means no predicate. "
+                "Same applicability rules as `find` for that node's kind."
             ),
         ),
-        edge_filter: dict[str, Any] | str | None = Field(
+        edge_filter: mcp_v2.EdgeFilter | None = Field(
             default=None,
             description=(
                 "Optional EdgeFilter on CALLS edge attributes (edge_types=['CALLS'] only). Use "
                 "callee_declaring_role for callee stereotype projection — not NodeFilter.role on method neighbors. "
-                "Mutually exclusive with include_unresolved. Prefer a JSON object; a JSON-encoded string is accepted."
+                "Mutually exclusive with include_unresolved."
             ),
         ),
         include_unresolved: bool = Field(
@@ -598,10 +644,11 @@ def create_mcp_server() -> FastMCP:
             "status=one (single node), many (≥2 ranked candidates with reason), or none "
             "(no match — fall back to search(query=...) for natural language or fuzzy text). "
             "Optional hint_kind narrows to symbol, route, client, or producer. "
-            "Successful responses may include hints_structured (tool call suggestions with `reason` field) and advisories (pure informational text) — same contract as other v2 tools. "
             "Malformed empty/whitespace identifier returns success=false. "
             "Examples: resolve('com.foo.Bar', hint_kind='symbol'); "
             "resolve('GET /api/v1/customers', hint_kind='route'); "
+            "resolve('PaymentClient', hint_kind='client'); "
+            "resolve('order.created', hint_kind='producer'); "
             "resolve('the client that handles assignments') → none (use search instead)."
         ),
     )
@@ -622,12 +669,13 @@ def create_mcp_server() -> FastMCP:
 
 
 def main() -> None:
+    raise_fd_limit()
     emit_legacy_env_hints_if_present()
 
     # Load YAML config and apply embedding settings to environment
     # This ensures SBERT_MODEL and SBERT_DEVICE from .java-codebase-rag.yml are available
     # before any tool handler runs (same behavior as CLI path)
-    cfg = resolve_operator_config(source_root=_project_root())
+    cfg = resolve_operator_config(source_root=_source_root_for_operator_config())
     cfg.apply_to_os_environ()
     mcp_v2.set_hints_enabled(cfg.hints_enabled)
 

user_rag/__init__.py

@@ -0,0 +1 @@
+

user_rag/cli.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import pprint
+import sys
+from pathlib import Path
+from typing import Any
+
+import pr_analysis
+import server
+from path_filtering import LayeredIgnore
+
+
+def _jsonable(value: Any) -> Any:
+    if hasattr(value, "model_dump"):
+        return value.model_dump()
+    if isinstance(value, Path):
+        return str(value)
+    raise TypeError(f"Object of type {type(value).__name__} is not JSON serializable")
+
+
+def _to_payload(value: Any) -> Any:
+    if hasattr(value, "model_dump"):
+        return value.model_dump()
+    return value
+
+
+def _emit(value: Any) -> None:
+    payload = _to_payload(value)
+    if sys.stdout.isatty():
+        print(pprint.pformat(payload, sort_dicts=True))
+        return
+    print(json.dumps(payload, default=_jsonable, sort_keys=True, indent=None))
+
+
+def _parse_common_graph_flags(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--source-root", type=str, default=None)
+    parser.add_argument("--kuzu-path", type=str, default=None)
+    parser.add_argument("--lancedb-path", type=str, default=None)
+
+
+def _apply_graph_env(args: argparse.Namespace) -> None:
+    if args.source_root:
+        os.environ["LANCEDB_MCP_PROJECT_ROOT"] = str(Path(args.source_root).expanduser().resolve())
+    if args.kuzu_path:
+        os.environ["KUZU_DB_PATH"] = str(Path(args.kuzu_path).expanduser().resolve())
+        # Reset singleton to pick up override path.
+        from kuzu_queries import KuzuGraph
+
+        KuzuGraph._instance = None
+        KuzuGraph._instance_path = None
+    if args.lancedb_path:
+        os.environ["LANCEDB_URI"] = str(Path(args.lancedb_path).expanduser().resolve())
+
+
+def _cmd_refresh(args: argparse.Namespace) -> int:
+    """Return 1 for launched-subprocess failures, 2 for internal pre-launch errors."""
+    _apply_graph_env(args)
+    result = asyncio.run(server.run_refresh_pipeline(quiet=bool(args.quiet)))
+    payload = result.model_dump()
+    if payload.get("success"):
+        _emit(payload)
+        return 0
+    _emit(payload)
+    return 2 if payload.get("exit_code") is None else 1
+
+
+def _cmd_meta(args: argparse.Namespace) -> int:
+    _apply_graph_env(args)
+    payload = server._graph_meta_output().model_dump()
+    _emit(payload)
+    return 0 if payload.get("success") else 2
+
+
+def _cmd_tables(args: argparse.Namespace) -> int:
+    _apply_graph_env(args)
+    payload = server.list_code_index_tables_payload().model_dump()
+    _emit(payload)
+    return 0
+
+
+def _cmd_diagnose_ignore(args: argparse.Namespace) -> int:
+    _apply_graph_env(args)
+    # Keep this after _apply_graph_env so relative paths resolve from --source-root.
+    root = server._project_root()
+    raw = Path(args.path)
+    try:
+        abs_path = raw.resolve() if raw.is_absolute() else (root / raw).resolve()
+    except OSError as exc:
+        _emit({"success": False, "message": f"Invalid path: {exc}"})
+        return 1
+    li = LayeredIgnore(root)
+    _emit(li.diagnose_dict(abs_path))
+    return 0
+
+
+def _read_diff_text(args: argparse.Namespace) -> str:
+    if args.diff_file:
+        return Path(args.diff_file).read_text(encoding="utf-8")
+    if args.diff_stdin:
+        return sys.stdin.read()
+    raise ValueError("Provide exactly one of --diff-file or --diff-stdin")
+
+
+def _cmd_analyze_pr(args: argparse.Namespace) -> int:
+    _apply_graph_env(args)
+    try:
+        diff_text = _read_diff_text(args)
+    except Exception as exc:
+        _emit({"success": False, "message": str(exc)})
+        return 1
+    if not diff_text.strip():
+        _emit({"success": False, "message": "Diff is empty"})
+        return 1
+    from kuzu_queries import KuzuGraph
+
+    if not KuzuGraph.exists():
+        _emit({"success": False, "message": "Kuzu graph not found"})
+        return 1
+    graph = KuzuGraph.get()
+    report = pr_analysis.analyze_pr_pipeline(graph, diff_text)
+    _emit(pr_analysis.pr_report_to_dict(report))
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="java-codebase-rag")
+    subparsers = parser.add_subparsers(dest="subcommand")
+
+    refresh = subparsers.add_parser("refresh")
+    _parse_common_graph_flags(refresh)
+    refresh.add_argument("--quiet", action="store_true")
+    refresh.set_defaults(handler=_cmd_refresh)
+
+    meta = subparsers.add_parser("meta")
+    _parse_common_graph_flags(meta)
+    meta.set_defaults(handler=_cmd_meta)
+
+    tables = subparsers.add_parser("tables")
+    _parse_common_graph_flags(tables)
+    tables.set_defaults(handler=_cmd_tables)
+
+    diagnose = subparsers.add_parser("diagnose-ignore")
+    _parse_common_graph_flags(diagnose)
+    diagnose.add_argument("path", type=str)
+    diagnose.set_defaults(handler=_cmd_diagnose_ignore)
+
+    analyze = subparsers.add_parser("analyze-pr")
+    _parse_common_graph_flags(analyze)
+    group = analyze.add_mutually_exclusive_group(required=True)
+    group.add_argument("--diff-file", type=str)
+    group.add_argument("--diff-stdin", action="store_true")
+    analyze.set_defaults(handler=_cmd_analyze_pr)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    handler = getattr(args, "handler", None)
+    if handler is None:
+        parser.print_help(sys.stderr)
+        return 2
+    try:
+        return int(handler(args))
+    except Exception as exc:  # pragma: no cover - defensive top-level guard
+        _emit({"success": False, "exit_code": 2, "message": f"internal error: {exc}"})
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

java_codebase_rag-0.5.3.dist-info/RECORD

@@ -1,31 +0,0 @@
-ast_java.py,sha256=OKoH7oX6L7AEEd6UY-spK8BPtWYY1T_4esrTC5VtoK8,98881
-brownfield_events.py,sha256=yxXkKDgMb3VPtaiakGzncHM_EGnda8xIue6w90yYp8s,2055
-build_ast_graph.py,sha256=1uqgFK2ebBdEc2QcAYK5vU4afOb95jU3zht5FracCkI,148683
-chunk_heuristics.py,sha256=aQk2NOKxzUdqoUAJUO3G3LE0MN_bYZWNLQ0tkmj5uts,1813
-graph_enrich.py,sha256=m3cksCHLqLHhA0Y-TLodbm09YfSJZjlTDN0Z51DiP2c,63317
-index_common.py,sha256=HT6FKHFJ084eFvd3fR1j8z8gf4eWoPHVW8GXLpw464I,285
-java_index_flow_lancedb.py,sha256=LMmfMSdE2d-ujxuJ2-hss7BhkrUMxHNyZuqsiGITuAI,12057
-java_index_v1_common.py,sha256=nF1KrSqboF_RRvWerG9knRRFmWwsrG_CvhgnsoZ8KqA,1154
-java_ontology.py,sha256=nM-oY8_91rmUudv9hAss1AMus9BFY9s5tTpAWjlCz00,16424
-kuzu_queries.py,sha256=9bQzrU311AOw_BcUp_KSGiZgPVSaLSU7y63XfcT_vqI,90137
-mcp_hints.py,sha256=3swh05LSiWur3tm3-yssndBsLxIxFhy501kBtJI8jJ0,42509
-mcp_v2.py,sha256=JFe62sYzJ2XiE6L3wAH8XG9_Ya2oOeJQ_hkiTmXFnSE,79065
-path_filtering.py,sha256=-oX16SYLWYwX9pcV1fu3vbVTIhY1GzFflT7J1E2tqPY,17122
-pr_analysis.py,sha256=Zaq90xYgMgrReV3vCGcFhOkK61gIRMAAIgs7ev-rJG4,18410
-search_lancedb.py,sha256=-XgtpbJ_3zDLiZ_vGKXjaLpl7RlvgyzUb7oAGoWkXO0,36754
-server.py,sha256=1ZEDkRAOMs0ORncMh9CP2ICCTGEuAe2qmptytQ4QYYU,28862
-java_codebase_rag/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-java_codebase_rag/cli.py,sha256=WW-DsskSGr-d0JXBLkj4IdAa2OsAcLz5e54_DWvD9Sk,33872
-java_codebase_rag/cli_format.py,sha256=arU7P9W6Fvm7X_wzR1wJ8EfyxK1rDP_ESEhdA0ub4Mo,2579
-java_codebase_rag/cli_progress.py,sha256=9jCqEagYOXs32SYVA31_sOCrONvYy7cl1CrdBD2Pg44,3168
-java_codebase_rag/config.py,sha256=1BkRQsdY2ohZ8IWmbTG3WHgotVVUIrRTN537A1QAoCQ,15352
-java_codebase_rag/installer.py,sha256=flj330ZPSBrO2iw_yuNFBILHOTVbarMufYwqjZ8JzN0,42778
-java_codebase_rag/pipeline.py,sha256=D9SNdffcmJLoKHnNZLWZzfor1fI4bkkpJkU0KFsqfdA,9722
-java_codebase_rag/install_data/agents/explorer-rag-enhanced.md,sha256=APl9d-No12qZNZLjU7mwNRwxHIgnT3ZtQZiD4clWlyU,14413
-java_codebase_rag/install_data/skills/explore-codebase/SKILL.md,sha256=pIM-Xdwq_fXkhhBJCdb-fA2nes5c_mMPcdUXb7Adyxo,12040
-java_codebase_rag-0.5.3.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
-java_codebase_rag-0.5.3.dist-info/METADATA,sha256=iI08-selyGz8kYjgqBsWbt4Z9e7MeQd_aF7kHFPu65Q,16807
-java_codebase_rag-0.5.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-java_codebase_rag-0.5.3.dist-info/entry_points.txt,sha256=mVVQJa0n73OWfhHXYCDoPRrWin_LJhH2Rn0CkJ2iax4,101
-java_codebase_rag-0.5.3.dist-info/top_level.txt,sha256=5aIYoMkvJvvfXvf4iHn2OeSIM7PZXP-0j94eNESnwMw,242
-java_codebase_rag-0.5.3.dist-info/RECORD,,