Translate all code comments, strings, and variable names to English

Updates comments, docstrings, user-facing strings, variable names, and function names across Python and TypeScript files to English.

Replit-Commit-Author: Agent
Replit-Commit-Session-Id: e3ff2484-bbd8-4aba-bea0-1940769b874a
Replit-Commit-Checkpoint-Type: full_checkpoint
Replit-Commit-Event-Id: fca1b854-e4b4-4bfc-9bb2-ebe5af51a4f9
Replit-Commit-Screenshot-Url: https://storage.googleapis.com/screenshot-production-us-central1/1739408b-93a5-479b-a658-30f2493b0467/e3ff2484-bbd8-4aba-bea0-1940769b874a/Pw9jNbA
Replit-Helium-Checkpoint-Created: true

artifacts/api-server/src/middlewares/auth.ts

@@ -8,13 +8,13 @@ export function requireApiKey(req: Request, res: Response, next: NextFunction) {
     : (req.headers["x-api-key"] as string | undefined)?.trim() ?? "";
 
   if (!key) {
-    res.status(401).json({ error: "API key requerida. Usa el header: Authorization: Bearer <tu-key>" });
+    res.status(401).json({ error: "API key required. Use the header: Authorization: Bearer <your-key>" });
     return;
   }
 
   const found = validateKey(key);
   if (!found) {
-    res.status(403).json({ error: "API key inválida o revocada." });
+    res.status(403).json({ error: "Invalid or revoked API key." });
     return;
   }
 
@@ -25,7 +25,7 @@ export function requireApiKey(req: Request, res: Response, next: NextFunction) {
 export function requireAdmin(req: Request, res: Response, next: NextFunction) {
   const secret = req.headers["x-admin-secret"] as string | undefined;
   if (!secret || secret !== getAdminSecret()) {
-    res.status(403).json({ error: "Admin secret incorrecto." });
+    res.status(403).json({ error: "Incorrect admin secret." });
     return;
   }
   next();

artifacts/api-server/src/routes/keys.ts

@@ -7,14 +7,14 @@ const router = Router();
 router.post("/keys", requireAdmin, (req, res) => {
   const { name } = req.body as { name?: string };
   if (!name || typeof name !== "string" || !name.trim()) {
-    res.status(400).json({ error: "El campo 'name' es obligatorio." });
+    res.status(400).json({ error: "The 'name' field is required." });
     return;
   }
   const key = generateKey(name.trim());
   res.status(201).json({
-    message: "API key generada. Guárdala, no se vuelve a mostrar.",
-    key: key.key,
-    name: key.name,
+    message:   "API key generated. Save it now — it won't be shown again.",
+    key:       key.key,
+    name:      key.name,
     createdAt: key.createdAt,
   });
 });
@@ -27,10 +27,10 @@ router.delete("/keys/:name", requireAdmin, (req, res) => {
   const { name } = req.params;
   const ok = revokeKey(name!);
   if (!ok) {
-    res.status(404).json({ error: "Key no encontrada o ya revocada." });
+    res.status(404).json({ error: "Key not found or already revoked." });
     return;
   }
-  res.json({ message: `Key '${name}' revocada.` });
+  res.json({ message: `Key '${name}' revoked.` });
 });
 
 export default router;

artifacts/api-server/src/routes/neo.ts

@@ -11,7 +11,7 @@ router.post("/neo/chat", requireApiKey, async (req, res) => {
   };
 
   if (!message || typeof message !== "string" || !message.trim()) {
-    res.status(400).json({ error: "El campo 'message' es obligatorio." });
+    res.status(400).json({ error: "The 'message' field is required." });
     return;
   }
 
@@ -24,19 +24,19 @@ router.post("/neo/chat", requireApiKey, async (req, res) => {
 
     if (!response.ok) {
       const err = await response.text();
-      res.status(502).json({ error: "Error del modelo NEO-1", detail: err });
+      res.status(502).json({ error: "NEO-1 model error.", detail: err });
       return;
     }
 
     const data = await response.json() as { response: string; model: string; status: string };
     res.json({
       response: data.response,
-      model: data.model ?? "mdfjbots-neo-1",
-      status: "ok",
+      model:    data.model ?? "mdfjbots-neo-1",
+      status:   "ok",
     });
   } catch (err: any) {
     res.status(503).json({
-      error: "No se pudo conectar con el modelo NEO-1. ¿Está corriendo?",
+      error:  "Could not connect to the NEO-1 model. Is it running?",
       detail: err?.message ?? String(err),
     });
   }
@@ -46,10 +46,10 @@ router.get("/neo/models", requireApiKey, (_req, res) => {
   res.json({
     models: [
       {
-        id: "mdfjbots-neo-1",
-        name: "NEO-1",
-        description: "Asistente conversacional con soporte de Roblox, calculadora y temas educativos.",
-        version: "1.13.1",
+        id:          "mdfjbots-neo-1",
+        name:        "NEO-1",
+        description: "Conversational assistant with Roblox support, calculator, and educational topics.",
+        version:     "1.13.1",
       },
     ],
   });

chat-app/app.py

@@ -1,158 +1,157 @@
 import os
 import time
 import gradio as gr
-from neo_rest import iniciar_servidor
+from neo_rest import start_server
 from logica import (
-    buscar_respuesta_personalizada, generar_explicacion_juego,
-    detectar_roblox, modo_calculadora_activo, extraer_texto_content,
+    find_custom_response, generate_game_explanation,
+    detect_roblox, calculator_mode_active, extract_text_content,
 )
-from buscador import buscar as buscar_web, ERROR_RED, ERROR_RATE_LIMIT, ERROR_LICENCIA
-from resumidor import resumir
-from roblox_api import buscar_jugador, buscar_juego, formatear_jugador, formatear_juego
+from buscador import search as web_search, ERROR_NETWORK, ERROR_RATE_LIMIT, ERROR_LICENSE
+from resumidor import summarize
+from roblox_api import search_player, search_game, format_player, format_game
 from matematicas import (
-    es_solicitud_calculadora, es_operacion_matematica,
-    resolver_operacion, formatear_resultado, extraer_nombre_usuario,
+    is_calculator_request, is_math_operation,
+    solve_operation, format_result, extract_username,
 )
 
-def añadir_turno(historial, user_msg, bot_msg=""):
-    return historial + [
+def add_turn(history, user_msg, bot_msg=""):
+    return history + [
         {"role": "user", "content": user_msg},
         {"role": "assistant", "content": bot_msg},
     ]
 
-def stream_tokens(texto, historial):
+def stream_tokens(text, history):
     """
-    Emite la respuesta token por token (palabra por palabra)
-    el proceso de generación de un modelo de lenguaje real.
-    Tokens largos = pausas ligeramente mayores (más "peso" semántico).
+    Emits the response token by token (word by word),
+    simulating the generation process of a real language model.
+    Longer tokens = slightly longer pauses (more semantic weight).
     """
-    tokens = texto.split(" ")
-    acumulado = ""
+    tokens = text.split(" ")
+    accumulated = ""
     for i, token in enumerate(tokens):
-        acumulado += token
+        accumulated += token
         if i < len(tokens) - 1:
-            acumulado += " "
-        historial[-1]["content"] = acumulado
-        # Pausa variable: tokens largos tardan un poco más (como un LLM real)
+            accumulated += " "
+        history[-1]["content"] = accumulated
         delay = 0.055 if len(token) > 4 else 0.030
         time.sleep(delay)
-        yield historial
-
-def responder(mensaje, historial):
-    texto = mensaje.strip().lower()
-
-    if es_solicitud_calculadora(mensaje):
-        nombre = extraer_nombre_usuario(historial)
-        saludo = (
-            f"Claro 😀, {nombre} aquí tienes nuestra calculadora:\n\n"
-            "🧮 **Calculadora Virtual NEO-1**\n"
-            "Escribe cualquier operación matemática y la resolveré al instante.\n\n"
-            "**Ejemplos:**\n"
+        yield history
+
+def respond(message, history):
+    text = message.strip().lower()
+
+    if is_calculator_request(message):
+        name = extract_username(history)
+        greeting = (
+            f"Sure! 😀 {name}, here's our calculator:\n\n"
+            "🧮 **NEO-1 Virtual Calculator**\n"
+            "Type any math operation and I'll solve it instantly.\n\n"
+            "**Examples:**\n"
             "- `5 + 3`\n- `12 * 7`\n- `100 / 4`\n"
-            "- `2 ** 8` (potencia)\n- `144 ** 0.5` (raíz cuadrada)\n\n"
-            "_Escribe tu operación o di 'salir de calculadora' para volver._"
+            "- `2 ** 8` (power)\n- `144 ** 0.5` (square root)\n\n"
+            "_Type your operation or say 'exit calculator' to go back._"
         )
-        historial = añadir_turno(historial, mensaje)
-        for h in stream_tokens(saludo, historial):
+        history = add_turn(history, message)
+        for h in stream_tokens(greeting, history):
             yield h, ""
         return
 
-    if texto in ("salir de calculadora", "salir calculadora", "cerrar calculadora", "volver al chat"):
-        historial = añadir_turno(historial, mensaje, "De acuerdo, volviendo al chat normal. ¡Pregúntame lo que quieras! 😊")
-        yield historial, ""
+    if text in ("exit calculator", "close calculator", "quit calculator", "back to chat"):
+        history = add_turn(history, message, "Alright, back to normal chat. Ask me anything! 😊")
+        yield history, ""
         return
 
-    if modo_calculadora_activo(historial) or es_operacion_matematica(mensaje):
-        resultado = resolver_operacion(mensaje)
-        if resultado is not None:
-            respuesta = formatear_resultado(mensaje, resultado)
-            historial = añadir_turno(historial, mensaje)
-            for h in stream_tokens(respuesta, historial):
+    if calculator_mode_active(history) or is_math_operation(message):
+        result = solve_operation(message)
+        if result is not None:
+            response = format_result(message, result)
+            history = add_turn(history, message)
+            for h in stream_tokens(response, history):
                 yield h, ""
             return
 
-    tipo_roblox, nombre_roblox = detectar_roblox(mensaje)
+    roblox_type, roblox_name = detect_roblox(message)
 
-    if tipo_roblox == "jugador":
-        historial = añadir_turno(historial, mensaje, "🔍 Buscando jugador en Roblox...")
-        yield historial, ""
-        datos = buscar_jugador(nombre_roblox)
-        resultado = formatear_jugador(datos)
-        historial[-1]["content"] = resultado
-        yield historial, ""
+    if roblox_type == "player":
+        history = add_turn(history, message, "🔍 Searching for player on Roblox...")
+        yield history, ""
+        data = search_player(roblox_name)
+        result = format_player(data)
+        history[-1]["content"] = result
+        yield history, ""
         return
 
-    if tipo_roblox == "juego":
-        historial = añadir_turno(historial, mensaje, "🔍 Buscando juego en Roblox...")
-        yield historial, ""
-        datos = buscar_juego(nombre_roblox)
-        resultado = formatear_juego(datos)
-        if datos and "error" not in datos:
-            explicacion = generar_explicacion_juego(datos)
-            resultado = resultado + "\n\n💡 **¿De qué trata el juego?**\n" + explicacion
-        historial[-1]["content"] = resultado
-        yield historial, ""
+    if roblox_type == "game":
+        history = add_turn(history, message, "🔍 Searching for game on Roblox...")
+        yield history, ""
+        data = search_game(roblox_name)
+        result = format_game(data)
+        if data and "error" not in data:
+            explanation = generate_game_explanation(data)
+            result = result + "\n\n💡 **What is this game about?**\n" + explanation
+        history[-1]["content"] = result
+        yield history, ""
         return
 
-    respuesta_personalizada = buscar_respuesta_personalizada(mensaje)
-    if respuesta_personalizada:
-        historial = añadir_turno(historial, mensaje)
-        for h in stream_tokens(respuesta_personalizada, historial):
+    custom_response = find_custom_response(message)
+    if custom_response:
+        history = add_turn(history, message)
+        for h in stream_tokens(custom_response, history):
             yield h, ""
         return
 
-    # ── NEO-2: búsqueda en internet ──────────────────────────────────────────
-    historial = añadir_turno(historial, mensaje, "🌐 Buscando en internet...")
-    yield historial, ""
+    # ── NEO-2: web search fallback ────────────────────────────────────────────
+    history = add_turn(history, message, "🌐 Searching the web...")
+    yield history, ""
 
-    resultado_web = buscar_web(mensaje)
+    web_result = web_search(message)
 
-    if resultado_web.get("encontrado"):
-        resumen = resumir(mensaje, resultado_web)
-        if resumen:
-            historial[-1]["content"] = ""
-            for h in stream_tokens(resumen, historial):
+    if web_result.get("found"):
+        summary = summarize(message, web_result)
+        if summary:
+            history[-1]["content"] = ""
+            for h in stream_tokens(summary, history):
                 yield h, ""
             return
 
-    # ── Mensajes de error según el tipo de fallo ─────────────────────────────
-    tipo_error = resultado_web.get("tipo_error", "")
+    # ── User-facing error messages based on failure type ──────────────────────
+    error_type = web_result.get("error_type", "")
 
-    if tipo_error == ERROR_RED:
+    if error_type == ERROR_NETWORK:
         msg = (
-            "⚠️ **Sin conexión a internet**\n\n"
-            "No pude conectarme al buscador web en este momento. "
-            "Revisé mi base de conocimiento pero tampoco encontré el tema ahí.\n\n"
-            "_Intenta de nuevo en unos segundos o reformula tu pregunta._"
+            "⚠️ **No internet connection**\n\n"
+            "I couldn't reach the web search engine right now. "
+            "I also checked my knowledge base but found nothing on that topic.\n\n"
+            "_Please try again in a few seconds or rephrase your question._"
         )
-    elif tipo_error == ERROR_RATE_LIMIT:
+    elif error_type == ERROR_RATE_LIMIT:
         msg = (
-            "⏳ **Demasiadas búsquedas en poco tiempo**\n\n"
-            "El buscador me pidió pausar un momento. "
-            "Espera unos segundos e intenta de nuevo. 😊"
+            "⏳ **Too many searches in a short time**\n\n"
+            "The search engine asked me to slow down for a moment. "
+            "Please wait a few seconds and try again. 😊"
         )
-    elif tipo_error == ERROR_LICENCIA:
+    elif error_type == ERROR_LICENSE:
         msg = (
-            "🔒 **Fuentes no disponibles**\n\n"
-            "Encontré resultados en internet, pero todas las fuentes usan licencias restrictivas "
-            "(All Rights Reserved, CC BY-ND, etc.) que no me permiten usar su contenido.\n\n"
-            "_Intenta reformular tu pregunta para encontrar fuentes abiertas._"
+            "🔒 **Sources unavailable**\n\n"
+            "I found results online, but all sources use restrictive licenses "
+            "(All Rights Reserved, CC BY-ND, etc.) that don't allow me to use their content.\n\n"
+            "_Try rephrasing your question to find open-licensed sources._"
         )
     else:
         msg = (
-            "🤖 **Sin resultados**\n\n"
-            "No encontré información sobre ese tema ni en mi base de conocimiento "
-            "ni en internet. Intenta reformular tu pregunta."
+            "🤖 **No results found**\n\n"
+            "I couldn't find information on that topic in my knowledge base "
+            "or on the web. Try rephrasing your question."
         )
 
-    historial[-1]["content"] = msg
-    yield historial, ""
+    history[-1]["content"] = msg
+    yield history, ""
 
 with gr.Blocks(title="mdfjbots-neo-1") as demo:
     gr.Markdown(
         """
         # 🤖 mdfjbots-neo-1
-        ### Asistente de inteligencia artificial conversacional
+        ### Conversational AI assistant
         """
     )
 
@@ -163,38 +162,38 @@ with gr.Blocks(title="mdfjbots-neo-1") as demo:
     )
 
     with gr.Row():
-        entrada = gr.Textbox(
-            placeholder="Escribe tu mensaje aquí... (ej: 'buscar jugador Builderman')",
+        input_box = gr.Textbox(
+            placeholder="Type your message here... (e.g. 'search player Builderman')",
             show_label=False,
             scale=9,
             container=False,
             autofocus=True,
         )
-        btn_enviar = gr.Button("Enviar", scale=1, variant="primary")
+        btn_send = gr.Button("Send", scale=1, variant="primary")
 
     with gr.Row():
-        btn_limpiar = gr.Button("🗑️ Limpiar conversación", size="sm")
+        btn_clear = gr.Button("🗑️ Clear conversation", size="sm")
 
     gr.Examples(
         examples=[
-            "Hola, ¿quién eres?",
-            "buscar jugador Builderman",
-            "buscar juego Adopt Me",
-            "definición de historia",
-            "calculadora",
-            "que es linux",
-            "guerra de corea",
+            "Hello, who are you?",
+            "search player Builderman",
+            "search game Adopt Me",
+            "definition of history",
+            "calculator",
+            "what is linux",
+            "korean war",
         ],
-        inputs=entrada,
-        label="Ejemplos de preguntas",
+        inputs=input_box,
+        label="Example questions",
     )
 
-    entrada.submit(fn=responder, inputs=[entrada, chatbot], outputs=[chatbot, entrada])
-    btn_enviar.click(fn=responder, inputs=[entrada, chatbot], outputs=[chatbot, entrada])
-    btn_limpiar.click(fn=lambda: ([], ""), outputs=[chatbot, entrada])
+    input_box.submit(fn=respond, inputs=[input_box, chatbot], outputs=[chatbot, input_box])
+    btn_send.click(fn=respond, inputs=[input_box, chatbot], outputs=[chatbot, input_box])
+    btn_clear.click(fn=lambda: ([], ""), outputs=[chatbot, input_box])
 
 if __name__ == "__main__":
-    iniciar_servidor()
+    start_server()
 
     port = int(os.environ.get("PORT", 5000))
     dev_domain = os.environ.get("REPLIT_DEV_DOMAIN", "")

chat-app/buscador.py

@@ -1,70 +1,70 @@
 """
-buscador.py — NEO-2 Motor de búsqueda web con filtro de licencias
-------------------------------------------------------------------
-Usa ddgs para búsqueda web real. Filtra resultados según la licencia
-del dominio fuente para respetar los términos de uso del contenido.
-
-Política de licencias NEO-2:
-  ✅ PERMITIDAS  : CC BY, CC0, Dominio Público
-  ❌ EVITADAS    : CC BY-SA, CC BY-NC, CC BY-ND, All Rights Reserved
-
-Resiliencia ante fallos:
-  • Reintentos automáticos (hasta 2 intentos con pausa entre ellos)
-  • Caché en memoria para la sesión actual (evita repetir búsquedas)
-  • Errores tipificados para dar mensajes claros al usuario
+buscador.py — NEO-2 Web search engine with license filtering
+------------------------------------------------------------
+Uses ddgs for real web search. Filters results based on the source
+domain's license to respect content usage terms.
+
+NEO-2 license policy:
+  ✅ ALLOWED  : CC BY, CC0, Public Domain
+  ❌ BLOCKED  : CC BY-SA, CC BY-NC, CC BY-ND, All Rights Reserved
+
+Fault tolerance:
+  • Automatic retries (up to 2 attempts with pause between them)
+  • In-memory session cache (avoids repeated searches)
+  • Typed errors for clear user-facing messages
 """
 
 import time
 from ddgs import DDGS
 
-# ── Caché de sesión ────────────────────────────────────────────────────────────
-# Guarda resultados de la sesión actual para no volver a buscar lo mismo.
+# ── Session cache ──────────────────────────────────────────────────────────────
+# Stores results from the current session to avoid re-searching the same query.
 _CACHE: dict[str, dict] = {}
-_MAX_CACHE = 50   # máximo de queries guardadas en memoria
+_MAX_CACHE = 50
 
-_REINTENTOS   = 2     # número de intentos antes de declarar fallo
-_PAUSA_RETRY  = 1.5   # segundos entre reintentos
+_MAX_RETRIES  = 2
+_RETRY_PAUSE  = 1.5
 
-# ── Clasificación de dominios por licencia ─────────────────────────────────────
+# ── Domain classification by license ──────────────────────────────────────────
 
-# ✅ Fuentes con licencia CC BY, CC0 o Dominio Público
-DOMINIOS_PERMITIDOS: dict[str, str] = {
-    # Gobierno / datos abiertos (dominio público o CC0)
-    "nasa.gov":           "CC0 / Dominio Público",
+# ✅ Allowed: CC BY, CC0 or Public Domain sources
+ALLOWED_DOMAINS: dict[str, str] = {
+    # Government / open data (public domain or CC0)
+    "nasa.gov":           "CC0 / Public Domain",
     "data.gov":           "CC0",
-    "datos.gob.mx":       "Dominio Público",
+    "datos.gob.mx":       "Public Domain",
     "datos.gob.es":       "CC BY",
     "datos.gob.ar":       "CC BY",
     "open.canada.ca":     "CC BY",
     "data.europa.eu":     "CC BY 4.0",
     "ec.europa.eu":       "CC BY 4.0",
-    "who.int":            "CC BY-NC-SA",   # OMS — permitida solo referencia
-    "un.org":             "Dominio Público",
+    "who.int":            "CC BY-NC-SA",
+    "un.org":             "Public Domain",
 
-    # Conocimiento abierto (CC0 / CC BY)
+    # Open knowledge (CC0 / CC BY)
     "wikidata.org":       "CC0",
     "commons.wikimedia.org": "CC BY / CC0",
-    "gutenberg.org":      "Dominio Público",
-    "archive.org":        "CC BY / Dominio Público",
+    "gutenberg.org":      "Public Domain",
+    "archive.org":        "CC BY / Public Domain",
     "openstax.org":       "CC BY 4.0",
-    "arxiv.org":          "CC BY / licencia autor",
+    "arxiv.org":          "CC BY / author license",
     "plos.org":           "CC BY 4.0",
     "doaj.org":           "CC BY",
     "creativecommons.org":"CC BY 4.0",
-    "publicdomainreview.org": "CC BY-SA",  # parcialmente abierto
+    "publicdomainreview.org": "CC BY-SA",
     "freesound.org":      "CC0 / CC BY",
-    "unsplash.com":       "Licencia Unsplash (similar CC0)",
+    "unsplash.com":       "Unsplash License (CC0-like)",
     "pixabay.com":        "CC0",
     "pexels.com":         "CC0",
 
-    # Diccionarios / enciclopedias libres (CC BY)
-    "simple.wikipedia.org": "CC BY-SA",  # SA — evitado pero mejor que nada
+    # Free encyclopedias / dictionaries (CC BY)
+    "simple.wikipedia.org": "CC BY-SA",
     "es.wikiversity.org": "CC BY-SA",
 }
 
-# ❌ Fuentes con licencia restrictiva (CC BY-SA, CC BY-NC, CC BY-ND, ARR)
-DOMINIOS_EVITADOS: dict[str, str] = {
-    # CC BY-SA (share-alike — impone licencia en derivados)
+# ❌ Blocked: restrictive licenses (CC BY-SA, CC BY-NC, CC BY-ND, ARR)
+BLOCKED_DOMAINS: dict[str, str] = {
+    # CC BY-SA (share-alike — imposes license on derivatives)
     "wikipedia.org":      "CC BY-SA",
     "wikivoyage.org":     "CC BY-SA",
     "wikibooks.org":      "CC BY-SA",
@@ -74,18 +74,18 @@ DOMINIOS_EVITADOS: dict[str, str] = {
     "stackexchange.com":  "CC BY-SA 4.0",
     "openstreetmap.org":  "ODbL (share-alike)",
 
-    # CC BY-NC (no comercial)
+    # CC BY-NC (non-commercial)
     "medium.com":         "CC BY-NC",
     "academia.edu":       "CC BY-NC",
     "researchgate.net":   "CC BY-NC",
     "slideshare.net":     "CC BY-NC",
     "ted.com":            "CC BY-NC",
 
-    # CC BY-ND (sin derivados — no se puede resumir/parafrasear)
+    # CC BY-ND (no derivatives — cannot be summarized or paraphrased)
     "economist.com":      "CC BY-ND",
     "foreignpolicy.com":  "CC BY-ND",
 
-    # All Rights Reserved (todos los derechos reservados)
+    # All Rights Reserved
     "cnn.com":            "All Rights Reserved",
     "bbc.com":            "All Rights Reserved",
     "bbc.co.uk":          "All Rights Reserved",
@@ -120,141 +120,138 @@ DOMINIOS_EVITADOS: dict[str, str] = {
     "google.es":          "All Rights Reserved",
 }
 
-# ── Clasificar un dominio ──────────────────────────────────────────────────────
+# ── Domain helpers ─────────────────────────────────────────────────────────────
 
-def _dominio_de_url(url: str) -> str:
-    """Extrae el dominio base de una URL."""
+def _extract_domain(url: str) -> str:
+    """Extracts the base domain from a URL."""
     url = url.lower().replace("https://", "").replace("http://", "").replace("www.", "")
     return url.split("/")[0]
 
-def _clasificar_url(url: str) -> str:
-    """
-    Retorna: 'permitido', 'evitado' o 'desconocido'
-    """
-    dominio = _dominio_de_url(url)
+def _classify_url(url: str) -> str:
+    """Returns: 'allowed', 'blocked' or 'unknown'."""
+    domain = _extract_domain(url)
 
-    # Chequear evitados (verificación exacta + sufijos)
-    for d_evitado in DOMINIOS_EVITADOS:
-        if dominio == d_evitado or dominio.endswith("." + d_evitado):
-            return "evitado"
+    for blocked in BLOCKED_DOMAINS:
+        if domain == blocked or domain.endswith("." + blocked):
+            return "blocked"
 
-    # Chequear permitidos
-    for d_permitido in DOMINIOS_PERMITIDOS:
-        if dominio == d_permitido or dominio.endswith("." + d_permitido):
-            return "permitido"
+    for allowed in ALLOWED_DOMAINS:
+        if domain == allowed or domain.endswith("." + allowed):
+            return "allowed"
 
-    # Heurística: dominios .gov y .edu suelen ser CC0 / dominio público
-    if dominio.endswith(".gov") or dominio.endswith(".gob") or \
-       dominio.endswith(".gob.mx") or dominio.endswith(".gob.ar") or \
-       dominio.endswith(".gob.es") or dominio.endswith(".edu"):
-        return "permitido"
+    # Heuristic: .gov and .edu domains are usually CC0 / public domain
+    if (domain.endswith(".gov") or domain.endswith(".gob") or
+            domain.endswith(".gob.mx") or domain.endswith(".gob.ar") or
+            domain.endswith(".gob.es") or domain.endswith(".edu")):
+        return "allowed"
 
-    return "desconocido"
+    return "unknown"
 
-def _es_resultado_util(resultado: dict) -> bool:
-    """Descarta resultados demasiado cortos."""
-    cuerpo = resultado.get("body", "").strip()
-    return len(cuerpo) >= 40
+def _is_useful_result(result: dict) -> bool:
+    """Discards results that are too short to be useful."""
+    body = result.get("body", "").strip()
+    return len(body) >= 40
 
-# ── Tipos de error ─────────────────────────────────────────────────────────────
+# ── Error type constants ───────────────────────────────────────────────────────
 
-ERROR_RED        = "error_red"        # sin conexión / timeout
-ERROR_RATE_LIMIT = "error_rate_limit" # demasiadas peticiones
-ERROR_LICENCIA   = "error_licencia"   # solo fuentes bloqueadas
-ERROR_SIN_DATOS  = "error_sin_datos"  # búsqueda ok pero sin resultados útiles
+ERROR_NETWORK    = "error_network"    # connection failure / timeout
+ERROR_RATE_LIMIT = "error_rate_limit" # too many requests
+ERROR_LICENSE    = "error_license"    # only blocked sources found
+ERROR_NO_DATA    = "error_no_data"    # search ok but no useful results
 
-def _hacer_busqueda(query: str) -> list:
-    """Ejecuta la búsqueda DDGS. Lanza excepción si falla."""
+def _run_search(query: str) -> list:
+    """Executes the DDGS search. Raises an exception on failure."""
     with DDGS() as ddgs:
-        return list(ddgs.text(query, max_results=12, region="es-es"))
+        return list(ddgs.text(query, max_results=12, region="en-us"))
 
-def _procesar_resultados(resultados: list) -> dict:
+def _process_results(results: list) -> dict:
     """
-    Filtra por licencia y construye el dict de respuesta.
-    Retorna el dict final (encontrado True/False).
+    Filters results by license and builds the response dict.
+    Returns the final dict with found=True or found=False.
     """
-    utiles = [r for r in resultados if _es_resultado_util(r)]
+    useful = [r for r in results if _is_useful_result(r)]
 
-    permitidos   = []
-    desconocidos = []
-    for r in utiles:
+    allowed  = []
+    unknown  = []
+    for r in useful:
         url = r.get("href", r.get("url", ""))
-        cat = _clasificar_url(url)
-        if cat == "permitido":
-            permitidos.append(r)
-        elif cat == "desconocido":
-            desconocidos.append(r)
-
-    candidatos = permitidos if permitidos else desconocidos
-
-    if not candidatos:
-        return {"encontrado": False, "tipo_error": ERROR_LICENCIA,
-                "abstract": "", "snippets": [], "titulo": "", "url": "", "licencia": ""}
-
-    primero  = candidatos[0]
-    titulo   = primero.get("title", "").strip()
-    abstract = primero.get("body", "").strip()
-    url      = primero.get("href", primero.get("url", "")).strip()
-    licencia = DOMINIOS_PERMITIDOS.get(_dominio_de_url(url), "Desconocida")
-    snippets = [r.get("body", "").strip() for r in candidatos[1:6] if r.get("body", "").strip()]
-    origen   = "permitido" if permitidos else "desconocido"
+        cat = _classify_url(url)
+        if cat == "allowed":
+            allowed.append(r)
+        elif cat == "unknown":
+            unknown.append(r)
+
+    candidates = allowed if allowed else unknown
+
+    if not candidates:
+        return {
+            "found": False, "error_type": ERROR_LICENSE,
+            "abstract": "", "snippets": [], "title": "", "url": "", "license": "",
+        }
+
+    first    = candidates[0]
+    title    = first.get("title", "").strip()
+    abstract = first.get("body", "").strip()
+    url      = first.get("href", first.get("url", "")).strip()
+    license_ = ALLOWED_DOMAINS.get(_extract_domain(url), "Unknown")
+    snippets = [r.get("body", "").strip() for r in candidates[1:6] if r.get("body", "").strip()]
+    origin   = "allowed" if allowed else "unknown"
 
     return {
-        "titulo": titulo, "abstract": abstract, "snippets": snippets,
-        "url": url, "licencia": licencia, "origen": origen, "encontrado": True,
+        "title": title, "abstract": abstract, "snippets": snippets,
+        "url": url, "license": license_, "origin": origin, "found": True,
     }
 
-# ── Función principal con reintentos + caché ───────────────────────────────────
+# ── Main search function with retries + cache ──────────────────────────────────
 
-def buscar(query: str) -> dict:
+def search(query: str) -> dict:
     """
-    Busca en la web con tres niveles de protección ante fallos:
+    Searches the web with three layers of fault protection:
 
-    1. Caché de sesión — si ya se buscó esta query, devuelve el resultado guardado.
-    2. Reintentos automáticos — intenta hasta _REINTENTOS veces con pausa entre ellos.
-    3. Errores tipificados — distingue entre fallo de red, rate-limit y sin resultados,
-       para que app.py pueda mostrar mensajes claros al usuario.
+    1. Session cache — returns a saved result if this query was already searched.
+    2. Automatic retries — tries up to _MAX_RETRIES times with a pause between them.
+    3. Typed errors — distinguishes between network failure, rate-limit and no
+       results, so app.py can show clear messages to the user.
     """
-    clave = query.strip().lower()
+    cache_key = query.strip().lower()
 
-    # ── 1. Caché ──────────────────────────────────────────────────────────────
-    if clave in _CACHE:
-        resultado = dict(_CACHE[clave])
-        resultado["desde_cache"] = True
-        return resultado
+    # ── 1. Cache ───────────────────────────────────────────────────────────────
+    if cache_key in _CACHE:
+        result = dict(_CACHE[cache_key])
+        result["from_cache"] = True
+        return result
 
-    # ── 2. Reintentos ─────────────────────────────────────────────────────────
-    ultimo_error = None
-    tipo_error   = ERROR_RED
+    # ── 2. Retries ─────────────────────────────────────────────────────────────
+    last_error = None
+    error_type = ERROR_NETWORK
 
-    for intento in range(_REINTENTOS):
+    for attempt in range(_MAX_RETRIES):
         try:
-            resultados = _hacer_busqueda(query)
-            resultado  = _procesar_resultados(resultados)
+            raw_results = _run_search(query)
+            result      = _process_results(raw_results)
 
-            # Guardar en caché si fue exitoso
-            if resultado.get("encontrado"):
+            if result.get("found"):
                 if len(_CACHE) >= _MAX_CACHE:
-                    _CACHE.pop(next(iter(_CACHE)))   # eliminar el más viejo
-                _CACHE[clave] = resultado
+                    _CACHE.pop(next(iter(_CACHE)))
+                _CACHE[cache_key] = result
 
-            return resultado
+            return result
 
         except Exception as e:
-            ultimo_error = str(e)
-            err_lower    = ultimo_error.lower()
+            last_error = str(e)
+            err_lower  = last_error.lower()
 
             if "ratelimit" in err_lower or "429" in err_lower or "too many" in err_lower:
-                tipo_error = ERROR_RATE_LIMIT
-                break   # no tiene sentido reintentar un rate-limit inmediatamente
+                error_type = ERROR_RATE_LIMIT
+                break
 
-            if intento < _REINTENTOS - 1:
-                time.sleep(_PAUSA_RETRY)
+            if attempt < _MAX_RETRIES - 1:
+                time.sleep(_RETRY_PAUSE)
 
-    # ── 3. Fallo definitivo ────────────────────────────────────────────────────
+    # ── 3. Definitive failure ──────────────────────────────────────────────────
     return {
-        "encontrado":  False,
-        "tipo_error":  tipo_error,
-        "detalle":     ultimo_error or "Error desconocido",
-        "abstract": "", "snippets": [], "titulo": "", "url": "", "licencia": "",
+        "found":      False,
+        "error_type": error_type,
+        "detail":     last_error or "Unknown error",
+        "abstract": "", "snippets": [], "title": "", "url": "", "license": "",
     }

chat-app/compilar_respuestas.py

@@ -1,16 +1,19 @@
 """
-compilar_respuestas.py — NEO-1 Closed Edition
-----------------------------------------------
-Convierte respuestas.json en respuestas.dat (cifrado + comprimido).
+compilar_respuestas.py — NEO-1 Closed Edition compiler
+-------------------------------------------------------
+Converts respuestas.json into respuestas.dat (encrypted + compressed).
 
-Uso:
+Usage:
     python chat-app/compilar_respuestas.py
 
-El archivo .dat resultante es la versión cerrada del banco de conocimiento.
-Incluye este .dat en tu repositorio privado y excluye respuestas.json.
+The resulting .dat file is the closed edition of the knowledge base.
+Include this .dat in your private repository and exclude respuestas.json.
 
-La clave de cifrado se lee de la variable de entorno NEO_DATA_KEY.
-Si no está definida, usa la clave interna por defecto.
+The encryption key is read from the NEO_DATA_KEY environment variable.
+If not set, falls back to the internal default key.
+
+Decompile (owner only):
+    python chat-app/compilar_respuestas.py --decompile [output_path]
 """
 
 import os
@@ -19,74 +22,73 @@ import zlib
 import base64
 import json
 
-_DIR = os.path.dirname(os.path.abspath(__file__))
-RUTA_JSON = os.path.join(_DIR, "respuestas.json")
-RUTA_DAT  = os.path.join(_DIR, "respuestas.dat")
+_DIR      = os.path.dirname(os.path.abspath(__file__))
+JSON_PATH = os.path.join(_DIR, "respuestas.json")
+DAT_PATH  = os.path.join(_DIR, "respuestas.dat")
 
-def _clave() -> bytes:
+def _get_key() -> bytes:
     key = os.environ.get("NEO_DATA_KEY", "neo1-mdfj-science-closed-2025")
     return key.encode("utf-8")
 
 def _xor(data: bytes, key: bytes) -> bytes:
     return bytes(b ^ key[i % len(key)] for i, b in enumerate(data))
 
-def compilar():
-    if not os.path.exists(RUTA_JSON):
-        print(f"❌ No se encontró {RUTA_JSON}")
+def compile_knowledge():
+    if not os.path.exists(JSON_PATH):
+        print(f"❌ File not found: {JSON_PATH}")
         sys.exit(1)
 
-    with open(RUTA_JSON, "r", encoding="utf-8") as f:
-        contenido = f.read()
+    with open(JSON_PATH, "r", encoding="utf-8") as f:
+        content = f.read()
 
-    # Validar JSON antes de compilar
     try:
-        datos = json.loads(contenido)
-        n_entradas = len(datos.get("respuestas", []))
+        data        = json.loads(content)
+        entry_count = len(data.get("respuestas", []))
     except json.JSONDecodeError as e:
-        print(f"❌ JSON inválido: {e}")
+        print(f"❌ Invalid JSON: {e}")
         sys.exit(1)
 
-    raw       = contenido.encode("utf-8")
-    comprimido = zlib.compress(raw, level=9)
-    cifrado    = _xor(comprimido, _clave())
-    encoded    = base64.b64encode(cifrado)
+    raw        = content.encode("utf-8")
+    compressed = zlib.compress(raw, level=9)
+    encrypted  = _xor(compressed, _get_key())
+    encoded    = base64.b64encode(encrypted)
 
-    with open(RUTA_DAT, "wb") as f:
+    with open(DAT_PATH, "wb") as f:
         f.write(encoded)
 
-    print(f"✅ Compilado correctamente:")
-    print(f"   Entradas de conocimiento : {n_entradas}")
-    print(f"   JSON original            : {len(raw):,} bytes")
-    print(f"   DAT cifrado              : {len(encoded):,} bytes")
-    print(f"   Guardado en              : {RUTA_DAT}")
+    print("✅ Compiled successfully:")
+    print(f"   Knowledge entries : {entry_count}")
+    print(f"   Original JSON     : {len(raw):,} bytes")
+    print(f"   Encrypted DAT     : {len(encoded):,} bytes")
+    print(f"   Saved to          : {DAT_PATH}")
     print()
-    print("📦 Para la versión cerrada:")
-    print("   - Incluye 'respuestas.dat' en tu repo privado")
-    print("   - NO incluyas 'respuestas.json'")
-    print("   - Define NEO_DATA_KEY como variable de entorno secreta")
-
-def descompilar(destino: str | None = None):
-    """Utilidad: convierte respuestas.dat de vuelta a JSON (solo para el dueño)."""
-    if not os.path.exists(RUTA_DAT):
-        print(f"❌ No se encontró {RUTA_DAT}")
+    print("📦 For the closed edition:")
+    print("   - Include 'respuestas.dat' in your private repo")
+    print("   - Do NOT include 'respuestas.json'")
+    print("   - Set NEO_DATA_KEY as a secret environment variable")
+
+def decompile_knowledge(output_path: str | None = None):
+    """Utility: converts respuestas.dat back to JSON (owner only)."""
+    if not os.path.exists(DAT_PATH):
+        print(f"❌ File not found: {DAT_PATH}")
         sys.exit(1)
 
-    with open(RUTA_DAT, "rb") as f:
+    with open(DAT_PATH, "rb") as f:
         encoded = f.read()
 
-    cifrado    = base64.b64decode(encoded)
-    comprimido = _xor(cifrado, _clave())
-    raw        = zlib.decompress(comprimido)
-    contenido  = raw.decode("utf-8")
+    encrypted  = base64.b64decode(encoded)
+    compressed = _xor(encrypted, _get_key())
+    raw        = zlib.decompress(compressed)
+    content    = raw.decode("utf-8")
 
-    salida = destino or RUTA_JSON.replace(".json", "_descompilado.json")
-    with open(salida, "w", encoding="utf-8") as f:
-        f.write(contenido)
+    destination = output_path or JSON_PATH.replace(".json", "_decompiled.json")
+    with open(destination, "w", encoding="utf-8") as f:
+        f.write(content)
 
-    print(f"✅ Descompilado en: {salida}")
+    print(f"✅ Decompiled to: {destination}")
 
 if __name__ == "__main__":
-    if len(sys.argv) > 1 and sys.argv[1] == "--descompilar":
-        descompilar(sys.argv[2] if len(sys.argv) > 2 else None)
+    if len(sys.argv) > 1 and sys.argv[1] == "--decompile":
+        decompile_knowledge(sys.argv[2] if len(sys.argv) > 2 else None)
     else:
-        compilar()
+        compile_knowledge()

chat-app/logica.py

@@ -5,166 +5,161 @@ import zlib
 import base64
 import random
 import unicodedata
-from roblox_api import buscar_jugador, buscar_juego, formatear_jugador, formatear_juego
+from roblox_api import search_player, search_game, format_player, format_game
 from matematicas import (
-    es_solicitud_calculadora, es_operacion_matematica,
-    resolver_operacion, formatear_resultado, extraer_nombre_usuario,
+    is_calculator_request, is_math_operation,
+    solve_operation, format_result, extract_username,
 )
-from buscador import buscar as buscar_web
-from resumidor import resumir
+from buscador import search as web_search
+from resumidor import summarize
 
-# ── BANCO DE VARIACIONES DE LENGUAJE ──────────────────────────────────────────
+# ── LANGUAGE VARIATION BANK ───────────────────────────────────────────────────
 
 INTROS = [
     "",
-    "¡Claro! ",
-    "¡Con gusto! ",
-    "¡Buena pregunta! ",
-    "Te cuento: ",
-    "Por supuesto. ",
-    "Aquí va: ",
-    "Déjame explicarte. ",
+    "Of course! ",
+    "Gladly! ",
+    "Great question! ",
+    "Here's what I know: ",
+    "Certainly. ",
+    "Here we go: ",
+    "Let me explain. ",
 ]
 
-CONECTORES = [
-    "Además, ",
-    "También vale mencionar que ",
-    "Por otro lado, ",
-    "Cabe añadir que ",
-    "Algo importante: ",
-    "No te olvides de que ",
+CONNECTORS = [
+    "Also, ",
+    "Worth mentioning that ",
+    "On the other hand, ",
+    "It's worth adding that ",
+    "Something important: ",
+    "Don't forget that ",
 ]
 
-CIERRES = [
+CLOSINGS = [
     "",
-    "\n\n¿Tienes alguna otra pregunta? 😊",
-    "\n\n¿Quieres que profundice en algo? 🤔",
-    "\n\n¿Necesitas más detalles sobre esto?",
-    "\n\n¿Algo más en lo que pueda ayudarte?",
-    "\n\n¡Espero que te sea útil! 😄",
+    "\n\nDo you have any other questions? 😊",
+    "\n\nWould you like me to go deeper on anything? 🤔",
+    "\n\nNeed more details on this?",
+    "\n\nAnything else I can help you with?",
+    "\n\nHope that was helpful! 😄",
 ]
 
-# Palabras que indican que un bloque es intro/cierre y no debe moverse
-_MARCAS_FIJAS = (
-    "aquí tienes", "aquí va", "te cuento", "soy ", "¡hola", "claro 😀",
-    "de acuerdo", "fue un placer", "con mucho gusto",
+# Words that indicate a block is an intro/closing and should not be shuffled
+_FIXED_MARKERS = (
+    "here's what", "here we go", "let me", "i'm ", "hello", "of course",
+    "alright", "my pleasure", "gladly", "certainly",
 )
 
-def _es_bloque_fijo(bloque):
-    """Devuelve True si el bloque debe mantenerse en su posición original."""
-    bl = bloque.lower()
-    return any(marca in bl for marca in _MARCAS_FIJAS)
+def _is_fixed_block(block):
+    """Returns True if the block should stay in its original position."""
+    bl = block.lower()
+    return any(marker in bl for marker in _FIXED_MARKERS)
 
-def generar_variacion(respuesta):
+def generate_variation(response):
     """
-    Genera una versión variada de la respuesta para que NEO-1 no suene
-    repetitivo. Estrategia:
-      1. Divide la respuesta en párrafos/bloques (separados por \\n\\n).
-      2. Mantiene el primer bloque fijo si parece una intro.
-      3. Mezcla aleatoriamente los bloques del medio.
-      4. Opcionalmente añade un cierre diferente.
-      5. Con cierta probabilidad inserta un conector antes de un bloque.
+    Generates a varied version of the response so NEO-1 doesn't sound
+    repetitive. Strategy:
+      1. Split the response into paragraphs/blocks (separated by \\n\\n).
+      2. Keep the first block fixed if it looks like an intro.
+      3. Randomly shuffle the middle blocks.
+      4. Optionally append a different closing.
+      5. With some probability, insert a connector before a block.
     """
-    bloques = [b.strip() for b in respuesta.split("\n\n") if b.strip()]
+    blocks = [b.strip() for b in response.split("\n\n") if b.strip()]
 
-    if len(bloques) <= 2:
-        intro = random.choice(INTROS[:4])
-        cierre = random.choice(CIERRES)
-        texto = intro + respuesta + cierre
-        return texto.strip()
+    if len(blocks) <= 2:
+        intro   = random.choice(INTROS[:4])
+        closing = random.choice(CLOSINGS)
+        return (intro + response + closing).strip()
 
-    # Separar intro, medio y cierre
-    inicio = bloques[0]
-    fin    = bloques[-1]
-    medio  = bloques[1:-1]
+    start  = blocks[0]
+    end    = blocks[-1]
+    middle = blocks[1:-1]
 
-    # Mezclar secciones del medio solo si hay más de una y ninguna es fija
-    shuffleable = [b for b in medio if not _es_bloque_fijo(b)]
-    fijos       = [b for b in medio if _es_bloque_fijo(b)]
+    shuffleable = [b for b in middle if not _is_fixed_block(b)]
+    fixed       = [b for b in middle if _is_fixed_block(b)]
 
     random.shuffle(shuffleable)
-    medio_nuevo = fijos + shuffleable  # los fijos siempre primero
-
-    # Con 40% de probabilidad insertar un conector antes de un bloque
-    if len(medio_nuevo) > 1 and random.random() < 0.40:
-        idx = random.randint(1, len(medio_nuevo) - 1)
-        conector = random.choice(CONECTORES)
-        # Solo añadir si el bloque no empieza ya con negrita/emoji
-        if not medio_nuevo[idx].startswith(("**", "🌞", "🌑", "☀️", "💧", "🟢", "🌬️")):
-            medio_nuevo[idx] = conector + medio_nuevo[idx]
-
-    # Cierre variable (50% de probabilidad de añadir uno)
-    cierre = random.choice(CIERRES) if random.random() < 0.50 else ""
-
-    partes = [inicio] + medio_nuevo + [fin]
-    return "\n\n".join(partes) + cierre
-
-GENEROS_ROBLOX = {
-    "Town and City": "un juego de vida urbana y roleplay social",
-    "Adventure": "un juego de aventura y exploración",
-    "Role Playing": "un juego de rol donde puedes ser quien quieras",
-    "Comedy": "un juego de comedia y entretenimiento",
-    "Action": "un juego de acción y combate",
-    "Horror": "un juego de terror y suspenso",
-    "Military": "un juego de temática militar y estrategia",
-    "Medieval": "un juego de temática medieval con castillos y caballeros",
-    "Naval": "un juego de aventuras navales y piratas",
-    "Sci-Fi": "un juego de ciencia ficción",
-    "Sports": "un juego deportivo",
-    "Fighting": "un juego de peleas y combate",
-    "Western": "un juego de temática del lejano oeste",
-    "FPS": "un juego de disparos en primera persona",
-    "Building": "un juego de construcción y creatividad",
-    "Simulator": "un simulador",
-    "Tycoon": "un juego de gestión y negocios (tycoon)",
-    "Obby": "un juego de obstáculos (obby)",
-    "All Genres": "un juego variado",
+    new_middle = fixed + shuffleable
+
+    if len(new_middle) > 1 and random.random() < 0.40:
+        idx       = random.randint(1, len(new_middle) - 1)
+        connector = random.choice(CONNECTORS)
+        if not new_middle[idx].startswith(("**", "🌞", "🌑", "☀️", "💧", "🟢", "🌬️")):
+            new_middle[idx] = connector + new_middle[idx]
+
+    closing = random.choice(CLOSINGS) if random.random() < 0.50 else ""
+
+    parts = [start] + new_middle + [end]
+    return "\n\n".join(parts) + closing
+
+GAME_GENRES = {
+    "Town and City": "an urban life and social roleplay game",
+    "Adventure": "an adventure and exploration game",
+    "Role Playing": "a role-playing game where you can be anyone",
+    "Comedy": "a comedy and entertainment game",
+    "Action": "an action and combat game",
+    "Horror": "a horror and suspense game",
+    "Military": "a military-themed strategy game",
+    "Medieval": "a medieval-themed game with castles and knights",
+    "Naval": "a naval adventure and pirates game",
+    "Sci-Fi": "a science fiction game",
+    "Sports": "a sports game",
+    "Fighting": "a fighting and combat game",
+    "Western": "a Wild West-themed game",
+    "FPS": "a first-person shooter",
+    "Building": "a building and creativity game",
+    "Simulator": "a simulator",
+    "Tycoon": "a management and business tycoon game",
+    "Obby": "an obstacle course game (obby)",
+    "All Genres": "a mixed-genre game",
 }
 
 def _xor(data: bytes, key: bytes) -> bytes:
     return bytes(b ^ key[i % len(key)] for i, b in enumerate(data))
 
-def _clave() -> bytes:
+def _get_key() -> bytes:
     key = os.environ.get("NEO_DATA_KEY", "neo1-mdfj-science-closed-2025")
     return key.encode("utf-8")
 
-def cargar_respuestas():
+def load_responses():
     """
-    Carga el banco de conocimiento. Orden de prioridad:
-      1. respuestas.dat  → versión cerrada (cifrada + comprimida)
-      2. respuestas.json → versión abierta (texto plano)
+    Loads the knowledge base. Priority order:
+      1. responses.dat  → closed edition (encrypted + compressed)
+      2. responses.json → open edition (plain text)
+    Falls back silently if both fail.
     """
-    directorio = os.path.dirname(__file__)
-    ruta_dat   = os.path.join(directorio, "respuestas.dat")
-    ruta_json  = os.path.join(directorio, "respuestas.json")
+    directory  = os.path.dirname(__file__)
+    dat_path   = os.path.join(directory, "respuestas.dat")
+    json_path  = os.path.join(directory, "respuestas.json")
 
-    # ── Versión cerrada (.dat) ────────────────────────────────────────────────
-    if os.path.exists(ruta_dat):
+    # ── Closed edition (.dat) ─────────────────────────────────────────────────
+    if os.path.exists(dat_path):
         try:
-            with open(ruta_dat, "rb") as f:
+            with open(dat_path, "rb") as f:
                 encoded = f.read()
-            cifrado    = base64.b64decode(encoded)
-            comprimido = _xor(cifrado, _clave())
-            raw        = zlib.decompress(comprimido)
-            datos      = json.loads(raw.decode("utf-8"))
-            return datos.get("respuestas", [])
+            encrypted   = base64.b64decode(encoded)
+            compressed  = _xor(encrypted, _get_key())
+            raw         = zlib.decompress(compressed)
+            data        = json.loads(raw.decode("utf-8"))
+            return data.get("respuestas", [])
         except Exception:
-            pass  # Si falla, intenta con el JSON
+            pass
 
-    # ── Versión abierta (.json) ───────────────────────────────────────────────
+    # ── Open edition (.json) ──────────────────────────────────────────────────
     try:
-        with open(ruta_json, "r", encoding="utf-8") as f:
-            datos = json.load(f)
-            return datos.get("respuestas", [])
+        with open(json_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            return data.get("respuestas", [])
     except Exception:
         return []
 
-RESPUESTAS_PERSONALIZADAS = cargar_respuestas()
+KNOWLEDGE_BASE = load_responses()
 
-# ── TOKENIZADOR ────────────────────────────────────────────────────────────────
+# ── TOKENIZER ─────────────────────────────────────────────────────────────────
 
-# Palabras vacías en español — no aportan significado semántico propio.
-# Filtrarlas evita falsos matches como "que es supernova" → licencias.
+# Spanish stopwords — they carry no semantic meaning on their own.
+# Filtering them prevents false matches like "what is a supernova" → licenses.
 STOPWORDS = {
     "que", "es", "el", "la", "los", "las", "un", "una", "unos", "unas",
     "de", "del", "al", "a", "en", "por", "para", "con", "sin", "sobre",
@@ -175,210 +170,229 @@ STOPWORDS = {
     "como", "cómo", "dónde", "quién", "qué", "cuánto", "cuanto",
     "este", "esta", "estos", "estas", "ese", "esa", "esos", "esas",
     "me", "puedes", "puedo", "puede", "quiero", "quieres", "dame",
-    "dime", "dime", "hay", "tiene", "tienen", "tengo",
+    "dime", "hay", "tiene", "tienen", "tengo",
+    # English stopwords
+    "the", "is", "are", "was", "were", "be", "been", "being",
+    "a", "an", "and", "or", "but", "if", "in", "on", "at", "to",
+    "for", "of", "with", "by", "from", "as", "what", "who", "how",
+    "when", "where", "which", "that", "this", "do", "does", "did",
+    "can", "could", "will", "would", "should", "may", "might",
+    "i", "you", "he", "she", "it", "we", "they", "me", "him", "her",
+    "us", "them", "my", "your", "his", "its", "our", "their",
 }
 
-def tokenizar(texto):
+def tokenize(text):
     """
-    Convierte texto a lista de tokens normalizados:
-    1. Elimina tildes/acentos
-    2. Convierte a minúsculas
-    3. Elimina puntuación
-    4. Divide en tokens y filtra stopwords
+    Converts text to a list of normalized tokens:
+    1. Removes accents/diacritics
+    2. Lowercases
+    3. Removes punctuation
+    4. Splits into tokens and filters stopwords
     """
-    texto = unicodedata.normalize("NFD", texto)
-    texto = "".join(c for c in texto if unicodedata.category(c) != "Mn")
-    texto = texto.lower()
-    texto = re.sub(r"[^\w\s]", " ", texto)
-    return [t for t in texto.split() if t and t not in STOPWORDS]
+    text = unicodedata.normalize("NFD", text)
+    text = "".join(c for c in text if unicodedata.category(c) != "Mn")
+    text = text.lower()
+    text = re.sub(r"[^\w\s]", " ", text)
+    return [t for t in text.split() if t and t not in STOPWORDS]
 
-def similitud_tokens(tokens_entrada, tokens_patron):
+def token_similarity(input_tokens, pattern_tokens):
     """
-    Calcula similitud Jaccard sobre tokens significativos (sin stopwords).
-    Requisito mínimo: al menos 1 token significativo en común.
-    Retorna 0.0 si no hay intersección de tokens significativos.
+    Computes Jaccard similarity over significant tokens (without stopwords).
+    Minimum requirement: at least 1 significant token in common.
+    Returns 0.0 if there is no significant token overlap.
     """
-    set_entrada = set(tokens_entrada)
-    set_patron  = set(tokens_patron)
+    set_input   = set(input_tokens)
+    set_pattern = set(pattern_tokens)
 
-    if not set_patron or not set_entrada:
+    if not set_pattern or not set_input:
         return 0.0
 
-    interseccion = set_entrada & set_patron
+    intersection = set_input & set_pattern
 
-    # Sin ningún token significativo en común → score 0 (evita falsos matches)
-    if not interseccion:
+    if not intersection:
         return 0.0
 
-    union   = set_entrada | set_patron
-    jaccard = len(interseccion) / len(union)
+    union   = set_input | set_pattern
+    jaccard = len(intersection) / len(union)
 
-    # Bonus: si todos los tokens del patrón están en la entrada
-    if set_patron.issubset(set_entrada):
+    # Bonus: if all pattern tokens are present in the input
+    if set_pattern.issubset(set_input):
         jaccard = max(jaccard, 0.80)
 
     return jaccard
 
-def buscar_respuesta_personalizada(mensaje):
+def find_custom_response(message):
     """
-    Busca la mejor respuesta usando similitud de tokens y devuelve
-    una variación generada automáticamente para que NEO-1 no repita
-    siempre las mismas palabras.
-    Umbral mínimo: 0.20 (al menos 20% de overlap Jaccard)
+    Finds the best matching response using token similarity and returns
+    an automatically generated variation so NEO-1 doesn't repeat
+    the exact same words every time.
+    Minimum threshold: 0.20 (at least 20% Jaccard overlap)
     """
-    tokens_entrada = tokenizar(mensaje)
-    mejor_respuesta = None
-    mejor_score = 0.0
-    UMBRAL = 0.20
-
-    for entrada in RESPUESTAS_PERSONALIZADAS:
-        for pregunta in entrada.get("preguntas", []):
-            tokens_patron = tokenizar(pregunta)
-            score = similitud_tokens(tokens_entrada, tokens_patron)
-            if score > mejor_score:
-                mejor_score = score
-                mejor_respuesta = entrada.get("respuesta")
-
-    if mejor_score >= UMBRAL and mejor_respuesta:
-        return generar_variacion(mejor_respuesta)
+    input_tokens  = tokenize(message)
+    best_response = None
+    best_score    = 0.0
+    THRESHOLD     = 0.20
+
+    for entry in KNOWLEDGE_BASE:
+        for question in entry.get("preguntas", []):
+            pattern_tokens = tokenize(question)
+            score = token_similarity(input_tokens, pattern_tokens)
+            if score > best_score:
+                best_score    = score
+                best_response = entry.get("respuesta")
+
+    if best_score >= THRESHOLD and best_response:
+        return generate_variation(best_response)
     return None
 
-# ── UTILIDADES ─────────────────────────────────────────────────────────────────
+# ── UTILITIES ──────────────────────────────────────────────────────────────────
 
-def extraer_texto_content(content):
+def extract_text_content(content):
     if not content:
         return ""
     if isinstance(content, str):
         return content
     if isinstance(content, list):
-        partes = []
-        for bloque in content:
-            if isinstance(bloque, str):
-                partes.append(bloque)
-            elif isinstance(bloque, dict):
-                partes.append(str(bloque.get("text") or bloque.get("value") or bloque.get("content") or ""))
-        return " ".join(partes)
+        parts = []
+        for block in content:
+            if isinstance(block, str):
+                parts.append(block)
+            elif isinstance(block, dict):
+                parts.append(str(block.get("text") or block.get("value") or block.get("content") or ""))
+        return " ".join(parts)
     return str(content)
 
-def modo_calculadora_activo(historial):
-    if not historial:
+def calculator_mode_active(history):
+    if not history:
         return False
-    for msg in reversed(historial):
+    for msg in reversed(history):
         if isinstance(msg, dict) and msg.get("role") == "assistant":
-            texto = extraer_texto_content(msg.get("content")).lower()
-            return "calculadora neo-1" in texto or "aquí tienes nuestra calculadora" in texto
+            text = extract_text_content(msg.get("content")).lower()
+            return "neo-1 virtual calculator" in text or "here's our calculator" in text
     return False
 
-# ── ROBLOX ─────────────────────────────────────────────────────────────────────
+# ── ROBLOX ────────────────────────────────────────────────────────────────────
 
-def generar_explicacion_juego(datos):
-    nombre     = datos.get("nombre", "Este juego")
-    tema       = datos.get("tema", "")
-    descripcion = datos.get("descripcion", "").strip()
-    visitas    = datos.get("visitas", 0)
-    creador    = datos.get("creador", "")
+def generate_game_explanation(data):
+    name        = data.get("name", "This game")
+    genre       = data.get("genre", "")
+    description = data.get("description", "").strip()
+    visits      = data.get("visits", 0)
+    creator     = data.get("creator", "")
 
-    tipo   = GENEROS_ROBLOX.get(tema, f"un juego de {tema.lower()}" if tema else "un juego")
-    partes = [f"**{nombre}** es {tipo} de Roblox creado por **{creador}**."]
+    genre_desc = GAME_GENRES.get(genre, f"a {genre.lower()} game" if genre else "a game")
+    parts = [f"**{name}** is {genre_desc} on Roblox created by **{creator}**."]
 
-    if descripcion and descripcion != "Sin descripción.":
-        desc_corta = descripcion[:200] + ("..." if len(descripcion) > 200 else "")
-        partes.append(f"Según su descripción oficial: *\"{desc_corta}\"*")
+    if description and description != "No description.":
+        short_desc = description[:200] + ("..." if len(description) > 200 else "")
+        parts.append(f"According to its official description: *\"{short_desc}\"*")
 
     try:
-        v = int(visitas)
+        v = int(visits)
         if v >= 1_000_000_000:
-            partes.append(f"Es uno de los juegos más visitados de Roblox con más de {v // 1_000_000_000} mil millones de visitas.")
+            parts.append(f"It's one of the most visited games on Roblox with over {v // 1_000_000_000}B visits.")
         elif v >= 1_000_000:
-            partes.append(f"Cuenta con más de {v // 1_000_000} millones de visitas en total.")
+            parts.append(f"It has over {v // 1_000_000}M total visits.")
         elif v >= 1_000:
-            partes.append(f"Cuenta con más de {v // 1_000}K visitas en total.")
+            parts.append(f"It has over {v // 1_000}K total visits.")
     except Exception:
         pass
 
-    return " ".join(partes)
-
-PATRONES_JUGADOR = [
+    return " ".join(parts)
+
+PLAYER_PATTERNS = [
+    r"search\s+player\s+(.+)",
+    r"find\s+player\s+(.+)",
+    r"roblox\s+player\s+(.+)",
+    r"roblox\s+user\s+(.+)",
+    r"roblox\s+profile\s+(.+)",
+    r"search\s+user\s+(.+)",
+    r"find\s+user\s+(.+)",
+    r"who\s+is\s+(.+)\s+on\s+roblox",
+    r"info\s+(?:on|about)\s+(.+)\s+roblox",
+    # Spanish patterns (kept for backward compatibility)
     r"buscar\s+jugador\s+(.+)",
     r"busca\s+jugador\s+(.+)",
     r"jugador\s+de\s+roblox\s+(.+)",
     r"usuario\s+de\s+roblox\s+(.+)",
     r"perfil\s+de\s+roblox\s+(.+)",
-    r"buscar\s+usuario\s+(.+)",
-    r"busca\s+usuario\s+(.+)",
     r"quien\s+es\s+(.+)\s+en\s+roblox",
-    r"quién\s+es\s+(.+)\s+en\s+roblox",
-    r"info\s+de\s+(.+)\s+roblox",
 ]
 
-PATRONES_JUEGO = [
+GAME_PATTERNS = [
+    r"search\s+game\s+(.+)",
+    r"find\s+game\s+(.+)",
+    r"roblox\s+game\s+(.+)",
+    r"search\s+(.+)\s+on\s+roblox",
+    r"find\s+(.+)\s+on\s+roblox",
+    r"game\s+info\s+(.+)",
+    r"game\s+information\s+(.+)",
+    # Spanish patterns (kept for backward compatibility)
     r"buscar\s+juego\s+(.+)",
     r"busca\s+juego\s+(.+)",
     r"juego\s+de\s+roblox\s+(.+)",
     r"buscar\s+(.+)\s+en\s+roblox",
-    r"busca\s+(.+)\s+en\s+roblox",
     r"información\s+del\s+juego\s+(.+)",
-    r"informacion\s+del\s+juego\s+(.+)",
 ]
 
-def detectar_roblox(mensaje):
-    texto = mensaje.lower().strip()
-    for patron in PATRONES_JUGADOR:
-        m = re.search(patron, texto)
+def detect_roblox(message):
+    text = message.lower().strip()
+    for pattern in PLAYER_PATTERNS:
+        m = re.search(pattern, text)
         if m:
-            return "jugador", m.group(1).strip()
-    for patron in PATRONES_JUEGO:
-        m = re.search(patron, texto)
+            return "player", m.group(1).strip()
+    for pattern in GAME_PATTERNS:
+        m = re.search(pattern, text)
         if m:
-            return "juego", m.group(1).strip()
+            return "game", m.group(1).strip()
     return None, None
 
-# ── RESPUESTA FINAL (no-streaming, usada por neo_rest.py) ─────────────────────
+# ── FINAL RESPONSE (non-streaming, used by neo_rest.py) ───────────────────────
 
-def respuesta_final(mensaje, historial):
-    texto = mensaje.strip().lower()
+def final_response(message, history):
+    text = message.strip().lower()
 
-    if es_solicitud_calculadora(mensaje):
-        nombre = extraer_nombre_usuario(historial)
+    if is_calculator_request(message):
+        name = extract_username(history)
         return (
-            f"Claro 😀, {nombre} aquí tienes nuestra calculadora:\n\n"
-            "🧮 **Calculadora Virtual NEO-1**\n"
-            "Escribe cualquier operación matemática y la resolveré al instante.\n\n"
-            "**Ejemplos:** `5 + 3`, `12 * 7`, `100 / 4`, `2 ** 8` (potencia)\n\n"
-            "_Escribe tu operación o di 'salir de calculadora' para volver._"
+            f"Sure! 😀 {name}, here's our calculator:\n\n"
+            "🧮 **NEO-1 Virtual Calculator**\n"
+            "Type any math operation and I'll solve it instantly.\n\n"
+            "**Examples:** `5 + 3`, `12 * 7`, `100 / 4`, `2 ** 8` (power)\n\n"
+            "_Type your operation or say 'exit calculator' to go back._"
         )
 
-    if texto in ("salir de calculadora", "salir calculadora", "cerrar calculadora", "volver al chat"):
-        return "De acuerdo, volviendo al chat normal. ¡Pregúntame lo que quieras! 😊"
+    if text in ("exit calculator", "close calculator", "quit calculator", "back to chat"):
+        return "Alright, back to normal chat. Ask me anything! 😊"
 
-    if modo_calculadora_activo(historial) or es_operacion_matematica(mensaje):
-        resultado = resolver_operacion(mensaje)
-        if resultado is not None:
-            return formatear_resultado(mensaje, resultado)
+    if calculator_mode_active(history) or is_math_operation(message):
+        result = solve_operation(message)
+        if result is not None:
+            return format_result(message, result)
 
-    tipo_roblox, nombre_roblox = detectar_roblox(mensaje)
+    roblox_type, roblox_name = detect_roblox(message)
 
-    if tipo_roblox == "jugador":
-        datos = buscar_jugador(nombre_roblox)
-        return formatear_jugador(datos)
+    if roblox_type == "player":
+        data = search_player(roblox_name)
+        return format_player(data)
 
-    if tipo_roblox == "juego":
-        datos = buscar_juego(nombre_roblox)
-        resultado = formatear_juego(datos)
-        if datos and "error" not in datos:
-            explicacion = generar_explicacion_juego(datos)
-            resultado = resultado + "\n\n💡 **¿De qué trata el juego?**\n" + explicacion
-        return resultado
+    if roblox_type == "game":
+        data   = search_game(roblox_name)
+        result = format_game(data)
+        if data and "error" not in data:
+            explanation = generate_game_explanation(data)
+            result = result + "\n\n💡 **What is this game about?**\n" + explanation
+        return result
 
-    respuesta = buscar_respuesta_personalizada(mensaje)
-    if respuesta:
-        return respuesta
+    response = find_custom_response(message)
+    if response:
+        return response
 
-    # ── NEO-2: búsqueda en internet como respaldo ─────────────────────────────
-    resultado_web = buscar_web(mensaje)
-    if resultado_web.get("encontrado"):
-        resumen = resumir(mensaje, resultado_web)
-        if resumen:
-            return resumen
+    # ── NEO-2: web search fallback ────────────────────────────────────────────
+    web_result = web_search(message)
+    if web_result.get("found"):
+        summary = summarize(message, web_result)
+        if summary:
+            return summary
 
-    return "🤖 No encontré información sobre eso ni en mi base de conocimiento ni en internet. Intenta reformular tu pregunta."
+    return "🤖 I couldn't find information on that topic in my knowledge base or on the web. Try rephrasing your question."

chat-app/matematicas.py

@@ -1,7 +1,15 @@
 import re
 import math
 
-PATRONES_CALCULADORA = [
+CALCULATOR_PATTERNS = [
+    r"virtual calculator",
+    r"\bcalculator\b",
+    r"open calculator",
+    r"use calculator",
+    r"i want to calculate",
+    r"i need a calculator",
+    r"calculator mode",
+    # Spanish patterns (kept for backward compatibility)
     r"calculadora virtual",
     r"calculadora",
     r"abrir calculadora",
@@ -11,28 +19,38 @@ PATRONES_CALCULADORA = [
     r"modo calculadora",
 ]
 
-def es_solicitud_calculadora(mensaje):
-    texto = mensaje.lower().strip()
-    for patron in PATRONES_CALCULADORA:
-        if re.search(patron, texto):
+def is_calculator_request(message):
+    text = message.lower().strip()
+    for pattern in CALCULATOR_PATTERNS:
+        if re.search(pattern, text):
             return True
     return False
 
-def es_operacion_matematica(mensaje):
-    texto = mensaje.strip()
-    texto = texto.replace("por", "*").replace("entre", "/")
-    texto = texto.replace("más", "+").replace("mas", "+")
-    texto = texto.replace("menos", "-").replace("elevado a", "**")
-    texto = texto.replace("al cuadrado", "**2").replace("al cubo", "**3")
-    texto = re.sub(r'\bx\b', '*', texto)
-    if re.search(r'\d', texto) and re.search(r'[\+\-\*\/\%\^]', texto):
+def is_math_operation(message):
+    text = message.strip()
+    # English word replacements
+    text = text.replace("times", "*").replace("divided by", "/")
+    text = text.replace("plus", "+").replace("minus", "-")
+    text = text.replace("to the power of", "**").replace("squared", "**2").replace("cubed", "**3")
+    # Spanish word replacements (backward compatibility)
+    text = text.replace("por", "*").replace("entre", "/")
+    text = text.replace("más", "+").replace("mas", "+")
+    text = text.replace("menos", "-").replace("elevado a", "**")
+    text = text.replace("al cuadrado", "**2").replace("al cubo", "**3")
+    text = re.sub(r'\bx\b', '*', text)
+    if re.search(r'\d', text) and re.search(r'[\+\-\*\/\%\^]', text):
         return True
-    if re.match(r'^\s*[\d\s\+\-\*\/\.\(\)\%\^]+\s*$', texto) and re.search(r'\d', texto):
+    if re.match(r'^\s*[\d\s\+\-\*\/\.\(\)\%\^]+\s*$', text) and re.search(r'\d', text):
         return True
     return False
 
-def resolver_operacion(expresion):
-    expr = expresion.strip()
+def solve_operation(expression):
+    expr = expression.strip()
+    # English word replacements
+    expr = expr.replace("times", "*").replace("divided by", "/")
+    expr = expr.replace("plus", "+").replace("minus", "-")
+    expr = expr.replace("to the power of", "**").replace("squared", "**2").replace("cubed", "**3")
+    # Spanish word replacements (backward compatibility)
     expr = expr.replace("por", "*").replace("entre", "/")
     expr = expr.replace("más", "+").replace("mas", "+")
     expr = expr.replace("menos", "-").replace("elevado a", "**")
@@ -43,58 +61,62 @@ def resolver_operacion(expresion):
     if not expr or not re.search(r'\d', expr):
         return None
     try:
-        espacio_seguro = {
+        safe_namespace = {
             "__builtins__": {},
             "abs": abs, "round": round,
             "sqrt": math.sqrt, "pow": pow,
             "pi": math.pi, "e": math.e,
         }
-        resultado = eval(expr, espacio_seguro)
-        if isinstance(resultado, float) and resultado == int(resultado):
-            return int(resultado)
-        if isinstance(resultado, float):
-            return round(resultado, 6)
-        return resultado
+        result = eval(expr, safe_namespace)
+        if isinstance(result, float) and result == int(result):
+            return int(result)
+        if isinstance(result, float):
+            return round(result, 6)
+        return result
     except Exception:
         return None
 
-def formatear_resultado(expresion_original, resultado):
-    if resultado is None:
-        return "❌ No pude resolver esa operación. Asegúrate de escribirla correctamente, por ejemplo: `5 + 3`, `12 * 4`, `100 / 5`."
-    lineas = [
-        "🧮 **Calculadora NEO-1**",
+def format_result(original_expression, result):
+    if result is None:
+        return "❌ I couldn't solve that operation. Make sure it's written correctly, e.g.: `5 + 3`, `12 * 4`, `100 / 5`."
+    lines = [
+        "🧮 **NEO-1 Calculator**",
         "",
-        f"📥 **Operación:** `{expresion_original.strip()}`",
-        f"📤 **Resultado:** `{resultado}`",
+        f"📥 **Operation:** `{original_expression.strip()}`",
+        f"📤 **Result:** `{result}`",
         "",
-        "_Puedes escribir otra operación o decir 'salir de calculadora' para volver al chat normal._"
+        "_You can type another operation or say 'exit calculator' to go back to normal chat._"
     ]
-    return "\n".join(lineas)
+    return "\n".join(lines)
 
-def extraer_nombre_usuario(historial):
-    patrones_nombre = [
+def extract_username(history):
+    name_patterns = [
+        r"my name is\s+([A-Za-z]+)",
+        r"i am\s+([A-Za-z]+)",
+        r"call me\s+([A-Za-z]+)",
+        r"i'm\s+([A-Za-z]+)",
+        # Spanish patterns (backward compatibility)
         r"me llamo\s+([A-Za-záéíóúÁÉÍÓÚñÑ]+)",
         r"mi nombre es\s+([A-Za-záéíóúÁÉÍÓÚñÑ]+)",
         r"soy\s+([A-Za-záéíóúÁÉÍÓÚñÑ]+)",
         r"llámame\s+([A-Za-záéíóúÁÉÍÓÚñÑ]+)",
-        r"llamame\s+([A-Za-záéíóúÁÉÍÓÚñÑ]+)",
     ]
-    for msg in historial:
+    for msg in history:
         if isinstance(msg, dict):
             if msg.get("role") != "user":
                 continue
             content = msg.get("content") or ""
             if isinstance(content, list):
-                partes = [b.get("text", "") if isinstance(b, dict) else str(b) for b in content]
-                mensaje_usuario = " ".join(partes).lower()
+                parts        = [b.get("text", "") if isinstance(b, dict) else str(b) for b in content]
+                user_message = " ".join(parts).lower()
             else:
-                mensaje_usuario = str(content).lower()
+                user_message = str(content).lower()
         else:
-            mensaje_usuario = (msg[0] or "").lower()
-        for patron in patrones_nombre:
-            m = re.search(patron, mensaje_usuario)
+            user_message = (msg[0] or "").lower()
+        for pattern in name_patterns:
+            m = re.search(pattern, user_message)
             if m:
-                nombre = m.group(1).strip().capitalize()
-                if nombre.lower() not in ("un", "una", "el", "la", "de", "que", "y", "a"):
-                    return nombre
-    return "usuario"
+                name = m.group(1).strip().capitalize()
+                if name.lower() not in ("a", "an", "the", "un", "una", "el", "la", "de", "que", "y"):
+                    return name
+    return "user"

chat-app/neo_rest.py

@@ -5,7 +5,7 @@ from http.server import HTTPServer, BaseHTTPRequestHandler
 import sys
 import os
 sys.path.insert(0, os.path.dirname(__file__))
-from logica import respuesta_final
+from logica import final_response
 
 NEO_REST_PORT = 5001
 
@@ -21,42 +21,42 @@ class NeoAPIHandler(BaseHTTPRequestHandler):
     def do_POST(self):
         if self.path == "/chat":
             try:
-                length = int(self.headers.get("Content-Length", 0))
-                raw = self.rfile.read(length)
-                data = json.loads(raw)
+                length  = int(self.headers.get("Content-Length", 0))
+                raw     = self.rfile.read(length)
+                data    = json.loads(raw)
 
-                mensaje = str(data.get("message", "")).strip()
-                historial = data.get("history", [])
+                message = str(data.get("message", "")).strip()
+                history = data.get("history", [])
 
-                if not mensaje:
-                    self._send_json(400, {"error": "El campo 'message' es obligatorio"})
+                if not message:
+                    self._send_json(400, {"error": "The 'message' field is required."})
                     return
 
-                respuesta = respuesta_final(mensaje, historial)
+                response = final_response(message, history)
                 self._send_json(200, {
-                    "response": respuesta,
-                    "model": "mdfjbots-neo-1",
-                    "status": "ok",
+                    "response": response,
+                    "model":    "mdfjbots-neo-1",
+                    "status":   "ok",
                 })
             except json.JSONDecodeError:
-                self._send_json(400, {"error": "JSON inválido"})
+                self._send_json(400, {"error": "Invalid JSON."})
             except Exception as e:
                 self._send_json(500, {"error": str(e)})
         else:
-            self._send_json(404, {"error": "Ruta no encontrada"})
+            self._send_json(404, {"error": "Route not found."})
 
     def do_GET(self):
         if self.path == "/health":
             self._send_json(200, {"status": "ok", "model": "mdfjbots-neo-1"})
         else:
-            self._send_json(404, {"error": "Ruta no encontrada"})
+            self._send_json(404, {"error": "Route not found."})
 
     def log_message(self, format, *args):
         pass
 
-def iniciar_servidor():
+def start_server():
     server = HTTPServer(("0.0.0.0", NEO_REST_PORT), NeoAPIHandler)
     thread = threading.Thread(target=server.serve_forever, daemon=True)
     thread.start()
-    print(f"[NeoAPI REST] Corriendo en http://0.0.0.0:{NEO_REST_PORT}")
+    print(f"[NeoAPI REST] Running on http://0.0.0.0:{NEO_REST_PORT}")
     return server

chat-app/resumidor.py

@@ -1,182 +1,171 @@
 """
-resumidor.py — NEO-2 Motor de resumen abstractivo
----------------------------------------------------
-Toma datos crudos de la búsqueda web y construye una respuesta
-en prosa propia — no copia los snippets, los reescribe.
-
-Estrategia (sin LLM):
-  1. El título del resultado suele ser el mejor resumen en una línea.
-  2. Extrae hechos clave de los snippets (fechas, lugares, nombres, roles).
-  3. Construye oraciones nuevas combinando esos hechos con plantillas.
-  4. Presenta todo como un párrafo natural, no como lista de bullets copiados.
+resumidor.py — NEO-2 Abstractive summarization engine
+------------------------------------------------------
+Takes raw web search data and builds a prose response
+using its own words — it does not copy snippets verbatim.
+
+Strategy (no LLM required):
+  1. The result title is usually the best single-line summary.
+  2. Extract key facts from snippets (dates, places, names, roles).
+  3. Build new sentences combining those facts with templates.
+  4. Present everything as a natural paragraph, not a copied bullet list.
 """
 
 import re
 import random
 import unicodedata
 
-# ── Encabezados y cierres variados ────────────────────────────────────────────
+# ── Response headers and closings ─────────────────────────────────────────────
 
-_ENCABEZADOS = [
-    "Encontré esto sobre **{tema}**:",
-    "Aquí tienes lo que sé sobre **{tema}**:",
-    "Te cuento sobre **{tema}**:",
-    "Esto es lo que encontré sobre **{tema}**:",
-    "Basándome en información actualizada de internet:",
+_HEADERS = [
+    "Here's what I found about **{topic}**:",
+    "Here's what I know about **{topic}**:",
+    "Let me tell you about **{topic}**:",
+    "This is what I found about **{topic}**:",
+    "Based on up-to-date information from the web:",
 ]
 
-_CONECTORES = [
-    "Además, ", "También se sabe que ", "Por otro lado, ",
-    "Cabe mencionar que ", "Adicionalmente, ", "Se destaca que ",
+_CONNECTORS = [
+    "Also, ", "It's also known that ", "On the other hand, ",
+    "Worth mentioning that ", "Additionally, ", "Notably, ",
 ]
 
-_CIERRES = [
+_CLOSINGS = [
     "",
-    "\n\n¿Quieres que profundice en algún punto? 😊",
-    "\n\n¿Necesitas más detalles?",
-    "\n\n¡Espero que te sea útil! 😄",
+    "\n\nWould you like me to go deeper on any point? 😊",
+    "\n\nNeed more details?",
+    "\n\nHope that was helpful! 😄",
     "",
 ]
 
-# ── Utilidades ─────────────────────────────────────────────────────────────────
+# ── Utilities ──────────────────────────────────────────────────────────────────
 
-def _normalizar(texto: str) -> str:
-    texto = unicodedata.normalize("NFD", texto)
-    texto = "".join(c for c in texto if unicodedata.category(c) != "Mn")
-    return texto.lower()
+def _normalize(text: str) -> str:
+    text = unicodedata.normalize("NFD", text)
+    text = "".join(c for c in text if unicodedata.category(c) != "Mn")
+    return text.lower()
 
-def _limpiar_oracion(oracion: str) -> str:
-    """Limpia marcadores temporales redundantes y normaliza espacios."""
-    oracion = re.sub(r'\s+', ' ', oracion).strip()
-    # Quitar frases que suenan a clickbait
+def _clean_sentence(sentence: str) -> str:
+    """Cleans redundant markers and normalizes whitespace."""
+    sentence = re.sub(r'\s+', ' ', sentence).strip()
     clickbait = [
-        r'haz clic aquí.*', r'lee también.*', r'más información.*',
-        r'sigue leyendo.*', r'descubre.*más.*', r'entérate.*',
+        r'click here.*', r'read more.*', r'more information.*',
+        r'keep reading.*', r'discover more.*', r'find out.*',
     ]
-    for patron in clickbait:
-        oracion = re.sub(patron, '', oracion, flags=re.IGNORECASE)
-    # Capitalizar
-    if oracion:
-        oracion = oracion[0].upper() + oracion[1:]
-        if not oracion[-1] in '.!?':
-            oracion += '.'
-    return oracion.strip()
-
-def _dividir_oraciones(texto: str) -> list[str]:
-    """Divide texto en oraciones individuales."""
-    partes = re.split(r'(?<=[.!?])\s+', texto)
-    return [p.strip() for p in partes if len(p.strip()) > 30]
-
-def _score(oracion: str, query_tokens: list[str]) -> float:
-    norm = _normalizar(oracion)
+    for pattern in clickbait:
+        sentence = re.sub(pattern, '', sentence, flags=re.IGNORECASE)
+    if sentence:
+        sentence = sentence[0].upper() + sentence[1:]
+        if sentence[-1] not in '.!?':
+            sentence += '.'
+    return sentence.strip()
+
+def _split_sentences(text: str) -> list[str]:
+    """Splits text into individual sentences."""
+    parts = re.split(r'(?<=[.!?])\s+', text)
+    return [p.strip() for p in parts if len(p.strip()) > 30]
+
+def _score(sentence: str, query_tokens: list[str]) -> float:
+    norm  = _normalize(sentence)
     score = sum(1.5 for t in query_tokens if t in norm)
-    largo = len(oracion)
-    if 50 <= largo <= 200:
+    length = len(sentence)
+    if 50 <= length <= 200:
         score += 1.0
-    elif largo < 50:
+    elif length < 50:
         score -= 0.5
     return score
 
-def _extraer_hechos(snippets: list[str], query_tokens: list[str], n: int = 3) -> list[str]:
+def _extract_facts(snippets: list[str], query_tokens: list[str], n: int = 3) -> list[str]:
     """
-    Extrae las oraciones más informativas de los snippets,
-    puntuadas por relevancia al query.
+    Extracts the most informative sentences from snippets,
+    scored by relevance to the query.
     """
-    todas = []
+    all_sentences = []
     for s in snippets:
-        todas.extend(_dividir_oraciones(s))
+        all_sentences.extend(_split_sentences(s))
 
-    if not todas:
+    if not all_sentences:
         return []
 
-    puntuadas = sorted(todas, key=lambda o: -_score(o, query_tokens))
-
-    # Deduplicar por similitud superficial
-    seleccionadas = []
-    vistas = set()
-    for o in puntuadas:
-        clave = _normalizar(o)[:50]
-        if clave not in vistas:
-            vistas.add(clave)
-            seleccionadas.append(o)
-        if len(seleccionadas) >= n:
+    scored = sorted(all_sentences, key=lambda s: -_score(s, query_tokens))
+
+    selected = []
+    seen     = set()
+    for sentence in scored:
+        key = _normalize(sentence)[:50]
+        if key not in seen:
+            seen.add(key)
+            selected.append(sentence)
+        if len(selected) >= n:
             break
 
-    return seleccionadas
+    return selected
 
-def _construir_parrafo(titulo_resultado: str, hechos: list[str]) -> str:
+def _build_paragraph(result_title: str, facts: list[str]) -> str:
     """
-    Construye un párrafo en prosa a partir del título y los hechos extraídos.
-    El título actúa como oración principal (lead sentence).
-    Los hechos se integran con conectores naturales.
+    Builds a prose paragraph from the title and extracted facts.
+    The title acts as the lead sentence.
+    Facts are integrated with natural connectors.
     """
-    partes = []
+    parts = []
 
-    # Oración principal desde el título del resultado
-    lead = _limpiar_oracion(titulo_resultado)
+    lead = _clean_sentence(result_title)
     if lead:
-        partes.append(lead)
+        parts.append(lead)
 
-    # Hechos adicionales con conectores variados
-    conectores_usados = random.sample(_CONECTORES, min(len(hechos), len(_CONECTORES)))
-    for i, hecho in enumerate(hechos):
-        hecho_limpio = _limpiar_oracion(hecho)
-        if not hecho_limpio or hecho_limpio.lower()[:40] in lead.lower():
-            continue  # Evitar repetir lo que ya dijo el lead
-        conector = conectores_usados[i] if i < len(conectores_usados) else ""
-        partes.append(conector + hecho_limpio)
+    used_connectors = random.sample(_CONNECTORS, min(len(facts), len(_CONNECTORS)))
+    for i, fact in enumerate(facts):
+        clean_fact = _clean_sentence(fact)
+        if not clean_fact or clean_fact.lower()[:40] in lead.lower():
+            continue
+        connector = used_connectors[i] if i < len(used_connectors) else ""
+        parts.append(connector + clean_fact)
 
-    return " ".join(partes)
+    return " ".join(parts)
 
-# ── Función principal ──────────────────────────────────────────────────────────
+# ── Main function ──────────────────────────────────────────────────────────────
 
-def resumir(query: str, resultado: dict, max_hechos: int = 3) -> str | None:
+def summarize(query: str, result: dict, max_facts: int = 3) -> str | None:
     """
-    Genera una respuesta propia a partir de los resultados web.
-    No copia snippets — construye prosa nueva combinando hechos clave.
+    Generates an original response from web search results.
+    Does not copy snippets — builds new prose from key facts.
     """
-    titulo   = resultado.get("titulo", "").strip()
-    abstract = resultado.get("abstract", "").strip()
-    snippets = resultado.get("snippets", [])
-    url      = resultado.get("url", "").strip()
+    title    = result.get("title", "").strip()
+    abstract = result.get("abstract", "").strip()
+    snippets = result.get("snippets", [])
+    url      = result.get("url", "").strip()
 
-    if not titulo and not abstract and not snippets:
+    if not title and not abstract and not snippets:
         return None
 
-    query_tokens = _normalizar(query).split()
+    query_tokens = _normalize(query).split()
 
-    # Recopilar fuentes de hechos (abstract + snippets)
-    todas_fuentes = []
+    all_sources = []
     if abstract:
-        todas_fuentes.append(abstract)
-    todas_fuentes.extend(snippets)
-
-    hechos = _extraer_hechos(todas_fuentes, query_tokens, n=max_hechos)
+        all_sources.append(abstract)
+    all_sources.extend(snippets)
 
-    # Construir párrafo en prosa
-    parrafo = _construir_parrafo(titulo, hechos)
+    facts     = _extract_facts(all_sources, query_tokens, n=max_facts)
+    paragraph = _build_paragraph(title, facts)
 
-    if not parrafo.strip():
+    if not paragraph.strip():
         return None
 
-    # Encabezado dinámico basado en el tema principal
-    tema = titulo.split(":")[0].split("—")[0].strip() if titulo else query
-    encabezado = random.choice(_ENCABEZADOS).format(tema=tema)
-
-    cierre = random.choice(_CIERRES)
+    topic   = title.split(":")[0].split("—")[0].strip() if title else query
+    header  = random.choice(_HEADERS).format(topic=topic)
+    closing = random.choice(_CLOSINGS)
 
-    # Mostrar fuente y licencia si están disponibles
-    licencia = resultado.get("licencia", "")
-    origen   = resultado.get("origen", "desconocido")
+    license_ = result.get("license", "")
+    origin   = result.get("origin", "unknown")
 
     if url:
-        if licencia and licencia != "Desconocida":
-            pie = f"\n\n🔗 Fuente: {url}\n📄 Licencia: {licencia}"
-        elif origen == "desconocido":
-            pie = f"\n\n🔗 Fuente: {url}\n⚠️ _Licencia desconocida — contenido usado solo como referencia._"
+        if license_ and license_ != "Unknown":
+            footer = f"\n\n🔗 Source: {url}\n📄 License: {license_}"
+        elif origin == "unknown":
+            footer = f"\n\n🔗 Source: {url}\n⚠️ _Unknown license — content used for reference only._"
         else:
-            pie = f"\n\n🔗 Fuente: {url}"
+            footer = f"\n\n🔗 Source: {url}"
     else:
-        pie = ""
+        footer = ""
 
-    return f"{encabezado}\n\n{parrafo}{pie}{cierre}".strip()
+    return f"{header}\n\n{paragraph}{footer}{closing}".strip()

chat-app/roblox_api.py

@@ -5,175 +5,191 @@ HEADERS = {
     "Accept": "application/json",
 }
 
-def buscar_jugador(nombre):
+def search_player(name):
     try:
-        url = "https://users.roblox.com/v1/usernames/users"
-        resp = requests.post(url, json={"usernames": [nombre], "excludeBannedUsers": False}, headers=HEADERS, timeout=8)
-        datos = resp.json()
-        usuarios = datos.get("data", [])
-        if not usuarios:
+        url  = "https://users.roblox.com/v1/usernames/users"
+        resp = requests.post(
+            url,
+            json={"usernames": [name], "excludeBannedUsers": False},
+            headers=HEADERS,
+            timeout=8,
+        )
+        data  = resp.json()
+        users = data.get("data", [])
+        if not users:
             return None
-        usuario = usuarios[0]
-        user_id = usuario["id"]
-        perfil = obtener_perfil(user_id)
-        avatar_url = obtener_avatar(user_id)
-        estadisticas = obtener_estadisticas(user_id)
+        user    = users[0]
+        user_id = user["id"]
+        profile = get_profile(user_id)
+        avatar  = get_avatar(user_id)
+        stats   = get_stats(user_id)
         return {
-            "id": user_id,
-            "nombre": usuario.get("name"),
-            "nombre_display": usuario.get("displayName"),
-            "descripcion": perfil.get("description", ""),
-            "creado": perfil.get("created", "Desconocido"),
-            "is_banned": perfil.get("isBanned", False),
-            "avatar": avatar_url,
-            "amigos": estadisticas.get("amigos", "N/A"),
-            "seguidores": estadisticas.get("seguidores", "N/A"),
-            "siguiendo": estadisticas.get("siguiendo", "N/A"),
+            "id":           user_id,
+            "name":         user.get("name"),
+            "display_name": user.get("displayName"),
+            "description":  profile.get("description", ""),
+            "created":      profile.get("created", "Unknown"),
+            "is_banned":    profile.get("isBanned", False),
+            "avatar":       avatar,
+            "friends":      stats.get("friends", "N/A"),
+            "followers":    stats.get("followers", "N/A"),
+            "following":    stats.get("following", "N/A"),
         }
     except Exception as e:
         return {"error": str(e)}
 
-def obtener_perfil(user_id):
+def get_profile(user_id):
     try:
-        url = f"https://users.roblox.com/v1/users/{user_id}"
+        url  = f"https://users.roblox.com/v1/users/{user_id}"
         resp = requests.get(url, headers=HEADERS, timeout=8)
         return resp.json()
     except Exception:
         return {}
 
-def obtener_avatar(user_id):
+def get_avatar(user_id):
     try:
-        url = f"https://thumbnails.roblox.com/v1/users/avatar-headshot?userIds={user_id}&size=420x420&format=Png&isCircular=false"
+        url  = (
+            f"https://thumbnails.roblox.com/v1/users/avatar-headshot"
+            f"?userIds={user_id}&size=420x420&format=Png&isCircular=false"
+        )
         resp = requests.get(url, headers=HEADERS, timeout=8)
-        datos = resp.json()
-        return datos.get("data", [{}])[0].get("imageUrl", None)
+        data = resp.json()
+        return data.get("data", [{}])[0].get("imageUrl", None)
     except Exception:
         return None
 
-def obtener_estadisticas(user_id):
-    resultado = {}
+def get_stats(user_id):
+    result = {}
     try:
-        r = requests.get(f"https://friends.roblox.com/v1/users/{user_id}/friends/count", headers=HEADERS, timeout=8)
-        resultado["amigos"] = r.json().get("count", "N/A")
+        r = requests.get(
+            f"https://friends.roblox.com/v1/users/{user_id}/friends/count",
+            headers=HEADERS, timeout=8,
+        )
+        result["friends"] = r.json().get("count", "N/A")
     except Exception:
-        resultado["amigos"] = "N/A"
+        result["friends"] = "N/A"
     try:
-        r = requests.get(f"https://friends.roblox.com/v1/users/{user_id}/followers/count", headers=HEADERS, timeout=8)
-        resultado["seguidores"] = r.json().get("count", "N/A")
+        r = requests.get(
+            f"https://friends.roblox.com/v1/users/{user_id}/followers/count",
+            headers=HEADERS, timeout=8,
+        )
+        result["followers"] = r.json().get("count", "N/A")
     except Exception:
-        resultado["seguidores"] = "N/A"
+        result["followers"] = "N/A"
     try:
-        r = requests.get(f"https://friends.roblox.com/v1/users/{user_id}/followings/count", headers=HEADERS, timeout=8)
-        resultado["siguiendo"] = r.json().get("count", "N/A")
+        r = requests.get(
+            f"https://friends.roblox.com/v1/users/{user_id}/followings/count",
+            headers=HEADERS, timeout=8,
+        )
+        result["following"] = r.json().get("count", "N/A")
     except Exception:
-        resultado["siguiendo"] = "N/A"
-    return resultado
+        result["following"] = "N/A"
+    return result
 
-def buscar_juego(nombre):
+def search_game(name):
     try:
-        url = f"https://games.roblox.com/v1/games/list?keyword={nombre}&maxRows=5&startRows=0"
+        url  = f"https://games.roblox.com/v1/games/list?keyword={name}&maxRows=5&startRows=0"
         resp = requests.get(url, headers=HEADERS, timeout=8)
-        datos = resp.json()
-        juegos = datos.get("games", [])
-        if not juegos:
+        data = resp.json()
+        games = data.get("games", [])
+        if not games:
             return None
-        universe_id = juegos[0].get("universeId")
+        universe_id = games[0].get("universeId")
         if not universe_id:
             return None
-        detalle = obtener_detalle_juego(universe_id)
-        return detalle
+        return get_game_details(universe_id)
     except Exception as e:
         return {"error": str(e)}
 
-def obtener_detalle_juego(universe_id):
+def get_game_details(universe_id):
     try:
-        url = f"https://games.roblox.com/v1/games?universeIds={universe_id}"
+        url  = f"https://games.roblox.com/v1/games?universeIds={universe_id}"
         resp = requests.get(url, headers=HEADERS, timeout=8)
-        datos = resp.json()
-        juegos = datos.get("data", [])
-        if not juegos:
+        data = resp.json()
+        games = data.get("data", [])
+        if not games:
             return None
-        j = juegos[0]
-        actualizado = j.get("updated", "Desconocido")
-        if actualizado and actualizado != "Desconocido":
-            actualizado = actualizado[:10]
+        g           = games[0]
+        last_update = g.get("updated", "Unknown")
+        if last_update and last_update != "Unknown":
+            last_update = last_update[:10]
         return {
-            "nombre": j.get("name"),
-            "tema": j.get("genre", "Sin categoría"),
-            "visitas": j.get("visits", 0),
-            "ultima_update": actualizado,
-            "descripcion": j.get("description") or "Sin descripción.",
-            "creador": j.get("creator", {}).get("name", "Desconocido"),
-            "jugando": j.get("playing", 0),
-            "id": universe_id,
+            "name":        g.get("name"),
+            "genre":       g.get("genre", "Uncategorized"),
+            "visits":      g.get("visits", 0),
+            "last_update": last_update,
+            "description": g.get("description") or "No description.",
+            "creator":     g.get("creator", {}).get("name", "Unknown"),
+            "playing":     g.get("playing", 0),
+            "id":          universe_id,
         }
     except Exception as e:
         return {"error": str(e)}
 
-def formatear_jugador(datos):
-    if not datos:
-        return "No encontré ese jugador en Roblox. Verifica que el nombre de usuario sea correcto."
-    if "error" in datos:
-        return f"Hubo un error al buscar el jugador: {datos['error']}"
-
-    descripcion = datos.get("descripcion") or "Sin descripción."
-    fecha = datos.get("creado", "Desconocido")
-    if fecha != "Desconocido":
-        fecha = fecha[:10]
-    baneado = "Sí ⚠️" if datos.get("is_banned") else "No ✅"
-    amigos = datos.get("amigos", "N/A")
-    seguidores = datos.get("seguidores", "N/A")
-    siguiendo = datos.get("siguiendo", "N/A")
-
-    lineas = [
-        "Aquí tienes datos públicos del jugador en Roblox 😊",
+def format_player(data):
+    if not data:
+        return "I couldn't find that player on Roblox. Please check that the username is correct."
+    if "error" in data:
+        return f"An error occurred while searching for the player: {data['error']}"
+
+    description = data.get("description") or "No description."
+    created     = data.get("created", "Unknown")
+    if created != "Unknown":
+        created = created[:10]
+    banned    = "Yes ⚠️" if data.get("is_banned") else "No ✅"
+    friends   = data.get("friends", "N/A")
+    followers = data.get("followers", "N/A")
+    following = data.get("following", "N/A")
+
+    lines = [
+        "Here's the public data for this Roblox player 😊",
         "",
-        f"👤 **Nombre de usuario:** {datos['nombre']}",
-        f"✏️ **Su nombre completo:** {datos['nombre_display']}",
-        f"🆔 **ID:** {datos['id']}",
-        f"📝 **Historia (descripción):** {descripcion}",
-        f"📅 **Nacimiento de la cuenta de Roblox:** {fecha}",
-        f"🚫 **¿Fue baneado?:** {baneado}",
+        f"👤 **Username:** {data['name']}",
+        f"✏️ **Display name:** {data['display_name']}",
+        f"🆔 **ID:** {data['id']}",
+        f"📝 **Description:** {description}",
+        f"📅 **Account created:** {created}",
+        f"🚫 **Banned?:** {banned}",
         "",
-        "📊 **Estadísticas:**",
-        f"👫 **Sus amigos:** {amigos}",
-        f"👥 **Sus seguidores:** {seguidores}",
-        f"➡️ **A quien sigue:** {siguiendo}",
+        "📊 **Stats:**",
+        f"👫 **Friends:** {friends}",
+        f"👥 **Followers:** {followers}",
+        f"➡️ **Following:** {following}",
     ]
 
-    if datos.get("avatar"):
-        lineas.append(f"\n🖼️ **Avatar:** {datos['avatar']}")
+    if data.get("avatar"):
+        lines.append(f"\n🖼�� **Avatar:** {data['avatar']}")
 
-    return "\n".join(lineas)
+    return "\n".join(lines)
 
-def formatear_juego(datos):
-    if not datos:
-        return "No encontré ese juego en Roblox. Intenta con otro nombre."
-    if "error" in datos:
-        return f"Hubo un error al buscar el juego: {datos['error']}"
+def format_game(data):
+    if not data:
+        return "I couldn't find that game on Roblox. Try a different name."
+    if "error" in data:
+        return f"An error occurred while searching for the game: {data['error']}"
 
-    visitas = datos.get("visitas", 0)
+    visits = data.get("visits", 0)
     try:
-        visitas = f"{int(visitas):,}"
+        visits = f"{int(visits):,}"
     except Exception:
-        visitas = str(visitas)
+        visits = str(visits)
 
-    jugando = datos.get("jugando", 0)
+    playing = data.get("playing", 0)
     try:
-        jugando = f"{int(jugando):,}"
+        playing = f"{int(playing):,}"
     except Exception:
-        jugando = str(jugando)
+        playing = str(playing)
 
-    lineas = [
-        "Datos del juego de Roblox 😎",
+    lines = [
+        "Roblox game data 😎",
         "",
-        f"🎮 **Nombre:** {datos.get('nombre', 'Desconocido')}",
-        f"🎭 **Tema:** {datos.get('tema', 'Sin categoría')}",
-        f"👁️ **Vistas:** {visitas}",
-        f"🔄 **Última update:** {datos.get('ultima_update', 'Desconocido')}",
-        f"📝 **Descripción del juego:** {datos.get('descripcion', 'Sin descripción.')}",
+        f"🎮 **Name:** {data.get('name', 'Unknown')}",
+        f"🎭 **Genre:** {data.get('genre', 'Uncategorized')}",
+        f"👁️ **Visits:** {visits}",
+        f"🔄 **Last update:** {data.get('last_update', 'Unknown')}",
+        f"📝 **Description:** {data.get('description', 'No description.')}",
         "",
-        f"👤 **Creador:** {datos.get('creador', 'Desconocido')}",
-        f"👥 **Jugando ahora:** {jugando}",
+        f"👤 **Creator:** {data.get('creator', 'Unknown')}",
+        f"👥 **Currently playing:** {playing}",
     ]
-    return "\n".join(lineas)
+    return "\n".join(lines)