codespine 0.1.7__tar.gz → 0.1.9__tar.gz

{codespine-0.1.7 → codespine-0.1.9}/PKG-INFO

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

{codespine-0.1.7 → codespine-0.1.9}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "0.1.7"
+__version__ = "0.1.9"

{codespine-0.1.7 → codespine-0.1.9}/codespine/cli.py

@@ -77,7 +77,7 @@ def main() -> None:
 
 @main.command()
 @click.argument("path", type=click.Path(exists=True))
-@click.option("--full/--incremental", default=True, show_default=True)
+@click.option("--full/--incremental", default=False, show_default=True)
 @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."""
@@ -89,7 +89,7 @@ def analyse(path: str, full: bool, deep: bool) -> None:
     abs_path = os.path.abspath(path)
     store = GraphStore(read_only=False)
     indexer = JavaIndexer(store)
-    parse_state = {"shown": False, "indexed": 0, "total": 0, "last_ts": 0.0}
+    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}
 
     def _progress(event: str, payload: dict) -> None:
@@ -105,6 +105,7 @@ def analyse(path: str, full: bool, deep: bool) -> None:
             _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))
@@ -149,7 +150,7 @@ def analyse(path: str, full: bool, deep: bool) -> None:
     result = indexer.index_project(abs_path, full=full, progress=_progress)
     if parse_state["shown"]:
         click.echo()
-    if parse_state["total"] == 0:
+    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']}")

{codespine-0.1.7 → codespine-0.1.9}/codespine/config.py

@@ -8,6 +8,7 @@ class Settings:
     pid_file: str = os.path.expanduser("~/.codespine.pid")
     log_file: str = os.path.expanduser("~/.codespine.log")
     embedding_cache_db: str = os.path.expanduser("~/.codespine_embedding_cache.sqlite3")
+    index_meta_dir: str = os.path.expanduser("~/.codespine_index_meta")
     embedding_model: str = "BAAI/bge-small-en-v1.5"
     vector_dim: int = 384
     rrf_k: int = 60

{codespine-0.1.7 → codespine-0.1.9}/codespine/indexer/call_resolver.py

@@ -62,16 +62,23 @@ def resolve_calls(
     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)
 
     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 {}
 
@@ -90,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]
@@ -102,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

{codespine-0.1.7 → codespine-0.1.9}/codespine/indexer/engine.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import json
 import os
 from dataclasses import dataclass
 from typing import Callable
 
+from codespine.config import SETTINGS
 from codespine.indexer.call_resolver import resolve_calls
 from codespine.indexer.java_parser import parse_java_source
 from codespine.indexer.symbol_builder import class_id, digest_bytes, file_id, method_id, symbol_id
@@ -37,21 +39,24 @@ class JavaIndexer:
         current_files = self._collect_java_files(root_path)
         self._emit(progress, "scan_done", files_found=len(current_files))
         db_files = self.store.project_file_hashes(project_id) if not full else {}
-        current_hashes = self._hash_files(project_id, root_path, current_files) if not full else {}
+        meta_cache = self._load_file_meta_cache(project_id)
+        current_file_ids = {
+            file_id(project_id, os.path.relpath(fp, root_path))
+            for fp in current_files
+        }
 
         if full:
             to_reindex = current_files
             deleted_file_ids = []
+            meta_cache = {}
         else:
-            to_reindex = []
-            deleted_file_ids = [fid for fid in db_files if fid not in current_hashes]
-            for file_path in current_files:
-                rel_path = os.path.relpath(file_path, root_path)
-                fid = file_id(project_id, rel_path)
-                digest = current_hashes[fid]
-                old = db_files.get(fid, {}).get("hash")
-                if old != digest:
-                    to_reindex.append(file_path)
+            to_reindex, deleted_file_ids, meta_cache = self._plan_incremental(
+                project_id,
+                root_path,
+                current_files,
+                db_files,
+                meta_cache,
+            )
         self._emit(
             progress,
             "plan_done",
@@ -59,6 +64,21 @@ class JavaIndexer:
             deleted_files=len(deleted_file_ids),
             mode="full" if full else "incremental",
         )
+        if not full and not to_reindex and not deleted_file_ids:
+            self._prune_meta_cache(meta_cache, current_file_ids)
+            self._save_file_meta_cache(project_id, meta_cache)
+            self._emit(progress, "resolve_calls_done", calls_resolved=0)
+            self._emit(progress, "resolve_types_done", type_relationships=0)
+            return IndexResult(
+                project_id=project_id,
+                files_found=len(current_files),
+                files_indexed=0,
+                classes_indexed=0,
+                methods_indexed=0,
+                calls_resolved=0,
+                type_relationships=0,
+                embeddings_generated=0,
+            )
 
         files_indexed = 0
         classes_indexed = 0
@@ -70,6 +90,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,32 +105,40 @@ 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()
 
                 parsed = parse_java_source(source)
                 f_id = file_id(project_id, rel_path)
+                file_digest = digest_bytes(source)
                 if not full:
                     # Drop old symbols/methods/classes for changed files before reinserting.
                     self.store.clear_file(f_id)
-                self.store.upsert_file(f_id, file_path, project_id, is_test, digest_bytes(source))
+                self.store.upsert_file(f_id, file_path, project_id, is_test, file_digest)
+                self._update_meta_cache_entry(meta_cache, f_id, file_path, file_digest, len(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 +152,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 +165,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 +183,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,
@@ -182,9 +213,17 @@ class JavaIndexer:
             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)
 
+        self._prune_meta_cache(meta_cache, current_file_ids)
+        self._save_file_meta_cache(project_id, meta_cache)
+
         return IndexResult(
             project_id=project_id,
             files_found=len(current_files),
@@ -210,22 +249,59 @@ class JavaIndexer:
                     out.append(os.path.join(root, filename))
         return out
 
-    @staticmethod
-    def _hash_files(project_id: str, root_path: str, files: list[str]) -> dict[str, str]:
-        hashes: dict[str, str] = {}
-        for fp in files:
-            rel = os.path.relpath(fp, root_path)
-            fid = file_id(project_id, rel)
-            with open(fp, "rb") as f:
-                hashes[fid] = digest_bytes(f.read())
-        return hashes
+    def _plan_incremental(
+        self,
+        project_id: str,
+        root_path: str,
+        files: list[str],
+        db_files: dict[str, dict[str, str]],
+        meta_cache: dict[str, dict],
+    ) -> tuple[list[str], list[str], dict[str, dict]]:
+        current_ids = {
+            file_id(project_id, os.path.relpath(fp, root_path))
+            for fp in files
+        }
+        deleted_file_ids = [fid for fid in db_files if fid not in current_ids]
+        to_reindex: list[str] = []
+
+        for file_path in files:
+            rel_path = os.path.relpath(file_path, root_path)
+            fid = file_id(project_id, rel_path)
+            old_hash = db_files.get(fid, {}).get("hash")
+            try:
+                st = os.stat(file_path)
+            except OSError:
+                continue
+            mtime_ns = int(getattr(st, "st_mtime_ns", int(st.st_mtime * 1_000_000_000)))
+            size = int(st.st_size)
+            cached = meta_cache.get(fid, {})
+
+            if (
+                cached
+                and int(cached.get("mtime_ns", -1)) == mtime_ns
+                and int(cached.get("size", -1)) == size
+                and cached.get("hash")
+                and cached.get("hash") == old_hash
+            ):
+                continue
+
+            with open(file_path, "rb") as f:
+                digest = digest_bytes(f.read())
+            meta_cache[fid] = {"mtime_ns": mtime_ns, "size": size, "hash": digest}
+            if old_hash != digest:
+                to_reindex.append(file_path)
+
+        for fid in deleted_file_ids:
+            meta_cache.pop(fid, None)
+
+        return to_reindex, deleted_file_ids, meta_cache
 
     def _existing_method_catalog(self, project_id: str) -> dict[str, dict]:
         recs = self.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.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},
         )
@@ -239,9 +315,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(
             """
@@ -263,14 +360,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
@@ -302,38 +402,98 @@ 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
+    def _meta_cache_path(project_id: str) -> str:
+        base = SETTINGS.index_meta_dir
+        try:
+            os.makedirs(base, exist_ok=True)
+        except OSError:
+            base = "/tmp/.codespine_index_meta"
+            os.makedirs(base, exist_ok=True)
+        return os.path.join(base, f"{project_id}.json")
+
+    def _load_file_meta_cache(self, project_id: str) -> dict[str, dict]:
+        path = self._meta_cache_path(project_id)
+        if not os.path.exists(path):
+            return {}
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            if isinstance(data, dict):
+                return data
+        except (OSError, ValueError, TypeError):
+            return {}
+        return {}
+
+    def _save_file_meta_cache(self, project_id: str, data: dict[str, dict]) -> None:
+        path = self._meta_cache_path(project_id)
+        tmp_path = f"{path}.tmp"
+        try:
+            with open(tmp_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, separators=(",", ":"))
+            os.replace(tmp_path, path)
+        except OSError:
+            return
+
+    @staticmethod
+    def _update_meta_cache_entry(meta_cache: dict[str, dict], fid: str, file_path: str, digest: str, size_hint: int) -> None:
+        try:
+            st = os.stat(file_path)
+            mtime_ns = int(getattr(st, "st_mtime_ns", int(st.st_mtime * 1_000_000_000)))
+            size = int(st.st_size)
+        except OSError:
+            mtime_ns = -1
+            size = size_hint
+        meta_cache[fid] = {"mtime_ns": mtime_ns, "size": size, "hash": digest}
+
+    @staticmethod
+    def _prune_meta_cache(meta_cache: dict[str, dict], current_file_ids: set[str]) -> None:
+        for fid in list(meta_cache.keys()):
+            if fid not in current_file_ids:
+                del meta_cache[fid]
+
     @staticmethod
     def _emit(progress: Callable[[str, dict], None] | None, event: str, **payload: object) -> None:
         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.9/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.7 → codespine-0.1.9}/codespine.egg-info/PKG-INFO

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

{codespine-0.1.7 → codespine-0.1.9}/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.7 → codespine-0.1.9}/pyproject.toml

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

codespine-0.1.9/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.7 → codespine-0.1.9}/tests/test_index_and_hybrid.py

@@ -19,3 +19,16 @@ def test_index_and_hybrid_search():
     results = hybrid_search(store, "process payment", k=5)
     assert results
     assert any("processPayment" in (r.get("fqname") or "") for r in results)
+
+
+def test_incremental_no_change_reindexes_zero_files():
+    fixture = Path(__file__).parent / "fixtures" / "java_simple"
+    store = GraphStore(read_only=False)
+    indexer = JavaIndexer(store)
+
+    first = indexer.index_project(str(fixture), full=True)
+    second = indexer.index_project(str(fixture), full=False)
+
+    assert first.files_found >= 2
+    assert second.files_found == first.files_found
+    assert second.files_indexed == 0

codespine-0.1.9/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.7/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.7/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