feat: implement medicine and BP handlers with clean history and intent fix

Backend/agent/agent.py

@@ -1,5 +1,6 @@
 import os
 import sys
+import logging
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from agent.context import get_relevant_context_from_vector_store
@@ -12,6 +13,8 @@
 from agent.handlers.weight import handle as handle_weight
 from agent.handlers.symptoms import handle as handle_symptoms
 from agent.handlers.guidelines import handle as handle_guidelines
+from agent.handlers.medicine import handle as handle_medicine
+from agent.handlers.blood_pressure import handle as handle_bp
 
 from agent.vector_store import register_vector_store_updater, update_guidelines_in_vector_store
 
@@ -20,84 +23,41 @@
     "weight": handle_weight,
     "symptoms": handle_symptoms,
     "guidelines": handle_guidelines,
+    "medicine": handle_medicine,
+    "blood_pressure": handle_bp,
 }
 
 class BabyNestAgent:
     def __init__(self, db_path: str):
         self.db_path = db_path
         self.context_cache = get_context_cache(db_path)
-
-        # Register embedding refresh
         register_vector_store_updater(update_guidelines_in_vector_store)
 
     def get_user_context(self, user_id: str = "default"):
-        """Get user context from cache."""
         return self.context_cache.get_context(user_id)
 
     def run(self, query: str, user_id: str = "default"):
         if not query or not isinstance(query, str):
-            return "Invalid query. Please provide a valid string."
+            return "Invalid query."
 
         try:
-            # Step 1: Get user context from cache (no DB hit if cache is valid)
-            user_context = self.get_user_context(user_id)
-            if not user_context:
-                return "User profile not found. Please complete your profile setup first."
-
-            # Step 2: Classify intent to see if a specialized handler should be used.
+            user_context = self.get_user_context(user_id) or {"current_week": 1}
             intent = classify_intent(query)
+            logging.info("Detected Intent: %s", intent)
+
             if intent in dispatch_intent:
-                # Pass user context to handlers
                 return dispatch_intent[intent](query, user_context)
 
-            # Step 3: Retrieve relevant context from the vector store based on the query.
             context = get_relevant_context_from_vector_store(query)
-
-            # Step 4: Build the prompt with the retrieved context and user context, then run the LLM.
             prompt = build_prompt(query, context, user_context)
             return run_llm(prompt)
-
         except Exception as e:
-            return f"Error processing query: {e}"
-
-    def update_cache(self, user_id: str = "default", data_type: str = None, operation: str = "update"):
-        """
-        Intelligently update cache based on database changes.
-
-        Args:
-            user_id: User ID to update cache for
-            data_type: Type of data that changed ('profile', 'weight', 'medicine', 'symptoms', 'blood_pressure', 'discharge')
-            operation: Type of operation ('create', 'update', 'delete')
-        """
-        self.context_cache.update_cache(user_id, data_type, operation)
-
-    def invalidate_cache(self, user_id: str = None):
-        """Invalidate cache for specific user or all users."""
-        self.context_cache.invalidate_cache(user_id)
-
-    def refresh_cache_and_embeddings(self):
-        """Manually refresh cache and regenerate embeddings after database changes."""
-        print("🔄 Manually refreshing cache and regenerating embeddings...")
-        self.context_cache.invalidate_cache()
-        update_guidelines_in_vector_store()
-
-    def get_cache_stats(self):
-        """Get cache statistics for monitoring."""
-        return self.context_cache.get_cache_stats()
-
-    def cleanup_cache(self):
-        """Manually trigger cache cleanup."""
-        self.context_cache._cleanup_old_cache_files()
-        self.context_cache._cleanup_memory_cache()
-        print("🧹 Cache cleanup completed")
+            logging.exception("Error processing query")
+            return f"Error processing query: {e!s}"
 
-# Global agent instance
 _agent_instance = None
-
 def get_agent(db_path: str) -> BabyNestAgent:
-    """Get or create the global agent instance."""
     global _agent_instance
     if _agent_instance is None:
         _agent_instance = BabyNestAgent(db_path)
-    return _agent_instance
-
+    return _agent_instance

Backend/agent/handlers/blood_pressure.py

@@ -0,0 +1,37 @@
+import re
+import sqlite3
+from db.db import open_db
+
+def handle(query, user_context):
+    """
+    Parses blood pressure readings (systolic/diastolic) from the user query,
+    validates the numeric ranges, and records the data into the database logs.
+    """
+    db = open_db()
+    try:
+
+        match = re.search(r'(\d{1,3})\s*(?:/|over|-)\s*(\d{1,3})', query, re.IGNORECASE)
+        if not match:
+            return "Please provide BP in format like '120/80' or '120 over 80'."
+
+        systolic = int(match.group(1))
+        diastolic = int(match.group(2))
+
+        if not (70 <= systolic <= 250 and 40 <= diastolic <= 150):
+            return "BP values out of valid range. Please check."
+
+        week = user_context.get('week_number', 1)
+
+
+        db.execute(
+            'INSERT INTO blood_pressure_logs (week_number, systolic, diastolic, time) VALUES (?, ?, ?, datetime("now"))',
+            (week, systolic, diastolic)
+        )
+        db.commit()
+        return f"Recorded BP: {systolic}/{diastolic} for week {week}."
+    except sqlite3.Error as e:
+        return f"Database error: {str(e)}"
+    except Exception as e:
+        return f"Unexpected error: {str(e)}"
+    finally:
+        db.close()

Backend/agent/handlers/medicine.py

@@ -0,0 +1,35 @@
+import re
+import sqlite3
+from db.db import open_db
+
+def handle(query, user_context):
+    """
+    Extracts medicine name, dosage, and time from user query using regex 
+    and persists the record into the weekly_medicine database table.
+    """
+    db = open_db()
+    try:
+
+        name_match = re.search(r'(?:took|taking|take)\s+([\w\s\-()]+?)(?:\s+\d|\s+at|$)', query, re.IGNORECASE)
+        name = name_match.group(1).strip() if name_match else "Medicine"
+
+        dose_match = re.search(r'(\d+\s*(?:tablet|pill|capsule|mg|ml|unit)s?)', query, re.IGNORECASE)
+        dose = dose_match.group(1).strip() if dose_match else "1 unit"
+
+        time_match = re.search(r'at\s+(\d{1,2}(?::\d{2})?\s*(?:am|pm)?)', query, re.IGNORECASE)
+        time = time_match.group(1) if time_match else "00:00"
+
+        week = user_context.get('week_number', 1)
+
+        db.execute(
+            'INSERT INTO weekly_medicine (week_number, name, dose, time) VALUES (?, ?, ?, ?)',
+            (week, name, dose, time)
+        )
+        db.commit()
+        return f"Logged {name} ({dose}) at {time} for week {week}."
+    except sqlite3.Error as e:
+        return f"Database error: {str(e)}"
+    except Exception as e:
+        return f"Unexpected error: {str(e)}"
+    finally:
+        db.close()

Backend/agent/intent.py

@@ -1,4 +1,4 @@
-# agent/intent.py
+
 def classify_intent(query: str) -> str:
     if not query or not isinstance(query, str):
         return "general"
@@ -10,6 +10,10 @@ def classify_intent(query: str) -> str:
         return "weight"
     elif "symptom" in query:
         return "symptoms"
+    elif "medicine" in query or "took" in query or "tablet" in query or "pill" in query:
+        return "medicine"
+    elif "bp" in query or "blood pressure" in query or "/" in query:
+        return "blood_pressure"
     elif "vaccine" in query or "guideline" in query or "what tests" in query or "recommend" in query:
         return "guidelines"
-    return "general"
+    return "general"