superlocalmemory 2.5.0 → 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.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 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"
   },
@@ -98,5 +98,8 @@
     "year": "2026",
     "github": "https://github.com/varun369",
     "required": "Attribution notice must be preserved in all copies and derivative works"
+  },
+  "dependencies": {
+    "docx": "^9.5.1"
   }
 }

package/scripts/generate-thumbnails.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+SuperLocalMemory V2 - Thumbnail Generator
+Copyright (c) 2026 Varun Pratap Bhardwaj
+Licensed under MIT License
+
+Generates optimized thumbnail versions of all screenshots.
+- Size: 320×180px (16:9 ratio)
+- Format: PNG (for wiki/docs) and WebP (for website)
+- Quality: High enough to recognize content
+- File size: < 50KB per thumbnail
+"""
+
+import os
+import json
+from pathlib import Path
+from PIL import Image, ImageFilter, ImageOps
+from datetime import datetime
+
+# Configuration
+SCREENSHOT_DIR = Path(__file__).parent.parent / "assets" / "screenshots"
+THUMBNAIL_DIR = Path(__file__).parent.parent / "assets" / "thumbnails"
+THUMBNAIL_SIZE = (320, 180)  # 16:9 ratio
+QUALITY_PNG = 95
+QUALITY_WEBP = 85
+MAX_FILESIZE = 50 * 1024  # 50KB
+
+# Category mapping based on filename patterns
+CATEGORY_MAP = {
+    "overview": "dashboard",
+    "timeline": "timeline",
+    "agents": "agents",
+    "patterns": "patterns",
+    "clusters": "clusters",
+    "memories": "memories",
+    "graph": "graph",
+    "filtered": "search",
+    "live-events": "events",
+}
+
+def get_category(filename):
+    """Extract category from filename."""
+    for pattern, category in CATEGORY_MAP.items():
+        if pattern in filename.lower():
+            return category
+    return "general"
+
+def get_title(filename):
+    """Generate human-readable title from filename."""
+    # Remove extensions and convert dashes/underscores to spaces
+    name = Path(filename).stem
+    # Remove 'dashboard-' prefix if present
+    if name.startswith("dashboard-"):
+        name = name[9:]
+    # Remove '-dark' suffix
+    name = name.replace("-dark", "")
+    # Convert to title case
+    return " ".join(word.capitalize() for word in name.split("-"))
+
+def get_description(filename, category):
+    """Generate description based on filename and category."""
+    descriptions = {
+        "overview": "Main dashboard with memory statistics and knowledge graph overview",
+        "timeline": "Chronological timeline of all stored memories and events",
+        "agents": "Agent connections and activity tracking",
+        "patterns": "Learned coding patterns and user preferences",
+        "clusters": "Knowledge graph clusters and relationships",
+        "memories": "Detailed memory list with search and filtering",
+        "graph": "Interactive knowledge graph visualization",
+        "search": "Advanced memory search and filtering interface",
+        "events": "Real-time live event stream from memory operations",
+    }
+    is_dark = "-dark" in filename.lower()
+    base_desc = descriptions.get(category, "Dashboard interface")
+    if is_dark:
+        base_desc += " (dark mode)"
+    return base_desc
+
+def resize_and_crop(image, target_size):
+    """
+    Resize image to target size while maintaining aspect ratio.
+    Crops if necessary to achieve exact dimensions.
+    """
+    img_ratio = image.width / image.height
+    target_ratio = target_size[0] / target_size[1]
+
+    if img_ratio > target_ratio:
+        # Image is wider, crop width
+        new_height = target_size[1]
+        new_width = int(new_height * img_ratio)
+        resized = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        left = (resized.width - target_size[0]) // 2
+        return resized.crop((left, 0, left + target_size[0], target_size[1]))
+    else:
+        # Image is taller, crop height
+        new_width = target_size[0]
+        new_height = int(new_width / img_ratio)
+        resized = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        top = (resized.height - target_size[1]) // 2
+        return resized.crop((0, top, target_size[0], top + target_size[1]))
+
+def apply_sharpening(image):
+    """Apply subtle sharpening to enhance detail."""
+    # Use UNSHARP_MASK equivalent with subtle settings
+    return image.filter(ImageFilter.UnsharpMask(radius=1, percent=100, threshold=3))
+
+def generate_thumbnail(source_path, dest_dir, metadata):
+    """Generate PNG and WebP thumbnails for a single source image."""
+    try:
+        # Open image
+        with Image.open(source_path) as img:
+            # Convert RGBA to RGB if necessary (for PNG/WebP)
+            if img.mode == "RGBA":
+                background = Image.new("RGB", img.size, (255, 255, 255))
+                background.paste(img, mask=img.split()[3])
+                img = background
+            elif img.mode != "RGB":
+                img = img.convert("RGB")
+
+            # Resize and crop
+            thumbnail = resize_and_crop(img, THUMBNAIL_SIZE)
+
+            # Apply sharpening
+            thumbnail = apply_sharpening(thumbnail)
+
+            filename = source_path.stem
+
+            # Save PNG version
+            png_path = dest_dir / f"{filename}-thumb.png"
+            thumbnail.save(png_path, "PNG", quality=QUALITY_PNG, optimize=True)
+            png_size = png_path.stat().st_size
+
+            # Save WebP version
+            webp_path = dest_dir / f"{filename}-thumb.webp"
+            thumbnail.save(webp_path, "WEBP", quality=QUALITY_WEBP, method=6)
+            webp_size = webp_path.stat().st_size
+
+            # Check file sizes
+            if png_size > MAX_FILESIZE:
+                print(f"⚠️  PNG {filename}: {png_size/1024:.1f}KB (exceeds limit)")
+            if webp_size > MAX_FILESIZE:
+                print(f"⚠️  WebP {filename}: {webp_size/1024:.1f}KB (exceeds limit)")
+
+            print(f"✓ {filename}")
+            print(f"  PNG: {png_size/1024:.1f}KB | WebP: {webp_size/1024:.1f}KB")
+
+            # Store metadata
+            category = get_category(filename)
+            metadata[filename] = {
+                "title": get_title(filename),
+                "description": get_description(source_path.name, category),
+                "category": category,
+                "full_image": f"../screenshots/dashboard/{source_path.name}",
+                "thumbnail_png": f"{filename}-thumb.png",
+                "thumbnail_webp": f"{filename}-thumb.webp",
+                "created": datetime.now().isoformat(),
+                "original_size": f"{img.width}×{img.height}",
+                "thumbnail_size": f"{THUMBNAIL_SIZE[0]}×{THUMBNAIL_SIZE[1]}",
+                "png_size_kb": round(png_size / 1024, 2),
+                "webp_size_kb": round(webp_size / 1024, 2),
+            }
+            return True
+    except Exception as e:
+        print(f"✗ {source_path.name}: {str(e)}")
+        return False
+
+def main():
+    """Generate all thumbnails."""
+    # Ensure thumbnail directory exists
+    THUMBNAIL_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Verify screenshot directory exists
+    if not SCREENSHOT_DIR.exists():
+        print(f"Error: Screenshot directory not found: {SCREENSHOT_DIR}")
+        return 1
+
+    # Find all images in screenshot directory
+    image_extensions = {".png", ".jpg", ".jpeg", ".webp"}
+    sources = sorted([
+        f for f in SCREENSHOT_DIR.glob("**/*")
+        if f.is_file() and f.suffix.lower() in image_extensions and not f.name.startswith(".")
+    ])
+
+    if not sources:
+        print(f"No images found in {SCREENSHOT_DIR}")
+        return 1
+
+    print(f"Found {len(sources)} images in {SCREENSHOT_DIR}")
+    print(f"Generating thumbnails to {THUMBNAIL_DIR}\n")
+
+    metadata = {}
+    successful = 0
+    failed = 0
+
+    for source in sources:
+        if generate_thumbnail(source, THUMBNAIL_DIR, metadata):
+            successful += 1
+        else:
+            failed += 1
+
+    # Save metadata index
+    index_path = THUMBNAIL_DIR / "index.json"
+    with open(index_path, "w") as f:
+        json.dump(metadata, f, indent=2, sort_keys=True)
+    print(f"\n✓ Saved metadata index to {index_path}")
+
+    # Print summary
+    print(f"\n{'='*60}")
+    print(f"Summary:")
+    print(f"  Total processed: {len(sources)}")
+    print(f"  Successful: {successful}")
+    print(f"  Failed: {failed}")
+    print(f"  PNG thumbnails: {len(list(THUMBNAIL_DIR.glob('*-thumb.png')))}")
+    print(f"  WebP thumbnails: {len(list(THUMBNAIL_DIR.glob('*-thumb.webp')))}")
+    print(f"  Total size: {sum(f.stat().st_size for f in THUMBNAIL_DIR.glob('*-thumb.*')) / 1024:.1f}KB")
+
+    return 0 if failed == 0 else 1
+
+if __name__ == "__main__":
+    exit(main())

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]: