cortex-local 2.0.10__tar.gz → 2.1.0__tar.gz

{cortex_local-2.0.10 → cortex_local-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortex-local
-Version: 2.0.10
+Version: 2.1.0
 Summary: Local semantic search MCP server — notes + code, embedded Qdrant, fastembed
 Requires-Python: >=3.11
 Requires-Dist: click>=8.0.0

cortex_local-2.1.0/cortex/cli.py

@@ -0,0 +1,141 @@
+"""cortex CLI — index <path> and serve (stdio MCP)."""
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import click
+
+from .config import (
+    WORKSPACES_DIR, get_active_workspace, set_active_workspace, get_workspace_dir,
+)
+
+
+@click.group()
+def cli() -> None:
+    """cortex: local semantic search MCP server."""
+
+
+@cli.command()
+@click.argument("path", type=click.Path(exists=True, file_okay=False, resolve_path=True))
+def index(path: str) -> None:
+    """Index PATH (notes and/or code) into ~/.cortex."""
+    from .indexer import index_path
+    index_path(Path(path))
+
+
+@cli.command()
+def serve() -> None:
+    """Run cortex MCP server on stdio."""
+    from .mcp_server import run
+    run()
+
+
+@cli.command()
+def pull_models() -> None:
+    """Pre-download fastembed models."""
+    from .embedder import pull_models as _pull
+    _pull()
+
+
+@cli.command()
+def stats() -> None:
+    """Show cortex efficiency stats."""
+    from .state import _stats
+    from .mcp_server import _fmt_stats
+    from .config import VERSION
+    click.echo(_fmt_stats(VERSION, _stats, current=True))
+
+
+@cli.group()
+def workspace() -> None:
+    """Manage cortex workspaces."""
+
+
+@workspace.command("list")
+def workspace_list() -> None:
+    """List all workspaces and their status."""
+    active = get_active_workspace()
+    if not WORKSPACES_DIR.exists():
+        click.echo(f"No workspaces found. Active: '{active}' (not yet indexed).")
+        return
+    workspaces = sorted([d.name for d in WORKSPACES_DIR.iterdir() if d.is_dir()])
+    if not workspaces:
+        click.echo(f"No workspaces found. Active: '{active}'.")
+        return
+    click.echo(f"Active workspace: {active}\n")
+    for ws in workspaces:
+        marker = "* " if ws == active else "  "
+        has_index = (WORKSPACES_DIR / ws / "qdrant").exists()
+        click.echo(f"{marker}{ws} ({'indexed' if has_index else 'empty'})")
+
+
+@workspace.command("create")
+@click.argument("name")
+def workspace_create(name: str) -> None:
+    """Create a new workspace."""
+    ws_dir = get_workspace_dir(name)
+    if ws_dir.exists():
+        click.echo(f"Workspace '{name}' already exists.")
+        return
+    ws_dir.mkdir(parents=True, exist_ok=True)
+    click.echo(f"Created workspace '{name}'. Switch with: cortex workspace switch {name}")
+
+
+@workspace.command("switch")
+@click.argument("name")
+def workspace_switch(name: str) -> None:
+    """Switch the active workspace."""
+    ws_dir = get_workspace_dir(name)
+    if not ws_dir.exists():
+        click.echo(f"Workspace '{name}' does not exist. Create it with: cortex workspace create {name}")
+        return
+    set_active_workspace(name)
+    click.echo(f"Switched to workspace '{name}'.")
+
+
+@workspace.command("delete")
+@click.argument("name")
+@click.confirmation_option(prompt="Delete workspace and all its data?")
+def workspace_delete(name: str) -> None:
+    """Delete a workspace and all its indexed data."""
+    if name == get_active_workspace():
+        click.echo("Cannot delete active workspace. Switch first.")
+        return
+    ws_dir = get_workspace_dir(name)
+    if not ws_dir.exists():
+        click.echo(f"Workspace '{name}' does not exist.")
+        return
+    shutil.rmtree(ws_dir)
+    click.echo(f"Deleted workspace '{name}'.")
+
+
+@workspace.command("current")
+def workspace_current() -> None:
+    """Print the active workspace name."""
+    click.echo(get_active_workspace())
+
+
+@cli.command("install")
+def install_cmd() -> None:
+    """Download embedding models and register cortex MCP in Claude Code."""
+    from .embedder import pull_models as _pull
+    click.echo("Downloading embedding models...")
+    _pull()
+    mcp_cmd = "claude mcp add cortex --transport stdio cortex serve"
+    claude = shutil.which("claude")
+    if not claude:
+        click.echo("Models ready. Register MCP manually (claude not found in PATH):")
+        click.echo(f"  {mcp_cmd}")
+        return
+    click.echo("Registering MCP server in Claude Code...")
+    result = subprocess.run(
+        [claude, "mcp", "add", "cortex", "--transport", "stdio", "cortex", "serve"],
+        capture_output=True, text=True,
+    )
+    if result.returncode == 0:
+        click.echo("Done. cortex is ready — restart Claude Code to activate.")
+    else:
+        click.echo(f"MCP registration failed. Run manually:\n  {mcp_cmd}")
+        click.echo(result.stderr.strip())

cortex_local-2.1.0/cortex/config.py

@@ -0,0 +1,64 @@
+"""Paths and constants for cortex local mode."""
+
+import shutil
+from pathlib import Path
+
+CORTEX_DIR = Path.home() / ".cortex"
+WORKSPACES_DIR = CORTEX_DIR / "workspaces"
+ACTIVE_WORKSPACE_FILE = CORTEX_DIR / "active_workspace"
+
+EMBED_MODEL = "nomic-ai/nomic-embed-text-v1.5"
+VECTOR_SIZE = 768
+
+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"
+
+
+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.0.10 → cortex_local-2.1.0}/cortex/indexer.py

@@ -10,7 +10,7 @@ from qdrant_client.models import (
     MatchValue, PointStruct, SparseVector, SparseVectorParams, VectorParams,
 )
 
-from .config import QDRANT_PATH, DATA_DIR, CACHE_FILE, VECTOR_SIZE
+from .config import qdrant_path, data_dir, cache_file, VECTOR_SIZE, migrate_legacy
 from .embedder import embed, sparse_embed
 from .core.chunker import chunk_file, CODE_EXTS, SKIP_DIRS
 from .core.cache import load_cache, save_cache
@@ -18,7 +18,10 @@ from .core import graph as _graph
 
 
 def _qdrant() -> QdrantClient:
-    return QdrantClient(path=QDRANT_PATH)
+    migrate_legacy()
+    d = data_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    return QdrantClient(path=qdrant_path())
 
 
 def _ensure_collection(client: QdrantClient, name: str) -> bool:
@@ -116,7 +119,7 @@ def index_notes(notes_dir: Path) -> int:
     md_files = [p for p in notes_dir.rglob("*.md")
                 if ".obsidian" not in p.parts and ".git" not in p.parts]
 
-    cache = load_cache("notes", CACHE_FILE)
+    cache = load_cache("notes", cache_file())
     if client.get_collection("notes").points_count == 0:
         cache = {}
     new_cache: dict = {}
@@ -139,12 +142,12 @@ def index_notes(notes_dir: Path) -> int:
             print(f"  {rel}: {len(points)} chunk(s)", flush=True)
         new_cache[rel] = mtime
 
-    save_cache("notes", new_cache, CACHE_FILE)
+    save_cache("notes", new_cache, cache_file())
     print(f"Done. {total} chunks indexed, {cached}/{len(md_files)} files cached.", flush=True)
 
     try:
         G = _graph.build_notes_graph(notes_dir)
-        _graph.persist_notes_graph(G, DATA_DIR)
+        _graph.persist_notes_graph(G, data_dir())
     except Exception as e:
         print(f"  notes graph failed: {e}")
 
@@ -170,7 +173,7 @@ def index_code(code_dir: Path) -> int:
         and not any(s in p.parts for s in SKIP_DIRS)
     ]
 
-    cache = load_cache("code", CACHE_FILE)
+    cache = load_cache("code", cache_file())
     if client.get_collection("code").points_count == 0:
         cache = {}
     new_cache = dict(cache)
@@ -198,7 +201,7 @@ def index_code(code_dir: Path) -> int:
             total += len(points)
             new_cache[cache_key] = mtime
 
-    save_cache("code", new_cache, CACHE_FILE)
+    save_cache("code", new_cache, cache_file())
     print(f"  {repo_name}: {total} chunks from {len(code_files) - cached} files ({cached} cached)", flush=True)
 
     all_files = {
@@ -208,7 +211,7 @@ def index_code(code_dir: Path) -> int:
         G = _graph.build_code_graph(code_dir, all_files)
         if G is not None:
             metadata = _graph.compute_code_metadata(G)
-            _graph.persist_code_graph(G, metadata, repo_name, DATA_DIR)
+            _graph.persist_code_graph(G, metadata, repo_name, data_dir())
             for file_rel, meta in metadata.items():
                 pids = file_point_ids.get(file_rel, [])
                 if pids:
@@ -233,7 +236,7 @@ def index_code(code_dir: Path) -> int:
 def index_path(path: Path) -> None:
     """Index a path — .md files as notes, code files as code."""
     path = path.resolve()
-    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    data_dir().mkdir(parents=True, exist_ok=True)
 
     md_files = list(path.rglob("*.md"))
     code_files = [p for p in path.rglob("*")

{cortex_local-2.0.10 → cortex_local-2.1.0}/cortex/mcp_server.py

@@ -10,9 +10,13 @@ from mcp.server.fastmcp import FastMCP
 from qdrant_client import QdrantClient
 from qdrant_client.models import Prefetch, Fusion, SparseVector
 
-from .config import QDRANT_PATH, DATA_DIR, VERSION, VECTOR_SIZE
+from .config import (
+    qdrant_path, data_dir, VERSION, VECTOR_SIZE,
+    WORKSPACES_DIR, get_active_workspace, set_active_workspace,
+    get_workspace_dir,
+)
 from .embedder import embed, sparse_embed
-from .state import _stats, get_graph_meta, save_stats
+from .state import _stats, get_graph_meta, save_stats, invalidate_graph_cache
 from .indexer import index_path
 
 mcp = FastMCP("cortex")
@@ -24,7 +28,7 @@ _reindex_path: str = ""
 
 
 def _qdrant() -> QdrantClient:
-    return QdrantClient(path=QDRANT_PATH)
+    return QdrantClient(path=qdrant_path())
 
 
 # ── Reindex ─────────────────────────────────────────────────────────────────
@@ -54,7 +58,7 @@ def _ppr_block(matched_files: list, matched_scores: list) -> str | None:
         from .core.notes_graph import ppr_augment
     except Exception:
         return None
-    graph_path = DATA_DIR / "graph_notes.json"
+    graph_path = data_dir() / "graph_notes.json"
     extras, reason = ppr_augment(matched_files, matched_scores, graph_path, _return_reason=True)
     if extras:
         _stats["ppr_fires"] += 1
@@ -376,6 +380,45 @@ cortex is available as an MCP tool. Use it proactively:
 {cortex_section}"""
 
 
+@mcp.tool()
+def switch_workspace(name: str) -> str:
+    """Switch the active cortex workspace.
+
+    Each workspace has its own isolated index (notes + code).
+    Use when switching between work/personal/project contexts.
+    Example: switch_workspace("work")
+    """
+    ws_dir = get_workspace_dir(name)
+    if not ws_dir.exists():
+        return (
+            f"Workspace '{name}' does not exist.\n"
+            f"Create it with: cortex workspace create {name}"
+        )
+    set_active_workspace(name)
+    invalidate_graph_cache()
+    return f"Switched to workspace '{name}'. search_code and search_notes now use this workspace's index."
+
+
+@mcp.tool()
+def list_workspaces() -> str:
+    """List all cortex workspaces and their status.
+
+    Shows which workspace is currently active and whether each has an index.
+    """
+    active = get_active_workspace()
+    if not WORKSPACES_DIR.exists():
+        return f"No workspaces found. Active: '{active}' (not yet indexed)."
+    workspaces = sorted([d.name for d in WORKSPACES_DIR.iterdir() if d.is_dir()])
+    if not workspaces:
+        return f"No workspaces found. Active: '{active}'."
+    lines = [f"Active workspace: {active}\n"]
+    for ws in workspaces:
+        marker = "* " if ws == active else "  "
+        has_index = (WORKSPACES_DIR / ws / "qdrant").exists()
+        lines.append(f"{marker}{ws} ({'indexed' if has_index else 'empty'})")
+    return "\n".join(lines)
+
+
 def run() -> None:
     """Entry point for stdio MCP server."""
     mcp.run(transport="stdio")

{cortex_local-2.0.10 → cortex_local-2.1.0}/cortex/state.py

@@ -4,10 +4,9 @@ import json
 from datetime import datetime, timezone
 from pathlib import Path
 
-from .config import DATA_DIR, STATS_FILE, VERSION
+from .config import data_dir, stats_file, VERSION
 
 _graph_cache: dict = {}
-
 _stats: dict = {}
 
 
@@ -35,8 +34,9 @@ def _default_stats() -> dict:
 def _load_stats() -> dict:
     defaults = _default_stats()
     try:
-        if STATS_FILE.exists():
-            data = json.loads(STATS_FILE.read_text())
+        sf = stats_file()
+        if sf.exists():
+            data = json.loads(sf.read_text())
             saved = data.get("versions", {}).get(VERSION, {})
             if saved:
                 return {**defaults, **saved}
@@ -47,12 +47,13 @@ def _load_stats() -> dict:
 
 def save_stats() -> None:
     try:
+        sf = stats_file()
         existing: dict = {}
-        if STATS_FILE.exists():
-            existing = json.loads(STATS_FILE.read_text()).get("versions", {})
+        if sf.exists():
+            existing = json.loads(sf.read_text()).get("versions", {})
         existing[VERSION] = {**_stats, "last_saved": datetime.now(timezone.utc).isoformat()}
-        STATS_FILE.parent.mkdir(parents=True, exist_ok=True)
-        STATS_FILE.write_text(json.dumps({"versions": existing}, indent=2))
+        sf.parent.mkdir(parents=True, exist_ok=True)
+        sf.write_text(json.dumps({"versions": existing}, indent=2))
     except Exception:
         pass
 
@@ -61,7 +62,7 @@ def get_graph_meta(repo_name: str) -> dict:
     if repo_name in _graph_cache:
         _stats["graph_cache_hits"] += 1
         return _graph_cache[repo_name]
-    path = DATA_DIR / f"graph_{repo_name}.json"
+    path = data_dir() / f"graph_{repo_name}.json"
     if not path.exists():
         _stats["graph_cache_misses"] += 1
         return {}

{cortex_local-2.0.10 → cortex_local-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cortex-local"
-version = "2.0.10"
+version = "2.1.0"
 description = "Local semantic search MCP server — notes + code, embedded Qdrant, fastembed"
 readme = "README.md"
 requires-python = ">=3.11"

cortex_local-2.0.10/cortex/cli.py

@@ -1,68 +0,0 @@
-"""cortex CLI — index <path> and serve (stdio MCP)."""
-
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-import click
-
-
-@click.group()
-def cli() -> None:
-    """cortex: local semantic search MCP server."""
-
-
-@cli.command()
-@click.argument("path", type=click.Path(exists=True, file_okay=False, resolve_path=True))
-def index(path: str) -> None:
-    """Index PATH (notes and/or code) into ~/.cortex."""
-    from .indexer import index_path
-    index_path(Path(path))
-
-
-@cli.command()
-def serve() -> None:
-    """Run cortex MCP server on stdio."""
-    from .mcp_server import run
-    run()
-
-
-@cli.command()
-def pull_models() -> None:
-    """Pre-download fastembed models."""
-    from .embedder import pull_models as _pull
-    _pull()
-
-
-@cli.command()
-def stats() -> None:
-    """Show cortex efficiency stats."""
-    from .state import _stats
-    from .mcp_server import _fmt_stats
-    from .config import VERSION
-    click.echo(_fmt_stats(VERSION, _stats, current=True))
-
-
-@cli.command("install")
-def install_cmd() -> None:
-    """Download embedding models and register cortex MCP in Claude Code."""
-    from .embedder import pull_models as _pull
-    click.echo("Downloading embedding models...")
-    _pull()
-    mcp_cmd = "claude mcp add cortex --transport stdio cortex serve"
-    claude = shutil.which("claude")
-    if not claude:
-        click.echo("Models ready. Register MCP manually (claude not found in PATH):")
-        click.echo(f"  {mcp_cmd}")
-        return
-    click.echo("Registering MCP server in Claude Code...")
-    result = subprocess.run(
-        [claude, "mcp", "add", "cortex", "--transport", "stdio", "cortex", "serve"],
-        capture_output=True, text=True,
-    )
-    if result.returncode == 0:
-        click.echo("Done. cortex is ready — restart Claude Code to activate.")
-    else:
-        click.echo(f"MCP registration failed. Run manually:\n  {mcp_cmd}")
-        click.echo(result.stderr.strip())

cortex_local-2.0.10/cortex/config.py

@@ -1,18 +0,0 @@
-"""Paths and constants for cortex local mode."""
-
-from pathlib import Path
-
-CORTEX_DIR = Path.home() / ".cortex"
-QDRANT_PATH = str(CORTEX_DIR / "qdrant")
-DATA_DIR = CORTEX_DIR
-STATS_FILE = CORTEX_DIR / "stats.json"
-CACHE_FILE = CORTEX_DIR / "embed_cache.json"
-
-EMBED_MODEL = "nomic-ai/nomic-embed-text-v1.5"
-VECTOR_SIZE = 768
-
-try:
-    from importlib.metadata import version
-    VERSION = version("cortex")
-except Exception:
-    VERSION = "dev"