codespine 0.9.8__tar.gz → 0.9.9__tar.gz

{codespine-0.9.8 → codespine-0.9.9}/PKG-INFO

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

{codespine-0.9.8 → codespine-0.9.9}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "0.9.8"
+__version__ = "0.9.9"

codespine-0.9.9/codespine/cache/__init__.py

@@ -0,0 +1,4 @@
+"""Result caching for MCP tools."""
+from codespine.cache.result_cache import ResultCache
+
+__all__ = ["ResultCache"]

codespine-0.9.9/codespine/cache/result_cache.py

@@ -0,0 +1,167 @@
+"""LRU result cache for CodeSpine MCP tools.
+
+Avoids recomputing expensive analyses (impact BFS, dead-code scan, community
+lookup) when the same arguments are passed and the underlying index hasn't
+changed since the last call.
+
+Cache key: ``(tool_name, args_hash, snapshot_mtime_rounded)``
+  - ``tool_name`` — the MCP tool that produced the result
+  - ``args_hash`` — SHA-1 of the JSON-serialised arguments (sorted keys)
+  - ``snapshot_mtime_rounded`` — read-replica mtime rounded to 1 s, so a new
+    snapshot invalidates all cached results for the affected store
+
+TTL: entries are evicted after ``ttl_s`` seconds (default 300 s / 5 min) even
+if the cache isn't full, preventing stale results across long sessions.
+
+Usage
+-----
+    from codespine.cache.result_cache import ResultCache
+
+    _cache = ResultCache(maxsize=256, ttl_s=300.0)
+
+    key = _cache.make_key("get_impact", {"symbol": "Foo", "project": "myapp"}, mtime)
+    cached = _cache.get(key)
+    if cached is not None:
+        return cached
+    result = expensive_computation(...)
+    _cache.put(key, result)
+    return result
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import threading
+import time
+from collections import OrderedDict
+from typing import Any
+
+
+class ResultCache:
+    """Thread-safe LRU cache for pre-serialised JSON tool results.
+
+    Parameters
+    ----------
+    maxsize:
+        Maximum number of entries to keep.  Oldest entry is evicted when
+        the cache is full (LRU eviction).
+    ttl_s:
+        Time-to-live in seconds.  Entries older than this are treated as
+        missing even if they're still in the cache.
+    """
+
+    def __init__(self, maxsize: int = 256, ttl_s: float = 300.0) -> None:
+        self._maxsize = maxsize
+        self._ttl = ttl_s
+        # OrderedDict preserves insertion order: oldest → newest
+        self._cache: OrderedDict[tuple, tuple[str, float]] = OrderedDict()
+        self._lock = threading.Lock()
+        self._hits = 0
+        self._misses = 0
+
+    # ------------------------------------------------------------------
+    # Key construction
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def make_key(
+        tool_name: str,
+        args: dict[str, Any],
+        snapshot_mtime: float,
+    ) -> tuple:
+        """Build a cache key from tool name, arguments, and index timestamp.
+
+        Parameters
+        ----------
+        tool_name:
+            Name of the MCP tool (e.g. ``"get_impact"``).
+        args:
+            Tool arguments dict (``None`` values included so missing optional
+            args don't collide with explicitly-set ones).
+        snapshot_mtime:
+            Last-modified time of the read-replica sentinel file, rounded to
+            1-second precision.  A new snapshot invalidates old entries.
+        """
+        try:
+            args_bytes = json.dumps(args, sort_keys=True, default=str).encode()
+        except Exception:
+            args_bytes = str(args).encode()
+        args_hash = hashlib.sha1(args_bytes).hexdigest()[:16]
+        return (tool_name, args_hash, round(snapshot_mtime, 0))
+
+    # ------------------------------------------------------------------
+    # Cache operations
+    # ------------------------------------------------------------------
+
+    def get(self, key: tuple) -> str | None:
+        """Return the cached value for *key*, or ``None`` if missing/expired."""
+        with self._lock:
+            if key not in self._cache:
+                self._misses += 1
+                return None
+            value, inserted_at = self._cache[key]
+            if time.monotonic() - inserted_at > self._ttl:
+                del self._cache[key]
+                self._misses += 1
+                return None
+            # Promote to most-recently-used position.
+            self._cache.move_to_end(key)
+            self._hits += 1
+            return value
+
+    def put(self, key: tuple, value: str) -> None:
+        """Store *value* under *key*.  Evicts LRU entry if cache is full."""
+        with self._lock:
+            if key in self._cache:
+                self._cache.move_to_end(key)
+            self._cache[key] = (value, time.monotonic())
+            # Evict oldest entries until we're within maxsize.
+            while len(self._cache) > self._maxsize:
+                self._cache.popitem(last=False)
+
+    def invalidate(self) -> int:
+        """Clear the entire cache.  Call after any index mutation.
+
+        Returns the number of entries evicted.
+        """
+        with self._lock:
+            n = len(self._cache)
+            self._cache.clear()
+            return n
+
+    def invalidate_tool(self, tool_name: str) -> int:
+        """Evict all entries for a specific tool.
+
+        Returns the number of entries removed.
+        """
+        with self._lock:
+            keys_to_remove = [k for k in self._cache if k[0] == tool_name]
+            for k in keys_to_remove:
+                del self._cache[k]
+            return len(keys_to_remove)
+
+    # ------------------------------------------------------------------
+    # Stats / introspection
+    # ------------------------------------------------------------------
+
+    def stats(self) -> dict[str, Any]:
+        """Return cache statistics (size, hit/miss counts, hit rate)."""
+        with self._lock:
+            total = self._hits + self._misses
+            return {
+                "size": len(self._cache),
+                "maxsize": self._maxsize,
+                "ttl_s": self._ttl,
+                "hits": self._hits,
+                "misses": self._misses,
+                "hit_rate": round(self._hits / total, 3) if total else 0.0,
+            }
+
+    def __repr__(self) -> str:  # pragma: no cover
+        s = self.stats()
+        return (
+            f"ResultCache(size={s['size']}/{s['maxsize']}, "
+            f"hits={s['hits']}, misses={s['misses']}, "
+            f"hit_rate={s['hit_rate']:.1%})"
+        )

{codespine-0.9.8 → codespine-0.9.9}/codespine/cli.py

@@ -293,7 +293,13 @@ def main() -> None:
 @main.command()
 @click.argument("path", type=click.Path(exists=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.")
+@click.option("--deep/--no-deep", default=False, show_default=True, help="Run expensive global analyses (auto-on for repos ≤3 k files).")
+@click.option(
+    "--incremental-deep",
+    is_flag=True,
+    default=False,
+    help="Force deep analysis even during incremental re-index. Useful after large refactors.",
+)
 @click.option(
     "--embed/--no-embed",
     default=True,
@@ -301,7 +307,7 @@ def main() -> None:
     help="Generate vector embeddings. Uses sentence-transformers if installed (pip install codespine[ml]), otherwise falls back to hash-based vectors.",
 )
 @click.option("--allow-running", is_flag=True, hidden=True, help="Skip MCP running check (used by MCP analyse_project tool).")
-def analyse(path: str, full: bool, deep: bool, embed: bool, allow_running: bool) -> None:
+def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bool, allow_running: bool) -> None:
     """Index a local Java project (auto-detects workspace / Maven / Gradle layout).
 
     Embeddings are generated by default. If sentence-transformers is installed
@@ -459,7 +465,7 @@ def analyse(path: str, full: bool, deep: bool, embed: bool, allow_running: bool)
     dead: list[dict] = []
     coupling_pairs: list[dict] = []
 
-    should_run_deep = deep or total_files_found <= 1200
+    should_run_deep = deep or incremental_deep or total_files_found <= 3000
     if should_run_deep:
         comm_label = "Detecting communities..."
         _live_phase(comm_label, "running")
@@ -1138,6 +1144,36 @@ def stop() -> None:
             os.remove(SETTINGS.pid_file)
 
 
+@main.command("install-model")
+def install_model() -> None:
+    """Download and cache the sentence-transformers embedding model.
+
+    Requires 'pip install codespine[ml]'. The model is downloaded once and
+    cached locally; subsequent analyse runs use the cache without network access.
+    """
+    try:
+        from sentence_transformers import SentenceTransformer  # noqa: F401
+    except ImportError:
+        click.secho(
+            "sentence-transformers is not installed.\n"
+            "Run: pip install codespine[ml]",
+            fg="red",
+        )
+        return
+
+    model_name = SETTINGS.embedding_model
+    click.secho(f"Downloading model '{model_name}' …", fg="cyan")
+    try:
+        from sentence_transformers import SentenceTransformer
+
+        model = SentenceTransformer(model_name)
+        # Run a tiny inference to confirm the model is usable.
+        _ = model.encode(["hello world"])
+        click.secho(f"✓ Model '{model_name}' ready. Semantic search is now enabled.", fg="green")
+    except Exception as exc:
+        click.secho(f"✗ Failed to load model: {exc}", fg="red")
+
+
 @main.command("run-mcp", hidden=True)
 def run_mcp() -> None:
     """Run MCP server in stdio mode."""

{codespine-0.9.8 → codespine-0.9.9}/codespine/mcp/server.py

@@ -30,6 +30,7 @@ from codespine.watch.watcher import (
     get_overlay_status as get_overlay_status_state,
     promote_overlay as promote_overlay_state,
 )
+from codespine.cache.result_cache import ResultCache
 
 
 def _json(data: dict) -> str:
@@ -271,6 +272,49 @@ def build_mcp_server(store, repo_path_provider):
     _watch: dict = {"proc": None, "path": None, "started_at": None, "interval": 30}
     _analyse: dict = {"proc": None, "path": None, "started_at": None, "log_path": None, "returncode": None}
 
+    # Per-server result cache (FR-12): LRU cache keyed by (tool, args_hash, snapshot_mtime).
+    # Invalidated automatically when the read replica sentinel file changes.
+    _result_cache = ResultCache(maxsize=256, ttl_s=300.0)
+
+    def _cache_key(tool_name: str, **kwargs):
+        """Build a cache key using current snapshot mtime."""
+        try:
+            sentinel = getattr(store, "_snapshot_path", "") + ".updated"
+            mtime = os.path.getmtime(sentinel) if os.path.exists(sentinel) else 0.0
+        except OSError:
+            mtime = 0.0
+        return ResultCache.make_key(tool_name, kwargs, mtime)
+
+    # FR-03: Auto-start watch if indexed projects exist and watch is not running.
+    def _maybe_auto_start_watch() -> None:
+        try:
+            projs = store.query_records(
+                "MATCH (p:Project) RETURN p.path as path, p.id as id ORDER BY p.indexed_at DESC LIMIT 1"
+            )
+            if not projs:
+                return
+            watch_path = projs[0].get("path", "")
+            if not watch_path or not os.path.isdir(watch_path):
+                return
+            # Start watch as a background subprocess (same as start_watch tool).
+            cmd = [sys.executable, "-m", "codespine.cli", "watch", watch_path,
+                   "--interval", "30", "--allow-running"]
+            proc = subprocess.Popen(
+                cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+            _watch["proc"] = proc
+            _watch["path"] = watch_path
+            _watch["started_at"] = time.time()
+            _LOGGER.info("Auto-started watch on %s (pid %d)", watch_path, proc.pid)
+        except Exception as exc:
+            _LOGGER.debug("Auto-watch skipped: %s", exc)
+
+    # Trigger auto-watch in a daemon thread so server startup isn't delayed.
+    import threading as _threading
+    _auto_watch_thread = _threading.Thread(target=_maybe_auto_start_watch, daemon=True, name="codespine-auto-watch")
+    _auto_watch_thread.start()
+
     # ------------------------------------------------------------------
     # Connectivity / feature discovery
     # ------------------------------------------------------------------
@@ -526,6 +570,10 @@ def build_mcp_server(store, repo_path_provider):
         project scopes the target symbol lookup; cross-project callers are always included.
         """
         try:
+            _ck = _cache_key("get_impact", symbol=symbol, max_depth=max_depth, project=project)
+            _cached = _result_cache.get(_ck)
+            if _cached is not None:
+                return _cached
             normalized = _normalize_symbol_input(symbol)
             result = analyze_impact(store, normalized, max_depth=max_depth, project=project)
             if not result.get("resolved_to"):
@@ -533,7 +581,9 @@ def build_mcp_server(store, repo_path_provider):
                 result = analyze_impact(store, symbol, max_depth=max_depth, project=project)
             if not result.get("resolved_to"):
                 return {"available": False, "note": f"Symbol '{symbol}' not found in the index."}
-            return _staleness_meta(store, {"available": True, **result}, project, overlay_store=overlay_store)
+            out = _staleness_meta(store, {"available": True, **result}, project, overlay_store=overlay_store)
+            _result_cache.put(_ck, out)
+            return out
         except Exception as exc:
             return _safe_tool_response("get_impact", exc)
 
@@ -558,6 +608,11 @@ def build_mcp_server(store, repo_path_provider):
         exemption rules — useful for validating that the feature is working
         even when the dead list is empty.
         """
+        _ck = _cache_key("detect_dead_code", limit=limit, project=project, strict=strict)
+        _cached = _result_cache.get(_ck)
+        if _cached is not None:
+            return _cached
+
         raw = detect_dead_code_analysis(store, limit=limit, project=project, strict=strict)
         if raw is None:
             return _no_symbols_response()
@@ -571,12 +626,14 @@ def build_mcp_server(store, repo_path_provider):
             else:
                 dead.append(entry)
 
-        return _staleness_meta(store, {
+        out = _staleness_meta(store, {
             "available": True,
             "dead_code": dead,
             "count": len(dead),
             "exemption_stats": stats,
         }, project, overlay_store=overlay_store, deep_scope=True)
+        _result_cache.put(_ck, out)
+        return out
 
     @mcp.tool()
     def trace_execution_flows(entry_symbol: str | None = None, max_depth: int = 6, project: str | None = None):
@@ -1722,6 +1779,12 @@ def build_mcp_server(store, repo_path_provider):
                 enriched.append(entry)
             return enriched
 
+        target_pid = target["project_id"]
+        enriched_callers = _enrich(callers, extra_keys=["confidence", "reason"])
+        # FR-11: label cross-project callers so consumers can separate them.
+        local_callers = [c for c in enriched_callers if c.get("project_id") == target_pid]
+        cross_project_callers = [c for c in enriched_callers if c.get("project_id") != target_pid]
+
         result = {
             "available": True,
             "target": {
@@ -1730,9 +1793,10 @@ def build_mcp_server(store, repo_path_provider):
                 "signature": target["signature"],
                 "class_fqcn": target["class_fqcn"],
                 "file_path": target["file_path"],
-                "project_id": target["project_id"],
+                "project_id": target_pid,
             },
-            "callers": _enrich(callers, extra_keys=["confidence", "reason"]),
+            "callers": local_callers,
+            "cross_project_callers": cross_project_callers,
             "callees": _enrich(callees, extra_keys=["confidence", "reason"]),
             "siblings": [
                 {"name": s["name"], "signature": s["signature"]}
@@ -1741,7 +1805,8 @@ def build_mcp_server(store, repo_path_provider):
             "overrides": _enrich(overrides_up),
             "overridden_by": _enrich(overrides_down),
             "summary": {
-                "callers": len(callers),
+                "callers": len(local_callers),
+                "cross_project_callers": len(cross_project_callers),
                 "callees": len(callees),
                 "siblings": len(siblings),
                 "overrides": len(overrides_up),
@@ -2668,6 +2733,166 @@ def build_mcp_server(store, repo_path_provider):
         except Exception as exc:
             return _safe_tool_response("find_pattern", exc)
 
+    # ------------------------------------------------------------------
+    # rename_plan  (FR-11 / Phase 5)
+    # ------------------------------------------------------------------
+
+    @mcp.tool()
+    def rename_plan(symbol: str, new_name: str, project: str | None = None):
+        """
+        Safe cross-project rename plan for a method, class, or field.
+
+        Finds all references to the symbol (callers, overrides, interface
+        declarations, direct mentions) and returns a structured list of
+        files_to_modify with the current text and suggested replacement.
+
+        This tool does NOT modify files — it produces a plan that you (or your
+        editor) can apply.  Review the plan before making changes.
+
+        Parameters:
+          symbol   – Method name, class name, or FQN to rename.
+          new_name – The desired new name (simple name, not FQN).
+          project  – Optional project scope for the initial symbol lookup.
+        """
+        try:
+            normalized = _normalize_symbol_input(symbol)
+            project_clause = "AND f.project_id = $proj" if project else ""
+            params: dict = {"q": normalized, "raw": symbol}
+            if project:
+                params["proj"] = project
+
+            # 1. Resolve to methods + classes with the given name.
+            method_recs = store.query_records(
+                f"""
+                MATCH (m:Method), (c:Class), (f:File)
+                WHERE m.class_id = c.id AND c.file_id = f.id {project_clause}
+                  AND (m.id = $q OR m.id = $raw
+                       OR lower(m.name) = lower($q)
+                       OR lower(m.signature) CONTAINS lower($q))
+                RETURN m.id as id, m.name as name, m.signature as signature,
+                       c.fqcn as class_fqcn, f.path as file_path,
+                       f.project_id as project_id, 'method' as kind
+                LIMIT 20
+                """,
+                params,
+            )
+            class_recs = store.query_records(
+                f"""
+                MATCH (c:Class), (f:File)
+                WHERE c.file_id = f.id {project_clause}
+                  AND (c.id = $q OR c.id = $raw
+                       OR lower(c.name) = lower($q) OR lower(c.fqcn) = lower($q))
+                RETURN c.id as id, c.name as name, c.fqcn as class_fqcn,
+                       f.path as file_path, f.project_id as project_id, 'class' as kind
+                LIMIT 10
+                """,
+                params,
+            )
+
+            all_targets = method_recs + class_recs
+            if not all_targets:
+                return {
+                    "available": False,
+                    "note": f"Symbol '{symbol}' not found. Try find_symbol() first.",
+                }
+
+            # 2. Collect all files that declare or reference the targets.
+            target_ids = [r["id"] for r in all_targets]
+            declaration_files: dict[str, dict] = {}  # file_path → info
+
+            # Declaration sites.
+            for rec in all_targets:
+                fp = rec.get("file_path", "")
+                if fp:
+                    declaration_files.setdefault(fp, {
+                        "file_path": fp,
+                        "project_id": rec.get("project_id"),
+                        "changes": [],
+                    })["changes"].append({
+                        "kind": "declaration",
+                        "symbol_kind": rec.get("kind", "method"),
+                        "current_name": rec.get("name", symbol),
+                        "suggested_name": new_name,
+                        "note": f"Rename {rec.get('kind','method')} declaration",
+                    })
+
+            # Caller sites (only methods have call sites).
+            method_ids = [r["id"] for r in method_recs]
+            if method_ids:
+                ph = ", ".join("$mid" + str(i) for i in range(len(method_ids)))
+                caller_params = {f"mid{i}": v for i, v in enumerate(method_ids)}
+                callers = store.query_records(
+                    f"""
+                    MATCH (caller:Method)-[:CALLS]->(m:Method), (c:Class), (f:File)
+                    WHERE m.id IN [{ph}]
+                      AND caller.class_id = c.id AND c.file_id = f.id
+                    RETURN DISTINCT f.path as file_path, f.project_id as project_id,
+                           caller.name as caller_name
+                    LIMIT 100
+                    """,
+                    caller_params,
+                )
+                for cr in callers:
+                    fp = cr.get("file_path", "")
+                    if fp:
+                        declaration_files.setdefault(fp, {
+                            "file_path": fp,
+                            "project_id": cr.get("project_id"),
+                            "changes": [],
+                        })["changes"].append({
+                            "kind": "call_site",
+                            "current_text": symbol,
+                            "suggested_text": new_name,
+                            "note": f"Call site in {cr.get('caller_name','<unknown>')}",
+                        })
+
+            # Override sites.
+            for method_id in method_ids:
+                overrides = store.query_records(
+                    """
+                    MATCH (child:Method)-[:OVERRIDES]->(m:Method {id: $mid}),
+                          (cc:Class), (ff:File)
+                    WHERE child.class_id = cc.id AND cc.file_id = ff.id
+                    RETURN ff.path as file_path, ff.project_id as project_id,
+                           child.name as name
+                    """,
+                    {"mid": method_id},
+                )
+                for ov in overrides:
+                    fp = ov.get("file_path", "")
+                    if fp:
+                        declaration_files.setdefault(fp, {
+                            "file_path": fp,
+                            "project_id": ov.get("project_id"),
+                            "changes": [],
+                        })["changes"].append({
+                            "kind": "override",
+                            "current_name": ov.get("name", symbol),
+                            "suggested_name": new_name,
+                            "note": "Override — must match new name",
+                        })
+
+            files_to_modify = sorted(
+                declaration_files.values(), key=lambda x: x.get("file_path", "")
+            )
+            projects_affected = {f["project_id"] for f in files_to_modify if f.get("project_id")}
+
+            return _staleness_meta(store, {
+                "available": True,
+                "symbol": symbol,
+                "new_name": new_name,
+                "targets_found": len(all_targets),
+                "files_to_modify": files_to_modify,
+                "files_count": len(files_to_modify),
+                "projects_affected": list(projects_affected),
+                "note": (
+                    f"Found {len(files_to_modify)} files to update. "
+                    "This is a plan only — no files have been changed."
+                ),
+            }, project, overlay_store=overlay_store)
+        except Exception as exc:
+            return _safe_tool_response("rename_plan", exc)
+
     # ------------------------------------------------------------------
     # Advanced / raw access
     # ------------------------------------------------------------------

{codespine-0.9.8 → codespine-0.9.9}/codespine/search/vector.py

@@ -11,13 +11,30 @@ from codespine.config import SETTINGS
 
 
 def _hash_vector(text: str, dim: int) -> list[float]:
-    """Deterministic fallback embedding when sentence-transformers is unavailable."""
+    """Deterministic fallback embedding when sentence-transformers is unavailable.
+
+    Uses character n-grams (bi-, tri-, and quad-grams) plus full word tokens for
+    significantly better score calibration compared to word-only hashing.  Similar
+    identifiers (e.g. ``getUserById`` vs ``getUserByName``) now land closer in
+    vector space than they would with whole-word tokens alone.
+    """
     vec = [0.0] * dim
     if not text:
         return vec
-    tokens = text.lower().split()
-    for token in tokens:
-        digest = hashlib.sha1(token.encode("utf-8")).digest()
+    normalized = text.lower()
+
+    features: list[str] = []
+    # Include whole words (split on camelCase boundaries too)
+    import re as _re
+    words = _re.sub(r"([a-z])([A-Z])", r"\1 \2", text).lower().split()
+    features.extend(words)
+    # Character n-grams (bigrams, trigrams, quadgrams) over normalized text
+    for n in (2, 3, 4):
+        for i in range(len(normalized) - n + 1):
+            features.append(normalized[i : i + n])
+
+    for feat in features:
+        digest = hashlib.sha1(feat.encode("utf-8")).digest()
         idx = int.from_bytes(digest[:2], "big") % dim
         sign = 1.0 if digest[2] % 2 == 0 else -1.0
         vec[idx] += sign

{codespine-0.9.8 → codespine-0.9.9}/codespine.egg-info/PKG-INFO

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

{codespine-0.9.8 → codespine-0.9.9}/codespine.egg-info/SOURCES.txt

@@ -20,6 +20,8 @@ codespine/analysis/crossmodule.py
 codespine/analysis/deadcode.py
 codespine/analysis/flow.py
 codespine/analysis/impact.py
+codespine/cache/__init__.py
+codespine/cache/result_cache.py
 codespine/db/__init__.py
 codespine/db/duckdb_store.py
 codespine/db/schema.py
@@ -61,6 +63,7 @@ tests/test_index_and_hybrid.py
 tests/test_java_parser.py
 tests/test_multimodule_index.py
 tests/test_overlay.py
+tests/test_result_cache.py
 tests/test_search_ranking.py
 tests/test_sharding.py
 tests/test_store_recovery.py

{codespine-0.9.8 → codespine-0.9.9}/pyproject.toml

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

codespine-0.9.9/tests/test_result_cache.py

@@ -0,0 +1,179 @@
+"""Tests for codespine.cache.result_cache.ResultCache."""
+
+from __future__ import annotations
+
+import time
+
+import pytest
+
+from codespine.cache.result_cache import ResultCache
+
+
+# ---------------------------------------------------------------------------
+# make_key
+# ---------------------------------------------------------------------------
+
+
+def test_make_key_same_args_same_key():
+    k1 = ResultCache.make_key("get_impact", {"symbol": "Foo", "project": None}, 1000.0)
+    k2 = ResultCache.make_key("get_impact", {"symbol": "Foo", "project": None}, 1000.0)
+    assert k1 == k2
+
+
+def test_make_key_different_tool():
+    k1 = ResultCache.make_key("get_impact", {"symbol": "Foo"}, 1000.0)
+    k2 = ResultCache.make_key("detect_dead_code", {"symbol": "Foo"}, 1000.0)
+    assert k1 != k2
+
+
+def test_make_key_different_mtime():
+    k1 = ResultCache.make_key("get_impact", {"symbol": "Foo"}, 1000.0)
+    k2 = ResultCache.make_key("get_impact", {"symbol": "Foo"}, 1001.0)
+    assert k1 != k2
+
+
+def test_make_key_different_args():
+    k1 = ResultCache.make_key("search", {"query": "Foo"}, 1000.0)
+    k2 = ResultCache.make_key("search", {"query": "Bar"}, 1000.0)
+    assert k1 != k2
+
+
+def test_make_key_arg_order_independent():
+    k1 = ResultCache.make_key("t", {"a": 1, "b": 2}, 0.0)
+    k2 = ResultCache.make_key("t", {"b": 2, "a": 1}, 0.0)
+    assert k1 == k2  # sorted keys in json.dumps
+
+
+# ---------------------------------------------------------------------------
+# get / put / hit
+# ---------------------------------------------------------------------------
+
+
+def test_cache_miss_returns_none():
+    c = ResultCache()
+    assert c.get(("x", "y", 0.0)) is None
+
+
+def test_cache_put_and_get():
+    c = ResultCache()
+    k = ResultCache.make_key("t", {}, 0.0)
+    c.put(k, '{"result": 1}')
+    assert c.get(k) == '{"result": 1}'
+
+
+def test_cache_hit_stat():
+    c = ResultCache()
+    k = ResultCache.make_key("t", {}, 0.0)
+    c.put(k, "v")
+    c.get(k)
+    s = c.stats()
+    assert s["hits"] == 1
+    assert s["misses"] == 0
+
+
+def test_cache_miss_stat():
+    c = ResultCache()
+    c.get(("x", "y", 0.0))
+    s = c.stats()
+    assert s["misses"] == 1
+    assert s["hits"] == 0
+
+
+# ---------------------------------------------------------------------------
+# LRU eviction
+# ---------------------------------------------------------------------------
+
+
+def test_lru_eviction():
+    c = ResultCache(maxsize=3)
+    for i in range(4):
+        k = ResultCache.make_key("t", {"i": i}, 0.0)
+        c.put(k, str(i))
+    # First entry should have been evicted.
+    k0 = ResultCache.make_key("t", {"i": 0}, 0.0)
+    assert c.get(k0) is None
+    # Later entries should still be present.
+    k3 = ResultCache.make_key("t", {"i": 3}, 0.0)
+    assert c.get(k3) == "3"
+
+
+def test_lru_promotes_on_get():
+    c = ResultCache(maxsize=3)
+    keys = [ResultCache.make_key("t", {"i": i}, 0.0) for i in range(3)]
+    for i, k in enumerate(keys):
+        c.put(k, str(i))
+    # Access key 0 to promote it to MRU.
+    c.get(keys[0])
+    # Add a new entry — key 1 (now oldest) should be evicted.
+    k3 = ResultCache.make_key("t", {"i": 3}, 0.0)
+    c.put(k3, "3")
+    assert c.get(keys[0]) is not None  # was promoted, should survive
+    assert c.get(keys[1]) is None      # was LRU, should be evicted
+
+
+# ---------------------------------------------------------------------------
+# TTL expiry
+# ---------------------------------------------------------------------------
+
+
+def test_ttl_expiry(monkeypatch):
+    c = ResultCache(ttl_s=0.05)
+    k = ResultCache.make_key("t", {}, 0.0)
+    c.put(k, "v")
+    # Patch monotonic to advance time past TTL.
+    real_monotonic = time.monotonic
+
+    class _FakeClock:
+        def __init__(self):
+            self._base = real_monotonic()
+
+        def __call__(self):
+            return self._base + 1.0  # 1 second ahead
+
+    monkeypatch.setattr(time, "monotonic", _FakeClock())
+    assert c.get(k) is None
+
+
+# ---------------------------------------------------------------------------
+# Invalidation
+# ---------------------------------------------------------------------------
+
+
+def test_invalidate_clears_all():
+    c = ResultCache()
+    for i in range(5):
+        k = ResultCache.make_key("t", {"i": i}, 0.0)
+        c.put(k, str(i))
+    removed = c.invalidate()
+    assert removed == 5
+    assert c.stats()["size"] == 0
+
+
+def test_invalidate_tool():
+    c = ResultCache()
+    k1 = ResultCache.make_key("get_impact", {"s": "A"}, 0.0)
+    k2 = ResultCache.make_key("detect_dead_code", {}, 0.0)
+    c.put(k1, "a")
+    c.put(k2, "b")
+    removed = c.invalidate_tool("get_impact")
+    assert removed == 1
+    assert c.get(k1) is None
+    assert c.get(k2) == "b"
+
+
+# ---------------------------------------------------------------------------
+# Stats
+# ---------------------------------------------------------------------------
+
+
+def test_stats_hit_rate():
+    c = ResultCache()
+    k = ResultCache.make_key("t", {}, 0.0)
+    c.put(k, "v")
+    c.get(k)       # hit
+    c.get(k)       # hit
+    c.get(("x",))  # miss
+    s = c.stats()
+    assert s["hits"] == 2
+    assert s["misses"] == 1
+    assert abs(s["hit_rate"] - 2 / 3) < 0.01