superlocalmemory 2.7.6 → 2.8.0

package/src/lifecycle/tests/test_mcp_compact.py

@@ -0,0 +1,149 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for compact_memories MCP tool handler.
+
+Validates the MCP wrapper around LifecycleEvaluator + LifecycleEngine —
+tests dry_run mode, recommendations output, and live transition execution.
+"""
+import asyncio
+import os
+import shutil
+import sqlite3
+import sys
+import tempfile
+from datetime import datetime, timedelta
+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 memory.db with a mix of stale and fresh memories."""
+    conn = sqlite3.connect(db_path)
+    conn.execute(
+        """CREATE TABLE memories (
+            id INTEGER PRIMARY KEY,
+            content TEXT,
+            importance INTEGER DEFAULT 5,
+            lifecycle_state TEXT DEFAULT 'active',
+            lifecycle_history TEXT DEFAULT '[]',
+            lifecycle_updated_at TIMESTAMP,
+            last_accessed TIMESTAMP,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            access_count INTEGER DEFAULT 0,
+            profile TEXT DEFAULT 'default',
+            access_level TEXT DEFAULT 'public'
+        )"""
+    )
+    now = datetime.now()
+    # Stale: 45 days old, low importance -> should be recommended for active->warm
+    conn.execute(
+        "INSERT INTO memories (content, importance, lifecycle_state, last_accessed, created_at) "
+        "VALUES (?, ?, ?, ?, ?)",
+        (
+            "stale memory",
+            3,
+            "active",
+            (now - timedelta(days=45)).isoformat(),
+            (now - timedelta(days=100)).isoformat(),
+        ),
+    )
+    # Fresh: just accessed, high importance -> should NOT be recommended
+    conn.execute(
+        "INSERT INTO memories (content, importance, lifecycle_state, last_accessed, created_at) "
+        "VALUES (?, ?, ?, ?, ?)",
+        ("fresh memory", 8, "active", now.isoformat(), now.isoformat()),
+    )
+    conn.commit()
+    conn.close()
+
+
+class TestMCPCompact:
+    """Tests for the compact_memories 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_dry_run_default(self):
+        """Default call should be dry_run=True."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(tools.compact_memories())
+        assert result["success"] is True
+        assert result["dry_run"] is True
+
+    def test_dry_run_shows_recommendations(self):
+        """Dry run should report recommendation count."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(tools.compact_memories(dry_run=True))
+        assert "recommendations" in result
+        assert isinstance(result["recommendations"], int)
+
+    def test_dry_run_has_stale_recommendation(self):
+        """The stale memory should appear in recommendations."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(tools.compact_memories(dry_run=True))
+        assert result["recommendations"] >= 1
+        # The stale memory (id=1) should be recommended active -> warm
+        detail_ids = [d["memory_id"] for d in result.get("details", [])]
+        assert 1 in detail_ids
+
+    def test_dry_run_details_structure(self):
+        """Each detail entry should have the right keys."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(tools.compact_memories(dry_run=True))
+        if result["recommendations"] > 0:
+            detail = result["details"][0]
+            assert "memory_id" in detail
+            assert "from" in detail
+            assert "to" in detail
+            assert "reason" in detail
+
+    def test_execute_transitions(self):
+        """Non-dry-run should actually transition memories."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(tools.compact_memories(dry_run=False))
+        assert result["success"] is True
+        assert result["dry_run"] is False
+        assert "transitioned" in result
+        assert "evaluated" in result
+
+    def test_execute_changes_state(self):
+        """After execution, the stale memory should be in 'warm' state."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        self._run(tools.compact_memories(dry_run=False))
+        # Verify the stale memory transitioned
+        result = self._run(tools.get_lifecycle_status(memory_id=1))
+        assert result["success"] is True
+        assert result["lifecycle_state"] == "warm"
+
+    def test_fresh_memory_untouched(self):
+        """After execution, the fresh memory should remain 'active'."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        self._run(tools.compact_memories(dry_run=False))
+        result = self._run(tools.get_lifecycle_status(memory_id=2))
+        assert result["success"] is True
+        assert result["lifecycle_state"] == "active"

package/src/lifecycle/tests/test_mcp_lifecycle_status.py

@@ -0,0 +1,114 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for get_lifecycle_status MCP tool handler.
+
+Validates the MCP wrapper around LifecycleEngine — tests state distribution
+retrieval, single memory state lookup, and nonexistent memory handling.
+"""
+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 with lifecycle columns for testing."""
+    conn = sqlite3.connect(db_path)
+    conn.execute(
+        """CREATE TABLE memories (
+            id INTEGER PRIMARY KEY,
+            content TEXT,
+            lifecycle_state TEXT DEFAULT 'active',
+            lifecycle_history TEXT DEFAULT '[]',
+            lifecycle_updated_at TIMESTAMP,
+            importance INTEGER DEFAULT 5,
+            last_accessed TIMESTAMP,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            access_count INTEGER DEFAULT 0,
+            profile TEXT DEFAULT 'default',
+            access_level TEXT DEFAULT 'public'
+        )"""
+    )
+    conn.execute(
+        "INSERT INTO memories (content, lifecycle_state) VALUES ('test mem 1', 'active')"
+    )
+    conn.execute(
+        "INSERT INTO memories (content, lifecycle_state) VALUES ('test mem 2', 'warm')"
+    )
+    conn.execute(
+        "INSERT INTO memories (content, lifecycle_state) VALUES ('test mem 3', 'active')"
+    )
+    conn.commit()
+    conn.close()
+
+
+class TestMCPLifecycleStatus:
+    """Tests for the get_lifecycle_status 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_get_distribution(self):
+        """Without memory_id, should return state distribution."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(tools.get_lifecycle_status())
+        assert result["success"] is True
+        assert "distribution" in result
+        assert result["distribution"]["active"] == 2
+        assert result["distribution"]["warm"] == 1
+        assert result["total_memories"] == 3
+
+    def test_get_single_active_memory(self):
+        """With memory_id=1, should return lifecycle_state='active'."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(tools.get_lifecycle_status(memory_id=1))
+        assert result["success"] is True
+        assert result["memory_id"] == 1
+        assert result["lifecycle_state"] == "active"
+
+    def test_get_single_warm_memory(self):
+        """With memory_id=2, should return lifecycle_state='warm'."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(tools.get_lifecycle_status(memory_id=2))
+        assert result["success"] is True
+        assert result["lifecycle_state"] == "warm"
+
+    def test_nonexistent_memory(self):
+        """Looking up a nonexistent memory_id should return success=False."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(tools.get_lifecycle_status(memory_id=999))
+        assert result["success"] is False
+        assert "not found" in result["error"]
+
+    def test_distribution_all_states_present(self):
+        """Distribution dict should always contain all 5 lifecycle states."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(tools.get_lifecycle_status())
+        dist = result["distribution"]
+        for state in ("active", "warm", "cold", "archived", "tombstoned"):
+            assert state in dist

package/src/lifecycle/tests/test_retention_policy.py

@@ -0,0 +1,162 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for retention policy management.
+"""
+import sqlite3
+import tempfile
+import os
+import sys
+import json
+from pathlib import Path
+
+# Ensure src/ is importable and takes precedence (matches existing test pattern)
+SRC_DIR = Path(__file__).resolve().parent.parent.parent  # src/
+_src_str = str(SRC_DIR)
+if _src_str not in sys.path:
+    sys.path.insert(0, _src_str)
+
+
+class TestRetentionPolicy:
+    """Test retention policy loading, evaluation, and enforcement."""
+
+    def setup_method(self):
+        self.tmp_dir = tempfile.mkdtemp()
+        self.db_path = os.path.join(self.tmp_dir, "test.db")
+        conn = sqlite3.connect(self.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 ('general memory', '[]', 'myproject')")
+        conn.execute("INSERT INTO memories (content, tags, project_name) VALUES ('medical record', '[\"hipaa\"]', 'healthcare')")
+        conn.execute("INSERT INTO memories (content, tags, project_name) VALUES ('user PII data', '[\"gdpr\",\"pii\"]', 'eu-app')")
+        conn.commit()
+        conn.close()
+
+    def teardown_method(self):
+        import shutil
+        shutil.rmtree(self.tmp_dir, ignore_errors=True)
+
+    def test_create_policy(self):
+        """Can create a retention policy programmatically."""
+        from lifecycle.retention_policy import RetentionPolicyManager
+        mgr = RetentionPolicyManager(self.db_path)
+        policy_id = mgr.create_policy(
+            name="GDPR Erasure",
+            retention_days=0,
+            framework="gdpr",
+            action="tombstone",
+            applies_to={"tags": ["gdpr"]},
+        )
+        assert isinstance(policy_id, int)
+        assert policy_id > 0
+
+    def test_list_policies(self):
+        """Can list all policies."""
+        from lifecycle.retention_policy import RetentionPolicyManager
+        mgr = RetentionPolicyManager(self.db_path)
+        mgr.create_policy(name="Policy A", retention_days=30, framework="internal", action="archive", applies_to={})
+        mgr.create_policy(name="Policy B", retention_days=365, framework="hipaa", action="retain", applies_to={})
+        policies = mgr.list_policies()
+        assert len(policies) == 2
+        names = {p["name"] for p in policies}
+        assert "Policy A" in names
+        assert "Policy B" in names
+
+    def test_evaluate_memory_matching_tag(self):
+        """Policy with tag filter matches memories with that tag."""
+        from lifecycle.retention_policy import RetentionPolicyManager
+        mgr = RetentionPolicyManager(self.db_path)
+        mgr.create_policy(
+            name="HIPAA Retention",
+            retention_days=2555,  # ~7 years
+            framework="hipaa",
+            action="retain",
+            applies_to={"tags": ["hipaa"]},
+        )
+        result = mgr.evaluate_memory(2)  # Memory 2 has hipaa tag
+        assert result is not None
+        assert result["policy_name"] == "HIPAA Retention"
+        assert result["action"] == "retain"
+
+    def test_evaluate_memory_no_match(self):
+        """Memory without matching tags returns None."""
+        from lifecycle.retention_policy import RetentionPolicyManager
+        mgr = RetentionPolicyManager(self.db_path)
+        mgr.create_policy(
+            name="HIPAA Retention",
+            retention_days=2555,
+            framework="hipaa",
+            action="retain",
+            applies_to={"tags": ["hipaa"]},
+        )
+        result = mgr.evaluate_memory(1)  # Memory 1 has no hipaa tag
+        assert result is None
+
+    def test_gdpr_erasure_policy(self):
+        """GDPR erasure: retention_days=0, action=tombstone."""
+        from lifecycle.retention_policy import RetentionPolicyManager
+        mgr = RetentionPolicyManager(self.db_path)
+        mgr.create_policy(
+            name="GDPR Right to Erasure",
+            retention_days=0,
+            framework="gdpr",
+            action="tombstone",
+            applies_to={"tags": ["gdpr"]},
+        )
+        result = mgr.evaluate_memory(3)  # Memory 3 has gdpr tag
+        assert result is not None
+        assert result["action"] == "tombstone"
+
+    def test_strictest_policy_wins(self):
+        """When multiple policies match, the strictest (shortest retention) wins."""
+        from lifecycle.retention_policy import RetentionPolicyManager
+        mgr = RetentionPolicyManager(self.db_path)
+        mgr.create_policy(name="Lenient", retention_days=365, framework="internal", action="archive", applies_to={"tags": ["gdpr"]})
+        mgr.create_policy(name="Strict", retention_days=0, framework="gdpr", action="tombstone", applies_to={"tags": ["gdpr"]})
+        result = mgr.evaluate_memory(3)
+        assert result["policy_name"] == "Strict"
+        assert result["action"] == "tombstone"
+
+    def test_load_policies_from_json(self):
+        """Can load policies from a JSON file."""
+        from lifecycle.retention_policy import RetentionPolicyManager
+        mgr = RetentionPolicyManager(self.db_path)
+        policy_file = os.path.join(self.tmp_dir, "policies.json")
+        with open(policy_file, "w") as f:
+            json.dump([
+                {"name": "EU AI Act", "retention_days": 3650, "framework": "eu_ai_act", "action": "retain", "applies_to": {"project_name": "eu-app"}},
+            ], f)
+        count = mgr.load_policies(policy_file)
+        assert count == 1
+        policies = mgr.list_policies()
+        assert len(policies) == 1
+
+    def test_missing_policy_file_no_error(self):
+        """Missing policy file returns 0 loaded, no crash."""
+        from lifecycle.retention_policy import RetentionPolicyManager
+        mgr = RetentionPolicyManager(self.db_path)
+        count = mgr.load_policies("/nonexistent/path/policies.json")
+        assert count == 0
+
+    def test_get_protected_memory_ids(self):
+        """get_protected_memory_ids returns set of IDs protected by retention policies."""
+        from lifecycle.retention_policy import RetentionPolicyManager
+        mgr = RetentionPolicyManager(self.db_path)
+        mgr.create_policy(name="Retain HIPAA", retention_days=2555, framework="hipaa", action="retain", applies_to={"tags": ["hipaa"]})
+        protected = mgr.get_protected_memory_ids()
+        assert 2 in protected  # Memory 2 has hipaa tag
+        assert 1 not in protected  # Memory 1 has no matching tags