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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.6.0
+Version: 0.6.2
 Summary: MCP server for semantic + structural search over Java codebases
 Author: HumanBean17
 License-Expression: MIT
@@ -35,6 +35,7 @@ Requires-Dist: unidiff<1,>=0.7.3
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: pytest-xdist>=3; extra == "dev"
 Requires-Dist: ruff>=0.4; extra == "dev"
 Dynamic: license-file
 

{java_codebase_rag-0.6.0 → java_codebase_rag-0.6.2}/ast_java.py

@@ -13,6 +13,7 @@ Python with no tree-sitter dependency.
 from __future__ import annotations
 
 import posixpath
+import sys
 from dataclasses import dataclass, field
 from functools import lru_cache
 from typing import Iterable
@@ -1642,9 +1643,17 @@ def _parse_codebase_http_client_annotation(
     pairs, _ = _annotation_kv_nodes(ann, src)
     client_kind = ""
     if "clientKind" in pairs:
-        val, _kind = _annotation_value(pairs["clientKind"], src)
-        if val and _kind == "enum":
-            client_kind = str(val)
+        val, vkind = _annotation_value(pairs["clientKind"], src)
+        if val and vkind == "enum":
+            kind_val = str(val)
+            from java_ontology import VALID_CLIENT_KINDS  # deferred: java_ontology imports ast_java
+            if kind_val in VALID_CLIENT_KINDS:
+                client_kind = kind_val
+            else:
+                print(
+                    f"[lancedb-mcp] CodebaseHttpClient: invalid clientKind {kind_val!r} — ignored",
+                    file=sys.stderr,
+                )
     target_service = ""
     if "targetService" in pairs:
         atoms = _string_value_atoms(pairs["targetService"], src, ctx)
@@ -1714,9 +1723,17 @@ def _parse_codebase_producer_annotation(
     client_kind = "kafka_send"
     kind_node = pairs.get("producerKind") or pairs.get("clientKind")
     if kind_node is not None:
-        val, _kind = _annotation_value(kind_node, src)
-        if val and _kind == "enum":
-            client_kind = str(val)
+        val, vkind = _annotation_value(kind_node, src)
+        if val and vkind == "enum":
+            kind_val = str(val)
+            from java_ontology import VALID_PRODUCER_KINDS  # deferred: java_ontology imports ast_java
+            if kind_val in VALID_PRODUCER_KINDS:
+                client_kind = kind_val
+            else:
+                print(
+                    f"[lancedb-mcp] CodebaseProducer: invalid producerKind {kind_val!r} — ignored",
+                    file=sys.stderr,
+                )
     topic = ""
     if "topic" in pairs:
         atoms = _string_value_atoms(pairs["topic"], src, ctx)

{java_codebase_rag-0.6.0 → java_codebase_rag-0.6.2}/build_ast_graph.py

@@ -3668,10 +3668,17 @@ def incremental_rebuild(
 
 
 def _init_hash_tracker(source_root: Path, ladybug_path: Path) -> int:
-    """Initialize hash tracker for all Java files. Returns number of files hashed."""
+    """Initialize hash tracker for all Java files. Returns number of files hashed.
+
+    Called right after a full graph rebuild (``write_ladybug``), so the store must
+    mirror exactly the files that were just indexed. We deliberately do NOT
+    ``load()`` the existing store: ``update`` re-hashes every current file anyway,
+    and preserving old entries would leave stale hashes for files that no longer
+    exist (deleted or now-ignored). Those ghosts would be re-detected as "removed"
+    on every subsequent ``increment``, sustaining an endless full-rebuild loop.
+    """
     index_dir = ladybug_path.parent
     tracker = FileHashTracker(index_dir)
-    tracker.load()
     ignore = LayeredIgnore(source_root)
     all_files: set[str] = set()
     source_root_resolved = source_root.resolve()
@@ -3742,7 +3749,7 @@ def _write_clients_producers_and_calls(conn: ladybug.Connection, tables: GraphTa
 
     # Write declares_client edges
     for row in tables.declares_client_rows:
-        source_file = member_by_id.get(row.symbol_id, MemberEntry(kind="", decl=None, parent_id="", parent_fqn="", file_path="", module="", microservice="")).file_path
+        source_file = member_by_id.get(row.symbol_id, MemberEntry(kind="", decl=None, parent_id="", parent_fqn="", file_path="", module="", microservice="", node_id="")).file_path
         conn.execute(_CREATE_DECLARES_CLIENT, {
             "sid": row.symbol_id,
             "cid": row.client_id,
@@ -3753,7 +3760,7 @@ def _write_clients_producers_and_calls(conn: ladybug.Connection, tables: GraphTa
 
     # Write declares_producer edges
     for row in tables.declares_producer_rows:
-        source_file = member_by_id.get(row.symbol_id, MemberEntry(kind="", decl=None, parent_id="", parent_fqn="", file_path="", module="", microservice="")).file_path
+        source_file = member_by_id.get(row.symbol_id, MemberEntry(kind="", decl=None, parent_id="", parent_fqn="", file_path="", module="", microservice="", node_id="")).file_path
         conn.execute(_CREATE_DECLARES_PRODUCER, {
             "sid": row.symbol_id,
             "pid": row.producer_id,

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

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

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

@@ -52,14 +52,36 @@ _DEFAULT_EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
 _UNRESOLVED_VAR_RE = re.compile(r"\$(\w+|\{[^}]+\})")
 
 
-def maybe_expand_embedding_model_path(value: str) -> str:
-    """Expand ``~`` and ``$VAR`` when *value* is path-shaped.
+def maybe_expand_embedding_model_path(
+    value: str,
+    *,
+    config_dir: Path | None = None,
+    source_root: Path | None = None,
+    source: SettingSource | None = None,
+) -> str:
+    """Expand ``~`` / ``$VAR`` for path-shaped values and resolve relatives to absolute.
 
     Path-shape: starts with ``/``, ``./``, ``../``, ``~``, or contains ``$``.
     Plain ``org/name`` (hub id) does not match and is passed through unchanged.
 
-    Used for ``embedding.model`` after precedence resolution and for runtime
-    ``SBERT_MODEL`` reads (e.g. MCP) so the string matches ``ResolvedOperatorConfig``.
+    Relative resolution mirrors :func:`_resolve_index_dir_path` so a committed
+    config is portable regardless of process CWD:
+
+    * YAML values (``source == "yaml"``) resolve against ``config_dir`` (the
+      directory holding ``.java-codebase-rag.yml``).
+    * CLI / env values resolve against ``source_root``.
+
+    Only a result that still starts with ``./`` or ``../`` *after* ``~`` /
+    ``$VAR`` expansion is re-based — so hub ids (``org/name``), absolute paths,
+    ``~/``-expanded paths, and an env var that already yielded an absolute path
+    are all left untouched.
+
+    When no base is supplied (the runtime ``SBERT_MODEL`` read via
+    :func:`resolved_sbert_model_for_process_env`), relative resolution is
+    skipped: the value is returned ``expandvars`` / ``expanduser``-expanded but
+    not re-based, matching the prior best-effort behavior. The main resolution
+    path (:func:`resolve_operator_config`) supplies a base, so the absolute path
+    it stores is what downstream loaders receive.
     """
     needs_expand = value.startswith(("/", "./", "../", "~")) or "$" in value
     if not needs_expand:
@@ -70,9 +92,31 @@ def maybe_expand_embedding_model_path(value: str) -> str:
             f"java-codebase-rag: path-shaped model string contains unresolved variable: {expanded}",
             file=sys.stderr,
         )
+    if expanded.startswith(("./", "../")):
+        base = _embedding_model_base(
+            source=source, config_dir=config_dir, source_root=source_root
+        )
+        if base is not None:
+            return str((base / expanded).resolve())
     return expanded
 
 
+def _embedding_model_base(
+    *,
+    source: SettingSource | None,
+    config_dir: Path | None,
+    source_root: Path | None,
+) -> Path | None:
+    """Base directory for a relative ``embedding.model``.
+
+    Mirrors :func:`_resolve_index_dir_path`: YAML values anchor on the config
+    file's directory; CLI / env values anchor on the resolved ``source_root``.
+    """
+    if source == "yaml":
+        return config_dir
+    return source_root
+
+
 def resolved_sbert_model_for_process_env(import_time_default: str) -> str:
     """``SBERT_MODEL`` from the process environment, with the same expansion as YAML/CLI resolution.
 
@@ -306,9 +350,19 @@ def _pick_bool(
 def _resolve_index_dir_path(
     *,
     source_root: Path,
+    config_dir: Path,
     cli_index_dir: str | None,
     yaml_dict: dict[str, Any],
 ) -> tuple[Path, SettingSource]:
+    # Bases for relative paths:
+    #   - YAML ``index_dir``  -> the config file's directory (``config_dir``),
+    #     the SAME base used for YAML ``source_root``. Paths written in the
+    #     config file are relative to the file, so both keys stay consistent.
+    #   - CLI / env ``index_dir`` -> ``source_root`` (unchanged). These are not
+    #     "in the config file"; preserving the existing base avoids a semantics
+    #     change for operators who pass ``--index-dir`` on the command line.
+    #   - Default ``./.java-codebase-rag`` -> ``source_root`` so the index sits
+    #     beside the Java tree (the layout ``discover_project_root`` anchors on).
     raw_cli = cli_index_dir.strip() if isinstance(cli_index_dir, str) else None
     if raw_cli:
         p = Path(raw_cli).expanduser()
@@ -324,7 +378,7 @@ def _resolve_index_dir_path(
     idx = yaml_dict.get("index_dir")
     if isinstance(idx, str) and idx.strip():
         p = Path(idx.strip()).expanduser()
-        out = p.resolve() if p.is_absolute() else (source_root / p).resolve()
+        out = p.resolve() if p.is_absolute() else (config_dir / p).resolve()
         return out, "yaml"
 
     return (source_root / ".java-codebase-rag").resolve(), "default"
@@ -368,7 +422,7 @@ def resolve_operator_config(
                 root = config_dir
 
     index_dir, index_src = _resolve_index_dir_path(
-        source_root=root, cli_index_dir=cli_index_dir, yaml_dict=yaml_dict
+        source_root=root, config_dir=config_dir, cli_index_dir=cli_index_dir, yaml_dict=yaml_dict
     )
     model, model_src = _pick_str(
         cli_val=cli_embedding_model,
@@ -377,7 +431,12 @@ def resolve_operator_config(
         yaml_path=("embedding", "model"),
         default=_DEFAULT_EMBEDDING_MODEL,
     )
-    model = maybe_expand_embedding_model_path(model)
+    model = maybe_expand_embedding_model_path(
+        model,
+        config_dir=config_dir,
+        source_root=root,
+        source=model_src,
+    )
     device, device_src = _pick_optional_device(
         cli_val=cli_embedding_device,
         env_key="SBERT_DEVICE",

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

@@ -759,6 +759,11 @@ def generate_yaml_config(
         else:
             config["embedding"].pop("model", None)
 
+    # Seed cross-service resolution safe-by-default: only evidence-backed cross-service
+    # edges survive (see _is_brownfield_sourced in build_ast_graph). setdefault preserves
+    # an explicit user choice (e.g. `auto`) on re-run update.
+    config.setdefault("cross_service_resolution", "brownfield_only")
+
     # Keys NOT written by installer (preserved if present):
     # - source_root (config.py resolves from walk-up discovery)
     # - index_dir (config.py defaults to <source_root>/.java-codebase-rag)
@@ -1250,9 +1255,14 @@ def run_update(
         print("Skipping index update.")
         return EXIT_PARTIAL if has_artifact_failures else EXIT_SUCCESS
 
-    # Resolve configuration
+    # Resolve configuration. Pass source_root=None so the YAML ``source_root``
+    # field is honored exactly like increment/init/reprocess — passing the
+    # discovered config dir here routes resolve_operator_config into the
+    # explicit-override branch that SKIPS the YAML field, which made `update`
+    # point cocoindex at the config dir (no Java) against the real index and
+    # mass-delete it. Discovery still runs against the CLI's cwd.
     try:
-        cfg = resolve_operator_config(source_root=project_root, cli_index_dir=None)
+        cfg = resolve_operator_config(source_root=None, cli_index_dir=None)
         index_dir = cfg.index_dir
     except Exception as e:
         print(f"\nWarning: Failed to resolve configuration: {e}")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.6.0
+Version: 0.6.2
 Summary: MCP server for semantic + structural search over Java codebases
 Author: HumanBean17
 License-Expression: MIT
@@ -35,6 +35,7 @@ Requires-Dist: unidiff<1,>=0.7.3
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: pytest-xdist>=3; extra == "dev"
 Requires-Dist: ruff>=0.4; extra == "dev"
 Dynamic: license-file
 

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

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

{java_codebase_rag-0.6.0 → java_codebase_rag-0.6.2}/java_codebase_rag.egg-info/requires.txt

@@ -16,4 +16,5 @@ unidiff<1,>=0.7.3
 [dev]
 pytest>=7
 pytest-asyncio>=0.21
+pytest-xdist>=3
 ruff>=0.4

{java_codebase_rag-0.6.0 → java_codebase_rag-0.6.2}/java_ontology.py

@@ -15,7 +15,10 @@ from ast_java import (
     _TYPE_ANN_TO_CAPABILITY,
 )
 
-# Roles: Spring stereotype values plus DTO from `infer_role_for_type`.
+# Roles assignable by indexing: Spring stereotype values plus DTO. ``OTHER`` is the
+# built-in inference fallback (ast_java.infer_role when nothing matches) and is
+# deliberately excluded here — it is a read-side value (the mcp_v2 ``Role`` enum
+# includes it) but not a role a user may set via @CodebaseRole / role_overrides.
 VALID_ROLES: frozenset[str] = frozenset((*ROLE_ANNOTATIONS.values(), "DTO"))
 
 VALID_CAPABILITIES: frozenset[str] = frozenset(

{java_codebase_rag-0.6.0 → java_codebase_rag-0.6.2}/mcp_v2.py

@@ -48,6 +48,22 @@ def _hints_or_skip(tool: str, payload: dict) -> tuple[list, list]:
 
 DeclarationSymbolKind = Literal["class", "interface", "enum", "record", "annotation", "method", "constructor"]
 
+# Closed value taxonomies surfaced to MCP consumers as enums. Sources of truth:
+#   Role         — VALID_ROLES in java_ontology.py + the "OTHER" inference fallback (ast_java.infer_role)
+#   Framework    — hardcoded literals across ast_java.py / build_ast_graph.py
+#   SourceLayer  — exhaustive classifier build_ast_graph._client_source_layer / _producer_source_layer
+#   ClientKind   — VALID_CLIENT_KINDS in java_ontology.py (every producer validated at index time)
+#   ProducerKind — VALID_PRODUCER_KINDS in java_ontology.py (every producer validated at index time)
+# Keep these in sync with the indexing-side taxonomies if they change.
+Role = Literal[
+    "CONTROLLER", "SERVICE", "REPOSITORY", "COMPONENT", "CONFIG",
+    "ENTITY", "CLIENT", "MAPPER", "DTO", "OTHER",
+]
+Framework = Literal["spring_mvc", "webflux", "kafka", "rabbitmq", "jms", "stream", "feign", ""]
+SourceLayer = Literal["builtin", "layer_a_meta", "layer_b_ann", "layer_b_fqn", "layer_c_source"]
+ClientKind = Literal["feign_method", "rest_template", "web_client"]
+ProducerKind = Literal["kafka_send", "stream_bridge_send"]
+
 # Stored graph edge labels for one-hop neighbors. Composed DECLARES.* and OVERRIDDEN_BY.*
 # dot-keys are separate ComposedEdgeType literals (2-hop traversal). Stored OVERRIDES is an EdgeType.
 EdgeType = Literal[
@@ -133,21 +149,30 @@ class NodeFilter(BaseModel):
 
     microservice: str | None = None
     module: str | None = None
-    source_layer: str | None = None
-    role: str | None = None
-    exclude_roles: list[str] | None = None
+    source_layer: SourceLayer | None = None
+    role: Role | None = None
+    exclude_roles: list[Role] | None = None
     annotation: str | None = None
     capability: str | None = None
     fqn_prefix: str | None = None
     symbol_kind: DeclarationSymbolKind | None = None
     symbol_kinds: list[DeclarationSymbolKind] | None = None
-    http_method: str | None = None
+    http_method: str | None = Field(
+        default=None,
+        description="HTTP verb (commonly GET/POST/PUT/DELETE/PATCH; user route annotations may yield others).",
+    )
     path_prefix: str | None = None
-    framework: str | None = None
-    client_kind: str | None = None
+    framework: Framework | None = None
+    client_kind: ClientKind | None = Field(
+        default=None,
+        description="Outbound HTTP client kind: feign_method, rest_template, or web_client.",
+    )
     target_service: str | None = None
     target_path_prefix: str | None = None
-    producer_kind: str | None = None
+    producer_kind: ProducerKind | None = Field(
+        default=None,
+        description="Outbound async producer kind: kafka_send or stream_bridge_send.",
+    )
     topic_prefix: str | None = None
 
 
@@ -157,9 +182,9 @@ class EdgeFilter(BaseModel):
     min_confidence: float | None = None
     exclude_strategies: list[str] | None = None
     include_strategies: list[str] | None = None
-    callee_declaring_role: str | None = None
-    callee_declaring_roles: list[str] | None = None
-    exclude_callee_declaring_roles: list[str] | None = None
+    callee_declaring_role: Role | None = None
+    callee_declaring_roles: list[Role] | None = None
+    exclude_callee_declaring_roles: list[Role] | None = None
 
     @model_validator(mode="after")
     def _strategy_axes_mutually_exclusive(self) -> EdgeFilter:

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

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