agent-os-kernel 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

modules/emk/tests/test_file_adapter.py

@@ -0,0 +1,195 @@
+"""Tests for the FileAdapter."""
+
+import pytest
+import tempfile
+import os
+from pathlib import Path
+
+from emk.schema import Episode
+from emk.store import FileAdapter
+
+
+@pytest.fixture
+def temp_file():
+    """Create a temporary file for testing."""
+    fd, path = tempfile.mkstemp(suffix=".jsonl")
+    os.close(fd)
+    yield path
+    # Cleanup
+    if os.path.exists(path):
+        os.remove(path)
+
+
+def test_file_adapter_creation(temp_file):
+    """Test FileAdapter creation."""
+    adapter = FileAdapter(temp_file)
+    assert adapter.filepath == Path(temp_file)
+    assert adapter.filepath.exists()
+
+
+def test_store_episode(temp_file):
+    """Test storing an episode."""
+    adapter = FileAdapter(temp_file)
+    
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    episode_id = adapter.store(episode)
+    
+    assert episode_id == episode.episode_id
+    assert adapter.filepath.stat().st_size > 0
+
+
+def test_retrieve_episodes(temp_file):
+    """Test retrieving episodes."""
+    adapter = FileAdapter(temp_file)
+    
+    # Store multiple episodes
+    episodes = []
+    for i in range(5):
+        episode = Episode(
+            goal=f"Goal {i}",
+            action=f"Action {i}",
+            result=f"Result {i}",
+            reflection=f"Reflection {i}"
+        )
+        adapter.store(episode)
+        episodes.append(episode)
+    
+    # Retrieve all
+    retrieved = adapter.retrieve(limit=10)
+    
+    assert len(retrieved) == 5
+    # Should be in reverse order (most recent first)
+    assert retrieved[0].goal == "Goal 4"
+    assert retrieved[4].goal == "Goal 0"
+
+
+def test_retrieve_with_limit(temp_file):
+    """Test retrieving episodes with limit."""
+    adapter = FileAdapter(temp_file)
+    
+    # Store multiple episodes
+    for i in range(5):
+        episode = Episode(
+            goal=f"Goal {i}",
+            action=f"Action {i}",
+            result=f"Result {i}",
+            reflection=f"Reflection {i}"
+        )
+        adapter.store(episode)
+    
+    # Retrieve with limit
+    retrieved = adapter.retrieve(limit=3)
+    
+    assert len(retrieved) == 3
+
+
+def test_retrieve_with_filters(temp_file):
+    """Test retrieving episodes with metadata filters."""
+    adapter = FileAdapter(temp_file)
+    
+    # Store episodes with different metadata
+    episode1 = Episode(
+        goal="Goal 1",
+        action="Action 1",
+        result="Result 1",
+        reflection="Reflection 1",
+        metadata={"user_id": "123"}
+    )
+    adapter.store(episode1)
+    
+    episode2 = Episode(
+        goal="Goal 2",
+        action="Action 2",
+        result="Result 2",
+        reflection="Reflection 2",
+        metadata={"user_id": "456"}
+    )
+    adapter.store(episode2)
+    
+    episode3 = Episode(
+        goal="Goal 3",
+        action="Action 3",
+        result="Result 3",
+        reflection="Reflection 3",
+        metadata={"user_id": "123"}
+    )
+    adapter.store(episode3)
+    
+    # Retrieve with filter
+    retrieved = adapter.retrieve(filters={"user_id": "123"})
+    
+    assert len(retrieved) == 2
+    assert all(e.metadata.get("user_id") == "123" for e in retrieved)
+
+
+def test_get_by_id(temp_file):
+    """Test retrieving a specific episode by ID."""
+    adapter = FileAdapter(temp_file)
+    
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    episode_id = adapter.store(episode)
+    
+    # Retrieve by ID
+    retrieved = adapter.get_by_id(episode_id)
+    
+    assert retrieved is not None
+    assert retrieved.episode_id == episode_id
+    assert retrieved.goal == episode.goal
+
+
+def test_get_by_id_not_found(temp_file):
+    """Test retrieving a non-existent episode."""
+    adapter = FileAdapter(temp_file)
+    
+    retrieved = adapter.get_by_id("nonexistent")
+    
+    assert retrieved is None
+
+
+def test_retrieve_empty_file(temp_file):
+    """Test retrieving from an empty file."""
+    adapter = FileAdapter(temp_file)
+    
+    retrieved = adapter.retrieve()
+    
+    assert retrieved == []
+
+
+def test_multiple_stores_append(temp_file):
+    """Test that multiple stores append to the file."""
+    adapter = FileAdapter(temp_file)
+    
+    # Store first episode
+    episode1 = Episode(
+        goal="Goal 1",
+        action="Action 1",
+        result="Result 1",
+        reflection="Reflection 1"
+    )
+    adapter.store(episode1)
+    
+    # Store second episode
+    episode2 = Episode(
+        goal="Goal 2",
+        action="Action 2",
+        result="Result 2",
+        reflection="Reflection 2"
+    )
+    adapter.store(episode2)
+    
+    # Retrieve all
+    retrieved = adapter.retrieve()
+    
+    assert len(retrieved) == 2

modules/emk/tests/test_indexer.py

@@ -0,0 +1,174 @@
+"""Tests for the Indexer."""
+
+import pytest
+
+from emk.schema import Episode
+from emk.indexer import Indexer
+
+
+def test_extract_tags_basic():
+    """Test basic tag extraction."""
+    text = "The user wants to retrieve data from the database"
+    tags = Indexer.extract_tags(text)
+    
+    assert "user" in tags
+    assert "wants" in tags
+    assert "retrieve" in tags
+    assert "data" in tags
+    assert "database" in tags
+    # Stop words should be filtered
+    assert "the" not in tags
+    assert "to" not in tags
+    assert "from" not in tags
+
+
+def test_extract_tags_min_length():
+    """Test tag extraction with minimum length."""
+    text = "I go to eat at a restaurant"
+    tags = Indexer.extract_tags(text, min_length=4)
+    
+    assert "restaurant" in tags
+    # Short words should be filtered
+    assert "go" not in tags
+    assert "eat" not in tags
+
+
+def test_extract_tags_lowercased():
+    """Test that tags are lowercased."""
+    text = "Database Query System"
+    tags = Indexer.extract_tags(text)
+    
+    assert "database" in tags
+    assert "query" in tags
+    assert "system" in tags
+    assert "Database" not in tags
+
+
+def test_generate_episode_tags():
+    """Test generating tags from an episode."""
+    episode = Episode(
+        goal="Retrieve user preferences from database",
+        action="Execute SQL query",
+        result="Successfully retrieved data",
+        reflection="Query was efficient",
+        metadata={"user_id": "123", "query_type": "select"}
+    )
+    
+    tags = Indexer.generate_episode_tags(episode)
+    
+    assert isinstance(tags, list)
+    assert len(tags) > 0
+    # Should include words from all fields
+    assert "retrieve" in tags
+    assert "preferences" in tags
+    assert "database" in tags
+    assert "query" in tags
+    assert "efficient" in tags
+    # Should include metadata keys
+    assert "user_id" in tags
+    assert "query_type" in tags
+
+
+def test_compute_content_hash():
+    """Test computing content hash."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    content_hash = Indexer.compute_content_hash(episode)
+    
+    assert isinstance(content_hash, str)
+    assert len(content_hash) == 64  # SHA-256 hash length
+    assert content_hash == episode.episode_id
+
+
+def test_enrich_metadata():
+    """Test enriching episode metadata."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection",
+        metadata={"user_id": "123"}
+    )
+    
+    enriched = Indexer.enrich_metadata(episode)
+    
+    assert "user_id" in enriched
+    assert enriched["user_id"] == "123"
+    assert "tags" in enriched
+    assert isinstance(enriched["tags"], list)
+    assert "goal_length" in enriched
+    assert enriched["goal_length"] == len("Test goal")
+    assert "action_length" in enriched
+    assert "result_length" in enriched
+    assert "reflection_length" in enriched
+
+
+def test_enrich_metadata_no_auto_tags():
+    """Test enriching metadata without auto tags."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    enriched = Indexer.enrich_metadata(episode, auto_tags=False)
+    
+    assert "tags" not in enriched
+    assert "goal_length" in enriched
+
+
+def test_enrich_metadata_preserves_existing_tags():
+    """Test that existing tags are preserved."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection",
+        metadata={"tags": ["custom", "tags"]}
+    )
+    
+    enriched = Indexer.enrich_metadata(episode, auto_tags=True)
+    
+    assert enriched["tags"] == ["custom", "tags"]
+
+
+def test_create_search_text():
+    """Test creating search text from episode."""
+    episode = Episode(
+        goal="Retrieve user data",
+        action="Query database",
+        result="Success",
+        reflection="Worked well",
+        metadata={"user_id": "123"}
+    )
+    
+    search_text = Indexer.create_search_text(episode)
+    
+    assert isinstance(search_text, str)
+    assert "Goal: Retrieve user data" in search_text
+    assert "Action: Query database" in search_text
+    assert "Result: Success" in search_text
+    assert "Reflection: Worked well" in search_text
+    assert "Context:" in search_text
+    assert "user_id: 123" in search_text
+
+
+def test_create_search_text_no_metadata():
+    """Test creating search text without metadata."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    search_text = Indexer.create_search_text(episode)
+    
+    assert "Goal: Test goal" in search_text
+    assert "Context:" not in search_text

modules/emk/tests/test_init.py

@@ -0,0 +1,55 @@
+"""Tests for package initialization and imports."""
+
+import pytest
+
+
+def test_import_main_package():
+    """Test that the main package can be imported."""
+    import emk
+    assert hasattr(emk, '__version__')
+    assert emk.__version__ == "0.1.0"
+
+
+def test_import_episode():
+    """Test that Episode can be imported."""
+    from emk import Episode
+    
+    episode = Episode(
+        goal="Test",
+        action="Test",
+        result="Test",
+        reflection="Test"
+    )
+    assert episode.goal == "Test"
+
+
+def test_import_file_adapter():
+    """Test that FileAdapter can be imported."""
+    from emk import FileAdapter
+    
+    assert FileAdapter is not None
+
+
+def test_import_vector_store_adapter():
+    """Test that VectorStoreAdapter can be imported."""
+    from emk import VectorStoreAdapter
+    
+    assert VectorStoreAdapter is not None
+
+
+def test_import_indexer():
+    """Test that Indexer can be imported."""
+    from emk import Indexer
+    
+    assert Indexer is not None
+
+
+def test_chromadb_adapter_optional():
+    """Test that ChromaDBAdapter import is optional."""
+    try:
+        from emk import ChromaDBAdapter
+        # If import succeeds, chromadb is installed
+        assert ChromaDBAdapter is not None
+    except ImportError:
+        # If import fails, chromadb is not installed - this is expected
+        pytest.skip("chromadb not installed")

modules/emk/tests/test_negative_memory.py

@@ -0,0 +1,83 @@
+"""Tests for negative memory (failure tracking) functionality."""
+
+from emk.schema import Episode
+
+
+def test_episode_is_failure_default():
+    """Test that episodes are not failures by default."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    assert not episode.is_failure()
+
+
+def test_episode_mark_as_failure():
+    """Test marking an episode as a failure."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    failed_episode = episode.mark_as_failure(reason="Connection timeout")
+    
+    assert failed_episode.is_failure()
+    assert failed_episode.metadata["is_failure"] is True
+    assert failed_episode.metadata["failure_reason"] == "Connection timeout"
+    
+    # Original episode should remain unchanged (immutability)
+    assert not episode.is_failure()
+
+
+def test_episode_mark_as_failure_no_reason():
+    """Test marking an episode as failure without a reason."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    failed_episode = episode.mark_as_failure()
+    
+    assert failed_episode.is_failure()
+    assert failed_episode.metadata["is_failure"] is True
+    assert "failure_reason" not in failed_episode.metadata
+
+
+def test_episode_with_failure_metadata():
+    """Test creating an episode with failure metadata directly."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Failed",
+        reflection="Need to retry",
+        metadata={"is_failure": True, "failure_reason": "Network error"}
+    )
+    
+    assert episode.is_failure()
+    assert episode.metadata["failure_reason"] == "Network error"
+
+
+def test_episode_failure_serialization():
+    """Test that failure metadata survives serialization."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Failed",
+        reflection="Test reflection"
+    )
+    
+    failed_episode = episode.mark_as_failure(reason="Test failure")
+    
+    # Serialize and deserialize
+    json_str = failed_episode.to_json()
+    restored_episode = Episode.from_json(json_str)
+    
+    assert restored_episode.is_failure()
+    assert restored_episode.metadata["failure_reason"] == "Test failure"

modules/emk/tests/test_schema.py

@@ -0,0 +1,150 @@
+"""Tests for the Episode schema."""
+
+import pytest
+from datetime import datetime
+import json
+
+from emk.schema import Episode
+
+
+def test_episode_creation():
+    """Test basic episode creation."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    assert episode.goal == "Test goal"
+    assert episode.action == "Test action"
+    assert episode.result == "Test result"
+    assert episode.reflection == "Test reflection"
+    assert episode.episode_id is not None
+    assert isinstance(episode.timestamp, datetime)
+    assert episode.metadata == {}
+
+
+def test_episode_with_metadata():
+    """Test episode creation with metadata."""
+    metadata = {"user_id": "123", "session": "abc"}
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection",
+        metadata=metadata
+    )
+    
+    assert episode.metadata == metadata
+
+
+def test_episode_id_generation():
+    """Test that episode IDs are unique and deterministic."""
+    episode1 = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    episode2 = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    # Same content should generate different IDs due to different timestamps
+    assert episode1.episode_id != episode2.episode_id
+
+
+def test_episode_to_dict():
+    """Test episode conversion to dictionary."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    data = episode.to_dict()
+    
+    assert isinstance(data, dict)
+    assert data["goal"] == "Test goal"
+    assert data["action"] == "Test action"
+    assert data["result"] == "Test result"
+    assert data["reflection"] == "Test reflection"
+    assert "episode_id" in data
+    assert "timestamp" in data
+
+
+def test_episode_to_json():
+    """Test episode conversion to JSON."""
+    episode = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection"
+    )
+    
+    json_str = episode.to_json()
+    
+    assert isinstance(json_str, str)
+    data = json.loads(json_str)
+    assert data["goal"] == "Test goal"
+
+
+def test_episode_from_dict():
+    """Test episode creation from dictionary."""
+    data = {
+        "goal": "Test goal",
+        "action": "Test action",
+        "result": "Test result",
+        "reflection": "Test reflection",
+        "metadata": {"key": "value"}
+    }
+    
+    episode = Episode.from_dict(data)
+    
+    assert episode.goal == "Test goal"
+    assert episode.action == "Test action"
+    assert episode.result == "Test result"
+    assert episode.reflection == "Test reflection"
+    assert episode.metadata == {"key": "value"}
+
+
+def test_episode_from_json():
+    """Test episode creation from JSON."""
+    json_str = json.dumps({
+        "goal": "Test goal",
+        "action": "Test action",
+        "result": "Test result",
+        "reflection": "Test reflection"
+    })
+    
+    episode = Episode.from_json(json_str)
+    
+    assert episode.goal == "Test goal"
+    assert episode.action == "Test action"
+
+
+def test_episode_roundtrip():
+    """Test that episode can be serialized and deserialized."""
+    original = Episode(
+        goal="Test goal",
+        action="Test action",
+        result="Test result",
+        reflection="Test reflection",
+        metadata={"key": "value"}
+    )
+    
+    # Convert to JSON and back
+    json_str = original.to_json()
+    restored = Episode.from_json(json_str)
+    
+    assert restored.goal == original.goal
+    assert restored.action == original.action
+    assert restored.result == original.result
+    assert restored.reflection == original.reflection
+    assert restored.metadata == original.metadata