codecortex 0.8.1__tar.gz → 0.8.3__tar.gz

{codecortex-0.8.1/src/codecortex.egg-info → codecortex-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.8.1
+Version: 0.8.3
 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.1 → codecortex-0.8.3/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.8.1
+Version: 0.8.3
 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.1 → codecortex-0.8.3}/src/codecortex.egg-info/SOURCES.txt

@@ -48,10 +48,12 @@ tests/test_graph_stdin.py
 tests/test_hardening.py
 tests/test_http_auth.py
 tests/test_http_server.py
+tests/test_installer.py
 tests/test_integration.py
 tests/test_lsp_provider.py
 tests/test_lsp_real.py
 tests/test_mapper.py
+tests/test_model_dimension.py
 tests/test_never_raise.py
 tests/test_onboarding.py
 tests/test_rbac.py

codecortex-0.8.3/src/codeintel/__init__.py

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

{codecortex-0.8.1 → codecortex-0.8.3}/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.1 → codecortex-0.8.3}/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.3/src/codeintel/installer.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+
+_AGENTS = ["claude", "codex", "gemini", "zed"]
+
+
+def _atomic_write_text(path: pathlib.Path, text: str) -> None:
+    """Write via a sibling temp file + os.replace so an interrupted write can never truncate
+    the user's existing agent config (which holds unrelated settings) to a partial/empty file.
+    The temp lives in the same directory as ``path`` so the replace stays on one filesystem."""
+    tmp = path.with_name(path.name + ".codeintel.tmp")
+    tmp.write_text(text, encoding="utf-8")
+    os.replace(tmp, path)
+
+
+# Per-agent registration recipe. Most agents take a Claude-style JSON block; Codex is different —
+# its CLI reads MCP servers from ``~/.codex/config.toml`` as ``[mcp_servers.<name>]`` TOML tables,
+# NOT a JSON ``mcpServers`` map in config.json (writing the latter registers nothing).
+_CONFIG: dict[str, dict] = {
+    "claude": {
+        "format": "json",
+        "path": "~/.claude/settings.json",
+        "key": ["mcpServers", "codeintel"],
+        "value": {"command": "codeintel", "args": ["serve"]},
+    },
+    "codex": {
+        "format": "toml-mcp",
+        "path": "~/.codex/config.toml",
+        "table": "[mcp_servers.codeintel]",
+        "block": '[mcp_servers.codeintel]\ncommand = "codeintel"\nargs = ["serve"]\n',
+    },
+    "gemini": {
+        "format": "json",
+        "path": "~/.gemini/settings.json",
+        "key": ["mcpServers", "codeintel"],
+        "value": {"command": "codeintel", "args": ["serve"]},
+    },
+    "zed": {
+        "format": "json",
+        "path": "~/.config/zed/settings.json",
+        "key": ["context_servers", "codeintel"],
+        "value": {"command": {"path": "codeintel", "args": ["serve"]}},
+    },
+}
+
+
+def _get_nested(data: dict, keys: list[str]):
+    node = data
+    for k in keys:
+        if not isinstance(node, dict) or k not in node:
+            return None
+        node = node[k]
+    return node
+
+
+def _set_nested(data: dict, keys: list[str], value) -> None:
+    node = data
+    for k in keys[:-1]:
+        if k not in node or not isinstance(node[k], dict):
+            node[k] = {}
+        node = node[k]
+    node[keys[-1]] = value
+
+
+class Installer:
+    def register(self, agent: str) -> dict:
+        spec = _CONFIG.get(agent)
+        if spec is None:
+            return self._result(agent, "", False, "failed", f"unknown agent '{agent}'")
+        config_path = pathlib.Path(spec["path"]).expanduser()
+        try:
+            if spec.get("format") == "toml-mcp":
+                return self._register_toml(agent, config_path, spec)
+            return self._register_json(agent, config_path, spec)
+        except Exception as exc:
+            return self._result(agent, str(config_path), False, "failed", str(exc))
+
+    def _register_json(self, agent: str, config_path: pathlib.Path, spec: dict) -> dict:
+        if config_path.exists():
+            data = json.loads(config_path.read_text(encoding="utf-8"))
+            if not isinstance(data, dict):
+                data = {}
+        else:
+            data = {}
+
+        if _get_nested(data, spec["key"]) == spec["value"]:
+            return self._result(agent, str(config_path), True, "already")
+
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        _set_nested(data, spec["key"], spec["value"])
+        _atomic_write_text(config_path, json.dumps(data, indent=2))
+        return self._result(agent, str(config_path), True, "registered")
+
+    def _register_toml(self, agent: str, config_path: pathlib.Path, spec: dict) -> dict:
+        """Codex: append an ``[mcp_servers.codeintel]`` table to config.toml, preserving everything
+        already there (other servers, project trust levels, hooks). Text-based on purpose — it must
+        not reformat or risk corrupting a config the user hand-edits, and it stays idempotent by
+        checking for the table header. If a codeintel entry already exists it is left untouched."""
+        existing = config_path.read_text(encoding="utf-8") if config_path.exists() else ""
+        if spec["table"] in existing:
+            return self._result(agent, str(config_path), True, "already")
+
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        if existing == "":
+            new_text = spec["block"]
+        else:
+            prefix = existing if existing.endswith("\n") else existing + "\n"
+            new_text = prefix + "\n" + spec["block"]  # blank line before the new table
+        _atomic_write_text(config_path, new_text)
+        return self._result(agent, str(config_path), True, "registered")
+
+    @staticmethod
+    def _result(agent: str, path: str, ok: bool, action: str, reason: str = "") -> dict:
+        return {"agent": agent, "path": path, "ok": ok, "action": action, "reason": reason}
+
+    def register_all(self) -> list[dict]:
+        return [self.register(agent) for agent in _AGENTS]

{codecortex-0.8.1 → codecortex-0.8.3}/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.1 → codecortex-0.8.3}/src/codeintel/providers/graph.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import os
 import shutil
 import subprocess
 import threading
@@ -107,6 +108,13 @@ class GraphProvider:
         older/mocked shape — accept both. Prefer an exact ``root_path`` match; otherwise the
         LONGEST prefix match (so ``.../project/codeintel`` resolves to codeintel, not its
         parent ``.../project``). Pure + static so ``_resolve_project`` and ``probe`` share it."""
+        # Normalize the input to an absolute realpath: the backend stores absolute root_paths, so a
+        # relative ``project_root`` (e.g. `codeintel map .` passing ".") would otherwise never match
+        # — the bug where the map/query silently reported "not indexed" from inside the repo.
+        try:
+            project_root = os.path.realpath(project_root)
+        except Exception:
+            pass
         entries = raw.get("projects", []) if isinstance(raw, dict) else raw
         if not isinstance(entries, list):
             return None

{codecortex-0.8.1 → codecortex-0.8.3}/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.1 → codecortex-0.8.3}/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.1 → codecortex-0.8.3}/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.1 → codecortex-0.8.3}/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.1 → codecortex-0.8.3}/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
 

{codecortex-0.8.1 → codecortex-0.8.3}/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.1 → codecortex-0.8.3}/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.1 → codecortex-0.8.3}/tests/test_graph_provider.py

@@ -1,12 +1,25 @@
 """GraphProvider tests: never-raise invariant and key behavioral guarantees."""
 from __future__ import annotations
 
+import os
 import subprocess
 
 from codeintel.providers.graph import GraphProvider
 from codeintel.server import code_status_handler
 
 
+def test_match_project_resolves_a_relative_path(tmp_path, monkeypatch):
+    # The backend stores absolute root_paths, so a relative project_root (e.g. `codeintel map .`)
+    # must be normalized before matching — otherwise resolution fails from inside the repo and the
+    # map/graph query silently reports "not indexed" (the map-stub bug).
+    real = os.path.realpath(str(tmp_path))
+    raw = {"projects": [{"name": "myrepo", "root_path": real}]}
+    monkeypatch.chdir(tmp_path)
+    assert GraphProvider._match_project(raw, ".") == "myrepo"      # relative resolves now
+    assert GraphProvider._match_project(raw, real) == "myrepo"     # absolute still works
+    assert GraphProvider._match_project(raw, os.path.join(real, "src")) == "myrepo"  # subdir prefix
+
+
 # ---------------------------------------------------------------------------
 # Group 1 — Never-raise: None args
 # ---------------------------------------------------------------------------