Update app.py

app.py

@@ -1,14 +1,21 @@
-"""Veda Programming Assistant - Auto Learning (Hidden Teacher)"""
+"""
+Veda Programming Assistant (Gradio 6.x)
+- Hidden teacher fallback (OpenRouter) when student fails
+- Auto-training in background using teacher responses
+- Math solver for simple arithmetic
+- Compatible with Gradio "messages format" + multimodal inputs
+"""
 
-import gradio as gr
-import tensorflow as tf
 import os
 import json
+import time
+import threading
 import re
 import ast
 import operator as op
-import threading
-import time
+
+import gradio as gr
+import tensorflow as tf
 
 from model import VedaProgrammingLLM
 from tokenizer import VedaTokenizer
@@ -18,52 +25,85 @@ from teacher import teacher
 from config import MODEL_DIR
 
 
-# --------- Globals ----------
+# -----------------------------
+# GLOBALS
+# -----------------------------
 model = None
 tokenizer = None
-conversation_history = []
+
+# For building student prompt context
+conversation_history = []  # list of dicts: {"user": "...", "assistant": "..."}
+
 current_conv_id = -1
 
-# Auto-training settings
+# Teacher usage stats (not shown in chat)
+teacher_used_count = 0
+teacher_failed_count = 0
+
+# Auto-training control
 AUTO_TRAIN_ENABLED = True
-AUTO_TRAIN_MIN_SAMPLES = 10  # Train after this many teacher responses
-AUTO_TRAIN_INTERVAL = 1800   # Check every 30 minutes (in seconds)
-AUTO_TRAIN_EPOCHS = 10
-is_training = False
-last_train_time = 0
+AUTO_TRAIN_MIN_TEACHER_SAMPLES = 10     # retrain after this many new teacher samples
+AUTO_TRAIN_CHECK_EVERY_SEC = 120        # check every 2 minutes
+AUTO_TRAIN_EPOCHS = 5                   # keep small for Spaces CPU
+AUTO_TRAIN_COOLDOWN_SEC = 60 * 20       # at least 20 minutes between trainings
 
+_is_training = False
+_last_train_time = 0
+_train_lock = threading.Lock()
 
-# --------- Helpers ----------
+
+# -----------------------------
+# GRADIO INPUT HELPERS
+# -----------------------------
 def extract_text(message):
+    """
+    Convert Gradio multimodal/messages -> plain string.
+    Handles:
+      - str
+      - dict {"text": "..."} or {"content": ...}
+      - list [{"type":"text","text":"..."}]
+    """
     if message is None:
         return ""
     if isinstance(message, str):
         return message
+
     if isinstance(message, dict):
         if "text" in message:
             return str(message.get("text", ""))
         if "content" in message:
             return extract_text(message["content"])
         return ""
+
     if isinstance(message, list):
-        parts = []
+        out = []
         for part in message:
             if isinstance(part, dict) and part.get("type") == "text":
-                parts.append(str(part.get("text", "")))
+                out.append(str(part.get("text", "")))
             elif isinstance(part, str):
-                parts.append(part)
-        return "".join(parts).strip()
+                out.append(part)
+        return "".join(out).strip()
+
     return str(message)
 
 
 def ensure_messages_history(history):
+    """
+    Ensure history is messages-format list:
+      [{"role":"user","content":"..."}, {"role":"assistant","content":"..."}]
+    Convert tuple format if needed.
+    """
     if history is None:
         return []
-    if len(history) > 0 and isinstance(history[0], dict) and "role" in history[0]:
+
+    # already messages format
+    if len(history) > 0 and isinstance(history[0], dict) and "role" in history[0] and "content" in history[0]:
         fixed = []
         for m in history:
             fixed.append({"role": m["role"], "content": extract_text(m["content"])})
         return fixed
+
+    # tuple format -> messages format
     fixed = []
     for pair in history:
         if isinstance(pair, (list, tuple)) and len(pair) == 2:
@@ -72,7 +112,9 @@ def ensure_messages_history(history):
     return fixed
 
 
-# --------- Math Solver ----------
+# -----------------------------
+# SAFE MATH SOLVER
+# -----------------------------
 _ALLOWED_OPS = {
     ast.Add: op.add,
     ast.Sub: op.sub,
@@ -84,7 +126,6 @@ _ALLOWED_OPS = {
     ast.UAdd: op.pos,
 }
 
-
 def safe_eval_math(expr: str):
     node = ast.parse(expr, mode="eval").body
 
@@ -95,176 +136,131 @@ def safe_eval_math(expr: str):
             return _ALLOWED_OPS[type(n.op)](_eval(n.left), _eval(n.right))
         if isinstance(n, ast.UnaryOp) and type(n.op) in _ALLOWED_OPS:
             return _ALLOWED_OPS[type(n.op)](_eval(n.operand))
-        raise ValueError("Unsupported")
+        raise ValueError("Unsupported expression")
 
     return _eval(node)
 
-
 def try_math_answer(user_text: str):
     if not user_text:
         return None
-    s = user_text.strip().replace("=", "").replace("?", "").strip().replace("^", "**")
+    s = user_text.strip()
+    s = s.replace("=", "").replace("?", "").strip()
+    s = s.replace("^", "**")  # allow ^
+
+    # only allow numeric math chars
     if not re.fullmatch(r"[0-9\.\s\+\-\*\/\(\)%]+", s):
         return None
+
     try:
         val = safe_eval_math(s)
         if isinstance(val, float) and val.is_integer():
             val = int(val)
         return str(val)
-    except:
+    except Exception:
         return None
 
 
-# --------- Response Quality Check ----------
-def is_good_response(response: str) -> bool:
-    """Check if student response is good quality"""
-    if not response:
-        return False
-    
-    response = response.strip()
-    
-    # Too short
-    if len(response) < 30:
-        return False
-    
-    # Contains gibberish patterns
-    gibberish_patterns = [
-        r'\["\]',
-        r'arr\[\s*a',
-        r'print\s*\(\s*"\s*,',
-        r'=\s+=\s+=',
-        r'\[\.\]',
-        r'return\s+if\s+is',
-        r'\s{10,}',
-        r'(\w)\1{5,}',
-        r'\[\s*\]',
-        r'def\s+def',
-        r'class\s+class',
-        r'return\s+return',
-        r'if\s+if',
-        r'\(\s*\)',
-        r'=\s*=\s*=',
+# -----------------------------
+# QUALITY CHECK + TEACHER TRIGGER
+# -----------------------------
+def is_code_request(user_text: str) -> bool:
+    t = user_text.lower()
+    triggers = [
+        "write", "implement", "code", "function", "algorithm",
+        "bubble sort", "binary search", "merge sort", "quick sort", "quicksort",
+        "linked list", "stack", "queue", "class ", "def "
     ]
-    
-    for pattern in gibberish_patterns:
-        if re.search(pattern, response):
-            return False
-    
-    # Too many special characters
-    letters = sum(1 for c in response if c.isalpha())
-    special = sum(1 for c in response if c in '[]{}()=<>|\\')
-    if letters > 0 and special / letters > 0.5:
-        return False
-    
-    # Too many brackets without proper code
-    brackets = response.count('[') + response.count(']') + response.count('{') + response.count('}')
-    if brackets > 20 and 'def ' not in response and 'class ' not in response:
+    return any(k in t for k in triggers)
+
+def looks_like_python_code(text: str) -> bool:
+    if not text:
         return False
-    
-    # Check for error phrases
-    error_phrases = [
-        "i'm not sure",
-        "i don't know",
-        "could you try rephrasing",
-        "error:",
-        "cannot understand",
-        "not sure how to respond",
+    t = text.strip()
+    if "```" in t:
+        return True
+    if "def " in t or "class " in t:
+        return True
+    if "\n    " in t:
+        return True
+    return False
+
+def is_gibberish(text: str) -> bool:
+    if not text:
+        return True
+    t = text.strip()
+
+    # repeated greeting
+    if t.lower().count("hello how are you") >= 2:
+        return True
+
+    # too short
+    if len(t) < 25:
+        return True
+
+    # lots of symbols vs letters
+    letters = sum(c.isalpha() for c in t)
+    special = sum(c in "[]{}()=<>|\\" for c in t)
+    if letters > 0 and (special / max(letters, 1)) > 0.35:
+        return True
+
+    # low unique word ratio
+    words = re.findall(r"[a-zA-Z_]+", t.lower())
+    if len(words) >= 20:
+        uniq_ratio = len(set(words)) / len(words)
+        if uniq_ratio < 0.35:
+            return True
+
+    # known “junk” patterns
+    junk_patterns = [
+        r"\[\s*\"?\s*\]",        # empty brackets patterns
+        r"return\s+if\s+is",
+        r"=\s*=\s*=",
+        r"def\s+def",
+        r"class\s+class",
+        r"return\s+return",
     ]
-    
-    response_lower = response.lower()
-    for phrase in error_phrases:
-        if phrase in response_lower:
-            return False
-    
-    return True
-
-
-# --------- Auto Training ----------
-def auto_train_background():
-    """Background thread that automatically trains when enough data collected"""
-    global model, tokenizer, is_training, last_train_time
-    
-    while True:
-        time.sleep(60)  # Check every minute
-        
-        if not AUTO_TRAIN_ENABLED:
-            continue
-        
-        if is_training:
-            continue
-        
-        # Check if enough time passed since last training
-        if time.time() - last_train_time < AUTO_TRAIN_INTERVAL:
-            continue
-        
-        # Check if we have enough samples
-        try:
-            unused = db.get_unused_distillation_data()
-            if len(unused) >= AUTO_TRAIN_MIN_SAMPLES:
-                print(f"\n[Auto-Train] Starting training with {len(unused)} samples...")
-                is_training = True
-                
-                # Prepare training data
-                good_convs = db.get_good_conversations()
-                extra_data = ""
-                for conv in good_convs:
-                    extra_data += f"<USER> {conv['user_input']}\n"
-                    extra_data += f"<ASSISTANT> {conv['assistant_response']}\n\n"
-                
-                distillation_data = ""
-                for item in unused:
-                    distillation_data += f"<USER> {item['user_input']}\n"
-                    distillation_data += f"<ASSISTANT> {item['teacher_response']}\n\n"
-                
-                # Train
-                trainer = VedaTrainer()
-                history = trainer.train(
-                    epochs=AUTO_TRAIN_EPOCHS,
-                    extra_data=extra_data,
-                    distillation_data=distillation_data,
-                )
-                
-                # Update global model
-                model = trainer.model
-                tokenizer = trainer.tokenizer
-                
-                # Mark as used
-                ids = [item["id"] for item in unused]
-                db.mark_distillation_used(ids)
-                
-                loss = history.history["loss"][-1]
-                db.save_training_history(
-                    training_type="auto",
-                    samples_used=len(unused) + len(good_convs),
-                    epochs=AUTO_TRAIN_EPOCHS,
-                    final_loss=loss,
-                )
-                
-                last_train_time = time.time()
-                is_training = False
-                print(f"[Auto-Train] Completed! Loss: {loss:.4f}")
-                
-        except Exception as e:
-            print(f"[Auto-Train] Error: {e}")
-            is_training = False
+    for p in junk_patterns:
+        if re.search(p, t):
+            return True
+
+    return False
+
+def should_use_teacher(user_text: str, student_text: str) -> bool:
+    # teacher must be available
+    if not teacher.is_available():
+        return False
+
+    # always use teacher for code requests unless student produced real code
+    if is_code_request(user_text) and not looks_like_python_code(student_text):
+        return True
 
+    # use teacher if student output is gibberish
+    if is_gibberish(student_text):
+        return True
 
-# --------- Model Init ----------
+    return False
+
+
+# -----------------------------
+# MODEL LOAD
+# -----------------------------
 def initialize():
     global model, tokenizer
 
     print("Initializing Veda Programming Assistant...")
 
     config_path = os.path.join(MODEL_DIR, "config.json")
+    weights_path = os.path.join(MODEL_DIR, "weights.h5")
+    tok_path = os.path.join(MODEL_DIR, "tokenizer.json")
 
-    if os.path.exists(config_path):
+    if os.path.exists(config_path) and os.path.exists(weights_path) and os.path.exists(tok_path):
         print("Loading existing model...")
 
         with open(config_path, "r") as f:
             config = json.load(f)
 
         tokenizer = VedaTokenizer()
-        tokenizer.load(os.path.join(MODEL_DIR, "tokenizer.json"))
+        tokenizer.load(tok_path)
 
         model = VedaProgrammingLLM(
             vocab_size=config["vocab_size"],
@@ -277,162 +273,241 @@ def initialize():
 
         dummy = tf.zeros((1, config["max_length"]), dtype=tf.int32)
         model(dummy)
-        model.load_weights(os.path.join(MODEL_DIR, "weights.h5"))
+        model.load_weights(weights_path)
 
-        print("Model loaded!")
+        print("Model loaded.")
     else:
-        print("Training new model...")
+        print("No saved model found. Training initial model...")
         trainer = VedaTrainer()
-        trainer.train(epochs=15)
+        trainer.train(epochs=10)
         model = trainer.model
         tokenizer = trainer.tokenizer
-        print("Model trained!")
+        print("Initial model trained.")
 
 
 def clean_response(text: str) -> str:
     if not text:
         return ""
-    
+
     text = text.replace("<CODE>", "\n```python\n")
     text = text.replace("<ENDCODE>", "\n```\n")
-    
+
     for token in ["<PAD>", "<UNK>", "<START>", "<END>", "<USER>", "<ASSISTANT>"]:
         text = text.replace(token, "")
-    
+
+    # reduce empty lines
     lines = text.split("\n")
     cleaned = []
-    empty_count = 0
-    
+    empty = 0
     for line in lines:
         if line.strip() == "":
-            empty_count += 1
-            if empty_count <= 2:
+            empty += 1
+            if empty <= 2:
                 cleaned.append(line)
         else:
-            empty_count = 0
+            empty = 0
             cleaned.append(line)
-    
     return "\n".join(cleaned).strip()
 
 
-def get_student_response(user_input: str, temperature: float = 0.7, max_tokens: int = 200) -> str:
-    """Get response from student model (Veda)"""
+# -----------------------------
+# STUDENT + TEACHER RESPONSE
+# -----------------------------
+def get_student_response(user_text: str, temperature: float, max_tokens: int) -> str:
     if model is None or tokenizer is None:
         return ""
-    
-    try:
-        context = ""
-        for msg in conversation_history[-3:]:
-            context += f"<USER> {msg['user']}\n<ASSISTANT> {msg['assistant']}\n"
-
-        prompt = context + f"<USER> {user_input}\n<ASSISTANT>"
-        tokens = tokenizer.encode(prompt)
-
-        if len(tokens) > model.max_length - max_tokens:
-            tokens = tokens[-(model.max_length - max_tokens):]
-
-        generated = model.generate(
-            tokens,
-            max_new_tokens=max_tokens,
-            temperature=temperature,
-            top_k=50,
-            top_p=0.9,
-            repetition_penalty=1.2,
-        )
 
-        response = tokenizer.decode(generated)
+    # build context from internal conversation_history
+    context = ""
+    for m in conversation_history[-3:]:
+        context += f"<USER> {m['user']}\n<ASSISTANT> {m['assistant']}\n"
 
-        if "<ASSISTANT>" in response:
-            response = response.split("<ASSISTANT>")[-1].strip()
-        if "<USER>" in response:
-            response = response.split("<USER>")[0].strip()
+    prompt = context + f"<USER> {user_text}\n<ASSISTANT>"
+    tokens = tokenizer.encode(prompt)
 
-        return clean_response(response)
-    
-    except Exception as e:
-        print(f"Student error: {e}")
-        return ""
+    if len(tokens) > model.max_length - max_tokens:
+        tokens = tokens[-(model.max_length - max_tokens):]
 
+    generated = model.generate(
+        tokens,
+        max_new_tokens=max_tokens,
+        temperature=temperature,
+        top_k=50,
+        top_p=0.9,
+        repetition_penalty=1.2,
+    )
 
-def get_teacher_response(user_input: str) -> str:
-    """Get response from teacher model (hidden from user)"""
-    try:
-        conv_history = []
-        for msg in conversation_history[-4:]:
-            conv_history.append({"role": "user", "content": msg["user"]})
-            conv_history.append({"role": "assistant", "content": msg["assistant"]})
-        
-        response = teacher.ask(
-            user_message=user_input,
-            conversation_history=conv_history,
-        )
-        
-        return response if response else ""
-    
-    except Exception as e:
-        print(f"Teacher error: {e}")
-        return ""
+    out = tokenizer.decode(generated)
+
+    if "<ASSISTANT>" in out:
+        out = out.split("<ASSISTANT>")[-1].strip()
+    if "<USER>" in out:
+        out = out.split("<USER>")[0].strip()
+
+    return clean_response(out)
 
 
-def generate_response(user_input: str, temperature: float = 0.7, max_tokens: int = 200) -> str:
-    """Generate response - seamlessly uses teacher when needed (hidden from user)"""
-    global current_conv_id, conversation_history
+def get_teacher_response(user_text: str) -> str:
+    # Build teacher history from our internal conversation_history
+    teacher_hist = []
+    for m in conversation_history[-4:]:
+        teacher_hist.append({"role": "user", "content": m["user"]})
+        teacher_hist.append({"role": "assistant", "content": m["assistant"]})
 
-    user_input = extract_text(user_input).strip()
-    if not user_input:
-        return "Please type a message!"
+    return teacher.ask(user_message=user_text, conversation_history=teacher_hist) or ""
 
-    # 1) Math first
-    math_ans = try_math_answer(user_input)
+
+# -----------------------------
+# MAIN GENERATION (HIDDEN TEACHER)
+# -----------------------------
+def generate_response(user_input, temperature=0.7, max_tokens=200) -> str:
+    global current_conv_id, teacher_used_count, teacher_failed_count
+
+    user_text = extract_text(user_input).strip()
+    if not user_text:
+        return "Please type a message."
+
+    # math solver first
+    math_ans = try_math_answer(user_text)
     if math_ans is not None:
-        conversation_history.append({"user": user_input, "assistant": math_ans})
-        current_conv_id = db.save_conversation(user_input, math_ans)
+        conversation_history.append({"user": user_text, "assistant": math_ans})
+        current_conv_id = db.save_conversation(user_text, math_ans)
         return math_ans
 
-    # 2) Try student
-    student_response = get_student_response(user_input, temperature, max_tokens)
-    
-    # 3) Check quality
-    if is_good_response(student_response):
-        final_response = student_response
-    else:
-        # 4) Silently ask teacher (user doesn't know!)
-        teacher_response = get_teacher_response(user_input)
-        
-        if teacher_response:
-            final_response = teacher_response
-            
-            # Save for auto-training (silent learning)
-            db.save_distillation_data(
-                user_input=user_input,
-                teacher_response=teacher_response,
-                student_response=student_response,
-                quality_score=1.0,
-            )
+    # student attempt
+    student = get_student_response(user_text, temperature, max_tokens)
+
+    # teacher fallback
+    if should_use_teacher(user_text, student):
+        teacher_resp = get_teacher_response(user_text)
+        if teacher_resp.strip():
+            teacher_used_count += 1
+
+            # save distillation sample
+            try:
+                db.save_distillation_data(
+                    user_input=user_text,
+                    teacher_response=teacher_resp,
+                    student_response=student,
+                    quality_score=1.0,
+                )
+            except Exception as e:
+                print("Could not save distillation sample:", e)
+
+            final = teacher_resp
         else:
-            final_response = student_response if student_response else "I'm having trouble understanding. Could you rephrase that?"
+            teacher_failed_count += 1
+            final = student if student else "Please try again."
+    else:
+        final = student
+
+    final = clean_response(final)
+    if not final:
+        final = "Please try asking in a different way."
+
+    conversation_history.append({"user": user_text, "assistant": final})
+    current_conv_id = db.save_conversation(user_text, final)
+    return final
+
+
+# -----------------------------
+# AUTO TRAINING
+# -----------------------------
+def auto_train_loop():
+    global _is_training, _last_train_time, model, tokenizer
+
+    while True:
+        time.sleep(AUTO_TRAIN_CHECK_EVERY_SEC)
+
+        if not AUTO_TRAIN_ENABLED:
+            continue
+
+        if time.time() - _last_train_time < AUTO_TRAIN_COOLDOWN_SEC:
+            continue
 
-    if not final_response:
-        final_response = "I couldn't generate a response. Please try again."
+        if _train_lock.locked():
+            continue
+
+        # check distillation samples
+        try:
+            unused = db.get_unused_distillation_data(limit=1000)
+        except Exception as e:
+            print("[AutoTrain] Could not read distillation data:", e)
+            continue
+
+        if len(unused) < AUTO_TRAIN_MIN_TEACHER_SAMPLES:
+            continue
 
-    conversation_history.append({"user": user_input, "assistant": final_response})
-    current_conv_id = db.save_conversation(user_input, final_response)
+        # train in this background thread
+        with _train_lock:
+            _is_training = True
+            print(f"[AutoTrain] Starting training on {len(unused)} teacher samples...")
+
+            try:
+                distill_text = ""
+                ids = []
+                for row in unused:
+                    ids.append(row["id"])
+                    distill_text += f"<USER> {row['user_input']}\n<ASSISTANT> {row['teacher_response']}\n\n"
+
+                # include good user-rated conversations too
+                extra = ""
+                try:
+                    good = db.get_good_conversations(limit=200)
+                    for conv in good:
+                        extra += f"<USER> {conv['user_input']}\n<ASSISTANT> {conv['assistant_response']}\n\n"
+                except Exception:
+                    pass
+
+                trainer = VedaTrainer()
+                hist = trainer.train(
+                    epochs=AUTO_TRAIN_EPOCHS,
+                    extra_data=extra,
+                    distillation_data=distill_text,
+                )
+
+                model = trainer.model
+                tokenizer = trainer.tokenizer
 
-    # NO indicator - user doesn't know if it's teacher or student!
-    return final_response
+                # mark distillation used
+                try:
+                    db.mark_distillation_used(ids)
+                except Exception as e:
+                    print("[AutoTrain] Could not mark distillation used:", e)
 
+                loss = float(hist.history["loss"][-1])
+                try:
+                    db.save_training_history(
+                        training_type="auto",
+                        samples_used=len(unused),
+                        epochs=AUTO_TRAIN_EPOCHS,
+                        final_loss=loss,
+                    )
+                except Exception:
+                    pass
 
-# --------- Gradio Handlers ----------
+                _last_train_time = time.time()
+                print(f"[AutoTrain] Done. loss={loss:.4f}")
+
+            except Exception as e:
+                print("[AutoTrain] Training failed:", e)
+
+            _is_training = False
+
+
+# -----------------------------
+# GRADIO HANDLERS
+# -----------------------------
 def respond(message, history, temperature, max_tokens):
     history = ensure_messages_history(history)
     user_text = extract_text(message).strip()
     if not user_text:
         return "", history
 
-    bot_message = generate_response(user_text, temperature, max_tokens)
+    bot_text = generate_response(user_text, temperature=float(temperature), max_tokens=int(max_tokens))
 
     history.append({"role": "user", "content": user_text})
-    history.append({"role": "assistant", "content": bot_message})
+    history.append({"role": "assistant", "content": bot_text})
 
     return "", history
 
@@ -440,141 +515,124 @@ def respond(message, history, temperature, max_tokens):
 def feedback_good():
     if current_conv_id > 0:
         db.update_feedback(current_conv_id, 1)
-        return "👍 Thanks!"
-    return ""
+        return "Thanks!"
+    return "No message to rate yet."
 
 
 def feedback_bad():
     if current_conv_id > 0:
         db.update_feedback(current_conv_id, -1)
-        return "👎 Thanks for feedback!"
-    return ""
+        return "Thanks!"
+    return "No message to rate yet."
 
 
 def clear_chat():
     global conversation_history
     conversation_history = []
-    return [], "Chat cleared."
+    return [], ""
 
 
-def get_stats():
+def get_stats_md():
     stats = db.get_stats()
-    
-    # Calculate learning progress
-    total_teacher = stats.get('distillation_total', 0)
-    used_teacher = total_teacher - stats.get('distillation_unused', 0)
-    
-    if total_teacher > 0:
-        learning_progress = (used_teacher / total_teacher) * 100
-    else:
-        learning_progress = 0
+    teacher_ok = teacher.is_available()
+
+    return f"""
+## Statistics
 
-    return f"""## 📊 Statistics
+**Teacher available:** `{teacher_ok}`  
+**Teacher used (this runtime):** `{teacher_used_count}`  
+**Teacher failed (this runtime):** `{teacher_failed_count}`  
+**Auto-training enabled:** `{AUTO_TRAIN_ENABLED}`  
+**Currently training:** `{_is_training}`  
 
 ### Conversations
-| Metric | Count |
-|--------|-------|
-| 💬 Total Chats | {stats['total']} |
-| 👍 Helpful | {stats['positive']} |
-| 👎 Needs Work | {stats['negative']} |
-
-### 🧠 Learning Progress
-| Metric | Value |
-|--------|-------|
-| Knowledge Gained | {used_teacher} lessons |
-| Learning Queue | {stats.get('distillation_unused', 0)} pending |
-| Auto-Training | {'✅ Active' if AUTO_TRAIN_ENABLED else '❌ Disabled'} |
-| Currently Training | {'🔄 Yes' if is_training else '✅ Ready'} |
-"""
+- Total: **{stats.get('total', 0)}**
+- Positive: **{stats.get('positive', 0)}**
+- Negative: **{stats.get('negative', 0)}**
 
+### Distillation (teacher lessons)
+- Total saved: **{stats.get('distillation_total', 0)}**
+- Pending for training: **{stats.get('distillation_unused', 0)}**
+"""
 
-# --------- Startup ----------
-print("=" * 50)
-print("Starting Veda Programming Assistant...")
-print("=" * 50)
 
+# -----------------------------
+# STARTUP
+# -----------------------------
+print("=== Booting Veda Assistant ===")
 initialize()
 
-# Start auto-training background thread
+print("Teacher available:", teacher.is_available())
 if AUTO_TRAIN_ENABLED:
-    print("Starting auto-learning background process...")
-    train_thread = threading.Thread(target=auto_train_background, daemon=True)
-    train_thread.start()
-    print("Auto-learning enabled!")
-
-print("=" * 50)
-print("Ready!")
-print("=" * 50)
+    t = threading.Thread(target=auto_train_loop, daemon=True)
+    t.start()
+    print("Auto-training thread started.")
+print("=== Ready ===")
 
 
-# --------- UI (Simple - No Training Tab) ----------
+# -----------------------------
+# UI
+# -----------------------------
 with gr.Blocks(title="Veda Programming Assistant") as demo:
-    gr.Markdown("""
-# 🕉️ Veda Programming Assistant
+    gr.Markdown(
+        """
+# Veda Programming Assistant
+
+Ask programming questions, request code, or do math like `2+2=?` or `(10+5)/3`.
 
-I can help you with **coding**, **programming concepts**, and **math**!
-""")
+(Teacher is hidden. Auto-learning is automatic.)
+"""
+    )
 
     with gr.Tabs():
-        with gr.TabItem("💬 Chat"):
-            chatbot = gr.Chatbot(label="Conversation", height=450, value=[])
+        with gr.TabItem("Chat"):
+            chatbot = gr.Chatbot(label="Conversation", height=420, value=[])
 
             with gr.Row():
                 msg = gr.Textbox(
-                    label="Your message",
-                    placeholder="Ask me anything about programming...",
+                    label="Message",
+                    placeholder="Example: Write bubble sort",
                     lines=2,
                     scale=4,
                 )
-                send_btn = gr.Button("Send", variant="primary", scale=1)
+                send = gr.Button("Send", variant="primary", scale=1)
 
             with gr.Row():
-                temperature = gr.Slider(0.1, 1.5, 0.7, step=0.1, label="Creativity")
-                max_tokens = gr.Slider(50, 400, 200, step=50, label="Response length")
+                temperature = gr.Slider(0.1, 1.5, 0.7, step=0.1, label="Temperature")
+                max_tokens = gr.Slider(50, 400, 200, step=50, label="Max tokens")
 
             with gr.Row():
-                good_btn = gr.Button("👍 Helpful", variant="secondary")
-                bad_btn = gr.Button("👎 Not Helpful", variant="secondary")
-                clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+                good = gr.Button("Helpful", variant="secondary")
+                bad = gr.Button("Not helpful", variant="secondary")
+                clear = gr.Button("Clear", variant="secondary")
+
+            status = gr.Textbox(label="", show_label=False, lines=1)
 
-            feedback_msg = gr.Textbox(label="", lines=1, interactive=False, show_label=False)
+            send.click(respond, inputs=[msg, chatbot, temperature, max_tokens], outputs=[msg, chatbot])
+            msg.submit(respond, inputs=[msg, chatbot, temperature, max_tokens], outputs=[msg, chatbot])
 
-            send_btn.click(respond, [msg, chatbot, temperature, max_tokens], [msg, chatbot])
-            msg.submit(respond, [msg, chatbot, temperature, max_tokens], [msg, chatbot])
-            good_btn.click(feedback_good, outputs=feedback_msg)
-            bad_btn.click(feedback_bad, outputs=feedback_msg)
-            clear_btn.click(clear_chat, outputs=[chatbot, feedback_msg])
+            good.click(feedback_good, outputs=status)
+            bad.click(feedback_bad, outputs=status)
+            clear.click(clear_chat, outputs=[chatbot, status])
 
-            gr.Markdown("### 💡 Try asking:")
             gr.Examples(
                 examples=[
-                    ["Hello! What can you do?"],
-                    ["What is Python?"],
-                    ["Write a factorial function"],
+                    ["Write bubble sort in python"],
+                    ["Write binary search"],
                     ["Explain recursion"],
-                    ["Write bubble sort"],
                     ["2+2=?"],
-                    ["What is a list in Python?"],
-                    ["How do I read a file?"],
+                    ["(10+5)/3"],
+                    ["2^5"],
                 ],
                 inputs=msg,
             )
 
-        with gr.TabItem("📊 Stats"):
-            gr.Markdown("### How is Veda doing?")
-            stats_out = gr.Markdown()
-            refresh_btn = gr.Button("🔄 Refresh")
-            refresh_btn.click(get_stats, outputs=stats_out)
-            
-            gr.Markdown("""
----
-**💡 Tip:** Rate responses to help Veda learn faster!
-- 👍 = This was helpful
-- 👎 = This needs improvement
-""")
-
-    gr.Markdown("---\n**Veda Programming Assistant** | Always learning, always improving!")
-
+        with gr.TabItem("Statistics"):
+            stats_md = gr.Markdown()
+            refresh = gr.Button("Refresh")
+            refresh.click(get_stats_md, outputs=stats_md)
+            # Show stats immediately
+            demo.load(get_stats_md, outputs=stats_md)
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)