@smilintux/skmemory 0.7.2 → 0.9.2

package/tests/test_sharing.py

@@ -4,18 +4,19 @@ from __future__ import annotations
 
 from pathlib import Path
 
-import pgpy
 import pytest
-from pgpy.constants import (
+
+pgpy = pytest.importorskip("pgpy", reason="pgpy not available or incompatible")
+from pgpy.constants import (  # noqa: E402
     HashAlgorithm,
     KeyFlags,
     PubKeyAlgorithm,
     SymmetricKeyAlgorithm,
 )
 
-from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer
-from skmemory.sharing import MemorySharer, ShareBundle, ShareFilter
-from skmemory.store import MemoryStore
+from skmemory.models import EmotionalSnapshot, MemoryLayer  # noqa: E402
+from skmemory.sharing import MemorySharer, ShareBundle, ShareFilter  # noqa: E402
+from skmemory.store import MemoryStore  # noqa: E402
 
 PASSPHRASE = "share-test-2026"
 
@@ -164,7 +165,9 @@ class TestImportBundle:
     """Tests for memory import."""
 
     def test_import_adds_provenance(
-        self, sharer: MemorySharer, receiver_store: MemoryStore,
+        self,
+        sharer: MemorySharer,
+        receiver_store: MemoryStore,
     ) -> None:
         """Imported memories have provenance tags."""
         sf = ShareFilter(tags=["project"])
@@ -180,7 +183,9 @@ class TestImportBundle:
         assert len(imported) >= 1
         assert any("shared:from:capauth:alice@skworld.io" in m.tags for m in imported)
 
-    def test_import_untrusted_skips(self, sharer: MemorySharer, receiver_store: MemoryStore) -> None:
+    def test_import_untrusted_skips(
+        self, sharer: MemorySharer, receiver_store: MemoryStore
+    ) -> None:
         """Untrusted sharer is rejected."""
         sf = ShareFilter(tags=["project"])
         bundle = sharer.export_memories(sf)
@@ -207,7 +212,9 @@ class TestEncryptDecrypt:
     """Tests for PGP encryption of share bundles."""
 
     def test_encrypt_decrypt_roundtrip(
-        self, sharer: MemorySharer, recipient_keys: tuple[str, str],
+        self,
+        sharer: MemorySharer,
+        recipient_keys: tuple[str, str],
     ) -> None:
         """Bundle encrypted for recipient can be decrypted."""
         priv, pub = recipient_keys

package/tests/test_skgraph_backend.py

@@ -22,14 +22,13 @@ Coverage areas:
 
 from __future__ import annotations
 
-from unittest.mock import MagicMock, patch, call
+from unittest.mock import MagicMock, patch
 
 import pytest
 
 from skmemory.backends.skgraph_backend import SKGraphBackend
 from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer
 
-
 # ─────────────────────────────────────────────────────────
 # Shared fixtures
 # ─────────────────────────────────────────────────────────
@@ -89,9 +88,11 @@ class TestInitialization:
     def test_lazy_init_without_falkordb(self):
         """Backend gracefully handles missing falkordb package."""
         fb = SKGraphBackend()
-        with patch.dict("sys.modules", {"falkordb": None}):
-            with patch("builtins.__import__", side_effect=ImportError("no falkordb")):
-                assert fb._ensure_initialized() is False
+        with (
+            patch.dict("sys.modules", {"falkordb": None}),
+            patch("builtins.__import__", side_effect=ImportError("no falkordb")),
+        ):
+            assert fb._ensure_initialized() is False
 
     def test_connection_failure_handled(self):
         """Backend handles connection failure gracefully."""
@@ -138,10 +139,7 @@ class TestIndexMemory:
         calls = [str(c) for c in mock_graph.query.call_args_list]
         # Explicit RELATED_TO edges: one per related_id, passed with b_id param.
         # Exclude the shared-tag auto-wire query (which uses a_id only, no b_id).
-        explicit_related = [
-            c for c in calls
-            if "RELATED_TO" in c and "b_id" in c
-        ]
+        explicit_related = [c for c in calls if "RELATED_TO" in c and "b_id" in c]
         assert len(explicit_related) == len(related_memory.related_ids)
 
     def test_index_with_parent_id(self, backend, mock_graph, related_memory):
@@ -164,10 +162,7 @@ class TestIndexMemory:
         calls = [str(c) for c in mock_graph.query.call_args_list]
         # Explicit TAGGED calls use $tag param; exclude the shared-tag sweep
         # (CREATE_SHARED_TAG_RELATED also contains "TAGGED" but uses $a_id only).
-        explicit_tagged = [
-            c for c in calls
-            if "TAGGED" in c and "'tag'" in c
-        ]
+        explicit_tagged = [c for c in calls if "TAGGED" in c and "'tag'" in c]
         assert len(explicit_tagged) == len(sample_memory.tags)
 
     def test_index_creates_from_source_edge(self, backend, mock_graph, sample_memory):
@@ -177,9 +172,7 @@ class TestIndexMemory:
         source_calls = [c for c in calls if "FROM_SOURCE" in c]
         assert len(source_calls) >= 1
 
-    def test_index_creates_preceded_by_edge_when_prior_exists(
-        self, backend, mock_graph
-    ):
+    def test_index_creates_preceded_by_edge_when_prior_exists(self, backend, mock_graph):
         """PRECEDED_BY edge is created when a prior memory from same source exists."""
         # Simulate a previous memory from same source being found
         prior_result = MagicMock()
@@ -202,9 +195,7 @@ class TestIndexMemory:
         def side_effect(query, params=None):
             call_count[0] += 1
             result = MagicMock()
-            if "FIND_PREVIOUS_FROM_SOURCE" in query or (
-                params and "exclude_id" in params
-            ):
+            if "FIND_PREVIOUS_FROM_SOURCE" in query or (params and "exclude_id" in params):
                 result.result_set = [["prior-mem-id", "2026-01-01T00:00:00"]]
             else:
                 result.result_set = []
@@ -556,13 +547,15 @@ class TestStats:
     def test_stats_returns_counts(self, backend, mock_graph):
         """stats() returns node_count, edge_count, memory_count, tag_distribution."""
         results = [
-            MagicMock(result_set=[[42]]),   # COUNT_NODES
+            MagicMock(result_set=[[42]]),  # COUNT_NODES
             MagicMock(result_set=[[100]]),  # COUNT_EDGES
-            MagicMock(result_set=[[30]]),   # COUNT_MEMORIES
-            MagicMock(result_set=[         # TAG_DISTRIBUTION
-                ("cloud9", 15),
-                ("seed", 10),
-            ]),
+            MagicMock(result_set=[[30]]),  # COUNT_MEMORIES
+            MagicMock(
+                result_set=[  # TAG_DISTRIBUTION
+                    ("cloud9", 15),
+                    ("seed", 10),
+                ]
+            ),
         ]
         mock_graph.query.side_effect = results
 
@@ -592,10 +585,10 @@ class TestStats:
     def test_stats_empty_graph(self, backend, mock_graph):
         """stats() handles an empty graph gracefully."""
         results = [
-            MagicMock(result_set=[[0]]),   # COUNT_NODES
-            MagicMock(result_set=[[0]]),   # COUNT_EDGES
-            MagicMock(result_set=[[0]]),   # COUNT_MEMORIES
-            MagicMock(result_set=[]),      # TAG_DISTRIBUTION — empty
+            MagicMock(result_set=[[0]]),  # COUNT_NODES
+            MagicMock(result_set=[[0]]),  # COUNT_EDGES
+            MagicMock(result_set=[[0]]),  # COUNT_MEMORIES
+            MagicMock(result_set=[]),  # TAG_DISTRIBUTION — empty
         ]
         mock_graph.query.side_effect = results
 

package/tests/test_skvector_backend.py

@@ -7,8 +7,7 @@ list, delete, and health check operations.
 
 from __future__ import annotations
 
-import json
-from unittest.mock import MagicMock, patch, PropertyMock
+from unittest.mock import MagicMock, patch
 
 import pytest
 
@@ -22,6 +21,7 @@ from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer
 
 try:
     import qdrant_client  # noqa: F401
+
     QDRANT_AVAILABLE = True
 except ImportError:
     QDRANT_AVAILABLE = False

package/tests/test_soul.py

@@ -6,11 +6,9 @@ import pytest
 
 from skmemory.soul import (
     SoulBlueprint,
-    Relationship,
-    CoreMemoryRef,
     create_default_soul,
-    save_soul,
     load_soul,
+    save_soul,
 )
 
 

package/tests/test_sqlite_backend.py

@@ -1,9 +1,5 @@
 """Tests for the SQLite-indexed storage backend."""
 
-import json
-import tempfile
-from pathlib import Path
-
 import pytest
 
 from skmemory.backends.sqlite_backend import SQLiteBackend
@@ -151,9 +147,7 @@ class TestListSummaries:
     def test_summaries_order_by_intensity(self, backend):
         """Can order by emotional intensity."""
         self._store_memories(backend, 5)
-        summaries = backend.list_summaries(
-            order_by="emotional_intensity", limit=3
-        )
+        summaries = backend.list_summaries(order_by="emotional_intensity", limit=3)
         intensities = [s["emotional_intensity"] for s in summaries]
         assert intensities == sorted(intensities, reverse=True)
 
@@ -180,24 +174,23 @@ class TestSearch:
 
     def test_search_finds_by_title(self, backend):
         """Search matches on title."""
-        m = Memory(title="Penguin Kingdom moment", content="details",
-                    layer=MemoryLayer.SHORT)
+        m = Memory(title="Penguin Kingdom moment", content="details", layer=MemoryLayer.SHORT)
         backend.save(m)
         results = backend.search_text("Penguin")
         assert len(results) == 1
 
     def test_search_finds_by_tags(self, backend):
         """Search matches on tags."""
-        m = Memory(title="Tagged", content="details",
-                    layer=MemoryLayer.SHORT, tags=["cloud9", "love"])
+        m = Memory(
+            title="Tagged", content="details", layer=MemoryLayer.SHORT, tags=["cloud9", "love"]
+        )
         backend.save(m)
         results = backend.search_text("cloud9")
         assert len(results) == 1
 
     def test_search_no_results(self, backend):
         """Search returns empty for no matches."""
-        m = Memory(title="Something", content="nothing special",
-                    layer=MemoryLayer.SHORT)
+        m = Memory(title="Something", content="nothing special", layer=MemoryLayer.SHORT)
         backend.save(m)
         results = backend.search_text("zzzznonexistent")
         assert len(results) == 0
@@ -209,8 +202,7 @@ class TestRelatedMemories:
     def test_get_related_follows_links(self, backend):
         """Related memories are found via related_ids."""
         m1 = Memory(title="Root", content="root", layer=MemoryLayer.SHORT)
-        m2 = Memory(title="Child", content="child", layer=MemoryLayer.SHORT,
-                     related_ids=[m1.id])
+        m2 = Memory(title="Child", content="child", layer=MemoryLayer.SHORT, related_ids=[m1.id])
         backend.save(m1)
         backend.save(m2)
 
@@ -220,8 +212,7 @@ class TestRelatedMemories:
     def test_get_related_follows_parent(self, backend):
         """Related memories are found via parent_id."""
         m1 = Memory(title="Parent", content="parent", layer=MemoryLayer.LONG)
-        m2 = Memory(title="Child", content="child", layer=MemoryLayer.SHORT,
-                     parent_id=m1.id)
+        m2 = Memory(title="Child", content="child", layer=MemoryLayer.SHORT, parent_id=m1.id)
         backend.save(m1)
         backend.save(m2)
 

package/tests/test_steelman.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import json
-import os
 import tempfile
 from pathlib import Path
 
@@ -48,9 +47,9 @@ class TestSteelManResult:
 
     def test_coherence_bounds(self) -> None:
         """Coherence must be between 0 and 1."""
-        with pytest.raises(Exception):
+        with pytest.raises(Exception):  # noqa: B017
             SteelManResult(proposition="x", coherence_score=1.5)
-        with pytest.raises(Exception):
+        with pytest.raises(Exception):  # noqa: B017
             SteelManResult(proposition="x", coherence_score=-0.1)
 
     def test_summary_format(self) -> None:

package/tests/test_store.py

@@ -1,6 +1,5 @@
 """Tests for the MemoryStore (main interface)."""
 
-import tempfile
 from pathlib import Path
 
 import pytest
@@ -8,7 +7,6 @@ import pytest
 from skmemory.backends.file_backend import FileBackend
 from skmemory.models import (
     EmotionalSnapshot,
-    Memory,
     MemoryLayer,
     MemoryRole,
     SeedMemory,

package/tests/test_store_graph_integration.py

@@ -8,12 +8,12 @@ the system degrades gracefully when SKGraph is unavailable.
 from __future__ import annotations
 
 from pathlib import Path
-from unittest.mock import MagicMock, patch
+from unittest.mock import MagicMock
 
 import pytest
 
-from skmemory.backends.skgraph_backend import SKGraphBackend
 from skmemory.backends.file_backend import FileBackend
+from skmemory.backends.skgraph_backend import SKGraphBackend
 from skmemory.models import (
     EmotionalSnapshot,
     Memory,

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