superlocalmemory 2.8.6 → 3.0.0

package/src/compression/tier3_compressor.py

@@ -1,153 +0,0 @@
-#!/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

@@ -1,148 +0,0 @@
-#!/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)
-        }