java-codebase-rag 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

graph_enrich.py

@@ -1565,6 +1565,38 @@ def microservice_for_path(
     return ""
 
 
+def detect_microservice_from_path(cwd: Path, source_root: Path) -> str | None:
+    """Detect microservice from cwd for query-time auto-scope.
+
+    Returns None if cwd is outside source_root, cwd IS source_root (system level),
+    or no microservice is detected. Otherwise returns the microservice name.
+    """
+    cwd_resolved = cwd.resolve()
+    source_resolved = source_root.resolve()
+
+    # Check if cwd is outside source_root
+    try:
+        cwd_resolved.relative_to(source_resolved)
+    except ValueError:
+        return None
+
+    # Check if cwd IS source_root (at system level, no specific scope)
+    if cwd_resolved == source_resolved:
+        return None
+
+    # Check if cwd itself matches a YAML override (directory name matches microservice_roots)
+    overrides = load_microservice_overrides(source_resolved)
+    if overrides and cwd_resolved.name in overrides:
+        return cwd_resolved.name
+
+    # microservice_for_path walks _bounded_parents which excludes the path itself.
+    # For query-time detection we need cwd included in the walk, so pass a synthetic
+    # child path so that cwd appears as a parent in the build-marker scan.
+    synthetic = cwd_resolved / "__scope_probe__"
+    ms = microservice_for_path(str(synthetic), source_resolved)
+    return ms if ms else None
+
+
 # ---------- chunk enrichment ----------
 
 

java_codebase_rag/cli.py

@@ -21,7 +21,7 @@ from java_codebase_rag.config import (
     index_dir_has_existing_artifacts,
     resolve_operator_config,
 )
-from java_codebase_rag.pipeline import clip, run_build_ast_graph, run_cocoindex_drop, run_cocoindex_update
+from java_codebase_rag.pipeline import clip, run_build_ast_graph, run_cocoindex_drop, run_cocoindex_update, run_incremental_graph
 from java_ontology import VALID_UNRESOLVED_CALL_REASONS
 
 KUZU_INCREMENTAL_TRACKING_ISSUE_URL = "https://github.com/HumanBean17/java-codebase-rag/issues/73"
@@ -229,6 +229,23 @@ def _add_verbosity_flags(p: argparse.ArgumentParser) -> None:
 
 def _cmd_init(args: argparse.Namespace) -> int:
     cfg = _resolved_from_ns(args)
+    # Check for parent config or index
+    from java_codebase_rag.config import discover_project_root, find_yaml_config_file
+    parent_config_dir = discover_project_root(cfg.source_root.parent)
+    if parent_config_dir is not None:
+        parent_config = find_yaml_config_file(parent_config_dir)
+        if parent_config is not None:
+            print(
+                f"Warning: found existing config at {parent_config}. "
+                f"Creating a new project here will create a separate index.",
+                file=sys.stderr,
+            )
+        else:
+            print(
+                f"Warning: found existing index at {parent_config_dir / '.java-codebase-rag'}. "
+                f"Creating a new project here will create a separate index.",
+                file=sys.stderr,
+            )
     _startup_hints(cfg)
     cfg.apply_to_os_environ()
     occupied, paths = index_dir_has_existing_artifacts(cfg.index_dir)
@@ -298,7 +315,11 @@ def _cmd_increment(args: argparse.Namespace) -> int:
     cfg = _resolved_from_ns(args)
     _startup_hints(cfg)
     cfg.apply_to_os_environ()
-    _emit_increment_kuzu_warning()
+
+    # Check for --vectors-only flag
+    vectors_only = bool(getattr(args, "vectors_only", False))
+    if vectors_only:
+        _emit_increment_kuzu_warning()
 
     def work() -> int:
         env = cfg.subprocess_env()
@@ -320,7 +341,50 @@ def _cmd_increment(args: argparse.Namespace) -> int:
                 }
             )
             return 1
-        _emit({"success": True, "message": "increment completed (Lance only; graph may be stale — see stderr)"})
+
+        # If --vectors-only is set, skip graph update
+        if vectors_only:
+            _emit({"success": True, "message": "increment completed (Lance only; graph may be stale — see stderr)"})
+            return 0
+
+        # Run incremental graph update
+        g = run_incremental_graph(
+            source_root=cfg.source_root,
+            kuzu_path=cfg.kuzu_path,
+            verbose=bool(args.verbose),
+            quiet=bool(args.quiet),
+            env=env,
+        )
+
+        # Check if incremental fell back to full rebuild
+        if g.returncode == 0 and g.stdout:
+            # Parse stdout to check for full_fallback mode
+            # The incremental_rebuild function returns a JSON payload with mode field
+            try:
+                result = json.loads(g.stdout.strip())
+                if result.get("mode") == "full_fallback":
+                    print(
+                        "[increment] fell back to full graph rebuild — this is normal after schema changes or first run",
+                        file=sys.stderr,
+                        flush=True,
+                    )
+            except (json.JSONDecodeError, ValueError):
+                # If parsing fails, continue silently
+                pass
+
+        if g.returncode != 0:
+            _emit(
+                {
+                    "success": False,
+                    "exit_code": g.returncode,
+                    "stdout": clip(g.stdout, 4000),
+                    "stderr": clip(g.stderr, 4000),
+                    "message": f"graph builder exit {g.returncode}",
+                }
+            )
+            return 1
+
+        _emit({"success": True, "message": "increment completed (Lance + graph updated)"})
         return 0
 
     return _run_with_pipeline_progress("increment", cfg, quiet=bool(args.quiet), work=work)
@@ -615,7 +679,7 @@ def build_parser() -> argparse.ArgumentParser:
         "--quiet suppresses that stream; stdout remains the machine-readable payload.\n\n"
         "Lifecycle (manage the index):\n"
         "  init            Create a fresh index from a Java repository.\n"
-        "  increment       Pick up changes since the last index update (Lance only).\n"
+        "  increment       Pick up changes since the last index update (Lance + graph).\n"
         "  reprocess       Full vector + graph rebuild (default); optional --vectors-only / --graph-only.\n"
         "  erase           Delete the index from disk.\n\n"
         "Introspection (inspect the index):\n"
@@ -650,10 +714,15 @@ def build_parser() -> argparse.ArgumentParser:
     increment = subparsers.add_parser(
         "increment",
         help="Pick up changes since the last index update.",
-        description="Runs cocoindex catch-up (no full reprocess). Does not rebuild Kuzu; see stderr warning.",
+        description="Runs cocoindex catch-up and incremental Kuzu graph update. Use --vectors-only to skip graph update.",
     )
     _add_index_embedding_flags(increment)
     _add_verbosity_flags(increment)
+    increment.add_argument(
+        "--vectors-only",
+        action="store_true",
+        help="Run only cocoindex catch-up (Lance); skip graph update.",
+    )
     increment.set_defaults(handler=_cmd_increment)
 
     reprocess = subparsers.add_parser(

java_codebase_rag/config.py

@@ -123,6 +123,46 @@ def find_yaml_config_file(source_root: Path) -> Path | None:
     return None
 
 
+def _has_index_dir(directory: Path) -> bool:
+    """True if *directory* contains a non-empty ``.java-codebase-rag/`` index directory."""
+    idx = directory / ".java-codebase-rag"
+    return idx.is_dir() and any(idx.iterdir())
+
+
+def discover_project_root(start: Path) -> Path | None:
+    """Walk up from start to find the directory containing a config file or index.
+
+    Looks for ``.java-codebase-rag.yml`` / ``.java-codebase-rag.yaml`` (preferred)
+    or the ``.java-codebase-rag/`` index directory as a project boundary marker.
+
+    First match wins (closest to start). Config file takes priority over index
+    directory at the same level. Stops at $HOME inclusive — checks $HOME itself
+    but does not walk past it. Returns None if no marker found.
+    """
+    start = start.resolve()
+    home = Path.home().resolve()
+
+    current = start
+    while True:
+        # Config file is the primary anchor
+        if find_yaml_config_file(current) is not None:
+            return current
+        # Index directory is the secondary anchor (supports indexes without config)
+        if _has_index_dir(current):
+            return current
+
+        # Stop if we've reached home (check home itself, but don't walk past it)
+        if current == home:
+            return None
+
+        # Stop if we've reached filesystem root
+        parent = current.parent
+        if parent == current:
+            return None
+
+        current = parent
+
+
 def load_yaml_mapping(source_root: Path) -> dict[str, Any]:
     path = find_yaml_config_file(source_root)
     if path is None:
@@ -277,8 +317,36 @@ def resolve_operator_config(
     cli_embedding_model: str | None = None,
     cli_embedding_device: str | None = None,
 ) -> ResolvedOperatorConfig:
-    root = (source_root or Path.cwd()).expanduser().resolve()
-    yaml_dict = load_yaml_mapping(root)
+    # Phase 1: Find the config file directory
+    if source_root is not None:
+        # CLI flag provided: use it as both config_dir and effective source_root
+        # (skip YAML source_root check - CLI wins)
+        root = source_root.expanduser().resolve()
+        config_dir = root
+        yaml_dict = load_yaml_mapping(config_dir)
+    else:
+        # Check env var first
+        env_raw = os.environ.get(ENV_SOURCE_ROOT, "").strip()
+        if env_raw:
+            root = Path(env_raw).expanduser().resolve()
+            config_dir = root
+            yaml_dict = load_yaml_mapping(config_dir)
+        else:
+            # Walk up to find config dir
+            discovered = discover_project_root(Path.cwd())
+            config_dir = discovered if discovered is not None else Path.cwd().resolve()
+            # Load YAML from config dir
+            yaml_dict = load_yaml_mapping(config_dir)
+
+            # Phase 2: Resolve effective source root
+            # Check for YAML source_root field (resolved relative to config dir)
+            yaml_source_root = yaml_dict.get("source_root")
+            if isinstance(yaml_source_root, str) and yaml_source_root.strip():
+                yroot = Path(yaml_source_root.strip()).expanduser()
+                root = yroot.resolve() if yroot.is_absolute() else (config_dir / yroot).resolve()
+            else:
+                root = config_dir
+
     index_dir, index_src = _resolve_index_dir_path(
         source_root=root, cli_index_dir=cli_index_dir, yaml_dict=yaml_dict
     )

java_codebase_rag/pipeline.py

@@ -247,5 +247,60 @@ def run_build_ast_graph(
     return subprocess.CompletedProcess(args=cmd, returncode=code, stdout=out_s, stderr=err_s)
 
 
+def run_incremental_graph(
+    *,
+    source_root: Path,
+    kuzu_path: Path,
+    verbose: bool,
+    quiet: bool = False,
+    env: dict[str, str] | None = None,
+) -> subprocess.CompletedProcess[str]:
+    """Run incremental graph rebuild by passing --incremental flag to build_ast_graph.py."""
+    builder = bundle_dir() / "build_ast_graph.py"
+    if not builder.is_file():
+        return subprocess.CompletedProcess(
+            args=[],
+            returncode=126,
+            stdout="",
+            stderr=f"build_ast_graph.py not found under {builder.parent}",
+        )
+    cmd: list[str] = [
+        sys.executable,
+        str(builder),
+        "--source-root",
+        str(source_root),
+        "--kuzu-path",
+        str(kuzu_path),
+        "--incremental",
+    ]
+    # Three-tier: --quiet (silent) / default (filtered progress) / --verbose (raw).
+    # Default passes --verbose so the builder emits per-pass progress lines,
+    # which the parent filters via _LineFilter.  --verbose bypasses the filter.
+    if verbose or not quiet:
+        cmd.append("--verbose")
+    if quiet:
+        return subprocess.run(
+            cmd,
+            cwd=str(source_root),
+            env=env or os.environ.copy(),
+            capture_output=True,
+            text=True,
+        )
+    proc = subprocess.Popen(
+        cmd,
+        cwd=str(source_root),
+        env=env or os.environ.copy(),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        bufsize=0,
+    )
+    out_s, err_s, code = _popen_capturing_stderr(proc, verbose=verbose)
+    if not verbose:
+        from java_codebase_rag.cli_format import bold_cyan, styled_check, styled_cross
+        marker = styled_check() if code == 0 else styled_cross()
+        print(f"{marker} {bold_cyan('[increment]')} done", file=sys.stderr, flush=True)
+    return subprocess.CompletedProcess(args=cmd, returncode=code, stdout=out_s, stderr=err_s)
+
+
 def clip(s: str, n: int) -> str:
     return s[-n:] if len(s) > n else s

{java_codebase_rag-0.3.1.dist-info → java_codebase_rag-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.3.1
+Version: 0.4.0
 Summary: MCP server for semantic + structural search over Java codebases
 Author: HumanBean17
 License-Expression: MIT
@@ -29,7 +29,12 @@ Requires-Dist: PyYAML<7,>=6.0.3
 Requires-Dist: sentence-transformers<6,>=5.4.0
 Requires-Dist: tree-sitter<0.26,>=0.25.2
 Requires-Dist: tree-sitter-java<0.24,>=0.23.5
+Requires-Dist: pydantic<3,>=2.0
 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: ruff>=0.4; extra == "dev"
 Dynamic: license-file
 
 # java-codebase-rag
@@ -126,7 +131,9 @@ With the package installed, the console script `java-codebase-rag-mcp` is on you
 claude mcp add --transport stdio java-codebase-rag -- java-codebase-rag-mcp
 ```
 
-Then set env vars (`JAVA_CODEBASE_RAG_INDEX_DIR`, `JAVA_CODEBASE_RAG_SOURCE_ROOT`, `SBERT_MODEL`, …) in `.mcp.json` or your shell profile. For a project-scoped `.mcp.json` template, see [`mcp.json.example`](./mcp.json.example). Official docs: [Claude Code settings](https://docs.anthropic.com/en/docs/claude-code/settings).
+**Zero-env-var configuration:** The tool automatically walks up the directory tree to find `.java-codebase-rag.yml`, so you don't need to set `JAVA_CODEBASE_RAG_SOURCE_ROOT` when working from within a project. Just place the config file at your project root and the tool will find it. See [`mcp.json.example`](./mcp.json.example) for the minimal configuration.
+
+If you need to override defaults, you can set env vars (`JAVA_CODEBASE_RAG_INDEX_DIR`, `JAVA_CODEBASE_RAG_SOURCE_ROOT`, `SBERT_MODEL`, …) in `.mcp.json` or your shell profile. For a full configuration template, see [`mcp.json.example`](./mcp.json.example). Official docs: [Claude Code settings](https://docs.anthropic.com/en/docs/claude-code/settings).
 
 ### Claude Desktop
 
@@ -200,7 +207,7 @@ Run `java-codebase-rag --help` to list grouped subcommands. Operator playbook wi
 | Group | Subcommand | What it does |
 |---|---|---|
 | Lifecycle | `init` | First-time index. Refuses if artifacts already exist. |
-| Lifecycle | `increment` | CocoIndex catch-up (Lance only); Kuzu stays stale until `reprocess`. |
+| Lifecycle | `increment` | CocoIndex catch-up + incremental Kuzu update. `--vectors-only` for Lance only. |
 | Lifecycle | `reprocess` | Full Lance + Kuzu rebuild. `--vectors-only` / `--graph-only` for a single phase. |
 | Lifecycle | `erase` | Delete index artifacts. Requires `--yes` or TTY confirm. |
 | Introspection | `meta`, `tables`, `diagnose-ignore`, `unresolved-calls` | Health, table listing, ignore-layer diagnostics, receiver-failure call sites. |
@@ -244,5 +251,4 @@ 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).
-- Incremental Kuzu updates (per-changed-file) — see [`propose/TIER2-INCREMENTAL-REBUILD-PROPOSE.md`](./propose/TIER2-INCREMENTAL-REBUILD-PROPOSE.md) and [`propose/INDEX-AUTO-MODE-PROPOSE.md`](./propose/INDEX-AUTO-MODE-PROPOSE.md).
 - Optional `codegraph_nodes` LanceDB table embedding symbol summaries so the graph itself is vector-searchable.

{java_codebase_rag-0.3.1.dist-info → java_codebase_rag-0.4.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-ast_java.py,sha256=NGs34vhoSypfHbKnNRpA9aj-gO4P6bED3ASmDWEVsZk,98881
+ast_java.py,sha256=OKoH7oX6L7AEEd6UY-spK8BPtWYY1T_4esrTC5VtoK8,98881
 brownfield_events.py,sha256=yxXkKDgMb3VPtaiakGzncHM_EGnda8xIue6w90yYp8s,2055
-build_ast_graph.py,sha256=oK2C94tZqCL6KVxOHkrXTLfeF29xWXuBDF49KQxCMZo,118133
+build_ast_graph.py,sha256=KY5rpqWR7UafvAcIv0ubSz6jiYA8I5ZGqm_SKIFJulE,148770
 chunk_heuristics.py,sha256=aQk2NOKxzUdqoUAJUO3G3LE0MN_bYZWNLQ0tkmj5uts,1813
-graph_enrich.py,sha256=2-njD2alm7FFpLn217ZG3f3ln-zqbdtGwTghOpd44oo,62021
+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
@@ -13,16 +13,16 @@ 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=6pw3g29o7SwVYmRZV0NxSc2d_eFg521LkUn9kUCzbJw,26470
+server.py,sha256=c4Bo0FXPoKP2AwIVP_wiv0XENkmKchLHf0QrQPUUgq4,28645
 java_codebase_rag/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-java_codebase_rag/cli.py,sha256=7nwrnXdRGZvRKMYcHJDR0CecYsiBt1Fu1RJwrQAIMV0,28518
+java_codebase_rag/cli.py,sha256=h4-86RRZAlCSARuhMhLbqnUiwxAagBnrY5rj4IF0yIo,31238
 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=F6NtbRAlcs9M96bhrkQVeptOkvCFdd0rt_UJFKNiRfA,12633
-java_codebase_rag/pipeline.py,sha256=p0u6yJlBYip2kr7LaCUYFHI4sv9inEgXpZTzcJK_rJ8,7583
-java_codebase_rag-0.3.1.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
-java_codebase_rag-0.3.1.dist-info/METADATA,sha256=o4nk9F_JRE6yX0Jv7O4A45c2vHPXIGVryjxPz8dWEDQ,15068
-java_codebase_rag-0.3.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-java_codebase_rag-0.3.1.dist-info/entry_points.txt,sha256=mVVQJa0n73OWfhHXYCDoPRrWin_LJhH2Rn0CkJ2iax4,101
-java_codebase_rag-0.3.1.dist-info/top_level.txt,sha256=5aIYoMkvJvvfXvf4iHn2OeSIM7PZXP-0j94eNESnwMw,242
-java_codebase_rag-0.3.1.dist-info/RECORD,,
+java_codebase_rag/config.py,sha256=1BkRQsdY2ohZ8IWmbTG3WHgotVVUIrRTN537A1QAoCQ,15352
+java_codebase_rag/pipeline.py,sha256=nMXwX9r7HG9yPstrm7y_vfOMUZuDmw5_1lJTAfR-jwI,9488
+java_codebase_rag-0.4.0.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
+java_codebase_rag-0.4.0.dist-info/METADATA,sha256=Je_Zr3MB5ANZNolBRvHOpjQvEO_Y9GBFes4sXYiI_Uw,15422
+java_codebase_rag-0.4.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+java_codebase_rag-0.4.0.dist-info/entry_points.txt,sha256=mVVQJa0n73OWfhHXYCDoPRrWin_LJhH2Rn0CkJ2iax4,101
+java_codebase_rag-0.4.0.dist-info/top_level.txt,sha256=5aIYoMkvJvvfXvf4iHn2OeSIM7PZXP-0j94eNESnwMw,242
+java_codebase_rag-0.4.0.dist-info/RECORD,,

server.py

@@ -16,7 +16,12 @@ from java_codebase_rag.cli_progress import (
     emit_vectors_finish,
     emit_vectors_start,
 )
-from java_codebase_rag.config import emit_legacy_env_hints_if_present, resolved_sbert_model_for_process_env, resolve_operator_config
+from java_codebase_rag.config import (
+    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 mcp.server.fastmcp import FastMCP
 from pydantic import BaseModel, Field
@@ -91,10 +96,49 @@ class IndexInfoOutput(BaseModel):
     graph: GraphMetaOutput
 
 
+# Module-level scope manager, initialized in main()
+_scope_manager: ScopeManager | None = None
+
+
+class ScopeManager:
+    """Manages automatic microservice scope detection and injection."""
+
+    def __init__(self, source_root: Path):
+        self.source_root = source_root
+        self.default_scope: str | None = self._detect_scope()
+        self._log_detection()
+
+    def _detect_scope(self) -> str | None:
+        from graph_enrich import detect_microservice_from_path
+        return detect_microservice_from_path(Path.cwd(), self.source_root)
+
+    def _log_detection(self) -> None:
+        if self.default_scope:
+            print(f"[scope] Detected microservice: {self.default_scope}", file=sys.stderr)
+            print(f"[scope] Queries scoped to {self.default_scope}", file=sys.stderr)
+        else:
+            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:
+        """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
+
+
 def _resolve_lancedb_uri() -> str:
     raw = os.environ.get("JAVA_CODEBASE_RAG_INDEX_DIR", "").strip()
     if not raw:
-        raw = str((Path.cwd() / ".java-codebase-rag").resolve())
+        raw = str((_project_root() / ".java-codebase-rag").resolve())
     p = Path(raw).expanduser()
     if not str(raw).startswith(("s3://", "gs://", "az://")):
         try:
@@ -108,7 +152,8 @@ def _project_root() -> Path:
     env = os.environ.get("JAVA_CODEBASE_RAG_SOURCE_ROOT", "").strip()
     if env:
         return Path(env).expanduser().resolve()
-    return Path.cwd().resolve()
+    discovered = discover_project_root(Path.cwd())
+    return discovered if discovered is not None else Path.cwd().resolve()
 
 
 def _cocoindex_subprocess_env(project_root: Path) -> dict[str, str]:
@@ -370,6 +415,7 @@ def create_mcp_server() -> FastMCP:
             ),
         ),
     ) -> mcp_v2.SearchOutput:
+        scoped_filter = _scope_manager.apply_auto_scope(filter) if _scope_manager else filter
         return await asyncio.to_thread(
             mcp_v2.search_v2,
             query,
@@ -378,7 +424,7 @@ def create_mcp_server() -> FastMCP:
             limit,
             offset,
             path_contains,
-            filter,
+            scoped_filter,
             None,
         )
 
@@ -413,7 +459,8 @@ def create_mcp_server() -> FastMCP:
         limit: int = Field(default=25, ge=1, le=500, description="Max nodes to return"),
         offset: int = Field(default=0, ge=0, le=499, description="Skip this many nodes (pagination)"),
     ) -> mcp_v2.FindOutput:
-        return await asyncio.to_thread(mcp_v2.find_v2, kind, filter, limit, offset, None)
+        scoped_filter = _scope_manager.apply_auto_scope(filter) if _scope_manager else filter
+        return await asyncio.to_thread(mcp_v2.find_v2, kind, scoped_filter, limit, offset, None)
 
     @mcp.tool(
         name="describe",
@@ -525,6 +572,7 @@ def create_mcp_server() -> FastMCP:
             ),
         ),
     ) -> mcp_v2.NeighborsOutput:
+        scoped_filter = _scope_manager.apply_auto_scope(filter) if _scope_manager else filter
         return await asyncio.to_thread(
             mcp_v2.neighbors_v2,
             ids,
@@ -532,7 +580,7 @@ def create_mcp_server() -> FastMCP:
             edge_types,
             limit,
             offset,
-            filter,
+            scoped_filter,
             edge_filter,
             include_unresolved,
             dedup_calls,
@@ -580,6 +628,10 @@ def main() -> None:
     cfg.apply_to_os_environ()
     mcp_v2.set_hints_enabled(cfg.hints_enabled)
 
+    # Initialize scope manager for automatic microservice detection
+    global _scope_manager
+    _scope_manager = ScopeManager(cfg.source_root)
+
     asyncio.run(create_mcp_server().run_stdio_async())