mcal-ai-crewai 0.2.0__tar.gz

mcal_ai_crewai-0.2.0/.gitignore

@@ -0,0 +1,57 @@
+aws_config.env
+*.pem
+instance_info.txt
+.env
+
+# Deployment artifacts
+*.tar.gz
+*.zip
+
+# Backup folders
+backup_feb2_2026/
+backup_*/
+
+# Python cache
+__pycache__/
+*.pyc
+*.pyo
+.pytest_cache/
+
+# Virtual environment
+.venv/
+venv/
+
+# Logs
+logs/
+
+# IDE
+.idea/
+.vscode/
+
+# OS files
+.DS_Store
+
+# Build artifacts
+*.egg-info/
+dist/
+build/
+.coverage
+htmlcov/
+
+# Test data and outputs
+mcal_data/
+results/*.json
+experiments/__pycache__/
+
+# Local development folders (archived)
+docs/
+data/
+experiments/
+
+# Debug output files
+debug_output.txt
+validation_output.txt
+*.log
+
+# Temporary PR body
+.github/pr_body.md

mcal_ai_crewai-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shiva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcal_ai_crewai-0.2.0/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: mcal-ai-crewai
+Version: 0.2.0
+Summary: CrewAI integration for MCAL - Goal-aware memory for AI agent crews
+Project-URL: Homepage, https://github.com/Shivakoreddi/mcal-ai
+Project-URL: Documentation, https://github.com/Shivakoreddi/mcal-ai/docs
+Project-URL: Repository, https://github.com/Shivakoreddi/mcal-ai
+Author: MCAL Team
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,crewai,goal-tracking,mcal,memory
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: crewai>=0.100.0
+Requires-Dist: mcal-ai>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# mcal-crewai
+
+Goal-aware memory integration for CrewAI agent crews.
+
+## Installation
+
+```bash
+pip install mcal-crewai
+```
+
+## Quick Start
+
+### Using MCALStorage (Mem0-style)
+
+MCAL provides a storage backend that integrates directly with CrewAI's memory system:
+
+```python
+from crewai import Crew, Agent, Task, Process
+from crewai.memory.short_term.short_term_memory import ShortTermMemory
+from crewai.memory.long_term.long_term_memory import LongTermMemory
+from crewai.memory.entity.entity_memory import EntityMemory
+from mcal_crewai import MCALStorage
+
+# Create MCAL-backed memories
+short_term = ShortTermMemory(
+    storage=MCALStorage(type="short_term", user_id="john")
+)
+long_term = LongTermMemory(
+    storage=MCALStorage(type="long_term", user_id="john")
+)
+entity_memory = EntityMemory(
+    storage=MCALStorage(type="entities", user_id="john")
+)
+
+# Use with CrewAI
+crew = Crew(
+    agents=[agent],
+    tasks=[task],
+    memory=True,
+    short_term_memory=short_term,
+    long_term_memory=long_term,
+    entity_memory=entity_memory,
+)
+```
+
+### Using External Memory
+
+For cross-session persistence with goal awareness:
+
+```python
+from crewai.memory.external.external_memory import ExternalMemory
+from mcal_crewai import MCALStorage
+
+external = ExternalMemory(
+    embedder_config={
+        "provider": "mcal",
+        "config": {
+            "user_id": "john",
+            "llm_provider": "anthropic",
+            "enable_goal_tracking": True,
+        }
+    }
+)
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    external_memory=external,
+    process=Process.sequential,
+)
+```
+
+## Features
+
+### Goal-Aware Memory
+Unlike basic memory systems, MCAL tracks user goals and priorities:
+
+```python
+storage = MCALStorage(
+    type="long_term",
+    user_id="project_manager",
+    config={
+        "enable_goal_tracking": True,
+        "extract_priorities": True,
+    }
+)
+```
+
+### Context Preservation
+MCAL maintains reasoning context across agent handoffs:
+
+```python
+# Agent 1 saves with context
+await storage.save(
+    "Research findings on market trends",
+    metadata={
+        "agent": "researcher",
+        "goal": "market_analysis",
+        "confidence": 0.95
+    }
+)
+
+# Agent 2 retrieves with goal awareness
+results = await storage.search(
+    "What do we know about market trends?",
+    limit=5,
+    score_threshold=0.7
+)
+```
+
+### TTL Support
+Automatic expiration for short-term memories:
+
+```python
+storage = MCALStorage(
+    type="short_term",
+    user_id="session_user",
+    default_ttl=3600,  # 1 hour
+)
+```
+
+## Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `type` | str | required | Memory type: "short_term", "long_term", "entities", "external" |
+| `user_id` | str | "default" | User identifier for memory isolation |
+| `llm_provider` | str | "anthropic" | LLM for goal extraction |
+| `embedding_provider` | str | "openai" | Embedding model provider |
+| `default_ttl` | int | None | Default TTL in seconds |
+| `enable_goal_tracking` | bool | True | Enable goal extraction |
+
+## API Reference
+
+### MCALStorage
+
+```python
+class MCALStorage(Storage):
+    """MCAL storage backend for CrewAI memory."""
+    
+    def save(self, value: Any, metadata: dict) -> None:
+        """Save value with goal-aware processing."""
+    
+    def search(
+        self, 
+        query: str, 
+        limit: int = 5, 
+        score_threshold: float = 0.6
+    ) -> list:
+        """Search with goal-aware relevance."""
+    
+    def reset(self) -> None:
+        """Clear all stored memories."""
+```
+
+## Comparison with Mem0
+
+| Feature | Mem0 | MCAL |
+|---------|------|------|
+| Basic Memory | ✓ | ✓ |
+| Goal Tracking | ✗ | ✓ |
+| Priority Extraction | ✗ | ✓ |
+| Context Preservation | ✗ | ✓ |
+| TTL Support | ✗ | ✓ |
+| Local Storage | ✓ | ✓ |
+| Cloud API | ✓ | Coming |
+
+## License
+
+MIT License

mcal_ai_crewai-0.2.0/README.md

@@ -0,0 +1,170 @@
+# mcal-crewai
+
+Goal-aware memory integration for CrewAI agent crews.
+
+## Installation
+
+```bash
+pip install mcal-crewai
+```
+
+## Quick Start
+
+### Using MCALStorage (Mem0-style)
+
+MCAL provides a storage backend that integrates directly with CrewAI's memory system:
+
+```python
+from crewai import Crew, Agent, Task, Process
+from crewai.memory.short_term.short_term_memory import ShortTermMemory
+from crewai.memory.long_term.long_term_memory import LongTermMemory
+from crewai.memory.entity.entity_memory import EntityMemory
+from mcal_crewai import MCALStorage
+
+# Create MCAL-backed memories
+short_term = ShortTermMemory(
+    storage=MCALStorage(type="short_term", user_id="john")
+)
+long_term = LongTermMemory(
+    storage=MCALStorage(type="long_term", user_id="john")
+)
+entity_memory = EntityMemory(
+    storage=MCALStorage(type="entities", user_id="john")
+)
+
+# Use with CrewAI
+crew = Crew(
+    agents=[agent],
+    tasks=[task],
+    memory=True,
+    short_term_memory=short_term,
+    long_term_memory=long_term,
+    entity_memory=entity_memory,
+)
+```
+
+### Using External Memory
+
+For cross-session persistence with goal awareness:
+
+```python
+from crewai.memory.external.external_memory import ExternalMemory
+from mcal_crewai import MCALStorage
+
+external = ExternalMemory(
+    embedder_config={
+        "provider": "mcal",
+        "config": {
+            "user_id": "john",
+            "llm_provider": "anthropic",
+            "enable_goal_tracking": True,
+        }
+    }
+)
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    external_memory=external,
+    process=Process.sequential,
+)
+```
+
+## Features
+
+### Goal-Aware Memory
+Unlike basic memory systems, MCAL tracks user goals and priorities:
+
+```python
+storage = MCALStorage(
+    type="long_term",
+    user_id="project_manager",
+    config={
+        "enable_goal_tracking": True,
+        "extract_priorities": True,
+    }
+)
+```
+
+### Context Preservation
+MCAL maintains reasoning context across agent handoffs:
+
+```python
+# Agent 1 saves with context
+await storage.save(
+    "Research findings on market trends",
+    metadata={
+        "agent": "researcher",
+        "goal": "market_analysis",
+        "confidence": 0.95
+    }
+)
+
+# Agent 2 retrieves with goal awareness
+results = await storage.search(
+    "What do we know about market trends?",
+    limit=5,
+    score_threshold=0.7
+)
+```
+
+### TTL Support
+Automatic expiration for short-term memories:
+
+```python
+storage = MCALStorage(
+    type="short_term",
+    user_id="session_user",
+    default_ttl=3600,  # 1 hour
+)
+```
+
+## Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `type` | str | required | Memory type: "short_term", "long_term", "entities", "external" |
+| `user_id` | str | "default" | User identifier for memory isolation |
+| `llm_provider` | str | "anthropic" | LLM for goal extraction |
+| `embedding_provider` | str | "openai" | Embedding model provider |
+| `default_ttl` | int | None | Default TTL in seconds |
+| `enable_goal_tracking` | bool | True | Enable goal extraction |
+
+## API Reference
+
+### MCALStorage
+
+```python
+class MCALStorage(Storage):
+    """MCAL storage backend for CrewAI memory."""
+    
+    def save(self, value: Any, metadata: dict) -> None:
+        """Save value with goal-aware processing."""
+    
+    def search(
+        self, 
+        query: str, 
+        limit: int = 5, 
+        score_threshold: float = 0.6
+    ) -> list:
+        """Search with goal-aware relevance."""
+    
+    def reset(self) -> None:
+        """Clear all stored memories."""
+```
+
+## Comparison with Mem0
+
+| Feature | Mem0 | MCAL |
+|---------|------|------|
+| Basic Memory | ✓ | ✓ |
+| Goal Tracking | ✗ | ✓ |
+| Priority Extraction | ✗ | ✓ |
+| Context Preservation | ✗ | ✓ |
+| TTL Support | ✗ | ✓ |
+| Local Storage | ✓ | ✓ |
+| Cloud API | ✓ | Coming |
+
+## License
+
+MIT License

mcal_ai_crewai-0.2.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mcal-ai-crewai"
+version = "0.2.0"
+description = "CrewAI integration for MCAL - Goal-aware memory for AI agent crews"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "MCAL Team" }
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+keywords = ["mcal", "crewai", "memory", "agents", "ai", "goal-tracking"]
+
+dependencies = [
+    "mcal-ai>=0.1.0",
+    "crewai>=0.100.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Shivakoreddi/mcal-ai"
+Documentation = "https://github.com/Shivakoreddi/mcal-ai/docs"
+Repository = "https://github.com/Shivakoreddi/mcal-ai"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcal_crewai"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+addopts = "-v --tb=short"

mcal_ai_crewai-0.2.0/src/mcal_crewai/__init__.py

@@ -0,0 +1,23 @@
+"""
+MCAL CrewAI Integration
+
+Goal-aware memory for CrewAI agent crews.
+
+Usage:
+    from mcal_crewai import MCALStorage
+    
+    storage = MCALStorage(type="short_term", user_id="john")
+    
+    # Use with CrewAI memory
+    from crewai.memory.short_term.short_term_memory import ShortTermMemory
+    memory = ShortTermMemory(storage=storage)
+"""
+
+from mcal_crewai.storage import MCALStorage
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "MCALStorage",
+    "__version__",
+]

mcal_ai_crewai-0.2.0/src/mcal_crewai/storage.py

@@ -0,0 +1,316 @@
+"""
+MCAL Storage Backend for CrewAI
+
+Implements CrewAI's Storage interface with goal-aware memory.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections.abc import Iterable
+from typing import Any, Optional
+
+# Lazy import for MCAL to avoid circular dependencies
+_mcal_instance: Optional[Any] = None
+_mcal_lock = threading.Lock()
+
+
+def _get_mcal(
+    llm_provider: str = "anthropic",
+    embedding_provider: str = "openai",
+    storage_path: Optional[str] = None,
+    **kwargs
+) -> Any:
+    """Get or create MCAL instance (lazy singleton)."""
+    global _mcal_instance
+    
+    if _mcal_instance is None:
+        with _mcal_lock:
+            if _mcal_instance is None:
+                from mcal import MCAL
+                _mcal_instance = MCAL(
+                    llm_provider=llm_provider,
+                    embedding_provider=embedding_provider,
+                    storage_path=storage_path,
+                    **kwargs
+                )
+    return _mcal_instance
+
+
+class MCALStorage:
+    """
+    MCAL storage backend for CrewAI memory.
+    
+    This class implements CrewAI's Storage interface, providing
+    goal-aware memory with context preservation for agent crews.
+    
+    Compatible with:
+    - ShortTermMemory
+    - LongTermMemory  
+    - EntityMemory
+    - ExternalMemory
+    
+    Usage:
+        from mcal_crewai import MCALStorage
+        from crewai.memory.short_term.short_term_memory import ShortTermMemory
+        
+        storage = MCALStorage(type="short_term", user_id="john")
+        memory = ShortTermMemory(storage=storage)
+        
+    Args:
+        type: Memory type - "short_term", "long_term", "entities", "external"
+        crew: Optional CrewAI Crew instance
+        config: Configuration dictionary with MCAL options
+        user_id: User identifier for memory isolation
+        default_ttl: Default TTL in seconds for memory items
+        enable_goal_tracking: Whether to extract goals from content
+    """
+    
+    SUPPORTED_TYPES = {"short_term", "long_term", "entities", "external"}
+    
+    def __init__(
+        self,
+        type: str,
+        crew: Any = None,
+        config: Optional[dict] = None,
+        user_id: str = "default",
+        default_ttl: Optional[int] = None,
+        enable_goal_tracking: bool = True,
+        **kwargs
+    ):
+        # Validate type
+        if type not in self.SUPPORTED_TYPES:
+            raise ValueError(
+                f"Invalid type '{type}'. Must be one of: {', '.join(self.SUPPORTED_TYPES)}"
+            )
+        
+        self.memory_type = type
+        self.crew = crew
+        self.config = config or {}
+        # user_id priority: explicit param > config > default
+        self.user_id = user_id if user_id != "default" else self.config.get("user_id", user_id)
+        self.default_ttl = default_ttl
+        self.enable_goal_tracking = enable_goal_tracking
+        
+        # Extract config values
+        self.llm_provider = self.config.get("llm_provider", "anthropic")
+        self.embedding_provider = self.config.get("embedding_provider", "openai")
+        self.storage_path = self.config.get("storage_path")
+        
+        # TTL tracking (lazy expiration)
+        self._ttl: dict[str, int] = {}  # key -> ttl_seconds
+        self._expires_at: dict[str, float] = {}  # key -> expiration_timestamp
+        
+        # Thread safety
+        self._lock = threading.RLock()
+        
+        # Internal storage (in-memory for now, will use MCAL graph later)
+        self._data: dict[str, dict[str, Any]] = {}
+        
+        # MCAL instance (lazy loaded)
+        self._mcal: Optional[Any] = None
+    
+    @property
+    def mcal(self) -> Any:
+        """Lazy load MCAL instance."""
+        if self._mcal is None:
+            self._mcal = _get_mcal(
+                llm_provider=self.llm_provider,
+                embedding_provider=self.embedding_provider,
+                storage_path=self.storage_path,
+            )
+        return self._mcal
+    
+    def _generate_key(self, value: Any, metadata: dict) -> str:
+        """Generate a unique key for storage."""
+        import hashlib
+        content = str(value) + str(metadata)
+        return hashlib.sha256(content.encode()).hexdigest()[:16]
+    
+    def _is_expired(self, key: str) -> bool:
+        """Check if a key has expired."""
+        if key not in self._expires_at:
+            return False
+        return time.time() > self._expires_at[key]
+    
+    def _set_ttl(self, key: str, ttl: Optional[int] = None) -> None:
+        """Set TTL for a key."""
+        ttl_value = ttl or self.default_ttl
+        if ttl_value is not None:
+            self._ttl[key] = ttl_value
+            self._expires_at[key] = time.time() + ttl_value
+    
+    def _cleanup_expired(self) -> None:
+        """Remove expired entries (lazy cleanup)."""
+        expired_keys = [
+            key for key in self._expires_at 
+            if time.time() > self._expires_at[key]
+        ]
+        for key in expired_keys:
+            self._data.pop(key, None)
+            self._ttl.pop(key, None)
+            self._expires_at.pop(key, None)
+    
+    def _extract_last_content(
+        self, 
+        messages: Iterable[dict[str, Any]], 
+        role: str
+    ) -> str:
+        """Extract last message content for a given role."""
+        return next(
+            (
+                m.get("content", "")
+                for m in reversed(list(messages))
+                if m.get("role") == role
+            ),
+            "",
+        )
+    
+    def _get_agent_name(self) -> str:
+        """Get current agent name from crew context."""
+        if self.crew and hasattr(self.crew, "_current_agent"):
+            agent = self.crew._current_agent
+            if agent and hasattr(agent, "role"):
+                return str(agent.role)
+        return self.config.get("agent_id", "default_agent")
+    
+    def save(self, value: Any, metadata: dict[str, Any]) -> None:
+        """
+        Save a value to MCAL storage.
+        
+        Args:
+            value: The content to save (string, dict, or conversation)
+            metadata: Additional metadata (agent, task, etc.)
+        """
+        with self._lock:
+            # Generate key
+            key = self._generate_key(value, metadata)
+            
+            # Process value based on type
+            if isinstance(value, dict) and "messages" in value:
+                # Conversation format
+                messages = value.get("messages", [])
+                content = self._extract_last_content(messages, "assistant")
+                if not content:
+                    content = self._extract_last_content(messages, "user")
+            elif isinstance(value, str):
+                content = value
+            else:
+                content = str(value)
+            
+            # Build storage entry
+            entry = {
+                "content": content,
+                "raw_value": value,
+                "metadata": {
+                    "type": self.memory_type,
+                    "user_id": self.user_id,
+                    "agent": self._get_agent_name(),
+                    "timestamp": time.time(),
+                    **metadata,
+                },
+            }
+            
+            # Extract goals if enabled
+            if self.enable_goal_tracking and content:
+                entry["metadata"]["goal_tracked"] = True
+                # TODO: Use MCAL's goal extraction when integrated
+                # goals = self.mcal.extract_goals(content)
+                # entry["metadata"]["goals"] = goals
+            
+            # Store with TTL
+            self._data[key] = entry
+            
+            # Set TTL if configured
+            ttl = metadata.get("ttl") or self.default_ttl
+            if ttl:
+                self._set_ttl(key, ttl)
+            
+            # Short-term memory gets default TTL if not set
+            if self.memory_type == "short_term" and key not in self._ttl:
+                self._set_ttl(key, 3600)  # 1 hour default for short-term
+    
+    def search(
+        self, 
+        query: str, 
+        limit: int = 5, 
+        score_threshold: float = 0.6
+    ) -> list[Any]:
+        """
+        Search storage for relevant content.
+        
+        Args:
+            query: Search query
+            limit: Maximum results to return
+            score_threshold: Minimum relevance score (0-1)
+            
+        Returns:
+            List of matching results with 'content' key
+        """
+        with self._lock:
+            # Cleanup expired entries
+            self._cleanup_expired()
+            
+            # Simple keyword-based search for now
+            # TODO: Use MCAL's semantic search when integrated
+            results = []
+            query_lower = query.lower()
+            query_words = set(query_lower.split())
+            
+            for key, entry in self._data.items():
+                # Skip expired
+                if self._is_expired(key):
+                    continue
+                
+                content = entry.get("content", "")
+                content_lower = content.lower()
+                
+                # Calculate simple relevance score
+                content_words = set(content_lower.split())
+                overlap = query_words & content_words
+                
+                if overlap:
+                    score = len(overlap) / max(len(query_words), 1)
+                    
+                    if score >= score_threshold:
+                        results.append({
+                            "content": content,
+                            "memory": content,  # Compatibility with Mem0 format
+                            "score": score,
+                            "metadata": entry.get("metadata", {}),
+                        })
+            
+            # Sort by score and limit
+            results.sort(key=lambda x: x["score"], reverse=True)
+            return results[:limit]
+    
+    def reset(self) -> None:
+        """Clear all stored memories for this type."""
+        with self._lock:
+            self._data.clear()
+            self._ttl.clear()
+            self._expires_at.clear()
+    
+    def get_all(self) -> list[dict[str, Any]]:
+        """Get all non-expired entries."""
+        with self._lock:
+            self._cleanup_expired()
+            return [
+                entry for key, entry in self._data.items()
+                if not self._is_expired(key)
+            ]
+    
+    def delete(self, key: str) -> bool:
+        """Delete a specific entry by key."""
+        with self._lock:
+            if key in self._data:
+                del self._data[key]
+                self._ttl.pop(key, None)
+                self._expires_at.pop(key, None)
+                return True
+            return False
+
+
+# Alias for backward compatibility
+MCALMemoryStorage = MCALStorage

mcal_ai_crewai-0.2.0/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for mcal-crewai package."""

mcal_ai_crewai-0.2.0/tests/test_storage.py

@@ -0,0 +1,310 @@
+"""
+Tests for MCALStorage - CrewAI Storage backend.
+"""
+
+import pytest
+import time
+from unittest.mock import MagicMock, patch
+
+from mcal_crewai import MCALStorage
+
+
+class TestMCALStorageInit:
+    """Test MCALStorage initialization."""
+    
+    def test_init_with_valid_type(self):
+        """Test initialization with valid memory types."""
+        for memory_type in ["short_term", "long_term", "entities", "external"]:
+            storage = MCALStorage(type=memory_type)
+            assert storage.memory_type == memory_type
+    
+    def test_init_with_invalid_type(self):
+        """Test initialization with invalid type raises error."""
+        with pytest.raises(ValueError, match="Invalid type"):
+            MCALStorage(type="invalid_type")
+    
+    def test_init_with_user_id(self):
+        """Test initialization with user_id."""
+        storage = MCALStorage(type="short_term", user_id="test_user")
+        assert storage.user_id == "test_user"
+    
+    def test_init_with_config_user_id(self):
+        """Test user_id from config."""
+        storage = MCALStorage(
+            type="short_term",
+            config={"user_id": "config_user"}
+        )
+        assert storage.user_id == "config_user"
+    
+    def test_init_with_default_ttl(self):
+        """Test initialization with default TTL."""
+        storage = MCALStorage(type="short_term", default_ttl=3600)
+        assert storage.default_ttl == 3600
+    
+    def test_init_goal_tracking_enabled(self):
+        """Test goal tracking is enabled by default."""
+        storage = MCALStorage(type="short_term")
+        assert storage.enable_goal_tracking is True
+    
+    def test_init_goal_tracking_disabled(self):
+        """Test goal tracking can be disabled."""
+        storage = MCALStorage(type="short_term", enable_goal_tracking=False)
+        assert storage.enable_goal_tracking is False
+
+
+class TestMCALStorageSave:
+    """Test MCALStorage save operations."""
+    
+    def test_save_string_value(self):
+        """Test saving a simple string."""
+        storage = MCALStorage(type="long_term", user_id="test")
+        storage.save("Test content", {"agent": "researcher"})
+        
+        results = storage.get_all()
+        assert len(results) == 1
+        assert results[0]["content"] == "Test content"
+    
+    def test_save_with_metadata(self):
+        """Test metadata is preserved."""
+        storage = MCALStorage(type="long_term", user_id="test")
+        storage.save("Content", {"agent": "writer", "task": "summarize"})
+        
+        results = storage.get_all()
+        assert results[0]["metadata"]["agent"] == "writer"
+        assert results[0]["metadata"]["task"] == "summarize"
+    
+    def test_save_conversation_format(self):
+        """Test saving conversation format (messages list)."""
+        storage = MCALStorage(type="short_term", user_id="test")
+        
+        conversation = {
+            "messages": [
+                {"role": "user", "content": "What is the weather?"},
+                {"role": "assistant", "content": "It's sunny today."}
+            ]
+        }
+        storage.save(conversation, {})
+        
+        results = storage.get_all()
+        assert len(results) == 1
+        assert "sunny" in results[0]["content"]
+    
+    def test_save_with_explicit_ttl(self):
+        """Test saving with explicit TTL in metadata."""
+        storage = MCALStorage(type="short_term", user_id="test")
+        storage.save("Temporary", {"ttl": 60})
+        
+        # Check TTL was set
+        assert len(storage._ttl) == 1
+        assert len(storage._expires_at) == 1
+
+
+class TestMCALStorageSearch:
+    """Test MCALStorage search operations."""
+    
+    def test_search_finds_matching_content(self):
+        """Test search finds relevant content."""
+        storage = MCALStorage(type="long_term", user_id="test")
+        storage.save("Python is a programming language", {})
+        storage.save("JavaScript runs in browsers", {})
+        
+        results = storage.search("Python programming")
+        assert len(results) >= 1
+        assert "Python" in results[0]["content"]
+    
+    def test_search_respects_limit(self):
+        """Test search respects limit parameter."""
+        storage = MCALStorage(type="long_term", user_id="test")
+        for i in range(10):
+            storage.save(f"Document {i} about Python", {})
+        
+        results = storage.search("Python", limit=3)
+        assert len(results) <= 3
+    
+    def test_search_returns_empty_for_no_match(self):
+        """Test search returns empty for no matches."""
+        storage = MCALStorage(type="long_term", user_id="test")
+        storage.save("Python is great", {})
+        
+        results = storage.search("completely unrelated xyz")
+        assert len(results) == 0
+    
+    def test_search_includes_score(self):
+        """Test search results include relevance score."""
+        storage = MCALStorage(type="long_term", user_id="test")
+        storage.save("Python programming tutorial", {})
+        
+        results = storage.search("Python programming")
+        assert len(results) >= 1
+        assert "score" in results[0]
+        assert 0 <= results[0]["score"] <= 1
+    
+    def test_search_skips_expired_content(self):
+        """Test search skips expired content."""
+        storage = MCALStorage(type="short_term", user_id="test")
+        
+        # Save with very short TTL
+        storage.save("Expired content about cats", {"ttl": 1})
+        storage.save("Valid content about dogs", {})
+        
+        # Wait for expiration
+        time.sleep(1.1)
+        
+        results = storage.search("cats dogs")
+        # Should only find dogs, not cats
+        for result in results:
+            assert "cats" not in result["content"].lower()
+
+
+class TestMCALStorageTTL:
+    """Test TTL (Time-To-Live) functionality."""
+    
+    def test_ttl_expiration(self):
+        """Test items expire after TTL."""
+        storage = MCALStorage(type="short_term", default_ttl=1)
+        storage.save("Temporary data", {})
+        
+        # Should exist initially
+        assert len(storage.get_all()) == 1
+        
+        # Wait for expiration
+        time.sleep(1.1)
+        
+        # Should be gone
+        assert len(storage.get_all()) == 0
+    
+    def test_no_ttl_means_no_expiration(self):
+        """Test items without TTL don't expire."""
+        storage = MCALStorage(type="long_term")  # No default_ttl
+        storage.save("Permanent data", {})
+        
+        # Should persist
+        assert len(storage.get_all()) == 1
+        
+        # Clear TTL tracking to ensure no expiration
+        storage._expires_at.clear()
+        
+        time.sleep(0.1)
+        assert len(storage.get_all()) == 1
+    
+    def test_short_term_gets_default_ttl(self):
+        """Test short_term memory gets default TTL."""
+        storage = MCALStorage(type="short_term")
+        storage.save("Short term data", {})
+        
+        # Should have TTL set (1 hour default)
+        assert len(storage._ttl) == 1
+
+
+class TestMCALStorageReset:
+    """Test reset functionality."""
+    
+    def test_reset_clears_all_data(self):
+        """Test reset clears all stored data."""
+        storage = MCALStorage(type="long_term", user_id="test")
+        storage.save("Data 1", {})
+        storage.save("Data 2", {})
+        
+        assert len(storage.get_all()) == 2
+        
+        storage.reset()
+        
+        assert len(storage.get_all()) == 0
+    
+    def test_reset_clears_ttl_tracking(self):
+        """Test reset clears TTL tracking."""
+        storage = MCALStorage(type="short_term", default_ttl=3600)
+        storage.save("Data", {})
+        
+        assert len(storage._ttl) == 1
+        assert len(storage._expires_at) == 1
+        
+        storage.reset()
+        
+        assert len(storage._ttl) == 0
+        assert len(storage._expires_at) == 0
+
+
+class TestMCALStorageDelete:
+    """Test delete functionality."""
+    
+    def test_delete_existing_key(self):
+        """Test deleting an existing key."""
+        storage = MCALStorage(type="long_term")
+        storage.save("Test data", {})
+        
+        keys = list(storage._data.keys())
+        assert len(keys) == 1
+        
+        result = storage.delete(keys[0])
+        assert result is True
+        assert len(storage.get_all()) == 0
+    
+    def test_delete_nonexistent_key(self):
+        """Test deleting a nonexistent key."""
+        storage = MCALStorage(type="long_term")
+        
+        result = storage.delete("nonexistent_key")
+        assert result is False
+
+
+class TestMCALStorageThreadSafety:
+    """Test thread safety."""
+    
+    def test_storage_has_lock(self):
+        """Test storage has RLock for thread safety."""
+        storage = MCALStorage(type="long_term")
+        assert hasattr(storage, "_lock")
+        assert isinstance(storage._lock, type(storage._lock))
+
+
+class TestMCALStorageMemoryFormat:
+    """Test compatibility with CrewAI memory format."""
+    
+    def test_search_returns_memory_key(self):
+        """Test search results have 'memory' key for Mem0 compatibility."""
+        storage = MCALStorage(type="long_term")
+        storage.save("Test content for memory", {})
+        
+        results = storage.search("memory")
+        assert len(results) >= 1
+        assert "memory" in results[0]
+        assert results[0]["memory"] == results[0]["content"]
+
+
+class TestMCALStorageMetadataExtraction:
+    """Test metadata extraction."""
+    
+    def test_metadata_includes_type(self):
+        """Test metadata includes memory type."""
+        storage = MCALStorage(type="entities")
+        storage.save("Entity data", {})
+        
+        results = storage.get_all()
+        assert results[0]["metadata"]["type"] == "entities"
+    
+    def test_metadata_includes_user_id(self):
+        """Test metadata includes user_id."""
+        storage = MCALStorage(type="long_term", user_id="john")
+        storage.save("User data", {})
+        
+        results = storage.get_all()
+        assert results[0]["metadata"]["user_id"] == "john"
+    
+    def test_metadata_includes_timestamp(self):
+        """Test metadata includes timestamp."""
+        storage = MCALStorage(type="long_term")
+        storage.save("Timestamped data", {})
+        
+        results = storage.get_all()
+        assert "timestamp" in results[0]["metadata"]
+        assert results[0]["metadata"]["timestamp"] > 0
+
+
+class TestMCALStorageBackwardCompatibility:
+    """Test backward compatibility."""
+    
+    def test_alias_exists(self):
+        """Test MCALMemoryStorage alias exists."""
+        from mcal_crewai.storage import MCALMemoryStorage
+        assert MCALMemoryStorage is MCALStorage