codespine 0.1.1__py3-none-any.whl

codespine/db/store.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Any
+
+import kuzu
+
+from codespine.config import SETTINGS
+from codespine.db.schema import ensure_schema
+
+LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class GraphStore:
+    read_only: bool = False
+
+    def __post_init__(self) -> None:
+        self.db = kuzu.Database(SETTINGS.db_path, buffer_pool_size=1024**3)
+        self.conn = kuzu.Connection(self.db)
+        if not self.read_only:
+            ensure_schema(self.conn)
+
+    @staticmethod
+    def stable_id(*parts: str) -> str:
+        raw = "::".join(parts)
+        return hashlib.sha1(raw.encode("utf-8")).hexdigest()
+
+    def execute(self, query: str, params: dict[str, Any] | None = None):
+        return self.conn.execute(query, params or {})
+
+    @contextmanager
+    def transaction(self):
+        tx_started = True
+        try:
+            self.execute("BEGIN TRANSACTION")
+        except Exception:
+            tx_started = False
+        try:
+            yield
+            if tx_started:
+                self.execute("COMMIT")
+        except Exception:
+            if tx_started:
+                self.execute("ROLLBACK")
+            raise
+
+    def clear_project(self, project_id: str) -> None:
+        # Keep project node and rebuild attached graph artifacts.
+        self.execute(
+            """
+            MATCH (s:Symbol), (f:File)
+            WHERE s.file_id = f.id AND f.project_id = $pid
+            DETACH DELETE s
+            """,
+            {"pid": project_id},
+        )
+        self.execute(
+            """
+            MATCH (m:Method), (c:Class), (f:File)
+            WHERE m.class_id = c.id AND c.file_id = f.id AND f.project_id = $pid
+            DETACH DELETE m
+            """,
+            {"pid": project_id},
+        )
+        self.execute(
+            """
+            MATCH (c:Class), (f:File)
+            WHERE c.file_id = f.id AND f.project_id = $pid
+            DETACH DELETE c
+            """,
+            {"pid": project_id},
+        )
+        self.execute(
+            """
+            MATCH (f:File) WHERE f.project_id = $pid
+            DETACH DELETE f
+            """,
+            {"pid": project_id},
+        )
+
+    def upsert_project(self, project_id: str, path: str) -> None:
+        self.execute(
+            "MERGE (p:Project {id: $id}) SET p.path = $path, p.language = 'java'",
+            {"id": project_id, "path": path},
+        )
+
+    def project_file_hashes(self, project_id: str) -> dict[str, dict[str, str]]:
+        recs = self.query_records(
+            """
+            MATCH (f:File)
+            WHERE f.project_id = $pid
+            RETURN f.id as id, f.path as path, f.hash as hash
+            """,
+            {"pid": project_id},
+        )
+        return {r["id"]: {"path": r.get("path", ""), "hash": r.get("hash", "")} for r in recs}
+
+    def clear_file(self, file_id: str) -> None:
+        self.execute(
+            """
+            MATCH (s:Symbol) WHERE s.file_id = $fid
+            DETACH DELETE s
+            """,
+            {"fid": file_id},
+        )
+        self.execute(
+            """
+            MATCH (m:Method), (c:Class)
+            WHERE m.class_id = c.id AND c.file_id = $fid
+            DETACH DELETE m
+            """,
+            {"fid": file_id},
+        )
+        self.execute(
+            """
+            MATCH (c:Class) WHERE c.file_id = $fid
+            DETACH DELETE c
+            """,
+            {"fid": file_id},
+        )
+        self.execute(
+            """
+            MATCH (f:File {id: $fid})
+            DETACH DELETE f
+            """,
+            {"fid": file_id},
+        )
+
+    def list_methods(self) -> list[dict[str, Any]]:
+        return self.query_records(
+            """
+            MATCH (m:Method), (c:Class)
+            WHERE m.class_id = c.id
+            RETURN m.id as method_id, m.name as name, m.signature as signature, c.fqcn as class_fqcn
+            """
+        )
+
+    def upsert_file(self, file_id: str, path: str, project_id: str, is_test: bool, digest: str) -> None:
+        self.execute(
+            """
+            MERGE (f:File {id: $id})
+            SET f.path = $path, f.project_id = $project_id, f.is_test = $is_test, f.hash = $hash
+            """,
+            {
+                "id": file_id,
+                "path": path,
+                "project_id": project_id,
+                "is_test": is_test,
+                "hash": digest,
+            },
+        )
+
+    def upsert_class(self, class_id: str, fqcn: str, name: str, package: str, file_id: str) -> None:
+        self.execute(
+            """
+            MERGE (c:Class {id: $id})
+            SET c.fqcn = $fqcn, c.name = $name, c.package = $package, c.file_id = $file_id
+            """,
+            {
+                "id": class_id,
+                "fqcn": fqcn,
+                "name": name,
+                "package": package,
+                "file_id": file_id,
+            },
+        )
+
+    def upsert_method(
+        self,
+        method_id: str,
+        class_id: str,
+        name: str,
+        signature: str,
+        return_type: str,
+        modifiers: list[str],
+        is_constructor: bool,
+        is_test: bool,
+    ) -> None:
+        self.execute(
+            """
+            MERGE (m:Method {id: $id})
+            SET m.class_id = $class_id,
+                m.name = $name,
+                m.signature = $signature,
+                m.return_type = $return_type,
+                m.modifiers = $modifiers,
+                m.is_constructor = $is_constructor,
+                m.is_test = $is_test
+            """,
+            {
+                "id": method_id,
+                "class_id": class_id,
+                "name": name,
+                "signature": signature,
+                "return_type": return_type,
+                "modifiers": modifiers,
+                "is_constructor": is_constructor,
+                "is_test": is_test,
+            },
+        )
+        self.execute(
+            "MATCH (c:Class {id: $cid}), (m:Method {id: $mid}) MERGE (c)-[:HAS_METHOD]->(m)",
+            {"cid": class_id, "mid": method_id},
+        )
+
+    def upsert_symbol(
+        self,
+        symbol_id: str,
+        kind: str,
+        name: str,
+        fqname: str,
+        file_id: str,
+        line: int,
+        col: int,
+        embedding: list[float] | None,
+    ) -> None:
+        self.execute(
+            """
+            MERGE (s:Symbol {id: $id})
+            SET s.kind = $kind,
+                s.name = $name,
+                s.fqname = $fqname,
+                s.file_id = $file_id,
+                s.line = $line,
+                s.col = $col,
+                s.embedding = $embedding
+            """,
+            {
+                "id": symbol_id,
+                "kind": kind,
+                "name": name,
+                "fqname": fqname,
+                "file_id": file_id,
+                "line": line,
+                "col": col,
+                "embedding": embedding,
+            },
+        )
+        self.execute(
+            "MATCH (f:File {id: $fid}), (s:Symbol {id: $sid}) MERGE (f)-[:DECLARES]->(s)",
+            {"fid": file_id, "sid": symbol_id},
+        )
+
+    def add_call(self, source_id: str, target_id: str, confidence: float, reason: str) -> None:
+        self.execute(
+            """
+            MATCH (source:Method {id: $source_id}), (target:Method {id: $target_id})
+            MERGE (source)-[:CALLS {confidence: $confidence, reason: $reason}]->(target)
+            """,
+            {
+                "source_id": source_id,
+                "target_id": target_id,
+                "confidence": confidence,
+                "reason": reason,
+            },
+        )
+
+    def add_reference(self, rel: str, src_label: str, src_id: str, dst_label: str, dst_id: str, confidence: float) -> None:
+        if rel not in {"REFERENCES_TYPE", "IMPLEMENTS", "OVERRIDES"}:
+            return
+        query = (
+            f"MATCH (s:{src_label} {{id: $src_id}}), (d:{dst_label} {{id: $dst_id}}) "
+            f"MERGE (s)-[:{rel} {{confidence: $confidence}}]->(d)"
+        )
+        self.execute(query, {"src_id": src_id, "dst_id": dst_id, "confidence": confidence})
+
+    def set_community(self, community_id: str, label: str, cohesion: float, symbol_ids: list[str]) -> None:
+        self.execute(
+            "MERGE (c:Community {id: $id}) SET c.label = $label, c.cohesion = $cohesion",
+            {"id": community_id, "label": label, "cohesion": cohesion},
+        )
+        for sid in symbol_ids:
+            self.execute(
+                "MATCH (s:Symbol {id: $sid}), (c:Community {id: $cid}) MERGE (s)-[:IN_COMMUNITY]->(c)",
+                {"sid": sid, "cid": community_id},
+            )
+
+    def set_flow(self, flow_id: str, entry_symbol_id: str, kind: str, symbols_at_depth: list[tuple[str, int]]) -> None:
+        self.execute(
+            "MERGE (f:Flow {id: $id}) SET f.entry_symbol_id = $entry, f.kind = $kind",
+            {"id": flow_id, "entry": entry_symbol_id, "kind": kind},
+        )
+        for sid, depth in symbols_at_depth:
+            self.execute(
+                "MATCH (s:Symbol {id: $sid}), (f:Flow {id: $fid}) MERGE (s)-[:IN_FLOW {depth: $depth}]->(f)",
+                {"sid": sid, "fid": flow_id, "depth": int(depth)},
+            )
+
+    def upsert_coupling(self, file_a: str, file_b: str, strength: float, cochanges: int, months: int) -> None:
+        self.execute(
+            """
+            MATCH (a:File {id: $a}), (b:File {id: $b})
+            MERGE (a)-[:CO_CHANGED_WITH {strength: $strength, cochanges: $cochanges, months: $months}]->(b)
+            """,
+            {
+                "a": file_a,
+                "b": file_b,
+                "strength": strength,
+                "cochanges": int(cochanges),
+                "months": int(months),
+            },
+        )
+
+    def query_records(self, query: str, params: dict[str, Any] | None = None) -> list[dict[str, Any]]:
+        frame = self.execute(query, params or {}).get_as_df()
+        if frame.empty:
+            return []
+        return json.loads(frame.to_json(orient="records"))

codespine/diff/__init__.py

@@ -0,0 +1 @@
+"""Branch diff layer."""

codespine/diff/branch_diff.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+
+import tree_sitter_java as tsjava
+from tree_sitter import Language, Parser, Query
+
+from codespine.indexer.java_parser import parse_java_source
+
+JAVA_LANGUAGE = Language(tsjava.language())
+PARSER = Parser(JAVA_LANGUAGE)
+
+
+def _text(node) -> str:
+    return node.text.decode("utf-8")
+
+
+def _hash_text(text: str) -> str:
+    return hashlib.sha1(_normalize_java_snippet(text).encode("utf-8")).hexdigest()
+
+
+def _normalize_java_snippet(text: str) -> str:
+    """Normalize formatting/comments so branch diff emphasizes semantic edits."""
+    text = re.sub(r"/\*.*?\*/", "", text, flags=re.DOTALL)
+    text = re.sub(r"//.*?$", "", text, flags=re.MULTILINE)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+
+def _method_hashes(source: bytes) -> dict[str, dict]:
+    tree = PARSER.parse(source)
+    root = tree.root_node
+    method_query = Query(
+        JAVA_LANGUAGE,
+        """
+        [
+          (method_declaration
+            name: (identifier) @name
+            parameters: (formal_parameters) @params) @decl
+          (constructor_declaration
+            name: (identifier) @name
+            parameters: (formal_parameters) @params) @decl
+        ]
+        """,
+    )
+    methods: dict[str, dict] = {}
+    grouped: dict[object, dict[str, str]] = {}
+    for node, tag in method_query.captures(root):
+        key_node = node if tag == "decl" else node.parent
+        grouped.setdefault(key_node, {})[tag] = _text(node)
+
+    for node, capture in grouped.items():
+        name = capture.get("name")
+        params = capture.get("params", "()")
+        if not name:
+            continue
+        signature = f"{name}{params}"
+        methods[signature] = {
+            "hash": _hash_text(_text(node)),
+            "line_start": node.start_point[0] + 1,
+            "line_end": node.end_point[0] + 1,
+        }
+    return methods
+
+
+def _class_hashes(source: bytes) -> dict[str, str]:
+    tree = PARSER.parse(source)
+    root = tree.root_node
+    class_query = Query(
+        JAVA_LANGUAGE,
+        """
+        (class_declaration
+          name: (identifier) @name) @decl
+        """,
+    )
+    grouped: dict[object, dict[str, str]] = {}
+    for node, tag in class_query.captures(root):
+        key_node = node if tag == "decl" else node.parent
+        grouped.setdefault(key_node, {})[tag] = _text(node)
+    out: dict[str, str] = {}
+    for node, capture in grouped.items():
+        name = capture.get("name")
+        if name:
+            out[name] = _hash_text(_text(node))
+    return out
+
+
+def _symbol_manifest(repo_path: str) -> dict[str, dict]:
+    manifest: dict[str, dict] = {}
+    for root, _, files in os.walk(repo_path):
+        if any(skip in root for skip in [".git", "target", "build", "out"]):
+            continue
+        for f in files:
+            if not f.endswith(".java"):
+                continue
+            path = os.path.join(root, f)
+            rel = os.path.relpath(path, repo_path)
+            with open(path, "rb") as fp:
+                source = fp.read()
+            parsed = parse_java_source(source)
+            method_hashes = _method_hashes(source)
+            class_hashes = _class_hashes(source)
+            for cls in parsed.classes:
+                cls_key = f"class:{cls.fqcn}"
+                manifest[cls_key] = {
+                    "kind": "Class",
+                    "file": rel,
+                    "name": cls.fqcn,
+                    "hash": class_hashes.get(cls.name, cls.body_hash),
+                    "line_start": cls.line,
+                }
+                for m in cls.methods:
+                    m_key = f"method:{cls.fqcn}#{m.signature}"
+                    mh = method_hashes.get(f"{m.name}({','.join(m.parameter_types)})") or method_hashes.get(m.signature) or {}
+                    manifest[m_key] = {
+                        "kind": "Method",
+                        "file": rel,
+                        "name": m.signature,
+                        "class": cls.fqcn,
+                        "hash": m.body_hash or mh.get("hash"),
+                        "line_start": mh.get("line_start", m.line),
+                        "line_end": mh.get("line_end", m.line),
+                    }
+    return manifest
+
+
+def compare_branches(repo_path: str, base_ref: str, head_ref: str) -> dict:
+    temp_dir = tempfile.mkdtemp(prefix="codespine-diff-")
+    base_dir = os.path.join(temp_dir, "base")
+    head_dir = os.path.join(temp_dir, "head")
+
+    try:
+        subprocess.run(["git", "-C", repo_path, "worktree", "add", "--detach", base_dir, base_ref], check=True, capture_output=True)
+        subprocess.run(["git", "-C", repo_path, "worktree", "add", "--detach", head_dir, head_ref], check=True, capture_output=True)
+
+        base_manifest = _symbol_manifest(base_dir)
+        head_manifest = _symbol_manifest(head_dir)
+
+        added = sorted(set(head_manifest) - set(base_manifest))
+        removed = sorted(set(base_manifest) - set(head_manifest))
+
+        modified = []
+        for key in sorted(set(base_manifest) & set(head_manifest)):
+            if json.dumps(base_manifest[key], sort_keys=True) != json.dumps(head_manifest[key], sort_keys=True):
+                modified.append(key)
+
+        return {
+            "base": base_ref,
+            "head": head_ref,
+            "added": [head_manifest[k] for k in added],
+            "removed": [base_manifest[k] for k in removed],
+            "modified": [head_manifest[k] for k in modified],
+        }
+    finally:
+        subprocess.run(["git", "-C", repo_path, "worktree", "remove", "--force", base_dir], check=False, capture_output=True)
+        subprocess.run(["git", "-C", repo_path, "worktree", "remove", "--force", head_dir], check=False, capture_output=True)
+        shutil.rmtree(temp_dir, ignore_errors=True)

codespine/indexer/__init__.py

@@ -0,0 +1 @@
+"""Indexing layer."""

codespine/indexer/call_resolver.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from collections import defaultdict
+
+from codespine.noise.blocklist import NOISE_METHOD_NAMES
+
+
+def _simple_type_name(type_name: str | None) -> str:
+    if not type_name:
+        return ""
+    base = type_name.strip().replace("[]", "")
+    return base.split(".")[-1]
+
+
+def _resolve_type_candidates(type_name: str | None, context: dict, class_catalog: dict[str, list[str]]) -> list[str]:
+    """Best-effort type resolution using fqcn/simple-name, imports, and package."""
+    if not type_name:
+        return []
+    resolved: list[str] = []
+    raw = type_name.strip()
+    simple = _simple_type_name(raw)
+
+    # Direct FQCN hint.
+    if "." in raw:
+        resolved.append(raw)
+
+    # Imported types.
+    imports = context.get("imports", []) or []
+    for imp in imports:
+        if imp.endswith(f".{simple}"):
+            resolved.append(imp)
+
+    # Same package fallback.
+    pkg = context.get("package", "")
+    if pkg:
+        resolved.append(f"{pkg}.{simple}")
+
+    # Indexed type matches by simple class name.
+    resolved.extend(class_catalog.get(simple, []))
+
+    # Stable unique order.
+    uniq: list[str] = []
+    seen = set()
+    for item in resolved:
+        if item and item not in seen:
+            uniq.append(item)
+            seen.add(item)
+    return uniq
+
+
+def resolve_calls(
+    method_catalog: dict[str, dict],
+    calls: dict[str, list],
+    method_context: dict[str, dict],
+    class_catalog: dict[str, list[str]],
+) -> list[tuple[str, str, float, str]]:
+    """Resolve call names to known method ids.
+
+    Returns 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))
+    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)
+
+    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", "")
+        local_types = src_ctx.get("local_types", {}) or {}
+        field_types = src_ctx.get("field_types", {}) or {}
+
+        for call in call_sites:
+            call_name = call.name
+            if call_name in NOISE_METHOD_NAMES:
+                continue
+
+            key = (call_name, int(call.arg_count))
+            targets: list[str] = []
+            confidence = 0.5
+            reason = "fuzzy_name_ambiguous"
+
+            receiver = (call.receiver or "").strip() if getattr(call, "receiver", None) else ""
+            if receiver:
+                receiver_type = None
+                receiver_is_this = False
+                if receiver == "this":
+                    receiver_type = src_class
+                    receiver_is_this = True
+                elif receiver in local_types:
+                    receiver_type = local_types[receiver]
+                elif receiver in field_types:
+                    receiver_type = field_types[receiver]
+                else:
+                    receiver_type = receiver
+
+                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, []))
+
+                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, [])
+                if in_class:
+                    targets = in_class
+                    confidence = 1.0
+                    reason = "intra_class_exact"
+
+            if not targets:
+                # Prefer same-package candidates before global fallback.
+                src_pkg = src_ctx.get("package", "")
+                same_pkg = []
+                for mid in name_arity_to_method_ids.get(key, []):
+                    fqcn = method_catalog.get(mid, {}).get("class_fqcn", "")
+                    if src_pkg and fqcn.startswith(f"{src_pkg}."):
+                        same_pkg.append(mid)
+                targets = same_pkg or name_arity_to_method_ids.get(key, [])
+                if len(targets) == 1:
+                    confidence = 1.0
+                    reason = "exact_name_arity_unique"
+                elif len(targets) > 1:
+                    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