codecortex 0.8.2__tar.gz → 0.8.4__tar.gz

{codecortex-0.8.2/src/codecortex.egg-info → codecortex-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.8.2
+Version: 0.8.4
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT

{codecortex-0.8.2 → codecortex-0.8.4/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.8.2
+Version: 0.8.4
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT

{codecortex-0.8.2 → codecortex-0.8.4}/src/codecortex.egg-info/SOURCES.txt

@@ -53,6 +53,8 @@ tests/test_integration.py
 tests/test_lsp_provider.py
 tests/test_lsp_real.py
 tests/test_mapper.py
+tests/test_mcp_server.py
+tests/test_model_dimension.py
 tests/test_never_raise.py
 tests/test_onboarding.py
 tests/test_rbac.py

codecortex-0.8.4/src/codeintel/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.4"

{codecortex-0.8.2 → codecortex-0.8.4}/src/codeintel/__main__.py

@@ -110,28 +110,32 @@ def main() -> None:
         from codeintel.semantic_db import SemanticDb, default_db_path
 
         project_root = args.project_root or os.getcwd()
-        cfg = load_config(project_root)
-
-        db_path = default_db_path()
-        os.makedirs(os.path.dirname(db_path), exist_ok=True)
-        db = SemanticDb(db_path)
+        # Wrap the whole semantic pass so a setup failure (e.g. an unresolvable home dir →
+        # Path.home() raising) degrades with a message, like every other subcommand, not a traceback.
         try:
-            db.init()
-            count = Indexer(
-                db,
-                model_name=str(cfg.get("model") or "BAAI/bge-small-en-v1.5"),
-                window=int(cfg.get("window", 20)),
-                stride=int(cfg.get("stride", 10)),
-                max_chunks=int(cfg.get("max_chunks", 500)),
-                max_total_chunks=int(cfg.get("max_total_chunks", 100000)),
-                chunk_strategy=str(cfg.get("chunk_strategy", "syntax")),
-            ).index(project_root)
-            if count > 0:
-                print(f"Indexed {count} chunks")
-            else:
-                print("Nothing new to index")
-        finally:
-            db.close()
+            cfg = load_config(project_root)
+            db_path = default_db_path(str(cfg.get("model") or ""))
+            os.makedirs(os.path.dirname(db_path), exist_ok=True)
+            db = SemanticDb(db_path)
+            try:
+                db.init()
+                count = Indexer(
+                    db,
+                    model_name=str(cfg.get("model") or "BAAI/bge-small-en-v1.5"),
+                    window=int(cfg.get("window", 20)),
+                    stride=int(cfg.get("stride", 10)),
+                    max_chunks=int(cfg.get("max_chunks", 500)),
+                    max_total_chunks=int(cfg.get("max_total_chunks", 100000)),
+                    chunk_strategy=str(cfg.get("chunk_strategy", "syntax")),
+                ).index(project_root)
+                if count > 0:
+                    print(f"Indexed {count} chunks")
+                else:
+                    print("Nothing new to index")
+            finally:
+                db.close()
+        except Exception as exc:
+            print(f"index failed: {exc}")
 
         # best-effort graph reindex
         import shutil
@@ -242,8 +246,9 @@ def main() -> None:
                 state = "available" if available else "unavailable"
                 print(f"  {engine:<10} {state}")
 
+            from codeintel.config import load_config
             from codeintel.semantic_db import default_db_path
-            db_path = default_db_path()
+            db_path = default_db_path(str(load_config(project_root).get("model") or ""))
             if os.path.exists(db_path):
                 import datetime
                 mtime = os.path.getmtime(db_path)

{codecortex-0.8.2 → codecortex-0.8.4}/src/codeintel/indexer.py

@@ -519,6 +519,11 @@ class Indexer:
                     break
                 try:
                     vec = embeddings[j]
+                    # Create code_embeddings lazily, sized to this vector (self-dimensioning). A
+                    # returned dim != len(vec) means the file already holds a different dimension
+                    # (only reachable on a DEFAULT_MODEL size bump) — skip rather than corrupt/mix.
+                    if self.db.ensure_embeddings_table(len(vec)) != len(vec):
+                        continue
                     vec_bytes = struct.pack(f"{len(vec)}f", *vec)
                     # sqlite-vec's vec0 virtual table does NOT honor INSERT OR REPLACE — it raises
                     # UNIQUE on an existing chunk_id instead of replacing. So re-embedding a chunk

{codecortex-0.8.2 → codecortex-0.8.4}/src/codeintel/onboarding.py

@@ -63,7 +63,7 @@ def _bounded_index(project_root: str, *, timeout_s: float, out) -> dict:
     def _work() -> None:
         try:
             cfg = load_config(project_root)
-            db_path = default_db_path()
+            db_path = default_db_path(str(cfg.get("model") or ""))
             os.makedirs(os.path.dirname(db_path), exist_ok=True)
             db = SemanticDb(db_path)
             try:

{codecortex-0.8.2 → codecortex-0.8.4}/src/codeintel/providers/semantic.py

@@ -12,8 +12,6 @@ try:
 except ImportError:
     _DEPS_OK = False
 
-_DB_PATH = pathlib.Path.home() / ".codeintel" / "semantic.db"
-
 
 class SemanticProvider:
     """Real semantic search provider backed by SemanticDb and Searcher."""
@@ -23,9 +21,10 @@ class SemanticProvider:
         return _DEPS_OK
 
     def probe(self, project_root: str) -> dict:
-        """Never-raise health check for the doctor. READ-ONLY and MODEL-FREE: it opens the db
-        read-only and counts this repo's chunks — it must NOT call SemanticDb.init() (a schema
-        write) or load fastembed. ``repo_indexed`` is project-scoped (mirrors Searcher.has_index)."""
+        """Never-raise health check for the doctor. READ-ONLY: it opens the db read-only and counts
+        this repo's chunks — it must NOT call SemanticDb.init() (a schema write) or LOAD fastembed.
+        It does resolve the project's ``model`` *name* (a cheap config read, no model load) to pick
+        the per-model cache file. ``repo_indexed`` is project-scoped (mirrors Searcher.has_index)."""
         if not self.available:
             return {
                 "installed": False, "runnable": False, "repo_indexed": False,
@@ -36,8 +35,10 @@ class SemanticProvider:
         import sqlite3
 
         try:
+            from codeintel.config import load_config
             from codeintel.semantic_db import default_db_path
-            db_path = default_db_path()
+            model = str(load_config(project_root).get("model") or "")
+            db_path = default_db_path(model)
         except Exception:
             db_path = ""
         if not db_path or not os.path.exists(db_path):
@@ -59,8 +60,8 @@ class SemanticProvider:
         except Exception as exc:
             return {
                 "installed": True, "runnable": False, "repo_indexed": False,
-                "detail": f"semantic.db present but unreadable ({type(exc).__name__})",
-                "remediation": "rm ~/.codeintel/semantic.db && codeintel index <root>",
+                "detail": f"semantic cache present but unreadable ({type(exc).__name__})",
+                "remediation": f"codeintel reset {project_root} && codeintel index {project_root}",
             }
         if count > 0:
             return {
@@ -95,11 +96,16 @@ class SemanticProvider:
             from codeintel.indexer import Indexer
             from codeintel.searcher import Searcher
 
+            from codeintel.semantic_db import default_db_path
+
             cfg = load_config(project_root)
             model = str(cfg.get("model") or "BAAI/bge-small-en-v1.5")
 
-            _DB_PATH.parent.mkdir(parents=True, exist_ok=True)
-            db = SemanticDb(str(_DB_PATH))
+            # Per-model cache file: index and search for this repo use the SAME model → same file,
+            # so a repo configured with a different model can never corrupt or wipe another's rows.
+            db_path = default_db_path(model)
+            pathlib.Path(db_path).parent.mkdir(parents=True, exist_ok=True)
+            db = SemanticDb(db_path)
             db.init()
 
             searcher = Searcher(db, model_name=model)

{codecortex-0.8.2 → codecortex-0.8.4}/src/codeintel/reindexer.py

@@ -102,11 +102,11 @@ class Reindexer:
         from codeintel.semantic_db import SemanticDb, default_db_path
         from codeintel.indexer import Indexer
 
-        # Same per-machine cache the SemanticProvider reads — index and search must never diverge
+        # Same per-model cache file the SemanticProvider reads — index and search must never diverge
         # onto different files. Honor the project's config so the background pass indexes exactly
-        # like the inline and CLI paths (same model, window/stride, and chunk ceilings).
+        # like the inline and CLI paths (same model → same file, plus window/stride, ceilings).
         cfg = load_config(project_root)
-        db_path = default_db_path()
+        db_path = default_db_path(str(cfg.get("model") or ""))
         pathlib.Path(db_path).parent.mkdir(parents=True, exist_ok=True)
         db = SemanticDb(db_path)
         try:

{codecortex-0.8.2 → codecortex-0.8.4}/src/codeintel/reset.py

@@ -5,6 +5,7 @@ module is pure (dry-run by default via ``apply=False``).
 """
 from __future__ import annotations
 
+import glob
 import os
 import sqlite3
 
@@ -13,6 +14,16 @@ import sqlite_vec
 from codeintel.semantic_db import default_db_path
 
 
+def _cache_files() -> list[str]:
+    """Every per-model cache file (``semantic.db`` + ``semantic-<hash>.db``). Reset must sweep all
+    of them: a repo's rows can live in any model's file, and a model switch leaves orphans behind."""
+    base = os.path.dirname(default_db_path())
+    try:
+        return sorted(glob.glob(os.path.join(base, "semantic*.db")))
+    except Exception:
+        return []
+
+
 def _reset_scoped(project_root: str, path: str, apply: bool) -> dict:
     real = os.path.realpath(str(project_root))
     if not os.path.exists(path):
@@ -37,9 +48,12 @@ def _reset_scoped(project_root: str, path: str, apply: bool) -> dict:
         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,))
+            try:
+                conn.execute(
+                    "DELETE FROM code_embeddings WHERE chunk_id IN "
+                    "(SELECT chunk_id FROM chunk_hashes WHERE project_root=?)", (real,))
+            except Exception:
+                pass  # code_embeddings is created lazily at first embed — may not exist yet
             conn.execute("DELETE FROM chunk_hashes WHERE project_root=?", (real,))
             conn.commit()
 
@@ -88,13 +102,27 @@ def run_reset(
     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."""
+    """Drop indexed rows for ``project_root`` (or, with ``all_projects``, remove the whole cache —
+    every per-model db file plus their -wal/-shm siblings). ``apply=False`` is a dry-run: count
+    only, delete nothing. Never raises.
+
+    An explicit ``db_path`` operates on exactly that one file (the test seam / a targeted reset);
+    otherwise reset sweeps EVERY per-model cache file, so a repo's rows are cleared no matter which
+    model's file they landed in, and model-switch orphans are reclaimed."""
     try:
-        path = db_path if db_path is not None else default_db_path()
+        if db_path is not None:
+            return _reset_all(db_path, apply) if all_projects else _reset_scoped(project_root, db_path, apply)
+
+        files = _cache_files() or [default_db_path()]
         if all_projects:
-            return _reset_all(path, apply)
-        return _reset_scoped(project_root, path, apply)
+            count = sum(_reset_all(p, apply)["count"] for p in files)
+            verb = "removed" if apply else "would remove"
+            return {"ok": True, "mode": "all", "target": "ALL", "count": count,
+                    "applied": bool(apply), "detail": f"{verb} {count} index file(s) across all models"}
+        real = os.path.realpath(str(project_root))
+        count = sum(_reset_scoped(project_root, p, apply)["count"] for p in files)
+        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, "applied": apply, "detail": f"reset-error: {type(exc).__name__}: {exc}"}

{codecortex-0.8.2 → codecortex-0.8.4}/src/codeintel/semantic_db.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import hashlib
 import logging
 import pathlib
+import re
 import sqlite3
 
 import sqlite_vec
@@ -11,23 +13,45 @@ logger = logging.getLogger(__name__)
 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")
+def _base_dir() -> pathlib.Path:
+    """The per-machine cache directory. A single seam so tests can redirect every model's db
+    file at once (patch this, not each computed path)."""
+    return pathlib.Path.home() / ".codeintel"
+
+
+def _model_slug(model: str) -> str:
+    # errors="replace" keeps this total (default_db_path promises it) even for a pathological
+    # model string with unpaired surrogates — unreachable via config, but the docstring says total.
+    return hashlib.sha256(model.strip().encode("utf-8", "replace")).hexdigest()[:12]
+
+
+def default_db_path(model: str | None = None) -> str:
+    """The per-machine semantic cache file for a given embedding ``model``. A sqlite-vec vec0 table
+    is single-dimension and different models' vectors are incompatible, so each model gets its OWN
+    file — different-model repos then coexist as separate files and can never corrupt or wipe each
+    other. The default model (and ``None``) map to the legacy ``semantic.db`` (zero migration); any
+    other model maps to ``semantic-<hash(model)>.db``.
+
+    Index and search for one repo MUST pass the same model → same file. Rows are still partitioned
+    by ``project_root`` WITHIN a shared-model file. Pure + total: any string yields a filename."""
+    base = _base_dir()
+    m = (model or "").strip()
+    if not m or m == DEFAULT_MODEL:
+        return str(base / "semantic.db")
+    return str(base / f"semantic-{_model_slug(m)}.db")
 
 
 class SemanticDb:
     """DB layer: opens a SQLite connection, loads sqlite-vec, and owns schema creation."""
 
-    dimension: int = 384
+    _DIM_RE = re.compile(r"float\s*\[\s*(\d+)\s*\]", re.IGNORECASE)
 
     def __init__(self, db_path: str) -> None:
         self.db_path = db_path
         self._conn: sqlite3.Connection | None = None
+        # The vec0 embedding dimension, discovered lazily from the table / the first real vector
+        # (see ensure_embeddings_table) rather than hardcoded — so any model's size just works.
+        self.dimension: int | None = None
 
     def conn(self) -> sqlite3.Connection:
         if self._conn is None:
@@ -68,12 +92,10 @@ class SemanticDb:
         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}]
-            );
-
+        # chunk_hashes + indexes are created now; code_embeddings is created LAZILY at the first
+        # write, sized to the embedding model's real vector length (ensure_embeddings_table) — a
+        # vec0 table is single-dimension, so it can't be created before the model's size is known.
+        c.executescript("""
             CREATE TABLE IF NOT EXISTS chunk_hashes (
                 chunk_id     TEXT PRIMARY KEY,
                 project_root TEXT NOT NULL,
@@ -94,6 +116,54 @@ class SemanticDb:
         """)
         c.commit()
 
+    def _table_dim(self) -> int | None:
+        """The existing code_embeddings vec0 dimension from the live schema (``FLOAT[N]``), or None
+        if the table is absent / unparseable."""
+        try:
+            row = self.conn().execute(
+                "SELECT sql FROM sqlite_master WHERE name = 'code_embeddings'"
+            ).fetchone()
+            if not row or not row[0]:
+                return None
+            m = self._DIM_RE.search(str(row[0]))
+            return int(m.group(1)) if m else None
+        except Exception:
+            return None
+
+    def ensure_embeddings_table(self, dim: int) -> int | None:
+        """Ensure ``code_embeddings`` exists sized to ``dim`` (the embedding's true length). Returns
+        the table dimension (== dim) on success, or ``None`` when it already exists at a DIFFERENT
+        dimension — the caller then skips the write, never mixing dimensions and never wiping data.
+        The table self-dimensions from the real vector, so any model (incl. future/unknown ones)
+        just works. Never raises.
+
+        A dimension mismatch is only reachable on the default-model file when a release bumps
+        ``DEFAULT_MODEL`` to a new-sized model (a non-default file is keyed by model, so its dim is
+        fixed); that release directs the user to ``codeintel reset`` once. Non-destructive here."""
+        try:
+            dim = int(dim)
+            if self.dimension is None:
+                self.dimension = self._table_dim()
+            if self.dimension == dim:
+                return dim
+            if self.dimension is not None:
+                logger.warning(
+                    "embedding dimension %d != cache dimension %d — skipping write; run "
+                    "`codeintel reset` to rebuild the semantic index for the new model",
+                    dim, self.dimension,
+                )
+                return None
+            self.conn().execute(
+                "CREATE VIRTUAL TABLE IF NOT EXISTS code_embeddings USING vec0("
+                f"chunk_id TEXT PRIMARY KEY, embedding FLOAT[{dim}])"
+            )
+            self.conn().commit()
+            self.dimension = dim
+            return dim
+        except Exception as exc:
+            logger.warning("ensure_embeddings_table failed: %s", exc)
+            return None
+
     def delete_file_orphans(
         self, project_root: str, file_path: str, keep_ids: set[str]
     ) -> int:

{codecortex-0.8.2 → codecortex-0.8.4}/src/codeintel/server.py

@@ -122,10 +122,18 @@ def code_status_handler(args: dict) -> dict:
             if semantic_available:
                 model = DEFAULT_MODEL
                 if project_root:
+                    try:  # report THIS repo's configured model, not the machine default
+                        from codeintel.config import load_config
+                        model = str(load_config(project_root).get("model") or DEFAULT_MODEL)
+                    except Exception:
+                        pass
                     indexed = bool(SemanticProvider().probe(project_root).get("repo_indexed"))
                 else:
+                    import glob
                     import os
-                    indexed = os.path.exists(default_db_path())
+                    # any per-model cache file (semantic.db / semantic-<hash>.db) counts as "indexed"
+                    base = os.path.dirname(default_db_path())
+                    indexed = bool(glob.glob(os.path.join(base, "semantic*.db")))
         except Exception:
             pass
 
@@ -210,10 +218,32 @@ def code_map_handler(args: dict) -> dict:
         return {"ok": True, "path": None, "size_bytes": 0, "note": "map-error"}
 
 
+# Surfaced by the MCP client to the model on connect (the standard `instructions` field): this is
+# how codeintel becomes the *default* way an agent understands code after `codeintel install`,
+# rather than just an available tool the agent may ignore in favor of grep/file-read.
+_MCP_INSTRUCTIONS = (
+    "codeintel unifies three code-intelligence engines — graph (call/import structure), LSP "
+    "(precise symbols/references), and semantic (embedding search) — behind one never-raise "
+    "`code.query` tool.\n\n"
+    "Prefer `code.query` as your FIRST step for understanding an unfamiliar or large codebase, "
+    "instead of grepping or reading files one by one: use it for who-calls-X (callers), what-X-calls "
+    "(callees), impact of a change, where-a-symbol-is-defined, how a call chain flows, and "
+    "natural-language 'find the code that does Y' search. It is graph-augmented and ranked, so it "
+    "beats raw grep for locating and relating code.\n\n"
+    "Orient on a new repo with `code.map` (ranked architecture: top symbols, entry points, routes). "
+    "If results look empty, call `code.doctor` — it says exactly what to index or install. "
+    "`code.status` reports engine health.\n\n"
+    "Every result is a safe envelope: `ok` is always true; a null `result` with a `reason` means "
+    "'nothing found / not indexed yet', NOT an error — read the `reason`/`hint` and, if it says the "
+    "repo isn't indexed, that resolves on the first query or via `codeintel index`."
+)
+
+
 def run() -> None:
+    from codeintel import __version__
     from codeintel.logconfig import configure_logging
     configure_logging()  # logs to stderr; stdout is the MCP protocol channel
-    mcp = MCPServer(name="codeintel")
+    mcp = MCPServer(name="codeintel", version=__version__, instructions=_MCP_INSTRUCTIONS)
 
     async def _code_query(
         op: str = "",
@@ -235,9 +265,26 @@ def run() -> None:
     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")
+    mcp.add_tool(_code_query, name="code.query", description=(
+        "Understand code across graph + LSP + semantic engines — prefer this over grep/file-read "
+        "for locating and relating code. ops: `search` (natural-language or symbol semantic search), "
+        "`symbol` (definition/signature), `callers`, `callees`, `impact`, `chain` (\"A->B\" call "
+        "path), `pattern` (graph-augmented grep), `overview` (architecture), `context` (fan-out). "
+        "`target` is the symbol/query; optional `engine` (auto|graph|lsp|semantic), `project_root`. "
+        "Never raises: `ok` is always true; a null `result` + `reason` means not-found/not-indexed."
+    ))
+    mcp.add_tool(_code_status, name="code.status", description=(
+        "Which engines (graph/LSP/semantic) are available and whether this repo is indexed. Check "
+        "this first if code.query keeps returning nothing."
+    ))
+    mcp.add_tool(_code_doctor, name="code.doctor", description=(
+        "Diagnose engine health + this repo's index status, with a concrete fix for each gap (what "
+        "to install or index). Run when code.query results look empty or an engine seems missing."
+    ))
+    mcp.add_tool(_code_map, name="code.map", description=(
+        "Generate/refresh CODE_INTEL.md — a ranked architecture overview (node/edge counts, top "
+        "symbols by caller count, entry points, routes). A great first call to orient on an "
+        "unfamiliar repo."
+    ))
 
     anyio.run(mcp.run_stdio_async)

{codecortex-0.8.2 → codecortex-0.8.4}/tests/test_doctor.py

@@ -157,7 +157,7 @@ def test_semantic_probe_real_db_indexed(tmp_path, monkeypatch):
     repo = tmp_path / "repo"
     repo.mkdir()
     _make_db(db_path, os.path.realpath(str(repo)))
-    monkeypatch.setattr("codeintel.semantic_db.default_db_path", lambda: str(db_path))
+    monkeypatch.setattr("codeintel.semantic_db.default_db_path", lambda *a, **k: str(db_path))
 
     r = SemanticProvider().probe(str(repo))
     assert r["installed"] is True and r["runnable"] is True and r["repo_indexed"] is True
@@ -172,7 +172,7 @@ def test_semantic_probe_real_db_indexed(tmp_path, monkeypatch):
 
 def test_semantic_probe_no_db(tmp_path, monkeypatch):
     monkeypatch.setattr("codeintel.providers.semantic._DEPS_OK", True)
-    monkeypatch.setattr("codeintel.semantic_db.default_db_path", lambda: str(tmp_path / "missing.db"))
+    monkeypatch.setattr("codeintel.semantic_db.default_db_path", lambda *a, **k: str(tmp_path / "missing.db"))
     r = SemanticProvider().probe(str(tmp_path))
     assert r["runnable"] is True and r["repo_indexed"] is False
     assert "codeintel index" in r["remediation"]
@@ -182,7 +182,7 @@ def test_semantic_probe_corrupt_db(tmp_path, monkeypatch):
     monkeypatch.setattr("codeintel.providers.semantic._DEPS_OK", True)
     db_path = tmp_path / "semantic.db"
     db_path.write_bytes(b"this is not a sqlite database")
-    monkeypatch.setattr("codeintel.semantic_db.default_db_path", lambda: str(db_path))
+    monkeypatch.setattr("codeintel.semantic_db.default_db_path", lambda *a, **k: str(db_path))
     r = SemanticProvider().probe(str(tmp_path))
     assert r["installed"] is True and r["runnable"] is False  # unreadable → not runnable
     assert r["remediation"]

{codecortex-0.8.2 → codecortex-0.8.4}/tests/test_e2e.py

@@ -58,8 +58,7 @@ def fixture_repo(tmp_path):
 
 
 def test_e2e_search_returns_ranked_result(fixture_repo, tmp_path, monkeypatch):
-    db_path = tmp_path / "e2e_semantic.db"
-    monkeypatch.setattr(_sem_mod, "_DB_PATH", db_path)
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
     monkeypatch.setattr(_sem_mod, "_DEPS_OK", True)
 
     with patch("fastembed.TextEmbedding", _FakeTextEmbedding):

{codecortex-0.8.2 → codecortex-0.8.4}/tests/test_hardening.py

@@ -24,7 +24,7 @@ def _patch_semantic(monkeypatch, tmp_path, has_index_value):
     from codeintel.indexer import Indexer
     from codeintel.searcher import Searcher
 
-    monkeypatch.setattr(sem, "_DB_PATH", tmp_path / "sem.db")
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
     calls = {"index": 0}
 
     def _fake_index(self, root):

{codecortex-0.8.2 → codecortex-0.8.4}/tests/test_integration.py

@@ -134,7 +134,7 @@ def test_overview_auto_falls_back_to_lsp():
 def test_empty_project_reports_no_index(tmp_path, monkeypatch):
     import codeintel.providers.semantic as sem
     empty = tmp_path / "empty"; empty.mkdir()
-    monkeypatch.setattr(sem, "_DB_PATH", tmp_path / "s.db")
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
     monkeypatch.setattr(sem, "_DEPS_OK", True)
     with patch("fastembed.TextEmbedding", _FakeTextEmbedding):
         r = SemanticProvider().build_result("search", "x", [], 0, str(empty))
@@ -150,7 +150,7 @@ def test_config_cosine_floor_reaches_searcher(tmp_path, monkeypatch):
         'cosine_floor = 0.99\nrerank = "off"\nrerank_candidates = 7\n'
     )
     (tmp_path / "code.py").write_text("def f():\n    return 1\n")
-    monkeypatch.setattr(sem, "_DB_PATH", tmp_path / "s.db")
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
     monkeypatch.setattr(sem, "_DEPS_OK", True)
 
     captured = {}

codecortex-0.8.4/tests/test_mcp_server.py

@@ -0,0 +1,42 @@
+"""MCP server advertisement (0.8.4).
+
+`codeintel install` only makes the tools *available*; for an agent to actually reach for them
+instead of grep/file-read, the server must advertise itself — the standard MCP `instructions`
+field plus tool descriptions that say when to use each. These assert that wiring.
+"""
+from __future__ import annotations
+
+import codeintel.server as srv
+
+
+def test_server_advertises_instructions_and_rich_tool_descriptions(monkeypatch):
+    captured: dict = {"kwargs": None, "tools": {}}
+
+    class _FakeMCP:
+        def __init__(self, **kwargs):
+            captured["kwargs"] = kwargs
+
+        def add_tool(self, fn, name=None, description=None):
+            captured["tools"][name] = description or ""
+
+        async def run_stdio_async(self):  # pragma: no cover - never awaited (anyio.run stubbed)
+            pass
+
+    monkeypatch.setattr(srv, "MCPServer", _FakeMCP)
+    monkeypatch.setattr(srv.anyio, "run", lambda *a, **k: None)  # don't block on stdio
+
+    srv.run()
+
+    kw = captured["kwargs"]
+    assert kw["name"] == "codeintel"
+    assert kw.get("version")  # server reports its version
+    instr = kw.get("instructions") or ""
+    assert "code.query" in instr
+    assert "grep" in instr.lower()          # explicitly steers the agent away from grep/file-read
+    assert "reason" in instr                # explains the never-raise safe-null envelope
+
+    tools = captured["tools"]
+    assert set(tools) == {"code.query", "code.status", "code.doctor", "code.map"}
+    # the primary tool sells when to use it, not the old throwaway one-liner
+    q = tools["code.query"]
+    assert "callers" in q and "grep" in q.lower() and len(q) > 100

codecortex-0.8.4/tests/test_model_dimension.py

@@ -0,0 +1,148 @@
+"""Embedding-model / vector-dimension handling (0.8.3).
+
+Different embedding models produce incompatible vectors (often different lengths), and a
+sqlite-vec vec0 table is single-dimension. The design isolates them PHYSICALLY: each model gets
+its own cache file (``semantic-<hash>.db``), and the vec0 table self-dimensions from the first
+real vector. Test #1 is the regression that caught the reverted global-wipe fix.
+"""
+from __future__ import annotations
+
+import glob
+import os
+from unittest.mock import patch
+
+import numpy as np
+
+from codeintel.indexer import Indexer
+from codeintel.reset import run_reset
+from codeintel.searcher import Searcher
+from codeintel.semantic_db import DEFAULT_MODEL, SemanticDb, default_db_path
+
+
+def _fake(dim):
+    class _F:
+        def __init__(self, model_name=None):
+            pass
+
+        def embed(self, texts):
+            return [np.full(dim, 0.1, dtype=np.float32) for _ in list(texts)]
+    return _F
+
+
+def _seed(path, project_root_real, cid="c1"):
+    db = SemanticDb(path)
+    db.init()
+    db.conn().execute(
+        "INSERT INTO chunk_hashes(chunk_id, project_root, file_path, chunk_start, content_hash)"
+        " VALUES (?,?,?,?,?)", (cid, project_root_real, "f.py", 0, "h"))
+    db.conn().commit()
+    db.close()
+
+
+# --------------------------------------------------------------------------- #1 THE regression
+
+def test_different_model_repos_do_not_wipe_each_other(tmp_path, monkeypatch):
+    # The reverted fix wiped the whole shared cache on a model mismatch; with two repos on
+    # different models that meant they perpetually destroyed each other. Per-model files make it
+    # physically impossible.
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
+    (tmp_path / "a").mkdir(); (tmp_path / "a" / "a.py").write_text("def a():\n    return 1\n")
+    (tmp_path / "b").mkdir(); (tmp_path / "b" / "b.py").write_text("def b():\n    return 2\n")
+
+    def index(repo, model, dim):
+        db = SemanticDb(default_db_path(model)); db.init()
+        with patch("fastembed.TextEmbedding", _fake(dim)):
+            Indexer(db, model_name=model).index(str(tmp_path / repo))
+        return db
+
+    # ping-pong: A(default,384) → B(other,768) → A → B, asserting each survives the other
+    for _ in range(2):
+        db_a = index("a", DEFAULT_MODEL, 384)
+        db_b = index("b", "other-model-768", 768)
+        assert Searcher(db_a, model_name=DEFAULT_MODEL).has_index(str(tmp_path / "a")), \
+            "repo A must survive repo B indexing under a different model"
+        assert Searcher(db_b, model_name="other-model-768").has_index(str(tmp_path / "b"))
+
+    # they live in DIFFERENT files
+    assert default_db_path(DEFAULT_MODEL) != default_db_path("other-model-768")
+    assert os.path.exists(tmp_path / "semantic.db")                    # A → default file
+    assert len(glob.glob(str(tmp_path / "semantic-*.db"))) == 1        # B → its own file
+
+
+# --------------------------------------------------------------------------- self-dimensioning
+
+def test_table_self_dimensions_from_first_vector(tmp_path):
+    db = SemanticDb(str(tmp_path / "y.db")); db.init()
+    assert db._table_dim() is None                       # init does NOT create code_embeddings
+    assert db.ensure_embeddings_table(768) == 768
+    assert db._table_dim() == 768                         # created at the real vector size, not 384
+
+
+def test_ensure_embeddings_table_skips_on_dimension_mismatch(tmp_path):
+    # the only in-file mismatch case (a DEFAULT_MODEL size bump): skip the write, never wipe
+    db = SemanticDb(str(tmp_path / "x.db")); db.init()
+    assert db.ensure_embeddings_table(384) == 384
+    assert db.ensure_embeddings_table(768) is None       # refuses
+    assert db._table_dim() == 384                         # table left intact, not recreated/wiped
+
+
+# --------------------------------------------------------------------------- path invariants
+
+def test_default_db_path_invariants(tmp_path, monkeypatch):
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
+    d = default_db_path
+    legacy = str(tmp_path / "semantic.db")
+    assert d() == d(None) == d("") == d("  ") == d(DEFAULT_MODEL) == legacy   # default → legacy file
+    assert d("other") != legacy and d("other").startswith(str(tmp_path / "semantic-"))
+    assert d("a") != d("b") and d("a") == d("a")          # distinct models distinct, same stable
+    assert d("wéird/model:v2") .endswith(".db")           # total: any string yields a filename
+
+
+# --------------------------------------------------------------------------- reset across files
+
+def test_scoped_reset_sweeps_all_model_files_but_spares_other_projects(tmp_path, monkeypatch):
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
+    real_a = os.path.realpath(str(tmp_path / "a"))
+    real_b = os.path.realpath(str(tmp_path / "b"))
+    # project A has rows in TWO model files; project B has rows in the default file
+    _seed(default_db_path(DEFAULT_MODEL), real_a, "a-default")
+    _seed(default_db_path("other"), real_a, "a-other")
+    db_b = SemanticDb(default_db_path(DEFAULT_MODEL))   # same default file as A's default rows
+    db_b.conn().execute(
+        "INSERT INTO chunk_hashes(chunk_id, project_root, file_path, chunk_start, content_hash)"
+        " VALUES (?,?,?,?,?)", ("b1", real_b, "g.py", 0, "h"))
+    db_b.conn().commit(); db_b.close()
+
+    res = run_reset(str(tmp_path / "a"), apply=True)      # no db_path → sweep every model file
+    assert res["count"] == 2                              # A's rows removed from BOTH files
+
+    surviving = SemanticDb(default_db_path(DEFAULT_MODEL)).conn().execute(
+        "SELECT COUNT(*) FROM chunk_hashes WHERE project_root=?", (real_b,)).fetchone()[0]
+    assert surviving == 1, "a scoped reset of A must leave project B untouched"
+
+
+def test_probe_and_build_result_resolve_the_same_file(tmp_path, monkeypatch):
+    # regression for the divergence the CHANGELOG says it closed (build_result used a module
+    # _DB_PATH, probe used default_db_path()): with a NON-default model both must hit the same file,
+    # or probe reports "not indexed" for a repo build_result just indexed.
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
+    monkeypatch.setattr("codeintel.providers.semantic._DEPS_OK", True)
+    from codeintel.providers.semantic import SemanticProvider
+    repo = tmp_path / "r"; repo.mkdir()
+    (repo / ".codeintel.toml").write_text('model = "custom-384-model"\n')
+    (repo / "m.py").write_text("def f():\n    return 1\n")
+
+    with patch("fastembed.TextEmbedding", _fake(384)):
+        SemanticProvider().build_result("search", "f", [], 0, str(repo))   # writes the model's file
+        assert os.path.exists(default_db_path("custom-384-model"))          # not the default file
+        assert SemanticProvider().probe(str(repo))["repo_indexed"] is True  # probe found the SAME file
+
+
+def test_reset_tolerates_absent_code_embeddings(tmp_path):
+    # code_embeddings is created lazily, so a seed-only db has none — reset must not choke on it
+    p = str(tmp_path / "x.db")
+    real = os.path.realpath(str(tmp_path))
+    _seed(p, real)
+    assert SemanticDb(p)._table_dim() is None             # confirms no code_embeddings table
+    res = run_reset(str(tmp_path), apply=True, db_path=p)
+    assert res["count"] == 1 and "removed" in res["detail"]

{codecortex-0.8.2 → codecortex-0.8.4}/tests/test_onboarding.py

@@ -59,7 +59,7 @@ def test_setup_index_real_db(tmp_path, monkeypatch):
     (repo / "sample.py").write_text("def greet():\n    return 'hello'\n")
 
     db_path = tmp_path / "semantic.db"
-    monkeypatch.setattr("codeintel.semantic_db.default_db_path", lambda: str(db_path))
+    monkeypatch.setattr("codeintel.semantic_db.default_db_path", lambda *a, **k: str(db_path))
 
     report = onboarding.run_setup(str(repo), do_index=True, out=io.StringIO())
     assert report["ok"] is True

{codecortex-0.8.2 → codecortex-0.8.4}/tests/test_semantic_provider.py

@@ -97,7 +97,7 @@ def test_available_when_deps_present(monkeypatch):
 def test_search_returns_matches(tmp_path, monkeypatch):
     (tmp_path / "sample.py").write_text("def greet():\n    return 'hello'\n")
     db_path = tmp_path / "semantic.db"
-    monkeypatch.setattr("codeintel.providers.semantic._DB_PATH", db_path)
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
     monkeypatch.setattr("codeintel.providers.semantic._DEPS_OK", True)
 
     with patch("fastembed.TextEmbedding", _FakeTextEmbedding):
@@ -135,7 +135,7 @@ def test_empty_index_safe_null(tmp_path, monkeypatch):
     empty_dir = tmp_path / "empty"
     empty_dir.mkdir()
     db_path = tmp_path / "semantic.db"
-    monkeypatch.setattr("codeintel.providers.semantic._DB_PATH", db_path)
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
     monkeypatch.setattr("codeintel.providers.semantic._DEPS_OK", True)
 
     with patch("fastembed.TextEmbedding", _FakeTextEmbedding):
@@ -155,7 +155,7 @@ def test_empty_index_safe_null(tmp_path, monkeypatch):
 def test_below_floor_returns_none(tmp_path, monkeypatch):
     (tmp_path / "code.py").write_text("x = 1\n")
     db_path = tmp_path / "semantic.db"
-    monkeypatch.setattr("codeintel.providers.semantic._DB_PATH", db_path)
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
     monkeypatch.setattr("codeintel.providers.semantic._DEPS_OK", True)
 
     with patch("fastembed.TextEmbedding", _FakeTextEmbedding), \
@@ -195,7 +195,7 @@ def test_context_op_is_accepted(monkeypatch):
 
 def test_provider_never_raises(tmp_path, monkeypatch):
     db_path = tmp_path / "semantic.db"
-    monkeypatch.setattr("codeintel.providers.semantic._DB_PATH", db_path)
+    monkeypatch.setattr("codeintel.semantic_db._base_dir", lambda: tmp_path)
     monkeypatch.setattr("codeintel.providers.semantic._DEPS_OK", True)
 
     with patch("codeintel.semantic_db.SemanticDb.init", side_effect=RuntimeError("injected")):

codecortex-0.8.2/src/codeintel/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.8.2"