superlocalmemory 2.7.6 → 2.8.1

package/src/compliance/tests/test_mcp_retention_policy.py

@@ -0,0 +1,125 @@
+# 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

@@ -0,0 +1,131 @@
+# 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

@@ -0,0 +1,99 @@
+# 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/db_connection_manager.py

@@ -1,16 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Database Connection Manager
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-
-Repository: https://github.com/varun369/SuperLocalMemoryV2
-Author: Varun Pratap Bhardwaj (Solution Architect)
-
-NOTICE: This software is protected by MIT License.
-Attribution must be preserved in all copies or derivatives.
-"""
-
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
 """
 DbConnectionManager — Thread-safe SQLite connection management with WAL mode.