superlocalmemory 2.8.6 → 3.0.0

package/src/lifecycle/tests/test_lifecycle_search.py

@@ -1,109 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for lifecycle-aware search filtering.
-"""
-import sqlite3
-import tempfile
-import os
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-
-class TestLifecycleSearch:
-    """Test that search respects lifecycle states."""
-
-    def setup_method(self):
-        self.db_fd, self.db_path = tempfile.mkstemp(suffix=".db")
-        # Create MemoryStoreV2 — this sets up full schema + FTS triggers
-        from memory_store_v2 import MemoryStoreV2
-        self.store = MemoryStoreV2(self.db_path)
-
-        # Create test memories via add_memory (the actual MemoryStoreV2 API)
-        self.store.add_memory(content="active memory about Python programming", tags=["python"], importance=5)
-        self.store.add_memory(content="another active memory about JavaScript", tags=["js"], importance=5)
-        self.store.add_memory(content="warm memory about database design", tags=["db"], importance=5)
-        self.store.add_memory(content="cold memory about API architecture", tags=["api"], importance=5)
-        self.store.add_memory(content="archived memory about legacy systems", tags=["legacy"], importance=5)
-        self.store.add_memory(content="tombstoned memory about deleted content", tags=["deleted"], importance=5)
-
-        # Manually set lifecycle states
-        conn = sqlite3.connect(self.db_path)
-        conn.execute("UPDATE memories SET lifecycle_state = 'warm' WHERE id = 3")
-        conn.execute("UPDATE memories SET lifecycle_state = 'cold' WHERE id = 4")
-        conn.execute("UPDATE memories SET lifecycle_state = 'archived' WHERE id = 5")
-        conn.execute("UPDATE memories SET lifecycle_state = 'tombstoned' WHERE id = 6")
-        conn.commit()
-        conn.close()
-
-        # Rebuild vectors after state changes
-        self.store._rebuild_vectors()
-
-    def teardown_method(self):
-        os.close(self.db_fd)
-        try:
-            os.unlink(self.db_path)
-        except OSError:
-            pass
-
-    def test_default_search_returns_active_and_warm(self):
-        """Default search should return ACTIVE and WARM memories only."""
-        results = self.store.search("memory", limit=10)
-        states = {r.get('lifecycle_state', 'active') for r in results}
-        # Should only contain active and warm
-        assert 'cold' not in states
-        assert 'archived' not in states
-        assert 'tombstoned' not in states
-
-    def test_default_search_includes_warm(self):
-        """Default search should include warm memories."""
-        results = self.store.search("database design", limit=10)
-        ids = {r['id'] for r in results}
-        # Memory 3 (warm, about database) should be found
-        assert 3 in ids
-
-    def test_include_cold(self):
-        """Search with include_cold should return active + warm + cold."""
-        results = self.store.search("memory", limit=10, lifecycle_states=("active", "warm", "cold"))
-        ids = {r['id'] for r in results}
-        # Cold memory (id=4) should be included
-        assert 4 in ids
-
-    def test_include_archived(self):
-        """Search with archived should return those memories."""
-        results = self.store.search("legacy", limit=10, lifecycle_states=("active", "warm", "cold", "archived"))
-        ids = {r['id'] for r in results}
-        assert 5 in ids
-
-    def test_tombstoned_never_returned(self):
-        """TOMBSTONED memories should never be returned, even when explicitly requested."""
-        results = self.store.search("deleted", limit=10, lifecycle_states=("active", "warm", "cold", "archived", "tombstoned"))
-        # Even with tombstoned in the filter, the search should work
-        # (tombstoned memories may or may not appear depending on implementation,
-        # but they should at minimum not break the search)
-        assert isinstance(results, list)
-
-    def test_backward_compat_no_lifecycle_param(self):
-        """Existing search calls without lifecycle parameter still work."""
-        results = self.store.search("Python programming", limit=5)
-        assert len(results) >= 1
-        assert results[0]['content'] is not None
-
-    def test_warm_memory_reactivated_on_recall(self):
-        """Warm memory should be reactivated to ACTIVE when recalled."""
-        # Search for the warm memory
-        results = self.store.search("database design", limit=5)
-        warm_found = any(r['id'] == 3 for r in results)
-        if warm_found:
-            # Check if it was reactivated
-            conn = sqlite3.connect(self.db_path)
-            row = conn.execute("SELECT lifecycle_state FROM memories WHERE id=3").fetchone()
-            conn.close()
-            assert row[0] == "active"
-
-    def test_search_result_includes_lifecycle_state(self):
-        """Search results should include lifecycle_state field."""
-        results = self.store.search("Python", limit=5)
-        if results:
-            assert 'lifecycle_state' in results[0]

package/src/lifecycle/tests/test_mcp_compact.py

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

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

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