codespine 0.1.5__tar.gz → 0.1.8__tar.gz

{codespine-0.1.5 → codespine-0.1.8}/PKG-INFO

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

{codespine-0.1.5 → codespine-0.1.8}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "0.1.5"
+__version__ = "0.1.8"

{codespine-0.1.5 → codespine-0.1.8}/codespine/cli.py

@@ -78,7 +78,8 @@ def main() -> None:
 @main.command()
 @click.argument("path", type=click.Path(exists=True))
 @click.option("--full/--incremental", default=True, show_default=True)
-def analyse(path: str, full: bool) -> None:
+@click.option("--deep/--no-deep", default=False, show_default=True, help="Run expensive global analyses.")
+def analyse(path: str, full: bool, deep: bool) -> None:
     """Index a local Java project."""
     if _is_running():
         click.secho("Stop MCP first ('codespine stop') to index.", fg="yellow")
@@ -89,6 +90,7 @@ def analyse(path: str, full: bool) -> None:
     store = GraphStore(read_only=False)
     indexer = JavaIndexer(store)
     parse_state = {"shown": False, "indexed": 0, "total": 0, "last_ts": 0.0}
+    call_state = {"shown": False, "count": 0, "last_ts": 0.0}
 
     def _progress(event: str, payload: dict) -> None:
         now = time.perf_counter()
@@ -119,6 +121,29 @@ def analyse(path: str, full: bool) -> None:
         if event == "resolve_calls_start" and parse_state["shown"]:
             click.echo()
             parse_state["shown"] = False
+            _phase("Tracing calls...", "running")
+            return
+        if event == "resolve_calls_start":
+            _phase("Tracing calls...", "running")
+            return
+        if event == "resolve_calls_progress":
+            call_state["count"] = int(payload.get("calls_resolved", 0))
+            if (now - call_state["last_ts"]) >= 0.25:
+                click.echo(f"\rTracing calls...               {call_state['count']} resolved", 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
+            _phase("Tracing calls...", f"{int(payload.get('calls_resolved', 0))} calls resolved")
+            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
 
     result = indexer.index_project(abs_path, full=full, progress=_progress)
@@ -128,27 +153,37 @@ def analyse(path: str, full: bool) -> None:
         _phase("Parsing code...", "0/0")
     elif parse_state["indexed"] < parse_state["total"]:
         _phase("Parsing code...", f"{parse_state['indexed']}/{parse_state['total']}")
-    _phase("Tracing calls...", f"{result.calls_resolved} calls resolved")
-    _phase("Analyzing types...", f"{result.type_relationships} type relationships")
-
-    communities = detect_communities(store)
-    _phase("Detecting communities...", f"{len(communities)} clusters found")
 
-    flows = trace_execution_flows(store)
-    _phase("Detecting execution flows...", f"{len(flows)} processes found")
-
-    dead = detect_dead_code(store, limit=500)
-    _phase("Finding dead code...", f"{len(dead)} unreachable symbols")
-
-    coupling_pairs = compute_coupling(
-        store,
-        abs_path,
-        result.project_id,
-        months=SETTINGS.default_coupling_months,
-        min_strength=SETTINGS.default_min_coupling_strength,
-        min_cochanges=SETTINGS.default_min_cochanges,
-    )
-    _phase("Analyzing git history...", f"{len(coupling_pairs)} coupled file pairs")
+    communities: list[dict] = []
+    flows: list[dict] = []
+    dead: list[dict] = []
+    coupling_pairs: list[dict] = []
+
+    should_run_deep = deep or result.files_found <= 1200
+    if should_run_deep:
+        communities = detect_communities(store)
+        _phase("Detecting communities...", f"{len(communities)} clusters found")
+
+        flows = trace_execution_flows(store)
+        _phase("Detecting execution flows...", f"{len(flows)} processes found")
+
+        dead = detect_dead_code(store, limit=500)
+        _phase("Finding dead code...", f"{len(dead)} unreachable symbols")
+
+        coupling_pairs = compute_coupling(
+            store,
+            abs_path,
+            result.project_id,
+            months=SETTINGS.default_coupling_months,
+            min_strength=SETTINGS.default_min_coupling_strength,
+            min_cochanges=SETTINGS.default_min_cochanges,
+        )
+        _phase("Analyzing git history...", f"{len(coupling_pairs)} coupled file pairs")
+    else:
+        _phase("Detecting communities...", "skipped (large repo; rerun with --deep)")
+        _phase("Detecting execution flows...", "skipped (large repo; rerun with --deep)")
+        _phase("Finding dead code...", "skipped (large repo; rerun with --deep)")
+        _phase("Analyzing git history...", "skipped (large repo; rerun with --deep)")
 
     vector_count = store.query_records(
         """

{codespine-0.1.5 → codespine-0.1.8}/codespine/indexer/call_resolver.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from typing import Iterator
 
 from codespine.noise.blocklist import NOISE_METHOD_NAMES
 
+MAX_FUZZY_TARGETS = 12
+
 
 def _simple_type_name(type_name: str | None) -> str:
     if not type_name:
@@ -53,23 +56,29 @@ def resolve_calls(
     calls: dict[str, list],
     method_context: dict[str, dict],
     class_catalog: dict[str, list[str]],
-) -> list[tuple[str, str, float, str]]:
+) -> Iterator[tuple[str, str, float, str]]:
     """Resolve call names to known method ids.
 
-    Returns tuples: (source_method_id, target_method_id, confidence, reason)
+    Yields tuples: (source_method_id, target_method_id, confidence, reason)
     """
     name_arity_to_method_ids: dict[tuple[str, int], list[str]] = defaultdict(list)
-    class_method_index: dict[str, dict[tuple[str, int], list[str]]] = defaultdict(lambda: defaultdict(list))
+    class_method_index_by_id: dict[str, dict[tuple[str, int], list[str]]] = defaultdict(lambda: defaultdict(list))
+    class_method_index_by_fqcn: dict[str, dict[tuple[str, int], list[str]]] = defaultdict(lambda: defaultdict(list))
     for method_id, meta in method_catalog.items():
         key = (meta["name"], int(meta["param_count"]))
         name_arity_to_method_ids[key].append(method_id)
-        class_method_index[meta["class_fqcn"]][key].append(method_id)
+        class_id = meta.get("class_id", "")
+        class_fqcn = meta.get("class_fqcn", "")
+        if class_id:
+            class_method_index_by_id[class_id][key].append(method_id)
+        if class_fqcn:
+            class_method_index_by_fqcn[class_fqcn][key].append(method_id)
 
-    edges: list[tuple[str, str, float, str]] = []
     for source_id, call_sites in calls.items():
         src_meta = method_catalog.get(source_id, {})
         src_ctx = method_context.get(source_id, {})
-        src_class = src_meta.get("class_fqcn", "")
+        src_class_id = src_meta.get("class_id", "") or src_ctx.get("class_id", "")
+        src_class_fqcn = src_meta.get("class_fqcn", "")
         local_types = src_ctx.get("local_types", {}) or {}
         field_types = src_ctx.get("field_types", {}) or {}
 
@@ -88,7 +97,7 @@ def resolve_calls(
                 receiver_type = None
                 receiver_is_this = False
                 if receiver == "this":
-                    receiver_type = src_class
+                    receiver_type = src_class_fqcn
                     receiver_is_this = True
                 elif receiver in local_types:
                     receiver_type = local_types[receiver]
@@ -100,14 +109,14 @@ def resolve_calls(
                 receiver_fqcn_candidates = _resolve_type_candidates(receiver_type, src_ctx, class_catalog)
 
                 for fqcn in receiver_fqcn_candidates:
-                    targets.extend(class_method_index.get(fqcn, {}).get(key, []))
+                    targets.extend(class_method_index_by_fqcn.get(fqcn, {}).get(key, []))
 
                 if targets:
                     confidence = 1.0 if receiver_is_this else 0.8
                     reason = "receiver_this_exact" if receiver_is_this else "receiver_method_match"
 
             if not targets:
-                in_class = class_method_index.get(src_class, {}).get(key, [])
+                in_class = class_method_index_by_id.get(src_class_id, {}).get(key, [])
                 if in_class:
                     targets = in_class
                     confidence = 1.0
@@ -126,12 +135,13 @@ def resolve_calls(
                     confidence = 1.0
                     reason = "exact_name_arity_unique"
                 elif len(targets) > 1:
+                    if len(targets) > MAX_FUZZY_TARGETS:
+                        # Avoid exploding low-confidence edges in large repos.
+                        continue
                     confidence = 0.5
                     reason = "fuzzy_name_arity_ambiguous"
 
             if not targets:
                 continue
-            for target_id in targets:
-                edges.append((source_id, target_id, confidence, reason))
-
-    return edges
+            for target_id in set(targets):
+                yield source_id, target_id, confidence, reason

{codespine-0.1.5 → codespine-0.1.8}/codespine/indexer/engine.py

@@ -70,6 +70,7 @@ class JavaIndexer:
         method_calls: dict[str, list] = {}
         method_context: dict[str, dict] = {}
         class_catalog: dict[str, list[str]] = self._existing_class_catalog(project_id) if not full else {}
+        fqcn_to_class_ids: dict[str, list[str]] = self._existing_class_ids_by_fqcn(project_id) if not full else {}
         class_meta: dict[str, dict] = {}
         class_methods: dict[str, dict[str, str]] = self._existing_class_methods(project_id) if not full else {}
 
@@ -84,6 +85,7 @@ class JavaIndexer:
             for file_path in to_reindex:
                 rel_path = os.path.relpath(file_path, root_path)
                 is_test = "src/test/java" in file_path.replace("\\", "/")
+                scope = self._scope_from_rel_path(rel_path)
 
                 with open(file_path, "rb") as f:
                     source = f.read()
@@ -96,20 +98,25 @@ class JavaIndexer:
                 self.store.upsert_file(f_id, file_path, project_id, is_test, digest_bytes(source))
 
                 for cls in parsed.classes:
-                    c_id = class_id(cls.fqcn)
+                    c_id = class_id(cls.fqcn, scope)
                     self.store.upsert_class(c_id, cls.fqcn, cls.name, cls.package, f_id)
                     class_catalog.setdefault(cls.name, [])
                     if cls.fqcn not in class_catalog[cls.name]:
                         class_catalog[cls.name].append(cls.fqcn)
-                    class_meta[cls.fqcn] = {
+                    fqcn_to_class_ids.setdefault(cls.fqcn, [])
+                    if c_id not in fqcn_to_class_ids[cls.fqcn]:
+                        fqcn_to_class_ids[cls.fqcn].append(c_id)
+                    class_meta[c_id] = {
+                        "fqcn": cls.fqcn,
                         "package": parsed.package,
                         "imports": parsed.imports,
                         "extends": cls.extends,
                         "interfaces": cls.interfaces,
+                        "scope": scope,
                     }
-                    class_methods.setdefault(cls.fqcn, {})
+                    class_methods.setdefault(c_id, {})
 
-                    cls_symbol_id = symbol_id("class", cls.fqcn)
+                    cls_symbol_id = symbol_id("class", cls.fqcn, scope)
                     self.store.upsert_symbol(
                         symbol_id=cls_symbol_id,
                         kind="class",
@@ -123,7 +130,7 @@ class JavaIndexer:
                     classes_indexed += 1
 
                     for method in cls.methods:
-                        m_id = method_id(cls.fqcn, method.signature)
+                        m_id = method_id(cls.fqcn, method.signature, scope)
                         self.store.upsert_method(
                             method_id=m_id,
                             class_id=c_id,
@@ -136,7 +143,7 @@ class JavaIndexer:
                         )
 
                         fqname = f"{cls.fqcn}#{method.signature}"
-                        m_symbol_id = symbol_id("method", fqname)
+                        m_symbol_id = symbol_id("method", fqname, scope)
                         self.store.upsert_symbol(
                             symbol_id=m_symbol_id,
                             kind="method",
@@ -154,16 +161,18 @@ class JavaIndexer:
                             "name": method.name,
                             "param_count": len(method.parameter_types),
                             "class_fqcn": cls.fqcn,
+                            "class_id": c_id,
                         }
                         method_calls[m_id] = method.calls
                         method_context[m_id] = {
+                            "class_id": c_id,
                             "class_fqcn": cls.fqcn,
                             "local_types": method.local_types,
                             "field_types": cls.field_types,
                             "imports": parsed.imports,
                             "package": parsed.package,
                         }
-                        class_methods[cls.fqcn][method.signature] = m_id
+                        class_methods[c_id][method.signature] = m_id
                 files_indexed += 1
                 self._emit(
                     progress,
@@ -177,10 +186,17 @@ class JavaIndexer:
             for src, dst, confidence, reason in resolve_calls(method_catalog, method_calls, method_context, class_catalog):
                 self.store.add_call(src, dst, confidence, reason)
                 calls_resolved += 1
+                if calls_resolved % 2000 == 0:
+                    self._emit(progress, "resolve_calls_progress", calls_resolved=calls_resolved)
             self._emit(progress, "resolve_calls_done", calls_resolved=calls_resolved)
 
             self._emit(progress, "resolve_types_start")
-            type_relationships += self._build_inheritance_edges(class_meta, class_catalog, class_methods)
+            type_relationships += self._build_inheritance_edges(
+                class_meta,
+                class_catalog,
+                class_methods,
+                fqcn_to_class_ids,
+            )
             self._emit(progress, "resolve_types_done", type_relationships=type_relationships)
 
         return IndexResult(
@@ -223,7 +239,7 @@ class JavaIndexer:
             """
             MATCH (m:Method), (c:Class), (f:File)
             WHERE m.class_id = c.id AND c.file_id = f.id AND f.project_id = $pid
-            RETURN m.id as method_id, m.name as name, m.signature as signature, c.fqcn as class_fqcn
+            RETURN m.id as method_id, m.name as name, m.signature as signature, c.fqcn as class_fqcn, c.id as class_id
             """,
             {"pid": project_id},
         )
@@ -237,9 +253,30 @@ class JavaIndexer:
                 "name": r.get("name", ""),
                 "param_count": param_count,
                 "class_fqcn": r.get("class_fqcn", ""),
+                "class_id": r.get("class_id", ""),
             }
         return out
 
+    def _existing_class_ids_by_fqcn(self, project_id: str) -> dict[str, list[str]]:
+        recs = self.store.query_records(
+            """
+            MATCH (c:Class), (f:File)
+            WHERE c.file_id = f.id AND f.project_id = $pid
+            RETURN c.fqcn as fqcn, c.id as class_id
+            """,
+            {"pid": project_id},
+        )
+        out: dict[str, list[str]] = {}
+        for r in recs:
+            fqcn = r.get("fqcn", "")
+            cid = r.get("class_id", "")
+            if not fqcn or not cid:
+                continue
+            out.setdefault(fqcn, [])
+            if cid not in out[fqcn]:
+                out[fqcn].append(cid)
+        return out
+
     def _existing_class_catalog(self, project_id: str) -> dict[str, list[str]]:
         recs = self.store.query_records(
             """
@@ -261,14 +298,17 @@ class JavaIndexer:
             """
             MATCH (m:Method), (c:Class), (f:File)
             WHERE m.class_id = c.id AND c.file_id = f.id AND f.project_id = $pid
-            RETURN c.fqcn as fqcn, m.signature as signature, m.id as method_id
+            RETURN c.id as class_id, m.signature as signature, m.id as method_id
             """,
             {"pid": project_id},
         )
         out: dict[str, dict[str, str]] = {}
         for r in recs:
-            out.setdefault(r["fqcn"], {})
-            out[r["fqcn"]][r["signature"]] = r["method_id"]
+            class_key = r.get("class_id")
+            if not class_key:
+                continue
+            out.setdefault(class_key, {})
+            out[class_key][r["signature"]] = r["method_id"]
         return out
 
     @staticmethod
@@ -300,34 +340,34 @@ class JavaIndexer:
         class_meta: dict[str, dict],
         class_catalog: dict[str, list[str]],
         class_methods: dict[str, dict[str, str]],
+        fqcn_to_class_ids: dict[str, list[str]],
     ) -> int:
         rel_count = 0
-        for fqcn, meta in class_meta.items():
-            src_id = class_id(fqcn)
+        for src_id, meta in class_meta.items():
             ctx = {"package": meta.get("package", ""), "imports": meta.get("imports", [])}
 
             parent_candidates = self._resolve_type_candidates(meta.get("extends"), ctx, class_catalog)
             for parent_fqcn in parent_candidates:
-                dst_id = class_id(parent_fqcn)
-                self.store.add_reference("IMPLEMENTS", "Class", src_id, "Class", dst_id, 0.8)
-                rel_count += 1
-                for sig, method_id in class_methods.get(fqcn, {}).items():
-                    parent_method = class_methods.get(parent_fqcn, {}).get(sig)
-                    if parent_method:
-                        self.store.add_reference("OVERRIDES", "Method", method_id, "Method", parent_method, 1.0)
-                        rel_count += 1
+                for dst_id in fqcn_to_class_ids.get(parent_fqcn, []):
+                    self.store.add_reference("IMPLEMENTS", "Class", src_id, "Class", dst_id, 0.8)
+                    rel_count += 1
+                    for sig, method_id in class_methods.get(src_id, {}).items():
+                        parent_method = class_methods.get(dst_id, {}).get(sig)
+                        if parent_method:
+                            self.store.add_reference("OVERRIDES", "Method", method_id, "Method", parent_method, 1.0)
+                            rel_count += 1
 
             for iface in meta.get("interfaces", []):
                 iface_candidates = self._resolve_type_candidates(iface, ctx, class_catalog)
                 for iface_fqcn in iface_candidates:
-                    dst_id = class_id(iface_fqcn)
-                    self.store.add_reference("IMPLEMENTS", "Class", src_id, "Class", dst_id, 1.0)
-                    rel_count += 1
-                    for sig, method_id in class_methods.get(fqcn, {}).items():
-                        iface_method = class_methods.get(iface_fqcn, {}).get(sig)
-                        if iface_method:
-                            self.store.add_reference("OVERRIDES", "Method", method_id, "Method", iface_method, 1.0)
-                            rel_count += 1
+                    for dst_id in fqcn_to_class_ids.get(iface_fqcn, []):
+                        self.store.add_reference("IMPLEMENTS", "Class", src_id, "Class", dst_id, 1.0)
+                        rel_count += 1
+                        for sig, method_id in class_methods.get(src_id, {}).items():
+                            iface_method = class_methods.get(dst_id, {}).get(sig)
+                            if iface_method:
+                                self.store.add_reference("OVERRIDES", "Method", method_id, "Method", iface_method, 1.0)
+                                rel_count += 1
         return rel_count
 
     @staticmethod
@@ -335,3 +375,13 @@ class JavaIndexer:
         if progress is None:
             return
         progress(event, payload)
+
+    @staticmethod
+    def _scope_from_rel_path(rel_path: str) -> str:
+        normalized = rel_path.replace("\\", "/")
+        if "/java/" in normalized:
+            return normalized.split("/java/", 1)[0]
+        if "/src/" in normalized:
+            return normalized.split("/src/", 1)[0]
+        scope = os.path.dirname(normalized).strip()
+        return scope or "."

codespine-0.1.8/codespine/indexer/symbol_builder.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+
+
+@dataclass
+class SymbolRef:
+    symbol_id: str
+    method_id: str
+    class_id: str
+    file_id: str
+
+
+def digest_bytes(payload: bytes) -> str:
+    return hashlib.sha1(payload).hexdigest()
+
+
+def file_id(project_id: str, rel_path: str) -> str:
+    return hashlib.sha1(f"{project_id}:{rel_path}".encode("utf-8")).hexdigest()
+
+
+def class_id(fqcn: str, scope: str | None = None) -> str:
+    key = f"{scope}::{fqcn}" if scope else fqcn
+    return hashlib.sha1(key.encode("utf-8")).hexdigest()
+
+
+def method_id(fqcn: str, signature: str, scope: str | None = None) -> str:
+    key = f"{scope}::{fqcn}#{signature}" if scope else f"{fqcn}#{signature}"
+    return hashlib.sha1(key.encode("utf-8")).hexdigest()
+
+
+def symbol_id(kind: str, fqname: str, scope: str | None = None) -> str:
+    key = f"{kind}:{scope}:{fqname}" if scope else f"{kind}:{fqname}"
+    return hashlib.sha1(key.encode("utf-8")).hexdigest()

{codespine-0.1.5 → codespine-0.1.8}/codespine.egg-info/PKG-INFO

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

{codespine-0.1.5 → codespine-0.1.8}/codespine.egg-info/SOURCES.txt

@@ -44,4 +44,5 @@ tests/test_branch_diff_normalize.py
 tests/test_call_resolver.py
 tests/test_index_and_hybrid.py
 tests/test_java_parser.py
+tests/test_multimodule_index.py
 tests/test_search_ranking.py

{codespine-0.1.5 → codespine-0.1.8}/pyproject.toml

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

codespine-0.1.8/tests/test_call_resolver.py

@@ -0,0 +1,43 @@
+from types import SimpleNamespace
+
+from codespine.indexer.call_resolver import resolve_calls
+
+
+def test_resolver_prefers_receiver_type_and_arity():
+    method_catalog = {
+        "src": {
+            "name": "entry",
+            "param_count": 0,
+            "class_id": "c_service",
+            "class_fqcn": "com.example.Service",
+            "signature": "entry()",
+        },
+        "m1": {"name": "run", "param_count": 0, "class_id": "c_service", "class_fqcn": "com.example.Service", "signature": "run()"},
+        "m2": {
+            "name": "run",
+            "param_count": 1,
+            "class_id": "c_service",
+            "class_fqcn": "com.example.Service",
+            "signature": "run(String)",
+        },
+        "m3": {"name": "save", "param_count": 0, "class_id": "c_repo", "class_fqcn": "com.example.Repo", "signature": "save()"},
+    }
+    calls = {
+        "src": [
+            SimpleNamespace(name="run", receiver="this", arg_count=0),
+            SimpleNamespace(name="save", receiver="repo", arg_count=0),
+        ]
+    }
+    method_context = {
+        "src": {
+            "class_id": "c_service",
+            "class_fqcn": "com.example.Service",
+            "local_types": {"repo": "Repo"},
+            "field_types": {},
+        }
+    }
+    class_catalog = {"Service": ["com.example.Service"], "Repo": ["com.example.Repo"]}
+
+    out = list(resolve_calls(method_catalog, calls, method_context, class_catalog))
+    assert ("src", "m1", 1.0, "receiver_this_exact") in out
+    assert ("src", "m3", 0.8, "receiver_method_match") in out

codespine-0.1.8/tests/test_multimodule_index.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("kuzu")
+pytest.importorskip("tree_sitter_java")
+
+from codespine.db.store import GraphStore
+from codespine.indexer.engine import JavaIndexer
+
+
+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_multimodule_duplicate_fqcn_is_indexed_without_collision(tmp_path: Path):
+    _write_java(
+        tmp_path / "module-a" / "src" / "main" / "java" / "com" / "example" / "App.java",
+        """
+        package com.example;
+        public class App { public void fromA() {} }
+        """,
+    )
+    _write_java(
+        tmp_path / "module-b" / "src" / "main" / "java" / "com" / "example" / "App.java",
+        """
+        package com.example;
+        public class App { public void fromB() {} }
+        """,
+    )
+
+    store = GraphStore(read_only=False)
+    result = JavaIndexer(store).index_project(str(tmp_path), full=True)
+
+    classes = store.query_records(
+        """
+        MATCH (c:Class), (f:File)
+        WHERE c.file_id = f.id AND f.project_id = $pid AND c.fqcn = $fqcn
+        RETURN c.id as id, f.path as path
+        """,
+        {"pid": result.project_id, "fqcn": "com.example.App"},
+    )
+    methods = store.query_records(
+        """
+        MATCH (m:Method), (c:Class), (f:File)
+        WHERE m.class_id = c.id AND c.file_id = f.id AND f.project_id = $pid
+        RETURN m.name as name
+        """,
+        {"pid": result.project_id},
+    )
+
+    assert len(classes) == 2
+    assert len({c["id"] for c in classes}) == 2
+    assert {"fromA", "fromB"}.issubset({m["name"] for m in methods})

codespine-0.1.5/codespine/indexer/symbol_builder.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-from dataclasses import dataclass
-
-
-@dataclass
-class SymbolRef:
-    symbol_id: str
-    method_id: str
-    class_id: str
-    file_id: str
-
-
-def digest_bytes(payload: bytes) -> str:
-    return hashlib.sha1(payload).hexdigest()
-
-
-def file_id(project_id: str, rel_path: str) -> str:
-    return hashlib.sha1(f"{project_id}:{rel_path}".encode("utf-8")).hexdigest()
-
-
-def class_id(fqcn: str) -> str:
-    return hashlib.sha1(fqcn.encode("utf-8")).hexdigest()
-
-
-def method_id(fqcn: str, signature: str) -> str:
-    return hashlib.sha1(f"{fqcn}#{signature}".encode("utf-8")).hexdigest()
-
-
-def symbol_id(kind: str, fqname: str) -> str:
-    return hashlib.sha1(f"{kind}:{fqname}".encode("utf-8")).hexdigest()

codespine-0.1.5/tests/test_call_resolver.py

@@ -1,30 +0,0 @@
-from types import SimpleNamespace
-
-from codespine.indexer.call_resolver import resolve_calls
-
-
-def test_resolver_prefers_receiver_type_and_arity():
-    method_catalog = {
-        "src": {"name": "entry", "param_count": 0, "class_fqcn": "com.example.Service", "signature": "entry()"},
-        "m1": {"name": "run", "param_count": 0, "class_fqcn": "com.example.Service", "signature": "run()"},
-        "m2": {"name": "run", "param_count": 1, "class_fqcn": "com.example.Service", "signature": "run(String)"},
-        "m3": {"name": "save", "param_count": 0, "class_fqcn": "com.example.Repo", "signature": "save()"},
-    }
-    calls = {
-        "src": [
-            SimpleNamespace(name="run", receiver="this", arg_count=0),
-            SimpleNamespace(name="save", receiver="repo", arg_count=0),
-        ]
-    }
-    method_context = {
-        "src": {
-            "class_fqcn": "com.example.Service",
-            "local_types": {"repo": "Repo"},
-            "field_types": {},
-        }
-    }
-    class_catalog = {"Service": ["com.example.Service"], "Repo": ["com.example.Repo"]}
-
-    out = resolve_calls(method_catalog, calls, method_context, class_catalog)
-    assert ("src", "m1", 1.0, "receiver_this_exact") in out
-    assert ("src", "m3", 0.8, "receiver_method_match") in out