superlocalmemory 3.0.28 → 3.0.29

package/CHANGELOG.md

@@ -16,6 +16,14 @@ SuperLocalMemory V3 - Intelligent local memory system for AI coding assistants.
 
 ---
 
+## [3.0.29] - 2026-03-21
+
+### Fixed
+- Profile sync across CLI, Dashboard, and MCP — all entry points now see the same profiles
+- Profile switching now persists correctly across restarts
+
+---
+
 ## [2.8.6] - 2026-03-06
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.0.28",
+  "version": "3.0.29",
   "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.0.28"
+version = "3.0.29"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "MIT"}

package/src/superlocalmemory/cli/commands.py

@@ -699,10 +699,17 @@ def cmd_dashboard(args: Namespace) -> None:
 
 
 def cmd_profile(args: Namespace) -> None:
-    """Profile management (list, switch, create)."""
+    """Profile management (list, switch, create).
+
+    Writes to BOTH SQLite and profiles.json so CLI, Dashboard, and
+    MCP all see the same profiles.
+    """
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.storage.database import DatabaseManager
     from superlocalmemory.storage import schema
+    from superlocalmemory.server.routes.helpers import (
+        ensure_profile_in_json, set_active_profile_everywhere,
+    )
 
     config = SLMConfig.load()
     db = DatabaseManager(config.db_path)
@@ -721,6 +728,7 @@ def cmd_profile(args: Namespace) -> None:
                            {"command": "slm profile switch <name> --json", "description": "Switch profile"},
                        ])
         elif args.action == "switch":
+            set_active_profile_everywhere(args.name)
             config.active_profile = args.name
             config.save()
             json_print("profile", data={"action": "switched", "profile": args.name})
@@ -729,6 +737,7 @@ def cmd_profile(args: Namespace) -> None:
                 "INSERT OR IGNORE INTO profiles (profile_id, name) VALUES (?, ?)",
                 (args.name, args.name),
             )
+            ensure_profile_in_json(args.name)
             json_print("profile", data={"action": "created", "profile": args.name},
                        next_actions=[
                            {"command": f"slm profile switch {args.name} --json",
@@ -743,13 +752,14 @@ def cmd_profile(args: Namespace) -> None:
             d = dict(r)
             print(f"  - {d['profile_id']}: {d.get('name', '')}")
     elif args.action == "switch":
+        set_active_profile_everywhere(args.name)
         config.active_profile = args.name
         config.save()
         print(f"Switched to profile: {args.name}")
     elif args.action == "create":
-        from superlocalmemory.storage.models import _new_id
         db.execute(
             "INSERT OR IGNORE INTO profiles (profile_id, name) VALUES (?, ?)",
             (args.name, args.name),
         )
+        ensure_profile_in_json(args.name)
         print(f"Created profile: {args.name}")

package/src/superlocalmemory/mcp/tools_core.py

@@ -201,6 +201,14 @@ def register_core_tools(server, get_engine: Callable) -> None:
             engine = get_engine()
             old = engine.profile_id
             engine.profile_id = profile_id
+
+            # Persist to both config stores so CLI and Dashboard stay in sync
+            from superlocalmemory.server.routes.helpers import (
+                ensure_profile_in_db, set_active_profile_everywhere,
+            )
+            ensure_profile_in_db(profile_id)
+            set_active_profile_everywhere(profile_id)
+
             return {
                 "success": True,
                 "previous_profile": old,

package/src/superlocalmemory/server/routes/helpers.py

@@ -78,6 +78,168 @@ def validate_profile_name(name: str) -> bool:
     return bool(re.match(r'^[a-zA-Z0-9_-]+$', name))
 
 
+# ============================================================================
+# Profile Sync — SQLite as single source of truth
+# ============================================================================
+
+
+def ensure_profile_in_db(name: str, description: str = "") -> None:
+    """Ensure a profile row exists in SQLite (idempotent)."""
+    if not DB_PATH.exists():
+        return
+    conn = sqlite3.connect(str(DB_PATH))
+    try:
+        conn.execute("PRAGMA foreign_keys=ON")
+        conn.execute(
+            "INSERT OR IGNORE INTO profiles (profile_id, name, description) "
+            "VALUES (?, ?, ?)",
+            (name, name, description or f"Memory profile: {name}"),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+
+def ensure_profile_in_json(name: str, description: str = "") -> None:
+    """Ensure a profile entry exists in profiles.json (idempotent)."""
+    from datetime import datetime
+    config_file = MEMORY_DIR / "profiles.json"
+    config = _load_profiles_json()
+    profiles = config.get('profiles', {})
+    if name not in profiles:
+        profiles[name] = {
+            'name': name,
+            'description': description or f'Memory profile: {name}',
+            'created_at': datetime.now().isoformat(),
+            'last_used': None,
+        }
+        config['profiles'] = profiles
+        _save_profiles_json(config)
+
+
+def sync_profiles() -> list[dict]:
+    """Reconcile SQLite and profiles.json. Returns merged profile list.
+
+    SQLite is the source of truth. Any profile in profiles.json
+    that's missing from SQLite is added to SQLite. Any profile in
+    SQLite that's missing from profiles.json is added to profiles.json.
+    """
+    db_profiles = _get_db_profiles()
+    json_config = _load_profiles_json()
+    json_profiles = json_config.get('profiles', {})
+
+    db_names = {p['name'] for p in db_profiles}
+    json_names = set(json_profiles.keys())
+
+    changed = False
+
+    # JSON-only → add to SQLite (fixes Dashboard-created profiles)
+    for name in json_names - db_names:
+        ensure_profile_in_db(name, json_profiles[name].get('description', ''))
+
+    # SQLite-only → add to profiles.json (fixes CLI-created profiles)
+    for name in db_names - json_names:
+        db_entry = next(p for p in db_profiles if p['name'] == name)
+        json_profiles[name] = {
+            'name': name,
+            'description': db_entry.get('description', ''),
+            'created_at': db_entry.get('created_at', ''),
+            'last_used': db_entry.get('last_used'),
+        }
+        changed = True
+
+    if changed:
+        json_config['profiles'] = json_profiles
+        _save_profiles_json(json_config)
+
+    # Return merged list from SQLite (now authoritative)
+    return _get_db_profiles()
+
+
+def set_active_profile_everywhere(name: str) -> None:
+    """Persist the active profile to BOTH profiles.json and config.json."""
+    # profiles.json
+    config = _load_profiles_json()
+    config['active_profile'] = name
+    _save_profiles_json(config)
+
+    # config.json (read by Engine/MCP on startup)
+    config_path = MEMORY_DIR / "config.json"
+    cfg = {}
+    if config_path.exists():
+        try:
+            cfg = json.loads(config_path.read_text())
+        except (json.JSONDecodeError, IOError):
+            pass
+    cfg['active_profile'] = name
+    config_path.write_text(json.dumps(cfg, indent=2))
+
+
+def delete_profile_from_db(name: str) -> None:
+    """Delete a profile row from SQLite. ON DELETE CASCADE handles child rows."""
+    if not DB_PATH.exists():
+        return
+    conn = sqlite3.connect(str(DB_PATH))
+    try:
+        conn.execute("PRAGMA foreign_keys=ON")
+        conn.execute("DELETE FROM profiles WHERE profile_id = ?", (name,))
+        conn.commit()
+    finally:
+        conn.close()
+
+
+def _get_db_profiles() -> list[dict]:
+    """Read all profiles from SQLite."""
+    if not DB_PATH.exists():
+        return []
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    try:
+        rows = conn.execute(
+            "SELECT profile_id, name, description, created_at, last_used "
+            "FROM profiles ORDER BY name"
+        ).fetchall()
+        return [dict(r) for r in rows]
+    except sqlite3.OperationalError:
+        return []
+    finally:
+        conn.close()
+
+
+def _load_profiles_json() -> dict:
+    """Load profiles.json config (Dashboard dict format)."""
+    config_file = MEMORY_DIR / "profiles.json"
+    if config_file.exists():
+        try:
+            with open(config_file, 'r') as f:
+                data = json.load(f)
+            # Handle ProfileManager array format → convert to dict format
+            if isinstance(data.get('profiles'), list):
+                converted = {}
+                for p in data['profiles']:
+                    n = p.get('name', '')
+                    if n:
+                        converted[n] = p
+                data['profiles'] = converted
+                if 'active' in data and 'active_profile' not in data:
+                    data['active_profile'] = data.pop('active')
+            return data
+        except (json.JSONDecodeError, IOError):
+            pass
+    return {
+        'profiles': {'default': {'name': 'default', 'description': 'Default memory profile'}},
+        'active_profile': 'default',
+    }
+
+
+def _save_profiles_json(config: dict) -> None:
+    """Save profiles.json config."""
+    MEMORY_DIR.mkdir(parents=True, exist_ok=True)
+    config_file = MEMORY_DIR / "profiles.json"
+    with open(config_file, 'w') as f:
+        json.dump(config, f, indent=2)
+
+
 # ============================================================================
 # Pydantic Models (shared across routes)
 # ============================================================================

package/src/superlocalmemory/server/routes/profiles.py

@@ -6,16 +6,21 @@
 
 Routes: /api/profiles, /api/profiles/{name}/switch,
         /api/profiles/create, DELETE /api/profiles/{name}
+
+SQLite is the single source of truth for profiles. profiles.json
+is kept in sync as a cache for backward compatibility.
 """
-import json
 import logging
 from datetime import datetime
 
 from fastapi import APIRouter, HTTPException
 
 from .helpers import (
-    get_db_connection, get_active_profile, validate_profile_name,
-    ProfileSwitch, MEMORY_DIR, DB_PATH,
+    get_db_connection, validate_profile_name,
+    ProfileSwitch, DB_PATH,
+    sync_profiles, ensure_profile_in_db, ensure_profile_in_json,
+    set_active_profile_everywhere, delete_profile_from_db,
+    _load_profiles_json, _save_profiles_json,
 )
 
 logger = logging.getLogger("superlocalmemory.routes.profiles")
@@ -25,35 +30,11 @@ router = APIRouter()
 ws_manager = None
 
 
-def _load_profiles_config() -> dict:
-    """Load profiles.json config."""
-    config_file = MEMORY_DIR / "profiles.json"
-    if config_file.exists():
-        try:
-            with open(config_file, 'r') as f:
-                return json.load(f)
-        except (json.JSONDecodeError, IOError):
-            pass
-    return {
-        'profiles': {'default': {'name': 'default', 'description': 'Default memory profile'}},
-        'active_profile': 'default',
-    }
-
-
-def _save_profiles_config(config: dict) -> None:
-    """Save profiles.json config."""
-    MEMORY_DIR.mkdir(parents=True, exist_ok=True)
-    config_file = MEMORY_DIR / "profiles.json"
-    with open(config_file, 'w') as f:
-        json.dump(config, f, indent=2)
-
-
 def _get_memory_count(profile: str) -> int:
-    """Get memory count for a profile (V3 atomic_facts or V2 memories)."""
+    """Get memory count for a profile."""
     try:
         conn = get_db_connection()
         cursor = conn.cursor()
-        # Try V3 table first
         try:
             cursor.execute(
                 "SELECT COUNT(*) FROM atomic_facts WHERE profile_id = ?", (profile,),
@@ -72,20 +53,22 @@ def _get_memory_count(profile: str) -> int:
 
 @router.get("/api/profiles")
 async def list_profiles():
-    """List available memory profiles."""
+    """List available memory profiles (synced from SQLite + profiles.json)."""
     try:
-        config = _load_profiles_config()
-        active = config.get('active_profile', 'default')
-        profiles = []
+        merged = sync_profiles()
+        json_config = _load_profiles_json()
+        active = json_config.get('active_profile', 'default')
 
-        for name, info in config.get('profiles', {}).items():
+        profiles = []
+        for p in merged:
+            name = p.get('name', p.get('profile_id', ''))
             count = _get_memory_count(name)
             profiles.append({
                 "name": name,
-                "description": info.get('description', ''),
+                "description": p.get('description', ''),
                 "memory_count": count,
-                "created_at": info.get('created_at', ''),
-                "last_used": info.get('last_used', ''),
+                "created_at": p.get('created_at', ''),
+                "last_used": p.get('last_used', ''),
                 "is_active": name == active,
             })
 
@@ -101,24 +84,29 @@ async def list_profiles():
 
 @router.post("/api/profiles/{name}/switch")
 async def switch_profile(name: str):
-    """Switch active memory profile."""
+    """Switch active memory profile (persists to both config stores)."""
     try:
         if not validate_profile_name(name):
             raise HTTPException(status_code=400, detail="Invalid profile name.")
 
-        config = _load_profiles_config()
+        merged = sync_profiles()
+        merged_names = {p.get('name', p.get('profile_id', '')) for p in merged}
 
-        if name not in config.get('profiles', {}):
-            available = ', '.join(config.get('profiles', {}).keys())
+        if name not in merged_names:
+            available = ', '.join(sorted(merged_names))
             raise HTTPException(
                 status_code=404,
                 detail=f"Profile '{name}' not found. Available: {available}",
             )
 
-        previous = config.get('active_profile', 'default')
-        config['active_profile'] = name
-        config['profiles'][name]['last_used'] = datetime.now().isoformat()
-        _save_profiles_config(config)
+        previous = _load_profiles_json().get('active_profile', 'default')
+        set_active_profile_everywhere(name)
+
+        # Update last_used in profiles.json
+        json_config = _load_profiles_json()
+        if name in json_config.get('profiles', {}):
+            json_config['profiles'][name]['last_used'] = datetime.now().isoformat()
+            _save_profiles_json(json_config)
 
         count = _get_memory_count(name)
 
@@ -143,22 +131,22 @@ async def switch_profile(name: str):
 
 @router.post("/api/profiles/create")
 async def create_profile(body: ProfileSwitch):
-    """Create a new memory profile."""
+    """Create a new memory profile (writes to BOTH SQLite and profiles.json)."""
     try:
         name = body.profile_name
         if not validate_profile_name(name):
             raise HTTPException(status_code=400, detail="Invalid profile name")
 
-        config = _load_profiles_config()
-
-        if name in config.get('profiles', {}):
+        # Check both stores for duplicates
+        merged = sync_profiles()
+        merged_names = {p.get('name', p.get('profile_id', '')) for p in merged}
+        if name in merged_names:
             raise HTTPException(status_code=409, detail=f"Profile '{name}' already exists")
 
-        config['profiles'][name] = {
-            'name': name, 'description': f'Memory profile: {name}',
-            'created_at': datetime.now().isoformat(), 'last_used': None,
-        }
-        _save_profiles_config(config)
+        # Write to BOTH stores atomically
+        desc = f'Memory profile: {name}'
+        ensure_profile_in_db(name, desc)
+        ensure_profile_in_json(name, desc)
 
         return {"success": True, "profile": name, "message": f"Profile '{name}' created"}
 
@@ -175,16 +163,18 @@ async def delete_profile(name: str):
         if name == 'default':
             raise HTTPException(status_code=400, detail="Cannot delete 'default' profile")
 
-        config = _load_profiles_config()
-
-        if name not in config.get('profiles', {}):
+        merged = sync_profiles()
+        merged_names = {p.get('name', p.get('profile_id', '')) for p in merged}
+        if name not in merged_names:
             raise HTTPException(status_code=404, detail=f"Profile '{name}' not found")
-        if config.get('active_profile') == name:
+
+        json_config = _load_profiles_json()
+        if json_config.get('active_profile') == name:
             raise HTTPException(status_code=400, detail="Cannot delete active profile.")
 
+        # Move data to default before deleting (bypasses CASCADE)
         conn = get_db_connection()
         cursor = conn.cursor()
-        # Move memories to default (try V3 first, then V2)
         moved = 0
         try:
             cursor.execute(
@@ -196,7 +186,7 @@ async def delete_profile(name: str):
             pass
         try:
             cursor.execute(
-                "UPDATE memories SET profile = 'default' WHERE profile = ?",
+                "UPDATE memories SET profile_id = 'default' WHERE profile_id = ?",
                 (name,),
             )
             moved += cursor.rowcount
@@ -205,8 +195,13 @@ async def delete_profile(name: str):
         conn.commit()
         conn.close()
 
-        del config['profiles'][name]
-        _save_profiles_config(config)
+        # Delete from BOTH stores
+        delete_profile_from_db(name)
+
+        profiles = json_config.get('profiles', {})
+        profiles.pop(name, None)
+        json_config['profiles'] = profiles
+        _save_profiles_json(json_config)
 
         return {
             "success": True,