superlocalmemory 2.8.6 → 3.0.0

package/src/compliance/tests/test_mcp_retention_policy.py

@@ -1,125 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for set_retention_policy MCP tool handler.
-
-Validates the MCP wrapper around RetentionPolicyManager — tests policy
-creation with tags, project scope, and various framework types.
-"""
-import asyncio
-import os
-import shutil
-import sqlite3
-import sys
-import tempfile
-from pathlib import Path
-
-import pytest
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-
-def _create_memory_db(db_path: str) -> None:
-    """Create a minimal memory.db for RetentionPolicyManager."""
-    conn = sqlite3.connect(db_path)
-    conn.execute(
-        """CREATE TABLE memories (
-            id INTEGER PRIMARY KEY,
-            content TEXT,
-            tags TEXT DEFAULT '[]',
-            project_name TEXT,
-            lifecycle_state TEXT DEFAULT 'active',
-            profile TEXT DEFAULT 'default'
-        )"""
-    )
-    conn.commit()
-    conn.close()
-
-
-class TestMCPRetentionPolicy:
-    """Tests for the set_retention_policy tool handler."""
-
-    def setup_method(self):
-        self.tmp_dir = tempfile.mkdtemp()
-        self.db_path = os.path.join(self.tmp_dir, "memory.db")
-        _create_memory_db(self.db_path)
-
-    def teardown_method(self):
-        shutil.rmtree(self.tmp_dir, ignore_errors=True)
-
-    def _run(self, coro):
-        return asyncio.get_event_loop().run_until_complete(coro)
-
-    def test_create_gdpr_policy(self):
-        """Creating a GDPR tombstone policy should return success with policy_id."""
-        import mcp_tools_v28 as tools
-        tools.DEFAULT_MEMORY_DB = self.db_path
-
-        result = self._run(
-            tools.set_retention_policy(
-                "GDPR Erasure", "gdpr", 0, "tombstone", ["gdpr"]
-            )
-        )
-        assert result["success"] is True
-        assert isinstance(result["policy_id"], int)
-        assert result["policy_id"] > 0
-        assert result["name"] == "GDPR Erasure"
-        assert result["framework"] == "gdpr"
-
-    def test_create_hipaa_policy(self):
-        """Creating a HIPAA retention policy should succeed."""
-        import mcp_tools_v28 as tools
-        tools.DEFAULT_MEMORY_DB = self.db_path
-
-        result = self._run(
-            tools.set_retention_policy(
-                "HIPAA Retention", "hipaa", 2190, "retain", ["medical"]
-            )
-        )
-        assert result["success"] is True
-        assert result["framework"] == "hipaa"
-
-    def test_create_policy_with_project(self):
-        """Policy scoped to a project should succeed."""
-        import mcp_tools_v28 as tools
-        tools.DEFAULT_MEMORY_DB = self.db_path
-
-        result = self._run(
-            tools.set_retention_policy(
-                "Internal Retention",
-                "internal",
-                365,
-                "archive",
-                applies_to_project="myproject",
-            )
-        )
-        assert result["success"] is True
-
-    def test_create_policy_with_tags_and_project(self):
-        """Policy with both tags and project scope should succeed."""
-        import mcp_tools_v28 as tools
-        tools.DEFAULT_MEMORY_DB = self.db_path
-
-        result = self._run(
-            tools.set_retention_policy(
-                "EU AI Act",
-                "eu_ai_act",
-                1825,
-                "retain",
-                applies_to_tags=["ai-decision"],
-                applies_to_project="ml-pipeline",
-            )
-        )
-        assert result["success"] is True
-
-    def test_multiple_policies_unique_ids(self):
-        """Consecutive policies should get distinct IDs."""
-        import mcp_tools_v28 as tools
-        tools.DEFAULT_MEMORY_DB = self.db_path
-
-        r1 = self._run(
-            tools.set_retention_policy("Policy A", "gdpr", 0, "tombstone", ["a"])
-        )
-        r2 = self._run(
-            tools.set_retention_policy("Policy B", "hipaa", 365, "retain", ["b"])
-        )
-        assert r1["policy_id"] != r2["policy_id"]

package/src/compliance/tests/test_retention_manager.py

@@ -1,131 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for compliance retention manager.
-"""
-import sqlite3
-import tempfile
-import os
-import sys
-import json
-from datetime import datetime, timedelta
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-
-class TestComplianceRetentionManager:
-    def setup_method(self):
-        self.tmp_dir = tempfile.mkdtemp()
-        self.memory_db_path = os.path.join(self.tmp_dir, "memory.db")
-        self.audit_db_path = os.path.join(self.tmp_dir, "audit.db")
-
-        # Create memory.db with test data
-        conn = sqlite3.connect(self.memory_db_path)
-        conn.execute("""
-            CREATE TABLE memories (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                content TEXT NOT NULL,
-                importance INTEGER DEFAULT 5,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                last_accessed TIMESTAMP,
-                access_count INTEGER DEFAULT 0,
-                lifecycle_state TEXT DEFAULT 'active',
-                lifecycle_updated_at TIMESTAMP,
-                lifecycle_history TEXT DEFAULT '[]',
-                access_level TEXT DEFAULT 'public',
-                profile TEXT DEFAULT 'default',
-                tags TEXT DEFAULT '[]',
-                project_name TEXT
-            )
-        """)
-        conn.execute("INSERT INTO memories (content, tags, project_name) VALUES ('user PII data', '[\"gdpr\",\"pii\"]', 'eu-app')")
-        conn.execute("INSERT INTO memories (content, tags, project_name) VALUES ('medical record', '[\"hipaa\"]', 'healthcare')")
-        conn.execute("INSERT INTO memories (content, tags) VALUES ('general note', '[]')")
-        conn.commit()
-        conn.close()
-
-    def teardown_method(self):
-        import shutil
-        shutil.rmtree(self.tmp_dir, ignore_errors=True)
-
-    def test_creation(self):
-        from compliance.retention_manager import ComplianceRetentionManager
-        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
-        assert mgr is not None
-
-    def test_create_gdpr_policy(self):
-        from compliance.retention_manager import ComplianceRetentionManager
-        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
-        pid = mgr.create_retention_rule(
-            name="GDPR Right to Erasure",
-            framework="gdpr",
-            retention_days=0,
-            action="tombstone",
-            applies_to={"tags": ["gdpr"]},
-        )
-        assert isinstance(pid, int)
-
-    def test_create_eu_ai_act_policy(self):
-        from compliance.retention_manager import ComplianceRetentionManager
-        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
-        pid = mgr.create_retention_rule(
-            name="EU AI Act Audit Retention",
-            framework="eu_ai_act",
-            retention_days=3650,
-            action="retain_audit",
-            applies_to={"tags": ["gdpr"]},
-        )
-        assert pid > 0
-
-    def test_gdpr_erasure_tombstones_memory(self):
-        """GDPR erasure request tombstones the memory."""
-        from compliance.retention_manager import ComplianceRetentionManager
-        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
-        result = mgr.execute_erasure_request(memory_id=1, framework="gdpr", requested_by="data_subject")
-        assert result["success"] is True
-        assert result["action"] == "tombstoned"
-        # Verify in DB
-        conn = sqlite3.connect(self.memory_db_path)
-        row = conn.execute("SELECT lifecycle_state FROM memories WHERE id=1").fetchone()
-        conn.close()
-        assert row[0] == "tombstoned"
-
-    def test_gdpr_erasure_preserves_audit(self):
-        """GDPR erasure logs the action to audit.db."""
-        from compliance.retention_manager import ComplianceRetentionManager
-        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
-        mgr.execute_erasure_request(memory_id=1, framework="gdpr", requested_by="data_subject")
-        conn = sqlite3.connect(self.audit_db_path)
-        rows = conn.execute("SELECT * FROM audit_events WHERE event_type='retention.erasure'").fetchall()
-        conn.close()
-        assert len(rows) >= 1
-
-    def test_list_rules(self):
-        from compliance.retention_manager import ComplianceRetentionManager
-        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
-        mgr.create_retention_rule("GDPR", "gdpr", 0, "tombstone", {"tags": ["gdpr"]})
-        mgr.create_retention_rule("HIPAA", "hipaa", 2555, "retain", {"tags": ["hipaa"]})
-        rules = mgr.list_rules()
-        assert len(rules) == 2
-
-    def test_evaluate_memory_against_rules(self):
-        from compliance.retention_manager import ComplianceRetentionManager
-        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
-        mgr.create_retention_rule("HIPAA Retention", "hipaa", 2555, "retain", {"tags": ["hipaa"]})
-        result = mgr.evaluate_memory(2)  # Memory 2 has hipaa tag
-        assert result is not None
-        assert result["rule_name"] == "HIPAA Retention"
-
-    def test_no_rule_match_returns_none(self):
-        from compliance.retention_manager import ComplianceRetentionManager
-        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
-        mgr.create_retention_rule("HIPAA", "hipaa", 2555, "retain", {"tags": ["hipaa"]})
-        result = mgr.evaluate_memory(3)  # Memory 3 has no hipaa tag
-        assert result is None
-
-    def test_get_compliance_status(self):
-        from compliance.retention_manager import ComplianceRetentionManager
-        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
-        status = mgr.get_compliance_status()
-        assert "rules_count" in status
-        assert "frameworks" in status

package/src/compliance/tests/test_retention_scheduler.py

@@ -1,99 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for retention policy background scheduler.
-"""
-import sqlite3, tempfile, os, sys, json, threading
-from datetime import datetime, timedelta
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-class TestRetentionScheduler:
-    def setup_method(self):
-        self.tmp_dir = tempfile.mkdtemp()
-        self.memory_db = os.path.join(self.tmp_dir, "memory.db")
-        self.audit_db = os.path.join(self.tmp_dir, "audit.db")
-        conn = sqlite3.connect(self.memory_db)
-        conn.execute("""
-            CREATE TABLE memories (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                content TEXT NOT NULL,
-                importance INTEGER DEFAULT 5,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                last_accessed TIMESTAMP,
-                access_count INTEGER DEFAULT 0,
-                lifecycle_state TEXT DEFAULT 'active',
-                lifecycle_updated_at TIMESTAMP,
-                lifecycle_history TEXT DEFAULT '[]',
-                access_level TEXT DEFAULT 'public',
-                profile TEXT DEFAULT 'default',
-                tags TEXT DEFAULT '[]',
-                project_name TEXT
-            )
-        """)
-        now = datetime.now()
-        # Memory 1: old GDPR data (created 400 days ago)
-        conn.execute("INSERT INTO memories (content, tags, created_at, lifecycle_state) VALUES (?, ?, ?, ?)",
-            ("old PII data", '["gdpr"]', (now - timedelta(days=400)).isoformat(), "active"))
-        # Memory 2: recent data
-        conn.execute("INSERT INTO memories (content, tags) VALUES (?, ?)",
-            ("fresh data", '[]'))
-        # Memory 3: tombstoned (should be checked for final deletion)
-        conn.execute("INSERT INTO memories (content, lifecycle_state, created_at) VALUES (?, ?, ?)",
-            ("tombstoned data", "tombstoned", (now - timedelta(days=100)).isoformat()))
-        conn.commit()
-        conn.close()
-
-    def teardown_method(self):
-        import shutil
-        shutil.rmtree(self.tmp_dir, ignore_errors=True)
-
-    def test_creation(self):
-        from compliance.retention_scheduler import RetentionScheduler
-        sched = RetentionScheduler(self.memory_db, self.audit_db)
-        assert sched is not None
-
-    def test_default_interval(self):
-        from compliance.retention_scheduler import RetentionScheduler
-        sched = RetentionScheduler(self.memory_db, self.audit_db)
-        assert sched.interval_seconds == 86400  # 24 hours
-
-    def test_run_now(self):
-        from compliance.retention_scheduler import RetentionScheduler
-        sched = RetentionScheduler(self.memory_db, self.audit_db)
-        result = sched.run_now()
-        assert "timestamp" in result
-        assert "actions" in result
-
-    def test_start_and_stop(self):
-        from compliance.retention_scheduler import RetentionScheduler
-        sched = RetentionScheduler(self.memory_db, self.audit_db, interval_seconds=3600)
-        sched.start()
-        assert sched.is_running is True
-        sched.stop()
-        assert sched.is_running is False
-
-    def test_thread_is_daemon(self):
-        from compliance.retention_scheduler import RetentionScheduler
-        sched = RetentionScheduler(self.memory_db, self.audit_db, interval_seconds=3600)
-        sched.start()
-        assert sched._timer.daemon is True
-        sched.stop()
-
-    def test_manual_trigger_works(self):
-        from compliance.retention_scheduler import RetentionScheduler
-        sched = RetentionScheduler(self.memory_db, self.audit_db)
-        result = sched.run_now()
-        assert isinstance(result["actions"], list)
-
-    def test_configurable_interval(self):
-        from compliance.retention_scheduler import RetentionScheduler
-        sched = RetentionScheduler(self.memory_db, self.audit_db, interval_seconds=7200)
-        assert sched.interval_seconds == 7200
-
-    def test_result_structure(self):
-        from compliance.retention_scheduler import RetentionScheduler
-        sched = RetentionScheduler(self.memory_db, self.audit_db)
-        result = sched.run_now()
-        assert "timestamp" in result
-        assert "actions" in result
-        assert "rules_evaluated" in result

package/src/compression/__init__.py

@@ -1,25 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-Compression sub-package for SuperLocalMemory.
-Provides tier-based progressive summarization and archival.
-
-Note: Uses relative imports to avoid collision with Python stdlib.
-"""
-
-from .config import CompressionConfig
-from .tier_classifier import TierClassifier
-from .tier2_compressor import Tier2Compressor
-from .tier3_compressor import Tier3Compressor
-from .cold_storage import ColdStorageManager
-from .orchestrator import CompressionOrchestrator
-
-__all__ = [
-    'CompressionConfig',
-    'TierClassifier',
-    'Tier2Compressor',
-    'Tier3Compressor',
-    'ColdStorageManager',
-    'CompressionOrchestrator',
-]

package/src/compression/cli.py

@@ -1,150 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-CLI interface for compression operations.
-"""
-
-import sys
-import json
-
-from compression.config import CompressionConfig
-from compression.tier_classifier import TierClassifier
-from compression.tier2_compressor import Tier2Compressor
-from compression.tier3_compressor import Tier3Compressor
-from compression.cold_storage import ColdStorageManager
-from compression.orchestrator import CompressionOrchestrator
-
-
-def main():
-    """Main CLI entry point."""
-    if len(sys.argv) < 2:
-        print("Progressive Summarization Compression for SuperLocalMemory\n")
-        print("Usage:")
-        print("  python compression.py classify         # Classify memories into tiers")
-        print("  python compression.py compress         # Run full compression cycle")
-        print("  python compression.py stats            # Show compression statistics")
-        print("  python compression.py tier2 <id>       # Compress specific memory to Tier 2")
-        print("  python compression.py tier3 <id>       # Compress specific memory to Tier 3")
-        print("  python compression.py cold-storage     # Move old memories to cold storage")
-        print("  python compression.py restore <id>     # Restore memory from cold storage")
-        print("  python compression.py init-config      # Initialize compression config")
-        sys.exit(0)
-
-    command = sys.argv[1]
-    orchestrator = CompressionOrchestrator()
-
-    if command == "classify":
-        classifier = TierClassifier()
-        updates = classifier.classify_memories()
-        print(f"Classified {len(updates)} memories")
-
-        stats = classifier.get_tier_stats()
-        print(f"\nTier breakdown:")
-        print(f"  Tier 1 (Full content):    {stats['tier1']} memories")
-        print(f"  Tier 2 (Summary+excerpts): {stats['tier2']} memories")
-        print(f"  Tier 3 (Bullets only):     {stats['tier3']} memories")
-
-    elif command == "compress":
-        print("Running full compression cycle...")
-        stats = orchestrator.run_full_compression()
-
-        print(f"\nCompression Results:")
-        print(f"  Tier updates:          {stats['tier_updates']}")
-        print(f"  Tier 2 compressed:     {stats['tier2_compressed']}")
-        print(f"  Tier 3 compressed:     {stats['tier3_compressed']}")
-        print(f"  Moved to cold storage: {stats['cold_stored']}")
-
-        if 'space_savings' in stats:
-            savings = stats['space_savings']
-            print(f"\nSpace Savings:")
-            print(f"  Original size:  {savings['estimated_original_bytes']:,} bytes")
-            print(f"  Current size:   {savings['current_size_bytes']:,} bytes")
-            print(f"  Savings:        {savings['savings_bytes']:,} bytes ({savings['savings_percent']}%)")
-
-        if stats.get('errors'):
-            print(f"\nErrors: {stats['errors']}")
-
-    elif command == "stats":
-        classifier = TierClassifier()
-        tier_stats = classifier.get_tier_stats()
-
-        cold_storage = ColdStorageManager()
-        cold_stats = cold_storage.get_cold_storage_stats()
-
-        savings = orchestrator._calculate_space_savings()
-
-        print("Compression Statistics\n")
-        print("Tier Breakdown:")
-        print(f"  Tier 1 (Full content):     {tier_stats['tier1']} memories")
-        print(f"  Tier 2 (Summary+excerpts): {tier_stats['tier2']} memories")
-        print(f"  Tier 3 (Bullets only):     {tier_stats['tier3']} memories")
-
-        print(f"\nCold Storage:")
-        print(f"  Archive files: {cold_stats['archive_count']}")
-        print(f"  Total memories: {cold_stats['total_memories']}")
-        print(f"  Total size: {cold_stats['total_size_bytes']:,} bytes")
-
-        print(f"\nSpace Savings:")
-        print(f"  Estimated original: {savings['estimated_original_bytes']:,} bytes")
-        print(f"  Current size:       {savings['current_size_bytes']:,} bytes")
-        print(f"  Savings:            {savings['savings_bytes']:,} bytes ({savings['savings_percent']}%)")
-
-    elif command == "tier2" and len(sys.argv) >= 3:
-        try:
-            memory_id = int(sys.argv[2])
-            compressor = Tier2Compressor()
-            if compressor.compress_to_tier2(memory_id):
-                print(f"Memory #{memory_id} compressed to Tier 2")
-            else:
-                print(f"Failed to compress memory #{memory_id}")
-        except ValueError:
-            print("Error: Memory ID must be a number")
-
-    elif command == "tier3" and len(sys.argv) >= 3:
-        try:
-            memory_id = int(sys.argv[2])
-            compressor = Tier3Compressor()
-            if compressor.compress_to_tier3(memory_id):
-                print(f"Memory #{memory_id} compressed to Tier 3")
-            else:
-                print(f"Failed to compress memory #{memory_id}")
-        except ValueError:
-            print("Error: Memory ID must be a number")
-
-    elif command == "cold-storage":
-        cold_storage = ColdStorageManager()
-        candidates = cold_storage.get_cold_storage_candidates()
-
-        if not candidates:
-            print("No memories ready for cold storage")
-        else:
-            print(f"Moving {len(candidates)} memories to cold storage...")
-            count = cold_storage.move_to_cold_storage(candidates)
-            print(f"Archived {count} memories")
-
-    elif command == "restore" and len(sys.argv) >= 3:
-        try:
-            memory_id = int(sys.argv[2])
-            cold_storage = ColdStorageManager()
-            content = cold_storage.restore_from_cold_storage(memory_id)
-
-            if content:
-                print(f"Memory #{memory_id} restored from cold storage")
-            else:
-                print(f"Memory #{memory_id} not found in cold storage")
-        except ValueError:
-            print("Error: Memory ID must be a number")
-
-    elif command == "init-config":
-        config = CompressionConfig()
-        config.initialize_defaults()
-        print("Compression configuration initialized")
-        print(json.dumps(config.compression_settings, indent=2))
-
-    else:
-        print(f"Unknown command: {command}")
-
-
-if __name__ == "__main__":
-    main()