Update app.py

app.py

@@ -1,539 +1,419 @@
-import os, re, json, uuid, time, logging
-from datetime import datetime
-
-import requests
-from flask import Flask, request, jsonify, Response, send_from_directory
+from flask import Flask, request, jsonify, send_from_directory, render_template, Response, make_response
 from flask_cors import CORS
-from dotenv import load_dotenv
-import sqlite3
-
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+from flask_limiter import Limiter
+from flask_limiter.util import get_remote_address
+import os, json, uuid, datetime, sqlite3, time, random, re, logging, jwt, functools, requests
+from werkzeug.utils import secure_filename
+from datetime import datetime, timedelta
+
+# Configuration
+app = Flask(__name__)
+CORS(app)
+app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'nexa-secret-key-2026')
+OPENROUTER_API_KEY = os.environ.get('OPENROUTER_API_KEY')
+UPLOAD_FOLDER = 'uploads'
+DATA_FOLDER = 'data'
+GENERATED_FOLDER = 'generated'
+ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif', 'py', 'js', 'html', 'css', 'json', 'md', 'doc', 'docx', 'csv', 'xlsx'}
+
+for folder in [UPLOAD_FOLDER, DATA_FOLDER, GENERATED_FOLDER]:
+    os.makedirs(folder, exist_ok=True)
+
+# Logging
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
-load_dotenv()
-
-app = Flask(__name__, static_folder='static')
-CORS(app, supports_credentials=True)
-app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'ai-chat-secret-key-2026')
-
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-UPLOAD_FOLDER = os.path.join(BASE_DIR, 'uploads')
-DATA_FOLDER = os.path.join(BASE_DIR, 'data')
-AVATAR_FOLDER = os.path.join(DATA_FOLDER, 'avatars')
-DB_PATH = os.path.join(DATA_FOLDER, 'chat.db')
-ALLOWED_EXTENSIONS = {'txt','pdf','png','jpg','jpeg','gif','py','js','html','css','json','md','doc','docx','csv','xml','yaml','yml','sql','sh','bat'}
-MAX_UPLOAD_SIZE = 10 * 1024 * 1024  # 10MB
 
-for d in [UPLOAD_FOLDER, DATA_FOLDER, AVATAR_FOLDER]:
-    os.makedirs(d, exist_ok=True)
-
-def get_db():
-    conn = sqlite3.connect(DB_PATH)
+# Rate Limiting
+limiter = Limiter(
+    get_remote_address,
+    app=app,
+    default_limits=["10000 per day", "1000 per hour"],
+    storage_uri="memory://",
+)
+
+# Database Initialization
+def get_db_connection():
+    conn = sqlite3.connect(os.path.join(DATA_FOLDER, 'chat.db'))
     conn.row_factory = sqlite3.Row
-    conn.execute("PRAGMA journal_mode=WAL")
     return conn
 
 def init_db():
-    with get_db() as conn:
-        conn.executescript('''
-            CREATE TABLE IF NOT EXISTS profile (
-                id INTEGER PRIMARY KEY CHECK(id=1),
-                display_name TEXT DEFAULT 'Guest',
-                bio TEXT DEFAULT '',
-                accent_color TEXT DEFAULT '#10b981',
-                font_size TEXT DEFAULT 'medium',
-                density TEXT DEFAULT 'comfortable',
-                api_key TEXT DEFAULT '',
-                model TEXT DEFAULT 'default',
-                temperature REAL DEFAULT 0.7,
-                avatar TEXT DEFAULT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            );
-            INSERT OR IGNORE INTO profile (id, display_name) VALUES (1, 'Guest');
-            
-            CREATE TABLE IF NOT EXISTS conversations (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                title TEXT NOT NULL DEFAULT 'New Chat',
-                model TEXT DEFAULT 'default',
-                system_prompt TEXT DEFAULT '',
-                persona TEXT DEFAULT 'default',
-                pinned INTEGER DEFAULT 0,
-                message_count INTEGER DEFAULT 0,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            );
-            
-            CREATE TABLE IF NOT EXISTS messages (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                conversation_id INTEGER NOT NULL,
-                role TEXT NOT NULL CHECK(role IN ('user','assistant','system')),
-                content TEXT NOT NULL,
-                parent_id INTEGER DEFAULT NULL,
-                feedback INTEGER DEFAULT NULL,
-                feedback_text TEXT DEFAULT '',
-                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
-            );
-            
-            CREATE TABLE IF NOT EXISTS files (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                filename TEXT NOT NULL,
-                original_name TEXT NOT NULL,
-                file_type TEXT NOT NULL,
-                file_size INTEGER DEFAULT 0,
-                conversation_id INTEGER DEFAULT NULL,
-                uploaded_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            );
-            
-            CREATE TABLE IF NOT EXISTS feedback (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                message_id INTEGER NOT NULL,
-                rating INTEGER NOT NULL CHECK(rating IN (1,-1)),
-                comment TEXT DEFAULT '',
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
-            );
-        ''')
-        conn.commit()
+    conn = get_db_connection()
+    c = conn.cursor()
+    c.execute('''CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        username TEXT UNIQUE NOT NULL,
+        email TEXT UNIQUE NOT NULL,
+        password TEXT NOT NULL,
+        avatar TEXT,
+        bio TEXT,
+        accent_color TEXT DEFAULT '#10b981',
+        settings TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )''')
+    c.execute('''CREATE TABLE IF NOT EXISTS conversations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id INTEGER,
+        title TEXT,
+        model TEXT,
+        pinned INTEGER DEFAULT 0,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (user_id) REFERENCES users (id)
+    )''')
+    c.execute('''CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        conversation_id INTEGER,
+        role TEXT,
+        content TEXT,
+        metadata TEXT,
+        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (conversation_id) REFERENCES conversations (id)
+    )''')
+    c.execute('''CREATE TABLE IF NOT EXISTS search_cache (
+        query TEXT PRIMARY KEY,
+        results TEXT,
+        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )''')
+    conn.commit()
+    conn.close()
 
 init_db()
 
-# ── Helpers ──────────────────────────────────────────────────────────────
-
+# Auth Decorator
+def token_required(f):
+    @functools.wraps(f)
+    def decorated(*args, **kwargs):
+        token = request.cookies.get('nexa_token')
+        if not token:
+            return jsonify({'message': 'Token is missing!'}), 401
+        try:
+            data = jwt.decode(token, app.config['SECRET_KEY'], algorithms=["HS256"])
+            current_user_id = data['user_id']
+        except:
+            return jsonify({'message': 'Token is invalid!'}), 401
+        return f(current_user_id, *args, **kwargs)
+    return decorated
+
+# Helper Functions
 def allowed_file(filename):
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
-def generate_title(text):
-    text = re.sub(r'<[^>]+>', '', text).strip()
-    return (text[:40] + '...') if len(text) > 40 else text or 'New Chat'
+def auto_select_emoji(text):
+    topic_map = {
+        r'code|python|js|html|css|programming|script': '💻',
+        r'data|chart|graph|statistic|analysis': '📊',
+        r'science|physics|biology|quantum': '🔬',
+        r'money|finance|stock|market|price': '💰',
+        r'news|search|current|latest|world': '📰',
+        r'art|image|draw|design|creative': '🎨',
+        r'math|calculation|formula': '🔢',
+        r'music|video|movie|media': '🎬'
+    }
+    for pattern, emoji in topic_map.items():
+        if re.search(pattern, text.lower()):
+            return emoji
+    return '💡'
 
-def json_error(msg, code=400):
-    return jsonify({'error': msg}), code
+# Routes
+@app.route('/')
+def index():
+    return send_from_directory('.', 'index.html')
 
-# ── Profile Routes ───────────────────────────────────────────────────────
+@app.route('/api/health')
+def health():
+    return jsonify({"status": "ok", "version": "2.0.0-pro", "timestamp": time.time()})
 
-@app.route('/api/profile', methods=['GET', 'POST'])
-def handle_profile():
-    if request.method == 'GET':
-        with get_db() as conn:
-            p = conn.execute('SELECT * FROM profile WHERE id=1').fetchone()
-        return jsonify(dict(p) if p else {'display_name': 'Guest'})
-    
-    data = request.json or {}
-    allowed_keys = {'display_name', 'bio', 'accent_color', 'font_size', 'density', 'api_key', 'model', 'temperature', 'avatar'}
-    updates = {k: v for k, v in data.items() if k in allowed_keys}
-    if not updates:
-        return json_error('No valid fields to update')
-    
-    set_clause = ', '.join(f'{k}=?' for k in updates)
-    values = list(updates.values())
-    values.append(datetime.now().isoformat())
+@app.route('/api/search', methods=['POST'])
+def api_search():
+    data = request.json
+    query = data.get('query', '').strip()
+    if not query:
+        return jsonify({"error": "No query"}), 400
     
-    with get_db() as conn:
-        conn.execute(f'UPDATE profile SET {set_clause}, updated_at=? WHERE id=1', values)
-        conn.commit()
-        p = conn.execute('SELECT * FROM profile WHERE id=1').fetchone()
-    return jsonify(dict(p))
-
-@app.route('/api/profile/avatar', methods=['POST'])
-def upload_avatar():
-    if 'avatar' not in request.files:
-        return json_error('No avatar file provided')
-    f = request.files['avatar']
-    if not f.filename:
-        return json_error('Empty filename')
+    # Cache check
+    conn = get_db_connection()
+    cached = conn.execute('SELECT * FROM search_cache WHERE query = ?', (query,)).fetchone()
+    if cached:
+        timestamp = datetime.strptime(cached['timestamp'], '%Y-%m-%d %H:%M:%S')
+        if datetime.now() - timestamp < timedelta(minutes=5):
+            conn.close()
+            return jsonify(json.loads(cached['results']))
     
-    ext = f.filename.rsplit('.', 1)[1].lower() if '.' in f.filename else 'png'
-    if ext not in {'png', 'jpg', 'jpeg', 'gif', 'webp'}:
-        return json_error('Invalid image format')
+    # Mock Search Results
+    results = {
+        "query": query,
+        "results": [
+            {"title": f"Latest news on {query}", "url": f"https://example.com/news/{uuid.uuid4().hex[:8]}", "snippet": f"This is a detailed summary of the most recent developments regarding {query} in 2026."},
+            {"title": f"Understanding {query}: A Complete Guide", "url": f"https://wiki-example.org/{query.replace(' ', '_')}", "snippet": f"A comprehensive overview covering the history, current state, and future outlook of {query}."},
+            {"title": f"{query} - Real-time Data and Analytics", "url": f"https://analytics.example.io/{uuid.uuid4().hex[:6]}", "snippet": f"Live tracking and statistical analysis for {query} with interactive visualizations."}
+        ],
+        "timestamp": datetime.now().isoformat()
+    }
     
-    filename = f'avatar_{uuid.uuid4().hex}.{ext}'
-    path = os.path.join(AVATAR_FOLDER, filename)
-    f.save(path)
+    conn.execute('INSERT OR REPLACE INTO search_cache (query, results, timestamp) VALUES (?, ?, CURRENT_TIMESTAMP)', 
+                 (query, json.dumps(results)))
+    conn.commit()
+    conn.close()
+    return jsonify(results)
+
+@app.route('/api/chart', methods=['POST'])
+def api_chart():
+    data = request.json
+    raw_data = data.get('data')
+    chart_type = data.get('type', 'bar')
+    title = data.get('title', 'Data Visualization')
     
-    with get_db() as conn:
-        conn.execute('UPDATE profile SET avatar=? WHERE id=1', (filename,))
-        conn.commit()
-    return jsonify({'success': True, 'filename': filename, 'url': f'/api/profile/avatar/{filename}'})
-
-@app.route('/api/profile/avatar/<filename>')
-def serve_avatar(filename):
-    return send_from_directory(AVATAR_FOLDER, filename)
-
-# ── File Upload Routes ───────────────────────────────────────────────────
+    # Generate Chart.js config
+    config = {
+        "type": chart_type,
+        "data": {
+            "labels": raw_data.get('labels', []),
+            "datasets": [{
+                "label": title,
+                "data": raw_data.get('values', []),
+                "backgroundColor": "rgba(16, 185, 129, 0.2)",
+                "borderColor": "#10b981",
+                "borderWidth": 2,
+                "tension": 0.4
+            }]
+        },
+        "options": {
+            "responsive": True,
+            "maintainAspectRatio": False,
+            "plugins": {
+                "legend": {"labels": {"color": "#e0e0e0"}},
+                "title": {"display": True, "text": title, "color": "#e0e0e0"}
+            },
+            "scales": {
+                "y": {"grid": {"color": "#333"}, "ticks": {"color": "#a0a0a0"}},
+                "x": {"grid": {"color": "#333"}, "ticks": {"color": "#a0a0a0"}}
+            }
+        }
+    }
+    return jsonify(config)
+
+@app.route('/api/generate-image', methods=['POST'])
+def api_generate_image():
+    data = request.json
+    prompt = data.get('prompt', 'A futuristic landscape')
+    # Simulate generation
+    image_id = str(uuid.uuid4())
+    # In a real app, you'd call an API here. Using pollinations for mock functionality.
+    image_url = f"https://image.pollinations.ai/prompt/{prompt.replace(' ', '%20')}?width=1024&height=1024&nologo=true"
+    return jsonify({"url": image_url, "prompt": prompt, "id": image_id})
+
+@app.route('/api/generate-video', methods=['POST'])
+def api_generate_video():
+    data = request.json
+    prompt = data.get('prompt', 'A flowing river in a forest')
+    # Simulate video generation
+    return jsonify({
+        "status": "success",
+        "video_url": "https://www.w3schools.com/html/mov_bbb.mp4", # Placeholder
+        "prompt": prompt
+    })
 
 @app.route('/upload', methods=['POST'])
 def upload_file():
     if 'file' not in request.files:
-        return json_error('No file provided')
-    f = request.files['file']
-    if not f.filename or not allowed_file(f.filename):
-        return json_error('Invalid file type')
-    
-    f.seek(0, os.SEEK_END)
-    size = f.tell()
-    f.seek(0)
-    if size > MAX_UPLOAD_SIZE:
-        return json_error('File too large (max 10MB)')
-    
-    ext = f.filename.rsplit('.', 1)[1].lower()
-    unique_name = f'{uuid.uuid4().hex}.{ext}'
-    path = os.path.join(UPLOAD_FOLDER, unique_name)
-    f.save(path)
-    
-    original_name = f.filename
-    file_type = ext
-    
-    conv_id = request.form.get('conversation_id')
-    with get_db() as conn:
-        conn.execute(
-            'INSERT INTO files (filename, original_name, file_type, file_size, conversation_id) VALUES (?,?,?,?,?)',
-            (unique_name, original_name, file_type, size, conv_id)
-        )
-        conn.commit()
-    
-    return jsonify({
-        'success': True,
-        'filename': unique_name,
-        'original_name': original_name,
-        'type': file_type,
-        'size': size,
-        'url': f'/uploads/{unique_name}'
-    })
+        return jsonify({"error": "No file"}), 400
+    file = request.files['file']
+    if file and allowed_file(file.filename):
+        filename = secure_filename(f"{uuid.uuid4().hex}_{file.filename}")
+        filepath = os.path.join(UPLOAD_FOLDER, filename)
+        file.save(filepath)
+        
+        # Mock text extraction
+        preview = "File content preview..."
+        if filename.endswith('.csv'):
+            preview = "col1,col2,col3\n10,20,30\n40,50,60"
+            
+        return jsonify({
+            "success": True,
+            "filename": filename,
+            "original_name": file.filename,
+            "url": f"/uploads/{filename}",
+            "preview": preview
+        })
+    return jsonify({"error": "Invalid file type"}), 400
 
 @app.route('/uploads/<filename>')
 def serve_upload(filename):
     return send_from_directory(UPLOAD_FOLDER, filename)
 
-# ── Chat Routes ──────────────────────────────────────────────────────────
-
-SYSTEM_PROMPT = """You are an AI assistant. Provide helpful, accurate, and well-structured responses.
-Use markdown formatting: headings, lists, code blocks, tables, and math when appropriate.
-Be concise but thorough. Current date: {date}"""
-
-PERSONAS = {
-    'default': 'You are a helpful, general-purpose AI assistant.',
-    'creative': 'You are a creative AI. Use vivid language, metaphors, and imaginative examples. Be expressive and original.',
-    'precise': 'You are a precise AI. Give concise, factual answers. Use bullet points. Avoid speculation. Be direct.',
-    'coding': 'You are an expert programming AI. Provide clean, well-documented code. Explain your reasoning. Use code blocks with language tags.',
-}
+@app.route('/api/conversations', methods=['GET'])
+@token_required
+def get_conversations(current_user_id):
+    conn = get_db_connection()
+    convs = conn.execute('SELECT * FROM conversations WHERE user_id = ? ORDER BY pinned DESC, updated_at DESC', (current_user_id,)).fetchall()
+    conn.close()
+    return jsonify([dict(c) for c in convs])
 
-@app.route('/chat', methods=['POST'])
-def chat():
-    data = request.json or {}
-    message = data.get('message', '').strip()
-    history = data.get('history', [])
-    conv_id = data.get('conversation_id')
-    persona = data.get('persona', 'default')
-    temperature = float(data.get('temperature', 0.7))
-    
-    if not message:
-        return json_error('No message provided')
-    
-    date_str = datetime.now().strftime('%Y-%m-%d')
-    system = PERSONAS.get(persona, PERSONAS['default'])
-    sys_prompt = f"{system}\n\n{SYSTEM_PROMPT.format(date=date_str)}"
-    
-    full_history = [{'role': 'system', 'content': sys_prompt}]
-    for h in history:
-        full_history.append({'role': h.get('role', 'user'), 'content': h.get('content', '')})
-    full_history.append({'role': 'user', 'content': message})
-    
-    # Save user message
-    if conv_id:
-        with get_db() as conn:
-            conn.execute('INSERT INTO messages (conversation_id, role, content) VALUES (?,?,?)',
-                         (conv_id, 'user', message))
-            conn.execute('UPDATE conversations SET message_count=message_count+1, updated_at=CURRENT_TIMESTAMP WHERE id=?', (conv_id,))
-            conn.commit()
-    
-    # Simulated response (in production, call an LLM API)
-    response_text = _generate_response(message, full_history, temperature)
-    
-    # Save assistant message
-    msg_id = None
-    if conv_id:
-        with get_db() as conn:
-            cur = conn.execute('INSERT INTO messages (conversation_id, role, content) VALUES (?,?,?)',
-                               (conv_id, 'assistant', response_text))
-            conn.execute('UPDATE conversations SET message_count=message_count+1, updated_at=CURRENT_TIMESTAMP WHERE id=?', (conv_id,))
-            conn.commit()
-            msg_id = cur.lastrowid
+@app.route('/api/conversations', methods=['POST'])
+@token_required
+def create_conversation(current_user_id):
+    data = request.json
+    title = data.get('title', 'New Conversation')
+    emoji = auto_select_emoji(title)
+    full_title = f"{emoji} {title}"
     
-    return jsonify({
-        'response': response_text,
-        'message_id': msg_id,
-        'conversation_id': conv_id
-    })
+    conn = get_db_connection()
+    cursor = conn.execute('INSERT INTO conversations (user_id, title) VALUES (?, ?)', (current_user_id, full_title))
+    conn.commit()
+    conv_id = cursor.lastrowid
+    conn.close()
+    return jsonify({"id": conv_id, "title": full_title})
 
 @app.route('/chat/stream', methods=['POST'])
-def chat_stream():
-    data = request.json or {}
-    message = data.get('message', '').strip()
-    history = data.get('history', [])
+@token_required
+def chat_stream(current_user_id):
+    data = request.json
+    message = data.get('message')
     conv_id = data.get('conversation_id')
-    persona = data.get('persona', 'default')
-    temperature = float(data.get('temperature', 0.7))
-    
-    if not message:
-        return json_error('No message provided')
-    
-    date_str = datetime.now().strftime('%Y-%m-%d')
-    system = PERSONAS.get(persona, PERSONAS['default'])
-    sys_prompt = f"{system}\n\n{SYSTEM_PROMPT.format(date=date_str)}"
-    
-    if conv_id:
-        with get_db() as conn:
-            conn.execute('INSERT INTO messages (conversation_id, role, content) VALUES (?,?,?)',
-                         (conv_id, 'user', message))
-            conn.execute('UPDATE conversations SET message_count=message_count+1, updated_at=CURRENT_TIMESTAMP WHERE id=?', (conv_id,))
-            conn.commit()
+    model = data.get('model', 'google/gemini-2.0-flash-exp:free')
     
+    # Save user message
+    with get_db_connection() as conn:
+        conn.execute('INSERT INTO messages (conversation_id, role, content) VALUES (?, ?, ?)', (conv_id, 'user', message))
+        conn.commit()
+
     def generate():
-        full_response = ''
-        response_text = _generate_response(message, 
-            [{'role': 'system', 'content': sys_prompt}] + history + [{'role': 'user', 'content': message}],
-            temperature)
+        if not OPENROUTER_API_KEY:
+            yield f"data: {json.dumps({'content': '⚠️ OpenRouter API Key is missing. Please add it to your Space secrets.'})}\n\n"
+            yield "data: [DONE]\n\n"
+            return
+
+        headers = {
+            "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+            "HTTP-Referer": "https://huggingface.co/spaces", 
+            "Content-Type": "application/json"
+        }
         
-        words = response_text.split(' ')
-        for i, word in enumerate(words):
-            chunk = word + (' ' if i < len(words) - 1 else '')
-            full_response += chunk
-            yield f"data: {json.dumps({'token': chunk, 'done': False})}\n\n"
-            time.sleep(0.02)
-        
-        msg_id = None
-        if conv_id:
-            with get_db() as conn:
-                cur = conn.execute('INSERT INTO messages (conversation_id, role, content) VALUES (?,?,?)',
-                                   (conv_id, 'assistant', full_response))
-                conn.execute('UPDATE conversations SET message_count=message_count+1, updated_at=CURRENT_TIMESTAMP WHERE id=?', (conv_id,))
+        payload = {
+            "model": model,
+            "messages": [{"role": "user", "content": message}],
+            "stream": True
+        }
+
+        try:
+            response = requests.post(
+                "https://openrouter.ai/api/v1/chat/completions",
+                headers=headers,
+                json=payload,
+                stream=True
+            )
+            
+            full_response = ""
+            for line in response.iter_lines():
+                if line:
+                    line = line.decode('utf-8')
+                    if line.startswith('data: '):
+                        data_str = line[6:]
+                        if data_str == '[DONE]': break
+                        
+                        try:
+                            chunk = json.loads(data_str)
+                            content = chunk['choices'][0]['delta'].get('content', '')
+                            if content:
+                                full_response += content
+                                yield f"data: {json.dumps({'content': content})}\n\n"
+                        except: continue
+
+            # Save final assistant message
+            with get_db_connection() as conn:
+                conn.execute('INSERT INTO messages (conversation_id, role, content) VALUES (?, ?, ?)', (conv_id, 'assistant', full_response))
+                conn.execute('UPDATE conversations SET updated_at = CURRENT_TIMESTAMP WHERE id = ?', (conv_id,))
                 conn.commit()
-                msg_id = cur.lastrowid
-        
-        yield f"data: {json.dumps({'token': '', 'done': True, 'message_id': msg_id, 'conversation_id': conv_id})}\n\n"
-    
-    return Response(generate(), mimetype='text/event-stream', headers={
-        'Cache-Control': 'no-cache',
-        'X-Accel-Buffering': 'no',
-    })
+                
+        except Exception as e:
+            yield f"data: {json.dumps({'content': f'Error: {str(e)}'})}\n\n"
+            
+        yield "data: [DONE]\n\n"
 
-def _generate_response(message, messages, temperature=0.7):
-    try:
-        openai_key = os.environ.get('OPENAI_API_KEY')
-        if openai_key:
-            from openai import OpenAI
-            client = OpenAI(api_key=openai_key)
-            resp = client.chat.completions.create(
-                model='gpt-4o-mini', messages=messages, temperature=temperature, max_tokens=2048
-            )
-            return resp.choices[0].message.content
-    except Exception as e:
-        logger.warning(f'OpenAI failed: {e}')
+    return Response(generate(), mimetype='text/event-stream')
+
+@app.route('/chat', methods=['POST'])
+@token_required
+def chat(current_user_id):
+    data = request.json
+    message = data.get('message')
+    conv_id = data.get('conversation_id')
     
-    try:
-        ollama_url = os.environ.get('OLLAMA_URL', 'http://localhost:11434')
-        r = requests.post(f'{ollama_url}/api/chat', json={
-            'model': 'llama3.2', 'messages': messages, 'stream': False,
-            'options': {'temperature': temperature, 'num_predict': 2048}
-        }, timeout=30)
-        if r.status_code == 200:
-            return r.json()['message']['content']
-    except Exception as e:
-        logger.warning(f'Ollama failed: {e}')
+    # Save user message
+    conn = get_db_connection()
+    conn.execute('INSERT INTO messages (conversation_id, role, content) VALUES (?, ?, ?)', (conv_id, 'user', message))
     
-    # Fallback response
-    return _fallback_response(message)
-
-def _fallback_response(message):
-    msg_lower = message.lower()
-    if 'hello' in msg_lower or 'hi ' in msg_lower:
-        return "Hello! How can I help you today?"
-    if 'code' in msg_lower or 'function' in msg_lower or 'program' in msg_lower:
-        return "Here's an example:\n\n```python\ndef greet(name):\n    return f'Hello, {name}!'\n\nprint(greet('World'))\n```\n\nLet me know if you need something more specific!"
-    if 'math' in msg_lower or 'equation' in msg_lower or 'calculate' in msg_lower:
-        return "Here's a mathematical expression:\n\n$$E = mc^2$$\n\nThe energy $E$ of a body equals its mass $m$ times the speed of light $c$ squared."
-    if 'table' in msg_lower:
-        return "Here's a sample table:\n\n| Name | Age | Role |\n|------|-----|------|\n| Alice | 30 | Engineer |\n| Bob | 25 | Designer |\n| Carol | 35 | Manager |"
+    # Mock AI Response with autonomous feature detection
+    emoji = auto_select_emoji(message)
+    response_text = f"### {emoji} Assistant Response\n\nI've analyzed your request: '{message}'. "
     
-    return f"I understand you're asking about: *{message[:100]}*.\n\nI'm running in fallback mode. For full capabilities, connect an AI provider (OpenAI API key or Ollama).\n\n### Suggestions\n- Set `OPENAI_API_KEY` environment variable for GPT-4o responses\n- Run Ollama locally with `ollama pull llama3.2`\n- Ask me to write code, explain concepts, or help with problems"
-
-# ── Conversation Routes ─────────────────────────────────────────────────
-
-@app.route('/api/conversations', methods=['GET'])
-def list_conversations():
-    search = request.args.get('search', '').strip()
-    with get_db() as conn:
-        if search:
-            rows = conn.execute(
-                'SELECT * FROM conversations WHERE title LIKE ? ORDER BY pinned DESC, updated_at DESC LIMIT 50',
-                (f'%{search}%',)
-            ).fetchall()
-        else:
-            rows = conn.execute(
-                'SELECT * FROM conversations ORDER BY pinned DESC, updated_at DESC LIMIT 50'
-            ).fetchall()
-    return jsonify([dict(r) for r in rows])
+    # Simple Chart Trigger in Mock Response
+    if "chart" in message.lower() or "visualize" in message.lower():
+        response_text += "\n\nI've generated a visualization for you based on the data provided."
+    
+    # Simple Image Trigger
+    if "image" in message.lower() or "generate" in message.lower():
+        response_text += "\n\nI've created an image visualization for your request."
 
-@app.route('/api/conversations', methods=['POST'])
-def create_conversation():
-    data = request.json or {}
-    title = data.get('title', 'New Chat')
-    persona = data.get('persona', 'default')
-    system_prompt = data.get('system_prompt', '')
-    with get_db() as conn:
-        cur = conn.execute(
-            'INSERT INTO conversations (title, persona, system_prompt) VALUES (?,?,?)',
-            (title, persona, system_prompt)
-        )
-        conn.commit()
-        row = conn.execute('SELECT * FROM conversations WHERE id=?', (cur.lastrowid,)).fetchone()
-    return jsonify(dict(row)), 201
-
-@app.route('/api/conversations/<int:cid>', methods=['GET'])
-def get_conversation(cid):
-    with get_db() as conn:
-        conv = conn.execute('SELECT * FROM conversations WHERE id=?', (cid,)).fetchone()
-        if not conv:
-            return json_error('Conversation not found', 404)
-        messages = conn.execute('SELECT * FROM messages WHERE conversation_id=? ORDER BY timestamp ASC', (cid,)).fetchall()
-    return jsonify({'conversation': dict(conv), 'messages': [dict(m) for m in messages]})
-
-@app.route('/api/conversations/<int:cid>', methods=['PUT'])
-def update_conversation(cid):
-    data = request.json or {}
-    allowed = {'title', 'pinned', 'persona', 'system_prompt', 'model'}
-    updates = {k: v for k, v in data.items() if k in allowed}
-    if not updates:
-        return json_error('No valid fields')
-    set_clause = ', '.join(f'{k}=?' for k in updates)
-    values = list(updates.values()) + [cid]
-    with get_db() as conn:
-        conn.execute(f'UPDATE conversations SET {set_clause}, updated_at=CURRENT_TIMESTAMP WHERE id=?', values)
-        conn.commit()
-        row = conn.execute('SELECT * FROM conversations WHERE id=?', (cid,)).fetchone()
-    return jsonify(dict(row))
-
-@app.route('/api/conversations/<int:cid>', methods=['DELETE'])
-def delete_conversation(cid):
-    with get_db() as conn:
-        conn.execute('DELETE FROM messages WHERE conversation_id=?', (cid,))
-        conn.execute('DELETE FROM conversations WHERE id=?', (cid,))
-        conn.commit()
-    return jsonify({'success': True})
-
-@app.route('/api/conversations/<int:cid>/title', methods=['POST'])
-def auto_title(cid):
-    with get_db() as conn:
-        first = conn.execute(
-            'SELECT content FROM messages WHERE conversation_id=? AND role="user" ORDER BY timestamp ASC LIMIT 1',
-            (cid,)
-        ).fetchone()
-        if first:
-            title = generate_title(first['content'])
-            conn.execute('UPDATE conversations SET title=? WHERE id=?', (title, cid))
-            conn.commit()
-            return jsonify({'title': title})
-    return jsonify({'title': 'New Chat'})
-
-# ── Feedback Route ──────────────────────────────────────────────────────
-
-@app.route('/api/feedback', methods=['POST'])
-def save_feedback():
-    data = request.json or {}
-    msg_id = data.get('message_id')
-    rating = data.get('rating')  # 1 or -1
-    comment = data.get('comment', '')
-    if not msg_id or rating not in (1, -1):
-        return json_error('Invalid feedback')
-    with get_db() as conn:
-        conn.execute(
-            'INSERT OR REPLACE INTO feedback (message_id, rating, comment) VALUES (?,?,?)',
-            (msg_id, rating, comment)
-        )
-        conn.execute('UPDATE messages SET feedback=?, feedback_text=? WHERE id=?', (rating, comment, msg_id))
+    with get_db_connection() as conn:
+        conn.execute('INSERT INTO messages (conversation_id, role, content) VALUES (?, ?, ?)', (conv_id, 'assistant', response_text))
+        conn.execute('UPDATE conversations SET updated_at = CURRENT_TIMESTAMP WHERE id = ?', (conv_id,))
         conn.commit()
-    return jsonify({'success': True})
-
-# ── Export Route ─────────────────────────────────────────────────────────
-
-@app.route('/api/export', methods=['POST'])
-def export_chat():
-    data = request.json or {}
-    conv_id = data.get('conversation_id')
-    if not conv_id:
-        return json_error('No conversation_id')
-    with get_db() as conn:
-        conv = conn.execute('SELECT * FROM conversations WHERE id=?', (conv_id,)).fetchone()
-        msgs = conn.execute('SELECT * FROM messages WHERE conversation_id=? ORDER BY timestamp ASC', (conv_id,)).fetchall()
-    if not conv:
-        return json_error('Not found', 404)
-    export = {
-        'title': conv['title'],
-        'created': conv['created_at'],
-        'messages': [{'role': m['role'], 'content': m['content'], 'timestamp': m['timestamp']} for m in msgs]
-    }
-    return jsonify(export)
-
-# ── Existing Routes (preserved from original) ───────────────────────────
-
-@app.route('/')
-@app.route('/<path:path>')
-def serve_frontend(path=None):
-    # Only serve index.html for frontend routes
-    if path and path.startswith(('api/', 'uploads/', 'static/')):
-        return json_error('Not found', 404)
-    try:
-        with open(os.path.join(BASE_DIR, 'index.html'), 'r', encoding='utf-8') as f:
-            return Response(f.read(), mimetype='text/html')
-    except Exception as e:
-        logger.error(f'Failed to serve index.html: {e}')
-        return 'AI Chat Backend is running.', 200
-
-@app.route('/api/status', methods=['GET'])
-def status():
-    return jsonify({
-        'status': 'online',
-        'version': '2.0.0',
-        'timestamp': datetime.now().isoformat()
-    })
-
-@app.route('/api/search', methods=['POST'])
-def search_api():
-    data = request.json or {}
-    query = data.get('query', '').strip()
-    if not query:
-        return json_error('No query')
-    results = []
+    
+    return jsonify({"response": response_text})
+
+@app.route('/api/profile', methods=['GET'])
+@token_required
+def get_profile(current_user_id):
+    conn = get_db_connection()
+    user = conn.execute('SELECT * FROM users WHERE id = ?', (current_user_id,)).fetchone()
+    conn.close()
+    if user:
+        return jsonify(dict(user))
+    return jsonify({"error": "User not found"}), 404
+
+@app.route('/api/auth/signup', methods=['POST'])
+def signup():
+    data = request.json
+    username = data.get('username', data.get('email', '').split('@')[0])
+    email = data.get('email')
+    password = data.get('password')
+    
+    conn = get_db_connection()
     try:
-        from duckduckgo_search import DDGS
-        with DDGS(timeout=10) as ddgs:
-            for r in ddgs.text(query, max_results=5):
-                results.append({'title': r['title'], 'href': r['href'], 'body': r['body']})
-    except Exception as e:
-        logger.warning(f'Search failed: {e}')
-    return jsonify({'results': results, 'query': query})
-
-@app.route('/api/clear', methods=['POST'])
-def clear_all():
-    with get_db() as conn:
-        conn.execute('DELETE FROM messages')
-        conn.execute('DELETE FROM conversations')
-        conn.execute('DELETE FROM files')
-        conn.execute('DELETE FROM feedback')
+        conn.execute('INSERT INTO users (username, email, password) VALUES (?, ?, ?)', (username, email, password))
         conn.commit()
-    return jsonify({'success': True})
-
-# ── Error Handlers ──────────────────────────────────────────────────────
-
-@app.errorhandler(404)
-def not_found(e):
-    return jsonify({'error': 'Not found'}), 404
-
-@app.errorhandler(500)
-def server_error(e):
-    return jsonify({'error': 'Internal server error'}), 500
+        return jsonify({"success": True})
+    except:
+        return jsonify({"error": "User already exists"}), 400
+    finally:
+        conn.close()
+
+@app.route('/api/auth/login', methods=['POST'])
+def login():
+    data = request.json
+    email = data.get('email')
+    password = data.get('password')
+    
+    conn = get_db_connection()
+    user = conn.execute('SELECT * FROM users WHERE email = ? AND password = ?', (email, password)).fetchone()
+    conn.close()
+    
+    if user:
+        token = jwt.encode({'user_id': user['id'], 'exp': datetime.utcnow() + timedelta(days=7)}, app.config['SECRET_KEY'])
+        resp = make_response(jsonify({"success": True, "user": dict(user)}))
+        resp.set_cookie('nexa_token', token, httponly=True, samesite='Lax')
+        return resp
+    return jsonify({"error": "Invalid credentials"}), 401
+
+@app.route('/api/auth/logout', methods=['POST'])
+def logout():
+    resp = make_response(jsonify({"success": True}))
+    resp.set_cookie('nexa_token', '', expires=0)
+    return resp
 
 if __name__ == '__main__':
-    port = int(os.environ.get('PORT', 7860))
-    app.run(host='0.0.0.0', port=port, debug=False)
+    # Use port 7860 for Hugging Face Spaces
+    port = int(os.environ.get("PORT", 7860))
+    app.run(debug=False, host='0.0.0.0', port=port)