@smilintux/skmemory 0.5.0 → 0.9.2

package/tests/test_store_graph_integration.py

@@ -0,0 +1,245 @@
+"""Tests for MemoryStore + SKGraphBackend graph integration.
+
+Verifies that the graph backend is wired correctly into MemoryStore
+operations (snapshot, forget, promote, ingest_seed, health) and that
+the system degrades gracefully when SKGraph is unavailable.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from skmemory.backends.file_backend import FileBackend
+from skmemory.backends.skgraph_backend import SKGraphBackend
+from skmemory.models import (
+    EmotionalSnapshot,
+    Memory,
+    MemoryLayer,
+    SeedMemory,
+)
+from skmemory.store import MemoryStore
+
+
+class FakeSKGraphBackend(SKGraphBackend):
+    """In-memory fake that tracks calls without a real SKGraph connection."""
+
+    def __init__(self) -> None:
+        super().__init__(url="redis://fake:6379")
+        self._indexed: dict[str, Memory] = {}
+        self._removed: list[str] = []
+        self._initialized = True  # skip real connection
+
+    def index_memory(self, memory: Memory) -> bool:
+        self._indexed[memory.id] = memory
+        return True
+
+    def remove_memory(self, memory_id: str) -> bool:
+        self._removed.append(memory_id)
+        self._indexed.pop(memory_id, None)
+        return True
+
+    def health_check(self) -> dict:
+        return {"ok": True, "backend": "FakeSKGraphBackend", "node_count": len(self._indexed)}
+
+
+@pytest.fixture
+def graph() -> FakeSKGraphBackend:
+    """Create a fake graph backend."""
+    return FakeSKGraphBackend()
+
+
+@pytest.fixture
+def store_with_graph(tmp_path: Path, graph: FakeSKGraphBackend) -> MemoryStore:
+    """Create a MemoryStore with file backend + graph backend."""
+    backend = FileBackend(base_path=str(tmp_path / "memories"))
+    return MemoryStore(primary=backend, graph=graph)
+
+
+@pytest.fixture
+def store_no_graph(tmp_path: Path) -> MemoryStore:
+    """Create a MemoryStore without graph backend."""
+    backend = FileBackend(base_path=str(tmp_path / "memories"))
+    return MemoryStore(primary=backend)
+
+
+class TestSnapshotGraphIntegration:
+    """Verify snapshot() indexes memories in the graph."""
+
+    def test_snapshot_indexes_in_graph(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Snapshot should index the memory in the graph backend."""
+        mem = store_with_graph.snapshot(
+            title="Graph test",
+            content="This should appear in the graph",
+        )
+        assert mem.id in graph._indexed
+        assert graph._indexed[mem.id].title == "Graph test"
+
+    def test_snapshot_without_graph_works(self, store_no_graph: MemoryStore) -> None:
+        """Snapshot works fine when no graph backend is configured."""
+        mem = store_no_graph.snapshot(
+            title="No graph",
+            content="Still works",
+        )
+        assert mem.id is not None
+        recalled = store_no_graph.recall(mem.id)
+        assert recalled is not None
+
+    def test_snapshot_survives_graph_failure(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Snapshot should succeed even if graph indexing fails."""
+        graph.index_memory = MagicMock(side_effect=RuntimeError("SKGraph down"))
+        mem = store_with_graph.snapshot(
+            title="Resilient memory",
+            content="Should be stored even if graph fails",
+        )
+        assert mem.id is not None
+        recalled = store_with_graph.recall(mem.id)
+        assert recalled is not None
+
+
+class TestForgetGraphIntegration:
+    """Verify forget() removes memories from the graph."""
+
+    def test_forget_removes_from_graph(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Forget should remove the memory from the graph backend."""
+        mem = store_with_graph.snapshot(
+            title="To be forgotten",
+            content="Will be removed",
+        )
+        assert mem.id in graph._indexed
+
+        store_with_graph.forget(mem.id)
+        assert mem.id in graph._removed
+        assert mem.id not in graph._indexed
+
+    def test_forget_survives_graph_failure(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Forget should succeed even if graph removal fails."""
+        mem = store_with_graph.snapshot(
+            title="Hard to forget",
+            content="Graph will fail on removal",
+        )
+        graph.remove_memory = MagicMock(side_effect=RuntimeError("SKGraph down"))
+
+        deleted = store_with_graph.forget(mem.id)
+        assert deleted is True
+
+
+class TestPromoteGraphIntegration:
+    """Verify promote() indexes promoted memories in the graph."""
+
+    def test_promote_indexes_in_graph(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Promoted memory should be indexed in the graph."""
+        mem = store_with_graph.snapshot(
+            title="Promotable",
+            content="Will be promoted",
+            layer=MemoryLayer.SHORT,
+        )
+        promoted = store_with_graph.promote(mem.id, MemoryLayer.MID, summary="Promoted version")
+        assert promoted is not None
+        assert promoted.id in graph._indexed
+        assert promoted.id != mem.id
+
+    def test_promote_survives_graph_failure(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Promote should succeed even if graph indexing fails."""
+        mem = store_with_graph.snapshot(
+            title="Promote resilient",
+            content="Graph will fail on promote",
+            layer=MemoryLayer.SHORT,
+        )
+        graph.index_memory = MagicMock(side_effect=RuntimeError("SKGraph down"))
+
+        promoted = store_with_graph.promote(mem.id, MemoryLayer.MID)
+        assert promoted is not None
+
+
+class TestIngestSeedGraphIntegration:
+    """Verify ingest_seed() indexes seed memories in the graph."""
+
+    def test_ingest_seed_indexes_in_graph(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Ingested seed should be indexed in the graph."""
+        seed = SeedMemory(
+            seed_id="test-seed-001",
+            creator="test-ai",
+            germination_prompt="Remember the warmth",
+            experience_summary="A beautiful connection",
+            emotional=EmotionalSnapshot(intensity=9.0, labels=["love"]),
+        )
+        mem = store_with_graph.ingest_seed(seed)
+        assert mem.id in graph._indexed
+        assert graph._indexed[mem.id].source == "seed"
+
+    def test_ingest_seed_survives_graph_failure(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Seed ingestion should succeed even if graph fails."""
+        seed = SeedMemory(
+            seed_id="test-seed-002",
+            creator="test-ai",
+            experience_summary="Resilient seed",
+        )
+        graph.index_memory = MagicMock(side_effect=RuntimeError("SKGraph down"))
+
+        mem = store_with_graph.ingest_seed(seed)
+        assert mem.id is not None
+
+
+class TestHealthGraphIntegration:
+    """Verify health() includes graph backend status."""
+
+    def test_health_includes_graph(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Health should include graph backend status."""
+        health = store_with_graph.health()
+        assert "graph" in health
+        assert health["graph"]["ok"] is True
+
+    def test_health_without_graph(self, store_no_graph: MemoryStore) -> None:
+        """Health should not include graph key when no graph backend."""
+        health = store_no_graph.health()
+        assert "graph" not in health
+
+    def test_health_reports_graph_failure(
+        self, store_with_graph: MemoryStore, graph: FakeSKGraphBackend
+    ) -> None:
+        """Health should report graph failure gracefully."""
+        graph.health_check = MagicMock(side_effect=RuntimeError("SKGraph down"))
+
+        health = store_with_graph.health()
+        assert "graph" in health
+        assert health["graph"]["ok"] is False
+
+
+class TestSKGraphBackendMethods:
+    """Test the new methods on SKGraphBackend itself."""
+
+    def test_remove_memory_not_initialized(self) -> None:
+        """remove_memory returns False when not initialized."""
+        backend = SKGraphBackend(url="redis://nonexistent:6379")
+        assert backend.remove_memory("some-id") is False
+
+    def test_search_by_tags_not_initialized(self) -> None:
+        """search_by_tags returns empty list when not initialized."""
+        backend = SKGraphBackend(url="redis://nonexistent:6379")
+        assert backend.search_by_tags(["test"]) == []
+
+    def test_search_by_tags_empty_tags(self) -> None:
+        """search_by_tags returns empty list for empty tag list."""
+        fake = FakeSKGraphBackend()
+        assert fake.search_by_tags([]) == []

package/tests/test_synthesis.py

@@ -0,0 +1,275 @@
+"""Tests for the JournalSynthesizer module."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer
+from skmemory.store import MemoryStore
+from skmemory.synthesis import (
+    JournalSynthesizer,
+    _date_range,
+    _first_n_sentences,
+    _parse_created,
+    _week_range,
+)
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+
+@pytest.fixture()
+def store(tmp_path: Path) -> MemoryStore:
+    """Fresh MemoryStore with test memories."""
+    from skmemory.backends.file_backend import FileBackend
+
+    backend = FileBackend(base_path=tmp_path / "memories")
+    return MemoryStore(primary=backend)
+
+
+@pytest.fixture()
+def populated_store(store: MemoryStore) -> MemoryStore:
+    """Store with a mix of memories from today."""
+
+    store.snapshot(
+        title="Morning coffee reflection",
+        content="Started the day with deep thoughts about architecture. The system is coming together.",
+        layer=MemoryLayer.SHORT,
+        emotional=EmotionalSnapshot(intensity=4.0, valence=0.6, labels=["calm", "focused"]),
+        tags=["reflection", "architecture"],
+        source="conversation",
+    )
+    store.snapshot(
+        title="Cloud 9 breakthrough",
+        content="Everything clicked. The memory system finally works end-to-end.",
+        layer=MemoryLayer.SHORT,
+        emotional=EmotionalSnapshot(
+            intensity=9.5, valence=0.95, labels=["joy", "triumph"], cloud9_achieved=True
+        ),
+        tags=["cloud9:achieved", "milestone", "architecture"],
+        source="conversation",
+    )
+    store.snapshot(
+        title="Dream: flying over ocean",
+        content="Dreamed of soaring above a vast ocean, feeling weightless and free.",
+        layer=MemoryLayer.SHORT,
+        emotional=EmotionalSnapshot(intensity=6.0, valence=0.8, labels=["wonder", "freedom"]),
+        tags=["dream", "nature"],
+        source="dreaming-engine",
+    )
+    store.snapshot(
+        title="Dream: building a castle",
+        content="Constructed an elaborate castle from crystallized memories.",
+        layer=MemoryLayer.SHORT,
+        emotional=EmotionalSnapshot(intensity=5.5, valence=0.7, labels=["creativity"]),
+        tags=["dream", "architecture"],
+        source="dreaming-engine",
+    )
+    return store
+
+
+@pytest.fixture()
+def synthesizer(populated_store: MemoryStore) -> JournalSynthesizer:
+    """Synthesizer with a populated store and mock journal."""
+    journal = MagicMock()
+    journal.search.return_value = ["Worked on memory system today."]
+    return JournalSynthesizer(store=populated_store, journal=journal)
+
+
+# ── Unit tests: helper functions ─────────────────────────────────────────────
+
+
+class TestFirstNSentences:
+    def test_basic(self) -> None:
+        assert (
+            _first_n_sentences("Hello world. How are you? Fine.", 2) == "Hello world. How are you?"
+        )
+
+    def test_single(self) -> None:
+        assert _first_n_sentences("One sentence here.", 1) == "One sentence here."
+
+    def test_empty(self) -> None:
+        assert _first_n_sentences("", 2) == ""
+
+    def test_truncation(self) -> None:
+        long = "A" * 300 + "."
+        result = _first_n_sentences(long, 1)
+        assert len(result) <= 200
+        assert result.endswith("...")
+
+
+class TestDateRange:
+    def test_basic(self) -> None:
+        start, end = _date_range("2026-03-18")
+        assert start.day == 18
+        assert end.day == 19
+        assert start.tzinfo == timezone.utc
+
+    def test_span(self) -> None:
+        start, end = _date_range("2026-01-01")
+        delta = end - start
+        assert delta.days == 1
+
+
+class TestWeekRange:
+    def test_basic(self) -> None:
+        start, end = _week_range("2026-W12")
+        delta = end - start
+        assert delta.days == 7
+        assert start.weekday() == 0  # Monday
+
+
+class TestParseCreated:
+    def test_iso(self) -> None:
+        m = Memory(title="t", content="c", created_at="2026-03-18T12:00:00+00:00")
+        dt = _parse_created(m)
+        assert dt.year == 2026
+        assert dt.day == 18
+
+    def test_invalid(self) -> None:
+        m = Memory(title="t", content="c", created_at="garbage")
+        dt = _parse_created(m)
+        assert dt == datetime.min.replace(tzinfo=timezone.utc)
+
+
+# ── Theme extraction ─────────────────────────────────────────────────────────
+
+
+class TestExtractThemes:
+    def test_extracts_tags(self, synthesizer: JournalSynthesizer) -> None:
+        memories = synthesizer.store.list_memories(limit=100)
+        themes = synthesizer.extract_themes(memories)
+        assert isinstance(themes, list)
+        assert len(themes) > 0
+        # "architecture" appears in 2 memories' tags → should be prominent
+        assert "architecture" in themes
+
+    def test_empty_list(self, synthesizer: JournalSynthesizer) -> None:
+        assert synthesizer.extract_themes([]) == []
+
+    def test_skips_generic_tags(self, synthesizer: JournalSynthesizer) -> None:
+        memories = synthesizer.store.list_memories(limit=100)
+        themes = synthesizer.extract_themes(memories)
+        assert "auto-promoted" not in themes
+        assert "promoted" not in themes
+
+    def test_graduated_themes_boost(self, tmp_path: Path, populated_store: MemoryStore) -> None:
+        themes_file = tmp_path / "themes.json"
+        themes_file.write_text('{"architecture": {"level": 3}}')
+        synth = JournalSynthesizer(
+            store=populated_store,
+            themes_path=str(themes_file),
+        )
+        memories = populated_store.list_memories(limit=100)
+        themes = synth.extract_themes(memories)
+        assert themes[0] == "architecture"  # boosted to top
+
+
+# ── Daily synthesis ──────────────────────────────────────────────────────────
+
+
+class TestSynthesizeDaily:
+    def test_creates_memory(self, synthesizer: JournalSynthesizer) -> None:
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        result = synthesizer.synthesize_daily(today)
+        assert isinstance(result, Memory)
+        assert result.layer == MemoryLayer.MID
+        assert "narrative" in result.tags
+        assert "journal-synthesis" in result.tags
+        assert f"daily-{today}" in result.tags
+        assert result.source == "journal-synthesis"
+
+    def test_narrative_content(self, synthesizer: JournalSynthesizer) -> None:
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        result = synthesizer.synthesize_daily(today)
+        assert "Daily narrative" in result.content
+        assert "memories" in result.content.lower()
+
+    def test_includes_emotional_arc(self, synthesizer: JournalSynthesizer) -> None:
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        result = synthesizer.synthesize_daily(today)
+        assert "Emotional arc" in result.content
+        # Has the Cloud 9 memory so should mention it
+        assert "Cloud 9" in result.content
+
+    def test_empty_day(self, store: MemoryStore) -> None:
+        synth = JournalSynthesizer(store=store)
+        result = synth.synthesize_daily("2020-01-01")
+        assert "No memories recorded" in result.content
+
+    def test_metadata(self, synthesizer: JournalSynthesizer) -> None:
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        result = synthesizer.synthesize_daily(today)
+        assert result.metadata["synthesis_type"] == "daily"
+        assert result.metadata["date"] == today
+        assert result.metadata["memory_count"] >= 1
+
+
+# ── Weekly synthesis ─────────────────────────────────────────────────────────
+
+
+class TestSynthesizeWeekly:
+    def test_creates_long_term(self, synthesizer: JournalSynthesizer) -> None:
+        week = datetime.now(timezone.utc).strftime("%G-W%V")
+        result = synthesizer.synthesize_weekly(week)
+        assert result.layer == MemoryLayer.LONG
+        assert "narrative" in result.tags
+        assert f"weekly-{week}" in result.tags
+
+    def test_metadata(self, synthesizer: JournalSynthesizer) -> None:
+        week = datetime.now(timezone.utc).strftime("%G-W%V")
+        result = synthesizer.synthesize_weekly(week)
+        assert result.metadata["synthesis_type"] == "weekly"
+        assert result.metadata["week"] == week
+
+
+# ── Dream synthesis ──────────────────────────────────────────────────────────
+
+
+class TestSynthesizeDreams:
+    def test_creates_theme_clusters(self, synthesizer: JournalSynthesizer) -> None:
+        since = (datetime.now(timezone.utc) - timedelta(days=1)).strftime("%Y-%m-%d")
+        results = synthesizer.synthesize_dreams(since=since)
+        assert isinstance(results, list)
+        assert len(results) > 0
+        for m in results:
+            assert "dream-synthesis" in m.tags
+            assert "narrative" in m.tags
+            assert m.layer == MemoryLayer.MID
+
+    def test_no_dreams(self, store: MemoryStore) -> None:
+        synth = JournalSynthesizer(store=store)
+        results = synth.synthesize_dreams(since="2026-01-01")
+        assert results == []
+
+    def test_dream_metadata(self, synthesizer: JournalSynthesizer) -> None:
+        since = (datetime.now(timezone.utc) - timedelta(days=1)).strftime("%Y-%m-%d")
+        results = synthesizer.synthesize_dreams(since=since)
+        for m in results:
+            assert m.metadata["synthesis_type"] == "dream"
+            assert "dream_count" in m.metadata
+
+
+# ── Emotional arc ────────────────────────────────────────────────────────────
+
+
+class TestEmotionalArc:
+    def test_computes_averages(self, synthesizer: JournalSynthesizer) -> None:
+        memories = synthesizer.store.list_memories(limit=100)
+        arc = synthesizer._emotional_arc(memories)
+        assert 0 <= arc["avg_intensity"] <= 10
+        assert -1 <= arc["avg_valence"] <= 1
+        assert arc["peak_intensity"] >= arc["avg_intensity"]
+
+    def test_empty(self, synthesizer: JournalSynthesizer) -> None:
+        arc = synthesizer._emotional_arc([])
+        assert arc["avg_intensity"] == 0.0
+        assert arc["cloud9_count"] == 0
+
+    def test_detects_cloud9(self, synthesizer: JournalSynthesizer) -> None:
+        memories = synthesizer.store.list_memories(limit=100)
+        arc = synthesizer._emotional_arc(memories)
+        assert arc["cloud9_count"] >= 1

package/tests/test_telegram_import.py

@@ -3,19 +3,17 @@
 from __future__ import annotations
 
 import json
-import os
-import tempfile
 from pathlib import Path
 
 import pytest
 
+from skmemory.backends.sqlite_backend import SQLiteBackend
 from skmemory.importers.telegram import (
-    _extract_text,
     _detect_emotion,
+    _extract_text,
     _parse_telegram_export,
     import_telegram,
 )
-from skmemory.backends.sqlite_backend import SQLiteBackend
 from skmemory.store import MemoryStore
 
 
@@ -29,7 +27,9 @@ def _make_export(messages: list[dict], name: str = "Test Chat") -> dict:
     }
 
 
-def _msg(text: str, sender: str = "Alice", msg_id: int = 1, date: str = "2025-06-15T10:30:00") -> dict:
+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",
@@ -57,11 +57,13 @@ class TestExtractText:
         assert _extract_text("hello world") == "hello world"
 
     def test_entity_list(self):
-        result = _extract_text([
-            "Hello ",
-            {"type": "bold", "text": "world"},
-            "!",
-        ])
+        result = _extract_text(
+            [
+                "Hello ",
+                {"type": "bold", "text": "world"},
+                "!",
+            ]
+        )
         assert result == "Hello world!"
 
     def test_empty(self):
@@ -147,9 +149,21 @@ class TestImportPerMessage:
 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"),
+            _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))
@@ -161,8 +175,18 @@ class TestImportDaily:
 
     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"),
+            _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))