God Mode+ v3 fix: agents/memory_agent.py

agents/memory_agent.py

@@ -1,13 +1,10 @@
 """
-MemoryAgent — Persistent long-term memory system (Phase 5)
-SQLite-backed with semantic search simulation
+MemoryAgent — Persistent memory via LLMRouter + SQLite
 """
-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, get_project_memory
+from memory.db import save_memory, search_memory, get_history
 
 log = structlog.get_logger()
 
@@ -17,114 +14,26 @@ 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", "")
-        task_id = kwargs.get("task_id", "")
-
-        # Determine if retrieve or save
+        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 any(k in task_lower for k in ["remember", "save", "store", "record"]):
-            content = context.get("content", task)
-            await self.save(content, session_id=session_id, memory_type="user_directive")
-            return f"✅ Saved to memory: {content[:100]}"
-        else:
-            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
+        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."
 
-    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)
+        elif "save" in task_lower or "store" in task_lower:
+            content = context.get("content", task)
+            await save_memory(content=content, memory_type="task",
+                              session_id=session_id, key="agent_memory")
+            return f"✅ Saved to memory: {content[:100]}"
 
-        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,
-        }
+        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."