codespine 0.1.2__tar.gz → 0.1.4__tar.gz

{codespine-0.1.2 → codespine-0.1.4}/PKG-INFO

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

{codespine-0.1.2 → codespine-0.1.4}/codespine/db/store.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import hashlib
 import json
 import logging
+import os
 from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import Any
@@ -20,7 +21,13 @@ class GraphStore:
     read_only: bool = False
 
     def __post_init__(self) -> None:
-        self.db = kuzu.Database(SETTINGS.db_path, buffer_pool_size=1024**3)
+        db_path = SETTINGS.db_path
+        try:
+            self.db = kuzu.Database(db_path, buffer_pool_size=1024**3)
+        except Exception as exc:
+            fallback = os.path.join("/tmp", ".codespine_db")
+            LOGGER.warning("Primary DB path failed (%s). Falling back to %s", exc, fallback)
+            self.db = kuzu.Database(fallback, buffer_pool_size=1024**3)
         self.conn = kuzu.Connection(self.db)
         if not self.read_only:
             ensure_schema(self.conn)

{codespine-0.1.2 → codespine-0.1.4}/codespine/diff/branch_diff.py

@@ -21,6 +21,59 @@ def _text(node) -> str:
     return node.text.decode("utf-8")
 
 
+def _captures(query: Query, node) -> list[tuple]:
+    if hasattr(query, "captures"):
+        return query.captures(node)
+
+    from tree_sitter import QueryCursor
+
+    raw = None
+    try:
+        cursor = QueryCursor(query)
+        if hasattr(cursor, "captures"):
+            raw = cursor.captures(node)
+    except TypeError:
+        raw = None
+
+    if raw is None:
+        cursor = QueryCursor()
+        for call in (
+            lambda: cursor.captures(query, node),
+            lambda: cursor.captures(node, query),
+        ):
+            try:
+                raw = call()
+                break
+            except TypeError:
+                continue
+    if raw is None:
+        return []
+    if isinstance(raw, dict):
+        out: list[tuple] = []
+        for tag, nodes in raw.items():
+            for n in nodes:
+                out.append((n, tag))
+        return out
+    out: list[tuple] = []
+    for item in raw:
+        if not isinstance(item, (tuple, list)) or len(item) < 2:
+            continue
+        n, t = item[0], item[1]
+        if isinstance(t, int):
+            tag = None
+            for attr in ("capture_name_for_id", "capture_name"):
+                if hasattr(query, attr):
+                    try:
+                        tag = getattr(query, attr)(t)
+                        break
+                    except Exception:
+                        pass
+            out.append((n, tag if tag else str(t)))
+        else:
+            out.append((n, t))
+    return out
+
+
 def _hash_text(text: str) -> str:
     return hashlib.sha1(_normalize_java_snippet(text).encode("utf-8")).hexdigest()
 
@@ -30,6 +83,7 @@ def _normalize_java_snippet(text: str) -> str:
     text = re.sub(r"/\*.*?\*/", "", text, flags=re.DOTALL)
     text = re.sub(r"//.*?$", "", text, flags=re.MULTILINE)
     text = re.sub(r"\s+", " ", text).strip()
+    text = re.sub(r"\s*([{}();,])\s*", r"\1", text)
     return text
 
 
@@ -51,7 +105,7 @@ def _method_hashes(source: bytes) -> dict[str, dict]:
     )
     methods: dict[str, dict] = {}
     grouped: dict[object, dict[str, str]] = {}
-    for node, tag in method_query.captures(root):
+    for node, tag in _captures(method_query, root):
         key_node = node if tag == "decl" else node.parent
         grouped.setdefault(key_node, {})[tag] = _text(node)
 
@@ -80,7 +134,7 @@ def _class_hashes(source: bytes) -> dict[str, str]:
         """,
     )
     grouped: dict[object, dict[str, str]] = {}
-    for node, tag in class_query.captures(root):
+    for node, tag in _captures(class_query, root):
         key_node = node if tag == "decl" else node.parent
         grouped.setdefault(key_node, {})[tag] = _text(node)
     out: dict[str, str] = {}

{codespine-0.1.2 → codespine-0.1.4}/codespine/indexer/java_parser.py

@@ -62,6 +62,66 @@ def _text(node) -> str:
     return node.text.decode("utf-8")
 
 
+def _captures(query: Query, node) -> list[tuple]:
+    """Compatibility wrapper for tree-sitter Python bindings."""
+    if hasattr(query, "captures"):
+        return query.captures(node)
+
+    from tree_sitter import QueryCursor
+
+    raw = None
+    # API shape A: QueryCursor(query).captures(node)
+    try:
+        cursor = QueryCursor(query)
+        if hasattr(cursor, "captures"):
+            raw = cursor.captures(node)
+    except TypeError:
+        raw = None
+
+    # API shape B/C: QueryCursor().captures(...)
+    if raw is None:
+        cursor = QueryCursor()
+        for call in (
+            lambda: cursor.captures(query, node),
+            lambda: cursor.captures(node, query),
+        ):
+            try:
+                raw = call()
+                break
+            except TypeError:
+                continue
+
+    if raw is None:
+        return []
+
+    # Newer bindings may return {capture_name: [nodes...]}
+    if isinstance(raw, dict):
+        out: list[tuple] = []
+        for tag, nodes in raw.items():
+            for n in nodes:
+                out.append((n, tag))
+        return out
+
+    out: list[tuple] = []
+    for item in raw:
+        if not isinstance(item, (tuple, list)) or len(item) < 2:
+            continue
+        n, t = item[0], item[1]
+        if isinstance(t, int):
+            tag = None
+            for attr in ("capture_name_for_id", "capture_name"):
+                if hasattr(query, attr):
+                    try:
+                        tag = getattr(query, attr)(t)
+                        break
+                    except Exception:
+                        pass
+            out.append((n, tag if tag else str(t)))
+        else:
+            out.append((n, t))
+    return out
+
+
 def _hash_node(node) -> str:
     return hashlib.sha1(_normalize_java_bytes(node.text).encode("utf-8")).hexdigest()
 
@@ -122,7 +182,7 @@ def _extract_local_types(method_node) -> dict[str, str]:
           declarator: (variable_declarator name: (identifier) @name))
         """,
     )
-    captures = q.captures(method_node)
+    captures = _captures(q, method_node)
     locals_map: dict[str, str] = {}
     current_type = None
     for node, tag in captures:
@@ -142,7 +202,7 @@ def _extract_field_types(class_node) -> dict[str, str]:
           declarator: (variable_declarator name: (identifier) @name))
         """,
     )
-    captures = q.captures(class_node)
+    captures = _captures(q, class_node)
     field_map: dict[str, str] = {}
     current_type = None
     for node, tag in captures:
@@ -156,16 +216,16 @@ def _extract_field_types(class_node) -> dict[str, str]:
 def _extract_parameter_types(params_node) -> list[str]:
     if params_node is None:
         return []
-    q = Query(
-        JAVA_LANGUAGE,
-        """
-        [
-          (formal_parameter type: (_) @ptype)
-          (spread_parameter type: (_) @ptype)
-        ]
-        """,
-    )
-    return [_node_type_name(node) for node, tag in q.captures(params_node) if tag == "ptype"]
+    types: list[str] = []
+    for child in params_node.named_children:
+        if child.type in {"formal_parameter", "spread_parameter"}:
+            tnode = child.child_by_field_name("type")
+            types.append(_node_type_name(tnode))
+        elif child.type == "receiver_parameter":
+            # Keep receiver as pseudo-type to stabilize signature arity
+            tnode = child.child_by_field_name("type")
+            types.append(_node_type_name(tnode))
+    return [t for t in types if t]
 
 
 def _extract_inheritance(class_node) -> tuple[str | None, list[str]]:
@@ -189,7 +249,7 @@ def _extract_inheritance(class_node) -> tuple[str | None, list[str]]:
             ]
             """,
         )
-        interfaces = [_node_type_name(n) for n, tag in type_query.captures(iface_node) if tag == "t"]
+        interfaces = [_node_type_name(n) for n, tag in _captures(type_query, iface_node) if tag == "t"]
 
     # Fallback for grammar variants where interfaces are not exposed as a field.
     if not interfaces:
@@ -206,7 +266,7 @@ def _extract_inheritance(class_node) -> tuple[str | None, list[str]]:
                     ]
                     """,
                 )
-                interfaces.extend([_node_type_name(n) for n, tag in type_query.captures(child) if tag == "t"])
+                interfaces.extend([_node_type_name(n) for n, tag in _captures(type_query, child) if tag == "t"])
 
     return extends_name, interfaces
 
@@ -229,12 +289,12 @@ def parse_java_source(source: bytes) -> ParsedFile:
     package_name = ""
     imports: list[str] = []
 
-    for node, tag in pkg_query.captures(root):
+    for node, tag in _captures(pkg_query, root):
         if tag == "pkg":
             package_name = _text(node)
             break
 
-    for node, tag in import_query.captures(root):
+    for node, tag in _captures(import_query, root):
         if tag == "imp":
             imports.append(_text(node))
 
@@ -267,7 +327,7 @@ def parse_java_source(source: bytes) -> ParsedFile:
         """,
     )
 
-    for node, tag in cls_query.captures(root):
+    for node, tag in _captures(cls_query, root):
         if tag != "class_decl":
             continue
 
@@ -292,8 +352,8 @@ def parse_java_source(source: bytes) -> ParsedFile:
             body_hash=_hash_node(node),
         )
 
-        method_nodes = [n for n, t in method_query.captures(node) if t == "method_decl"]
-        method_nodes.extend([n for n, t in ctor_query.captures(node) if t == "method_decl"])
+        method_nodes = [n for n, t in _captures(method_query, node) if t == "method_decl"]
+        method_nodes.extend([n for n, t in _captures(ctor_query, node) if t == "method_decl"])
 
         for m_node in method_nodes:
             m_name_node = m_node.child_by_field_name("name")
@@ -323,7 +383,7 @@ def parse_java_source(source: bytes) -> ParsedFile:
             body_node = m_node.child_by_field_name("body")
             if body_node is not None:
                 grouped: dict[object, dict[str, str]] = {}
-                for c_node, c_tag in call_query.captures(body_node):
+                for c_node, c_tag in _captures(call_query, body_node):
                     inv_node = c_node if c_tag == "call_inv" else c_node.parent
                     grouped.setdefault(inv_node, {})[c_tag] = _text(c_node)
                 for inv_node, capture_map in grouped.items():

{codespine-0.1.2 → codespine-0.1.4}/codespine/search/vector.py

@@ -35,7 +35,16 @@ def _load_model():
 
 @lru_cache(maxsize=1)
 def _embedding_cache_conn():
-    conn = sqlite3.connect(SETTINGS.embedding_cache_db)
+    path = SETTINGS.embedding_cache_db
+    try:
+        os_dir = path.rsplit("/", 1)[0] if "/" in path else ""
+        if os_dir:
+            import os
+
+            os.makedirs(os_dir, exist_ok=True)
+        conn = sqlite3.connect(path)
+    except Exception:
+        conn = sqlite3.connect("/tmp/.codespine_embedding_cache.sqlite3")
     conn.execute(
         """
         CREATE TABLE IF NOT EXISTS embedding_cache (

{codespine-0.1.2 → codespine-0.1.4}/codespine.egg-info/PKG-INFO

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

{codespine-0.1.2 → codespine-0.1.4}/pyproject.toml

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

{codespine-0.1.2 → codespine-0.1.4}/tests/test_java_parser.py

@@ -25,4 +25,4 @@ def test_parse_java_methods_and_calls():
     methods = {m.name: m for m in parsed.classes[0].methods}
     assert "processPayment" in methods
     assert "helper" in methods
-    assert "helper" in methods["processPayment"].calls
+    assert any(call.name == "helper" for call in methods["processPayment"].calls)