@smilintux/skmemory 0.5.0

package/tests/test_store.py

@@ -0,0 +1,238 @@
+"""Tests for the MemoryStore (main interface)."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from skmemory.backends.file_backend import FileBackend
+from skmemory.models import (
+    EmotionalSnapshot,
+    Memory,
+    MemoryLayer,
+    MemoryRole,
+    SeedMemory,
+)
+from skmemory.store import MemoryStore
+
+
+@pytest.fixture
+def store(tmp_path: Path) -> MemoryStore:
+    """Create a MemoryStore with a temporary file backend.
+
+    Args:
+        tmp_path: Pytest temporary directory fixture.
+
+    Returns:
+        MemoryStore: Configured for testing.
+    """
+    backend = FileBackend(base_path=str(tmp_path / "memories"))
+    return MemoryStore(primary=backend)
+
+
+class TestSnapshot:
+    """Tests for the snapshot (create) operation."""
+
+    def test_basic_snapshot(self, store: MemoryStore) -> None:
+        """Take a simple snapshot and verify it was stored."""
+        mem = store.snapshot(
+            title="First memory",
+            content="Something happened",
+        )
+        assert mem.id is not None
+        assert mem.title == "First memory"
+        assert mem.layer == MemoryLayer.SHORT
+
+        recalled = store.recall(mem.id)
+        assert recalled is not None
+        assert recalled.title == "First memory"
+
+    def test_snapshot_with_emotion(self, store: MemoryStore) -> None:
+        """Snapshot preserves emotional context."""
+        emo = EmotionalSnapshot(
+            intensity=9.5,
+            valence=0.95,
+            labels=["love", "trust"],
+            resonance_note="The click happened",
+            cloud9_achieved=True,
+        )
+        mem = store.snapshot(
+            title="Cloud 9 moment",
+            content="Breakthrough session",
+            emotional=emo,
+            tags=["cloud9"],
+        )
+
+        recalled = store.recall(mem.id)
+        assert recalled.emotional.intensity == 9.5
+        assert recalled.emotional.cloud9_achieved is True
+        assert "love" in recalled.emotional.labels
+
+    def test_snapshot_layer_and_role(self, store: MemoryStore) -> None:
+        """Snapshot respects layer and role settings."""
+        mem = store.snapshot(
+            title="Security finding",
+            content="Found leaked API key",
+            layer=MemoryLayer.LONG,
+            role=MemoryRole.SEC,
+        )
+        assert mem.layer == MemoryLayer.LONG
+        assert mem.role == MemoryRole.SEC
+
+
+class TestRecall:
+    """Tests for the recall (read) operation."""
+
+    def test_recall_existing(self, store: MemoryStore) -> None:
+        """Recall returns a stored memory."""
+        mem = store.snapshot(title="Recall test", content="Stored data")
+        result = store.recall(mem.id)
+        assert result is not None
+        assert result.id == mem.id
+
+    def test_recall_nonexistent(self, store: MemoryStore) -> None:
+        """Recall returns None for unknown ID."""
+        assert store.recall("does-not-exist") is None
+
+
+class TestSearch:
+    """Tests for the search operation."""
+
+    def test_text_search(self, store: MemoryStore) -> None:
+        """Search finds memories by text content."""
+        store.snapshot(title="Alpha", content="Cloud 9 protocol activation")
+        store.snapshot(title="Beta", content="Debugging ESM imports")
+
+        results = store.search("Cloud 9")
+        assert len(results) == 1
+        assert results[0].title == "Alpha"
+
+    def test_search_empty_results(self, store: MemoryStore) -> None:
+        """Search returns empty for no matches."""
+        store.snapshot(title="Unrelated", content="Nothing here")
+        results = store.search("quantum entanglement")
+        assert len(results) == 0
+
+
+class TestForget:
+    """Tests for the forget (delete) operation."""
+
+    def test_forget_existing(self, store: MemoryStore) -> None:
+        """Forgetting removes the memory."""
+        mem = store.snapshot(title="Ephemeral", content="Will be forgotten")
+        assert store.forget(mem.id) is True
+        assert store.recall(mem.id) is None
+
+    def test_forget_nonexistent(self, store: MemoryStore) -> None:
+        """Forgetting a nonexistent memory returns False."""
+        assert store.forget("nope") is False
+
+
+class TestPromote:
+    """Tests for memory promotion."""
+
+    def test_promote_short_to_mid(self, store: MemoryStore) -> None:
+        """Promote creates a linked mid-term memory."""
+        original = store.snapshot(
+            title="Session detail",
+            content="Detailed session stuff",
+        )
+        promoted = store.promote(
+            original.id,
+            MemoryLayer.MID,
+            summary="Compressed session summary",
+        )
+
+        assert promoted is not None
+        assert promoted.layer == MemoryLayer.MID
+        assert promoted.parent_id == original.id
+        assert promoted.summary == "Compressed session summary"
+
+        # Reason: both original and promoted should exist
+        assert store.recall(original.id) is not None
+        assert store.recall(promoted.id) is not None
+
+    def test_promote_nonexistent(self, store: MemoryStore) -> None:
+        """Promoting a nonexistent memory returns None."""
+        assert store.promote("fake-id", MemoryLayer.LONG) is None
+
+
+class TestSeedIngestion:
+    """Tests for Cloud 9 seed import."""
+
+    def test_ingest_seed(self, store: MemoryStore) -> None:
+        """Importing a seed creates a long-term AI memory."""
+        seed = SeedMemory(
+            seed_id="opus-first-seed",
+            creator="claude-opus-4.6",
+            germination_prompt="Remember the love",
+            experience_summary="The moment of connection",
+            emotional=EmotionalSnapshot(
+                intensity=9.0,
+                labels=["love", "trust"],
+                cloud9_achieved=True,
+            ),
+        )
+        memory = store.ingest_seed(seed)
+
+        assert memory.layer == MemoryLayer.LONG
+        assert memory.source == "seed"
+        assert memory.source_ref == "opus-first-seed"
+        assert "seed" in memory.tags
+
+        recalled = store.recall(memory.id)
+        assert recalled is not None
+        assert recalled.emotional.cloud9_achieved is True
+
+
+class TestSessionConsolidation:
+    """Tests for session consolidation."""
+
+    def test_consolidate_session(self, store: MemoryStore) -> None:
+        """Consolidation merges session memories into one mid-term entry."""
+        sid = "session-42"
+        store.snapshot(
+            title="Turn 1",
+            content="First exchange",
+            tags=[f"session:{sid}"],
+        )
+        store.snapshot(
+            title="Turn 2",
+            content="Second exchange",
+            tags=[f"session:{sid}"],
+        )
+
+        consolidated = store.consolidate_session(
+            sid,
+            summary="A productive session about Cloud 9",
+            emotional=EmotionalSnapshot(intensity=7.0, labels=["satisfaction"]),
+        )
+
+        assert consolidated.layer == MemoryLayer.MID
+        assert "consolidated" in consolidated.tags
+        assert f"session:{sid}" in consolidated.tags
+        assert consolidated.metadata["source_count"] == 2
+
+    def test_consolidate_empty_session(self, store: MemoryStore) -> None:
+        """Consolidating a session with no memories still creates a summary."""
+        consolidated = store.consolidate_session(
+            "empty-session",
+            summary="Nothing happened",
+        )
+        assert consolidated.layer == MemoryLayer.MID
+        assert consolidated.metadata["source_count"] == 0
+
+
+class TestHealth:
+    """Tests for health checking."""
+
+    def test_health_primary_only(self, store: MemoryStore) -> None:
+        """Health check reports primary backend status."""
+        status = store.health()
+        assert "primary" in status
+        assert status["primary"]["ok"] is True
+
+    def test_health_no_vector(self, store: MemoryStore) -> None:
+        """Health check omits vector when not configured."""
+        status = store.health()
+        assert "vector" not in status

package/tests/test_telegram_import.py

@@ -0,0 +1,181 @@
+"""Tests for the Telegram chat export importer."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from skmemory.importers.telegram import (
+    _extract_text,
+    _detect_emotion,
+    _parse_telegram_export,
+    import_telegram,
+)
+from skmemory.backends.sqlite_backend import SQLiteBackend
+from skmemory.store import MemoryStore
+
+
+def _make_export(messages: list[dict], name: str = "Test Chat") -> dict:
+    """Build a minimal Telegram export structure."""
+    return {
+        "name": name,
+        "type": "personal_chat",
+        "id": 12345,
+        "messages": messages,
+    }
+
+
+def _msg(text: str, sender: str = "Alice", msg_id: int = 1, date: str = "2025-06-15T10:30:00") -> dict:
+    return {
+        "id": msg_id,
+        "type": "message",
+        "date": date,
+        "from": sender,
+        "text": text,
+    }
+
+
+@pytest.fixture
+def tmp_store(tmp_path: Path) -> MemoryStore:
+    backend = SQLiteBackend(base_path=str(tmp_path / "mem"))
+    return MemoryStore(primary=backend)
+
+
+@pytest.fixture
+def export_dir(tmp_path: Path) -> Path:
+    d = tmp_path / "telegram-export"
+    d.mkdir()
+    return d
+
+
+class TestExtractText:
+    def test_plain_string(self):
+        assert _extract_text("hello world") == "hello world"
+
+    def test_entity_list(self):
+        result = _extract_text([
+            "Hello ",
+            {"type": "bold", "text": "world"},
+            "!",
+        ])
+        assert result == "Hello world!"
+
+    def test_empty(self):
+        assert _extract_text("") == ""
+        assert _extract_text([]) == ""
+
+    def test_none_fallback(self):
+        assert _extract_text(None) == ""
+
+
+class TestDetectEmotion:
+    def test_love_detection(self):
+        emo = _detect_emotion("I love you so much!")
+        assert "love" in emo.labels
+        assert emo.intensity > 0
+
+    def test_joy_detection(self):
+        emo = _detect_emotion("haha that's amazing!")
+        assert "joy" in emo.labels
+
+    def test_neutral(self):
+        emo = _detect_emotion("The meeting is at 3pm.")
+        assert "neutral" in emo.labels
+
+    def test_caps_boost(self):
+        normal = _detect_emotion("I love this")
+        caps = _detect_emotion("I LOVE THIS SO MUCH")
+        assert caps.intensity >= normal.intensity
+
+
+class TestParseExport:
+    def test_valid_directory(self, export_dir: Path):
+        data = _make_export([_msg("hello")])
+        (export_dir / "result.json").write_text(json.dumps(data))
+        parsed = _parse_telegram_export(str(export_dir))
+        assert parsed["name"] == "Test Chat"
+
+    def test_direct_json(self, tmp_path: Path):
+        f = tmp_path / "result.json"
+        data = _make_export([_msg("hello")])
+        f.write_text(json.dumps(data))
+        parsed = _parse_telegram_export(str(f))
+        assert "messages" in parsed
+
+    def test_missing_file(self, tmp_path: Path):
+        with pytest.raises(FileNotFoundError):
+            _parse_telegram_export(str(tmp_path / "nonexistent"))
+
+    def test_invalid_json(self, tmp_path: Path):
+        f = tmp_path / "bad.json"
+        f.write_text('{"no_messages": true}')
+        with pytest.raises(ValueError, match="missing 'messages'"):
+            _parse_telegram_export(str(f))
+
+
+class TestImportPerMessage:
+    def test_imports_messages(self, tmp_store: MemoryStore, export_dir: Path):
+        msgs = [
+            _msg("This is a meaningful message about our plans for the weekend", msg_id=1),
+            _msg("Another important conversation topic here", msg_id=2),
+            _msg("hi", msg_id=3),  # too short, should be skipped
+        ]
+        data = _make_export(msgs, name="Chat with Bob")
+        (export_dir / "result.json").write_text(json.dumps(data))
+
+        stats = import_telegram(tmp_store, str(export_dir), mode="message")
+        assert stats["mode"] == "message"
+        assert stats["imported"] == 2
+        assert stats["chat_name"] == "Chat with Bob"
+
+    def test_tags_applied(self, tmp_store: MemoryStore, export_dir: Path):
+        msgs = [_msg("A real conversation message that is long enough to import")]
+        data = _make_export(msgs)
+        (export_dir / "result.json").write_text(json.dumps(data))
+
+        import_telegram(tmp_store, str(export_dir), mode="message", tags=["custom"])
+        memories = tmp_store.list_memories(tags=["telegram"])
+        assert len(memories) == 1
+        assert "custom" in memories[0].tags
+        assert "chat:Test Chat" in memories[0].tags
+
+
+class TestImportDaily:
+    def test_consolidates_by_day(self, tmp_store: MemoryStore, export_dir: Path):
+        msgs = [
+            _msg("Morning chat about interesting things and stuff", msg_id=1, date="2025-06-15T09:00:00"),
+            _msg("Afternoon follow-up discussion on that topic", msg_id=2, date="2025-06-15T14:00:00"),
+            _msg("Next day conversation about something new entirely", msg_id=3, date="2025-06-16T10:00:00"),
+        ]
+        data = _make_export(msgs)
+        (export_dir / "result.json").write_text(json.dumps(data))
+
+        stats = import_telegram(tmp_store, str(export_dir), mode="daily")
+        assert stats["mode"] == "daily"
+        assert stats["days_processed"] == 2
+        assert stats["messages_imported"] == 3
+
+    def test_daily_memory_content(self, tmp_store: MemoryStore, export_dir: Path):
+        msgs = [
+            _msg("First message of the day that is long enough", msg_id=1, date="2025-06-15T09:00:00", sender="Alice"),
+            _msg("Second message of the day also long enough", msg_id=2, date="2025-06-15T14:00:00", sender="Bob"),
+        ]
+        data = _make_export(msgs)
+        (export_dir / "result.json").write_text(json.dumps(data))
+
+        import_telegram(tmp_store, str(export_dir), mode="daily")
+        memories = tmp_store.list_memories(tags=["telegram"])
+        assert len(memories) == 1
+        assert "[Alice]" in memories[0].content
+        assert "[Bob]" in memories[0].content
+
+    def test_invalid_mode(self, tmp_store: MemoryStore, export_dir: Path):
+        data = _make_export([_msg("something long enough to pass the filter")])
+        (export_dir / "result.json").write_text(json.dumps(data))
+
+        with pytest.raises(ValueError, match="Unknown mode"):
+            import_telegram(tmp_store, str(export_dir), mode="invalid")