acra-cli 0.1.1__py3-none-any.whl

acra/agents/memory/memory_manager.py

@@ -0,0 +1,273 @@
+import json
+import os
+import logging
+import threading
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from acra.config import MEMORY_STORAGE_DIR
+
+
+# memory manager class
+
+class MemoryManager:
+    """
+    Centralized memory management system.
+
+    Responsibilities:
+    - Store workflow memories
+    - Retrieve historical context
+    - Persist execution history
+    - Manage long-term memory
+    - Support autonomous learning
+    """
+
+    def __init__(
+        self,
+        session_id: str = "default_session"
+    ):
+
+        self.session_id = session_id
+        self._lock = threading.Lock()
+        self._max_entries = 500
+
+        self.memory_file = os.path.join(
+            str(MEMORY_STORAGE_DIR),
+            f"{session_id}.json"
+        )
+
+        self.memories = self._load_memories()
+
+
+    # load memories 
+
+    def _load_memories(self) -> List[Dict[str, Any]]:
+        """
+        Load memories from storage.
+        """
+
+        if not os.path.exists(self.memory_file):
+            return []
+
+        try:
+
+            with open(
+                self.memory_file,
+                "r",
+                encoding="utf-8"
+            ) as f:
+
+                return json.load(f)
+
+        except Exception as e:
+            logging.getLogger(__name__).error("MemoryManager._load_memories failed: %s", e, exc_info=True)
+
+            return []
+
+
+    # save memories
+
+    def _save_memories(self) -> None:
+        """
+        Persist memories to disk.
+        """
+
+        try:
+            with open(
+                self.memory_file,
+                "w",
+                encoding="utf-8"
+            ) as f:
+
+                json.dump(
+                    self.memories,
+                    f,
+                    indent=2,
+                    ensure_ascii=False
+                )
+        except Exception as e:
+            logging.getLogger(__name__).error("MemoryManager._save_memories failed: %s", e, exc_info=True)
+
+
+    # add memory 
+
+    def add_memory(
+        self,
+        memory_type: str,
+        content: Dict[str, Any]
+    ) -> None:
+        """
+        Add new memory entry with thread safety and size limits.
+        """
+
+        memory_entry = {
+
+            "timestamp": (
+                datetime.utcnow().isoformat()
+            ),
+
+            "memory_type": memory_type,
+
+            "content": content
+        }
+
+        with self._lock:
+            self.memories.append(memory_entry)
+            if len(self.memories) > self._max_entries:
+                self.memories = self.memories[-self._max_entries:]
+            self._save_memories()
+
+
+    # get all memories
+
+    def get_all_memories(
+        self
+    ) -> List[Dict[str, Any]]:
+        """
+        Return all stored memories.
+        """
+
+        return self.memories
+
+
+    # get memories by type
+
+    def get_memories_by_type(
+        self,
+        memory_type: str
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve memories matching type.
+        """
+
+        return [
+
+            memory
+
+            for memory in self.memories
+
+            if memory.get("memory_type")
+            == memory_type
+        ]
+
+
+    # search memories
+
+    def search_memories(
+        self,
+        keyword: str
+    ) -> List[Dict[str, Any]]:
+        """
+        Keyword-based memory search.
+        """
+
+        keyword = keyword.lower()
+
+        results = []
+
+        for memory in self.memories:
+
+            memory_str = json.dumps(
+                memory
+            ).lower()
+
+            if keyword in memory_str:
+
+                results.append(memory)
+
+        return results
+
+
+    # get recent memories
+
+    def get_recent_memories(
+        self,
+        limit: int = 5
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve most recent memories.
+        """
+
+        return self.memories[-limit:]
+
+
+    # delete memory
+
+    def delete_memory(
+        self,
+        index: int
+    ) -> bool:
+        """
+        Delete memory by index.
+        """
+
+        try:
+
+            del self.memories[index]
+
+            self._save_memories()
+
+            return True
+
+        except Exception:
+
+            return False
+
+
+    # clear memory
+
+    def clear_memory(self) -> None:
+        """
+        Remove all stored memories.
+        """
+
+        self.memories = []
+
+        self._save_memories()
+
+
+    # memory statistics
+
+    def get_memory_stats(self) -> Dict[str, Any]:
+        """
+        Return memory statistics.
+        """
+
+        memory_types = {}
+
+        for memory in self.memories:
+
+            mem_type = memory.get(
+                "memory_type",
+                "unknown"
+            )
+
+            memory_types[mem_type] = (
+                memory_types.get(mem_type, 0)
+                + 1
+            )
+
+        return {
+
+            "session_id": self.session_id,
+
+            "total_memories": len(
+                self.memories
+            ),
+
+            "memory_types": memory_types,
+
+            "memory_file": self.memory_file
+        }
+
+# global memory helper
+
+def get_memory_manager(
+    session_id: str = "default_session"
+) -> MemoryManager:
+    """
+    Returns memory manager instance.
+    """
+
+    return MemoryManager(
+        session_id=session_id
+    )

acra/agents/memory/retrieval.py

@@ -0,0 +1,355 @@
+from typing import Any, Dict, List, Optional
+
+from acra.agents.memory.memory_manager import (
+    get_memory_manager
+)
+
+
+# memory retrieval and context management system
+
+class MemoryRetrieval:
+    """
+    Memory retrieval and context management system.
+
+    Responsibilities:
+    - Retrieve relevant workflow memories
+    - Search historical execution patterns
+    - Support autonomous reasoning
+    - Provide contextual memory to agents
+    """
+
+    def __init__(
+        self,
+        session_id: str = "default_session"
+    ):
+
+        self.memory_manager = (
+            get_memory_manager(session_id)
+        )
+
+
+    # get relevant memories
+
+    def get_relevant_memories(
+        self,
+        query: str,
+        limit: int = 5
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve memories relevant to query.
+        """
+
+        matching_memories = (
+            self.memory_manager.search_memories(
+                query
+            )
+        )
+
+        return matching_memories[:limit]
+
+
+    # get failure memories
+
+    def get_failure_memories(
+        self,
+        limit: int = 5
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve previous failure memories.
+        """
+
+        failure_memories = []
+
+        all_memories = (
+            self.memory_manager.get_all_memories()
+        )
+
+        for memory in all_memories:
+
+            content = memory.get(
+                "content",
+                {}
+            )
+
+            if (
+                content.get("execution_success")
+                is False
+            ):
+
+                failure_memories.append(memory)
+
+        return failure_memories[-limit:]
+
+
+    # get successful patterns
+
+    def get_successful_patterns(
+        self,
+        limit: int = 5
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve successful execution memories.
+        """
+
+        successful_memories = []
+
+        all_memories = (
+            self.memory_manager.get_all_memories()
+        )
+
+        for memory in all_memories:
+
+            content = memory.get(
+                "content",
+                {}
+            )
+
+            quality_score = content.get(
+                "quality_score",
+                0
+            )
+
+            if (
+                content.get("execution_success")
+                is True
+                and quality_score >= 8
+            ):
+
+                successful_memories.append(memory)
+
+        return successful_memories[-limit:]
+
+
+    # get error solutions
+
+    def get_error_solutions(
+        self,
+        error_message: str,
+        limit: int = 3
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve previous fixes for similar errors.
+        """
+
+        matching_solutions = []
+
+        all_memories = (
+            self.memory_manager.get_all_memories()
+        )
+
+        for memory in all_memories:
+
+            content = memory.get(
+                "content",
+                {}
+            )
+
+            previous_error = str(
+                content.get(
+                    "error_message",
+                    ""
+                )
+            ).lower()
+
+            if (
+                error_message.lower()
+                in previous_error
+            ):
+
+                matching_solutions.append(memory)
+
+        return matching_solutions[:limit]
+
+
+    # build context for agent
+
+    def build_context_for_agent(
+        self,
+        agent_name: str,
+        query: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Build contextual memory package
+        for workflow agents.
+        """
+
+        context = {
+
+            "agent_name": agent_name,
+
+            "recent_memories": (
+                self.memory_manager
+                .get_recent_memories(limit=5)
+            ),
+
+            "successful_patterns": (
+                self.get_successful_patterns()
+            ),
+
+            "failure_patterns": (
+                self.get_failure_memories()
+            )
+        }
+
+        # Query-specific memory retrieval
+        if query:
+
+            context["relevant_memories"] = (
+                self.get_relevant_memories(
+                    query=query
+                )
+            )
+
+        return context
+
+
+    # get execution history
+
+    def get_execution_history(
+        self,
+        limit: int = 10
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve workflow execution history.
+        """
+
+        all_memories = (
+            self.memory_manager.get_all_memories()
+        )
+
+        execution_history = []
+
+        for memory in all_memories:
+
+            content = memory.get(
+                "content",
+                {}
+            )
+
+            execution_history.append({
+
+                "timestamp": memory.get(
+                    "timestamp"
+                ),
+
+                "workflow_status": content.get(
+                    "workflow_status"
+                ),
+
+                "execution_success": content.get(
+                    "execution_success"
+                ),
+
+                "quality_score": content.get(
+                    "quality_score"
+                ),
+
+                "retry_count": content.get(
+                    "retry_count"
+                )
+            })
+
+        return execution_history[-limit:]
+
+
+    # get memory insights
+
+    def get_memory_insights(
+        self
+    ) -> Dict[str, Any]:
+        """
+        Analyze workflow memory trends.
+        """
+
+        all_memories = (
+            self.memory_manager.get_all_memories()
+        )
+
+        total_memories = len(all_memories)
+
+        successful_runs = 0
+
+        failed_runs = 0
+
+        avg_quality = 0
+
+        quality_scores = []
+
+        for memory in all_memories:
+
+            content = memory.get(
+                "content",
+                {}
+            )
+
+            if content.get(
+                "execution_success"
+            ) is True:
+
+                successful_runs += 1
+
+            elif content.get(
+                "execution_success"
+            ) is False:
+
+                failed_runs += 1
+
+            score = content.get(
+                "quality_score"
+            )
+
+            if score is not None:
+
+                quality_scores.append(score)
+
+        if quality_scores:
+
+            avg_quality = (
+                sum(quality_scores)
+                / len(quality_scores)
+            )
+
+        success_rate = 0
+
+        total_runs = (
+            successful_runs + failed_runs
+        )
+
+        if total_runs > 0:
+
+            success_rate = (
+                successful_runs / total_runs
+            ) * 100
+
+        return {
+
+            "total_memories": total_memories,
+
+            "successful_runs": successful_runs,
+
+            "failed_runs": failed_runs,
+
+            "success_rate": round(
+                success_rate,
+                2
+            ),
+
+            "average_quality_score": round(
+                avg_quality,
+                2
+            )
+        }
+
+
+#global retrieval helper
+
+def get_memory_retrieval(
+    session_id: str = "default_session"
+) -> MemoryRetrieval:
+    """
+    Returns memory retrieval system.
+    """
+
+    return MemoryRetrieval(
+        session_id=session_id
+    )