Update app.py

app.py

@@ -1,21 +1,24 @@
 """
-StudyFlow AI Backend - Complete Working Version
+StudyFlow AI Backend - Complete Working Version with REAL Question Generation
 """
 import os
 import json
 import sqlite3
 import hashlib
 import tempfile
+import re
 from datetime import datetime
+from typing import List, Dict
 
 from fastapi import FastAPI, UploadFile, File, Form, HTTPException
 from fastapi.responses import JSONResponse, HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
 import PyPDF2
 from youtube_transcript_api import YouTubeTranscriptApi
 
 # Initialize FastAPI
-app = FastAPI(title="StudyFlow AI", version="1.0.0")
+app = FastAPI(title="StudyFlow AI", version="2.0.0")
 
 # CORS middleware
 app.add_middleware(
@@ -42,6 +45,7 @@ def init_db():
             content_type TEXT NOT NULL,
             difficulty TEXT NOT NULL,
             content_hash TEXT,
+            raw_content TEXT,
             created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
             last_accessed TIMESTAMP DEFAULT CURRENT_TIMESTAMP
         )
@@ -106,24 +110,12 @@ def init_db():
         )
     ''')
     
-    # User profile table
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS user_profile (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            total_questions INTEGER DEFAULT 0,
-            correct_answers INTEGER DEFAULT 0,
-            total_study_time INTEGER DEFAULT 0,
-            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-    ''')
-    
     conn.commit()
     conn.close()
 
 # Initialize database
 init_db()
 
-# Helper functions
 def generate_id(text: str = None):
     """Generate a unique ID"""
     import uuid
@@ -137,13 +129,14 @@ def extract_text_from_pdf(file_path: str) -> str:
         with open(file_path, 'rb') as file:
             pdf_reader = PyPDF2.PdfReader(file)
             text = ""
-            for page in pdf_reader.pages[:10]:  # Limit to first 10 pages
+            for page in pdf_reader.pages[:15]:  # First 15 pages
                 page_text = page.extract_text()
                 if page_text:
                     text += page_text + "\n"
-        return text[:10000]  # Limit text length
+        return text[:15000]  # Limit text length
     except Exception as e:
-        return f"PDF extraction: {str(e)}"
+        print(f"PDF extraction error: {str(e)}")
+        return ""
 
 def extract_text_from_youtube(url: str) -> str:
     """Extract transcript from YouTube video"""
@@ -153,93 +146,187 @@ def extract_text_from_youtube(url: str) -> str:
         elif "youtu.be/" in url:
             video_id = url.split("/")[-1].split("?")[0]
         else:
-            return "Invalid YouTube URL"
+            return ""
         
         transcript = YouTubeTranscriptApi.get_transcript(video_id)
-        text = " ".join([entry['text'] for entry in transcript])
-        return text[:10000]  # Limit text length
+        text = " ".join([entry['text'] for entry in transcript[:50]])  # First 50 entries
+        return text[:15000]
     except Exception as e:
-        return f"YouTube: {str(e)}"
+        print(f"YouTube extraction error: {str(e)}")
+        return ""
+
+def extract_key_concepts(text: str, count: int = 8) -> List[str]:
+    """Extract key concepts from text using NLP-like approach"""
+    # Clean text
+    text = text.lower()
+    
+    # Remove common stop words
+    stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'having', 'do', 'does', 'did', 'doing', 'but', 'so', 'if', 'then', 'else', 'when', 'where', 'which', 'what', 'who', 'whom', 'this', 'that', 'these', 'those', 'it', 'they', 'we', 'you', 'he', 'she', 'it', 'them', 'her', 'him', 'us'}
+    
+    # Split into words and count frequencies
+    words = re.findall(r'\b[a-z]{4,}\b', text)
+    freq = {}
+    for word in words:
+        if word not in stop_words:
+            freq[word] = freq.get(word, 0) + 1
+    
+    # Get top words as concepts
+    sorted_words = sorted(freq.items(), key=lambda x: x[1], reverse=True)
+    concepts = [word for word, _ in sorted_words[:count]]
+    
+    # Also extract phrases (2-3 word sequences)
+    phrases = re.findall(r'\b[a-z]{3,}\s+[a-z]{3,}\b', text)
+    phrase_freq = {}
+    for phrase in phrases[:50]:
+        phrase_freq[phrase] = phrase_freq.get(phrase, 0) + 1
+    
+    top_phrases = sorted(phrase_freq.items(), key=lambda x: x[1], reverse=True)[:3]
+    concepts.extend([phrase for phrase, _ in top_phrases])
+    
+    # Remove duplicates and limit
+    unique_concepts = []
+    for concept in concepts:
+        if concept not in unique_concepts:
+            unique_concepts.append(concept)
+    
+    return unique_concepts[:count]
 
-def generate_questions(text: str, difficulty: str, count: int = 5) -> list:
-    """Generate questions from text"""
-    import re
+def generate_questions_from_content(text: str, difficulty: str, count: int = 5) -> List[Dict]:
+    """Generate REAL questions based on the actual content"""
+    
+    # Clean and prepare text
+    text = text.replace('\n', ' ').strip()
     sentences = re.split(r'[.!?]+', text)
-    sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
+    sentences = [s.strip() for s in sentences if len(s.strip()) > 30]
     
-    if not sentences:
-        sentences = [text[:200]]
+    if len(sentences) < 3:
+        # Fallback for very short text
+        sentences = text.split('.')[:5]
     
+    concepts = extract_key_concepts(text, 6)
     questions = []
-    for i, sentence in enumerate(sentences[:count]):
-        qid = generate_id(f"q_{i}")
+    
+    for i in range(min(count, len(sentences))):
+        sentence = sentences[i]
+        qid = generate_id(f"q_{i}_{difficulty}")
         
         if difficulty == "easy":
-            # Fill in the blank
+            # Fill in the blank with a key word from the sentence
             words = sentence.split()
-            if len(words) > 3:
-                blank_index = len(words) // 2
-                blank_word = words[blank_index]
-                question_text = sentence.replace(blank_word, "_____", 1)
+            if len(words) > 4:
+                # Find a meaningful word to blank out (not first or last 2 words)
+                blank_pos = min(len(words) - 3, max(2, len(words) // 2))
+                blank_word = words[blank_pos]
+                question_text = sentence.replace(blank_word, "_______", 1)
+                
                 questions.append({
                     "id": qid,
-                    "question_text": question_text,
+                    "question_text": f"Complete this sentence from the material: {question_text}",
                     "question_type": "fill_blank",
+                    "options": None,
                     "correct_answer": blank_word,
-                    "difficulty": difficulty,
-                    "explanation": f"The answer is '{blank_word}'"
+                    "difficulty": "easy",
+                    "explanation": f"The original sentence uses the word '{blank_word}' which is key to understanding this concept.",
+                    "concept": concepts[i % len(concepts)] if concepts else "Key Concept"
+                })
+            else:
+                # Short sentence - use true/false
+                questions.append({
+                    "id": qid,
+                    "question_text": f"Based on the material: '{sentence[:100]}'",
+                    "question_type": "true_false",
+                    "options": None,
+                    "correct_answer": "True",
+                    "difficulty": "easy",
+                    "explanation": "This statement appears in the study material.",
+                    "concept": concepts[i % len(concepts)] if concepts else "Key Concept"
                 })
         
         elif difficulty == "medium":
-            # True/False
-            question_text = f"True or False: '{sentence}'"
+            # Multiple choice based on content
+            concept = concepts[i % len(concepts)] if concepts else "the topic"
+            
+            # Generate plausible distractors
+            other_concepts = [c for c in concepts if c != concept][:3]
+            while len(other_concepts) < 3:
+                other_concepts.extend(["Important detail", "Background information", "Supporting example"])
+            
+            options = [f"The concept of {concept}", f"{other_concepts[0]}", f"{other_concepts[1]}", f"{other_concepts[2]}"]
+            
             questions.append({
                 "id": qid,
-                "question_text": question_text,
-                "question_type": "true_false",
-                "correct_answer": "0",
-                "difficulty": difficulty,
-                "explanation": "This statement appears to be true."
+                "question_text": f"What is the main idea expressed in: '{sentence[:120]}...'?",
+                "question_type": "multiple_choice",
+                "options": json.dumps(options),
+                "correct_answer": options[0],
+                "difficulty": "medium",
+                "explanation": f"The text emphasizes {concept} as a central theme. Understanding this helps grasp the overall message.",
+                "concept": concept
             })
         
         else:  # hard
-            # Multiple choice
-            question_text = f"What is the main idea? '{sentence[:100]}...'"
-            options = ["Detail", "Concept", "Question", "Example"]
+            # Short answer requiring deeper understanding
+            concept = concepts[i % len(concepts)] if concepts else "key concept"
+            
             questions.append({
                 "id": qid,
-                "question_text": question_text,
-                "question_type": "multiple_choice",
-                "options": json.dumps(options),
-                "correct_answer": "1",
-                "difficulty": difficulty,
-                "explanation": "This presents a general concept."
+                "question_text": f"Explain the significance of '{concept}' based on this passage: '{sentence[:150]}...' What makes it important to understanding the material?",
+                "question_type": "short_answer",
+                "options": None,
+                "correct_answer": f"The passage presents '{concept}' as an important element that contributes to the overall understanding of the subject. A good answer should explain how it fits into the broader context.",
+                "difficulty": "hard",
+                "explanation": "When studying, focus on how key concepts connect to each other and the main theme.",
+                "concept": concept
             })
     
-    return questions
+    # If we couldn't generate enough questions, add some general ones about the content
+    while len(questions) < count:
+        concept = concepts[len(questions) % len(concepts)] if concepts else "the material"
+        qid = generate_id(f"q_gen_{len(questions)}")
+        questions.append({
+            "id": qid,
+            "question_text": f"What is the main focus of the section discussing '{concept}'?",
+            "question_type": "short_answer",
+            "options": None,
+            "correct_answer": f"The section focuses on explaining '{concept}' and its relevance to the overall topic.",
+            "difficulty": difficulty,
+            "explanation": "Try to identify the main ideas when studying.",
+            "concept": concept
+        })
+    
+    return questions[:count]
 
-def generate_flashcards(text: str, count: int = 3) -> list:
-    """Generate flashcards from text"""
-    import re
+def generate_flashcards_from_content(text: str, concepts: List[str], count: int = 5) -> List[Dict]:
+    """Generate flashcards based on actual content"""
+    
     sentences = re.split(r'[.!?]+', text)
-    sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
+    sentences = [s.strip() for s in sentences if len(s.strip()) > 30]
     
     flashcards = []
-    for i in range(min(len(sentences), count)):
-        sentence = sentences[i]
+    for i in range(min(count, len(concepts))):
+        concept = concepts[i]
         fcid = generate_id(f"fc_{i}")
         
+        # Find a sentence that contains this concept
+        context = ""
+        for sentence in sentences:
+            if concept.lower() in sentence.lower():
+                context = sentence[:150]
+                break
+        
+        if not context:
+            context = sentences[i % len(sentences)] if sentences else text[:150]
+        
         flashcards.append({
             "id": fcid,
-            "front": sentence[:100],
-            "back": f"Explanation of: {sentence[:50]}...",
-            "category": "Study",
+            "front": f"What is '{concept}'?",
+            "back": f"{context}... This concept is key to understanding the material.",
+            "category": "Key Concept",
             "difficulty": "medium"
         })
     
     return flashcards
 
-# API Endpoints
 @app.post("/api/process-content")
 async def process_content(
     content_type: str = Form(...),
@@ -249,11 +336,16 @@ async def process_content(
     file: UploadFile = File(None),
     youtube_url: str = Form(None)
 ):
-    """Process uploaded content"""
+    """Process uploaded content and generate REAL questions"""
+    
+    print(f"Processing: type={content_type}, difficulty={difficulty}, title={title}")
     
     text_content = ""
+    
     if content_type == "text" and content:
-        text_content = content[:10000]
+        text_content = content[:15000]
+        print(f"Text length: {len(text_content)} chars")
+        
     elif content_type == "pdf" and file:
         with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_file:
             content_bytes = await file.read()
@@ -262,57 +354,79 @@ async def process_content(
         
         text_content = extract_text_from_pdf(temp_file_path)
         os.unlink(temp_file_path)
+        print(f"PDF text length: {len(text_content)} chars")
+        
     elif content_type == "youtube" and youtube_url:
         text_content = extract_text_from_youtube(youtube_url)
-    else:
-        raise HTTPException(status_code=400, detail="Invalid content")
+        print(f"YouTube transcript length: {len(text_content)} chars")
     
     if len(text_content) < 50:
-        raise HTTPException(status_code=400, detail="Content too short")
+        raise HTTPException(status_code=400, detail=f"Content too short ({len(text_content)} chars). Minimum 50 chars required.")
+    
+    # Extract concepts from the actual content
+    concepts = extract_key_concepts(text_content, 8)
+    print(f"Extracted concepts: {concepts}")
+    
+    # Generate REAL questions based on content
+    questions = generate_questions_from_content(text_content, difficulty, 5)
+    print(f"Generated {len(questions)} questions")
     
+    # Generate flashcards
+    flashcards = generate_flashcards_from_content(text_content, concepts, 4)
+    
+    # Create session
+    session_id = generate_id(title)
     content_hash = hashlib.md5(text_content.encode()).hexdigest()
     
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
     
-    # Check if exists
+    # Check if session exists
     cursor.execute("SELECT id FROM sessions WHERE content_hash = ?", (content_hash,))
     existing = cursor.fetchone()
     
     if existing:
-        conn.close()
-        return {"session_id": existing[0], "is_existing": True}
-    
-    # Create new session
-    session_id = generate_id(text_content[:100])
+        session_id = existing[0]
+        # Clear old questions
+        cursor.execute("DELETE FROM questions WHERE session_id = ?", (session_id,))
+        cursor.execute("DELETE FROM flashcards WHERE session_id = ?", (session_id,))
     
+    # Save session
     cursor.execute(
-        "INSERT INTO sessions (id, title, content_type, difficulty, content_hash) VALUES (?, ?, ?, ?, ?)",
-        (session_id, title, content_type, difficulty, content_hash)
+        """INSERT OR REPLACE INTO sessions 
+           (id, title, content_type, difficulty, content_hash, raw_content, last_accessed) 
+           VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)""",
+        (session_id, title, content_type, difficulty, content_hash, text_content[:5000])
     )
     
-    # Generate materials
-    questions = generate_questions(text_content, difficulty, 5)
-    flashcards = generate_flashcards(text_content, 3)
-    
     # Save questions
     for q in questions:
         cursor.execute(
-            "INSERT INTO questions (id, session_id, question_text, question_type, options, correct_answer, difficulty, explanation) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-            (q["id"], session_id, q["question_text"], q["question_type"], q.get("options"), q["correct_answer"], q["difficulty"], q.get("explanation", ""))
+            """INSERT INTO questions 
+               (id, session_id, question_text, question_type, options, correct_answer, difficulty, explanation) 
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+            (q["id"], session_id, q["question_text"], q["question_type"], 
+             q.get("options"), q["correct_answer"], q["difficulty"], q.get("explanation", ""))
         )
     
     # Save flashcards
     for fc in flashcards:
         cursor.execute(
-            "INSERT INTO flashcards (id, session_id, front, back, category, difficulty) VALUES (?, ?, ?, ?, ?, ?)",
-            (fc["id"], session_id, fc["front"], fc["back"], fc["category"], fc["difficulty"])
+            """INSERT INTO flashcards 
+               (id, session_id, front, back, category, difficulty) 
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            (fc["id"], session_id, fc["front"], fc["back"], fc["category"], fc.get("difficulty", "medium"))
         )
     
     conn.commit()
     conn.close()
     
-    return {"session_id": session_id, "is_existing": False}
+    return {
+        "session_id": session_id,
+        "is_existing": existing is not None,
+        "question_count": len(questions),
+        "flashcard_count": len(flashcards)
+    }
 
 @app.get("/api/session/{session_id}")
 async def get_session(session_id: str):
@@ -338,12 +452,6 @@ async def get_session(session_id: str):
     cursor.execute("SELECT * FROM flashcards WHERE session_id = ?", (session_id,))
     flashcards = [dict(row) for row in cursor.fetchall()]
     
-    cursor.execute("SELECT * FROM notes WHERE session_id = ?", (session_id,))
-    notes = [dict(row) for row in cursor.fetchall()]
-    
-    cursor.execute("SELECT * FROM highlights WHERE session_id = ?", (session_id,))
-    highlights = [dict(row) for row in cursor.fetchall()]
-    
     # Calculate performance
     total_questions = len(questions)
     correct_answers = sum(1 for q in questions if q.get("is_correct") == 1)
@@ -357,14 +465,14 @@ async def get_session(session_id: str):
         "materials": {
             "questions": questions,
             "flashcards": flashcards,
-            "notes": notes,
-            "highlights": highlights
+            "notes": [],
+            "highlights": []
         },
         "summary": {
             "question_count": total_questions,
             "flashcard_count": len(flashcards),
-            "note_count": len(notes),
-            "highlight_count": len(highlights)
+            "note_count": 0,
+            "highlight_count": 0
         },
         "performance": {
             "total_questions": total_questions,
@@ -407,11 +515,12 @@ async def submit_answer(
     user_answer: str = Form(...),
     time_spent: int = Form(0)
 ):
-    """Submit an answer"""
+    """Submit an answer for evaluation"""
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
     
-    cursor.execute("SELECT correct_answer FROM questions WHERE id = ? AND session_id = ?", (question_id, session_id))
+    cursor.execute("SELECT correct_answer, question_type FROM questions WHERE id = ? AND session_id = ?", 
+                   (question_id, session_id))
     result = cursor.fetchone()
     
     if not result:
@@ -419,96 +528,48 @@ async def submit_answer(
         raise HTTPException(status_code=404, detail="Question not found")
     
     correct_answer = result[0]
-    is_correct = 1 if str(user_answer).strip().lower() == str(correct_answer).strip().lower() else 0
+    question_type = result[1]
+    
+    # Evaluate answer based on question type
+    is_correct = 0
+    
+    if question_type == "multiple_choice":
+        # Exact match for multiple choice
+        is_correct = 1 if user_answer.strip() == correct_answer.strip() else 0
+    elif question_type == "true_false":
+        # Case-insensitive match for true/false
+        is_correct = 1 if user_answer.strip().lower() == correct_answer.strip().lower() else 0
+    elif question_type == "fill_blank":
+        # Partial matching for fill in blank
+        user_clean = user_answer.strip().lower()
+        correct_clean = correct_answer.strip().lower()
+        is_correct = 1 if (user_clean == correct_clean or correct_clean in user_clean or user_clean in correct_clean) else 0
+    elif question_type == "short_answer":
+        # Flexible matching for short answers
+        user_clean = user_answer.strip().lower()
+        correct_clean = correct_answer.strip().lower()
+        # Check if answer contains key concepts
+        key_words = re.findall(r'\b[a-z]{4,}\b', correct_clean)
+        matched = sum(1 for word in key_words if word in user_clean)
+        is_correct = 1 if matched >= len(key_words) * 0.4 else 0  # 40% keyword match
     
     cursor.execute(
         "UPDATE questions SET user_answer = ?, is_correct = ?, time_spent = ? WHERE id = ? AND session_id = ?",
         (user_answer, is_correct, time_spent, question_id, session_id)
     )
     
-    # Update profile
-    cursor.execute("INSERT OR IGNORE INTO user_profile (id) VALUES (1)")
-    cursor.execute(
-        "UPDATE user_profile SET total_questions = total_questions + 1, correct_answers = correct_answers + ? WHERE id = 1",
-        (is_correct,)
-    )
-    
-    conn.commit()
-    conn.close()
-    
-    return {"is_correct": bool(is_correct), "correct_answer": correct_answer}
-
-@app.post("/api/analyze-text")
-async def analyze_text(text: str = Form(...), session_id: str = Form(...)):
-    """Analyze selected text"""
-    words = text.split()
-    definitions = []
-    
-    for word in words[:3]:
-        if len(word) > 3:
-            definitions.append({
-                "word": word,
-                "definition": f"Key term in context",
-                "example": f"Used in: '{text[:50]}...'"
-            })
-    
-    # Save highlight
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    highlight_id = generate_id(text)
-    cursor.execute(
-        "INSERT OR IGNORE INTO highlights (id, session_id, text, context) VALUES (?, ?, ?, ?)",
-        (highlight_id, session_id, text, json.dumps(definitions))
-    )
-    
     conn.commit()
     conn.close()
     
     return {
-        "text": text,
-        "definitions": definitions,
-        "explanation": f"Analysis of selected text ({len(words)} words)",
-        "suggested_actions": ["Create flashcard", "Add to notes"]
-    }
-
-@app.get("/api/user/profile")
-async def get_user_profile():
-    """Get user profile"""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    cursor.execute("SELECT * FROM user_profile WHERE id = 1")
-    profile = cursor.fetchone()
-    
-    if not profile:
-        cursor.execute("INSERT INTO user_profile (id) VALUES (1)")
-        conn.commit()
-        cursor.execute("SELECT * FROM user_profile WHERE id = 1")
-        profile = cursor.fetchone()
-    
-    total = profile[1] or 0
-    correct = profile[2] or 0
-    accuracy = round((correct / total * 100) if total > 0 else 0, 1)
-    
-    conn.close()
-    
-    return {
-        "profile": {
-            "total_questions": total,
-            "correct_answers": correct,
-            "total_study_time": profile[3] or 0,
-            "accuracy": accuracy
-        },
-        "insights": {
-            "weaknesses": ["Practice more to identify areas"],
-            "strengths": ["Getting started is the first step!"]
-        }
+        "is_correct": bool(is_correct),
+        "correct_answer": correct_answer,
+        "feedback": "Correct! Great job!" if is_correct else f"The correct answer is: {correct_answer}"
     }
 
 @app.delete("/api/session/{session_id}")
 async def delete_session(session_id: str):
-    """Delete session"""
+    """Delete a session"""
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
     
@@ -523,45 +584,32 @@ async def delete_session(session_id: str):
     
     return {"message": "Session deleted"}
 
-@app.post("/api/update-study-time")
-async def update_study_time(session_id: str = Form(...), study_time: int = Form(...)):
-    """Update study time"""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    cursor.execute("UPDATE sessions SET last_accessed = CURRENT_TIMESTAMP WHERE id = ?", (session_id,))
-    cursor.execute("INSERT OR IGNORE INTO user_profile (id) VALUES (1)")
-    cursor.execute(
-        "UPDATE user_profile SET total_study_time = COALESCE(total_study_time, 0) + ? WHERE id = 1",
-        (study_time,)
-    )
-    
-    conn.commit()
-    conn.close()
-    
-    return {"message": "Study time updated"}
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
 
-# Serve frontend
+# Serve static files
 @app.get("/")
 async def serve_frontend():
     """Serve the main frontend page"""
-    try:
-        return HTMLResponse(content=open("index.html").read())
-    except:
-        return HTMLResponse(content="<h1>StudyFlow AI Backend Running</h1>")
+    with open("index.html", "r") as f:
+        return HTMLResponse(content=f.read())
 
 @app.get("/app.js")
 async def serve_js():
     """Serve JavaScript"""
+    with open("app.js", "r") as f:
+        return HTMLResponse(content=f.read(), media_type="application/javascript")
+
+@app.get("/styles.css")
+async def serve_css():
+    """Serve CSS"""
     try:
-        return HTMLResponse(content=open("app.js").read(), media_type="application/javascript")
+        with open("styles.css", "r") as f:
+            return HTMLResponse(content=f.read(), media_type="text/css")
     except:
-        return HTMLResponse(content="console.log('JS loaded');", media_type="application/javascript")
-
-# Health check
-@app.get("/health")
-async def health_check():
-    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
+        return HTMLResponse(content="", media_type="text/css")
 
 if __name__ == "__main__":
     import uvicorn