Update it all .

app.py

@@ -1,407 +1,175 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
 import os
-import json
-import re
+import openai
 import random
-import datetime
-from flask import Flask, request, jsonify, send_from_directory
-
-# Optional libraries - loaded if available
-try:
-    import openai
-    OPENAI_AVAILABLE = bool(os.environ.get("OPENAI_API_KEY"))
-    if OPENAI_AVAILABLE:
-        openai.api_key = os.environ.get("OPENAI_API_KEY")
-except Exception:
-    OPENAI_AVAILABLE = False
-
-# Try to load HF emotion model (optional, may be large)
-try:
-    from transformers import pipeline
-    HF_AVAILABLE = True
-except Exception:
-    HF_AVAILABLE = False
-
-emotion_model = None
-if HF_AVAILABLE:
-    try:
-        emotion_model = pipeline("text-classification", model="j-hartmann/emotion-english-distilroberta-base", top_k=5)
-    except Exception:
-        emotion_model = None
-
-app = Flask(__name__, static_folder=".", static_url_path="/")
-
-# Memory file
-MEMORY_FILE = "session_memory.json"
-MEMORY_KEEP_DAYS = 15
-
-# Crisis keywords and helplines
-CRISIS_KEYWORDS = [
-    "suicide", "kill myself", "end my life", "want to die", "hurt myself", "i'm going to die",
-    "i want to die", "i cant go on", "can't go on"
-]
-HELPLINES = {
-    "US": "USA: Call or text 988 (Suicide & Crisis Lifeline)",
-    "IN": "India: AASRA Helpline +91-9820466726",
-    "GB": "UK: Samaritans 116 123",
-    "CA": "Canada: Talk Suicide Canada 1-833-456-4566",
-    "AU": "Australia: Lifeline 13 11 14",
-    "DEFAULT": "If you're in immediate danger, contact local emergency services or search for a local helpline."
-}
-
-# Personalities -> small descriptor (informs OpenAI prompt if used)
-PERSONA_TEXT = {
-    "calm": "Calm, grounding, gentle friend.",
-    "friendly": "Warm, slightly chatty and encouraging friend.",
-    "deep": "Reflective, thoughtful, soulful friend.",
-    "spiritual": "Peaceful, nurturing, mindful tone.",
-    "neutral": "Balanced, non-gendered, soothing voice."
-}
-
-# Utility: load & save memory
-def load_memory():
-    if os.path.exists(MEMORY_FILE):
-        try:
-            with open(MEMORY_FILE, "r") as f:
-                data = json.load(f)
-        except Exception:
-            data = {}
+from transformers import pipeline
+from datetime import datetime, timedelta
+import json
+
+app = Flask(__name__)
+CORS(app)
+
+# ======================
+# 🔐 CONFIGURATION
+# ======================
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+# Emotion detection model
+emotion_analyzer = pipeline(
+    "text-classification",
+    model="j-hartmann/emotion-english-distilroberta-base",
+    top_k=None
+)
+
+# Temporary in-memory user data (can be saved to file if needed)
+USER_MEMORY = {}
+
+# ======================
+# 🎭 UTILITIES
+# ======================
+
+def detect_intent(text):
+    """Detect if user wants emotional support or factual info."""
+    question_words = ["what", "how", "why", "when", "who", "explain", "tell me", "define", "where"]
+    if any(word in text.lower() for word in question_words):
+        return "knowledge"
+    return "support"
+
+
+def analyze_emotion(text):
+    """Analyze emotion using Hugging Face model."""
+    result = emotion_analyzer(text)[0]
+    top_emotion = max(result, key=lambda x: x['score'])['label']
+    return top_emotion
+
+
+def get_supportive_prompt(emotion, user_name, last_mood=None):
+    """Builds empathetic response prompt."""
+    mood_followups = [
+        f"{user_name}, I remember last time you were feeling {last_mood}. How have you been since then?",
+        f"Hey {user_name}, how’s your heart today?",
+        f"It’s good to see you again, {user_name}. How are you holding up?",
+    ]
+
+    sympathy_openers = [
+        "That sounds really tough.",
+        "I can sense there’s a lot on your mind.",
+        "You’re doing your best, and that already means a lot.",
+        "I’m here with you right now, and I care about what you’re going through."
+    ]
+
+    prompt = random.choice(sympathy_openers)
+
+    if last_mood:
+        prompt += " " + random.choice(mood_followups)
     else:
-        data = {}
-    # prune entries older than MEMORY_KEEP_DAYS
-    cutoff = datetime.datetime.utcnow() - datetime.timedelta(days=MEMORY_KEEP_DAYS)
-    good = {}
-    for k, v in data.items():
-        try:
-            t = datetime.datetime.fromisoformat(v.get("last_seen"))
-            if t >= cutoff:
-                good[k] = v
-        except Exception:
-            good[k] = v
-    return good
-
-def save_memory(mem):
-    with open(MEMORY_FILE, "w") as f:
-        json.dump(mem, f, indent=2)
-
-memory = load_memory()
-
-# Small NLP helpers
-def extract_name(text):
-    text = text.strip()
-    patterns = [
-        r"^(?:i am|i'm|im|i’m)\s+([A-Za-z][A-Za-z'\- ]{1,40})",
-        r"my name is\s+([A-Za-z][A-Za-z'\- ]{1,40})",
-        r"^([A-Z][a-z]{1,30})$"
+        prompt += " How have you been feeling lately?"
+
+    return prompt
+
+
+def generate_response(intent, user_name, text, last_mood=None):
+    """Main logic for generating AI replies."""
+    if intent == "knowledge":
+        # Friendly factual tone
+        system_prompt = (
+            "You are Serenity, a calm and intelligent emotional support companion. "
+            "If user asks factual questions, explain them simply and clearly in a friendly tone. "
+            "Then, connect gently to emotion — e.g., ‘That’s fascinating! What made you curious about that?’"
+        )
+    else:
+        # Emotional support tone
+        system_prompt = (
+            "You are Serenity, a compassionate emotional support friend. "
+            "Offer empathy, ask caring questions, validate feelings, and use varied, natural language. "
+            "Avoid repeating the same phrases like 'I'm sorry to hear that'."
+        )
+
+    # Compose conversation context
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": text}
     ]
-    for p in patterns:
-        m = re.search(p, text, flags=re.IGNORECASE)
-        if m:
-            name = m.group(1).strip()
-            return " ".join([w.capitalize() for w in name.split()])
-    return None
-
-def extract_age(text):
-    nums = re.findall(r"\b([1-9][0-9]?)\b", text)
-    for n in nums:
-        val = int(n)
-        if 8 <= val <= 120:
-            return val
-    return None
-
-def detect_crisis(text):
-    t = text.lower()
-    return any(kw in t for kw in CRISIS_KEYWORDS)
-
-def get_helpline_by_ip(ip):
-    # best-effort via ipapi.co (may fail); fallback to DEFAULT
-    try:
-        import requests
-        if ip and ":" not in ip:
-            url = f"https://ipapi.co/{ip}/json/"
-        else:
-            url = "https://ipapi.co/json/"
-        r = requests.get(url, timeout=2)
-        if r.status_code == 200:
-            data = r.json()
-            code = data.get("country_code", "").upper()
-            return HELPLINES.get(code, HELPLINES["DEFAULT"])
-    except Exception:
-        pass
-    return HELPLINES["DEFAULT"]
-
-def classify_emotion(text):
-    # first attempt HF model if available
-    if emotion_model:
-        try:
-            out = emotion_model(text)
-            # pipeline returns list or list-of-lists. Get top label.
-            first = out[0]
-            if isinstance(first, list):
-                label = first[0]["label"]
-            else:
-                label = first["label"]
-            return label.lower()
-        except Exception:
-            pass
-    # fallback keywords
-    low = text.lower()
-    if any(w in low for w in ["happy","glad","joy","great","good","awesome","yay"]):
-        return "joy"
-    if any(w in low for w in ["sad","down","depress","lonely","cry","unhappy"]):
-        return "sadness"
-    if any(w in low for w in ["angry","mad","furious","annoy"]):
-        return "anger"
-    if any(w in low for w in ["scared","afraid","anxious","panic","worried"]):
-        return "fear"
-    if any(w in low for w in ["love","loving","fond","cherish"]):
-        return "love"
-    return "neutral"
-
-# Intent detection simple rules
-def detect_intent(text):
-    t = text.lower()
-    if detect_crisis(t):
-        return "CRISIS"
-    if any(q in t for q in ["how are you","how're you","how you doing","are you okay","are you mad","you okay","are you fine"]):
-        return "ASK_BOT"
-    if any(w in t for w in ["motivate","motivation","guidance","inspire","give me guidance","need motivation"]):
-        return "REQUEST_MOTIVATION"
-    if any(w in t for w in ["lol","haha","jk","dude","bro","have you gone","are you mad?","you mad"]):
-        return "CASUAL"
-    if any(w in t for w in ["sad","down","depressed","anxious","anxiety","lonely","suicidal","hurt myself"]):
-        return "SUPPORT"
-    if len(t.split()) <= 6:
-        return "CASUAL"
-    return "SUPPORT"
-
-# Non repetitive picks
-def pick_nonrep(slot, choices):
-    recent = slot.get("recent", [])
-    options = [c for c in choices if c not in recent]
-    if not options:
-        slot["recent"] = []
-        options = choices[:]
-    pick = random.choice(options)
-    slot.setdefault("recent", []).insert(0, pick)
-    slot["recent"] = slot["recent"][:8]
-    return pick
-
-# Templates
-CASUAL_TEMPLATES = [
-    "Haha — you got me! What's up?",
-    "I’m here for that laugh and also for the real talk. Tell me more.",
-    "LOL — I might be a little wired, but I’m listening. Go on.",
-    "Okay that’s funny — but seriously, how are you?"
-]
-SUPPORT_OPENERS = [
-    "That sounds really heavy — thank you for sharing that with me.",
-    "I can feel how much that means. I'm here with you.",
-    "That must be hard — I'm listening and I care.",
-    "You did well telling me that. Would you like to tell me more?"
-]
-SUPPORT_FOLLOWUPS = [
-    "Would you like a calming exercise or some small practical steps?",
-    "How has this been affecting your daily life recently?",
-    "What helps you even a little when you feel like that?"
-]
-MOTIVATIONAL = [
-    "Even small steps matter — you don't have to fix everything at once.",
-    "You’ve made it this far; that already shows strength.",
-    "Rest is allowed. Healing isn't a straight line.",
-    "Breath by breath — keep going."
-]
-BOT_SELF_REPLIES = [
-    "I’m doing well — glad to be here with you. How are you?",
-    "Feeling calm and ready to listen — how about you?",
-    "I’m okay! My favorite thing is talking with you. How are you doing?"
-]
-
-# OpenAI reply wrapper (if available)
-def openai_reply(user_text, persona_desc, session_slot):
-    if not OPENAI_AVAILABLE:
-        return None
+
     try:
-        system = f"You are Serenity, {persona_desc} Respond empathetically, avoid repeating the same short phrase, be human and varied."
-        messages = [
-            {"role":"system","content":system},
-            {"role":"user","content":user_text}
-        ]
-        resp = openai.ChatCompletion.create(
-            model = os.environ.get("OPENAI_MODEL", "gpt-4o-mini"),
-            messages = messages,
-            temperature = 0.8,
-            max_tokens = 300,
-            n = 1
+        response = openai.ChatCompletion.create(
+            model="gpt-4o-mini",
+            messages=messages,
+            temperature=0.9,
+            max_tokens=200
         )
-        return resp.choices[0].message.content.strip()
-    except Exception:
-        return None
+        ai_reply = response.choices[0].message["content"].strip()
+    except Exception as e:
+        ai_reply = f"Oops — I ran into an issue while thinking. ({e})"
+
+    return ai_reply
+
+
+def get_helpline_info(country="IN"):
+    """Return suicide helpline information based on country."""
+    helplines = {
+        "IN": "AASRA Helpline (India): 91-9820466726",
+        "US": "National Suicide Prevention Lifeline (US): 988",
+        "UK": "Samaritans (UK): 116 123",
+        "CA": "Talk Suicide Canada: 1-833-456-4566",
+        "AU": "Lifeline Australia: 13 11 14"
+    }
+    return helplines.get(country, "If you’re in danger, please reach your local emergency services.")
+
+
+# ======================
+# 💬 API ENDPOINTS
+# ======================
 
-# Main /chat endpoint
-@app.route("/chat", methods=["POST"])
-def chat():
-    data = request.get_json() or {}
-    session = data.get("session") or request.remote_addr or "default"
-    message = (data.get("message") or "").strip()
-    personality = data.get("personality") or data.get("voice_profile") or "neutral"
-    init_flag = bool(data.get("init", False))
-
-    # ensure session slot
-    slot = memory.get(session, {})
-    if not slot:
-        slot = {"name": None, "age": None, "last_mood": None, "last_seen": datetime.datetime.utcnow().isoformat(), "recent": [], "history": []}
-
-    # init greeting logic (frontend uses init to fetch greeting)
-    if init_flag:
-        slot["last_seen"] = datetime.datetime.utcnow().isoformat()
-        memory[session] = slot
-        save_memory(memory)
-        if not slot.get("name"):
-            return jsonify({"reply":"Hey — I'm Serenity. What’s your name?", "emotion":"calm", "intent":"INIT"})
-        else:
-            last_mood = slot.get("last_mood")
-            last_seen = slot.get("last_seen")
-            try:
-                t = datetime.datetime.fromisoformat(last_seen)
-                if last_mood in ("sadness","anger","fear") and (datetime.datetime.utcnow() - t).days <= MEMORY_KEEP_DAYS:
-                    return jsonify({"reply":f"Hey {slot.get('name')}, I remember you were having a tough time last session. How are you today?", "emotion":"warm", "intent":"FOLLOWUP"})
-            except Exception:
-                pass
-            return jsonify({"reply":f"Welcome back {slot.get('name','friend')} — I'm here for you. What's on your mind?", "emotion":"calm", "intent":"INIT"})
-
-    if not message:
-        return jsonify({"reply":"I’m here whenever you’re ready to share — anything on your mind?", "emotion":"neutral", "intent":"NONE"})
-
-    # If awaiting name/age flows (simple)
-    awaiting = slot.get("awaiting")
-    if not slot.get("name") and not awaiting:
-        # try to extract name from message
-        nm = extract_name(message)
-        if nm:
-            slot["name"] = nm
-            slot["awaiting"] = "age"
-            slot["last_seen"] = datetime.datetime.utcnow().isoformat()
-            memory[session] = slot
-            save_memory(memory)
-            return jsonify({"reply":f"Lovely to meet you, {nm}! How old are you?", "emotion":"curious", "intent":"ASK_AGE"})
-        else:
-            slot["awaiting"] = "name"
-            slot["last_seen"] = datetime.datetime.utcnow().isoformat()
-            memory[session] = slot
-            save_memory(memory)
-            return jsonify({"reply":"Hey — what should I call you? What's your name?", "emotion":"calm", "intent":"ASK_NAME"})
-
-    if awaiting == "name":
-        guessed = extract_name(message) or message.split()[0].capitalize()
-        slot["name"] = guessed
-        slot.pop("awaiting", None)
-        slot["awaiting"] = "age"
-        slot["last_seen"] = datetime.datetime.utcnow().isoformat()
-        memory[session] = slot
-        save_memory(memory)
-        return jsonify({"reply":f"Nice to meet you, {guessed}! How old are you?", "emotion":"curious", "intent":"ASK_AGE"})
-
-    if awaiting == "age":
-        age = extract_age(message)
-        if age:
-            slot["age"] = age
-            slot.pop("awaiting", None)
-            slot["last_seen"] = datetime.datetime.utcnow().isoformat()
-            memory[session] = slot
-            save_memory(memory)
-            return jsonify({"reply":f"Thanks — got it. {slot.get('name')}, how have you been feeling lately?", "emotion":"curious", "intent":"ASK_MOOD"})
-        else:
-            return jsonify({"reply":"Could you tell me your age as a number (for example: 24)?", "emotion":"neutral", "intent":"ASK_AGE"})
-
-    # Crisis detection
-    if detect_crisis(message):
-        helpline = get_helpline_by_ip(request.remote_addr)
-        slot["last_mood"] = "crisis"
-        slot["last_seen"] = datetime.datetime.utcnow().isoformat()
-        memory[session] = slot
-        save_memory(memory)
-        reply = (f"I’m really concerned about how you're feeling. You are not alone. "
-                 f"Please consider contacting emergency services or this helpline: {helpline}")
-        return jsonify({"reply":reply, "emotion":"crisis", "intent":"CRISIS"})
-
-    # Normal flow: detect intent & emotion
-    intent = detect_intent(message)
-    emotion = classify_emotion(message)
-
-    # Behavior by intent
-    # 1) Asking about bot -> casual short human reply then pivot to user
-    if intent == "ASK_BOT":
-        bot_line = random.choice(BOT_SELF_REPLIES := BOT_SELF_REPLIES if 'BOT_SELF_REPLIES' in globals() else [
-            "I’m doing well — glad to be here with you.",
-            "Feeling calm and ready to listen — how about you?",
-            "I’m okay! Just happy we’re chatting. How are you?"
-        ])
-        pivot = random.choice(["How are you doing right now?", "And how about you?"])
-        reply = f"{bot_line} {pivot}"
-        slot["last_mood"] = emotion
-        slot["last_seen"] = datetime.datetime.utcnow().isoformat()
-        memory[session] = slot
-        save_memory(memory)
-        return jsonify({"reply": reply, "emotion": emotion, "intent": intent})
-
-    # 2) Casual -> friendly replies
-    if intent == "CASUAL":
-        reply = openai_reply(message, PERSONA_TEXT.get(personality, "friendly"), slot) if OPENAI_AVAILABLE else None
-        if not reply or reply.strip().lower() in ("i understand","i see","okay"):
-            reply = pick_nonrep(slot, CASUAL_TEMPLATES)
-        slot["last_mood"] = emotion
-        slot["last_seen"] = datetime.datetime.utcnow().isoformat()
-        slot.setdefault("history", []).append({"in": message, "out": reply, "time": slot["last_seen"], "intent": intent})
-        memory[session] = slot
-        save_memory(memory)
-        return jsonify({"reply": reply, "emotion": emotion, "intent": intent})
-
-    # 3) Request motivation
-    if intent == "REQUEST_MOTIVATION":
-        reply = pick_nonrep(slot, MOTIVATIONAL)
-        slot["last_mood"] = emotion
-        slot["last_seen"] = datetime.datetime.utcnow().isoformat()
-        memory[session] = slot
-        save_memory(memory)
-        return jsonify({"reply": reply, "emotion": emotion, "intent": intent})
-
-    # 4) Support mode (default)
-    # Attempt OpenAI for the best reply
-    reply = None
-    if OPENAI_AVAILABLE:
-        reply = openai_reply(message, PERSONA_TEXT.get(personality, ""), slot)
-    if not reply:
-        opener = pick_nonrep(slot, SUPPORT_OPENERS)
-        follow = pick_nonrep(slot, SUPPORT_FOLLOWUPS)
-        if random.random() < 0.35:
-            reply = f"{opener} {random.choice(MOTIVATIONAL)} {follow}"
-        else:
-            reply = f"{opener} {follow}"
-
-    # store and return
-    slot["last_mood"] = emotion
-    slot["last_seen"] = datetime.datetime.utcnow().isoformat()
-    slot.setdefault("history", []).append({"in": message, "out": reply, "time": slot["last_seen"], "intent": intent})
-    memory[session] = slot
-    save_memory(memory)
-
-    return jsonify({"reply": reply, "emotion": emotion, "intent": intent})
-
-# Reset session endpoint
-@app.route("/reset_session", methods=["POST"])
-def reset_session():
-    data = request.get_json() or {}
-    session = data.get("session")
-    if session and session in memory:
-        memory.pop(session, None)
-        save_memory(memory)
-    return jsonify({"ok": True})
-
-# Serve frontend (index.html)
 @app.route("/")
 def index():
-    return send_from_directory(".", "index.html")
+    return jsonify({"message": "🌸 Serenity Emotional Support Chatbot API is running!"})
+
+
+@app.route("/chat", methods=["POST"])
+def chat():
+    data = request.get_json()
+    user_input = data.get("message", "")
+    user_name = data.get("name", "friend")
+    country = data.get("country", "IN")
+
+    # Retrieve or initialize memory
+    user_data = USER_MEMORY.get(user_name, {"last_seen": datetime.now(), "last_mood": None})
+    last_mood = user_data.get("last_mood")
+
+    # Detect potential crisis
+    crisis_keywords = ["end my life", "kill myself", "suicide", "can't go on", "hurt myself"]
+    if any(k in user_input.lower() for k in crisis_keywords):
+        helpline = get_helpline_info(country)
+        return jsonify({
+            "response": (
+                "I'm really sorry you’re feeling this way. You’re not alone, and you deserve care. ❤️\n"
+                f"If you are in danger, please reach out now:\n{helpline}"
+            )
+        })
+
+    # Detect intent
+    intent = detect_intent(user_input)
+
+    # Analyze emotion
+    emotion = analyze_emotion(user_input)
+
+    # Generate empathetic or factual response
+    ai_reply = generate_response(intent, user_name, user_input, last_mood)
+
+    # Update memory
+    USER_MEMORY[user_name] = {
+        "last_seen": datetime.now(),
+        "last_mood": emotion
+    }
+
+    return jsonify({
+        "response": ai_reply,
+        "emotion": emotion,
+        "intent": intent
+    })
+
 
 if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))
-    app.run(host="0.0.0.0", port=port)
+    app.run(host="0.0.0.0", port=7860)