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

Backend/agent/agent.py

@@ -1,17 +1,21 @@
 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
 from agent.intent import classify_intent
 from agent.llm import run_llm
 from agent.prompt import build_prompt
 from agent.cache import get_context_cache
+from agent.handlers import insights
 
 from agent.handlers.appointment import handle as handle_appointments
 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 +24,42 @@
     "weight": handle_weight,
     "symptoms": handle_symptoms,
     "guidelines": handle_guidelines,
+    "medicine": handle_medicine,
+    "blood_pressure": handle_bp,
+    "get_insights": insights.handle,
 }
 
 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,51 @@
+import re
+import sqlite3
+from db.db import open_db
+
+def handle(query, user_context):
+    """
+    Extracts BP readings, validates thresholds for pregnancy safety, 
+    and logs data into the database.
+    """
+    db = open_db()
+    try:
+        # Improved regex to capture systolic and diastolic values
+        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))
+
+        # Basic physiological range validation
+        if not (70 <= systolic <= 250 and 40 <= diastolic <= 150):
+            return "BP values out of valid range. Please check and try again."
+
+        week = user_context.get('week_number', 1)
+
+        # Database persistence
+        db.execute(
+            'INSERT INTO blood_pressure_logs (week_number, systolic, diastolic, time) VALUES (?, ?, ?, datetime("now"))',
+            (week, systolic, diastolic)
+        )
+        db.commit()
+
+        # --- MEDICAL ALERT LOGIC ---
+        # Thresholds based on pregnancy-induced hypertension (PIH) guidelines
+        if systolic >= 140 or diastolic >= 90:
+            return (f"🚨 **URGENT ALERT**: Your BP is {systolic}/{diastolic}. This is classified as High Blood Pressure (Hypertension). "
+                    "In pregnancy, this requires immediate attention. Please rest and **contact your doctor right away**.")
+
+        elif systolic <= 90 or diastolic <= 60:
+            return (f"⚠️ **WARNING**: Your BP is {systolic}/{diastolic}, which is low. "
+                    "Ensure you are hydrated and notify your healthcare provider if you feel faint.")
+
+        else:
+            return f"✅ Recorded BP: {systolic}/{diastolic} for week {week}. Your reading is within the healthy range."
+
+    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/insights.py

@@ -0,0 +1,59 @@
+import sqlite3
+from datetime import datetime, timedelta
+from db.db import open_db
+
+def handle(query, user_context):
+    """
+    Analyzes data from the last 7 days across all logs to provide
+    a comprehensive health summary.
+    """
+    db = open_db()
+    try:
+        week = user_context.get('week_number', 1)
+
+        # 1. Fetch Blood Pressure Data (Last 7 Days)
+        bp_rows = db.execute(
+            "SELECT systolic, diastolic FROM blood_pressure_logs WHERE time >= datetime('now', '-7 days')"
+        ).fetchall()
+
+        # 2. Fetch Medicine Data (Last 7 Days)
+        med_rows = db.execute(
+            "SELECT status FROM weekly_medicine_logs WHERE time >= datetime('now', '-7 days')"
+        ).fetchall()
+
+        # 3. Fetch Weight Data (Last 7 Days)
+        weight_rows = db.execute(
+            "SELECT weight_value FROM weight_logs WHERE time >= datetime('now', '-7 days')"
+        ).fetchall()
+
+        # --- ANALYSIS LOGIC ---
+
+        # BP Analysis
+        if bp_rows:
+            avg_sys = sum(r[0] for r in bp_rows) // len(bp_rows)
+            avg_dia = sum(r[1] for r in bp_rows) // len(bp_rows)
+            bp_status = "Stable" if avg_sys < 140 else "High (Consult Doctor)"
+        else:
+            avg_sys, avg_dia, bp_status = "N/A", "N/A", "No data logged"
+
+        # Medicine Adherence
+        total_meds = len(med_rows)
+        taken_meds = sum(1 for r in med_rows if r[0] == 'taken')
+        adherence = (taken_meds / total_meds * 100) if total_meds > 0 else 0
+
+        # Response Building
+        response = (
+            f"📊 **Weekly Health Insights (Week {week})**\n\n"
+            f"🩺 **Blood Pressure:** Avg {avg_sys}/{avg_dia} mmHg\n"
+            f"💡 *Status:* {bp_status}\n\n"
+            f"💊 **Medicine Adherence:** {adherence:.1f}%\n"
+            f"💡 *Tip:* {'Great job staying consistent!' if adherence > 80 else 'Try to set reminders for your supplements.'}\n\n"
+            f"⚖️ **Weight Logs:** {len(weight_rows)} entries found this week."
+        )
+
+        return response
+
+    except Exception as e:
+        return f"Error generating insights: {str(e)}"
+    finally:
+        db.close()

Backend/agent/handlers/medicine.py

@@ -0,0 +1,44 @@
+import sqlite3
+from datetime import datetime
+from db.db import open_db
+
+def handle(query, user_context):
+    """
+    Records medicine intake and provides proactive reminders based 
+    on standard pregnancy supplement requirements.
+    """
+    db = open_db()
+    try:
+        # Standard supplements for pregnancy
+        required_meds = ["iron", "folic acid", "calcium"]
+        query_lower = query.lower()
+
+        # Identify which medicine the user is logging
+        logged_med = next((med for med in required_meds if med in query_lower), "medicine")
+
+        week = user_context.get('week_number', 1)
+
+        # Record the entry in the database
+        db.execute(
+            'INSERT INTO weekly_medicine_logs (week_number, medicine_name, status, time) VALUES (?, ?, ?, datetime("now"))',
+            (week, logged_med, "taken")
+        )
+        db.commit()
+
+        # --- PROACTIVE LOGIC ---
+        # Remind user about other important meds if they only logged one
+        missing_meds = [m for m in required_meds if m not in query_lower]
+
+        response = f"✅ Logged your {logged_med} intake for week {week}."
+
+        if missing_meds:
+            response += f"\n\n💡 **Tip**: Don't forget to also take your {', '.join(missing_meds)} today as prescribed for your pregnancy stage."
+
+        return response
+
+    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,15 +1,23 @@
-# agent/intent.py
 def classify_intent(query: str) -> str:
     if not query or not isinstance(query, str):
         return "general"
 
     query = query.lower()
+
+    if any(word in query for word in ["summary", "report", "insight", "dashboard", "track"]):
+        return "get_insights"
+
     if "appointment" in query:
         return "appointments"
     elif "weight" in query:
         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"