codespine 0.9.6__tar.gz → 0.9.7__tar.gz

{codespine-0.9.6 → codespine-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespine
-Version: 0.9.6
+Version: 0.9.7
 Summary: Local Java code intelligence indexer backed by a graph database
 Author: CodeSpine contributors
 License: MIT License

{codespine-0.9.6 → codespine-0.9.7}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "0.9.6"
+__version__ = "0.9.7"

{codespine-0.9.6 → codespine-0.9.7}/codespine/cli.py

@@ -6,7 +6,10 @@ import os
 import signal
 import subprocess
 import sys
+import threading
 import time
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 import click
 import psutil
@@ -91,6 +94,149 @@ def _spinner_char() -> str:
     return "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"[int(time.perf_counter() * 8) % 10]
 
 
+def _index_shard_group(
+    shard_idx: int,
+    modules: list[tuple[str, str]],
+    sg,
+    full: bool,
+    embed: bool,
+    output_lock: threading.Lock,
+    parallel: bool,
+) -> tuple[int, list, int]:
+    """Index one group of modules that share a shard.
+
+    Modules within the group are always indexed sequentially (same KùzuDB).
+    Multiple groups can run concurrently in different threads when they own
+    different shards.
+
+    Returns (total_files_found, all_results, shard_idx).
+    """
+    results = []
+    total_files = 0
+
+    def _locked_echo(*args, **kwargs) -> None:
+        """Thread-safe click.echo."""
+        with output_lock:
+            click.echo(*args, **kwargs)
+
+    def _locked_secho(*args, **kwargs) -> None:
+        with output_lock:
+            click.secho(*args, **kwargs)
+
+    prefix = f"[S{shard_idx}] " if parallel else ""
+
+    for mod_path, project_id in modules:
+        # Per-module progress state (local — no shared mutation).
+        parse_state: dict = {"shown": False, "indexed": 0, "total": 0,
+                              "last_ts": 0.0, "printed_zero": False}
+        call_state: dict = {"shown": False, "count": 0, "last_ts": 0.0,
+                             "started_at": 0.0}
+
+        def _progress(event: str, payload: dict) -> None:
+            now = time.perf_counter()
+            if event == "scan_done":
+                with output_lock:
+                    _phase(f"{prefix}Walking files...", f"{int(payload.get('files_found', 0))} files found")
+                return
+            if event == "plan_done":
+                to_index = int(payload.get("files_to_index", 0))
+                deleted = int(payload.get("deleted_files", 0))
+                mode = str(payload.get("mode", "incremental"))
+                parse_state["total"] = to_index
+                with output_lock:
+                    _phase(f"{prefix}Index mode...", f"{mode} ({to_index} files, {deleted} deleted)")
+                if to_index == 0:
+                    with output_lock:
+                        _phase(f"{prefix}Parsing code...", "0/0")
+                    parse_state["printed_zero"] = True
+                return
+            if event == "parse_progress":
+                indexed = int(payload.get("indexed", 0))
+                total = int(payload.get("total", 0))
+                parse_state["indexed"] = indexed
+                parse_state["total"] = total
+                if total == 0:
+                    return
+                if indexed == total or (now - parse_state["last_ts"]) >= 0.2:
+                    if not parallel:
+                        # In-place progress bar only makes sense in serial mode.
+                        click.echo(
+                            f"\r{prefix}Parsing code...   {_bar(indexed, total)} {indexed}/{total}  ",
+                            nl=False,
+                        )
+                    else:
+                        with output_lock:
+                            click.echo(
+                                f"\r{prefix}Parsing {indexed}/{total}  ",
+                                nl=False,
+                            )
+                    parse_state["shown"] = True
+                    parse_state["last_ts"] = now
+                return
+            if event in ("resolve_calls_start",):
+                if parse_state["shown"]:
+                    with output_lock:
+                        click.echo()
+                    parse_state["shown"] = False
+                call_state["started_at"] = now
+                with output_lock:
+                    _phase(f"{prefix}Tracing calls...", "starting...")
+                return
+            if event == "resolve_calls_progress":
+                call_state["count"] = int(payload.get("calls_resolved", 0))
+                if (now - call_state["last_ts"]) >= 0.25:
+                    elapsed_s = now - call_state["started_at"]
+                    if not parallel:
+                        click.echo(
+                            f"\r{_spinner_char()} {prefix}Tracing calls...   "
+                            f"{call_state['count']:>6} resolved  {elapsed_s:.1f}s  ",
+                            nl=False,
+                        )
+                    else:
+                        with output_lock:
+                            click.echo(
+                                f"\r{prefix}Calls: {call_state['count']} ({elapsed_s:.0f}s)  ",
+                                nl=False,
+                            )
+                    call_state["shown"] = True
+                    call_state["last_ts"] = now
+                return
+            if event == "resolve_calls_done":
+                if call_state["shown"]:
+                    with output_lock:
+                        click.echo()
+                call_state["shown"] = False
+                elapsed_s = (now - call_state["started_at"]) if call_state["started_at"] else 0.0
+                n = int(payload.get("calls_resolved", 0))
+                with output_lock:
+                    _phase(f"{prefix}Tracing calls...", f"{n} calls resolved  ({elapsed_s:.1f}s)")
+                return
+            if event == "resolve_types_start":
+                with output_lock:
+                    _phase(f"{prefix}Analyzing types...", "running")
+                return
+            if event == "resolve_types_done":
+                n = int(payload.get("type_relationships", 0))
+                with output_lock:
+                    _phase(f"{prefix}Analyzing types...", f"{n} type relationships")
+                return
+
+        shard_store = sg.shard(project_id)
+        indexer = JavaIndexer(shard_store)
+        result = indexer.index_project(
+            mod_path, full=full, progress=_progress, project_id=project_id, embed=embed
+        )
+        results.append(result)
+        total_files += result.files_found
+
+        # Flush any dangling progress line.
+        if parse_state["shown"]:
+            with output_lock:
+                click.echo()
+
+    return shard_idx, results, total_files
+
+
 def _show_shard_topology(as_json: bool) -> None:
     """Display the current shard routing topology and imbalance metrics."""
     router = ShardRouter()
@@ -217,103 +363,69 @@ def analyse(path: str, full: bool, deep: bool, embed: bool, allow_running: bool)
 
     root_basename = os.path.basename(abs_path)
 
-    # Shared progress state (reset per module)
-    parse_state = {"shown": False, "indexed": 0, "total": 0, "last_ts": 0.0, "printed_zero": False}
-    call_state = {"shown": False, "count": 0, "last_ts": 0.0, "started_at": 0.0}
-
-    def _reset_state() -> None:
-        for k in list(parse_state):
-            parse_state[k] = False if isinstance(parse_state[k], bool) else (0.0 if isinstance(parse_state[k], float) else 0)
-        parse_state["last_ts"] = 0.0
-
-    def _progress(event: str, payload: dict) -> None:
-        now = time.perf_counter()
-        if event == "scan_done":
-            _phase("Walking files...", f"{int(payload.get('files_found', 0))} files found")
-            return
-        if event == "plan_done":
-            to_index = int(payload.get("files_to_index", 0))
-            deleted = int(payload.get("deleted_files", 0))
-            mode = str(payload.get("mode", "incremental"))
-            parse_state["total"] = to_index
-            _phase("Index mode...", f"{mode} ({to_index} files to index, {deleted} deleted)")
-            if to_index == 0:
-                _phase("Parsing code...", "0/0")
-                parse_state["printed_zero"] = True
-            return
-        if event == "parse_progress":
-            indexed = int(payload.get("indexed", 0))
-            total = int(payload.get("total", 0))
-            parse_state["indexed"] = indexed
-            parse_state["total"] = total
-            if total == 0:
-                return
-            if indexed == total or (now - parse_state["last_ts"]) >= 0.2:
-                click.echo(f"\rParsing code...   {_bar(indexed, total)} {indexed}/{total}  ", nl=False)
-                parse_state["shown"] = True
-                parse_state["last_ts"] = now
-            return
-        if event == "resolve_calls_start" and parse_state["shown"]:
-            click.echo()
-            parse_state["shown"] = False
-            call_state["started_at"] = now
-            _phase("Tracing calls...", "starting...")
-            return
-        if event == "resolve_calls_start":
-            call_state["started_at"] = now
-            _phase("Tracing calls...", "starting...")
-            return
-        if event == "resolve_calls_progress":
-            call_state["count"] = int(payload.get("calls_resolved", 0))
-            if (now - call_state["last_ts"]) >= 0.25:
-                elapsed_s = now - call_state["started_at"]
-                click.echo(
-                    f"\r{_spinner_char()} Tracing calls...   {call_state['count']:>6} resolved  {elapsed_s:.1f}s  ",
-                    nl=False,
-                )
-                call_state["shown"] = True
-                call_state["last_ts"] = now
-            return
-        if event == "resolve_calls_done":
-            if call_state["shown"]:
-                click.echo()
-            call_state["shown"] = False
-            elapsed_s = (now - call_state["started_at"]) if call_state["started_at"] else 0.0
-            _phase("Tracing calls...", f"{int(payload.get('calls_resolved', 0))} calls resolved  ({elapsed_s:.1f}s)")
-            return
-        if event == "resolve_types_start":
-            _phase("Analyzing types...", "running")
-            return
-        if event == "resolve_types_done":
-            _phase("Analyzing types...", f"{int(payload.get('type_relationships', 0))} type relationships")
-            return
-
-    # --- Index each module ---
+    # ── Group modules by target shard ─────────────────────────────────
+    # Modules that hash to different shards own separate KùzuDBs and can
+    # be indexed in parallel.  Modules in the same shard (same project
+    # root for multi-module projects) are always indexed sequentially.
+    shard_groups: dict[int, list[tuple[str, str]]] = defaultdict(list)
+    for mod_path, pid in modules_with_ids:
+        shard_groups[sg.router.shard_for(pid)].append((mod_path, pid))
+
     is_multi = len(modules_with_ids) > 1
+    parallel_mode = len(shard_groups) > 1  # ≥2 shards → true parallelism
+    output_lock = threading.Lock()
+
+    if parallel_mode:
+        click.secho(
+            f"Parallel mode: {len(shard_groups)} shards will be indexed concurrently.",
+            fg="cyan",
+        )
+
+    # Print which shard each module lands on (multi-module only).
+    if is_multi:
+        for s_idx, group in sorted(shard_groups.items()):
+            for _, pid in group:
+                click.secho(f"  {pid:<40} → shard {s_idx}", fg="cyan")
+
+    # ── Dispatch to shards ────────────────────────────────────────────
     total_files_found = 0
+    all_results: list = []
     last_result = None
-    for idx, (module_path, project_id) in enumerate(modules_with_ids):
-        if is_multi:
-            shard_idx = sg.router.shard_for(project_id)
-            click.echo()
-            click.secho(
-                f"[{idx + 1}/{len(modules_with_ids)}] Indexing: {project_id}  (shard {shard_idx})",
-                fg="cyan",
-            )
-        _reset_state()
-        # Use the shard store for this project so data lands in the right DB.
-        shard_store = sg.shard(project_id)
-        indexer = JavaIndexer(shard_store)
-        last_result = indexer.index_project(
-            module_path, full=full, progress=_progress, project_id=project_id, embed=embed
+
+    if parallel_mode:
+        max_workers = min(len(shard_groups), 4)
+        click.echo()
+        futures_map = {}
+        with ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="codespine-shard") as ex:
+            for s_idx, group in shard_groups.items():
+                f = ex.submit(
+                    _index_shard_group,
+                    s_idx, group, sg, full, embed, output_lock, True,
+                )
+                futures_map[f] = s_idx
+
+            for future in as_completed(futures_map):
+                s_idx = futures_map[future]
+                try:
+                    ret_idx, results, n_files = future.result()
+                    all_results.extend(results)
+                    total_files_found += n_files
+                    if results:
+                        last_result = results[-1]
+                    with output_lock:
+                        click.secho(f"  Shard {ret_idx} done ({n_files} files)", fg="green")
+                except Exception as exc:  # noqa: BLE001
+                    with output_lock:
+                        click.secho(f"  Shard {s_idx} FAILED: {exc}", fg="red")
+    else:
+        # Serial path — single shard (or single module).  Full progress UX.
+        only_shard_idx = next(iter(shard_groups))
+        only_group = shard_groups[only_shard_idx]
+        _, all_results, total_files_found = _index_shard_group(
+            only_shard_idx, only_group, sg, full, embed, output_lock, False,
         )
-        total_files_found += last_result.files_found
-        if parse_state["shown"]:
-            click.echo()
-        if parse_state["total"] == 0 and not parse_state["printed_zero"]:
-            _phase("Parsing code...", "0/0")
-        elif parse_state["indexed"] < parse_state["total"]:
-            _phase("Parsing code...", f"{parse_state['indexed']}/{parse_state['total']}")
+        if all_results:
+            last_result = all_results[-1]
 
     # ── Helper for in-place progress updates ────────────────────────────
     def _live_phase(label: str, status: str) -> None:

{codespine-0.9.6 → codespine-0.9.7}/codespine/db/store.py

@@ -495,35 +495,77 @@ class GraphStore:
     def upsert_symbols_batch(self, records: list[dict[str, Any]], create_mode: bool = False) -> None:
         if not records:
             return
-        rows = [{"id": r["id"], "kind": r["kind"], "name": r["name"],
-                  "fqname": r["fqname"], "file_id": r["file_id"],
-                  "line": int(r["line"]), "col": int(r["col"]),
-                  "embedding": r.get("embedding")} for r in records]
-        if create_mode:
-            self.execute(
-                """
-                UNWIND $rows AS row
-                MATCH (f:File {id: row.file_id})
-                CREATE (s:Symbol {id: row.id, kind: row.kind, name: row.name,
-                                   fqname: row.fqname, file_id: row.file_id,
-                                   line: row.line, col: row.col, embedding: row.embedding})
-                CREATE (f)-[:DECLARES]->(s)
-                """,
-                {"rows": rows},
-            )
-        else:
-            self.execute(
-                """
-                UNWIND $rows AS row
-                MATCH (f:File {id: row.file_id})
-                MERGE (s:Symbol {id: row.id})
-                SET s.kind = row.kind, s.name = row.name, s.fqname = row.fqname,
-                    s.file_id = row.file_id, s.line = row.line, s.col = row.col,
-                    s.embedding = row.embedding
-                MERGE (f)-[:DECLARES]->(s)
-                """,
-                {"rows": rows},
-            )
+        # Split into rows with and without embeddings.
+        # Kuzu's UNWIND parameter type inference treats None as STRING, which
+        # conflicts with the FLOAT[384] column type.  Keeping the two groups
+        # separate avoids the type-mismatch error on fresh DBs.
+        rows_emb: list[dict] = []
+        rows_no_emb: list[dict] = []
+        for r in records:
+            emb = r.get("embedding")
+            base = {"id": r["id"], "kind": r["kind"], "name": r["name"],
+                    "fqname": r["fqname"], "file_id": r["file_id"],
+                    "line": int(r["line"]), "col": int(r["col"])}
+            if emb is not None:
+                rows_emb.append({**base, "embedding": emb})
+            else:
+                rows_no_emb.append(base)
+
+        op = "CREATE" if create_mode else "MERGE"
+        edge_op = "CREATE" if create_mode else "MERGE"
+
+        if rows_no_emb:
+            if create_mode:
+                self.execute(
+                    """
+                    UNWIND $rows AS row
+                    MATCH (f:File {id: row.file_id})
+                    CREATE (s:Symbol {id: row.id, kind: row.kind, name: row.name,
+                                       fqname: row.fqname, file_id: row.file_id,
+                                       line: row.line, col: row.col})
+                    CREATE (f)-[:DECLARES]->(s)
+                    """,
+                    {"rows": rows_no_emb},
+                )
+            else:
+                self.execute(
+                    """
+                    UNWIND $rows AS row
+                    MATCH (f:File {id: row.file_id})
+                    MERGE (s:Symbol {id: row.id})
+                    SET s.kind = row.kind, s.name = row.name, s.fqname = row.fqname,
+                        s.file_id = row.file_id, s.line = row.line, s.col = row.col
+                    MERGE (f)-[:DECLARES]->(s)
+                    """,
+                    {"rows": rows_no_emb},
+                )
+
+        if rows_emb:
+            if create_mode:
+                self.execute(
+                    """
+                    UNWIND $rows AS row
+                    MATCH (f:File {id: row.file_id})
+                    CREATE (s:Symbol {id: row.id, kind: row.kind, name: row.name,
+                                       fqname: row.fqname, file_id: row.file_id,
+                                       line: row.line, col: row.col, embedding: row.embedding})
+                    CREATE (f)-[:DECLARES]->(s)
+                    """,
+                    {"rows": rows_emb},
+                )
+            else:
+                self.execute(
+                    """
+                    UNWIND $rows AS row
+                    MATCH (f:File {id: row.file_id})
+                    MERGE (s:Symbol {id: row.id})
+                    SET s.kind = row.kind, s.name = row.name, s.fqname = row.fqname,
+                        s.file_id = row.file_id, s.line = row.line, s.col = row.col,
+                        s.embedding = row.embedding
+                    MERGE (f)-[:DECLARES]->(s)
+                    """,
+                    {"rows": rows_emb},
+                )
 
     def add_call(self, source_id: str, target_id: str, confidence: float, reason: str) -> None:
         self.execute(

{codespine-0.9.6 → codespine-0.9.7}/codespine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespine
-Version: 0.9.6
+Version: 0.9.7
 Summary: Local Java code intelligence indexer backed by a graph database
 Author: CodeSpine contributors
 License: MIT License

{codespine-0.9.6 → codespine-0.9.7}/codespine.egg-info/SOURCES.txt

@@ -60,4 +60,5 @@ tests/test_java_parser.py
 tests/test_multimodule_index.py
 tests/test_overlay.py
 tests/test_search_ranking.py
+tests/test_sharding.py
 tests/test_store_recovery.py

{codespine-0.9.6 → codespine-0.9.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codespine"
-version = "0.9.6"
+version = "0.9.7"
 description = "Local Java code intelligence indexer backed by a graph database"
 readme = "README.md"
 requires-python = ">=3.10"

codespine-0.9.7/tests/test_sharding.py

@@ -0,0 +1,200 @@
+"""Tests for sharding infrastructure: ShardRouter + ShardedGraphStore."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("kuzu")
+pytest.importorskip("tree_sitter_java")
+
+from codespine.sharding.router import ShardRouter
+from codespine.sharding.store import ShardedGraphStore
+from codespine.indexer.engine import JavaIndexer
+
+
+# ---------------------------------------------------------------------------
+# ShardRouter
+# ---------------------------------------------------------------------------
+
+
+def test_router_co_location():
+    """All modules of the same project must hash to the same shard."""
+    r = ShardRouter(num_shards=8)
+    root_shard = r.shard_for("myapp")
+    assert r.shard_for("myapp::module-a") == root_shard
+    assert r.shard_for("myapp::module-b") == root_shard
+    assert r.shard_for("myapp::module-c") == root_shard
+
+
+def test_router_single_shard_always_zero():
+    """With num_shards=1 every project must land on shard 0."""
+    r = ShardRouter(num_shards=1)
+    for pid in ["alpha", "beta", "gamma::sub", "delta"]:
+        assert r.shard_for(pid) == 0
+
+
+def test_router_distribution(tmp_path: Path):
+    """With 4 shards and many distinct projects, at least 2 shards get used."""
+    r = ShardRouter(num_shards=4)
+    projects = [f"project-{i}" for i in range(50)]
+    used_shards = {r.shard_for(p) for p in projects}
+    assert len(used_shards) >= 2, "Poor distribution — expected multiple shards to be used"
+
+
+def test_router_deterministic():
+    """Same project_id must always map to the same shard across instances."""
+    r1 = ShardRouter(num_shards=4)
+    r2 = ShardRouter(num_shards=4)
+    for pid in ["foo", "bar::baz", "qux"]:
+        assert r1.shard_for(pid) == r2.shard_for(pid)
+
+
+def test_router_paths(tmp_path: Path):
+    r = ShardRouter(num_shards=3, shards_dir=str(tmp_path / "shards"))
+    assert r.db_path(0).endswith("/0/db")
+    assert r.snapshot_path(1).endswith("/1/db_read")
+
+
+# ---------------------------------------------------------------------------
+# ShardedGraphStore — basic routing
+# ---------------------------------------------------------------------------
+
+
+def _write_java(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+
+
+def test_sharded_store_routes_modules_to_same_shard(tmp_path: Path):
+    """All modules of the same project must use the same GraphStore instance."""
+    sg = ShardedGraphStore(num_shards=4, shards_dir=str(tmp_path / "shards"))
+    store_a = sg.shard("myapp::module-a")
+    store_b = sg.shard("myapp::module-b")
+    store_c = sg.shard("myapp::module-c")
+    assert store_a is store_b
+    assert store_b is store_c
+    assert store_a._db_path == store_b._db_path
+
+
+def test_sharded_store_different_projects_may_differ(tmp_path: Path):
+    """Two unrelated projects may (and likely will) land on different stores."""
+    sg = ShardedGraphStore(num_shards=8, shards_dir=str(tmp_path / "shards"))
+    # Find two project IDs that hash to different shards.
+    router = sg.router
+    p1, p2 = None, None
+    for i in range(200):
+        pid = f"project-{i}"
+        if p1 is None:
+            p1 = pid
+        elif router.shard_for(pid) != router.shard_for(p1):
+            p2 = pid
+            break
+    if p2 is None:
+        pytest.skip("All 200 projects happened to hash to the same shard — skip")
+    store_1 = sg.shard(p1)
+    store_2 = sg.shard(p2)
+    assert store_1 is not store_2
+    assert store_1._db_path != store_2._db_path
+
+
+def test_sharded_store_list_projects_empty(tmp_path: Path):
+    sg = ShardedGraphStore(read_only=False, num_shards=2, shards_dir=str(tmp_path / "shards"))
+    # Force open all shards by reading — they're empty so result should be []
+    projects = sg.list_project_metadata()
+    assert projects == []
+
+
+# ---------------------------------------------------------------------------
+# Indexing via ShardedGraphStore
+# ---------------------------------------------------------------------------
+
+
+def test_index_single_project_via_sharded_store(tmp_path: Path):
+    """Indexing through ShardedGraphStore should produce queryable results."""
+    _write_java(
+        tmp_path / "src/main/java/com/example/Hello.java",
+        """
+        package com.example;
+        public class Hello {
+            public String greet(String name) { return "Hi " + name; }
+        }
+        """,
+    )
+
+    sg = ShardedGraphStore(num_shards=2, shards_dir=str(tmp_path / "shards"))
+    project_id = "hello-project"
+    shard_store = sg.shard(project_id)
+    result = JavaIndexer(shard_store).index_project(
+        str(tmp_path), full=True, project_id=project_id
+    )
+
+    assert result.files_indexed == 1
+    assert result.classes_indexed >= 1
+    assert result.methods_indexed >= 1
+
+    classes = shard_store.query_records(
+        "MATCH (c:Class) WHERE c.fqcn = $fqcn RETURN c.name as name",
+        {"fqcn": "com.example.Hello"},
+    )
+    assert classes, "Class not found in shard DB"
+    assert classes[0]["name"] == "Hello"
+
+    # list_project_metadata fan-out should find the project.
+    all_projects = sg.list_project_metadata()
+    assert any(p["id"] == project_id for p in all_projects)
+
+
+def test_two_projects_indexed_into_separate_shards(tmp_path: Path):
+    """When two projects land on different shards they're stored independently."""
+    _write_java(
+        tmp_path / "proj-a" / "src" / "main" / "java" / "a" / "A.java",
+        "package a; public class A { public void alpha() {} }",
+    )
+    _write_java(
+        tmp_path / "proj-b" / "src" / "main" / "java" / "b" / "B.java",
+        "package b; public class B { public void beta() {} }",
+    )
+
+    sg = ShardedGraphStore(num_shards=8, shards_dir=str(tmp_path / "shards"))
+    router = sg.router
+
+    # Find project IDs that will use different shards.
+    pid_a = "proj-a"
+    pid_b = None
+    for candidate in [f"project-alt-{i}" for i in range(100)]:
+        if router.shard_for(candidate) != router.shard_for(pid_a):
+            pid_b = candidate
+            break
+    if pid_b is None:
+        pytest.skip("Could not find two IDs hashing to different shards")
+
+    JavaIndexer(sg.shard(pid_a)).index_project(
+        str(tmp_path / "proj-a"), full=True, project_id=pid_a
+    )
+    JavaIndexer(sg.shard(pid_b)).index_project(
+        str(tmp_path / "proj-b"), full=True, project_id=pid_b
+    )
+
+    # Each shard should contain exactly one project.
+    store_a = sg.shard(pid_a)
+    store_b = sg.shard(pid_b)
+    assert store_a is not store_b
+
+    # Methods are visible only in their owning shard.
+    methods_a = store_a.query_records("MATCH (m:Method) RETURN m.name as name")
+    methods_b = store_b.query_records("MATCH (m:Method) RETURN m.name as name")
+    names_a = {m["name"] for m in methods_a}
+    names_b = {m["name"] for m in methods_b}
+    assert "alpha" in names_a
+    assert "beta" in names_b
+    # Cross-shard isolation: alpha not in shard B, beta not in shard A.
+    assert "beta" not in names_a
+    assert "alpha" not in names_b
+
+    # Fan-out list should see both.
+    all_projects = sg.list_project_metadata()
+    all_ids = {p["id"] for p in all_projects}
+    assert pid_a in all_ids
+    assert pid_b in all_ids