@smilintux/skcapstone 0.1.0 → 0.2.3

package/tests/test_memory_adapter.py

@@ -0,0 +1,339 @@
+"""Tests for the Memory Adapter — bridge between skcapstone and skmemory."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from skcapstone.memory_adapter import (
+    _LAYER_FROM_SKMEMORY,
+    _LAYER_TO_SKMEMORY,
+    entry_to_memory,
+    get_unified,
+    memory_to_entry,
+    verify_sync,
+    reindex_all,
+)
+from skcapstone.models import MemoryEntry, MemoryLayer
+
+
+# ---------------------------------------------------------------------------
+# Layer mapping
+# ---------------------------------------------------------------------------
+
+
+class TestLayerMapping:
+    """Tests for layer name conversion."""
+
+    def test_to_skmemory_mapping(self) -> None:
+        """skcapstone layers map to skmemory strings."""
+        assert _LAYER_TO_SKMEMORY[MemoryLayer.SHORT_TERM] == "short-term"
+        assert _LAYER_TO_SKMEMORY[MemoryLayer.MID_TERM] == "mid-term"
+        assert _LAYER_TO_SKMEMORY[MemoryLayer.LONG_TERM] == "long-term"
+
+    def test_from_skmemory_mapping(self) -> None:
+        """skmemory strings map back to skcapstone layers."""
+        assert _LAYER_FROM_SKMEMORY["short-term"] == MemoryLayer.SHORT_TERM
+        assert _LAYER_FROM_SKMEMORY["mid-term"] == MemoryLayer.MID_TERM
+        assert _LAYER_FROM_SKMEMORY["long-term"] == MemoryLayer.LONG_TERM
+
+    def test_roundtrip(self) -> None:
+        """Layer mappings are invertible."""
+        for layer in MemoryLayer:
+            sk_str = _LAYER_TO_SKMEMORY[layer]
+            assert _LAYER_FROM_SKMEMORY[sk_str] == layer
+
+
+# ---------------------------------------------------------------------------
+# entry_to_memory conversion
+# ---------------------------------------------------------------------------
+
+
+class TestEntryToMemory:
+    """Tests for converting MemoryEntry to skmemory Memory."""
+
+    def test_basic_conversion(self) -> None:
+        """Basic entry converts to Memory with correct fields."""
+        entry = MemoryEntry(
+            memory_id="abc123",
+            content="Test memory content",
+            tags=["test", "unit"],
+            source="cli",
+            layer=MemoryLayer.SHORT_TERM,
+            importance=0.7,
+        )
+        mem = entry_to_memory(entry)
+        assert mem.id == "abc123"
+        assert mem.content == "Test memory content"
+        assert mem.tags == ["test", "unit"]
+        assert mem.source == "cli"
+        assert mem.layer.value == "short-term"
+
+    def test_title_from_content(self) -> None:
+        """Title is derived from first 80 chars of content."""
+        entry = MemoryEntry(
+            memory_id="abc",
+            content="A" * 100,
+        )
+        mem = entry_to_memory(entry)
+        assert len(mem.title) == 80
+
+    def test_emotional_intensity_from_importance(self) -> None:
+        """Importance maps to emotional intensity (x10)."""
+        entry = MemoryEntry(
+            memory_id="abc",
+            content="Test",
+            importance=0.8,
+        )
+        mem = entry_to_memory(entry)
+        assert mem.emotional.intensity == 8.0
+
+    def test_metadata_preserved(self) -> None:
+        """Extra metadata fields are preserved."""
+        entry = MemoryEntry(
+            memory_id="abc",
+            content="Test",
+            metadata={"custom_key": "custom_value"},
+            access_count=5,
+            soul_context="lumina",
+        )
+        mem = entry_to_memory(entry)
+        assert mem.metadata["access_count"] == 5
+        assert mem.metadata["soul_context"] == "lumina"
+        assert mem.metadata["custom_key"] == "custom_value"
+
+    def test_all_layers(self) -> None:
+        """All layer types convert correctly."""
+        for layer in MemoryLayer:
+            entry = MemoryEntry(
+                memory_id=f"id-{layer.value}",
+                content="Test",
+                layer=layer,
+            )
+            mem = entry_to_memory(entry)
+            assert mem.layer.value == _LAYER_TO_SKMEMORY[layer]
+
+
+# ---------------------------------------------------------------------------
+# memory_to_entry conversion
+# ---------------------------------------------------------------------------
+
+
+class TestMemoryToEntry:
+    """Tests for converting skmemory Memory to MemoryEntry."""
+
+    def test_roundtrip(self) -> None:
+        """Entry → Memory → Entry preserves key fields."""
+        original = MemoryEntry(
+            memory_id="round-trip",
+            content="Round trip test",
+            tags=["test"],
+            source="mcp",
+            layer=MemoryLayer.MID_TERM,
+            importance=0.6,
+            access_count=3,
+        )
+        mem = entry_to_memory(original)
+        restored = memory_to_entry(mem)
+        assert restored.memory_id == original.memory_id
+        assert restored.content == original.content
+        assert restored.tags == original.tags
+        assert restored.source == original.source
+        assert restored.layer == original.layer
+        assert abs(restored.importance - original.importance) < 0.01
+        assert restored.access_count == original.access_count
+
+    def test_importance_clamped(self) -> None:
+        """Importance is clamped to [0.0, 1.0]."""
+        from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer as SKLayer
+
+        mem = Memory(
+            id="test",
+            title="test",
+            content="test",
+            layer=SKLayer("short-term"),
+            tags=[],
+            source="test",
+            emotional=EmotionalSnapshot(intensity=10.0),  # 10 / 10 = 1.0
+            metadata={},
+        )
+        entry = memory_to_entry(mem)
+        assert entry.importance <= 1.0
+        assert entry.importance >= 0.0
+
+    def test_soul_context_extracted(self) -> None:
+        """soul_context is extracted from metadata."""
+        original = MemoryEntry(
+            memory_id="soul-test",
+            content="Soul context test",
+            soul_context="opus",
+        )
+        mem = entry_to_memory(original)
+        restored = memory_to_entry(mem)
+        assert restored.soul_context == "opus"
+
+
+# ---------------------------------------------------------------------------
+# get_unified singleton
+# ---------------------------------------------------------------------------
+
+
+class TestGetUnified:
+    """Tests for the unified store singleton."""
+
+    def test_returns_none_without_skmemory(self) -> None:
+        """Returns None when skmemory is not available."""
+        import skcapstone.memory_adapter as ma
+
+        old_checked = ma._unified_checked
+        old_store = ma._unified_store
+        try:
+            ma._unified_checked = False
+            ma._unified_store = None
+            with patch.object(ma, "_skmemory_available", return_value=False):
+                with patch.object(ma, "_get_store", return_value=None):
+                    result = get_unified()
+            assert result is None
+        finally:
+            ma._unified_checked = old_checked
+            ma._unified_store = old_store
+
+    def test_caches_result(self) -> None:
+        """Second call returns cached store, doesn't recreate."""
+        import skcapstone.memory_adapter as ma
+
+        old_checked = ma._unified_checked
+        old_store = ma._unified_store
+        try:
+            ma._unified_checked = False
+            ma._unified_store = None
+            mock_store = MagicMock()
+            with patch.object(ma, "_get_store", return_value=mock_store) as mock_get:
+                first = get_unified()
+                second = get_unified()
+            assert first is second
+            assert mock_get.call_count == 1
+        finally:
+            ma._unified_checked = old_checked
+            ma._unified_store = old_store
+
+
+# ---------------------------------------------------------------------------
+# verify_sync
+# ---------------------------------------------------------------------------
+
+
+class TestVerifySync:
+    """Tests for sync verification."""
+
+    def test_returns_not_available_without_skmemory(self) -> None:
+        """Returns error dict when no store available."""
+        import skcapstone.memory_adapter as ma
+
+        old_checked = ma._unified_checked
+        old_store = ma._unified_store
+        try:
+            ma._unified_checked = True
+            ma._unified_store = None
+            result = verify_sync()
+            assert result["synced"] is False
+            assert "not available" in result["reason"]
+        finally:
+            ma._unified_checked = old_checked
+            ma._unified_store = old_store
+
+    def test_detects_sync(self) -> None:
+        """Reports synced when counts match."""
+        mock_store = MagicMock()
+        mock_store.health.return_value = {
+            "primary": {"ok": True},
+            "vector": {"ok": True, "point_count": 10},
+        }
+        mock_store.primary.stats.return_value = {"total": 10}
+
+        import skcapstone.memory_adapter as ma
+
+        old_checked = ma._unified_checked
+        old_store = ma._unified_store
+        try:
+            ma._unified_checked = True
+            ma._unified_store = mock_store
+            result = verify_sync()
+            assert result["synced"] is True
+        finally:
+            ma._unified_checked = old_checked
+            ma._unified_store = old_store
+
+    def test_detects_mismatch(self) -> None:
+        """Reports not synced when counts differ."""
+        mock_store = MagicMock()
+        mock_store.health.return_value = {
+            "primary": {"ok": True},
+            "vector": {"ok": True, "point_count": 5},
+        }
+        mock_store.primary.stats.return_value = {"total": 10}
+
+        import skcapstone.memory_adapter as ma
+
+        old_checked = ma._unified_checked
+        old_store = ma._unified_store
+        try:
+            ma._unified_checked = True
+            ma._unified_store = mock_store
+            result = verify_sync()
+            assert result["synced"] is False
+            assert "mismatch" in result.get("reason", "").lower()
+        finally:
+            ma._unified_checked = old_checked
+            ma._unified_store = old_store
+
+
+# ---------------------------------------------------------------------------
+# reindex_all
+# ---------------------------------------------------------------------------
+
+
+class TestReindexAll:
+    """Tests for full reindex."""
+
+    def test_returns_not_available_without_store(self) -> None:
+        """Returns error when no store available."""
+        import skcapstone.memory_adapter as ma
+
+        old_checked = ma._unified_checked
+        old_store = ma._unified_store
+        try:
+            ma._unified_checked = True
+            ma._unified_store = None
+            result = reindex_all()
+            assert result["ok"] is False
+        finally:
+            ma._unified_checked = old_checked
+            ma._unified_store = old_store
+
+    def test_reindexes_all_memories(self) -> None:
+        """Reindex processes all memories from primary."""
+        mock_mem = MagicMock()
+        mock_mem.id = "test-1"
+        mock_store = MagicMock()
+        mock_store.list_memories.return_value = [mock_mem, mock_mem]
+        mock_store.vector = MagicMock()
+        mock_store.graph = MagicMock()
+
+        import skcapstone.memory_adapter as ma
+
+        old_checked = ma._unified_checked
+        old_store = ma._unified_store
+        try:
+            ma._unified_checked = True
+            ma._unified_store = mock_store
+            result = reindex_all()
+            assert result["ok"] is True
+            assert result["total"] == 2
+            assert result["vector_indexed"] == 2
+            assert result["graph_indexed"] == 2
+        finally:
+            ma._unified_checked = old_checked
+            ma._unified_store = old_store

package/tests/test_memory_curator.py

@@ -0,0 +1,218 @@
+"""Tests for the memory curator module."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from skcapstone.memory_engine import list_memories, recall, store
+from skcapstone.memory_curator import (
+    CurationResult,
+    MemoryCurator,
+    _content_hash,
+    _suggest_tags,
+)
+from skcapstone.models import MemoryLayer
+from skcapstone.pillars.memory import initialize_memory
+
+
+@pytest.fixture
+def curator_home(tmp_agent_home: Path) -> Path:
+    """Provide an agent home with memory initialized."""
+    initialize_memory(tmp_agent_home)
+    return tmp_agent_home
+
+
+class TestSuggestTags:
+    """Tests for the auto-tag suggestion function."""
+
+    def test_detects_capauth(self):
+        """Finds capauth mentions."""
+        tags = _suggest_tags("The capauth system handles identity", [])
+        assert "capauth" in tags
+
+    def test_skips_existing_tags(self):
+        """Doesn't suggest tags already present."""
+        tags = _suggest_tags("The capauth system", ["capauth"])
+        assert "capauth" not in tags
+
+    def test_multiple_suggestions(self):
+        """Detects multiple patterns in one text."""
+        tags = _suggest_tags("skcapstone uses MCP and PGP for security", [])
+        assert "skcapstone" in tags
+        assert "mcp" in tags
+        assert "pgp" in tags
+
+    def test_no_suggestions_for_generic(self):
+        """Generic text gets no tag suggestions."""
+        tags = _suggest_tags("The weather is nice today", [])
+        assert tags == []
+
+
+class TestContentHash:
+    """Tests for the deduplication hash function."""
+
+    def test_identical_content(self):
+        """Same content produces same hash."""
+        assert _content_hash("hello world") == _content_hash("hello world")
+
+    def test_case_insensitive(self):
+        """Hash is case-insensitive."""
+        assert _content_hash("Hello World") == _content_hash("hello world")
+
+    def test_whitespace_normalized(self):
+        """Extra whitespace is normalized before hashing."""
+        assert _content_hash("hello  world") == _content_hash("hello world")
+
+    def test_different_content(self):
+        """Different content produces different hashes."""
+        assert _content_hash("alpha") != _content_hash("beta")
+
+
+class TestCuratorAutoTag:
+    """Tests for the auto-tagging pass."""
+
+    def test_adds_missing_tags(self, curator_home: Path):
+        """Auto-tag adds relevant tags to untagged memories."""
+        store(curator_home, "The skcapstone MCP server exposes tools", tags=[])
+        curator = MemoryCurator(curator_home)
+        result = curator.curate(promote=False, dedupe=False)
+
+        assert len(result.tagged) >= 1
+        memories = list_memories(curator_home)
+        tagged_mem = next((m for m in memories if "skcapstone" in m.tags), None)
+        assert tagged_mem is not None
+
+    def test_dry_run_no_changes(self, curator_home: Path):
+        """Dry run reports changes without applying them."""
+        store(curator_home, "The capauth PGP system", tags=[])
+        curator = MemoryCurator(curator_home)
+        result = curator.curate(dry_run=True, promote=False, dedupe=False)
+
+        assert len(result.tagged) >= 1
+        memories = list_memories(curator_home)
+        for m in memories:
+            assert "capauth" not in m.tags
+
+
+class TestCuratorPromote:
+    """Tests for the promotion pass."""
+
+    def test_promotes_high_access(self, curator_home: Path):
+        """Memories with high access count get promoted."""
+        entry = store(curator_home, "Frequently accessed memory", importance=0.3)
+        entry.access_count = 5
+        from skcapstone.memory_engine import _save_entry
+        _save_entry(curator_home, entry)
+
+        curator = MemoryCurator(curator_home)
+        result = curator.curate(auto_tag=False, dedupe=False)
+
+        assert len(result.promoted) >= 1
+
+    def test_promotes_high_importance(self, curator_home: Path):
+        """High importance short-term memories get promoted."""
+        store(curator_home, "Very important memory", importance=0.8)
+
+        curator = MemoryCurator(curator_home)
+        result = curator.curate(auto_tag=False, dedupe=False)
+
+        # Reason: importance >= 0.7 auto-promotes to mid-term at store time,
+        # so this won't be in short-term. Store at 0.65 instead.
+        store(curator_home, "Almost important", importance=0.65)
+        entry = list_memories(curator_home, limit=1)[0]
+        entry.access_count = 4
+        _save_entry = __import__("skcapstone.memory_engine", fromlist=["_save_entry"])._save_entry
+        _save_entry(curator_home, entry)
+
+        result2 = curator.curate(auto_tag=False, dedupe=False)
+        # At least the high-access one should promote
+        assert result2.total_scanned >= 1
+
+
+class TestCuratorDedupe:
+    """Tests for the deduplication pass."""
+
+    def test_removes_exact_duplicates(self, curator_home: Path):
+        """Identical content is deduplicated."""
+        store(curator_home, "Duplicate memory content here", importance=0.4)
+        store(curator_home, "Duplicate memory content here", importance=0.3)
+
+        curator = MemoryCurator(curator_home)
+        result = curator.curate(auto_tag=False, promote=False)
+
+        assert len(result.deduped) >= 1
+
+    def test_keeps_higher_tier(self, curator_home: Path):
+        """When deduping, the higher-tier memory is kept."""
+        store(curator_home, "Keep this important memory", importance=0.9)
+        store(curator_home, "Keep this important memory", importance=0.3)
+
+        before = len(list_memories(curator_home))
+        curator = MemoryCurator(curator_home)
+        curator.curate(auto_tag=False, promote=False)
+        after = len(list_memories(curator_home))
+
+        assert after < before
+
+    def test_no_false_positives(self, curator_home: Path):
+        """Different content is not deduplicated."""
+        store(curator_home, "First unique memory about cats")
+        store(curator_home, "Second unique memory about dogs")
+
+        curator = MemoryCurator(curator_home)
+        result = curator.curate(auto_tag=False, promote=False)
+
+        assert len(result.deduped) == 0
+
+
+class TestCuratorStats:
+    """Tests for get_stats()."""
+
+    def test_empty_stats(self, curator_home: Path):
+        """Stats on empty store returns zero counts."""
+        curator = MemoryCurator(curator_home)
+        stats = curator.get_stats()
+        assert stats["total"] == 0
+
+    def test_stats_with_memories(self, curator_home: Path):
+        """Stats reflect stored memories."""
+        store(curator_home, "First memory", tags=["alpha"])
+        store(curator_home, "Second memory", tags=["beta"])
+        store(curator_home, "Untagged memory")
+
+        curator = MemoryCurator(curator_home)
+        stats = curator.get_stats()
+
+        assert stats["total"] == 3
+        assert stats["tag_coverage"] > 0.0
+        assert stats["avg_importance"] > 0.0
+
+    def test_top_tags(self, curator_home: Path):
+        """Top tags are reported correctly."""
+        for _ in range(3):
+            store(curator_home, "PGP encryption test", tags=["pgp"])
+        store(curator_home, "Other stuff", tags=["misc"])
+
+        curator = MemoryCurator(curator_home)
+        stats = curator.get_stats()
+
+        tag_names = [t[0] for t in stats["top_tags"]]
+        assert "pgp" in tag_names
+
+
+class TestFullCuration:
+    """End-to-end curation test."""
+
+    def test_full_pass(self, curator_home: Path):
+        """Full curation pass runs all three phases."""
+        store(curator_home, "The skcapstone architecture uses pillars")
+        store(curator_home, "The skcapstone architecture uses pillars")
+        store(curator_home, "Security requires PGP encryption", tags=[])
+
+        curator = MemoryCurator(curator_home)
+        result = curator.curate()
+
+        assert result.total_scanned >= 3
+        assert isinstance(result, CurationResult)

package/tests/test_memory_engine.py

@@ -22,6 +22,12 @@ from skcapstone.memory_engine import (
 from skcapstone.models import MemoryEntry, MemoryLayer
 
 
+@pytest.fixture(autouse=True)
+def no_unified_backend(monkeypatch):
+    """Disable the unified skmemory backend so tests use only file-based storage."""
+    monkeypatch.setattr("skcapstone.memory_engine._get_unified", lambda: None)
+
+
 @pytest.fixture
 def agent_home(tmp_path: Path) -> Path:
     """Create a temporary agent home with memory directories."""