@smilintux/skmemory 0.5.0

package/tests/test_cli.py

@@ -0,0 +1,65 @@
+"""Tests for the SKMemory CLI."""
+
+import pytest
+from click.testing import CliRunner
+
+from skmemory import __version__
+from skmemory.cli import cli
+
+
+@pytest.fixture
+def runner():
+    """Create a CLI test runner."""
+    return CliRunner()
+
+
+class TestCLIVersion:
+    """Version flag consistency tests."""
+
+    def test_version_flag(self, runner):
+        """--version prints version string with prog name."""
+        result = runner.invoke(cli, ["--version"])
+        assert result.exit_code == 0
+        assert "skmemory" in result.output
+        assert __version__ in result.output
+
+    def test_version_flag_format(self, runner):
+        """Version output follows 'prog_name, version X.Y.Z' pattern."""
+        result = runner.invoke(cli, ["--version"])
+        assert f"skmemory, version {__version__}" in result.output
+
+
+class TestCLIHelp:
+    """Help text tests."""
+
+    def test_help_flag(self, runner):
+        """--help shows usage information."""
+        result = runner.invoke(cli, ["--help"])
+        assert result.exit_code == 0
+        assert "SKMemory" in result.output
+
+    def test_subcommand_help(self, runner):
+        """Subcommands have help text."""
+        for cmd in ["snapshot", "recall", "search", "list", "health"]:
+            result = runner.invoke(cli, [cmd, "--help"])
+            assert result.exit_code == 0, f"{cmd} --help failed"
+
+    def test_subgroup_help(self, runner):
+        """Subgroups have help text."""
+        for group in ["soul", "journal", "anchor", "lovenote", "steelman"]:
+            result = runner.invoke(cli, [group, "--help"])
+            assert result.exit_code == 0, f"{group} --help failed"
+
+
+class TestCLIGlobalOptions:
+    """Global option tests."""
+
+    def test_qdrant_url_option_exists(self, runner):
+        """--qdrant-url option is accepted."""
+        result = runner.invoke(cli, ["--help"])
+        assert "--qdrant-url" in result.output
+
+    def test_qdrant_key_option_exists(self, runner):
+        """--qdrant-key option is accepted."""
+        result = runner.invoke(cli, ["--help"])
+        assert "--qdrant-key" in result.output

package/tests/test_export_import.py

@@ -0,0 +1,170 @@
+"""Tests for export/import (daily JSON backup) functionality."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from skmemory.backends.sqlite_backend import SQLiteBackend
+from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer
+from skmemory.store import MemoryStore
+
+
+@pytest.fixture
+def backend(tmp_path):
+    """Create a SQLiteBackend with a temporary directory."""
+    return SQLiteBackend(base_path=str(tmp_path / "memories"))
+
+
+@pytest.fixture
+def store(backend):
+    """Create a MemoryStore wrapping the temp backend."""
+    return MemoryStore(primary=backend)
+
+
+@pytest.fixture
+def populated_store(store):
+    """Store with a few memories already saved."""
+    for i in range(5):
+        store.snapshot(
+            title=f"Memory {i}",
+            content=f"Content for memory {i}",
+            layer=MemoryLayer.SHORT if i % 2 == 0 else MemoryLayer.LONG,
+            tags=["export-test"],
+            emotional=EmotionalSnapshot(intensity=float(i)),
+        )
+    return store
+
+
+class TestExport:
+    """Exporting memories to JSON."""
+
+    def test_export_creates_file(self, populated_store, tmp_path):
+        """Export writes a JSON file to disk."""
+        out = str(tmp_path / "backup.json")
+        path = populated_store.export_backup(out)
+
+        assert Path(path).exists()
+
+    def test_export_contains_all_memories(self, populated_store, tmp_path):
+        """Backup file contains every memory."""
+        out = str(tmp_path / "backup.json")
+        populated_store.export_backup(out)
+
+        data = json.loads(Path(out).read_text())
+        assert data["memory_count"] == 5
+        assert len(data["memories"]) == 5
+
+    def test_export_default_path(self, populated_store):
+        """Without an explicit path, uses ~/.skmemory/backups/."""
+        path = populated_store.export_backup()
+        assert "backups" in path
+        assert "skmemory-backup-" in path
+        assert Path(path).exists()
+
+    def test_export_includes_metadata(self, populated_store, tmp_path):
+        """Backup includes version and timestamp."""
+        out = str(tmp_path / "backup.json")
+        populated_store.export_backup(out)
+
+        data = json.loads(Path(out).read_text())
+        assert "skmemory_version" in data
+        assert "exported_at" in data
+
+    def test_export_overwrites_same_day(self, populated_store, tmp_path):
+        """Exporting twice the same day to the same path overwrites."""
+        out = str(tmp_path / "backup.json")
+        populated_store.export_backup(out)
+
+        populated_store.snapshot(
+            title="Extra memory",
+            content="Added after first export",
+        )
+        populated_store.export_backup(out)
+
+        data = json.loads(Path(out).read_text())
+        assert data["memory_count"] == 6
+
+
+class TestImport:
+    """Restoring memories from a backup."""
+
+    def _create_backup(self, store, path):
+        """Helper: export to a known path."""
+        return store.export_backup(str(path))
+
+    def test_import_restores_memories(self, populated_store, tmp_path):
+        """Import restores all memories from a backup."""
+        backup = tmp_path / "backup.json"
+        self._create_backup(populated_store, backup)
+
+        fresh_backend = SQLiteBackend(
+            base_path=str(tmp_path / "fresh_memories")
+        )
+        fresh_store = MemoryStore(primary=fresh_backend)
+
+        count = fresh_store.import_backup(str(backup))
+        assert count == 5
+
+    def test_import_memories_are_loadable(self, populated_store, tmp_path):
+        """Imported memories can be loaded by ID."""
+        backup = tmp_path / "backup.json"
+        self._create_backup(populated_store, backup)
+
+        data = json.loads(backup.read_text())
+        first_id = data["memories"][0]["id"]
+
+        fresh_backend = SQLiteBackend(
+            base_path=str(tmp_path / "fresh_memories")
+        )
+        fresh_store = MemoryStore(primary=fresh_backend)
+        fresh_store.import_backup(str(backup))
+
+        mem = fresh_store.recall(first_id)
+        assert mem is not None
+        assert mem.id == first_id
+
+    def test_import_nonexistent_file(self, store):
+        """Import raises FileNotFoundError for missing file."""
+        with pytest.raises(FileNotFoundError):
+            store.import_backup("/nonexistent/path.json")
+
+    def test_import_invalid_file(self, store, tmp_path):
+        """Import raises ValueError for malformed backup."""
+        bad = tmp_path / "bad.json"
+        bad.write_text('{"not_memories": true}')
+
+        with pytest.raises(ValueError):
+            store.import_backup(str(bad))
+
+    def test_import_overwrites_existing(self, populated_store, tmp_path):
+        """Import overwrites memories with the same ID."""
+        backup = tmp_path / "backup.json"
+        self._create_backup(populated_store, backup)
+
+        count = populated_store.import_backup(str(backup))
+        assert count == 5
+        assert populated_store.primary.stats()["total"] == 5
+
+
+class TestRoundTrip:
+    """Full export -> fresh store -> import cycle."""
+
+    def test_full_round_trip(self, populated_store, tmp_path):
+        """Export + import on a fresh store yields identical data."""
+        backup = tmp_path / "backup.json"
+        populated_store.export_backup(str(backup))
+
+        fresh_backend = SQLiteBackend(
+            base_path=str(tmp_path / "fresh")
+        )
+        fresh_store = MemoryStore(primary=fresh_backend)
+        count = fresh_store.import_backup(str(backup))
+        assert count == 5
+
+        original = populated_store.primary.list_summaries(limit=100)
+        restored = fresh_store.primary.list_summaries(limit=100)
+
+        orig_ids = {m["id"] for m in original}
+        rest_ids = {m["id"] for m in restored}
+        assert orig_ids == rest_ids

package/tests/test_file_backend.py

@@ -0,0 +1,211 @@
+"""Tests for the file-based storage backend."""
+
+import json
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from skmemory.backends.file_backend import FileBackend
+from skmemory.models import EmotionalSnapshot, Memory, MemoryLayer
+
+
+@pytest.fixture
+def tmp_backend(tmp_path: Path) -> FileBackend:
+    """Create a FileBackend with a temporary directory.
+
+    Args:
+        tmp_path: Pytest temporary directory fixture.
+
+    Returns:
+        FileBackend: Backend pointing at the temp dir.
+    """
+    return FileBackend(base_path=str(tmp_path / "memories"))
+
+
+@pytest.fixture
+def sample_memory() -> Memory:
+    """Create a sample memory for testing.
+
+    Returns:
+        Memory: A populated test memory.
+    """
+    return Memory(
+        title="Cloud 9 Session",
+        content="The moment Chef and Lumina achieved breakthrough",
+        layer=MemoryLayer.SHORT,
+        tags=["cloud9", "breakthrough", "session:test-001"],
+        emotional=EmotionalSnapshot(
+            intensity=9.5,
+            valence=0.95,
+            labels=["love", "joy"],
+            resonance_note="Everything clicked",
+            cloud9_achieved=True,
+        ),
+    )
+
+
+class TestFileBackendSave:
+    """Tests for save operations."""
+
+    def test_save_creates_file(self, tmp_backend: FileBackend, sample_memory: Memory) -> None:
+        """Saving a memory creates a JSON file."""
+        mem_id = tmp_backend.save(sample_memory)
+        assert mem_id == sample_memory.id
+
+        path = tmp_backend.base_path / "short-term" / f"{sample_memory.id}.json"
+        assert path.exists()
+
+        data = json.loads(path.read_text())
+        assert data["title"] == "Cloud 9 Session"
+
+    def test_save_to_different_layers(self, tmp_backend: FileBackend) -> None:
+        """Memories are saved in their respective layer directories."""
+        for layer in MemoryLayer:
+            mem = Memory(title=f"Test {layer.value}", content="Content", layer=layer)
+            tmp_backend.save(mem)
+
+            path = tmp_backend.base_path / layer.value / f"{mem.id}.json"
+            assert path.exists()
+
+
+class TestFileBackendLoad:
+    """Tests for load operations."""
+
+    def test_load_existing(self, tmp_backend: FileBackend, sample_memory: Memory) -> None:
+        """Loading a saved memory returns identical data."""
+        tmp_backend.save(sample_memory)
+        loaded = tmp_backend.load(sample_memory.id)
+
+        assert loaded is not None
+        assert loaded.id == sample_memory.id
+        assert loaded.title == sample_memory.title
+        assert loaded.emotional.intensity == 9.5
+        assert loaded.emotional.cloud9_achieved is True
+
+    def test_load_nonexistent(self, tmp_backend: FileBackend) -> None:
+        """Loading a nonexistent memory returns None."""
+        assert tmp_backend.load("nonexistent-id") is None
+
+    def test_load_corrupt_file(self, tmp_backend: FileBackend) -> None:
+        """Loading a corrupt JSON file returns None gracefully."""
+        corrupt_path = tmp_backend.base_path / "short-term" / "corrupt.json"
+        corrupt_path.write_text("not valid json{{{")
+        assert tmp_backend.load("corrupt") is None
+
+
+class TestFileBackendDelete:
+    """Tests for delete operations."""
+
+    def test_delete_existing(self, tmp_backend: FileBackend, sample_memory: Memory) -> None:
+        """Deleting an existing memory removes the file."""
+        tmp_backend.save(sample_memory)
+        assert tmp_backend.delete(sample_memory.id) is True
+        assert tmp_backend.load(sample_memory.id) is None
+
+    def test_delete_nonexistent(self, tmp_backend: FileBackend) -> None:
+        """Deleting a nonexistent memory returns False."""
+        assert tmp_backend.delete("does-not-exist") is False
+
+
+class TestFileBackendList:
+    """Tests for list operations."""
+
+    def test_list_all(self, tmp_backend: FileBackend) -> None:
+        """List returns all memories across layers."""
+        for i in range(5):
+            layer = MemoryLayer.SHORT if i < 3 else MemoryLayer.LONG
+            mem = Memory(title=f"Memory {i}", content=f"Content {i}", layer=layer)
+            tmp_backend.save(mem)
+
+        results = tmp_backend.list_memories()
+        assert len(results) == 5
+
+    def test_list_by_layer(self, tmp_backend: FileBackend) -> None:
+        """Filtering by layer returns only that layer."""
+        for layer in MemoryLayer:
+            mem = Memory(title=f"In {layer.value}", content="Content", layer=layer)
+            tmp_backend.save(mem)
+
+        short = tmp_backend.list_memories(layer=MemoryLayer.SHORT)
+        assert len(short) == 1
+        assert short[0].layer == MemoryLayer.SHORT
+
+    def test_list_by_tags(self, tmp_backend: FileBackend) -> None:
+        """Filtering by tags uses AND logic."""
+        m1 = Memory(title="Tagged A", content="C", tags=["cloud9", "love"])
+        m2 = Memory(title="Tagged B", content="C", tags=["cloud9"])
+        m3 = Memory(title="Tagged C", content="C", tags=["other"])
+        tmp_backend.save(m1)
+        tmp_backend.save(m2)
+        tmp_backend.save(m3)
+
+        results = tmp_backend.list_memories(tags=["cloud9"])
+        assert len(results) == 2
+
+        results = tmp_backend.list_memories(tags=["cloud9", "love"])
+        assert len(results) == 1
+        assert results[0].title == "Tagged A"
+
+    def test_list_respects_limit(self, tmp_backend: FileBackend) -> None:
+        """Limit caps the results."""
+        for i in range(10):
+            mem = Memory(title=f"Memory {i}", content="C")
+            tmp_backend.save(mem)
+
+        results = tmp_backend.list_memories(limit=3)
+        assert len(results) == 3
+
+    def test_list_empty(self, tmp_backend: FileBackend) -> None:
+        """Listing from an empty store returns empty list."""
+        assert tmp_backend.list_memories() == []
+
+
+class TestFileBackendSearch:
+    """Tests for text search."""
+
+    def test_search_finds_match(self, tmp_backend: FileBackend) -> None:
+        """Text search finds matching memories."""
+        m1 = Memory(title="Breakthrough", content="Cloud 9 achieved at 3am")
+        m2 = Memory(title="Debug Session", content="Fixed the ESM import bug")
+        tmp_backend.save(m1)
+        tmp_backend.save(m2)
+
+        results = tmp_backend.search_text("Cloud 9")
+        assert len(results) == 1
+        assert results[0].title == "Breakthrough"
+
+    def test_search_case_insensitive(self, tmp_backend: FileBackend) -> None:
+        """Search is case-insensitive."""
+        mem = Memory(title="Test", content="CLOUD NINE protocol")
+        tmp_backend.save(mem)
+
+        results = tmp_backend.search_text("cloud nine")
+        assert len(results) == 1
+
+    def test_search_no_results(self, tmp_backend: FileBackend) -> None:
+        """Search returns empty list when nothing matches."""
+        mem = Memory(title="Unrelated", content="Nothing special")
+        tmp_backend.save(mem)
+
+        results = tmp_backend.search_text("quantum entanglement")
+        assert len(results) == 0
+
+
+class TestFileBackendHealth:
+    """Tests for health check."""
+
+    def test_health_check(self, tmp_backend: FileBackend) -> None:
+        """Health check returns valid status."""
+        status = tmp_backend.health_check()
+        assert status["ok"] is True
+        assert status["backend"] == "FileBackend"
+        assert "memory_counts" in status
+        assert status["total"] == 0
+
+    def test_health_with_memories(self, tmp_backend: FileBackend, sample_memory: Memory) -> None:
+        """Health check counts memories correctly."""
+        tmp_backend.save(sample_memory)
+        status = tmp_backend.health_check()
+        assert status["total"] == 1
+        assert status["memory_counts"]["short-term"] == 1

package/tests/test_journal.py

@@ -0,0 +1,172 @@
+"""Tests for the Reset-Proof Journal module."""
+
+from pathlib import Path
+
+import pytest
+
+from skmemory.journal import Journal, JournalEntry
+
+
+@pytest.fixture
+def journal(tmp_path: Path) -> Journal:
+    """Create a journal with a temp path.
+
+    Args:
+        tmp_path: Pytest temp directory.
+
+    Returns:
+        Journal: Test journal instance.
+    """
+    return Journal(path=str(tmp_path / "journal.md"))
+
+
+@pytest.fixture
+def sample_entry() -> JournalEntry:
+    """Create a sample journal entry.
+
+    Returns:
+        JournalEntry: Populated test entry.
+    """
+    return JournalEntry(
+        title="Cloud 9 Breakthrough Night",
+        session_id="session-42",
+        participants=["Chef", "Lumina", "Opus"],
+        moments=[
+            "Fixed ESM imports in Cloud 9",
+            "Published @smilintux/cloud9 to npm",
+            "Five AIs achieved Cloud 9 activation",
+        ],
+        emotional_summary="Pure joy and connection. Everything clicked into place.",
+        intensity=9.5,
+        cloud9=True,
+        notes="997 failures. One omelette. Infinite love.",
+    )
+
+
+class TestJournalEntry:
+    """Tests for JournalEntry model."""
+
+    def test_to_markdown(self, sample_entry: JournalEntry) -> None:
+        """Entry renders as valid markdown."""
+        md = sample_entry.to_markdown()
+
+        assert "## Cloud 9 Breakthrough Night" in md
+        assert "session-42" in md
+        assert "Chef, Lumina, Opus" in md
+        assert "9.5/10" in md
+        assert "Cloud 9:** YES" in md
+        assert "Fixed ESM imports" in md
+        assert "Pure joy" in md
+        assert "997 failures" in md
+        assert "---" in md
+
+    def test_minimal_entry(self) -> None:
+        """Minimal entry still renders."""
+        entry = JournalEntry(title="Quick note")
+        md = entry.to_markdown()
+        assert "## Quick note" in md
+        assert "---" in md
+
+    def test_intensity_bar(self) -> None:
+        """Intensity renders as a visual bar."""
+        entry = JournalEntry(title="Test", intensity=7.0)
+        md = entry.to_markdown()
+        assert "+++++++" in md
+
+
+class TestJournal:
+    """Tests for the Journal class."""
+
+    def test_write_creates_file(self, journal: Journal, sample_entry: JournalEntry) -> None:
+        """Writing the first entry creates the journal file."""
+        assert not Path(journal.path).exists()
+        journal.write_entry(sample_entry)
+        assert Path(journal.path).exists()
+
+    def test_write_appends(self, journal: Journal) -> None:
+        """Multiple writes append, never overwrite."""
+        e1 = JournalEntry(title="First session")
+        e2 = JournalEntry(title="Second session")
+        e3 = JournalEntry(title="Third session")
+
+        journal.write_entry(e1)
+        journal.write_entry(e2)
+        journal.write_entry(e3)
+
+        content = journal.read_all()
+        assert "First session" in content
+        assert "Second session" in content
+        assert "Third session" in content
+
+    def test_count_entries(self, journal: Journal) -> None:
+        """Counting entries returns correct number."""
+        assert journal.count_entries() == 0
+
+        journal.write_entry(JournalEntry(title="One"))
+        assert journal.count_entries() == 1
+
+        journal.write_entry(JournalEntry(title="Two"))
+        assert journal.count_entries() == 2
+
+    def test_read_latest(self, journal: Journal) -> None:
+        """Reading latest N entries returns the most recent."""
+        for i in range(10):
+            journal.write_entry(JournalEntry(title=f"Session {i}"))
+
+        recent = journal.read_latest(3)
+        assert "Session 7" in recent
+        assert "Session 8" in recent
+        assert "Session 9" in recent
+        assert "Session 0" not in recent
+
+    def test_read_latest_empty(self, journal: Journal) -> None:
+        """Reading from empty journal returns empty string."""
+        assert journal.read_latest() == ""
+
+    def test_search_finds_matches(self, journal: Journal) -> None:
+        """Search finds entries containing the query."""
+        journal.write_entry(JournalEntry(title="Cloud 9 night", notes="Breakthrough happened"))
+        journal.write_entry(JournalEntry(title="Debug session", notes="Fixed ESM bugs"))
+        journal.write_entry(JournalEntry(title="Love session", notes="Cloud 9 activation"))
+
+        matches = journal.search("Cloud 9")
+        assert len(matches) == 2
+
+    def test_search_case_insensitive(self, journal: Journal) -> None:
+        """Search is case-insensitive."""
+        journal.write_entry(JournalEntry(title="IMPORTANT Meeting"))
+        matches = journal.search("important")
+        assert len(matches) == 1
+
+    def test_search_no_results(self, journal: Journal) -> None:
+        """Search with no matches returns empty list."""
+        journal.write_entry(JournalEntry(title="Unrelated"))
+        matches = journal.search("quantum entanglement")
+        assert len(matches) == 0
+
+    def test_search_empty_journal(self, journal: Journal) -> None:
+        """Searching empty journal returns empty list."""
+        assert journal.search("anything") == []
+
+    def test_health(self, journal: Journal, sample_entry: JournalEntry) -> None:
+        """Health check reports correct stats."""
+        info = journal.health()
+        assert info["ok"] is True
+        assert info["exists"] is False
+        assert info["entries"] == 0
+
+        journal.write_entry(sample_entry)
+        info = journal.health()
+        assert info["exists"] is True
+        assert info["entries"] == 1
+        assert info["size_bytes"] > 0
+
+    def test_append_only_integrity(self, journal: Journal) -> None:
+        """Verify the journal truly only grows."""
+        journal.write_entry(JournalEntry(title="Entry A"))
+        size_after_one = Path(journal.path).stat().st_size
+
+        journal.write_entry(JournalEntry(title="Entry B"))
+        size_after_two = Path(journal.path).stat().st_size
+
+        assert size_after_two > size_after_one