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

modules/caas/tests/test_context_triad.py

@@ -0,0 +1,385 @@
+"""
+Test suite for the Context Triad (Hot, Warm, Cold) implementation.
+"""
+
+from caas.triad import ContextTriadManager
+from caas.models import ContextLayer
+
+
+def test_hot_context():
+    """Test hot context management (The Situation)."""
+    print("\n=== Testing Hot Context (The Situation) ===")
+    
+    manager = ContextTriadManager()
+    
+    # Add hot context items
+    id1 = manager.add_hot_context(
+        "User is debugging a NullPointerException in the authentication module",
+        metadata={"source": "error_log", "type": "exception"},
+        priority=2.0
+    )
+    print(f"✓ Added hot context item: {id1}")
+    
+    id2 = manager.add_hot_context(
+        "Currently viewing auth_service.py lines 145-200",
+        metadata={"source": "vscode", "type": "open_file"},
+        priority=1.5
+    )
+    print(f"✓ Added hot context item: {id2}")
+    
+    id3 = manager.add_hot_context(
+        "Current conversation: How to fix authentication issues?",
+        metadata={"source": "conversation", "type": "user_message"},
+        priority=3.0
+    )
+    print(f"✓ Added hot context item: {id3}")
+    
+    # Get hot context
+    hot_context = manager.get_hot_context(max_tokens=500, include_metadata=True)
+    print(f"\n--- Hot Context (prioritized) ---\n{hot_context}")
+    
+    # Verify hot context items are included
+    assert "authentication" in hot_context.lower()
+    assert "Hot Context" in hot_context
+    print("✓ Hot context retrieved successfully")
+    
+    # Test clearing hot context
+    manager.clear_hot_context()
+    hot_context_after_clear = manager.get_hot_context()
+    assert hot_context_after_clear == ""
+    print("✓ Hot context cleared successfully")
+
+
+def test_warm_context():
+    """Test warm context management (The Persona)."""
+    print("\n=== Testing Warm Context (The Persona) ===")
+    
+    manager = ContextTriadManager()
+    
+    # Add warm context items (user persona)
+    id1 = manager.add_warm_context(
+        "Senior Python developer with 8 years of experience",
+        metadata={"category": "Experience", "source": "linkedin"},
+        priority=1.5
+    )
+    print(f"✓ Added warm context item: {id1}")
+    
+    id2 = manager.add_warm_context(
+        "Prefers type hints and comprehensive docstrings",
+        metadata={"category": "Coding Style", "source": "preferences"},
+        priority=2.0
+    )
+    print(f"✓ Added warm context item: {id2}")
+    
+    id3 = manager.add_warm_context(
+        "Interested in AI/ML and distributed systems",
+        metadata={"category": "Interests", "source": "github_bio"},
+        priority=1.0
+    )
+    print(f"✓ Added warm context item: {id3}")
+    
+    id4 = manager.add_warm_context(
+        "Prefers FastAPI over Flask, uses pytest for testing",
+        metadata={"category": "Tech Stack", "source": "preferences"},
+        priority=1.8
+    )
+    print(f"✓ Added warm context item: {id4}")
+    
+    # Get warm context
+    warm_context = manager.get_warm_context(max_tokens=500, include_metadata=True)
+    print(f"\n--- Warm Context (User Persona) ---\n{warm_context}")
+    
+    # Verify warm context items are included
+    assert "Python" in warm_context or "python" in warm_context
+    assert "Warm Context" in warm_context
+    print("✓ Warm context retrieved successfully")
+
+
+def test_cold_context():
+    """Test cold context management (The Archive)."""
+    print("\n=== Testing Cold Context (The Archive) ===")
+    
+    manager = ContextTriadManager()
+    
+    # Add cold context items (historical data)
+    id1 = manager.add_cold_context(
+        "Ticket #1234: Fixed authentication bug in v1.2.0 (closed 2023-06-15)",
+        metadata={"date": "2023-06-15", "type": "ticket", "status": "closed"},
+        priority=1.0
+    )
+    print(f"✓ Added cold context item: {id1}")
+    
+    id2 = manager.add_cold_context(
+        "PR #567: Refactored authentication module (merged 2023-08-20)",
+        metadata={"date": "2023-08-20", "type": "pr", "status": "merged"},
+        priority=1.2
+    )
+    print(f"✓ Added cold context item: {id2}")
+    
+    id3 = manager.add_cold_context(
+        "Design doc: Legacy authentication flow (2022-01-10)",
+        metadata={"date": "2022-01-10", "type": "design_doc"},
+        priority=0.8
+    )
+    print(f"✓ Added cold context item: {id3}")
+    
+    # Cold context without query should return empty
+    cold_context_no_query = manager.get_cold_context()
+    assert cold_context_no_query == ""
+    print("✓ Cold context correctly returns empty without query")
+    
+    # Cold context with query
+    cold_context = manager.get_cold_context(
+        query="authentication",
+        max_tokens=500,
+        include_metadata=True
+    )
+    print(f"\n--- Cold Context (with query='authentication') ---\n{cold_context}")
+    
+    # Verify cold context items are included
+    assert "authentication" in cold_context.lower()
+    assert "Cold Context" in cold_context
+    assert "Query: authentication" in cold_context
+    print("✓ Cold context retrieved successfully with query")
+    
+    # Query that doesn't match should return minimal context
+    cold_context_no_match = manager.get_cold_context(
+        query="unrelated_topic",
+        max_tokens=500
+    )
+    # Should still have header but no content
+    assert cold_context_no_match == "" or "Cold Context" in cold_context_no_match
+    print("✓ Cold context correctly handles non-matching query")
+
+
+def test_full_context_triad():
+    """Test the complete context triad."""
+    print("\n=== Testing Full Context Triad ===")
+    
+    manager = ContextTriadManager()
+    
+    # Add hot context
+    manager.add_hot_context(
+        "Current error: AuthenticationError at line 145",
+        metadata={"source": "error_log"},
+        priority=2.0
+    )
+    
+    # Add warm context
+    manager.add_warm_context(
+        "Senior developer, prefers detailed error messages",
+        metadata={"category": "Profile"},
+        priority=1.5
+    )
+    
+    # Add cold context
+    manager.add_cold_context(
+        "Previous authentication bug fixed in 2023",
+        metadata={"date": "2023-06-15"},
+        priority=1.0
+    )
+    
+    # Test 1: Hot + Warm only (default behavior)
+    print("\n--- Test 1: Hot + Warm Context (Default) ---")
+    result = manager.get_full_context(
+        include_hot=True,
+        include_warm=True,
+        include_cold=False
+    )
+    
+    assert "hot" in result["layers_included"]
+    assert "warm" in result["layers_included"]
+    assert "cold" not in result["layers_included"]
+    assert "AuthenticationError" in result["hot_context"]
+    assert "developer" in result["warm_context"].lower()
+    assert result["cold_context"] == ""
+    print("✓ Hot + Warm context retrieved (Cold excluded as expected)")
+    
+    # Test 2: Hot + Warm + Cold with query
+    print("\n--- Test 2: Hot + Warm + Cold Context (with query) ---")
+    result = manager.get_full_context(
+        include_hot=True,
+        include_warm=True,
+        include_cold=True,
+        cold_query="authentication"
+    )
+    
+    assert "hot" in result["layers_included"]
+    assert "warm" in result["layers_included"]
+    assert "cold" in result["layers_included"]
+    assert "AuthenticationError" in result["hot_context"]
+    assert "authentication" in result["cold_context"].lower()
+    print("✓ All three layers retrieved successfully")
+    
+    # Test 3: Cold without query (should not include cold)
+    print("\n--- Test 3: Cold Context without query ---")
+    result = manager.get_full_context(
+        include_hot=False,
+        include_warm=False,
+        include_cold=True,
+        cold_query=None
+    )
+    
+    assert "cold" not in result["layers_included"]
+    assert result["cold_context"] == ""
+    print("✓ Cold context correctly excluded without query")
+    
+    # Test 4: Only Hot context
+    print("\n--- Test 4: Only Hot Context ---")
+    result = manager.get_full_context(
+        include_hot=True,
+        include_warm=False,
+        include_cold=False
+    )
+    
+    assert result["layers_included"] == ["hot"]
+    assert "AuthenticationError" in result["hot_context"]
+    print("✓ Only Hot context retrieved")
+
+
+def test_context_policies():
+    """Test that context triad follows its policies."""
+    print("\n=== Testing Context Triad Policies ===")
+    
+    manager = ContextTriadManager()
+    
+    # Add items to all layers
+    manager.add_hot_context("Hot: Current debugging session")
+    manager.add_warm_context("Warm: User prefers Python")
+    manager.add_cold_context("Cold: Old ticket from 2022")
+    
+    # Policy 1: Hot context ALWAYS included by default
+    result = manager.get_full_context()
+    assert "hot" in result["layers_included"]
+    print("✓ Policy 1: Hot context included by default (Attention Head)")
+    
+    # Policy 2: Warm context ALWAYS ON by default
+    assert "warm" in result["layers_included"]
+    print("✓ Policy 2: Warm context included by default (Always On Filter)")
+    
+    # Policy 3: Cold context ON DEMAND ONLY (not included without query)
+    assert "cold" not in result["layers_included"]
+    print("✓ Policy 3: Cold context excluded by default (On Demand Only)")
+    
+    # Policy 4: Cold context only with explicit query
+    result = manager.get_full_context(include_cold=True, cold_query="ticket")
+    assert "cold" in result["layers_included"]
+    print("✓ Policy 4: Cold context included when explicitly queried")
+
+
+def test_priority_ordering():
+    """Test that items are ordered by priority."""
+    print("\n=== Testing Priority Ordering ===")
+    
+    manager = ContextTriadManager()
+    
+    # Add hot context with different priorities
+    manager.add_hot_context("Low priority item", priority=1.0)
+    manager.add_hot_context("High priority item", priority=3.0)
+    manager.add_hot_context("Medium priority item", priority=2.0)
+    
+    hot_context = manager.get_hot_context()
+    
+    # High priority should appear first
+    high_pos = hot_context.find("High priority")
+    medium_pos = hot_context.find("Medium priority")
+    low_pos = hot_context.find("Low priority")
+    
+    assert high_pos < medium_pos < low_pos
+    print("✓ Items correctly ordered by priority (high to low)")
+
+
+def test_token_limits():
+    """Test that token limits are respected."""
+    print("\n=== Testing Token Limits ===")
+    
+    manager = ContextTriadManager()
+    
+    # Add multiple hot context items
+    for i in range(10):
+        manager.add_hot_context(
+            f"Item {i}: " + ("Long content " * 50),  # Make it long
+            priority=1.0
+        )
+    
+    # Get with small token limit
+    hot_context = manager.get_hot_context(max_tokens=100)
+    
+    # Should be truncated
+    assert len(hot_context) < 100 * 6  # Rough estimate (4-6 chars per token)
+    print("✓ Token limits respected")
+
+
+def test_item_removal():
+    """Test removing items from context."""
+    print("\n=== Testing Item Removal ===")
+    
+    manager = ContextTriadManager()
+    
+    # Add items
+    hot_id = manager.add_hot_context("Hot item")
+    warm_id = manager.add_warm_context("Warm item")
+    cold_id = manager.add_cold_context("Cold item")
+    
+    # Check initial state
+    state = manager.get_state()
+    assert len(state.hot_context) == 1
+    assert len(state.warm_context) == 1
+    assert len(state.cold_context) == 1
+    
+    # Remove items
+    assert manager.remove_item(hot_id, ContextLayer.HOT)
+    assert manager.remove_item(warm_id, ContextLayer.WARM)
+    assert manager.remove_item(cold_id, ContextLayer.COLD)
+    
+    # Check final state
+    state = manager.get_state()
+    assert len(state.hot_context) == 0
+    assert len(state.warm_context) == 0
+    assert len(state.cold_context) == 0
+    
+    print("✓ Items successfully removed from all layers")
+
+
+def test_hot_context_limit():
+    """Test that hot context is limited to keep it fresh."""
+    print("\n=== Testing Hot Context Auto-Limit ===")
+    
+    manager = ContextTriadManager()
+    
+    # Add many hot context items (more than limit)
+    for i in range(60):
+        manager.add_hot_context(f"Hot item {i}")
+    
+    state = manager.get_state()
+    
+    # Should be limited to 50 most recent items
+    assert len(state.hot_context) <= 50
+    print(f"✓ Hot context limited to {len(state.hot_context)} items (max 50)")
+
+
+if __name__ == "__main__":
+    print("============================================================")
+    print("Context Triad Test Suite")
+    print("============================================================")
+    
+    try:
+        test_hot_context()
+        test_warm_context()
+        test_cold_context()
+        test_full_context_triad()
+        test_context_policies()
+        test_priority_ordering()
+        test_token_limits()
+        test_item_removal()
+        test_hot_context_limit()
+        
+        print("\n============================================================")
+        print("✅ All Context Triad tests passed successfully!")
+        print("============================================================")
+    except AssertionError as e:
+        print(f"\n❌ Test failed: {e}")
+        raise
+    except Exception as e:
+        print(f"\n❌ Unexpected error: {e}")
+        raise

modules/caas/tests/test_conversation_manager.py

@@ -0,0 +1,289 @@
+"""
+Test suite for the Conversation Manager (Sliding Window / FIFO) implementation.
+
+The Brutal Squeeze Philosophy:
+Testing that Chopping (FIFO) is better than Summarizing.
+"""
+
+from caas.conversation import ConversationManager
+
+
+def test_basic_sliding_window():
+    """Test basic sliding window functionality."""
+    print("\n=== Testing Basic Sliding Window (FIFO) ===")
+    
+    # Create manager with small window for testing
+    manager = ConversationManager(max_turns=3)
+    
+    # Add 3 turns (should all fit)
+    id1 = manager.add_turn("Hello, how are you?", "I'm doing well, thanks!")
+    print(f"✓ Added turn 1: {id1[:8]}...")
+    
+    id2 = manager.add_turn("Can you help me with Python?", "Of course! What do you need?")
+    print(f"✓ Added turn 2: {id2[:8]}...")
+    
+    id3 = manager.add_turn("How do I read a file?", "Use open('file.txt', 'r')")
+    print(f"✓ Added turn 3: {id3[:8]}...")
+    
+    # Check we have 3 turns
+    state = manager.get_state()
+    assert len(state.turns) == 3
+    assert state.total_turns_ever == 3
+    print("✓ All 3 turns stored (window not exceeded)")
+    
+    # Add 4th turn - should trigger FIFO deletion
+    print("\n--- Adding 4th turn (should delete oldest) ---")
+    id4 = manager.add_turn("What about writing?", "Use open('file.txt', 'w')")
+    print(f"✓ Added turn 4: {id4[:8]}...")
+    
+    # Check we still have 3 turns, but turn 1 is gone
+    state = manager.get_state()
+    assert len(state.turns) == 3
+    assert state.total_turns_ever == 4
+    assert state.turns[0].id == id2  # Turn 1 deleted, turn 2 is now oldest
+    assert state.turns[-1].id == id4  # Turn 4 is newest
+    print("✓ FIFO worked: Turn 1 deleted, turns 2-4 kept intact")
+    print(f"✓ Total turns ever: {state.total_turns_ever} (1 deleted, 3 kept)")
+
+
+def test_no_summarization_loss():
+    """Test that no information is lost through summarization."""
+    print("\n=== Testing No Summarization Loss ===")
+    
+    manager = ConversationManager(max_turns=2)
+    
+    # Add turn with specific error code
+    specific_message = "I tried X and it failed with error code 500"
+    specific_response = "Error 500 is an internal server error. Check your logs at /var/log/app.log"
+    manager.add_turn(specific_message, specific_response)
+    print(f"✓ Added turn with specific error code: 500")
+    
+    # Get history - should have EXACT message
+    history = manager.get_conversation_history(format_as_text=False)
+    assert history[0].user_message == specific_message
+    assert "500" in history[0].user_message
+    assert "/var/log/app.log" in history[0].ai_response
+    print("✓ Exact message preserved (no lossy summarization)")
+    print(f"  Original: '{specific_message}'")
+    print(f"  Retrieved: '{history[0].user_message}'")
+    print("  ✅ Perfect match! No detail lost!")
+    
+    # Add 2 more turns to push the first one out
+    manager.add_turn("Another question", "Another answer")
+    manager.add_turn("Yet another question", "Yet another answer")
+    
+    # First turn should be gone, but recent turns are PERFECTLY intact
+    history = manager.get_conversation_history(format_as_text=False)
+    assert len(history) == 2
+    assert history[0].user_message == "Another question"
+    assert history[1].user_message == "Yet another question"
+    print("\n✓ After FIFO deletion:")
+    print(f"  - First turn (with error 500) is deleted")
+    print(f"  - Recent 2 turns are PERFECTLY intact")
+    print(f"  - No summarization = No information loss")
+
+
+def test_recent_turns_priority():
+    """Test that recent turns take priority."""
+    print("\n=== Testing Recent Turns Priority ===")
+    
+    manager = ConversationManager(max_turns=5)
+    
+    # Simulate conversation over time
+    turns = [
+        ("20 minutes ago: Old question", "Old answer"),
+        ("15 minutes ago: Another old question", "Another old answer"),
+        ("10 minutes ago: Yet another old", "Yet another old answer"),
+        ("5 minutes ago: Getting recent", "Recent answer"),
+        ("1 minute ago: Very recent", "Very recent answer"),
+        ("30 seconds ago: Code snippet: def foo():", "That's a function definition"),
+    ]
+    
+    for user_msg, ai_msg in turns:
+        manager.add_turn(user_msg, ai_msg)
+    
+    # Should have last 5 turns
+    history = manager.get_conversation_history(format_as_text=False)
+    assert len(history) == 5
+    assert "Old question" not in history[0].user_message  # First turn deleted
+    assert "Code snippet" in history[-1].user_message  # Most recent kept
+    print("✓ Recent precision maintained")
+    print(f"  - Oldest turn kept: '{history[0].user_message[:30]}...'")
+    print(f"  - Newest turn kept: '{history[-1].user_message[:30]}...'")
+    print("  ✅ User can still see their exact code snippet from 30 seconds ago!")
+
+
+def test_get_recent_turns():
+    """Test getting N most recent turns."""
+    print("\n=== Testing Get Recent Turns ===")
+    
+    manager = ConversationManager(max_turns=10)
+    
+    # Add 10 turns
+    for i in range(10):
+        manager.add_turn(f"Question {i+1}", f"Answer {i+1}")
+    
+    # Get last 3 turns
+    recent = manager.get_recent_turns(n=3)
+    assert len(recent) == 3
+    assert "Question 8" in recent[0].user_message
+    assert "Question 9" in recent[1].user_message
+    assert "Question 10" in recent[2].user_message
+    print("✓ Got last 3 turns correctly")
+    
+    # Get recent turns when we have fewer than requested
+    manager.clear_conversation()
+    manager.add_turn("Only one", "Only one answer")
+    recent = manager.get_recent_turns(n=5)
+    assert len(recent) == 1
+    print("✓ Handles case where we have fewer turns than requested")
+
+
+def test_update_turn_response():
+    """Test updating a turn's AI response."""
+    print("\n=== Testing Update Turn Response ===")
+    
+    manager = ConversationManager(max_turns=5)
+    
+    # Add turn without AI response
+    turn_id = manager.add_turn("What is Python?")
+    print(f"✓ Added turn without AI response: {turn_id[:8]}...")
+    
+    # Update with AI response
+    success = manager.update_turn_response(turn_id, "Python is a programming language")
+    assert success
+    print("✓ Updated turn with AI response")
+    
+    # Verify update
+    history = manager.get_conversation_history(format_as_text=False)
+    assert history[0].ai_response == "Python is a programming language"
+    print("✓ AI response correctly updated")
+    
+    # Try updating non-existent turn
+    success = manager.update_turn_response("fake-id", "Fake response")
+    assert not success
+    print("✓ Correctly handles non-existent turn ID")
+
+
+def test_conversation_statistics():
+    """Test conversation statistics."""
+    print("\n=== Testing Conversation Statistics ===")
+    
+    manager = ConversationManager(max_turns=3)
+    
+    # Add 5 turns (2 should be deleted)
+    for i in range(5):
+        manager.add_turn(f"Question {i+1}", f"Answer {i+1}")
+    
+    stats = manager.get_statistics()
+    assert stats["current_turns"] == 3
+    assert stats["max_turns"] == 3
+    assert stats["total_turns_ever"] == 5
+    assert stats["deleted_turns"] == 2
+    print("✓ Statistics correctly calculated:")
+    print(f"  - Current turns: {stats['current_turns']}")
+    print(f"  - Max turns: {stats['max_turns']}")
+    print(f"  - Total turns ever: {stats['total_turns_ever']}")
+    print(f"  - Deleted turns: {stats['deleted_turns']}")
+    print(f"  ✅ Sliding window deleted {stats['deleted_turns']} old turns, kept {stats['current_turns']} recent!")
+
+
+def test_formatted_output():
+    """Test formatted text output."""
+    print("\n=== Testing Formatted Output ===")
+    
+    manager = ConversationManager(max_turns=3)
+    
+    # Add some turns
+    manager.add_turn("Hello", "Hi there!", {"source": "user"})
+    manager.add_turn("How are you?", "I'm great!", {"source": "user"})
+    
+    # Get formatted text
+    text = manager.get_conversation_history(format_as_text=True, include_metadata=True)
+    assert "Conversation History" in text
+    assert "Sliding Window" in text
+    assert "Hello" in text
+    assert "Hi there!" in text
+    assert "source" in text
+    print("✓ Formatted output looks good:")
+    print(text)
+
+
+def test_clear_conversation():
+    """Test clearing conversation."""
+    print("\n=== Testing Clear Conversation ===")
+    
+    manager = ConversationManager(max_turns=5)
+    
+    # Add some turns
+    for i in range(3):
+        manager.add_turn(f"Question {i+1}", f"Answer {i+1}")
+    
+    assert len(manager.get_state().turns) == 3
+    print("✓ Added 3 turns")
+    
+    # Clear
+    manager.clear_conversation()
+    assert len(manager.get_state().turns) == 0
+    print("✓ Conversation cleared")
+    
+    # Total turns ever should still be 3
+    assert manager.get_state().total_turns_ever == 3
+    print("✓ Total turns ever counter preserved")
+
+
+def test_state_management():
+    """Test state get/set."""
+    print("\n=== Testing State Management ===")
+    
+    manager1 = ConversationManager(max_turns=5)
+    manager1.add_turn("Question 1", "Answer 1")
+    manager1.add_turn("Question 2", "Answer 2")
+    
+    # Get state
+    state = manager1.get_state()
+    assert len(state.turns) == 2
+    print("✓ Got state from manager 1")
+    
+    # Create new manager and set state
+    manager2 = ConversationManager(max_turns=5)
+    manager2.set_state(state)
+    assert len(manager2.get_state().turns) == 2
+    print("✓ Set state on manager 2")
+    
+    # Verify turns are the same
+    assert manager2.get_state().turns[0].user_message == "Question 1"
+    print("✓ State correctly transferred between managers")
+
+
+def run_all_tests():
+    """Run all conversation manager tests."""
+    print("\n" + "="*70)
+    print("CONVERSATION MANAGER TEST SUITE")
+    print("Testing: The Brutal Squeeze (Chopping > Summarizing)")
+    print("="*70)
+    
+    test_basic_sliding_window()
+    test_no_summarization_loss()
+    test_recent_turns_priority()
+    test_get_recent_turns()
+    test_update_turn_response()
+    test_conversation_statistics()
+    test_formatted_output()
+    test_clear_conversation()
+    test_state_management()
+    
+    print("\n" + "="*70)
+    print("✅ ALL TESTS PASSED!")
+    print("="*70)
+    print("\nKey Takeaways:")
+    print("1. ✅ Sliding Window (FIFO) keeps recent turns PERFECTLY intact")
+    print("2. ✅ No summarization = No information loss")
+    print("3. ✅ Users can see exact code snippets from 30 seconds ago")
+    print("4. ✅ Zero AI cost for context management")
+    print("5. ✅ Predictable behavior: Always know what's in context")
+    print("\n🎯 Recent Precision > Vague History!")
+
+
+if __name__ == "__main__":
+    run_all_tests()