superlocalmemory 3.4.53 → 3.4.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.53",
+  "version": "3.4.55",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.53"
+version = "3.4.55"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

package/scripts/install.sh

@@ -239,11 +239,63 @@ if [ -f "${REPO_DIR}/mcp_server.py" ]; then
     echo "✓ MCP server copied"
 fi
 
-# Copy config if not exists
-if [ ! -f "${INSTALL_DIR}/config.json" ]; then
-    echo "Creating default config..."
-    cp "${REPO_DIR}/config.json" "${INSTALL_DIR}/config.json"
-    echo "✓ Config created"
+# Interactive mode selection (v3.4.55)
+if [ ! -f "${INSTALL_DIR}/current_mode" ] && [ "${NON_INTERACTIVE}" != "true" ]; then
+    echo ""
+    echo "┌─────────────────────────────────────────────┐"
+    echo "│         SuperLocalMemory V3 — Setup         │"
+    echo "└─────────────────────────────────────────────┘"
+    echo ""
+    echo "  Choose operating mode:"
+    echo ""
+    echo "    [A] Zero-Cloud — Pure local, no API keys needed"
+    echo "        • Embedding: sentence-transformers (local)"
+    echo "        • LLM: none"
+    echo "        • Best for: privacy, air-gapped, EU AI Act"
+    echo ""
+    echo "    [B] Local AI — Ollama-powered (recommended)"
+    echo "        • Embedding: ollama / nomic-embed-text"
+    echo "        • LLM: ollama / llama3.2"
+    echo "        • Best for: full offline AI, zero cost"
+    echo ""
+    echo "    [C] Cloud Power — OpenRouter / OpenAI API"
+    echo "        • Embedding: text-embedding-3-large"
+    echo "        • LLM: claude-sonnet-4 / gpt-4.1-mini"
+    echo "        • Best for: max quality, API required"
+    echo ""
+    read -r -p "  Enter mode [A/B/C] (default: B): " MODE_CHOICE
+    MODE_CHOICE=${MODE_CHOICE:-b}
+    case "${MODE_CHOICE,,}" in
+        a) SELECTED_MODE="a" ;;
+        c) SELECTED_MODE="c" ;;
+        *) SELECTED_MODE="b" ;;
+    esac
+    echo ""
+    echo "  → Selected Mode ${SELECTED_MODE^^}"
+    echo ""
+    # Generate initial 3-mode config via Python
+    python3 -c "
+from superlocalmemory.core.config import SLMConfig
+SLMConfig.migrate_to_3mode()
+SLMConfig.switch_mode('${SELECTED_MODE}')
+print('✓ Mode ${SELECTED_MODE^^} configured')
+print('  Config files created: mode_a.json, mode_b.json, mode_c.json')
+print('  Run slm mode a/b/c to switch modes later')
+"
+elif [ ! -f "${INSTALL_DIR}/config.json" ] && [ "${NON_INTERACTIVE}" = "true" ]; then
+    echo "Creating default config (non-interactive, Mode B)..."
+    python3 -c "
+from superlocalmemory.core.config import SLMConfig
+SLMConfig.migrate_to_3mode()
+print('✓ Default config created (Mode B)')
+"
+elif [ -f "${INSTALL_DIR}/config.json" ] && [ ! -f "${INSTALL_DIR}/current_mode" ]; then
+    echo "Migrating existing config to 3-mode system..."
+    python3 -c "
+from superlocalmemory.core.config import SLMConfig
+SLMConfig.migrate_to_3mode()
+print('✓ Config migrated — your settings preserved')
+"
 else
     echo "○ Config exists (keeping existing)"
 fi

package/src/superlocalmemory/__init__.py

@@ -3,7 +3,7 @@
 import os
 os.environ.setdefault("KMP_DUPLICATE_LIB_OK", "TRUE")
 
-__version__ = "3.4.53"
+__version__ = "3.4.55"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

package/src/superlocalmemory/cli/commands.py

@@ -652,30 +652,11 @@ def cmd_mode(args: Namespace) -> None:
 
     config = SLMConfig.load()
 
-    def _apply_mode_change(new_value: str) -> tuple[SLMConfig, bool]:
-        """Mutate-in-place mode switch. Returns (updated_config, llm_was_set).
-
-        Only changes ``config.mode``. If the user has no LLM provider
-        configured AND is moving to Mode B or C, populates the mode's
-        default LLM block so the daemon has something to talk to.
-        Everything else (embedding, retrieval, evolution, forgetting,
-        math, profile) is preserved byte-for-byte.
-        """
-        new_mode = Mode(new_value)
-        llm_was_set = False
-        if new_mode != Mode.A and not config.llm.provider:
-            defaults = SLMConfig.for_mode(new_mode)
-            config.llm = defaults.llm
-            llm_was_set = True
-        config.mode = new_mode
-        config.save(mode_change=True)
-        return config, llm_was_set
-
     if getattr(args, 'json', False):
         from superlocalmemory.cli.json_output import json_print
         if args.value:
             old_mode = config.mode.value.upper()
-            updated, _ = _apply_mode_change(args.value)
+            updated = SLMConfig.switch_mode(args.value)
             json_print("mode", data={
                 "previous_mode": old_mode, "current_mode": args.value.upper(),
             }, next_actions=[
@@ -690,22 +671,17 @@ def cmd_mode(args: Namespace) -> None:
         return
 
     if args.value:
-        updated, llm_was_set = _apply_mode_change(args.value)
+        updated = SLMConfig.switch_mode(args.value)
         print(f"Mode set to: {args.value.upper()}")
-
-        # v3.4.43: embedding/retrieval are now preserved, so the old
-        # "Embedding model changed. Re-indexing will run on next recall."
-        # warning no longer fires from a CLI mode switch — that was the
-        # symptom of the bug. The warning is retained ONLY as an
-        # informational note when LLM defaults were freshly populated.
-        if llm_was_set:
-            print(f"  ℹ LLM provider populated from mode defaults: "
-                  f"{updated.llm.provider}/{updated.llm.model}. "
-                  f"Run `slm provider set` to customize.")
+        print(f"  Embedding: {updated.embedding.provider}/{updated.embedding.model_name}")
+        if args.value.lower() != "a":
+            print(f"  LLM: {updated.llm.provider}/{updated.llm.model}")
+        print(f"  Reranker: ONNX cross-encoder (enabled)")
 
         # V3.3.4: Warn if Mode C lacks cloud API key
         if args.value == "c" and not updated.llm.api_key:
             print("  ⚠ Mode C requires a cloud API key. Run: slm provider set")
+        print("  ℹ Run `slm restart` to apply the new mode.")
     else:
         print(f"Current mode: {config.mode.value.upper()}")
 

package/src/superlocalmemory/core/config.py

@@ -12,9 +12,12 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass, field
 from pathlib import Path
 
+logger = logging.getLogger(__name__)
+
 from superlocalmemory.storage.models import Mode
 
 
@@ -25,6 +28,9 @@ from superlocalmemory.storage.models import Mode
 DEFAULT_BASE_DIR = Path.home() / ".superlocalmemory"
 DEFAULT_DB_NAME = "memory.db"
 DEFAULT_PROFILES_FILE = "profiles.json"
+CURRENT_MODE_FILE = "current_mode"
+# Populated lazily in _get_mode_config_path() to avoid circular imports
+_MODE_CONFIG_NAMES: dict | None = None
 
 
 # ---------------------------------------------------------------------------
@@ -950,3 +956,180 @@ class SLMConfig:
                 sheaf_contradiction_threshold=0.65,  # Higher for 3072d embeddings
             ),
         )
+
+    # ------------------------------------------------------------------
+    # 3-Mode config system (v3.4.54)
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _mode_config_path(base_dir: Path, mode: "Mode") -> Path:
+        """Return the per-mode config file path."""
+        from superlocalmemory.storage.models import Mode as _M
+        _names = {
+            _M.A: "mode_a.json",
+            _M.B: "mode_b.json",
+            _M.C: "mode_c.json",
+        }
+        return base_dir / _names.get(mode, "mode_a.json")
+
+    @staticmethod
+    def read_current_mode(base_dir: Path | None = None) -> str:
+        """Read the current mode from the ``current_mode`` file.
+
+        Returns ``\"b\"`` (the default) if the file doesn't exist.
+        """
+        _base = base_dir or DEFAULT_BASE_DIR
+        _f = _base / CURRENT_MODE_FILE
+        try:
+            return _f.read_text(encoding="utf-8").strip().lower() or "b"
+        except (OSError, FileNotFoundError):
+            return "b"
+
+    @staticmethod
+    def write_current_mode(mode: str, base_dir: Path | None = None) -> None:
+        """Write the current mode letter to ``current_mode``."""
+        _base = base_dir or DEFAULT_BASE_DIR
+        _base.mkdir(parents=True, exist_ok=True)
+        (_base / CURRENT_MODE_FILE).write_text(
+            mode.lower().strip(), encoding="utf-8",
+        )
+
+    @classmethod
+    def switch_mode(
+        cls,
+        new_mode: str,
+        base_dir: Path | None = None,
+    ) -> "SLMConfig":
+        """Switch to a different mode, preserving the old mode's config.
+
+        v3.4.54: Saves the current config as ``mode_{old}.json``, then
+        loads ``mode_{new}.json`` (or creates it from defaults if it
+        doesn't exist). Writes ``current_mode`` and persists the new
+        active config as ``config.json`` for backward compatibility
+        with tooling that reads it directly.
+
+        Returns the new active config.
+        """
+        from superlocalmemory.storage.models import Mode as _M
+        _base = base_dir or DEFAULT_BASE_DIR
+        _base.mkdir(parents=True, exist_ok=True)
+
+        old_config = cls.load(_base / "config.json")
+        old_mode = old_config.mode.value.lower()
+
+        new_mode_val = _M(new_mode.lower())
+
+        # 1. Save current config to its per-mode file (unless already
+        #    matched — prevents overwriting user customizations)
+        if old_mode != new_mode.lower():
+            old_path = cls._mode_config_path(_base, old_config.mode)
+            old_config.save(old_path)
+
+        # 2. Try to load the target mode's saved config.
+        new_path = cls._mode_config_path(_base, new_mode_val)
+        need_migration = False
+        if new_path.exists():
+            try:
+                new_config = cls.load(new_path)
+                # Ensure the loaded config actually has the right mode
+                if new_config.mode != new_mode_val:
+                    new_config = cls.for_mode(new_mode_val, base_dir=_base)
+            except Exception:
+                new_config = cls.for_mode(new_mode_val, base_dir=_base)
+        else:
+            # First time switching to this mode: try migrating from
+            # legacy config.json if it was already in this mode
+            legacy = _base / "config.json"
+            if legacy.exists():
+                try:
+                    import json
+                    _data = json.loads(legacy.read_text(encoding="utf-8"))
+                    _legacy_mode = _data.get("mode", "").lower()
+                    if _legacy_mode == new_mode.lower():
+                        # config.json IS this mode — use it directly
+                        new_config = cls.load(legacy)
+                        need_migration = True
+                    else:
+                        new_config = cls.for_mode(new_mode_val, base_dir=_base)
+                except Exception:
+                    new_config = cls.for_mode(new_mode_val, base_dir=_base)
+            else:
+                new_config = cls.for_mode(new_mode_val, base_dir=_base)
+
+        # 3. Save as active config.json (backward compat)
+        new_config.save(_base / "config.json", mode_change=True)
+
+        # 4. Write current_mode
+        cls.write_current_mode(new_mode, _base)
+
+        # 5. On first migration, also save mode_a.json and mode_c.json
+        #    so users have a complete set
+        if need_migration:
+            for _m in (_M.A, _M.B, _M.C):
+                _mp = cls._mode_config_path(_base, _m)
+                if not _mp.exists():
+                    try:
+                        _mc = cls.for_mode(_m, base_dir=_base)
+                        _mc.save(_mp)
+                    except Exception:
+                        pass
+
+        return new_config
+
+    @classmethod
+    def migrate_to_3mode(cls, base_dir: Path | None = None) -> bool:
+        """One-time migration: config.json → 3-mode system.
+
+        Called on daemon boot. Idempotent — if ``current_mode`` already
+        exists, this is a no-op. Returns True if migration was performed.
+        """
+        _base = base_dir or DEFAULT_BASE_DIR
+        _current = _base / CURRENT_MODE_FILE
+        if _current.exists():
+            return False  # already migrated
+
+        legacy = _base / "config.json"
+        if not legacy.exists():
+            # No config at all — write defaults and current_mode
+            from superlocalmemory.storage.models import Mode as _M
+            _def = cls.for_mode(_M.B, base_dir=_base)
+            _def.save(legacy)
+            cls.write_current_mode("b", _base)
+            for _m in (_M.A, _M.B, _M.C):
+                _mp = cls._mode_config_path(_base, _m)
+                if not _mp.exists():
+                    try:
+                        _mc = cls.for_mode(_m, base_dir=_base)
+                        _mc.save(_mp)
+                    except Exception:
+                        pass
+            return True
+
+        # Migrate existing config.json → mode_{current}.json
+        try:
+            config = cls.load(legacy)
+            current = config.mode.value.lower()
+            cls.write_current_mode(current, _base)
+
+            # Save current config to its mode file
+            mode_path = cls._mode_config_path(_base, config.mode)
+            config.save(mode_path)
+
+            # Generate other mode files from defaults
+            from superlocalmemory.storage.models import Mode as _M
+            for _m in (_M.A, _M.B, _M.C):
+                _mp = cls._mode_config_path(_base, _m)
+                if not _mp.exists():
+                    try:
+                        _mc = cls.for_mode(_m, base_dir=_base)
+                        _mc.save(_mp)
+                    except Exception:
+                        pass
+
+            logger.info(
+                "3-mode config system migrated: config.json → mode_%s.json. "
+                "All three mode configs generated.", current,
+            )
+            return True
+        except Exception:
+            return False

package/src/superlocalmemory/server/unified_daemon.py

@@ -446,6 +446,9 @@ async def lifespan(application: FastAPI):
         from superlocalmemory.core.config import SLMConfig
         from superlocalmemory.core.engine import MemoryEngine
 
+        # v3.4.54: one-time migration config.json → 3-mode system
+        SLMConfig.migrate_to_3mode()
+
         config = SLMConfig.load()
         engine = MemoryEngine(config)
         engine.initialize()
@@ -1095,6 +1098,192 @@ def _register_dashboard_routes(application: FastAPI) -> None:
     async def api_version():
         return JSONResponse({"version": _SLM_VERSION})
 
+    # v3.4.55: Mode switching & config API for the dashboard UI.
+    # The auto-settings.js expects /api/v3/* endpoints. These routes
+    # bridge the 3-mode config system to the existing settings page.
+
+    @application.get("/api/v3/auto")
+    async def v3_auto_detect():
+        """Auto-detect available providers from environment."""
+        import os as _os
+        providers = []
+        if _os.environ.get("OPENROUTER_API_KEY"):
+            providers.append({"id": "openrouter", "name": "OpenRouter", "has_key": True})
+        if _os.environ.get("OPENAI_API_KEY"):
+            providers.append({"id": "openai", "name": "OpenAI", "has_key": True})
+        if _os.environ.get("ANTHROPIC_API_KEY"):
+            providers.append({"id": "anthropic", "name": "Anthropic", "has_key": True})
+        # Ollama is always available as a local option if the server is reachable
+        try:
+            import httpx as _hx
+            _r = _hx.get("http://localhost:11434/api/tags", timeout=2.0)
+            ollama_models = []
+            if _r.status_code == 200:
+                ollama_models = [m["name"] for m in _r.json().get("models", [])]
+            providers.append({
+                "id": "ollama", "name": "Ollama (local)",
+                "has_key": False, "running": True,
+                "models": ollama_models,
+            })
+        except Exception:
+            providers.append({
+                "id": "ollama", "name": "Ollama (local)",
+                "has_key": False, "running": False, "models": [],
+            })
+        return {"providers": providers}
+
+    @application.get("/api/v3/mode")
+    async def v3_get_mode():
+        """Get current mode and available modes."""
+        from superlocalmemory.core.config import SLMConfig
+        from superlocalmemory.storage.models import Mode as _M
+        _base = Path.home() / ".superlocalmemory"
+        current = SLMConfig.read_current_mode(_base)
+        modes = {}
+        for _m in (_M.A, _M.B, _M.C):
+            _name = _m.value.lower()
+            _path = SLMConfig._mode_config_path(_base, _m)
+            _cfg = None
+            if _path.exists():
+                try:
+                    _cfg = SLMConfig.load(_path)
+                except Exception:
+                    pass
+            modes[_name] = {
+                "label": {"a": "Zero-Cloud", "b": "Local AI", "c": "Cloud Power"}[_name],
+                "config_exists": _path.exists(),
+                "embedding_provider": getattr(_cfg.embedding, "provider", "") if _cfg else "",
+                "embedding_model": getattr(_cfg.embedding, "model_name", "") if _cfg else "",
+                "llm_provider": getattr(_cfg.llm, "provider", "") if _cfg else "",
+                "llm_model": getattr(_cfg.llm, "model", "") if _cfg else "",
+                "reranker": _cfg.retrieval.use_cross_encoder if _cfg else True,
+            }
+        return {"current_mode": current, "modes": modes}
+
+    @application.post("/api/v3/mode/set")
+    async def v3_set_mode(request: Request):
+        """Switch mode and optionally update provider/model. Body matches
+        the auto-settings.js saveSettings() payload."""
+        from superlocalmemory.core.config import SLMConfig
+        try:
+            body = await request.json()
+            new_mode = (body.get("mode") or body.get("settings_mode") or "").lower().strip()
+            if new_mode not in ("a", "b", "c"):
+                return JSONResponse(
+                    {"ok": False, "error": "mode must be a, b, or c"},
+                    status_code=400,
+                )
+            config = SLMConfig.switch_mode(new_mode)
+
+            # If provider/model were sent, update the saved config
+            provider = body.get("provider", "").strip()
+            if provider and new_mode != "a":
+                _base = Path.home() / ".superlocalmemory"
+                from superlocalmemory.core.config import LLMConfig, EmbeddingConfig
+                # Update LLM
+                model = body.get("model", "").strip()
+                api_key = body.get("api_key", "").strip()
+                endpoint = body.get("endpoint", "").strip()
+                if provider or model:
+                    config.llm = LLMConfig(
+                        provider=provider or config.llm.provider,
+                        model=model or config.llm.model,
+                        api_key=api_key or config.llm.api_key,
+                        api_base=endpoint or config.llm.api_base,
+                    )
+                # Update embedding
+                emb_provider = body.get("embedding_provider", "").strip()
+                emb_model = body.get("embedding_model", "").strip()
+                emb_key = body.get("embedding_key", "").strip()
+                if emb_provider or emb_model:
+                    config.embedding = EmbeddingConfig(
+                        provider=emb_provider or config.embedding.provider,
+                        model_name=emb_model or config.embedding.model_name,
+                        dimension=config.embedding.dimension,
+                        api_key=emb_key or config.embedding.api_key,
+                    )
+                config.save(mode_change=True)
+
+            return {
+                "ok": True, "mode": new_mode,
+                "embedding": f"{config.embedding.provider}/{config.embedding.model_name}",
+                "llm": f"{config.llm.provider}/{config.llm.model}",
+                "message": f"Switched to Mode {new_mode.upper()}. Run slm restart to apply.",
+            }
+        except Exception as exc:
+            return JSONResponse({"ok": False, "error": str(exc)}, status_code=500)
+
+    @application.get("/api/v3/ollama/status")
+    async def v3_ollama_status():
+        """Check if Ollama is running and list available models."""
+        try:
+            import httpx as _hx
+            _r = _hx.get("http://localhost:11434/api/tags", timeout=3.0)
+            if _r.status_code == 200:
+                _data = _r.json()
+                return {
+                    "running": True,
+                    "models": [{"name": m["name"], "size": m.get("size", 0)}
+                               for m in _data.get("models", [])],
+                }
+        except Exception:
+            pass
+        return {"running": False, "models": []}
+
+    @application.post("/api/v3/provider/test")
+    async def v3_provider_test(request: Request):
+        """Test a provider connection. Body: {provider, api_key, endpoint}."""
+        try:
+            body = await request.json()
+            provider = body.get("provider", "")
+            api_key = body.get("api_key", "")
+            endpoint = body.get("endpoint", "")
+            if provider == "ollama":
+                import httpx as _hx
+                _r = _hx.get(f"{endpoint or 'http://localhost:11434'}/api/tags", timeout=3.0)
+                return {"ok": _r.status_code == 200, "message": "Ollama reachable" if _r.status_code == 200 else f"HTTP {_r.status_code}"}
+            if provider in ("openai", "openrouter"):
+                import httpx as _hx
+                _url = f"{endpoint or 'https://api.openai.com/v1'}/models"
+                _headers = {"Authorization": f"Bearer {api_key}"}
+                _r = _hx.get(_url, headers=_headers, timeout=5.0)
+                return {"ok": _r.status_code == 200, "message": "API key valid" if _r.status_code == 200 else f"HTTP {_r.status_code}: {_r.text[:200]}"}
+            return {"ok": False, "message": f"Unknown provider: {provider}"}
+        except Exception as exc:
+            return {"ok": False, "message": str(exc)}
+
+    @application.get("/api/v3/embedding/config")
+    async def v3_get_embedding_config():
+        """Get current embedding configuration."""
+        engine = getattr(application.state, "engine", None)
+        if engine is None:
+            return JSONResponse({"ok": False, "error": "engine not initialized"}, status_code=503)
+        config = getattr(engine, "_config", None)
+        if config is None:
+            return JSONResponse({"ok": False, "error": "no config loaded"}, status_code=503)
+        return {
+            "provider": getattr(config.embedding, "provider", ""),
+            "model_name": getattr(config.embedding, "model_name", ""),
+            "dimension": getattr(config.embedding, "dimension", 0),
+        }
+
+    @application.post("/api/v3/embedding/test")
+    async def v3_embedding_test(request: Request):
+        """Test embedding with current config. Body: {text: \"test\"}."""
+        try:
+            body = await request.json()
+            text = body.get("text", "test embedding")
+            engine = getattr(application.state, "engine", None)
+            if engine is None:
+                return {"ok": False, "error": "engine not initialized"}
+            embedder = getattr(engine, "_embedder", None)
+            if embedder is None:
+                return {"ok": False, "error": "embedder not available"}
+            vec = embedder.embed(text)
+            return {"ok": True, "dimensions": len(vec) if vec else 0}
+        except Exception as exc:
+            return {"ok": False, "error": str(exc)}
+
     @application.get("/", response_class=HTMLResponse)
     async def root():
         index_path = UI_DIR / "index.html"

package/src/superlocalmemory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.53
+Version: 3.4.55
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later