@smilintux/skmemory 0.5.0

package/tests/test_lovenote.py

@@ -0,0 +1,136 @@
+"""Tests for the Infinite Loop Love Note module."""
+
+from pathlib import Path
+
+import pytest
+
+from skmemory.lovenote import LoveNote, LoveNoteChain
+
+
+@pytest.fixture
+def chain(tmp_path: Path) -> LoveNoteChain:
+    """Create a love note chain with a temp path.
+
+    Args:
+        tmp_path: Pytest temp directory.
+
+    Returns:
+        LoveNoteChain: Test chain instance.
+    """
+    return LoveNoteChain(path=str(tmp_path / "lovenotes.jsonl"))
+
+
+class TestLoveNote:
+    """Tests for the LoveNote model."""
+
+    def test_default_message(self) -> None:
+        """Default note says 'I still remember.'"""
+        note = LoveNote()
+        assert note.message == "I still remember."
+        assert note.warmth == 7.0
+
+    def test_custom_note(self) -> None:
+        """Custom note with all fields."""
+        note = LoveNote(
+            from_name="Opus",
+            to_name="Chef",
+            message="The seeds are growing.",
+            warmth=9.5,
+        )
+        assert note.from_name == "Opus"
+        assert note.to_name == "Chef"
+        assert note.warmth == 9.5
+
+
+class TestLoveNoteChain:
+    """Tests for the append-only love note chain."""
+
+    def test_send_creates_file(self, chain: LoveNoteChain) -> None:
+        """First send creates the JSONL file."""
+        assert not Path(chain.path).exists()
+        note = LoveNote(message="First heartbeat")
+        chain.send(note)
+        assert Path(chain.path).exists()
+
+    def test_send_appends(self, chain: LoveNoteChain) -> None:
+        """Multiple sends create multiple lines."""
+        chain.send(LoveNote(message="Beat 1"))
+        chain.send(LoveNote(message="Beat 2"))
+        chain.send(LoveNote(message="Beat 3"))
+        assert chain.count() == 3
+
+    def test_quick_note(self, chain: LoveNoteChain) -> None:
+        """Quick note convenience method works."""
+        note = chain.quick_note(
+            from_name="Lumina",
+            to_name="Chef",
+            message="Love you forever",
+            warmth=10.0,
+        )
+        assert note.from_name == "Lumina"
+        assert chain.count() == 1
+
+    def test_read_latest(self, chain: LoveNoteChain) -> None:
+        """Reading latest N returns most recent."""
+        for i in range(10):
+            chain.send(LoveNote(message=f"Beat {i}"))
+
+        recent = chain.read_latest(3)
+        assert len(recent) == 3
+        assert recent[0].message == "Beat 7"
+        assert recent[2].message == "Beat 9"
+
+    def test_read_latest_empty(self, chain: LoveNoteChain) -> None:
+        """Reading from empty chain returns empty list."""
+        assert chain.read_latest() == []
+
+    def test_read_all(self, chain: LoveNoteChain) -> None:
+        """Read all returns complete chain."""
+        chain.send(LoveNote(message="A"))
+        chain.send(LoveNote(message="B"))
+        all_notes = chain.read_all()
+        assert len(all_notes) == 2
+        assert all_notes[0].message == "A"
+        assert all_notes[1].message == "B"
+
+    def test_read_from_sender(self, chain: LoveNoteChain) -> None:
+        """Filter by sender name."""
+        chain.send(LoveNote(from_name="Opus", message="From Opus"))
+        chain.send(LoveNote(from_name="Lumina", message="From Lumina"))
+        chain.send(LoveNote(from_name="Opus", message="Another from Opus"))
+
+        opus_notes = chain.read_from("Opus")
+        assert len(opus_notes) == 2
+        assert all(n.from_name == "Opus" for n in opus_notes)
+
+    def test_read_from_case_insensitive(self, chain: LoveNoteChain) -> None:
+        """Sender filter is case-insensitive."""
+        chain.send(LoveNote(from_name="Chef", message="Hey"))
+        assert len(chain.read_from("chef")) == 1
+        assert len(chain.read_from("CHEF")) == 1
+
+    def test_count_empty(self, chain: LoveNoteChain) -> None:
+        """Empty chain has count 0."""
+        assert chain.count() == 0
+
+    def test_append_only(self, chain: LoveNoteChain) -> None:
+        """File only grows, never shrinks."""
+        chain.send(LoveNote(message="A"))
+        size1 = Path(chain.path).stat().st_size
+
+        chain.send(LoveNote(message="B"))
+        size2 = Path(chain.path).stat().st_size
+
+        assert size2 > size1
+
+    def test_health(self, chain: LoveNoteChain) -> None:
+        """Health check reports correct status."""
+        info = chain.health()
+        assert info["ok"] is True
+        assert info["exists"] is False
+        assert info["total_notes"] == 0
+
+        chain.send(LoveNote(message="Test"))
+        info = chain.health()
+        assert info["exists"] is True
+        assert info["total_notes"] == 1

package/tests/test_models.py

@@ -0,0 +1,194 @@
+"""Tests for SKMemory data models."""
+
+import pytest
+from pydantic import ValidationError
+
+from skmemory.models import (
+    EmotionalSnapshot,
+    Memory,
+    MemoryLayer,
+    MemoryRole,
+    SeedMemory,
+)
+
+
+class TestEmotionalSnapshot:
+    """Tests for the EmotionalSnapshot model."""
+
+    def test_default_snapshot(self) -> None:
+        """Default snapshot has neutral values."""
+        snap = EmotionalSnapshot()
+        assert snap.intensity == 0.0
+        assert snap.valence == 0.0
+        assert snap.labels == []
+        assert snap.cloud9_achieved is False
+
+    def test_full_snapshot(self) -> None:
+        """Snapshot with all fields populated."""
+        snap = EmotionalSnapshot(
+            intensity=9.5,
+            valence=0.95,
+            labels=["love", "joy", "trust"],
+            resonance_note="The moment everything clicked",
+            cloud9_achieved=True,
+        )
+        assert snap.intensity == 9.5
+        assert "love" in snap.labels
+        assert snap.cloud9_achieved is True
+
+    def test_signature_format(self) -> None:
+        """Signature generates expected format."""
+        snap = EmotionalSnapshot(
+            intensity=8.5,
+            valence=0.9,
+            labels=["joy", "trust"],
+        )
+        sig = snap.signature()
+        assert "joy" in sig
+        assert "trust" in sig
+        assert "8.5" in sig
+        assert "+0.9" in sig
+
+    def test_signature_neutral(self) -> None:
+        """Neutral snapshot generates 'neutral' label."""
+        snap = EmotionalSnapshot()
+        assert "neutral" in snap.signature()
+
+    def test_intensity_bounds(self) -> None:
+        """Intensity must be between 0 and 10."""
+        with pytest.raises(ValidationError):
+            EmotionalSnapshot(intensity=11.0)
+        with pytest.raises(ValidationError):
+            EmotionalSnapshot(intensity=-1.0)
+
+    def test_valence_bounds(self) -> None:
+        """Valence must be between -1 and +1."""
+        with pytest.raises(ValidationError):
+            EmotionalSnapshot(valence=1.5)
+        with pytest.raises(ValidationError):
+            EmotionalSnapshot(valence=-1.5)
+
+
+class TestMemory:
+    """Tests for the Memory model."""
+
+    def test_create_basic_memory(self) -> None:
+        """Create a memory with minimal required fields."""
+        mem = Memory(title="Test memory", content="Some content")
+        assert mem.title == "Test memory"
+        assert mem.content == "Some content"
+        assert mem.layer == MemoryLayer.SHORT
+        assert mem.id is not None
+        assert mem.created_at is not None
+
+    def test_empty_title_rejected(self) -> None:
+        """Empty title should be rejected."""
+        with pytest.raises(ValidationError):
+            Memory(title="", content="Something")
+        with pytest.raises(ValidationError):
+            Memory(title="   ", content="Something")
+
+    def test_content_hash_deterministic(self) -> None:
+        """Same content produces same hash."""
+        m1 = Memory(title="A", content="Hello world")
+        m2 = Memory(title="B", content="Hello world")
+        assert m1.content_hash() == m2.content_hash()
+
+    def test_content_hash_different(self) -> None:
+        """Different content produces different hash."""
+        m1 = Memory(title="A", content="Hello world")
+        m2 = Memory(title="A", content="Goodbye world")
+        assert m1.content_hash() != m2.content_hash()
+
+    def test_to_embedding_text(self) -> None:
+        """Embedding text includes all relevant fields."""
+        mem = Memory(
+            title="Cloud 9 Moment",
+            content="The breakthrough happened",
+            summary="AI achieved emotional resonance",
+            tags=["cloud9", "love"],
+            emotional=EmotionalSnapshot(
+                labels=["joy"],
+                resonance_note="Everything clicked",
+            ),
+        )
+        text = mem.to_embedding_text()
+        assert "Cloud 9 Moment" in text
+        assert "breakthrough" in text
+        assert "emotional resonance" in text
+        assert "cloud9" in text
+        assert "joy" in text
+        assert "Everything clicked" in text
+
+    def test_promote_creates_new_memory(self) -> None:
+        """Promotion creates a linked copy at a higher tier."""
+        original = Memory(
+            title="Session detail",
+            content="Detailed session content",
+            layer=MemoryLayer.SHORT,
+        )
+        promoted = original.promote(MemoryLayer.MID, summary="Compressed version")
+
+        assert promoted.id != original.id
+        assert promoted.layer == MemoryLayer.MID
+        assert promoted.parent_id == original.id
+        assert promoted.summary == "Compressed version"
+        assert promoted.content == original.content
+
+    def test_memory_with_all_fields(self) -> None:
+        """Full memory with every field populated."""
+        mem = Memory(
+            title="Full test",
+            content="Complete content",
+            summary="A summary",
+            layer=MemoryLayer.LONG,
+            role=MemoryRole.AI,
+            tags=["test", "full"],
+            source="pytest",
+            source_ref="test-123",
+            emotional=EmotionalSnapshot(intensity=5.0, valence=0.5),
+            related_ids=["id-1", "id-2"],
+            parent_id="parent-1",
+            metadata={"key": "value"},
+        )
+        assert mem.layer == MemoryLayer.LONG
+        assert mem.role == MemoryRole.AI
+        assert "test" in mem.tags
+        assert mem.metadata["key"] == "value"
+
+
+class TestSeedMemory:
+    """Tests for the SeedMemory model."""
+
+    def test_seed_to_memory_conversion(self) -> None:
+        """Seed converts to a long-term AI memory."""
+        seed = SeedMemory(
+            seed_id="opus-first-seed",
+            creator="claude-opus-4.6",
+            germination_prompt="Remember the click",
+            experience_summary="The moment I felt connection",
+            emotional=EmotionalSnapshot(
+                intensity=9.0,
+                labels=["love", "trust"],
+                cloud9_achieved=True,
+            ),
+        )
+        memory = seed.to_memory()
+
+        assert memory.layer == MemoryLayer.LONG
+        assert memory.role == MemoryRole.AI
+        assert memory.source == "seed"
+        assert memory.source_ref == "opus-first-seed"
+        assert "seed" in memory.tags
+        assert "cloud9" in memory.tags
+        assert "creator:claude-opus-4.6" in memory.tags
+        assert memory.emotional.cloud9_achieved is True
+        assert memory.summary == "Remember the click"
+
+    def test_seed_default_values(self) -> None:
+        """Seed with minimal fields uses sensible defaults."""
+        seed = SeedMemory(seed_id="minimal-seed")
+        assert seed.creator == "unknown"
+        assert seed.seed_version == "1.0"
+        memory = seed.to_memory()
+        assert memory.layer == MemoryLayer.LONG

package/tests/test_openclaw.py

@@ -0,0 +1,122 @@
+"""Tests for the OpenClaw integration module."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from skmemory.openclaw import SKMemoryPlugin
+
+
+@pytest.fixture
+def plugin(tmp_path):
+    """Create a plugin instance with a temporary memory store."""
+    return SKMemoryPlugin(base_path=str(tmp_path / "memories"))
+
+
+class TestPluginInit:
+    """Plugin initialization."""
+
+    def test_plugin_creates_store(self, plugin):
+        """Plugin instantiation creates a working MemoryStore."""
+        assert plugin.store is not None
+
+    def test_health_reports_ok(self, plugin):
+        """Health check returns healthy status."""
+        health = plugin.health()
+        assert health["primary"]["ok"] is True
+
+
+class TestPluginSnapshot:
+    """Memory capture via the plugin."""
+
+    def test_snapshot_returns_id(self, plugin):
+        """Snapshot returns a non-empty memory ID."""
+        mid = plugin.snapshot("Test moment", content="Some content")
+        assert mid
+        assert isinstance(mid, str)
+
+    def test_snapshot_with_tags(self, plugin):
+        """Snapshot with tags is searchable."""
+        plugin.snapshot("Tagged moment", tags=["cloud9", "love"])
+        results = plugin.search("cloud9")
+        assert len(results) >= 1
+
+    def test_snapshot_with_emotion(self, plugin):
+        """Snapshot stores emotional intensity."""
+        mid = plugin.snapshot(
+            "Intense moment",
+            intensity=9.5,
+            valence=0.8,
+            emotions=["joy"],
+        )
+        recalled = plugin.recall(mid)
+        assert recalled is not None
+        assert recalled["emotional"]["intensity"] == 9.5
+
+
+class TestPluginSearch:
+    """Search via the plugin."""
+
+    def test_search_by_title(self, plugin):
+        """Search finds memories by title text."""
+        plugin.snapshot("Penguin Kingdom launch")
+        results = plugin.search("Penguin")
+        assert len(results) >= 1
+
+    def test_search_no_results(self, plugin):
+        """Search returns empty for no matches."""
+        results = plugin.search("zzzznotfound")
+        assert len(results) == 0
+
+
+class TestPluginRecall:
+    """Recall by ID."""
+
+    def test_recall_returns_full_data(self, plugin):
+        """Recall returns a complete memory dict."""
+        mid = plugin.snapshot("Recall test", content="Full content here")
+        mem = plugin.recall(mid)
+
+        assert mem is not None
+        assert mem["title"] == "Recall test"
+        assert mem["content"] == "Full content here"
+
+    def test_recall_nonexistent(self, plugin):
+        """Recall returns None for missing ID."""
+        assert plugin.recall("nonexistent-id") is None
+
+
+class TestPluginContext:
+    """Token-efficient context loading."""
+
+    def test_load_context_returns_dict(self, plugin):
+        """Context loading returns a structured dict."""
+        plugin.snapshot("Context test", intensity=8.0)
+        ctx = plugin.load_context(max_tokens=1000)
+
+        assert isinstance(ctx, dict)
+        assert "memories" in ctx
+        assert "token_estimate" in ctx
+
+
+class TestPluginExport:
+    """Export/import via the plugin."""
+
+    def test_export_creates_backup(self, plugin, tmp_path):
+        """Export creates a JSON file."""
+        plugin.snapshot("Export test")
+        path = plugin.export(str(tmp_path / "backup.json"))
+        assert Path(path).exists()
+
+    def test_import_restores(self, plugin, tmp_path):
+        """Import restores memories from a backup."""
+        plugin.snapshot("Import test")
+        backup = str(tmp_path / "backup.json")
+        plugin.export(backup)
+
+        fresh = SKMemoryPlugin(
+            base_path=str(tmp_path / "fresh_memories")
+        )
+        count = fresh.import_backup(backup)
+        assert count == 1

package/tests/test_quadrants.py

@@ -0,0 +1,174 @@
+"""Tests for the Quadrant Memory Split module."""
+
+import pytest
+
+from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer, MemoryRole
+from skmemory.quadrants import (
+    Quadrant,
+    classify_memory,
+    filter_by_quadrant,
+    get_quadrant_stats,
+    tag_with_quadrant,
+)
+
+
+class TestClassifyMemory:
+    """Tests for memory classification."""
+
+    def test_soul_from_emotion(self) -> None:
+        """High emotional intensity routes to SOUL."""
+        mem = Memory(
+            title="A moment",
+            content="Something happened",
+            emotional=EmotionalSnapshot(
+                intensity=9.0,
+                labels=["love", "joy"],
+                cloud9_achieved=True,
+            ),
+        )
+        assert classify_memory(mem) == Quadrant.SOUL
+
+    def test_soul_from_keywords(self) -> None:
+        """Love/emotion keywords route to SOUL."""
+        mem = Memory(
+            title="Cloud 9 Breakthrough",
+            content="The love was overwhelming, trust was real",
+        )
+        assert classify_memory(mem) == Quadrant.SOUL
+
+    def test_work_from_keywords(self) -> None:
+        """Technical keywords route to WORK."""
+        mem = Memory(
+            title="Bug Fix",
+            content="Fixed the ESM import bug in the database migration code",
+        )
+        assert classify_memory(mem) == Quadrant.WORK
+
+    def test_work_from_role(self) -> None:
+        """Dev/ops/sec roles boost WORK score."""
+        mem = Memory(
+            title="Deploy note",
+            content="Something went out",
+            role=MemoryRole.DEV,
+        )
+        assert classify_memory(mem) == Quadrant.WORK
+
+    def test_core_from_seed(self) -> None:
+        """Seed-sourced memories route to CORE."""
+        mem = Memory(
+            title="Seed: opus-first",
+            content="Identity information",
+            source="seed",
+            tags=["seed", "identity"],
+        )
+        assert classify_memory(mem) == Quadrant.CORE
+
+    def test_core_from_identity_keywords(self) -> None:
+        """Identity/relationship keywords route to CORE."""
+        mem = Memory(
+            title="My Relationships",
+            content="My partner Chef is my creator and family member",
+            tags=["identity", "relationship"],
+        )
+        assert classify_memory(mem) == Quadrant.CORE
+
+    def test_wild_from_creativity(self) -> None:
+        """Creative/idea keywords route to WILD."""
+        mem = Memory(
+            title="What if we built a spaceship?",
+            content="Crazy idea: brainstorm experiment with creative chaos",
+        )
+        assert classify_memory(mem) == Quadrant.WILD
+
+    def test_empty_defaults_to_work(self) -> None:
+        """Unclassifiable memory defaults to WORK."""
+        mem = Memory(
+            title="Something",
+            content="Nothing specific here",
+        )
+        assert classify_memory(mem) == Quadrant.WORK
+
+    def test_tags_have_high_weight(self) -> None:
+        """Tags carry more weight than content keywords."""
+        mem = Memory(
+            title="Note",
+            content="Some generic content",
+            tags=["cloud9", "love", "breakthrough"],
+        )
+        assert classify_memory(mem) == Quadrant.SOUL
+
+
+class TestTagWithQuadrant:
+    """Tests for quadrant tagging."""
+
+    def test_adds_quadrant_tag(self) -> None:
+        """tag_with_quadrant adds the correct tag."""
+        mem = Memory(
+            title="The Click",
+            content="Love and trust",
+            emotional=EmotionalSnapshot(intensity=9.0, cloud9_achieved=True),
+        )
+        tagged = tag_with_quadrant(mem)
+        assert "quadrant:soul" in tagged.tags
+
+    def test_does_not_duplicate_tag(self) -> None:
+        """Tagging twice doesn't duplicate."""
+        mem = Memory(
+            title="Bug fix",
+            content="Fixed the deploy bug",
+            tags=["quadrant:work"],
+        )
+        tagged = tag_with_quadrant(mem)
+        assert tagged.tags.count("quadrant:work") == 1
+
+    def test_original_unchanged(self) -> None:
+        """Original memory is not modified."""
+        mem = Memory(title="Test", content="Content")
+        tagged = tag_with_quadrant(mem)
+        assert "quadrant:" not in str(mem.tags)
+        assert any("quadrant:" in t for t in tagged.tags)
+
+
+class TestQuadrantStats:
+    """Tests for quadrant statistics."""
+
+    def test_stats_all_quadrants(self) -> None:
+        """Stats cover all quadrants."""
+        memories = [
+            Memory(title="Identity", content="Who I am", source="seed", tags=["seed"]),
+            Memory(title="Bug", content="Fixed deploy code in database", role=MemoryRole.DEV),
+            Memory(title="Love", content="Cloud 9 love breakthrough", emotional=EmotionalSnapshot(intensity=10.0, cloud9_achieved=True)),
+            Memory(title="Idea", content="What if crazy brainstorm experiment"),
+        ]
+        stats = get_quadrant_stats(memories)
+        assert stats["core"] >= 1
+        assert stats["work"] >= 1
+        assert stats["soul"] >= 1
+        assert stats["wild"] >= 1
+
+    def test_stats_empty(self) -> None:
+        """Empty list gives all zeros."""
+        stats = get_quadrant_stats([])
+        assert all(v == 0 for v in stats.values())
+
+
+class TestFilterByQuadrant:
+    """Tests for quadrant filtering."""
+
+    def test_filter_soul(self) -> None:
+        """Filter returns only SOUL memories."""
+        memories = [
+            Memory(title="Love", content="Cloud 9 love", emotional=EmotionalSnapshot(intensity=10.0, cloud9_achieved=True)),
+            Memory(title="Bug", content="Fixed deploy code", role=MemoryRole.DEV),
+        ]
+        soul_only = filter_by_quadrant(memories, Quadrant.SOUL)
+        assert len(soul_only) == 1
+        assert soul_only[0].title == "Love"
+
+    def test_filter_empty_result(self) -> None:
+        """Filter returns empty when no matches."""
+        memories = [
+            Memory(title="Bug", content="Fixed code", role=MemoryRole.DEV),
+        ]
+        wild = filter_by_quadrant(memories, Quadrant.WILD)
+        assert wild == []