cortex-local 2.4.5__tar.gz → 2.5.2__tar.gz

{cortex_local-2.4.5 → cortex_local-2.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cortex-local
-Version: 2.4.5
+Version: 2.5.2
 Summary: Local semantic search MCP server — notes + code, embedded Qdrant, fastembed
 Requires-Python: >=3.11
 Requires-Dist: click>=8.0.0
@@ -9,6 +9,12 @@ Requires-Dist: mcp[cli]>=2.0.0
 Requires-Dist: networkx>=3.0
 Requires-Dist: qdrant-client>=1.17.0
 Requires-Dist: tqdm>=4.0
+Requires-Dist: tree-sitter-c-sharp
+Requires-Dist: tree-sitter-javascript
+Requires-Dist: tree-sitter-kotlin
+Requires-Dist: tree-sitter-python
+Requires-Dist: tree-sitter-typescript
+Requires-Dist: tree-sitter>=0.22
 Requires-Dist: watchdog>=3.0
 Description-Content-Type: text/markdown
 

cortex_local-2.5.2/cortex/__init__.py

@@ -0,0 +1,10 @@
+"""cortex local package."""
+
+import os as _os
+
+# Installed wheels bundle core/ as cortex/core (hatch force-include). In a source
+# checkout (pip install -e, tests) it lives at <repo>/core — expose it as cortex.core.
+_here = _os.path.dirname(__file__)
+_repo_root = _os.path.normpath(_os.path.join(_here, "..", ".."))
+if not _os.path.isdir(_os.path.join(_here, "core")) and _os.path.isdir(_os.path.join(_repo_root, "core")):
+    __path__.append(_repo_root)  # type: ignore[name-defined]

{cortex_local-2.4.5 → cortex_local-2.5.2}/cortex/cli.py

@@ -19,14 +19,25 @@ from .config import (
 @click.version_option(VERSION, prog_name="cortex")
 def cli() -> None:
     """cortex: local semantic search MCP server."""
+    # Windows consoles default to cp1252; never crash on non-ASCII output (e.g. `claude mcp get`).
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(errors="replace")
+        except Exception:
+            pass
 
 
 @cli.command()
 @click.argument("path", type=click.Path(exists=True, file_okay=False, resolve_path=True))
-@click.option("--progress/--no-progress", default=True, help="Show tqdm progress bar.")
+@click.option("--progress/--no-progress", default=None,
+              help="Show tqdm progress bar (default: only when stderr is a terminal).")
 def index(path: str, progress: bool) -> None:
     """Index PATH (notes and/or code) into ~/.cortex."""
+    import logging
     from .indexer import index_path
+    logging.basicConfig(level=logging.INFO, format="%(message)s", stream=sys.stdout, force=True)
+    if progress is None:
+        progress = sys.stderr.isatty()
     index_path(Path(path), show_progress=progress)
     save_last_indexed_path(path)
 
@@ -34,8 +45,25 @@ def index(path: str, progress: bool) -> None:
 @cli.command()
 def serve() -> None:
     """Run cortex MCP server on stdio."""
-    from .mcp_server import run
-    run()
+    # stdout is the MCP channel: startup failures go to stderr (shown by `claude mcp get` / logs)
+    # instead of dying silently as "Connection closed".
+    try:
+        from .mcp_server import run
+    except Exception:
+        import traceback
+        sys.stderr.write(f"cortex {VERSION}: failed to start (import error):\n{traceback.format_exc()}")
+        sys.stderr.write("Try reinstalling: pipx install --force cortex-local\n")
+        sys.exit(1)
+    try:
+        run()
+    except KeyboardInterrupt:
+        pass
+    except Exception:
+        import logging
+        import traceback
+        logging.getLogger("cortex").exception("server crashed")
+        sys.stderr.write(f"cortex {VERSION}: server error:\n{traceback.format_exc()}")
+        sys.exit(1)
 
 
 @cli.command()
@@ -199,7 +227,7 @@ def install_cmd(scope: str) -> None:
         capture_output=True, text=True,
     )
     if result.returncode == 0:
-        click.echo(f"Done. cortex is ready (scope: {scope}) — restart Claude Code to activate.")
+        click.echo(f"Done. cortex is ready (scope: {scope}) - restart Claude Code to activate.")
     else:
         click.echo(f"MCP registration failed. Run manually:\n  {mcp_cmd}")
         click.echo(result.stderr.strip())
@@ -231,17 +259,21 @@ def doctor_cmd() -> None:
     click.echo(f"version      {VERSION}")
 
     cache_ok = MODELS_DIR.exists() and any(MODELS_DIR.iterdir())
-    click.echo(f"model cache  {'ok' if cache_ok else 'missing — run: cortex pull-models'}")
+    click.echo(f"model cache  {'ok' if cache_ok else 'missing - run: cortex pull-models'}")
 
     claude = shutil.which("claude")
     mcp_status = "claude not found in PATH"
     if claude:
         r = subprocess.run([claude, "mcp", "get", "cortex"], capture_output=True, text=True)
         if r.returncode == 0:
-            detail = r.stdout.strip().splitlines()[0] if r.stdout.strip() else "registered"
-            mcp_status = detail
+            fields = {}
+            for line in r.stdout.splitlines():
+                key, sep, val = line.strip().partition(":")
+                if sep and key in ("Scope", "Status"):
+                    fields[key] = val.strip()
+            mcp_status = ", ".join(f"{k.lower()}: {v}" for k, v in fields.items()) or "registered"
         else:
-            mcp_status = "not registered — run: cortex install"
+            mcp_status = "not registered - run: cortex install"
     click.echo(f"MCP          {mcp_status}")
 
     ws = get_active_workspace()
@@ -250,6 +282,14 @@ def doctor_cmd() -> None:
 
     last = get_config()["index"].get("last_path") or "(none)"
     click.echo(f"last indexed {last}")
+    from .config import read_index_meta
+    from .core.formatters import fmt_index_roots
+    roots = read_index_meta(ws).get("roots", {})
+    for line in fmt_index_roots(roots):
+        root = line.split(" ", 1)[0]
+        click.echo(f"root         {line}{'' if Path(root).exists() else ' (missing on disk)'}")
+    if indexed and not roots:
+        click.echo("note         index has no recorded roots - run: cortex index <path>")
 
     claude_json = Path.home() / ".claude.json"
     if claude_json.exists():

cortex_local-2.5.2/cortex/config.py

@@ -0,0 +1,184 @@
+"""Paths and constants for cortex local mode."""
+
+import json
+import os
+import shutil
+import tomllib
+from pathlib import Path
+
+CORTEX_DIR = Path.home() / ".cortex"
+MODELS_DIR = CORTEX_DIR / "models"
+WORKSPACES_DIR = CORTEX_DIR / "workspaces"
+ACTIVE_WORKSPACE_FILE = CORTEX_DIR / "active_workspace"
+CONFIG_FILE = CORTEX_DIR / "config.toml"
+
+_CONFIG_DEFAULTS: dict = {
+    "watch": {"enabled": True, "debounce_seconds": 2.0},
+    "index": {"last_path": "", "exclude_patterns": []},
+}
+_config_cache: dict | None = None
+
+EMBED_MODEL = "nomic-ai/nomic-embed-text-v1.5"
+VECTOR_SIZE = 768
+PPR_THRESHOLD = float(os.environ.get("PPR_THRESHOLD", "0.03"))
+
+try:
+    from importlib.metadata import version
+    VERSION = version("cortex-local")
+except Exception:
+    VERSION = "dev"
+
+
+def get_active_workspace() -> str:
+    if ACTIVE_WORKSPACE_FILE.exists():
+        return ACTIVE_WORKSPACE_FILE.read_text().strip() or "default"
+    return "default"
+
+
+def set_active_workspace(name: str) -> None:
+    CORTEX_DIR.mkdir(parents=True, exist_ok=True)
+    ACTIVE_WORKSPACE_FILE.write_text(name)
+
+
+def get_workspace_dir(name: str | None = None) -> Path:
+    return WORKSPACES_DIR / (name or get_active_workspace())
+
+
+def qdrant_path(ws: str | None = None) -> str:
+    return str(get_workspace_dir(ws) / "qdrant")
+
+
+def data_dir(ws: str | None = None) -> Path:
+    return get_workspace_dir(ws)
+
+
+def cache_file(ws: str | None = None) -> Path:
+    return get_workspace_dir(ws) / "embed_cache.json"
+
+
+def stats_file(ws: str | None = None) -> Path:
+    return get_workspace_dir(ws) / "stats.json"
+
+
+# Bump when stored payloads change incompatibly; older indexes are wiped and rebuilt.
+# 2: POSIX payload paths (2.4.5 stored backslashes on Windows).
+# 3: `root` payload + root-scoped point ids / cache keys (incremental deletes, multi-root).
+INDEX_SCHEMA = 3
+
+
+def index_meta_file(ws: str | None = None) -> Path:
+    return get_workspace_dir(ws) / "index_meta.json"
+
+
+def read_index_meta(ws: str | None = None) -> dict:
+    try:
+        return json.loads(index_meta_file(ws).read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def write_index_meta(meta: dict, ws: str | None = None) -> None:
+    f = index_meta_file(ws)
+    f.parent.mkdir(parents=True, exist_ok=True)
+    f.write_text(json.dumps(meta, indent=2), encoding="utf-8")
+
+
+def ensure_index_schema(ws: str | None = None) -> bool:
+    """Wipe an index built with an older schema. Returns True if a wipe happened.
+
+    Must run before any QdrantClient opens the workspace.
+    """
+    meta = read_index_meta(ws)
+    if meta.get("schema") == INDEX_SCHEMA:
+        return False
+    ws_dir = get_workspace_dir(ws)
+    wiped = False
+    qdir = ws_dir / "qdrant"
+    if qdir.exists():
+        shutil.rmtree(qdir, ignore_errors=True)
+        wiped = True
+    for f in [ws_dir / "embed_cache.json", *ws_dir.glob("graph_*.json")]:
+        if f.exists():
+            f.unlink()
+            wiped = True
+    meta = {"schema": INDEX_SCHEMA, "roots": {}}
+    write_index_meta(meta, ws)
+    if wiped:
+        import logging
+        logging.getLogger("cortex.config").warning(
+            "index schema changed (now v%d): old index wiped - run: cortex index <path>", INDEX_SCHEMA)
+    return wiped
+
+
+def get_config() -> dict:
+    global _config_cache
+    if _config_cache is not None:
+        return _config_cache
+    cfg: dict = {k: dict(v) for k, v in _CONFIG_DEFAULTS.items()}
+    if CONFIG_FILE.exists():
+        try:
+            loaded = tomllib.loads(CONFIG_FILE.read_text())
+            for section, vals in loaded.items():
+                if section in cfg and isinstance(vals, dict):
+                    cfg[section].update(vals)
+        except Exception as e:
+            import logging
+            logging.getLogger("cortex.config").warning("config.toml unreadable (%s): %s", CONFIG_FILE, e)
+    _config_cache = cfg
+    return cfg
+
+
+def _toml_value(v) -> str:
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, (int, float)):
+        return repr(v)
+    if isinstance(v, (list, tuple)):
+        return "[" + ", ".join(_toml_value(x) for x in v) + "]"
+    # JSON string escaping is valid TOML basic-string escaping (handles \\ and quotes).
+    return json.dumps(str(v))
+
+
+def save_config(cfg: dict) -> None:
+    """Write config.toml from a {section: {key: value}} dict."""
+    global _config_cache
+    CORTEX_DIR.mkdir(parents=True, exist_ok=True)
+    lines: list = []
+    for section, vals in cfg.items():
+        if not isinstance(vals, dict):
+            continue
+        lines.append(f"[{section}]")
+        lines.extend(f"{k} = {_toml_value(v)}" for k, v in vals.items())
+        lines.append("")
+    CONFIG_FILE.write_text("\n".join(lines), encoding="utf-8")
+    _config_cache = None
+
+
+def save_last_indexed_path(path: str) -> None:
+    """Record PATH as last indexed (stored as POSIX)."""
+    cfg = {k: dict(v) for k, v in get_config().items()}
+    cfg["index"]["last_path"] = Path(path).resolve().as_posix()
+    cfg["index"].pop("roots", None)  # 2.4.6 kept roots here; now per workspace in index_meta.json
+    save_config(cfg)
+
+
+def get_roots(ws: str | None = None) -> list:
+    """Index roots of a workspace that still exist on disk (from index_meta.json)."""
+    roots = list(read_index_meta(ws).get("roots", {}))
+    return [r for r in roots if Path(r).exists()]
+
+
+def migrate_legacy() -> None:
+    """Move old flat ~/.cortex/ layout into ~/.cortex/workspaces/default/ on first run."""
+    old_qdrant = CORTEX_DIR / "qdrant"
+    default_dir = WORKSPACES_DIR / "default"
+    if not old_qdrant.exists() or WORKSPACES_DIR.exists():
+        return
+    default_dir.mkdir(parents=True, exist_ok=True)
+    shutil.move(str(old_qdrant), str(default_dir / "qdrant"))
+    for fname in ("embed_cache.json", "stats.json"):
+        src = CORTEX_DIR / fname
+        if src.exists():
+            shutil.move(str(src), str(default_dir / fname))
+    for f in CORTEX_DIR.glob("graph_*.json"):
+        shutil.move(str(f), str(default_dir / f.name))

{cortex_local-2.4.5 → cortex_local-2.5.2}/cortex/core/cache.py

@@ -1,10 +1,13 @@
 #!/usr/bin/env python3
 """Mtime-based embedding cache — skip re-embedding unchanged files on full reindex."""
 
+import logging
 import json
 import os
 from pathlib import Path
 
+log = logging.getLogger("cortex.cache")
+
 
 def _default_cache_file() -> Path:
     repos_config = os.environ.get("REPOS_CONFIG", "/app/data/repos.json")
@@ -33,4 +36,4 @@ def save_cache(section: str, data: dict, cache_file: Path | None = None) -> None
         existing[section] = data
         cache_file.write_text(json.dumps(existing))
     except Exception as e:
-        print(f"warn: cache save failed: {e}", flush=True)
+        log.warning(f"warn: cache save failed: {e}")

{cortex_local-2.4.5 → cortex_local-2.5.2}/cortex/core/chunker.py

@@ -261,7 +261,7 @@ def chunk_file(path: Path, repo_name: str, base_dir: Path | None = None, github_
     ext = path.suffix
     base = base_dir if base_dir else path.parent
     try:
-        rel = str(path.relative_to(base))
+        rel = path.relative_to(base).as_posix()
     except ValueError:
         rel = path.name
     language = LANG_MAP.get(ext, ext.lstrip("."))

{cortex_local-2.4.5 → cortex_local-2.5.2}/cortex/core/code_graph.py

@@ -1,16 +1,19 @@
 #!/usr/bin/env python3
 """Code graph extraction — import/call/inheritance edges, centrality, Louvain communities."""
 
+import logging
 import json
 import re
 from pathlib import Path
 
+log = logging.getLogger("cortex.graph")
+
 try:
     import networkx as nx
     _NX_AVAILABLE = True
 except ImportError:
     _NX_AVAILABLE = False
-    print("Warning: networkx not installed — graph features disabled")
+    log.warning("Warning: networkx not installed - graph features disabled")
 
 _IMPORT_RE: dict = {
     "py": re.compile(r'^(?:from|import)\s+([\w.]+)', re.MULTILINE),
@@ -170,7 +173,53 @@ def _extract_named_imports_map(src: str) -> dict:
     return result
 
 
-def _extract_call_targets(path: Path, ext: str, all_files: set, rel: str) -> list:
+_KT_IMPORT_RE = re.compile(r'^import\s+([\w.]+?)(?:\s+as\s+(\w+))?\s*$', re.MULTILINE)
+_KT_QUALIFIED_RE = re.compile(r'\b([A-Z]\w*)\s*(?:\.|::)')
+
+
+def _extract_kotlin_call_targets(src: str, all_files: set, rel: str, symbol_to_file: dict) -> list:
+    """Kotlin call edges: imported names that are used, plus same-package types that are used.
+
+    "Used" = called (`Foo(`, `bar(`) or referenced as a receiver (`Foo.bar`, `Foo::class`).
+    Same-package (same directory) resolution only considers capitalized names — classes and
+    objects — because lowercase method names collide too easily.
+    """
+    called = {m.group(1) for m in _CALL_RE.finditer(src)}
+    called |= {m.group(1) for m in _KT_QUALIFIED_RE.finditer(src)}
+    targets: set = set()
+    imported: set = set()
+    for m in _KT_IMPORT_RE.finditer(src):
+        fq, alias = m.group(1), m.group(2)
+        if fq.endswith("."):
+            continue
+        simple = fq.rsplit(".", 1)[-1]
+        imported.add(simple)
+        if (alias or simple) not in called:
+            continue
+        resolved = _resolve_import(rel, fq, all_files, Path(rel).suffix)
+        if not resolved:
+            # top-level function or nested symbol: resolve by declared name
+            resolved = symbol_to_file.get(simple)
+        if resolved and resolved != rel:
+            targets.add(resolved)
+    rel_dir = Path(rel).parent
+    for name in called:
+        if name in imported or not name[:1].isupper():
+            continue
+        target = symbol_to_file.get(name)
+        if target and target != rel and Path(target).parent == rel_dir and Path(target).suffix in (".kt", ".kts"):
+            targets.add(target)
+    return list(targets)
+
+
+def _extract_call_targets(path: Path, ext: str, all_files: set, rel: str,
+                          symbol_to_file: dict | None = None) -> list:
+    if ext in (".kt", ".kts"):
+        try:
+            src = path.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            return []
+        return _extract_kotlin_call_targets(src, all_files, rel, symbol_to_file or {})
     if ext not in (".js", ".jsx", ".ts", ".tsx", ".svelte"):
         return []
     try:
@@ -283,7 +332,7 @@ def build_code_graph(repo_path: Path, all_files: set):
             resolved = _resolve_import(rel, imp, all_files, ext)
             if resolved and resolved != rel:
                 _add_edge(G, rel, resolved, "import")
-        for target in _extract_call_targets(path, ext, all_files, rel):
+        for target in _extract_call_targets(path, ext, all_files, rel, symbol_to_file):
             _add_edge(G, rel, target, "call")
         for target in _extract_inheritance_targets(path, ext, all_files, rel, symbol_to_file):
             _add_edge(G, rel, target, "inherits")
@@ -333,7 +382,7 @@ def persist_code_graph(G, metadata: dict, repo_name: str, data_dir: Path) -> Non
     }
     out = data_dir / f"graph_{repo_name}.json"
     out.write_text(json.dumps(data))
-    print(
+    log.info(
         f"  graph: {len(data['nodes'])} nodes, {len(data['edges'])} edges "
         f"(import:{edge_counts['import']} call:{edge_counts['call']} "
         f"inherits:{edge_counts['inherits']}) -> {out.name}"

{cortex_local-2.4.5 → cortex_local-2.5.2}/cortex/core/formatters.py

@@ -1,8 +1,53 @@
 """Shared result formatters for MCP search tools — used by server and local modes."""
 
+import time
 from datetime import datetime, timezone
 
 
+def strip_embed_header(text: str) -> str:
+    """Drop the synthetic `# repo/path (lines)` / path-token / framework lines the chunker
+    prepends for embedding — they only cost tokens in a result."""
+    lines = text.split("\n")
+    i = 0
+    while i < len(lines) and lines[i].startswith("# "):
+        i += 1
+    if i == 0:
+        return text
+    while i < len(lines) and not lines[i].strip():
+        i += 1
+    return "\n".join(lines[i:])
+
+
+def _display_path(p: dict, fallback_prefix: str = "") -> str:
+    """Absolute POSIX path when the index recorded a root (local mode), else repo-relative."""
+    root = p.get("root")
+    if root:
+        return f"{root}/{p['file']}"
+    return f"{fallback_prefix}/{p['file']}" if fallback_prefix else p["file"]
+
+
+def fmt_age(seconds: float) -> str:
+    seconds = max(0, int(seconds))
+    if seconds < 60:
+        return f"{seconds}s"
+    if seconds < 3600:
+        return f"{seconds // 60}m"
+    if seconds < 86400:
+        return f"{seconds // 3600}h"
+    return f"{seconds // 86400}d"
+
+
+def fmt_index_roots(roots: dict, now: float | None = None) -> list:
+    """One line per index root: `path @head (age ago) notes=N code=M`."""
+    now = now or time.time()
+    out = []
+    for root, m in sorted(roots.items()):
+        head = f" @{m['git_head']}" if m.get("git_head") else ""
+        age = f" ({fmt_age(now - m['indexed_at'])} ago)" if m.get("indexed_at") else ""
+        out.append(f"{root}{head}{age} notes={m.get('notes', 0)} code={m.get('code', 0)}")
+    return out
+
+
 def format_notes_parts(results) -> tuple:
     """Build parts list from note search results.
 
@@ -18,8 +63,12 @@ def format_notes_parts(results) -> tuple:
         p = r.payload
         tags = p.get("tags", [])
         tag_str = f" `{'`, `'.join(tags)}`" if tags else ""
+        text = p["text"]
+        heading = p.get("heading", "")
+        if heading and text.startswith(heading + "\n"):
+            text = text[len(heading):].lstrip("\n")  # chunk text repeats the heading
         parts.append(
-            f"**{p['file']} > {p['heading']}** (score: {round(r.score, 3)}){tag_str}\n\n{p['text']}"
+            f"**{_display_path(p)} > {heading}** (score: {round(r.score, 3)}){tag_str}\n\n{text}"
         )
         matched_files.append(p.get("file", ""))
         matched_scores.append(r.score)
@@ -38,7 +87,7 @@ def format_code_results(deduped) -> str:
         centrality = file_meta.get("centrality")
         community = file_meta.get("community_id")
         header = (
-            f"**{p['repo']}/{p['file']}** "
+            f"**{_display_path(p, p.get('repo', ''))}** "
             f"lines {p['start_line']}-{p['end_line']} "
             f"({p.get('language', '')}) — score: {round(boosted_score, 3)}"
         )
@@ -47,7 +96,8 @@ def format_code_results(deduped) -> str:
         if community is not None:
             header += f" · community: {community}"
         url = p.get("github_url", "")
-        parts.append(f"{header}\n{url}\n\n{p['text']}" if url else f"{header}\n\n{p['text']}")
+        text = strip_embed_header(p["text"])
+        parts.append(f"{header}\n{url}\n\n{text}" if url else f"{header}\n\n{text}")
     return "\n\n---\n\n".join(parts)
 
 

{cortex_local-2.4.5 → cortex_local-2.5.2}/cortex/core/global_graph.py

@@ -1,10 +1,13 @@
 #!/usr/bin/env python3
 """Global cross-repo graph — scans root config files for inter-repo references."""
 
+import logging
 import json
 import re
 from pathlib import Path
 
+log = logging.getLogger("cortex.graph")
+
 try:
     import networkx as nx
     _NX_AVAILABLE = True
@@ -84,4 +87,4 @@ def build_global_graph(repo_paths: dict, data_dir: Path) -> None:
     }
     out = data_dir / "graph_global.json"
     out.write_text(json.dumps(data))
-    print(f"  global graph: {len(repo_names)} repos, {len(data['edges'])} cross-repo edges -> {out.name}")
+    log.info(f"  global graph: {len(repo_names)} repos, {len(data['edges'])} cross-repo edges -> {out.name}")

{cortex_local-2.4.5 → cortex_local-2.5.2}/cortex/core/notes_graph.py

@@ -1,16 +1,19 @@
 #!/usr/bin/env python3
 """Notes graph — Obsidian wikilink edges and Personalized PageRank augmentation."""
 
+import logging
 import json
 import re
 from pathlib import Path
 
+log = logging.getLogger("cortex.graph")
+
 try:
     import networkx as nx
     _NX_AVAILABLE = True
 except ImportError:
     _NX_AVAILABLE = False
-    print("Warning: networkx not installed — graph features disabled")
+    log.warning("Warning: networkx not installed - graph features disabled")
 
 _WIKILINK_RE = re.compile(r'\[\[([^\[\]|#]+?)(?:\|[^\[\]]+)?\]\]')
 
@@ -52,7 +55,7 @@ def persist_notes_graph(G, data_dir: Path) -> None:
     }
     out = data_dir / "graph_notes.json"
     out.write_text(json.dumps(data))
-    print(f"  notes graph: {len(data['nodes'])} nodes, {len(data['edges'])} wikilink edges -> {out.name}")
+    log.info(f"  notes graph: {len(data['nodes'])} nodes, {len(data['edges'])} wikilink edges -> {out.name}")
 
 
 def ppr_augment(matched_files: list, scores: list, graph_path: Path, threshold: float = 0.03, _return_reason: bool = False):

cortex_local-2.5.2/cortex/db.py

@@ -0,0 +1,79 @@
+"""Shared embedded-Qdrant client for the active workspace.
+
+Embedded Qdrant holds an exclusive file lock per storage folder, so a process must use one
+client per workspace. The MCP server searches while the watcher / reindex() thread writes;
+every client call is serialized through one lock (local mode is not thread-safe), and whole
+index runs are serialized through `index_lock`.
+"""
+
+import atexit
+import logging
+import threading
+
+from qdrant_client import QdrantClient
+
+from .config import data_dir, ensure_index_schema, get_active_workspace, migrate_legacy, qdrant_path
+
+log = logging.getLogger("cortex.db")
+
+_lock = threading.RLock()
+index_lock = threading.Lock()
+_client: QdrantClient | None = None
+_client_ws: str | None = None
+
+
+class _Serialized:
+    """Proxy that runs every client method under the shared lock."""
+
+    def __init__(self, client: QdrantClient):
+        self._client = client
+
+    def __getattr__(self, name):
+        attr = getattr(self._client, name)
+        if not callable(attr):
+            return attr
+
+        def call(*args, **kwargs):
+            with _lock:
+                return attr(*args, **kwargs)
+        return call
+
+
+def client() -> _Serialized:
+    """Client for the active workspace; reopened when the workspace changes."""
+    global _client, _client_ws
+    with _lock:
+        ws = get_active_workspace()
+        if _client is None or ws != _client_ws:
+            reset()
+            migrate_legacy()
+            ensure_index_schema(ws)
+            data_dir(ws).mkdir(parents=True, exist_ok=True)
+            try:
+                _client = QdrantClient(path=qdrant_path(ws))
+            except Exception as e:
+                if "already" in str(e).lower() or "lock" in str(e).lower():
+                    raise SystemExit(
+                        "Error: Qdrant database is locked by another process (cortex serve is running).\n"
+                        "Stop cortex serve first, or use the reindex() MCP tool from Claude Code instead."
+                    ) from e
+                raise
+            _client_ws = ws
+            log.info("opened index for workspace '%s'", ws)
+        return _Serialized(_client)
+
+
+def reset() -> None:
+    """Close the current client (workspace switch, shutdown)."""
+    global _client, _client_ws
+    with _lock:
+        if _client is not None:
+            try:
+                _client.close()
+            except Exception:
+                pass
+        _client = None
+        _client_ws = None
+
+
+atexit.register(reset)