Fix: update agents/memory_agent.py

agents/memory_agent.py

@@ -1,10 +1,13 @@
 """
-MemoryAgent — Persistent memory via LLMRouter + SQLite
+MemoryAgent — Persistent long-term memory system (Phase 5)
+SQLite-backed with semantic search simulation
 """
+import json
+import time
+from typing import Dict, List, Optional
 import structlog
-from typing import Dict
 from .base_agent import BaseAgent
-from memory.db import save_memory, search_memory, get_history
+from memory.db import save_memory, search_memory, get_history, get_project_memory
 
 log = structlog.get_logger()
 
@@ -14,26 +17,114 @@ class MemoryAgent(BaseAgent):
         super().__init__("MemoryAgent", ws_manager, ai_router)
 
     async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", context.get("session_id", ""))
-        task_id    = kwargs.get("task_id",    context.get("task_id", ""))
-        task_lower = task.lower()
-
-        if "recall" in task_lower or "remember" in task_lower or "history" in task_lower:
-            memories = await search_memory(task, session_id=session_id)
-            if memories:
-                items = "\n".join([f"- {m['content'][:120]}" for m in memories[:10]])
-                return f"**Memory Recall:**\n{items}"
-            return "No relevant memories found."
+        session_id = kwargs.get("session_id", "")
+        task_id = kwargs.get("task_id", "")
 
-        elif "save" in task_lower or "store" in task_lower:
+        # Determine if retrieve or save
+        task_lower = task.lower()
+        if any(k in task_lower for k in ["remember", "save", "store", "record"]):
             content = context.get("content", task)
-            await save_memory(content=content, memory_type="task",
-                              session_id=session_id, key="agent_memory")
+            await self.save(content, session_id=session_id, memory_type="user_directive")
             return f"✅ Saved to memory: {content[:100]}"
-
         else:
-            history = await get_history(session_id, limit=5)
-            if history:
-                items = "\n".join([f"- {h['content'][:120]}" for h in history])
-                return f"**Recent History ({session_id[:12]}):**\n{items}"
-            return "No conversation history yet."
+            results = await self.retrieve(task, session_id=session_id)
+            if results:
+                return "📚 **Memory Retrieved:**\n\n" + "\n".join(f"- {r['content'][:200]}" for r in results[:5])
+            return "No relevant memories found."
+
+    async def save(
+        self,
+        content: str,
+        session_id: str = "",
+        project_id: str = "",
+        memory_type: str = "general",
+        key: str = "",
+        metadata: Dict = {},
+    ):
+        """Save content to persistent memory."""
+        await save_memory(
+            content=content,
+            memory_type=memory_type,
+            session_id=session_id,
+            project_id=project_id,
+            key=key,
+            metadata=metadata,
+        )
+
+    async def retrieve(
+        self,
+        query: str,
+        session_id: str = "",
+        project_id: str = "",
+        limit: int = 10,
+    ) -> List[Dict]:
+        """Retrieve relevant memories."""
+        return await search_memory(query[:100], session_id=session_id, project_id=project_id, limit=limit)
+
+    async def get_conversation_history(self, session_id: str, limit: int = 20) -> List[Dict]:
+        """Get conversation history for a session."""
+        return await get_history(session_id, limit=limit)
+
+    async def save_interaction(
+        self,
+        user_message: str,
+        assistant_response: str,
+        session_id: str = "",
+        intent: Dict = {},
+    ):
+        """Save a full interaction to memory."""
+        await save_memory(
+            content=user_message,
+            memory_type="conversation",
+            session_id=session_id,
+            key="user_message",
+            metadata={"intent": intent.get("intent", ""), "timestamp": time.time()},
+        )
+        await save_memory(
+            content=assistant_response,
+            memory_type="conversation",
+            session_id=session_id,
+            key="assistant_response",
+            metadata={"agent": intent.get("primary_agent", "chat"), "timestamp": time.time()},
+        )
+
+    async def save_coding_style(self, style_notes: str, session_id: str = ""):
+        """Remember user's coding preferences."""
+        await save_memory(
+            content=style_notes,
+            memory_type="user_preference",
+            session_id=session_id,
+            key="coding_style",
+            metadata={"category": "coding_style"},
+        )
+
+    async def save_project_context(self, project_id: str, context: Dict):
+        """Save project-specific context."""
+        await save_memory(
+            content=json.dumps(context),
+            memory_type="project_context",
+            project_id=project_id,
+            key="project_context",
+            metadata={"timestamp": time.time()},
+        )
+
+    async def get_project_context(self, project_id: str) -> Optional[Dict]:
+        """Get project context."""
+        results = await get_project_memory(project_id, memory_type="project_context", limit=1)
+        if results:
+            try:
+                return json.loads(results[0]["content"])
+            except Exception:
+                return {"raw": results[0]["content"]}
+        return None
+
+    async def build_context_for_agent(self, session_id: str, query: str) -> Dict:
+        """Build rich context dict for agents from memory."""
+        history = await self.get_conversation_history(session_id, limit=10)
+        relevant = await self.retrieve(query, session_id=session_id, limit=5)
+
+        return {
+            "history": [{"role": "user" if i % 2 == 0 else "assistant", "content": h["content"]} for i, h in enumerate(reversed(history))],
+            "relevant_memories": [r["content"][:200] for r in relevant],
+            "session_id": session_id,
+        }