Create app.py

app.py

@@ -0,0 +1,784 @@
+import streamlit as st
+import os, json, datetime, hashlib
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_groq import ChatGroq
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from gtts import gTTS
+from pathlib import Path
+from dotenv import load_dotenv
+from sentence_transformers import SentenceTransformer, util
+import altair as alt
+import speech_recognition as sr
+from transformers import pipeline
+import torch
+import pickle
+import re
+
+# Load environment variables
+load_dotenv()
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+
+CRISIS_KEYWORDS = ["suicide", "kill myself", "end it all", "worthless", "can't go on", "hurt myself", "self harm", "want to disappear", "no reason to live"]
+
+# Initialize session state
+if "authenticated" not in st.session_state:
+    st.session_state.authenticated = False
+if "username" not in st.session_state:
+    st.session_state.username = None
+if "is_admin" not in st.session_state:
+    st.session_state.is_admin = False
+if "transcribed_text" not in st.session_state:
+    st.session_state.transcribed_text = ""
+
+# Admin configuration
+ADMIN_USERNAME = os.getenv("ADMIN_USERNAME")  # Set in HF Spaces secrets
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD")  # Set in HF Spaces secrets
+
+# User management functions
+def hash_password(password):
+    """Hash password using SHA-256 with salt"""
+    salt = "dilbot_secure_salt_2024"  # You can change this
+    return hashlib.sha256((password + salt).encode()).hexdigest()
+
+def get_secure_users_path():
+    """Get path to users file in a hidden directory"""
+    secure_dir = ".secure_data"
+    os.makedirs(secure_dir, exist_ok=True)
+    return os.path.join(secure_dir, "users_encrypted.json")
+
+def load_users():
+    """Load users from secure file"""
+    users_path = get_secure_users_path()
+    if os.path.exists(users_path):
+        try:
+            with open(users_path, "r") as f:
+                return json.load(f)
+        except:
+            return {}
+    return {}
+
+def save_users(users):
+    """Save users to secure file"""
+    users_path = get_secure_users_path()
+    with open(users_path, "w") as f:
+        json.dump(users, f, indent=4)
+
+def create_user_directory(username):
+    """Create user-specific directory structure"""
+    user_dir = f"users/{username}"
+    os.makedirs(user_dir, exist_ok=True)
+    return user_dir
+
+def get_user_file_path(username, filename):
+    """Get path to user-specific file"""
+    user_dir = f"users/{username}"
+    return os.path.join(user_dir, filename)
+
+def signup(username, password, email):
+    """Register new user"""
+    users = load_users()
+    if username in users:
+        return False, "Username already exists"
+    
+    email_pattern = r"^[\w\.-]+@[\w\.-]+\.\w+$"
+    if not re.match(email_pattern, email):
+         return False, "Invalid email format"
+        
+    users[username] = {
+        "password": hash_password(password),
+        "email": email,
+        "created_at": str(datetime.datetime.now())
+    }
+    save_users(users)
+    create_user_directory(username)
+    return True, "Account created successfully!"
+
+def login(username, password):
+    """Authenticate user or admin"""
+    # Check if admin login
+    if username == ADMIN_USERNAME and password == ADMIN_PASSWORD:
+        return True, "Admin login successful!", True
+    
+    # Regular user login
+    users = load_users()
+    if username not in users:
+        return False, "User not found.Please signup.", False
+    
+    if users[username]["password"] == hash_password(password):
+        return True, "Login successful!", False
+    return False, "Incorrect password", False
+
+# Emotion detection
+@st.cache_resource
+def load_emotion_model():
+    return pipeline(
+        "text-classification",
+        model="j-hartmann/emotion-english-distilroberta-base",
+        top_k=1,
+        device=-1
+    )
+
+def detect_emotion(text):
+    emotion_pipeline = load_emotion_model()
+    prediction = emotion_pipeline(text)[0][0]
+    return prediction['label'].lower(), prediction['score']
+
+# Authentication UI
+def show_auth_page():
+    st.set_page_config(page_title="DilBot - Login", page_icon="🧠")
+    st.title("🧠 DilBot - Emotional AI Companion")
+    st.markdown("Welcome! Please login or create an account to continue.")
+    
+    tab1, tab2 = st.tabs(["Login", "Sign Up"])
+    
+    with tab1:
+        st.subheader("Login to Your Account")
+        login_username = st.text_input("Username", key="login_user")
+        login_password = st.text_input("Password", type="password", key="login_pass")
+        
+        if st.button("Login", key="login_btn"):
+            if login_username and login_password:
+                success, message, is_admin = login(login_username, login_password)
+                if success:
+                    st.session_state.authenticated = True
+                    st.session_state.username = login_username
+                    st.session_state.is_admin = is_admin
+                    st.success(message)
+                    st.rerun()
+                else:
+                    st.error(message)
+            else:
+                st.warning("Please fill in all fields")
+    
+    with tab2:
+        st.subheader("Create New Account")
+        signup_username = st.text_input("Choose Username", key="signup_user")
+        signup_email = st.text_input("Email Address", key="signup_email")
+        signup_password = st.text_input("Choose Password", type="password", key="signup_pass")
+        signup_confirm = st.text_input("Confirm Password", type="password", key="signup_confirm")
+        
+        if st.button("Create Account", key="signup_btn"):
+            if all([signup_username, signup_email, signup_password, signup_confirm]):
+                if signup_password != signup_confirm:
+                    st.error("Passwords don't match!")
+                elif len(signup_password) < 6:
+                    st.error("Password must be at least 6 characters long!")
+                else:
+                    success, message = signup(signup_username, signup_password, signup_email)
+                    if success:
+                        st.success(message)
+                        st.info("You can now login with your credentials!")
+                    else:
+                        st.error(message)
+            else:
+                st.warning("Please fill in all fields")
+
+# Main app functions
+def build_user_vectorstore(username, quotes):
+    """Build and save user-specific vectorstore"""
+    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+    vectorstore = FAISS.from_texts(quotes, embedding=embeddings)
+    
+    # Save vectorstore for user
+    vectorstore_path = get_user_file_path(username, "vectorstore")
+    vectorstore.save_local(vectorstore_path)
+    return vectorstore
+
+def load_user_vectorstore(username):
+    """Load user-specific vectorstore"""
+    vectorstore_path = get_user_file_path(username, "vectorstore")
+    if os.path.exists(vectorstore_path):
+        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+        return FAISS.load_local(vectorstore_path, embeddings, allow_dangerous_deserialization=True)
+    return None
+
+def save_user_journal(username, user_input, emotion, score, response):
+    """Save journal entry for specific user"""
+    journal_path = get_user_file_path(username, "journal.json")
+    entry = {
+        "date": str(datetime.date.today()),
+        "timestamp": str(datetime.datetime.now()),
+        "user_input": user_input,
+        "emotion": emotion,
+        "confidence": round(score * 100, 2),
+        "response": response
+    }
+    
+    journal = []
+    if os.path.exists(journal_path):
+        with open(journal_path, "r") as f:
+            journal = json.load(f)
+    
+    journal.append(entry)
+    with open(journal_path, "w") as f:
+        json.dump(journal, f, indent=4)
+
+def load_user_journal(username):
+    """Load journal for specific user"""
+    journal_path = get_user_file_path(username, "journal.json")
+    if os.path.exists(journal_path):
+        with open(journal_path, "r") as f:
+            return json.load(f)
+    return []
+
+def get_admin_stats():
+    """Get comprehensive admin statistics"""
+    users = load_users()
+    stats = {
+        "total_users": len(users),
+        "users_today": 0,
+        "users_this_week": 0,
+        "total_conversations": 0,
+        "active_users": 0,
+        "user_details": []
+    }
+    
+    today = datetime.date.today()
+    week_ago = today - datetime.timedelta(days=7)
+    
+    for username, user_data in users.items():
+        created_date = datetime.datetime.fromisoformat(user_data["created_at"]).date()
+        
+        # Count registrations
+        if created_date == today:
+            stats["users_today"] += 1
+        if created_date >= week_ago:
+            stats["users_this_week"] += 1
+        
+        # Get user journal stats
+        journal_data = load_user_journal(username)
+        conversation_count = len(journal_data)
+        stats["total_conversations"] += conversation_count
+        
+        if conversation_count > 0:
+            stats["active_users"] += 1
+            last_activity = journal_data[-1]["date"] if journal_data else "Never"
+        else:
+            last_activity = "Never"
+        
+        # Get emotion breakdown
+        emotions = [entry['emotion'] for entry in journal_data]
+        emotion_counts = {}
+        for emotion in emotions:
+            emotion_counts[emotion] = emotion_counts.get(emotion, 0) + 1
+        
+        most_common_emotion = max(emotion_counts, key=emotion_counts.get) if emotion_counts else "None"
+        
+        stats["user_details"].append({
+            "username": username,
+            "email": user_data["email"],
+            "joined": created_date.strftime("%Y-%m-%d"),
+            "conversations": conversation_count,
+            "last_activity": last_activity,
+            "most_common_emotion": most_common_emotion.capitalize(),
+            "emotions_breakdown": emotion_counts
+        })
+    
+    return stats
+
+def log_admin_activity(action, details=""):
+    """Log admin activities"""
+    admin_log_path = "data/admin_log.json"  # Persistent and visible
+    log_entry = {
+        "timestamp": str(datetime.datetime.now()),
+        "action": action,
+        "details": details,
+        "admin": st.session_state.username
+    }
+    
+    admin_log = []
+    if os.path.exists(admin_log_path):
+        with open(admin_log_path, "r") as f:
+            admin_log = json.load(f)
+    
+    admin_log.append(log_entry)
+    
+    # Keep only last 100 entries
+    admin_log = admin_log[-100:]
+    
+    os.makedirs("data", exist_ok=True)
+    with open(admin_log_path, "w") as f:
+        json.dump(admin_log, f, indent=4)
+
+def get_admin_logs():
+    """Get admin activity logs"""
+    admin_log_path = "data/admin_log.json"
+    if os.path.exists(admin_log_path):
+        with open(admin_log_path, "r") as f:
+            return json.load(f)
+    return []
+
+def is_crisis(text):
+    """Check for crisis keywords"""
+    return any(phrase in text.lower() for phrase in CRISIS_KEYWORDS)
+
+def show_admin_dashboard():
+    """Admin dashboard for monitoring users and app usage"""
+    st.set_page_config(page_title="DilBot Admin Dashboard", page_icon="👑")
+    
+    # Header
+    col1, col2 = st.columns([4, 1])
+    with col1:
+        st.title("👑 DilBot Admin Dashboard")
+        st.markdown("Monitor users, conversations, and app analytics")
+    with col2:
+        if st.button("Logout", key="admin_logout"):
+            st.session_state.authenticated = False
+            st.session_state.username = None
+            st.session_state.is_admin = False
+            st.rerun()
+    
+    # Log admin access
+    log_admin_activity("Dashboard Access", "Viewed admin dashboard")
+    
+    # Get statistics
+    stats = get_admin_stats()
+    
+    # Overview metrics
+    st.header("📊 Overview")
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("Total Users", stats["total_users"])
+    with col2:
+        st.metric("Active Users", stats["active_users"])
+    with col3:
+        st.metric("New Today", stats["users_today"])
+    with col4:
+        st.metric("Total Conversations", stats["total_conversations"])
+    
+    # User registration trend
+    st.header("📈 User Registration Trend")
+    if stats["user_details"]:
+        # Create registration data
+        reg_data = {}
+        for user in stats["user_details"]:
+            date = user["joined"]
+            reg_data[date] = reg_data.get(date, 0) + 1
+        
+        chart_data = [{"date": date, "registrations": count} for date, count in sorted(reg_data.items())]
+        
+        if chart_data:
+            chart = alt.Chart(alt.Data(values=chart_data)).mark_line(point=True).encode(
+                x=alt.X('date:T', title='Date'),
+                y=alt.Y('registrations:Q', title='New Registrations'),
+                tooltip=['date:T', 'registrations:Q']
+            ).properties(
+                width=700,
+                height=300,
+                title="Daily User Registrations"
+            )
+            st.altair_chart(chart, use_container_width=True)
+    
+    # Detailed user table
+    st.header("👥 User Details")
+    
+    # Search and filter
+    col1, col2 = st.columns([2, 1])
+    with col1:
+        search_term = st.text_input("🔍 Search users", placeholder="Search by username or email")
+    with col2:
+        min_conversations = st.number_input("Min conversations", min_value=0, value=0)
+    
+    # Filter users
+    filtered_users = stats["user_details"]
+    if search_term:
+        filtered_users = [u for u in filtered_users if 
+                         search_term.lower() in u["username"].lower() or 
+                         search_term.lower() in u["email"].lower()]
+    
+    if min_conversations > 0:
+        filtered_users = [u for u in filtered_users if u["conversations"] >= min_conversations]
+    
+    # Display user table
+    if filtered_users:
+        for user in filtered_users:
+            with st.expander(f"👤 {user['username']} ({user['conversations']} conversations)"):
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.write(f"**Email:** {user['email']}")
+                    st.write(f"**Joined:** {user['joined']}")
+                    st.write(f"**Last Activity:** {user['last_activity']}")
+                
+                with col2:
+                    st.write(f"**Conversations:** {user['conversations']}")
+                    st.write(f"**Most Common Emotion:** {user['most_common_emotion']}")
+                    
+                    # Show emotion breakdown
+                    if user['emotions_breakdown']:
+                        st.write("**Emotion Breakdown:**")
+                        for emotion, count in user['emotions_breakdown'].items():
+                            st.write(f"  - {emotion.capitalize()}: {count}")
+                
+                # Quick actions
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    if st.button(f"View Journal", key=f"view_{user['username']}"):
+                        # Show user's recent conversations
+                        user_journal = load_user_journal(user['username'])
+                        if user_journal:
+                            st.subheader(f"Recent conversations for {user['username']}")
+                            for entry in user_journal[-5:]:
+                                st.text_area(
+                                    f"{entry['date']} - {entry['emotion'].capitalize()}",
+                                    f"User: {entry['user_input']}\nDilBot: {entry['response']}",
+                                    height=100,
+                                    disabled=True
+                                )
+                        else:
+                            st.info("No conversations found")
+                
+                with col2:
+                    reset_key = f"reset_{user['username']}"
+                    confirm_key = f"confirm_{user['username']}"
+                    
+                    if st.button(f"Reset Data", key=reset_key):
+                        st.session_state[confirm_key] = True  # Flag to show confirmation
+                    
+                    if st.session_state.get(confirm_key, False):
+                        st.warning(f"Are you sure you want to reset data for {user['username']}?")
+                        if st.button(f"Yes, Reset {user['username']}", key=f"confirm_reset_{user['username']}"):
+                            # Clear user's journal
+                            journal_path = get_user_file_path(user['username'], "journal.json")
+                            if os.path.exists(journal_path):
+                                os.remove(journal_path)
+                            
+                            log_admin_activity("User Data Reset", f"Reset data for {user['username']}")
+                            st.success(f"Data reset for {user['username']}")
+                            st.session_state[confirm_key] = False  # Reset confirmation flag
+                            st.rerun()
+                        if st.button(f"Cancel", key=f"cancel_reset_{user['username']}"):
+                            st.session_state[confirm_key] = False  # Cancel confirmation
+                            st.rerun()
+
+    else:
+        st.info("No users found matching your criteria")
+    
+    # System Analytics
+    st.header("🔧 System Analytics")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("Emotion Distribution (All Users)")
+        # Aggregate all emotions
+        all_emotions = {}
+        for user in stats["user_details"]:
+            for emotion, count in user['emotions_breakdown'].items():
+                all_emotions[emotion] = all_emotions.get(emotion, 0) + count
+        
+        if all_emotions:
+            emotion_chart_data = [{"emotion": emotion.capitalize(), "count": count} 
+                                 for emotion, count in all_emotions.items()]
+            
+            emotion_chart = alt.Chart(alt.Data(values=emotion_chart_data)).mark_bar().encode(
+                x=alt.X('emotion:N', title='Emotion'),
+                y=alt.Y('count:Q', title='Frequency'),
+                color=alt.Color('emotion:N', legend=None),
+                tooltip=['emotion:N', 'count:Q']
+            ).properties(
+                width=400,
+                height=300,
+                title="Overall Emotion Distribution"
+            )
+            st.altair_chart(emotion_chart, use_container_width=True)
+    
+    with col2:
+        st.subheader("User Activity Levels")
+        activity_levels = {"Inactive (0)": 0, "Light (1-5)": 0, "Moderate (6-20)": 0, "Heavy (21+)": 0}
+        
+        for user in stats["user_details"]:
+            conv_count = user["conversations"]
+            if conv_count == 0:
+                activity_levels["Inactive (0)"] += 1
+            elif conv_count <= 5:
+                activity_levels["Light (1-5)"] += 1
+            elif conv_count <= 20:
+                activity_levels["Moderate (6-20)"] += 1
+            else:
+                activity_levels["Heavy (21+)"] += 1
+        
+        activity_data = [{"level": level, "users": count} for level, count in activity_levels.items()]
+        
+        activity_chart = alt.Chart(alt.Data(values=activity_data)).mark_arc().encode(
+            theta=alt.Theta('users:Q'),
+            color=alt.Color('level:N', title="Activity Level"),
+            tooltip=['level:N', 'users:Q']
+        ).properties(
+            width=300,
+            height=300,
+            title="User Activity Distribution"
+        )
+        st.altair_chart(activity_chart, use_container_width=True)
+    
+    # Admin logs
+    st.header("📋 Admin Activity Logs")
+    admin_logs = get_admin_logs()
+    
+    if admin_logs:
+        # Show recent admin activities
+        for log_entry in reversed(admin_logs[-10:]):  # Last 10 activities
+            timestamp = datetime.datetime.fromisoformat(log_entry["timestamp"])
+            st.text(f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} - {log_entry['action']}: {log_entry['details']}")
+    else:
+        st.info("No admin activities logged yet")
+    
+    # Export functionality
+    st.header("💾 Data Export")
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Export User Data (JSON)"):
+            export_data = {
+                "export_timestamp": str(datetime.datetime.now()),
+                "statistics": stats,
+                "admin_logs": admin_logs
+            }
+            
+            st.download_button(
+                label="Download User Data",
+                data=json.dumps(export_data, indent=4),
+                file_name=f"dilbot_export_{datetime.date.today()}.json",
+                mime="application/json"
+            )
+            
+            log_admin_activity("Data Export", "Exported user data")
+    
+    with col2:
+        if st.button("Clear Admin Logs"):
+            admin_log_path = "data/admin_log.json"
+            if os.path.exists(admin_log_path):
+                os.remove(admin_log_path)
+            st.success("Admin logs cleared!")
+            st.rerun()
+            
+def speak(text, username):
+    """Generate and play audio response"""
+    tts = gTTS(text=text, lang='en')
+    audio_path = get_user_file_path(username, "response.mp3")
+    tts.save(audio_path)
+    st.audio(audio_path, format="audio/mp3")
+
+
+def transcribe_audio_file(uploaded_audio):
+    """Transcribe uploaded audio file"""
+    recognizer = sr.Recognizer()
+    try:
+        with sr.AudioFile(uploaded_audio) as source:
+            audio_data = recognizer.record(source)
+            text = recognizer.recognize_google(audio_data)
+            return text
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def show_main_app():
+    """Main DilBot application"""
+    username = st.session_state.username
+    
+    st.set_page_config(page_title="DilBot - Emotional AI", page_icon="🧠")
+    
+    # Header with logout
+    col1, col2 = st.columns([4, 1])
+    with col1:
+        st.title(f"🧠 DilBot - Welcome back, {username}!")
+        st.markdown("Your personal emotional AI companion")
+    with col2:
+        if st.button("Logout", key="logout_btn"):
+            st.session_state.authenticated = False
+            st.session_state.username = None
+            st.rerun()
+    
+    # Quote categories
+    quote_categories = {
+        "Grief": ["Grief is the price we pay for love.", "Tears are the silent language of grief.", "What we have once enjoyed we can never lose; all that we love deeply becomes a part of us."],
+        "Motivation": ["Believe in yourself and all that you are.", "Tough times never last, but tough people do.", "The only way to do great work is to love what you do."],
+        "Healing": ["Every wound has its own time to heal.", "It's okay to take your time to feel better.", "Healing is not linear, and that's perfectly okay."],
+        "Relationships": ["The best relationships are built on trust.", "Love is not about possession but appreciation.", "Healthy relationships require both people to show up authentically."]
+    }
+    
+    # UI for quote selection and file upload
+    col1, col2 = st.columns(2)
+    with col1:
+        selected_category = st.selectbox("🎯 Choose a quote theme:", list(quote_categories.keys()))
+    with col2:
+        uploaded_quotes = st.file_uploader("📁 Upload your own quotes (.txt)", type=["txt"])
+    
+    uploaded_audio = st.file_uploader("🎤 Upload a voice message (.wav)", type=["wav"])
+    
+    # Handle vectorstore
+    current_quotes = []
+    vectorstore = None
+    
+    if uploaded_quotes:
+        custom_quotes = uploaded_quotes.read().decode("utf-8").splitlines()
+        custom_quotes = [quote.strip() for quote in custom_quotes if quote.strip()]
+        vectorstore = build_user_vectorstore(username, custom_quotes)
+        current_quotes = custom_quotes
+        st.success(f"✅ {len(custom_quotes)} custom quotes uploaded and saved!")
+    else:
+        default_quotes = quote_categories[selected_category]
+        vectorstore = load_user_vectorstore(username)
+        if vectorstore is None:
+            vectorstore = build_user_vectorstore(username, default_quotes)
+        current_quotes = default_quotes
+    
+    # Voice transcription
+    if uploaded_audio and st.button("🎙️ Transcribe Voice"):
+        with st.spinner("Transcribing your voice..."):
+            transcribed = transcribe_audio_file(uploaded_audio)
+            if transcribed.startswith("Error:"):
+                st.error(transcribed)
+            else:
+                st.session_state.transcribed_text = transcribed
+                st.success("✅ Voice transcribed successfully!")
+    
+    # Input area
+    user_input = st.text_area(
+        "💬 What's on your mind?",
+        value=st.session_state.transcribed_text,
+        height=100,
+        placeholder="Share your thoughts, feelings, or experiences..."
+    )
+    
+    final_input = user_input.strip() or st.session_state.transcribed_text.strip()
+    
+    # Main interaction button
+    if st.button("🧠 Talk to DilBot", type="primary"):
+        if not final_input:
+            st.warning("⚠️ Please enter something to share or upload a voice message.")
+        else:
+            with st.spinner("DilBot is thinking and feeling..."):
+                # Emotion detection
+                emotion, score = detect_emotion(final_input)
+                
+                # Get AI response
+                prompt_template = PromptTemplate(
+                    input_variables=["context", "user_input", "username"],
+                    template="""You are DilBot, an empathetic emotional support AI companion for {username}. 
+Use the following emotional quote context to respond gently, supportively, and personally.
+Context quotes:
+{context}
+User's message:
+{user_input}
+Respond as DilBot with warmth, empathy, and understanding. Keep it conversational and supportive."""
+                )
+                
+                # Get similar quotes
+                similar_docs = vectorstore.similarity_search(final_input, k=2)
+                context = "\n".join([doc.page_content for doc in similar_docs])
+                
+                # Generate response
+                groq_llm = ChatGroq(api_key=GROQ_API_KEY, model="llama3-70b-8192")
+                chain = LLMChain(llm=groq_llm, prompt=prompt_template)
+                response = chain.run(context=context, user_input=final_input, username=username)
+                
+                # Save to user's journal
+                save_user_journal(username, final_input, emotion, score, response)
+                
+                # Display results
+                col1, col2 = st.columns([2, 1])
+                with col1:
+                    st.success(f"**Emotion Detected:** {emotion.capitalize()} ({round(score*100)}% confidence)")
+                with col2:
+                    if is_crisis(final_input):
+                        st.error("🚨 Crisis detected! Please reach out to a mental health professional immediately.")
+                
+                # Show relevant quote
+                if current_quotes:
+                    model = SentenceTransformer("all-MiniLM-L6-v2")
+                    quote_embeddings = model.encode(current_quotes, convert_to_tensor=True)
+                    user_embedding = model.encode(final_input, convert_to_tensor=True)
+                    sims = util.pytorch_cos_sim(user_embedding, quote_embeddings)[0]
+                    best_match = sims.argmax().item()
+                    selected_quote = current_quotes[best_match]
+                    st.info(f"💭 **Quote for you:** *{selected_quote}*")
+                
+                # Show response
+                st.markdown("### 🤖 DilBot's Response:")
+                st.markdown(f"> {response}")
+                
+                # Audio response
+                speak(response, username)
+                
+                # Clear transcribed text after successful interaction
+                st.session_state.transcribed_text = ""
+    
+    # User's personal dashboard
+    st.markdown("---")
+    st.header("📊 Your Personal Dashboard")
+    
+    # Load user's journal
+    journal_data = load_user_journal(username)
+    
+    if journal_data:
+        # Mood tracker
+        st.subheader("📈 Your Daily Mood Tracker")
+        
+        # Prepare data for chart
+        df_data = []
+        for entry in journal_data:
+            df_data.append({
+                "date": entry["date"],
+                "emotion": entry["emotion"].capitalize(),
+                "confidence": entry["confidence"]
+            })
+        
+        if df_data:
+            chart = alt.Chart(alt.Data(values=df_data)).mark_bar().encode(
+                x=alt.X('date:N', title='Date'),
+                y=alt.Y('count():Q', title='Frequency'),
+                color=alt.Color('emotion:N', title='Emotion'),
+                tooltip=['date:N', 'emotion:N', 'count():Q']
+            ).properties(
+                width=600,
+                height=300,
+                title="Your Emotional Journey Over Time"
+            )
+            st.altair_chart(chart, use_container_width=True)
+        
+        # Recent conversations
+        st.subheader("💬 Recent Conversations")
+        recent_entries = journal_data[-5:] if len(journal_data) >= 5 else journal_data
+        
+        for i, entry in enumerate(reversed(recent_entries)):
+            with st.expander(f"📅 {entry['date']} - {entry['emotion'].capitalize()} ({entry['confidence']}%)"):
+                st.markdown(f"**You said:** {entry['user_input']}")
+                st.markdown(f"**DilBot replied:** {entry['response']}")
+        
+        # Statistics
+        st.subheader("📊 Your Emotional Statistics")
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Total Conversations", len(journal_data))
+        
+        with col2:
+            emotions = [entry['emotion'] for entry in journal_data]
+            most_common = max(set(emotions), key=emotions.count) if emotions else "None"
+            st.metric("Most Common Emotion", most_common.capitalize())
+        
+        with col3:
+            if journal_data:
+                avg_confidence = sum(entry['confidence'] for entry in journal_data) / len(journal_data)
+                st.metric("Avg. Confidence", f"{avg_confidence:.1f}%")
+    
+    else:
+        st.info("🌟 Start your first conversation with DilBot to see your personal dashboard!")
+    
+    st.markdown("---")
+    st.caption("Built by Members of CSG Hackathon Team | Your data is stored privately and securely")
+
+# Main app logic
+def main():
+    if not st.session_state.authenticated:
+        show_auth_page()
+    elif st.session_state.is_admin:
+        show_admin_dashboard()
+    else:
+        show_main_app()
+
+if __name__ == "__main__":
+    main()