superlocalmemory 2.8.2 → 2.8.5

package/src/compression/tier3_compressor.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""
+Tier 3 compression logic.
+Compresses memories to bullet points only format.
+"""
+
+import sqlite3
+import json
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import List
+
+
+MEMORY_DIR = Path.home() / ".claude-memory"
+DB_PATH = MEMORY_DIR / "memory.db"
+
+
+class Tier3Compressor:
+    """Compress memories to bullet points only (Tier 3)."""
+
+    def __init__(self, db_path: Path = DB_PATH):
+        self.db_path = db_path
+
+    def compress_to_tier3(self, memory_id: int) -> bool:
+        """
+        Compress memory to bullet points only.
+
+        Args:
+            memory_id: ID of memory to compress
+
+        Returns:
+            True if compression succeeded, False otherwise
+        """
+        conn = sqlite3.connect(self.db_path)
+        try:
+            cursor = conn.cursor()
+
+            # Get Tier 2 compressed content
+            cursor.execute('''
+                SELECT content, tier FROM memories WHERE id = ?
+            ''', (memory_id,))
+            result = cursor.fetchone()
+
+            if not result:
+                return False
+
+            content, current_tier = result
+
+            # Skip if in wrong tier
+            if current_tier != 3:
+                return False
+
+            # Try to parse as Tier 2 compressed content
+            try:
+                compressed_content = json.loads(content)
+
+                # Check if already Tier 3
+                if isinstance(compressed_content, dict) and 'bullets' in compressed_content:
+                    return True  # Already Tier 3
+
+                # Get summary from Tier 2
+                if isinstance(compressed_content, dict) and 'summary' in compressed_content:
+                    summary = compressed_content.get('summary', '')
+                    tier2_archived_at = compressed_content.get('compressed_at')
+                    original_length = compressed_content.get('original_length', 0)
+                else:
+                    # Not Tier 2 format, treat as plain text
+                    summary = content
+                    tier2_archived_at = None
+                    original_length = len(content)
+
+            except (json.JSONDecodeError, TypeError):
+                # Not JSON, treat as plain text
+                summary = content
+                tier2_archived_at = None
+                original_length = len(content)
+
+            # Convert summary to bullet points (max 5)
+            bullet_points = self._summarize_to_bullets(summary)
+
+            # Ultra-compressed version
+            ultra_compressed = {
+                'bullets': bullet_points,
+                'tier2_archived_at': tier2_archived_at,
+                'original_length': original_length,
+                'compressed_to_tier3_at': datetime.now().isoformat()
+            }
+
+            # Update memory
+            cursor.execute('''
+                UPDATE memories
+                SET content = ?, tier = 3, updated_at = CURRENT_TIMESTAMP
+                WHERE id = ?
+            ''', (json.dumps(ultra_compressed), memory_id))
+
+            conn.commit()
+        finally:
+            conn.close()
+        return True
+
+    def _summarize_to_bullets(self, summary: str, max_bullets: int = 5) -> List[str]:
+        """
+        Convert summary to bullet points.
+
+        Args:
+            summary: Summary text
+            max_bullets: Maximum number of bullets
+
+        Returns:
+            List of bullet point strings
+        """
+        # Split into sentences
+        sentences = re.split(r'[.!?]+', summary)
+
+        bullets = []
+
+        for sent in sentences:
+            sent = sent.strip()
+
+            if len(sent) < 10:
+                continue
+
+            # Truncate long sentences
+            if len(sent) > 80:
+                sent = sent[:77] + '...'
+
+            bullets.append(sent)
+
+            if len(bullets) >= max_bullets:
+                break
+
+        return bullets if bullets else ['[No summary available]']
+
+    def compress_all_tier3(self) -> int:
+        """Compress all memories that are in Tier 3."""
+        conn = sqlite3.connect(self.db_path)
+        try:
+            cursor = conn.cursor()
+
+            cursor.execute('SELECT id FROM memories WHERE tier = 3')
+            memory_ids = [row[0] for row in cursor.fetchall()]
+        finally:
+            conn.close()
+
+        compressed_count = 0
+        for memory_id in memory_ids:
+            if self.compress_to_tier3(memory_id):
+                compressed_count += 1
+
+        return compressed_count

package/src/compression/tier_classifier.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""
+Tier classification logic for memory compression.
+Classifies memories into tiers based on age and access patterns.
+"""
+
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Tuple
+
+from compression.config import CompressionConfig
+
+
+MEMORY_DIR = Path.home() / ".claude-memory"
+DB_PATH = MEMORY_DIR / "memory.db"
+
+
+class TierClassifier:
+    """Classify memories into compression tiers based on age and access patterns."""
+
+    def __init__(self, db_path: Path = DB_PATH):
+        self.db_path = db_path
+        self.config = CompressionConfig()
+        self._ensure_schema()
+
+    def _ensure_schema(self):
+        """Add tier and access tracking columns if not present."""
+        conn = sqlite3.connect(self.db_path)
+        try:
+            cursor = conn.cursor()
+
+            # Check if tier column exists
+            cursor.execute("PRAGMA table_info(memories)")
+            columns = [row[1] for row in cursor.fetchall()]
+
+            if 'tier' not in columns:
+                cursor.execute('ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 1')
+                cursor.execute('CREATE INDEX IF NOT EXISTS idx_tier ON memories(tier)')
+
+            if 'last_accessed' not in columns:
+                cursor.execute('ALTER TABLE memories ADD COLUMN last_accessed TIMESTAMP')
+
+            if 'access_count' not in columns:
+                cursor.execute('ALTER TABLE memories ADD COLUMN access_count INTEGER DEFAULT 0')
+
+            # Create memory_archive table if not exists
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS memory_archive (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    memory_id INTEGER UNIQUE NOT NULL,
+                    full_content TEXT NOT NULL,
+                    archived_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+                )
+            ''')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_archive_memory ON memory_archive(memory_id)')
+
+            conn.commit()
+        finally:
+            conn.close()
+
+    def classify_memories(self) -> List[Tuple[int, int]]:
+        """
+        Classify all memories into tiers based on age and access.
+
+        Returns:
+            List of (tier, memory_id) tuples
+        """
+        if not self.config.enabled:
+            return []
+
+        now = datetime.now()
+        conn = sqlite3.connect(self.db_path)
+        try:
+            cursor = conn.cursor()
+
+            # Get all memories with access tracking
+            cursor.execute('''
+                SELECT id, created_at, last_accessed, access_count, importance, tier
+                FROM memories
+            ''')
+            memories = cursor.fetchall()
+
+            tier_updates = []
+
+            for memory_id, created_at, last_accessed, access_count, importance, current_tier in memories:
+                created = datetime.fromisoformat(created_at)
+                age_days = (now - created).days
+
+                # Override: High-importance memories stay in Tier 1
+                if self.config.preserve_high_importance and importance and importance >= 8:
+                    tier = 1
+                # Recently accessed stays in Tier 1
+                elif self.config.preserve_recently_accessed and last_accessed:
+                    last_access = datetime.fromisoformat(last_accessed)
+                    if (now - last_access).days < 7:
+                        tier = 1
+                    else:
+                        tier = self._classify_by_age(age_days)
+                # Age-based classification
+                else:
+                    tier = self._classify_by_age(age_days)
+
+                # Only update if tier changed
+                if tier != current_tier:
+                    tier_updates.append((tier, memory_id))
+
+            # Update tier field
+            if tier_updates:
+                cursor.executemany('''
+                    UPDATE memories SET tier = ? WHERE id = ?
+                ''', tier_updates)
+                conn.commit()
+
+        finally:
+            conn.close()
+        return tier_updates
+
+    def _classify_by_age(self, age_days: int) -> int:
+        """Classify memory tier based on age."""
+        if age_days < self.config.tier2_threshold_days:
+            return 1  # Recent
+        elif age_days < self.config.tier3_threshold_days:
+            return 2  # Active
+        else:
+            return 3  # Archived
+
+    def get_tier_stats(self) -> Dict[str, int]:
+        """Get count of memories in each tier."""
+        conn = sqlite3.connect(self.db_path)
+        try:
+            cursor = conn.cursor()
+
+            cursor.execute('''
+                SELECT tier, COUNT(*) FROM memories GROUP BY tier
+            ''')
+            stats = dict(cursor.fetchall())
+        finally:
+            conn.close()
+
+        return {
+            'tier1': stats.get(1, 0),
+            'tier2': stats.get(2, 0),
+            'tier3': stats.get(3, 0)
+        }

package/src/db_connection_manager.py

@@ -109,7 +109,7 @@ class DbConnectionManager:
             return cls._instances[key]
 
     @classmethod
-    def reset_instance(cls, db_path: Optional[Path] = None):
+    def reset_instance(cls, db_path: Optional[Path] = None) -> None:
         """
         Remove and close a singleton instance. Used for testing and cleanup.
 
@@ -265,7 +265,7 @@ class DbConnectionManager:
 
         return conn
 
-    def release_read_connection(self, conn: sqlite3.Connection):
+    def release_read_connection(self, conn: sqlite3.Connection) -> None:
         """
         Release a read connection back to the pool.
 
@@ -401,7 +401,7 @@ class DbConnectionManager:
     # Post-write hooks (Event Bus integration point)
     # =========================================================================
 
-    def register_post_write_hook(self, hook: Callable[[], None]):
+    def register_post_write_hook(self, hook: Callable[[], None]) -> None:
         """
         Register a callback that fires after every successful write commit.
 
@@ -415,7 +415,7 @@ class DbConnectionManager:
         with self._post_write_hooks_lock:
             self._post_write_hooks.append(hook)
 
-    def unregister_post_write_hook(self, hook: Callable[[], None]):
+    def unregister_post_write_hook(self, hook: Callable[[], None]) -> None:
         """
         Remove a previously registered post-write hook.
 
@@ -463,7 +463,7 @@ class DbConnectionManager:
     # Lifecycle management
     # =========================================================================
 
-    def close(self):
+    def close(self) -> None:
         """
         Shut down the connection manager. Drains the write queue and closes
         all connections.

package/src/event_bus.py

@@ -94,7 +94,7 @@ class EventBus:
             return cls._instances[key]
 
     @classmethod
-    def reset_instance(cls, db_path: Optional[Path] = None):
+    def reset_instance(cls, db_path: Optional[Path] = None) -> None:
         """Remove and close a singleton instance. Used for testing."""
         with cls._instances_lock:
             if db_path is None:
@@ -171,25 +171,27 @@ class EventBus:
             # Fallback: direct connection
             import sqlite3
             conn = sqlite3.connect(str(self.db_path))
-            cursor = conn.cursor()
-            cursor.execute('''
-                CREATE TABLE IF NOT EXISTS memory_events (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    event_type TEXT NOT NULL,
-                    memory_id INTEGER,
-                    source_agent TEXT DEFAULT 'user',
-                    source_protocol TEXT DEFAULT 'internal',
-                    payload TEXT,
-                    importance INTEGER DEFAULT 5,
-                    tier TEXT DEFAULT 'hot',
-                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                )
-            ''')
-            cursor.execute('CREATE INDEX IF NOT EXISTS idx_events_type ON memory_events(event_type)')
-            cursor.execute('CREATE INDEX IF NOT EXISTS idx_events_created ON memory_events(created_at)')
-            cursor.execute('CREATE INDEX IF NOT EXISTS idx_events_tier ON memory_events(tier)')
-            conn.commit()
-            conn.close()
+            try:
+                cursor = conn.cursor()
+                cursor.execute('''
+                    CREATE TABLE IF NOT EXISTS memory_events (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        event_type TEXT NOT NULL,
+                        memory_id INTEGER,
+                        source_agent TEXT DEFAULT 'user',
+                        source_protocol TEXT DEFAULT 'internal',
+                        payload TEXT,
+                        importance INTEGER DEFAULT 5,
+                        tier TEXT DEFAULT 'hot',
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )
+                ''')
+                cursor.execute('CREATE INDEX IF NOT EXISTS idx_events_type ON memory_events(event_type)')
+                cursor.execute('CREATE INDEX IF NOT EXISTS idx_events_created ON memory_events(created_at)')
+                cursor.execute('CREATE INDEX IF NOT EXISTS idx_events_tier ON memory_events(tier)')
+                conn.commit()
+            finally:
+                conn.close()
 
     # =========================================================================
     # Event Emission
@@ -309,7 +311,7 @@ class EventBus:
     # Listener Management
     # =========================================================================
 
-    def add_listener(self, callback: Callable[[dict], None]):
+    def add_listener(self, callback: Callable[[dict], None]) -> None:
         """
         Register a listener that receives every emitted event.
 
@@ -322,7 +324,7 @@ class EventBus:
         with self._listeners_lock:
             self._listeners.append(callback)
 
-    def remove_listener(self, callback: Callable[[dict], None]):
+    def remove_listener(self, callback: Callable[[dict], None]) -> None:
         """Remove a previously registered listener."""
         with self._listeners_lock:
             try:

package/src/hnsw_index.py

@@ -202,7 +202,7 @@ class HNSWIndex:
         except Exception as e:
             logger.error(f"Failed to save HNSW index: {e}")
 
-    def build(self, vectors: np.ndarray, memory_ids: List[int]):
+    def build(self, vectors: np.ndarray, memory_ids: List[int]) -> None:
         """
         Build HNSW index from vectors.
 
@@ -276,7 +276,7 @@ class HNSWIndex:
         self.id_to_idx = {mem_id: idx for idx, mem_id in enumerate(memory_ids)}
         logger.info(f"Built fallback index with {len(vectors)} vectors (linear search)")
 
-    def add(self, vector: np.ndarray, memory_id: int):
+    def add(self, vector: np.ndarray, memory_id: int) -> None:
         """
         Add single vector to index (incremental update).
 
@@ -416,7 +416,7 @@ class HNSWIndex:
         logger.warning("No search method available (HNSW and sklearn both unavailable)")
         return []
 
-    def update(self, memory_id: int, vector: np.ndarray):
+    def update(self, memory_id: int, vector: np.ndarray) -> None:
         """
         Update vector for existing memory.
 

package/src/learning/__init__.py

@@ -18,6 +18,7 @@ Dependencies (all optional):
 
 import logging
 from pathlib import Path
+from typing import Any, Optional
 
 logger = logging.getLogger("superlocalmemory.learning")
 
@@ -85,7 +86,7 @@ _feedback_collector = None
 _engagement_tracker = None
 
 
-def get_learning_db():
+def get_learning_db() -> Any:
     """Get or create the LearningDB singleton."""
     global _learning_db
     if _learning_db is None:
@@ -98,7 +99,7 @@ def get_learning_db():
     return _learning_db
 
 
-def get_adaptive_ranker():
+def get_adaptive_ranker() -> Any:
     """Get or create the AdaptiveRanker singleton."""
     global _adaptive_ranker
     if _adaptive_ranker is None:
@@ -111,7 +112,7 @@ def get_adaptive_ranker():
     return _adaptive_ranker
 
 
-def get_feedback_collector():
+def get_feedback_collector() -> Any:
     """Get or create the FeedbackCollector singleton."""
     global _feedback_collector
     if _feedback_collector is None:
@@ -124,7 +125,7 @@ def get_feedback_collector():
     return _feedback_collector
 
 
-def get_engagement_tracker():
+def get_engagement_tracker() -> Any:
     """Get or create the EngagementTracker singleton."""
     global _engagement_tracker
     if _engagement_tracker is None: