Update it.

app.py

@@ -1,152 +1,407 @@
 import os
 import json
-from datetime import datetime, timedelta
+import re
+import random
+import datetime
 from flask import Flask, request, jsonify, send_from_directory
-from transformers import pipeline
-from openai import OpenAI
-
-app = Flask(__name__)
-client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-
-# Load Hugging Face emotion model
-emotion_analyzer = pipeline("text-classification", model="j-hartmann/emotion-english-distilroberta-base", top_k=None)
-
-USER_DATA_FILE = "user_data.json"
-
-# ---------------------- UTILITIES -------------------------
-def load_user_data():
-    if os.path.exists(USER_DATA_FILE):
-        with open(USER_DATA_FILE, "r") as f:
-            return json.load(f)
-    return {"name": None, "age": None, "mood": None, "last_interaction": None, "missed_days": 0}
-
-def save_user_data(data):
-    with open(USER_DATA_FILE, "w") as f:
-        json.dump(data, f, indent=4)
-
-def detect_emotion(text):
-    result = emotion_analyzer(text)
-    top_emotion = sorted(result[0], key=lambda x: x["score"], reverse=True)[0]["label"]
-    return top_emotion.lower()
-
-def crisis_check(user_input, location="global"):
-    crisis_keywords = ["kill myself", "end my life", "suicide", "die", "worthless"]
-    if any(kw in user_input.lower() for kw in crisis_keywords):
-        if location == "india":
-            return ("I'm really sorry you’re feeling like this. You are not alone. "
-                    "You can reach out to AASRA Helpline at 91-9820466726 or Snehi at 91-9582208181.")
-        elif location == "us":
-            return ("It sounds like you’re going through a really difficult time. "
-                    "If you are in the U.S., please call or text 988 to connect with the Suicide and Crisis Lifeline.")
-        else:
-            return ("I’m so sorry you’re in pain right now. You are not alone. "
-                    "Please reach out to a local suicide helpline or emergency number right away.")
-    return None
 
-def days_since_last_interaction(user_data):
-    if not user_data.get("last_interaction"):
-        return None
-    last = datetime.fromisoformat(user_data["last_interaction"])
-    return (datetime.now() - last).days
-
-# ---------------------- PERSONALITY SYSTEM -------------------------
-PERSONALITIES = {
-    "calm": {
-        "tone": "gentle, understanding, patient",
-        "style": "Uses short, soft phrases and empathy-driven responses."
-    },
-    "friendly": {
-        "tone": "warm, chatty, and supportive",
-        "style": "Uses casual language and light humor to uplift users."
-    },
-    "deep": {
-        "tone": "reflective, philosophical, soulful",
-        "style": "Encourages self-reflection and growth."
-    },
-    "spiritual": {
-        "tone": "peaceful, grounding, and nurturing",
-        "style": "Focuses on mindfulness, acceptance, and compassion."
-    }
+# 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."
 }
 
-def generate_personality_prompt(personality):
-    p = PERSONALITIES.get(personality, PERSONALITIES["calm"])
-    return f"You are an emotional support AI with a {p['tone']} tone. {p['style']} Respond to users with empathy and variation."
+# 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 = {}
+    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})$"
+    ]
+    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?"
+]
 
-# ---------------------- RESPONSE LOGIC -------------------------
+# 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
+        )
+        return resp.choices[0].message.content.strip()
+    except Exception:
+        return None
+
+# Main /chat endpoint
 @app.route("/chat", methods=["POST"])
 def chat():
-    user_input = request.json.get("message", "")
-    personality = request.json.get("personality", "calm")
-    location = request.json.get("location", "global")
+    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": []}
 
-    user_data = load_user_data()
+    # 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
-    crisis_response = crisis_check(user_input, location)
-    if crisis_response:
-        return jsonify({"response": crisis_response, "emotion": "worried"})
-
-    # Daily check-in system
-    days_passed = days_since_last_interaction(user_data)
-    if days_passed is not None:
-        if days_passed >= 3:
-            reminder = "We missed you these past few days. How have you been feeling lately?"
-        elif days_passed == 1 and user_data.get("mood") in ["sad", "angry", "worried"]:
-            reminder = f"Hey {user_data.get('name','friend')}, you seemed a bit down yesterday. How are you feeling today?"
+    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:
-            reminder = None
-    else:
-        reminder = None
-
-    # Emotion detection
-    emotion = detect_emotion(user_input)
-    user_data["mood"] = emotion
-    user_data["last_interaction"] = datetime.now().isoformat()
-    save_user_data(user_data)
-
-    # OpenAI response generation
-    system_prompt = generate_personality_prompt(personality)
-    prompt = f"""
-    The user said: "{user_input}"
-    Their name: {user_data.get('name')}
-    Their age: {user_data.get('age')}
-    Their recent mood: {user_data.get('mood')}
-    Your goal: offer empathetic emotional support, avoid repetition, vary expressions naturally.
-    """
-
-    openai_reply = None
-    try:
-        response = client.chat.completions.create(
-            model="gpt-4o-mini",
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": prompt}
-            ],
-            temperature=0.9
-        )
-        openai_reply = response.choices[0].message.content.strip()
-    except Exception as e:
-        print("Error with OpenAI API:", e)
-        openai_reply = "I'm here for you, even though I’m having a bit of trouble expressing myself right now."
-
-    # Combine reminder if needed
-    if reminder:
-        final_reply = f"{reminder} {openai_reply}"
-    else:
-        final_reply = openai_reply
+            reply = f"{opener} {follow}"
 
-    return jsonify({"response": final_reply, "emotion": emotion})
+    # 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)
 
-# ---------------------- FRONTEND -------------------------
+    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")
 
-@app.route("/<path:path>")
-def static_files(path):
-    return send_from_directory(".", path)
-
-# ---------------------- RUN -------------------------
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port)