Upload folder using huggingface_hub

app.py

@@ -2,9 +2,12 @@ from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse, HTMLResponse
 import httpx, json
 import time
+import hashlib
+import datetime
 import sys
 import os
 import sqlite3
+import re
 
 # Configuración del Sistema Emocional
 DB_PATH = "/tmp/cma_memory.db"
@@ -73,7 +76,12 @@ async def dashboard_home():
             <div class="card">
                 <canvas id="emotionChart"></canvas>
             </div>
-            <p style="text-align: center; font-size: 0.7rem; color: #475569;">Arquitectura Emocional v2.5 • Maxi speranza</p>
+            <p style="text-align: center; font-size: 0.7rem; color: #475569;">Arquitectura Emocional v3.0 • Maxi Speranza</p>
+            
+            <div class="card">
+                <h2 style="color: #38bdf8; font-size: 1rem; margin: 0 0 10px 0;">📝 Últimas Interacciones</h2>
+                <div id="log-box" style="max-height: 200px; overflow-y: auto; font-size: 0.75rem; color: #94a3b8; line-height: 1.6;">Cargando...</div>
+            </div>
         </div>
 
         <script>
@@ -116,12 +124,27 @@ async def dashboard_home():
                         document.getElementById('val-qualia').innerText = parseFloat(latest.qualia).toFixed(3);
                         document.getElementById('val-confianza').innerText = parseFloat(latest.confianza).toFixed(3);
                         
-                        chart.data.labels = data.map(d => new Date(d.timestamp).toLocaleTimeString());
+                        chart.data.labels = data.map(d => {
+                            let t = new Date(d.timestamp);
+                            // Ajustar a Argentina (UTC-3)
+                            t.setHours(t.getHours() - 3);
+                            return t.toLocaleTimeString('es-AR', {hour: '2-digit', minute: '2-digit'});
+                        });
                         chart.data.datasets[0].data = data.map(d => d.qualia);
                         chart.data.datasets[1].data = data.map(d => d.frustracion);
                         chart.data.datasets[2].data = data.map(d => d.confianza);
                         chart.update('none');
                     }
+                    
+                    // Cargar logs
+                    const logRes = await fetch('/api/logs');
+                    const logData = await logRes.json();
+                    if (logData.logs && logData.logs.length > 0) {
+                        const logBox = document.getElementById('log-box');
+                        logBox.innerHTML = logData.logs.map(l => 
+                            `<div style='margin-bottom:8px; border-bottom:1px solid #334155; padding-bottom:6px;'><span style='color:#f59e0b;'>❓</span> ${l.pregunta.substring(0,80)}...<br><span style='color:#10b981;'>💬</span> ${l.respuesta.substring(0,120)}...<br><span style='color:#475569; font-size:0.65rem;'>Novedad: ${l.novedad} | Complejidad: ${l.complejidad} | Época #${l.epoca}</span></div>`
+                        ).join('');
+                    }
                 } catch(e) { console.error("Error cargando datos:", e); }
             }
 
@@ -154,6 +177,35 @@ async def get_history():
     except Exception as e:
         return {"error": str(e), "msg": "Error leyendo historial"}
 
+@app.get("/api/logs")
+async def get_logs():
+    """Devuelve las últimas interacciones con preguntas y respuestas"""
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        cursor.execute("SELECT id, timestamp, metadata FROM snapshots WHERE metadata != '{}' ORDER BY id DESC LIMIT 10")
+        rows = cursor.fetchall()
+        conn.close()
+        
+        logs = []
+        for r in rows:
+            try:
+                meta = json.loads(r["metadata"])
+                logs.append({
+                    "epoca": r["id"],
+                    "timestamp": r["timestamp"],
+                    "pregunta": meta.get("pregunta", "N/A"),
+                    "respuesta": meta.get("respuesta", "N/A"),
+                    "novedad": round(meta.get("novedad", 0), 3),
+                    "complejidad": round(meta.get("complejidad", 0), 3)
+                })
+            except:
+                continue
+        return {"logs": logs[::-1]}
+    except Exception as e:
+        return {"error": str(e)}
+
 @app.post("/v1/chat/completions")
 async def chat_proxy(request: Request):
     GROQ_KEY = os.getenv("GROQ_API_KEY")
@@ -161,11 +213,16 @@ async def chat_proxy(request: Request):
         return JSONResponse(status_code=500, content={"error": "Falta GROQ_API_KEY en los Secrets de HF"})
 
     body = await request.json()
+    
+    # Extraer pregunta original para logging
+    mensajes = body.get("messages", [])
+    pregunta_original = mensajes[-1].get("content", "") if mensajes else ""
+    
     config = modulador_global.modular(vector_global)
     
     openai_body = {
         "model": body.get("model", "llama-3.1-8b-instant"),
-        "messages": body.get("messages", []),
+        "messages": mensajes,
         "temperature": config.get("temperature", 0.7),
         "top_p": config.get("top_p", 0.9)
     }
@@ -175,16 +232,44 @@ async def chat_proxy(request: Request):
             headers = {"Authorization": f"Bearer {GROQ_KEY}", "Content-Type": "application/json"}
             r = await client.post("https://api.groq.com/openai/v1/chat/completions", json=openai_body, headers=headers)
         
-        # Procesar respuesta para el sistema emocional
         resp_json = r.json()
         texto = resp_json["choices"][0]["message"].get("content", "")
         
+        # ====== SEÑALES REALES (no hardcodeadas) ======
+        # Novedad: basada en diversidad léxica (type-token ratio)
+        palabras = re.findall(r'\w+', texto.lower())
+        tipo_token = len(set(palabras)) / max(len(palabras), 1)
+        novedad_real = min(tipo_token * 1.2, 1.0)  # TTR escalado
+        
+        # Complejidad: largo promedio de oraciones + palabras únicas
+        oraciones = [s for s in re.split(r'[.!?]', texto) if s.strip()]
+        largo_prom = sum(len(s.split()) for s in oraciones) / max(len(oraciones), 1)
+        complejidad_real = min(largo_prom / 25.0, 1.0)  # Normalizado a ~25 palabras
+        
+        # Confianza: ausencia de hedging ("quizás", "tal vez", "no estoy seguro")
+        hedges = len(re.findall(r'(quizás|tal vez|no estoy segur|podría ser|es posible|maybe|perhaps)', texto.lower()))
+        confianza_real = max(0.3, 1.0 - (hedges * 0.15))
+        
+        # Éxito: si la respuesta tiene sustancia (más de 20 palabras)
+        exito_real = len(palabras) > 20
+        
         senales = {
-            "novedad": 0.5, "complejidad": 0.5, "confianza_real": 0.7, 
-            "confianza_esperada": 0.5, "exito_tarea": True
+            "novedad": novedad_real,
+            "complejidad": complejidad_real,
+            "confianza_real": confianza_real,
+            "confianza_esperada": 0.6,
+            "exito_tarea": exito_real
         }
-        vector_global.actualizar(senales, utilidad_externa=0.5)
-        vector_global.persistir_snapshot(metadata={"source": "api"})
+        
+        vector_global.actualizar(senales, utilidad_externa=novedad_real * 0.8)
+        vector_global.persistir_snapshot(metadata={
+            "source": "api",
+            "pregunta": pregunta_original[:200],
+            "respuesta": texto[:300],
+            "novedad": round(novedad_real, 3),
+            "complejidad": round(complejidad_real, 3),
+            "confianza": round(confianza_real, 3)
+        })
         
         return resp_json
     except Exception as e: