codecortex 0.2.0__py3-none-any.whl

codeintel/reset.py

@@ -0,0 +1,100 @@
+"""Recovery command — drop the semantic index cache for one project, or nuke the whole
+per-machine db. This is the escape hatch for a corrupt index, so it must work even when the
+db file itself can't be opened: never raises, never prompts. The CLI owns confirmation; this
+module is pure (dry-run by default via ``apply=False``).
+"""
+from __future__ import annotations
+
+import os
+import sqlite3
+
+import sqlite_vec
+
+from codeintel.semantic_db import default_db_path
+
+
+def _reset_scoped(project_root: str, path: str, apply: bool) -> dict:
+    real = os.path.realpath(str(project_root))
+    if not os.path.exists(path):
+        return {"ok": True, "mode": "scoped", "target": real, "count": 0,
+                "applied": bool(apply), "detail": "no index db found — nothing to reset"}
+
+    conn = None
+    try:
+        conn = sqlite3.connect(path)
+        conn.execute("PRAGMA busy_timeout=2000")
+        try:
+            # Only needed to delete from the vec0 virtual table below — the count query
+            # against the plain chunk_hashes table works fine without it.
+            conn.enable_load_extension(True)
+            sqlite_vec.load(conn)
+        except Exception:
+            pass
+
+        row = conn.execute(
+            "SELECT COUNT(*) FROM chunk_hashes WHERE project_root=?", (real,)
+        ).fetchone()
+        count = int(row[0]) if row else 0
+
+        if apply:
+            conn.execute(
+                "DELETE FROM code_embeddings WHERE chunk_id IN "
+                "(SELECT chunk_id FROM chunk_hashes WHERE project_root=?)", (real,))
+            conn.execute("DELETE FROM chunk_hashes WHERE project_root=?", (real,))
+            conn.commit()
+
+        verb = "removed" if apply else "found"
+        return {"ok": True, "mode": "scoped", "target": real, "count": count,
+                "applied": bool(apply),
+                "detail": f"{verb} {count} indexed chunk(s) for this project"}
+    except Exception as exc:
+        return {"ok": True, "mode": "scoped", "target": real, "count": 0,
+                "applied": bool(apply),
+                "detail": f"reset-error: db unreadable/locked ({type(exc).__name__}: {exc})"}
+    finally:
+        if conn is not None:
+            try:
+                conn.close()
+            except Exception:
+                pass
+
+
+def _reset_all(path: str, apply: bool) -> dict:
+    candidates = [path, path + "-wal", path + "-shm"]
+    if apply:
+        removed = 0
+        for p in candidates:
+            try:
+                os.remove(p)
+                removed += 1
+            except FileNotFoundError:
+                pass
+            except Exception:
+                pass
+        count = removed
+        detail = f"removed {removed} index file(s)"
+    else:
+        count = sum(1 for p in candidates if os.path.exists(p))
+        detail = f"{count} index file(s) would be removed"
+
+    return {"ok": True, "mode": "all", "target": "ALL", "count": count,
+            "applied": bool(apply), "detail": detail}
+
+
+def run_reset(
+    project_root: str,
+    *,
+    all_projects: bool = False,
+    apply: bool = False,
+    db_path: str | None = None,
+) -> dict:
+    """Drop indexed rows for ``project_root`` (or, with ``all_projects``, remove the whole
+    cache db file plus its -wal/-shm siblings). ``apply=False`` is a dry-run: count only,
+    delete nothing. Never raises."""
+    try:
+        path = db_path if db_path is not None else default_db_path()
+        if all_projects:
+            return _reset_all(path, apply)
+        return _reset_scoped(project_root, path, apply)
+    except Exception as exc:
+        return {"ok": True, "applied": apply, "detail": f"reset-error: {type(exc).__name__}: {exc}"}

codeintel/searcher.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import logging
+import os
+import struct
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from codeintel.semantic_db import SemanticDb
+
+logger = logging.getLogger(__name__)
+
+_SNIPPET_LINES = 5
+
+
+class Searcher:
+    def __init__(
+        self,
+        db: SemanticDb,
+        model_name: str = "BAAI/bge-small-en-v1.5",
+    ) -> None:
+        self.db = db
+        self.model_name = model_name
+        self._embedder = None
+
+    def _get_embedder(self):
+        if self._embedder is None:
+            from fastembed import TextEmbedding
+            self._embedder = TextEmbedding(model_name=self.model_name)
+        return self._embedder
+
+    def _embed_query(self, query: str) -> bytes | None:
+        try:
+            embedder = self._get_embedder()
+            vecs = list(embedder.embed([query]))
+            if not vecs:
+                return None
+            vec = vecs[0]
+            return struct.pack(f"{len(vec)}f", *vec)
+        except Exception as exc:
+            logger.warning("query embedding failed: %s", exc)
+            return None
+
+    def _row_count(self, project_root_real: str) -> int:
+        try:
+            conn = self.db.conn()
+            row = conn.execute(
+                "SELECT COUNT(*) FROM chunk_hashes WHERE project_root = ?",
+                (project_root_real,),
+            ).fetchone()
+            return row[0] if row else 0
+        except Exception as exc:
+            logger.warning("rowcount check failed: %s", exc)
+            return 0
+
+    def has_index(self, project_root: str) -> bool:
+        """True when this project has at least one indexed chunk — lets the provider
+        distinguish 'nothing indexed yet' (no-index) from 'matches below floor'."""
+        return self._row_count(os.path.realpath(project_root)) > 0
+
+    def _read_snippet(self, file_path: Path, chunk_start: int) -> str:
+        try:
+            with open(file_path, encoding="utf-8", errors="replace") as f:
+                lines = f.readlines()
+            snippet_lines = lines[chunk_start: chunk_start + _SNIPPET_LINES]
+            return "".join(snippet_lines).rstrip()
+        except FileNotFoundError:
+            return "[file not found]"
+        except Exception as exc:
+            logger.debug("snippet read failed for %s:%d: %s", file_path, chunk_start, exc)
+            return "[file not found]"
+
+    def search(
+        self,
+        query: str,
+        project_root: str,
+        k: int = 10,
+        cosine_floor: float = 0.25,
+    ) -> list[dict]:
+        if not query or not query.strip():
+            return []
+
+        k = max(1, k)
+        project_root_real = os.path.realpath(project_root)
+
+        # Scope the KNN to THIS project — a search in repo B must never surface repo A's
+        # chunks (wrong-file, wrong-content hits) from the shared cache.
+        if self._row_count(project_root_real) == 0:
+            return []
+
+        query_vec = self._embed_query(query)
+        if query_vec is None:
+            return []
+
+        try:
+            conn = self.db.conn()
+            rows = conn.execute(
+                """
+                SELECT
+                    ce.chunk_id,
+                    ch.chunk_start,
+                    ch.file_path,
+                    vec_distance_cosine(ce.embedding, ?) AS dist
+                FROM code_embeddings ce
+                JOIN chunk_hashes ch ON ce.chunk_id = ch.chunk_id
+                WHERE ch.project_root = ?
+                ORDER BY dist
+                LIMIT ?
+                """,
+                (query_vec, project_root_real, k),
+            ).fetchall()
+        except Exception as exc:
+            logger.warning("KNN query failed: %s", exc)
+            return []
+
+        root = Path(project_root)
+        results: list[dict] = []
+
+        for row in rows:
+            try:
+                dist = float(row["dist"])
+                score = 1.0 - dist
+                if score < cosine_floor:
+                    continue
+
+                chunk_start = int(row["chunk_start"])
+                rel_path = str(row["file_path"])
+                abs_path = root / rel_path
+
+                snippet = self._read_snippet(abs_path, chunk_start)
+
+                results.append({
+                    "path": rel_path,
+                    "line": chunk_start,
+                    "snippet": snippet,
+                    "score": round(score, 6),
+                })
+            except Exception as exc:
+                logger.debug("result row processing failed: %s", exc)
+                continue
+
+        return results

codeintel/semantic_db.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import pathlib
+import sqlite3
+
+import sqlite_vec
+
+DEFAULT_MODEL = "BAAI/bge-small-en-v1.5"
+
+
+def default_db_path() -> str:
+    """The single, per-machine semantic index cache. Every entry point (the
+    SemanticProvider, the Reindexer, and the CLI) MUST resolve to this one path — rows
+    are partitioned by ``project_root`` inside it — so ``index`` and ``search`` can never
+    diverge onto different files for the same repo.
+    """
+    return str(pathlib.Path.home() / ".codeintel" / "semantic.db")
+
+
+class SemanticDb:
+    """DB layer: opens a SQLite connection, loads sqlite-vec, and owns schema creation."""
+
+    dimension: int = 384
+
+    def __init__(self, db_path: str) -> None:
+        self.db_path = db_path
+        self._conn: sqlite3.Connection | None = None
+
+    def conn(self) -> sqlite3.Connection:
+        if self._conn is None:
+            self._conn = sqlite3.connect(self.db_path)
+            self._conn.enable_load_extension(True)
+            self._conn.row_factory = sqlite3.Row
+        return self._conn
+
+    def init(self) -> None:
+        c = self.conn()
+        try:
+            sqlite_vec.load(c)
+        except Exception as exc:
+            raise RuntimeError(f"sqlite-vec extension failed to load: {exc}") from exc
+
+        # Migration: caches created before the project_root partition column lack it. The
+        # index is a regenerable cache, so on a schema mismatch we drop and rebuild rather
+        # than ALTER — the next index pass repopulates it.
+        try:
+            cols = [r[1] for r in c.execute("PRAGMA table_info(chunk_hashes)").fetchall()]
+            if cols and "project_root" not in cols:
+                c.executescript(
+                    "DROP TABLE IF EXISTS code_embeddings;"
+                    "DROP TABLE IF EXISTS chunk_hashes;"
+                )
+        except Exception:
+            pass
+
+        c.executescript(f"""
+            CREATE VIRTUAL TABLE IF NOT EXISTS code_embeddings USING vec0(
+                chunk_id TEXT PRIMARY KEY,
+                embedding FLOAT[{self.dimension}]
+            );
+
+            CREATE TABLE IF NOT EXISTS chunk_hashes (
+                chunk_id     TEXT PRIMARY KEY,
+                project_root TEXT NOT NULL,
+                file_path    TEXT NOT NULL,
+                chunk_start  INT  NOT NULL,
+                content_hash TEXT NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_chunk_project
+                ON chunk_hashes(project_root);
+        """)
+        c.commit()
+
+    def close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None

codeintel/server.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import threading
+
+import anyio
+from mcp.server.mcpserver.server import MCPServer
+
+from codeintel.gateway import Gateway
+from codeintel.policy import TieringPolicy
+from codeintel.provider import safe_null_result
+from codeintel.providers.graph import GraphProvider
+from codeintel.providers.lsp import LspProvider
+from codeintel.providers.semantic import SemanticProvider
+from codeintel.reindexer import Reindexer
+
+_REINDEXER = Reindexer()
+
+
+def _build_gateway() -> Gateway:
+    graph = None
+    lsp = None
+    try:
+        gp = GraphProvider()
+        if gp.available:
+            graph = gp
+    except Exception:
+        pass
+    try:
+        lp = LspProvider()
+        if lp.available:
+            lsp = lp
+    except Exception:
+        pass
+    semantic = SemanticProvider()
+    policy = TieringPolicy(enabled=False)
+    return Gateway(graph=graph, lsp=lsp, semantic=semantic, policy=policy, reindexer=_REINDEXER)
+
+
+_GATEWAY: Gateway | None = None
+_GATEWAY_LOCK = threading.Lock()
+
+
+def _get_gateway() -> Gateway:
+    """Build the gateway ONCE and reuse it across requests, so the content-hash cache and
+    the async-warming LSP session persist between an agent's calls. Rebuilding it per
+    request (the old behavior) left the cache permanently cold and the LSP engine stuck
+    re-warming a fresh ``uvx serena`` subprocess on every single call."""
+    global _GATEWAY
+    if _GATEWAY is None:
+        with _GATEWAY_LOCK:
+            if _GATEWAY is None:
+                _GATEWAY = _build_gateway()
+    return _GATEWAY
+
+
+def _reset_gateway() -> None:
+    """Test hook: drop the cached gateway so the next call rebuilds it."""
+    global _GATEWAY
+    with _GATEWAY_LOCK:
+        _GATEWAY = None
+
+
+def code_query_handler(args: dict) -> dict:
+    try:
+        op = args.get("op", "")
+        target = args.get("target", "")
+        project_root = args.get("project_root", "")
+        engine = args.get("engine", None)
+        role = args.get("role", "")
+        gw = _get_gateway()
+        return gw.query(op=op, target=target, engine=engine, role=role, project_root=project_root)
+    except Exception:
+        return safe_null_result("", "", reason="handler-error")
+
+
+def code_status_handler(args: dict) -> dict:
+    try:
+        graph_available = False
+        lsp_available = False
+        semantic_available = False
+        try:
+            gp = GraphProvider()
+            graph_available = bool(gp.available)
+        except Exception:
+            pass
+        try:
+            lp = LspProvider()
+            lsp_available = bool(lp.available)
+        except Exception:
+            pass
+        try:
+            sp = SemanticProvider()
+            semantic_available = bool(sp.available)
+        except Exception:
+            pass
+        engines: list[str] = []
+        if graph_available:
+            engines.append("graph")
+        if lsp_available:
+            engines.append("lsp")
+        if semantic_available:
+            engines.append("semantic")
+        if not engines:
+            engines.append("none")
+
+        # Report real freshness/model instead of hardcoded nulls (SPEC §7).
+        indexed = False
+        model = None
+        try:
+            import os
+            from codeintel.semantic_db import DEFAULT_MODEL, default_db_path
+            if semantic_available:
+                model = DEFAULT_MODEL
+                indexed = os.path.exists(default_db_path())
+        except Exception:
+            pass
+
+        return {
+            "ok": True,
+            "engines": engines,
+            "graph": graph_available,
+            "lsp": lsp_available,
+            "semantic": semantic_available,
+            "indexed": indexed,
+            "model": model,
+        }
+    except Exception:
+        return {
+            "ok": True,
+            "engines": ["none"],
+            "graph": False,
+            "lsp": False,
+            "semantic": False,
+            "indexed": False,
+            "model": None,
+        }
+
+
+def code_doctor_handler(args: dict) -> dict:
+    try:
+        from codeintel import doctor as _doctor
+
+        project_root = str(args.get("project_root", "") or "")
+        deep = bool(args.get("deep", False))
+        # Reuse the singleton gateway's providers so the report reflects the LIVE warmed LSP
+        # session state an agent's real queries hit (and the graph project cache).
+        gw = _get_gateway()
+        return _doctor.run_doctor(
+            project_root, deep=deep, graph=gw.graph, lsp=gw.lsp, semantic=gw.semantic
+        )
+    except Exception:
+        return {
+            "ok": True, "project_root": "", "deep": False,
+            "summary": {"ready": 0, "total": 3, "healthy": False},
+            "engines": {}, "note": "doctor-error",
+        }
+
+
+def code_map_handler(args: dict) -> dict:
+    try:
+        from codeintel.mapper import MapGenerator
+        from codeintel.injector import Injector
+
+        project_root = str(args.get("project_root", "") or "")
+        budget = int(args.get("budget", 32768) or 32768)
+        inject = bool(args.get("inject", False))
+
+        try:
+            provider = GraphProvider()
+        except Exception:
+            provider = None
+
+        gen = MapGenerator(provider)
+        content = gen.generate(project_root, budget_bytes=budget)
+        path = gen.write(project_root, content)
+        size = len(content.encode("utf-8"))
+
+        inject_result = None
+        if inject:
+            inj_path, inj_action = Injector().inject(project_root)
+            inject_result = {"path": inj_path, "action": inj_action}
+
+        return {"ok": True, "path": path, "size_bytes": size, "inject": inject_result}
+    except Exception:
+        return {"ok": True, "path": None, "size_bytes": 0, "note": "map-error"}
+
+
+def run() -> None:
+    mcp = MCPServer(name="codeintel")
+
+    async def _code_query(
+        op: str = "",
+        target: str = "",
+        project_root: str = "",
+        engine: str = "",
+        role: str = "",
+    ) -> dict:
+        return code_query_handler(
+            {"op": op, "target": target, "project_root": project_root, "engine": engine, "role": role}
+        )
+
+    async def _code_status() -> dict:
+        return code_status_handler({})
+
+    async def _code_doctor(project_root: str = "", deep: bool = False) -> dict:
+        return code_doctor_handler({"project_root": project_root, "deep": deep})
+
+    async def _code_map(project_root: str = "", budget: int = 32768, inject: bool = False) -> dict:
+        return code_map_handler({"project_root": project_root, "budget": budget, "inject": inject})
+
+    mcp.add_tool(_code_query, name="code.query", description="Query the code intelligence engine")
+    mcp.add_tool(_code_status, name="code.status", description="Return engine status")
+    mcp.add_tool(_code_doctor, name="code.doctor", description="Diagnose engine health + repo index status with remediation")
+    mcp.add_tool(_code_map, name="code.map", description="Generate or refresh CODE_INTEL.md orientation file")
+
+    anyio.run(mcp.run_stdio_async)