codespine 0.5.4__tar.gz → 0.5.5__tar.gz

{codespine-0.5.4 → codespine-0.5.5}/PKG-INFO

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

{codespine-0.5.4 → codespine-0.5.5}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "0.5.4"
+__version__ = "0.5.5"

{codespine-0.5.4 → codespine-0.5.5}/codespine/analysis/impact.py

@@ -2,22 +2,36 @@ from __future__ import annotations
 
 from collections import defaultdict, deque
 
+from codespine.overlay.merge import merged_call_edges, merged_method_records, merged_symbol_records
+
 
 def _resolve_symbol_ids(store, symbol_query: str, project: str | None = None) -> list[str]:
-    project_clause = "AND f.project_id = $proj" if project else ""
-    params: dict = {"q": symbol_query}
-    if project:
-        params["proj"] = project
-    recs = store.query_records(
-        f"""
-        MATCH (s:Symbol), (f:File)
-        WHERE s.file_id = f.id {project_clause}
-        AND (s.id = $q OR lower(s.name) = lower($q) OR lower(s.fqname) = lower($q) OR lower(s.fqname) CONTAINS lower($q))
-        RETURN s.id as id
-        LIMIT 50
-        """,
-        params,
-    )
+    overlay_store = getattr(store, "overlay_store", None)
+    if overlay_store is not None:
+        recs = []
+        needle = symbol_query.lower()
+        for rec in merged_symbol_records(store, overlay_store, project=project):
+            name = str(rec.get("name") or "").lower()
+            fqname = str(rec.get("fqname") or "").lower()
+            if rec.get("id") == symbol_query or name == needle or fqname == needle or needle in fqname:
+                recs.append({"id": rec["id"]})
+                if len(recs) >= 50:
+                    break
+    else:
+        project_clause = "AND f.project_id = $proj" if project else ""
+        params: dict = {"q": symbol_query}
+        if project:
+            params["proj"] = project
+        recs = store.query_records(
+            f"""
+            MATCH (s:Symbol), (f:File)
+            WHERE s.file_id = f.id {project_clause}
+            AND (s.id = $q OR lower(s.name) = lower($q) OR lower(s.fqname) = lower($q) OR lower(s.fqname) CONTAINS lower($q))
+            RETURN s.id as id
+            LIMIT 50
+            """,
+            params,
+        )
     return [r["id"] for r in recs]
 
 
@@ -30,15 +44,21 @@ def _resolve_method_metadata(store, method_ids: list[str]) -> dict[str, dict]:
     """
     if not method_ids:
         return {}
-    recs = store.query_records(
-        """
-        MATCH (m:Method), (c:Class), (f:File)
-        WHERE m.id IN $ids AND m.class_id = c.id AND c.file_id = f.id
-        RETURN m.id as id, m.name as name, m.signature as fqname,
-               c.fqcn as class_fqcn, f.path as file_path, f.project_id as project_id
-        """,
-        {"ids": method_ids},
-    )
+    overlay_store = getattr(store, "overlay_store", None)
+    if overlay_store is not None:
+        recs = [r for r in merged_method_records(store, overlay_store) if r.get("id") in set(method_ids)]
+        for rec in recs:
+            rec["fqname"] = rec.get("signature")
+    else:
+        recs = store.query_records(
+            """
+            MATCH (m:Method), (c:Class), (f:File)
+            WHERE m.id IN $ids AND m.class_id = c.id AND c.file_id = f.id
+            RETURN m.id as id, m.name as name, m.signature as fqname,
+                   c.fqcn as class_fqcn, f.path as file_path, f.project_id as project_id
+            """,
+            {"ids": method_ids},
+        )
     return {r["id"]: r for r in recs}
 
 
@@ -47,16 +67,33 @@ def analyze_impact(store, symbol_query: str, max_depth: int = 4, project: str |
     if not target_symbol_ids:
         return {"target": symbol_query, "depth_groups": {"1": [], "2": [], "3+": []}}
 
-    symbol_to_method = {
-        r["sid"]: r["mid"]
-        for r in store.query_records(
-            """
-            MATCH (s:Symbol),(m:Method)
-            WHERE s.kind = 'method' AND s.fqname CONTAINS m.signature
-            RETURN s.id as sid, m.id as mid
-            """
-        )
-    }
+    overlay_store = getattr(store, "overlay_store", None)
+    if overlay_store is not None:
+        methods = merged_method_records(store, overlay_store, project=project)
+        symbols = merged_symbol_records(store, overlay_store, project=project)
+        fqname_and_file_to_method = {
+            (f"{rec.get('class_fqcn')}#{rec.get('signature')}", rec.get("file_id")): rec["id"]
+            for rec in methods
+        }
+        symbol_to_method = {}
+        for rec in symbols:
+            if rec.get("kind") != "method":
+                continue
+            method_key = (rec.get("fqname"), rec.get("file_id"))
+            method_id = fqname_and_file_to_method.get(method_key)
+            if method_id:
+                symbol_to_method[rec["id"]] = method_id
+    else:
+        symbol_to_method = {
+            r["sid"]: r["mid"]
+            for r in store.query_records(
+                """
+                MATCH (s:Symbol),(m:Method)
+                WHERE s.kind = 'method' AND s.fqname CONTAINS m.signature
+                RETURN s.id as sid, m.id as mid
+                """
+            )
+        }
 
     target_method_ids = [symbol_to_method[sid] for sid in target_symbol_ids if sid in symbol_to_method]
     if not target_method_ids:
@@ -64,14 +101,19 @@ def analyze_impact(store, symbol_query: str, max_depth: int = 4, project: str |
 
     # Load all call edges – cross-project callers are included intentionally so
     # impact analysis surfaces inter-module dependencies.
-    edges = store.query_records(
-        """
-        MATCH (a:Method)-[r:CALLS]->(b:Method)
-        RETURN a.id as src, b.id as dst, 'CALLS' as edge_type,
-               coalesce(r.confidence, 0.5) as confidence,
-               coalesce(r.reason, 'unknown') as reason
-        """
-    )
+    if overlay_store is not None:
+        edges = merged_call_edges(store, overlay_store, project=project)
+        for edge in edges:
+            edge["edge_type"] = "CALLS"
+    else:
+        edges = store.query_records(
+            """
+            MATCH (a:Method)-[r:CALLS]->(b:Method)
+            RETURN a.id as src, b.id as dst, 'CALLS' as edge_type,
+                   coalesce(r.confidence, 0.5) as confidence,
+                   coalesce(r.reason, 'unknown') as reason
+            """
+        )
 
     reverse_adj: dict[str, list[dict]] = defaultdict(list)
     for edge in edges:

{codespine-0.5.4 → codespine-0.5.5}/codespine/cli.py

@@ -24,7 +24,7 @@ from codespine.diff.branch_diff import compare_branches
 from codespine.indexer.engine import JavaIndexer
 from codespine.mcp.server import build_mcp_server
 from codespine.search.hybrid import hybrid_search
-from codespine.watch.watcher import run_watch_mode
+from codespine.watch.watcher import clear_overlay, get_overlay_status, promote_overlay, run_watch_mode
 
 logging.basicConfig(filename=SETTINGS.log_file, level=logging.INFO)
 LOGGER = logging.getLogger(__name__)
@@ -414,10 +414,23 @@ def coupling(months: int, min_strength: float, min_cochanges: int, as_json: bool
 @main.command()
 @click.option("--path", default=".", show_default=True, type=click.Path(exists=True))
 @click.option("--global-interval", default=30, show_default=True, type=int)
-def watch(path: str, global_interval: int) -> None:
+@click.option(
+    "--overlay-debounce-ms",
+    default=SETTINGS.default_overlay_debounce_ms,
+    show_default=True,
+    type=int,
+)
+@click.option("--promote-on-commit/--no-promote-on-commit", default=True, show_default=True)
+def watch(path: str, global_interval: int, overlay_debounce_ms: int, promote_on_commit: bool) -> None:
     """Live re-indexing and periodic global analysis refresh."""
     store = GraphStore(read_only=False)
-    run_watch_mode(store, os.path.abspath(path), global_interval=global_interval)
+    run_watch_mode(
+        store,
+        os.path.abspath(path),
+        global_interval=global_interval,
+        overlay_debounce_ms=overlay_debounce_ms,
+        promote_on_commit=promote_on_commit,
+    )
 
 
 @main.command()
@@ -521,6 +534,8 @@ def status(as_json: bool) -> None:
                 pid = int(f.read().strip())
         except Exception:
             pid = None
+    store = GraphStore(read_only=True)
+    overlay = get_overlay_status(store)
     payload = {
         "running": running,
         "pid": pid,
@@ -528,10 +543,41 @@ def status(as_json: bool) -> None:
         "db_path": SETTINGS.db_path,
         "db_size_bytes": _db_size_bytes(SETTINGS.db_path),
         "log_file": SETTINGS.log_file,
+        "overlay_dir": SETTINGS.overlay_dir,
+        "overlay_projects": overlay,
     }
     _echo_json(payload, as_json)
 
 
+@main.command("overlay-status")
+@click.option("--project", default=None)
+@click.option("--json", "as_json", is_flag=True)
+def overlay_status_cmd(project: str | None, as_json: bool) -> None:
+    """Show dirty overlay status by project/module."""
+    store = GraphStore(read_only=True)
+    _echo_json(get_overlay_status(store, project=project), as_json)
+
+
+@main.command("overlay-clear")
+@click.option("--project", default=None)
+@click.option("--json", "as_json", is_flag=True)
+def overlay_clear_cmd(project: str | None, as_json: bool) -> None:
+    """Clear dirty overlay data without touching the committed base index."""
+    store = GraphStore(read_only=False)
+    result = {"cleared": clear_overlay(store, project=project)}
+    _echo_json(result, as_json)
+
+
+@main.command("overlay-promote")
+@click.option("--project", default=None)
+@click.option("--json", "as_json", is_flag=True)
+def overlay_promote_cmd(project: str | None, as_json: bool) -> None:
+    """Promote dirty overlay changes into the committed base index now."""
+    store = GraphStore(read_only=False)
+    result = {"promoted": promote_overlay(store, project=project, require_head_change=False)}
+    _echo_json(result, as_json)
+
+
 @main.command()
 @click.argument("query")
 @click.option("--json", "as_json", is_flag=True)
@@ -552,7 +598,7 @@ def clean(force: bool) -> None:
     if not force and not click.confirm("Remove local CodeSpine DB, PID, and logs?"):
         click.echo("Aborted.")
         return
-    for path in [SETTINGS.pid_file, SETTINGS.log_file, SETTINGS.db_path]:
+    for path in [SETTINGS.pid_file, SETTINGS.log_file, SETTINGS.db_path, SETTINGS.overlay_dir]:
         if not os.path.exists(path):
             continue
         if os.path.isdir(path):
@@ -591,6 +637,7 @@ def clear_project_cmd(project_id: str, allow_running: bool) -> None:
     project_path = recs[0].get("path", "")
     store.clear_analysis_artifacts()
     store.clear_project(project_id)
+    store.overlay_store.clear_project(project_id)
     meta_path = JavaIndexer._meta_cache_path(project_id)
     if os.path.exists(meta_path):
         try:
@@ -615,6 +662,7 @@ def clear_index_cmd(allow_running: bool) -> None:
     store = GraphStore(read_only=False)
     projects = store.query_records("MATCH (p:Project) RETURN p.id as id")
     store.rebuild_empty_db()
+    store.overlay_store.clear_all()
     for p in projects:
         meta_path = JavaIndexer._meta_cache_path(p["id"])
         if os.path.exists(meta_path):

{codespine-0.5.4 → codespine-0.5.5}/codespine/config.py

@@ -9,15 +9,19 @@ class Settings:
     log_file: str = os.path.expanduser("~/.codespine.log")
     embedding_cache_path: str = os.path.expanduser("~/.codespine_embedding_cache.json")
     index_meta_dir: str = os.path.expanduser("~/.codespine_index_meta")
+    overlay_dir: str = os.path.expanduser("~/.codespine_overlay")
     embedding_model: str = "BAAI/bge-small-en-v1.5"
     vector_dim: int = 384
     rrf_k: int = 60
     semantic_candidate_pool: int = 2000
     write_batch_size: int = 500
+    index_file_batch_size: int = 64
+    edge_write_batch_size: int = 2000
     default_coupling_months: int = 6
     default_min_coupling_strength: float = 0.3
     default_min_cochanges: int = 3
     default_global_interval_s: int = 30
+    default_overlay_debounce_ms: int = 1500
 
 
 SETTINGS = Settings()

{codespine-0.5.4 → codespine-0.5.5}/codespine/db/schema.py

@@ -10,7 +10,7 @@ NODE_TABLES: list[tuple[str, str]] = [
     ("SchemaMeta", "CREATE NODE TABLE SchemaMeta(key STRING, value STRING, PRIMARY KEY (key))"),
     (
         "Project",
-        "CREATE NODE TABLE Project(id STRING, path STRING, language STRING, indexed_at STRING, PRIMARY KEY (id))",
+        "CREATE NODE TABLE Project(id STRING, path STRING, language STRING, indexed_at STRING, indexed_commit STRING, overlay_dirty BOOL, PRIMARY KEY (id))",
     ),
     (
         "File",
@@ -81,5 +81,8 @@ def ensure_schema(conn) -> None:
 
     _safe_execute(
         conn,
-        "MERGE (s:SchemaMeta {key: 'schema_version'}) SET s.value = '3'",
+        "MERGE (s:SchemaMeta {key: 'schema_version'}) SET s.value = '4'",
     )
+
+    _safe_execute(conn, "ALTER TABLE Project ADD indexed_commit STRING DEFAULT ''")
+    _safe_execute(conn, "ALTER TABLE Project ADD overlay_dirty BOOL DEFAULT false")

{codespine-0.5.4 → codespine-0.5.5}/codespine/db/store.py

@@ -28,6 +28,9 @@ class GraphStore:
     def __post_init__(self) -> None:
         db_path = SETTINGS.db_path
         self._tls: threading.local = threading.local()
+        from codespine.overlay.store import OverlayStore
+
+        self.overlay_store = OverlayStore()
         try:
             self.db = self._open_db(db_path)
         except Exception as exc:
@@ -94,10 +97,77 @@ class GraphStore:
 
     def upsert_project(self, project_id: str, path: str) -> None:
         self.execute(
-            "MERGE (p:Project {id: $id}) SET p.path = $path, p.language = 'java', p.indexed_at = $ts",
+            """
+            MERGE (p:Project {id: $id})
+            SET p.path = $path,
+                p.language = 'java',
+                p.indexed_at = $ts,
+                p.indexed_commit = coalesce(p.indexed_commit, ''),
+                p.overlay_dirty = coalesce(p.overlay_dirty, false)
+            """,
             {"id": project_id, "path": path, "ts": str(int(time.time()))},
         )
 
+    def set_project_overlay_dirty(self, project_id: str, dirty: bool) -> None:
+        self.execute(
+            "MATCH (p:Project {id: $id}) SET p.overlay_dirty = $dirty",
+            {"id": project_id, "dirty": bool(dirty)},
+        )
+
+    def set_project_indexed_commit(self, project_id: str, commit: str) -> None:
+        self.execute(
+            """
+            MATCH (p:Project {id: $id})
+            SET p.indexed_commit = $commit,
+                p.indexed_at = $ts
+            """,
+            {"id": project_id, "commit": commit, "ts": str(int(time.time()))},
+        )
+
+    def get_project_metadata(self, project_id: str) -> dict[str, Any] | None:
+        recs = self.query_records(
+            """
+            MATCH (p:Project)
+            WHERE p.id = $pid
+            RETURN p.id as id,
+                   p.path as path,
+                   p.language as language,
+                   p.indexed_at as indexed_at,
+                   p.indexed_commit as indexed_commit,
+                   p.overlay_dirty as overlay_dirty
+            LIMIT 1
+            """,
+            {"pid": project_id},
+        )
+        return recs[0] if recs else None
+
+    def list_project_metadata(self) -> list[dict[str, Any]]:
+        return self.query_records(
+            """
+            MATCH (p:Project)
+            RETURN p.id as id,
+                   p.path as path,
+                   p.language as language,
+                   p.indexed_at as indexed_at,
+                   p.indexed_commit as indexed_commit,
+                   p.overlay_dirty as overlay_dirty
+            ORDER BY p.id
+            """
+        )
+
+    def project_has_embeddings(self, project_id: str) -> bool:
+        recs = self.query_records(
+            """
+            MATCH (s:Symbol), (f:File)
+            WHERE s.file_id = f.id
+              AND f.project_id = $pid
+              AND s.embedding IS NOT NULL
+            RETURN count(s) as count
+            """,
+            {"pid": project_id},
+        )
+        return bool(recs and int(recs[0].get("count") or 0) > 0)
+
     def project_file_hashes(self, project_id: str) -> dict[str, dict[str, str]]:
         recs = self.query_records(
             """
@@ -164,6 +234,16 @@ class GraphStore:
             },
         )
 
+    def upsert_files_batch(self, records: list[dict[str, Any]]) -> None:
+        for record in records:
+            self.upsert_file(
+                file_id=record["id"],
+                path=record["path"],
+                project_id=record["project_id"],
+                is_test=bool(record["is_test"]),
+                digest=record["hash"],
+            )
+
     def upsert_class(self, class_id: str, fqcn: str, name: str, package: str, file_id: str) -> None:
         self.execute(
             """
@@ -179,6 +259,16 @@ class GraphStore:
             },
         )
 
+    def upsert_classes_batch(self, records: list[dict[str, Any]]) -> None:
+        for record in records:
+            self.upsert_class(
+                class_id=record["id"],
+                fqcn=record["fqcn"],
+                name=record["name"],
+                package=record["package"],
+                file_id=record["file_id"],
+            )
+
     def upsert_method(
         self,
         method_id: str,
@@ -217,6 +307,19 @@ class GraphStore:
             {"cid": class_id, "mid": method_id},
         )
 
+    def upsert_methods_batch(self, records: list[dict[str, Any]]) -> None:
+        for record in records:
+            self.upsert_method(
+                method_id=record["id"],
+                class_id=record["class_id"],
+                name=record["name"],
+                signature=record["signature"],
+                return_type=record["return_type"],
+                modifiers=record["modifiers"],
+                is_constructor=bool(record["is_constructor"]),
+                is_test=bool(record["is_test"]),
+            )
+
     def upsert_symbol(
         self,
         symbol_id: str,
@@ -255,6 +358,19 @@ class GraphStore:
             {"fid": file_id, "sid": symbol_id},
         )
 
+    def upsert_symbols_batch(self, records: list[dict[str, Any]]) -> None:
+        for record in records:
+            self.upsert_symbol(
+                symbol_id=record["id"],
+                kind=record["kind"],
+                name=record["name"],
+                fqname=record["fqname"],
+                file_id=record["file_id"],
+                line=int(record["line"]),
+                col=int(record["col"]),
+                embedding=record.get("embedding"),
+            )
+
     def add_call(self, source_id: str, target_id: str, confidence: float, reason: str) -> None:
         self.execute(
             """
@@ -269,6 +385,15 @@ class GraphStore:
             },
         )
 
+    def add_calls_batch(self, records: list[dict[str, Any]]) -> None:
+        for record in records:
+            self.add_call(
+                source_id=record["source_id"],
+                target_id=record["target_id"],
+                confidence=float(record["confidence"]),
+                reason=record["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
@@ -278,6 +403,17 @@ class GraphStore:
         )
         self.execute(query, {"src_id": src_id, "dst_id": dst_id, "confidence": confidence})
 
+    def add_references_batch(self, records: list[dict[str, Any]]) -> None:
+        for record in records:
+            self.add_reference(
+                rel=record["rel"],
+                src_label=record["src_label"],
+                src_id=record["src_id"],
+                dst_label=record["dst_label"],
+                dst_id=record["dst_id"],
+                confidence=float(record["confidence"]),
+            )
+
     def _recycle_conn(self) -> None:
         """Drop and recreate the per-thread connection to release buffer pages."""
         try: