superlocalmemory 2.5.1 → 2.6.0

package/mcp_server.py

@@ -28,7 +28,9 @@ Usage:
 from mcp.server.fastmcp import FastMCP
 from mcp.types import ToolAnnotations
 import sys
+import os
 import json
+import re
 from pathlib import Path
 from typing import Optional
 
@@ -54,6 +56,25 @@ try:
 except ImportError:
     PROVENANCE_AVAILABLE = False
 
+# Trust Scorer (v2.6 — enforcement)
+try:
+    from trust_scorer import TrustScorer
+    TRUST_AVAILABLE = True
+except ImportError:
+    TRUST_AVAILABLE = False
+
+def _sanitize_error(error: Exception) -> str:
+    """Strip internal paths and structure from error messages."""
+    msg = str(error)
+    # Strip file paths containing claude-memory
+    msg = re.sub(r'/[\w./-]*claude-memory[\w./-]*', '[internal-path]', msg)
+    # Strip file paths containing SuperLocalMemory
+    msg = re.sub(r'/[\w./-]*SuperLocalMemory[\w./-]*', '[internal-path]', msg)
+    # Strip SQLite table names from error messages
+    msg = re.sub(r'table\s+\w+', 'table [redacted]', msg)
+    return msg
+
+
 # Parse command line arguments early (needed for port in constructor)
 import argparse as _argparse
 _parser = _argparse.ArgumentParser(add_help=False)
@@ -131,6 +152,19 @@ def get_provenance_tracker():
     return _provenance_tracker
 
 
+_trust_scorer = None
+
+
+def get_trust_scorer():
+    """Get shared TrustScorer singleton (v2.6+). Returns None if unavailable."""
+    global _trust_scorer
+    if not TRUST_AVAILABLE:
+        return None
+    if _trust_scorer is None:
+        _trust_scorer = TrustScorer.get_instance(DB_PATH)
+    return _trust_scorer
+
+
 def _register_mcp_agent(agent_name: str = "mcp-client"):
     """Register the calling MCP agent and record activity. Non-blocking."""
     registry = get_agent_registry()
@@ -188,6 +222,18 @@ async def remember(
         # Register MCP agent (v2.5 — agent tracking)
         _register_mcp_agent()
 
+        # Trust enforcement (v2.6) — block untrusted agents from writing
+        try:
+            trust = get_trust_scorer()
+            if trust and not trust.check_trust("mcp:mcp-client", "write"):
+                return {
+                    "success": False,
+                    "error": "Agent trust score too low for write operations",
+                    "message": "Trust enforcement blocked this operation"
+                }
+        except Exception:
+            pass  # Trust check failure should not block operations
+
         # Use existing MemoryStoreV2 class (no duplicate logic)
         store = get_store()
 
@@ -228,7 +274,7 @@ async def remember(
     except Exception as e:
         return {
             "success": False,
-            "error": str(e),
+            "error": _sanitize_error(e),
             "message": "Failed to save memory"
         }
 
@@ -277,8 +323,17 @@ async def recall(
         # Use existing MemoryStoreV2 class
         store = get_store()
 
-        # Call existing search method
-        results = store.search(query, limit=limit)
+        # Hybrid search (opt-in via env var, v2.6)
+        _use_hybrid = os.environ.get('SLM_HYBRID_SEARCH', 'false').lower() == 'true'
+        if _use_hybrid:
+            try:
+                from hybrid_search import HybridSearchEngine
+                engine = HybridSearchEngine(store=store)
+                results = engine.search(query, limit=limit)
+            except (ImportError, Exception):
+                results = store.search(query, limit=limit)
+        else:
+            results = store.search(query, limit=limit)
 
         # Filter by minimum score
         filtered_results = [
@@ -297,7 +352,7 @@ async def recall(
     except Exception as e:
         return {
             "success": False,
-            "error": str(e),
+            "error": _sanitize_error(e),
             "message": "Failed to search memories",
             "results": [],
             "count": 0
@@ -338,7 +393,7 @@ async def list_recent(limit: int = 10) -> dict:
     except Exception as e:
         return {
             "success": False,
-            "error": str(e),
+            "error": _sanitize_error(e),
             "message": "Failed to list memories",
             "memories": [],
             "count": 0
@@ -377,7 +432,7 @@ async def get_status() -> dict:
     except Exception as e:
         return {
             "success": False,
-            "error": str(e),
+            "error": _sanitize_error(e),
             "message": "Failed to get status"
         }
 
@@ -418,7 +473,7 @@ async def build_graph() -> dict:
     except Exception as e:
         return {
             "success": False,
-            "error": str(e),
+            "error": _sanitize_error(e),
             "message": "Failed to build graph"
         }
 
@@ -486,7 +541,7 @@ async def switch_profile(name: str) -> dict:
     except Exception as e:
         return {
             "success": False,
-            "error": str(e),
+            "error": _sanitize_error(e),
             "message": "Failed to switch profile"
         }
 
@@ -531,7 +586,7 @@ async def backup_status() -> dict:
     except Exception as e:
         return {
             "success": False,
-            "error": str(e),
+            "error": _sanitize_error(e),
             "message": "Failed to get backup status"
         }
 
@@ -583,7 +638,7 @@ async def search(query: str) -> dict:
         return {"results": results}
 
     except Exception as e:
-        return {"results": [], "error": str(e)}
+        return {"results": [], "error": _sanitize_error(e)}
 
 
 @mcp.tool(annotations=ToolAnnotations(
@@ -635,7 +690,7 @@ async def fetch(id: str) -> dict:
         }
 
     except Exception as e:
-        raise ValueError(f"Failed to fetch memory {id}: {str(e)}")
+        raise ValueError(f"Failed to fetch memory {id}: {_sanitize_error(e)}")
 
 
 # ============================================================================
@@ -654,7 +709,7 @@ async def get_recent_memories_resource(limit: str) -> str:
         memories = store.list_all(limit=int(limit))
         return json.dumps(memories, indent=2)
     except Exception as e:
-        return json.dumps({"error": str(e)}, indent=2)
+        return json.dumps({"error": _sanitize_error(e)}, indent=2)
 
 
 @mcp.resource("memory://stats")
@@ -669,7 +724,7 @@ async def get_stats_resource() -> str:
         stats = store.get_stats()
         return json.dumps(stats, indent=2)
     except Exception as e:
-        return json.dumps({"error": str(e)}, indent=2)
+        return json.dumps({"error": _sanitize_error(e)}, indent=2)
 
 
 @mcp.resource("memory://graph/clusters")
@@ -685,7 +740,7 @@ async def get_clusters_resource() -> str:
         clusters = stats.get('clusters', [])
         return json.dumps(clusters, indent=2)
     except Exception as e:
-        return json.dumps({"error": str(e)}, indent=2)
+        return json.dumps({"error": _sanitize_error(e)}, indent=2)
 
 
 @mcp.resource("memory://patterns/identity")
@@ -700,7 +755,7 @@ async def get_coding_identity_resource() -> str:
         patterns = learner.get_identity_context(min_confidence=0.5)
         return json.dumps(patterns, indent=2)
     except Exception as e:
-        return json.dumps({"error": str(e)}, indent=2)
+        return json.dumps({"error": _sanitize_error(e)}, indent=2)
 
 
 # ============================================================================
@@ -742,7 +797,7 @@ async def coding_identity_prompt() -> str:
         return prompt
 
     except Exception as e:
-        return f"# Coding Identity\n\nError loading patterns: {str(e)}"
+        return f"# Coding Identity\n\nError loading patterns: {_sanitize_error(e)}"
 
 
 @mcp.prompt()
@@ -780,7 +835,7 @@ async def project_context_prompt(project_name: str) -> str:
         return prompt
 
     except Exception as e:
-        return f"# Project Context: {project_name}\n\nError loading context: {str(e)}"
+        return f"# Project Context: {project_name}\n\nError loading context: {_sanitize_error(e)}"
 
 
 # ============================================================================

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "superlocalmemory",
-  "version": "2.5.1",
-  "description": "Your AI Finally Remembers You - Local-first intelligent memory system for AI assistants. Works with Claude, Cursor, Windsurf, VS Code/Copilot, Codex, and 16+ AI tools. 100% local, zero cloud dependencies.",
+  "version": "2.6.0",
+  "description": "Your AI Finally Remembers You - Local-first intelligent memory system for AI assistants. Works with Claude, Cursor, Windsurf, VS Code/Copilot, Codex, and 17+ AI tools. 100% local, zero cloud dependencies.",
   "keywords": [
     "ai-memory",
     "claude-ai",
@@ -34,7 +34,7 @@
     "type": "git",
     "url": "https://github.com/varun369/SuperLocalMemoryV2.git"
   },
-  "homepage": "https://github.com/varun369/SuperLocalMemoryV2#readme",
+  "homepage": "https://superlocalmemory.com",
   "bugs": {
     "url": "https://github.com/varun369/SuperLocalMemoryV2/issues"
   },

package/src/agent_registry.py

@@ -31,7 +31,7 @@ Protocols:
     cli     — Command-line interface (slm command, bin/ scripts)
     rest    — REST API (api_server.py)
     python  — Direct Python import
-    a2a     — Agent-to-Agent Protocol (v2.6+)
+    a2a     — Agent-to-Agent Protocol (v2.7+)
 """
 
 import json
@@ -323,6 +323,39 @@ class AgentRegistry:
             logger.error("Failed to list agents: %s", e)
             return []
 
+    def list_active_agents(self, timeout_minutes: int = 5) -> List[dict]:
+        """
+        List only active agents (seen within timeout_minutes).
+
+        Used by dashboard to filter out ghost/disconnected agents.
+        Default: agents seen within last 5 minutes are considered active.
+
+        Args:
+            timeout_minutes: Consider agents active if seen within this many minutes
+
+        Returns:
+            List of active agent dicts
+        """
+        try:
+            from db_connection_manager import DbConnectionManager
+            mgr = DbConnectionManager.get_instance(self.db_path)
+
+            with mgr.read_connection() as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    SELECT agent_id, agent_name, protocol, first_seen, last_seen,
+                           memories_written, memories_recalled, trust_score, metadata
+                    FROM agent_registry
+                    WHERE last_seen >= datetime('now', '-' || ? || ' minutes')
+                    ORDER BY last_seen DESC
+                """, (timeout_minutes,))
+                rows = cursor.fetchall()
+
+            return [self._row_to_dict(row) for row in rows]
+        except Exception as e:
+            logger.error("Failed to list active agents: %s", e)
+            return []
+
     def get_stats(self) -> dict:
         """Get agent registry statistics."""
         try:

package/src/auth_middleware.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""
+SuperLocalMemory V2 - Optional API Key Authentication
+Copyright (c) 2026 Varun Pratap Bhardwaj
+Licensed under MIT License
+
+Opt-in API key authentication for dashboard and API endpoints.
+When ~/.claude-memory/api_key file exists, write endpoints require
+X-SLM-API-Key header. Read endpoints remain open for backward compatibility.
+"""
+
+import os
+import hashlib
+import logging
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+MEMORY_DIR = Path.home() / ".claude-memory"
+API_KEY_FILE = MEMORY_DIR / "api_key"
+
+
+def _load_api_key_hash() -> Optional[str]:
+    """Load API key hash from file. Returns None if auth is not configured."""
+    if not API_KEY_FILE.exists():
+        return None
+    try:
+        key = API_KEY_FILE.read_text().strip()
+        if not key:
+            return None
+        return hashlib.sha256(key.encode()).hexdigest()
+    except Exception as e:
+        logger.warning("Failed to load API key: %s", e)
+        return None
+
+
+def check_api_key(request_headers: dict, is_write: bool = False) -> bool:
+    """
+    Check if request is authorized.
+
+    Returns True if:
+    - No API key file exists (auth not configured — backward compatible)
+    - Request is a read operation (reads always allowed)
+    - Request has valid X-SLM-API-Key header matching the key file
+    """
+    key_hash = _load_api_key_hash()
+
+    # No key file = auth not configured = allow all (backward compat)
+    if key_hash is None:
+        return True
+
+    # Read operations always allowed
+    if not is_write:
+        return True
+
+    # Write operations require valid key
+    provided_key = request_headers.get("x-slm-api-key", "")
+    if not provided_key:
+        return False
+
+    provided_hash = hashlib.sha256(provided_key.encode()).hexdigest()
+    return provided_hash == key_hash

package/src/cache_manager.py

@@ -178,7 +178,7 @@ class CacheManager:
 
             # For other types, try JSON serialization size
             return len(json.dumps(value, default=str))
-        except:
+        except Exception:
             # Fallback: assume moderate size
             return 1000
 

package/src/db_connection_manager.py

@@ -73,6 +73,7 @@ logger = logging.getLogger("superlocalmemory.db")
 DEFAULT_BUSY_TIMEOUT_MS = 5000
 DEFAULT_READ_POOL_SIZE = 4
 WRITE_QUEUE_SENTINEL = None  # Signals the writer thread to stop
+MAX_READ_CONNECTIONS = 50  # Maximum concurrent read connections
 
 
 class DbConnectionManager:
@@ -155,7 +156,7 @@ class DbConnectionManager:
         self._read_connections_lock = threading.Lock()
 
         # Write queue and dedicated writer thread
-        self._write_queue: Queue = Queue()
+        self._write_queue: Queue = Queue(maxsize=1000)
         self._writer_thread = threading.Thread(
             target=self._writer_loop,
             name="slm-db-writer",
@@ -190,6 +191,8 @@ class DbConnectionManager:
             conn.execute(f"PRAGMA busy_timeout={DEFAULT_BUSY_TIMEOUT_MS}")
             # Sync mode NORMAL is safe with WAL and faster than FULL
             conn.execute("PRAGMA synchronous=NORMAL")
+            # Incremental auto-vacuum reclaims space without full rebuild (v2.6)
+            conn.execute("PRAGMA auto_vacuum=INCREMENTAL")
             conn.close()
         except Exception:
             conn.close()
@@ -252,7 +255,18 @@ class DbConnectionManager:
                 self._remove_from_pool(conn)
                 conn = None
 
-        # Create new read connection for this thread
+        # Create new read connection for this thread (with pool limit)
+        with self._read_connections_lock:
+            if len(self._read_connections) >= MAX_READ_CONNECTIONS:
+                logger.warning(
+                    "Read connection pool at capacity (%d). Reusing oldest connection.",
+                    MAX_READ_CONNECTIONS
+                )
+                # Reuse the least recently used connection
+                conn = self._read_connections[0]
+                self._local.read_conn = conn
+                return conn
+
         conn = self._create_connection(readonly=True)
         self._local.read_conn = conn
 

package/src/event_bus.py

@@ -131,6 +131,10 @@ class EventBus:
         self._listeners: List[Callable[[dict], None]] = []
         self._listeners_lock = threading.Lock()
 
+        # Auto-prune tracking: lightweight heuristic trigger
+        self._write_count = 0
+        self._last_prune = datetime.now()
+
         # Initialize schema
         self._init_schema()
 
@@ -266,6 +270,17 @@ class EventBus:
         self._notify_listeners(event)
 
         logger.debug("Event emitted: type=%s, id=%s, memory_id=%s", event_type, event_id, memory_id)
+
+        # Auto-prune every 100 events or every 24 hours, whichever comes first
+        self._write_count += 1
+        if self._write_count >= 100 or (datetime.now() - self._last_prune).total_seconds() > 86400:
+            try:
+                self.prune_events()
+                self._write_count = 0
+                self._last_prune = datetime.now()
+            except Exception:
+                pass  # Don't let prune failures block event emission
+
         return event_id
 
     def _persist_event(self, event: dict) -> Optional[int]:

package/src/graph_engine.py

@@ -15,12 +15,12 @@ Implements GraphRAG with Leiden community detection to:
 All processing is local - no external APIs.
 
 LIMITS:
-- MAX_MEMORIES_FOR_GRAPH: 5000 (prevents O(n²) explosion)
+- MAX_MEMORIES_FOR_GRAPH: 10000 (prevents O(n²) explosion)
 - For larger datasets, use incremental updates
 """
 
 # SECURITY: Graph build limits to prevent resource exhaustion
-MAX_MEMORIES_FOR_GRAPH = 5000
+MAX_MEMORIES_FOR_GRAPH = 10000
 
 import sqlite3
 import json
@@ -157,43 +157,82 @@ class EdgeBuilder:
             logger.warning("Need at least 2 memories to build edges")
             return 0
 
-        # Compute pairwise cosine similarity
-        similarity_matrix = cosine_similarity(vectors)
+        # Try HNSW-accelerated edge building first (O(n log n))
+        use_hnsw = False
+        try:
+            from hnsw_index import HNSWIndex
+            if len(memory_ids) >= 50:  # HNSW overhead not worth it for small sets
+                use_hnsw = True
+        except ImportError:
+            pass
 
         edges_added = 0
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
 
         try:
-            for i in range(len(memory_ids)):
-                for j in range(i + 1, len(memory_ids)):
-                    sim = similarity_matrix[i, j]
-
-                    if sim >= self.min_similarity:
-                        # Find shared entities
-                        entities_i = set(entities_list[i])
-                        entities_j = set(entities_list[j])
-                        shared = list(entities_i & entities_j)
-
-                        # Classify relationship type
-                        rel_type = self._classify_relationship(sim, shared)
-
-                        # Insert edge (or update if exists)
-                        cursor.execute('''
-                            INSERT OR REPLACE INTO graph_edges
-                            (source_memory_id, target_memory_id, relationship_type,
-                             weight, shared_entities, similarity_score)
-                            VALUES (?, ?, ?, ?, ?, ?)
-                        ''', (
-                            memory_ids[i],
-                            memory_ids[j],
-                            rel_type,
-                            float(sim),
-                            json.dumps(shared),
-                            float(sim)
-                        ))
-
-                        edges_added += 1
+            if use_hnsw:
+                logger.info("Using HNSW-accelerated edge building for %d memories", len(memory_ids))
+                try:
+                    dim = vectors.shape[1]
+                    hnsw = HNSWIndex(dimension=dim, max_elements=len(memory_ids))
+                    hnsw.build(vectors, memory_ids)
+
+                    for i in range(len(memory_ids)):
+                        neighbors = hnsw.search(vectors[i], k=min(20, len(memory_ids) - 1))
+                        for neighbor_id, similarity in neighbors:
+                            if neighbor_id == memory_ids[i]:
+                                continue  # Skip self
+                            # Only process each pair once (lower ID first)
+                            if memory_ids[i] > neighbor_id:
+                                continue
+                            if similarity >= self.min_similarity:
+                                # Find indices for entity lookup
+                                j = memory_ids.index(neighbor_id)
+                                entities_i = set(entities_list[i])
+                                entities_j = set(entities_list[j])
+                                shared = list(entities_i & entities_j)
+                                rel_type = self._classify_relationship(similarity, shared)
+
+                                cursor.execute('''
+                                    INSERT OR REPLACE INTO graph_edges
+                                    (source_memory_id, target_memory_id, relationship_type,
+                                     weight, shared_entities, similarity_score)
+                                    VALUES (?, ?, ?, ?, ?, ?)
+                                ''', (
+                                    memory_ids[i], neighbor_id, rel_type,
+                                    float(similarity), json.dumps(shared), float(similarity)
+                                ))
+                                edges_added += 1
+
+                except Exception as e:
+                    logger.warning("HNSW edge building failed, falling back to O(n²): %s", e)
+                    use_hnsw = False  # Fall through to O(n²) below
+
+            if not use_hnsw:
+                # Fallback: O(n²) pairwise cosine similarity
+                similarity_matrix = cosine_similarity(vectors)
+
+                for i in range(len(memory_ids)):
+                    for j in range(i + 1, len(memory_ids)):
+                        sim = similarity_matrix[i, j]
+
+                        if sim >= self.min_similarity:
+                            entities_i = set(entities_list[i])
+                            entities_j = set(entities_list[j])
+                            shared = list(entities_i & entities_j)
+                            rel_type = self._classify_relationship(sim, shared)
+
+                            cursor.execute('''
+                                INSERT OR REPLACE INTO graph_edges
+                                (source_memory_id, target_memory_id, relationship_type,
+                                 weight, shared_entities, similarity_score)
+                                VALUES (?, ?, ?, ?, ?, ?)
+                            ''', (
+                                memory_ids[i], memory_ids[j], rel_type,
+                                float(sim), json.dumps(shared), float(sim)
+                            ))
+                            edges_added += 1
 
             conn.commit()
             logger.info(f"Created {edges_added} edges")
@@ -829,7 +868,7 @@ class GraphEngine:
             Dictionary with build statistics
 
         Raises:
-            ValueError: If too many memories (>5000) for safe processing
+            ValueError: If too many memories (>10000) for safe processing
         """
         start_time = time.time()
         logger.info("Starting full graph build...")
@@ -882,17 +921,47 @@ class GraphEngine:
                     'fix': "Add more memories: superlocalmemoryv2:remember 'Your content here'"
                 }
 
-            # SECURITY: Prevent O(n²) explosion for large datasets
+            # SCALABILITY: Intelligent sampling for large datasets (v2.6)
             if len(memories) > MAX_MEMORIES_FOR_GRAPH:
-                logger.error(f"Too many memories for graph build: {len(memories)}")
-                return {
-                    'success': False,
-                    'error': 'too_many_memories',
-                    'message': f"Graph build limited to {MAX_MEMORIES_FOR_GRAPH} memories for performance.",
-                    'memories': len(memories),
-                    'limit': MAX_MEMORIES_FOR_GRAPH,
-                    'fix': "Use incremental updates or reduce memory count with compression."
-                }
+                logger.warning(
+                    "Memory count (%d) exceeds graph cap (%d). Using intelligent sampling.",
+                    len(memories), MAX_MEMORIES_FOR_GRAPH
+                )
+                # Sample: 60% most recent + 40% highest importance (with overlap dedup)
+                recent_count = int(MAX_MEMORIES_FOR_GRAPH * 0.6)
+                important_count = int(MAX_MEMORIES_FOR_GRAPH * 0.4)
+
+                recent_memories = cursor.execute('''
+                    SELECT id, content, summary FROM memories
+                    WHERE profile = ?
+                    ORDER BY created_at DESC
+                    LIMIT ?
+                ''', (active_profile, recent_count)).fetchall()
+
+                important_memories = cursor.execute('''
+                    SELECT id, content, summary FROM memories
+                    WHERE profile = ?
+                    ORDER BY importance DESC, access_count DESC
+                    LIMIT ?
+                ''', (active_profile, important_count)).fetchall()
+
+                # Deduplicate by ID, preserving order
+                seen_ids = set()
+                memories = []
+                for m in recent_memories + important_memories:
+                    if m[0] not in seen_ids:
+                        seen_ids.add(m[0])
+                        memories.append(m)
+                memories = memories[:MAX_MEMORIES_FOR_GRAPH]
+                logger.info("Sampled %d memories for graph build", len(memories))
+
+            elif len(memories) > MAX_MEMORIES_FOR_GRAPH * 0.8:
+                logger.warning(
+                    "Approaching graph cap: %d/%d memories (%.0f%%). "
+                    "Consider running memory compression.",
+                    len(memories), MAX_MEMORIES_FOR_GRAPH,
+                    len(memories) / MAX_MEMORIES_FOR_GRAPH * 100
+                )
 
             # Clear existing graph data for this profile's memories
             profile_memory_ids = [m[0] for m in memories]

package/src/hybrid_search.py

@@ -150,7 +150,7 @@ class HybridSearchEngine:
                 try:
                     tags = json.loads(row[3])
                     text_parts.extend(tags)
-                except:
+                except Exception:
                     pass
 
             doc_text = ' '.join(text_parts)
@@ -334,7 +334,7 @@ class HybridSearchEngine:
                         new_score = current_score * similarity * (0.7 ** depth)
                         queue.append((rel_id, new_score, depth + 1))
 
-            except:
+            except Exception:
                 # Graph operation failed - skip
                 continue