Initial Commit

agent.py

@@ -0,0 +1,152 @@
+from typing import Dict, List, Optional, Union
+import spacy
+from transformers import AutoTokenizer, AutoModel
+import torch
+import numpy as np
+import re
+from patterns import (
+    PATRONES_AMBIGUEDAD_LEXICA,
+    PATRONES_AMBIGUEDAD_SINTACTICA,
+    SUGERENCIAS_MEJORA
+)
+
+class SemanticAnalyzer:
+    """
+    Analizador semántico que utiliza embeddings para comparar textos.
+    """
+    def __init__(self, model_name: str = "PlanTL-GOB-ES/roberta-base-bne"):
+        """
+        Inicializa el analizador semántico.
+        
+        Args:
+            model_name (str): Nombre del modelo de HuggingFace a utilizar
+        """
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.model = AutoModel.from_pretrained(model_name)
+        except Exception as e:
+            raise RuntimeError(f"Error cargando el modelo {model_name}: {str(e)}")
+
+    def get_embedding(self, texto: str) -> np.ndarray:
+        """
+        Obtiene el embedding de un texto usando el modelo de transformers.
+        
+        Args:
+            texto (str): Texto a procesar
+            
+        Returns:
+            np.ndarray: Vector de embedding
+        """
+        inputs = self.tokenizer(texto, return_tensors="pt", padding=True, truncation=True)
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+        return outputs.last_hidden_state.mean(dim=1).numpy()[0]
+
+    def calcular_similitud(self, texto1: str, texto2: str) -> float:
+        """
+        Compara la similitud semántica entre dos textos.
+        
+        Args:
+            texto1 (str): Primer texto
+            texto2 (str): Segundo texto
+            
+        Returns:
+            float: Score de similitud entre 0 y 1
+        """
+        emb1 = self.get_embedding(texto1)
+        emb2 = self.get_embedding(texto2)
+        similarity = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
+        return float(similarity)
+
+class AmbiguityClassifier:
+    """
+    Clasificador de ambigüedades en historias de usuario.
+    Detecta ambigüedades léxicas y sintácticas, y proporciona sugerencias de mejora.
+    """
+    
+    def __init__(self, model_name: str = "PlanTL-GOB-ES/roberta-base-bne"):
+        """
+        Inicializa el clasificador de ambigüedades.
+        
+        Args:
+            model_name (str): Nombre del modelo de HuggingFace a utilizar
+        """
+        try:
+            self.nlp = spacy.load("es_core_news_sm")
+        except OSError:
+            raise RuntimeError("Es necesario instalar el modelo es_core_news_sm. Ejecute: python -m spacy download es_core_news_sm")
+            
+        self.semantic_analyzer = SemanticAnalyzer(model_name)
+
+    def __call__(self, texto: str) -> Dict[str, Union[bool, List[str], float]]:
+        """
+        Analiza una historia de usuario en busca de ambigüedades.
+        
+        Args:
+            texto (str): Historia de usuario a analizar
+            
+        Returns:
+            Dict: Resultado del análisis con tipos de ambigüedad y sugerencias
+        """
+        if not texto or not isinstance(texto, str):
+            return {
+                "tiene_ambiguedad": False,
+                "ambiguedad_lexica": [],
+                "ambiguedad_sintactica": [],
+                "sugerencias": ["El texto está vacío o no es válido"],
+                "score_ambiguedad": 0.0
+            }
+
+        # Procesar el texto con spaCy
+        doc = self.nlp(texto.strip())
+        
+        # Detectar ambigüedades léxicas
+        ambiguedades_lexicas = []
+        for patron in PATRONES_AMBIGUEDAD_LEXICA:
+            if re.search(patron["patron"], texto, re.IGNORECASE):
+                ambiguedades_lexicas.append({
+                    "tipo": patron["tipo"],
+                    "descripcion": patron["descripcion"]
+                })
+
+        # Detectar ambigüedades sintácticas
+        ambiguedades_sintacticas = []
+        for patron in PATRONES_AMBIGUEDAD_SINTACTICA:
+            if re.search(patron["patron"], texto, re.IGNORECASE):
+                ambiguedades_sintacticas.append({
+                    "tipo": patron["tipo"],
+                    "descripcion": patron["descripcion"]
+                })
+
+        # Generar sugerencias de mejora
+        sugerencias = []
+        if ambiguedades_lexicas or ambiguedades_sintacticas:
+            for ambiguedad in ambiguedades_lexicas + ambiguedades_sintacticas:
+                tipo = ambiguedad["tipo"]
+                if tipo in SUGERENCIAS_MEJORA:
+                    sugerencias.extend(SUGERENCIAS_MEJORA[tipo])
+
+        # Calcular score de ambigüedad
+        score = len(ambiguedades_lexicas) * 0.4 + len(ambiguedades_sintacticas) * 0.6
+        score_normalizado = min(1.0, score / 5.0)  # Normalizar a un rango de 0 a 1
+
+        return {
+            "tiene_ambiguedad": bool(ambiguedades_lexicas or ambiguedades_sintacticas),
+            "ambiguedad_lexica": [amb["descripcion"] for amb in ambiguedades_lexicas],
+            "ambiguedad_sintactica": [amb["descripcion"] for amb in ambiguedades_sintacticas],
+            "sugerencias": sugerencias if sugerencias else ["No se encontraron ambigüedades"],
+            "score_ambiguedad": round(score_normalizado, 2)
+        }
+
+    def analizar_similitud_semantica(self, texto1: str, texto2: str) -> float:
+        """
+        Compara la similitud semántica entre dos textos.
+        
+        Args:
+            texto1 (str): Primer texto
+            texto2 (str): Segundo texto
+            
+        Returns:
+            float: Score de similitud entre 0 y 1
+        """
+        return self.semantic_analyzer.calcular_similitud(texto1, texto2) 

app.py

@@ -0,0 +1,305 @@
+import os
+import gradio as gr
+import requests
+import inspect
+import pandas as pd
+from agent import AmbiguityClassifier
+import json
+
+# (Keep Constants as is)
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+class BasicAgent:
+    """A langgraph agent that detects and classifies ambiguities in user stories."""
+    def __init__(self):
+        print("BasicAgent initialized.")
+        self.analizar_historia = AmbiguityClassifier()
+      
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        try:
+            resultado = self.analizar_historia(question)
+            
+            # Formatear la respuesta
+            respuesta = []
+            if resultado["tiene_ambiguedad"]:
+                respuesta.append("Se encontraron las siguientes ambigüedades:")
+                
+                if resultado["ambiguedad_lexica"]:
+                    respuesta.append("\nAmbigüedades léxicas:")
+                    for amb in resultado["ambiguedad_lexica"]:
+                        respuesta.append(f"- {amb}")
+                
+                if resultado["ambiguedad_sintactica"]:
+                    respuesta.append("\nAmbigüedades sintácticas:")
+                    for amb in resultado["ambiguedad_sintactica"]:
+                        respuesta.append(f"- {amb}")
+                
+                respuesta.append(f"\nScore de ambigüedad: {resultado['score_ambiguedad']}")
+                respuesta.append("\nSugerencias de mejora:")
+                for sug in resultado["sugerencias"]:
+                    respuesta.append(f"- {sug}")
+            else:
+                respuesta.append("No se encontraron ambigüedades en la historia de usuario.")
+                respuesta.append(f"Score de ambigüedad: {resultado['score_ambiguedad']}")
+            
+            return "\n".join(respuesta)
+        except Exception as e:
+            error_msg = f"Error analizando la historia: {str(e)}"
+            print(error_msg)
+            return error_msg
+
+def run_and_submit_all( profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
+    """
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+
+    if profile:
+        username= f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
+
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    # 1. Instantiate Agent ( modify this part to create your agent)
+    try:
+        agent = BasicAgent()
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
+
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+    print(f"Running agent on {len(questions_data)} questions...")
+    for item in questions_data:
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
+            continue
+        try:
+            submitted_answer = agent(question_text)
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+        except Exception as e:
+             print(f"Error running agent on task {task_id}: {e}")
+             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+
+    if not answers_payload:
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Prepare Submission 
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # 5. Submit
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result_data = response.json()
+        final_status = (
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
+        )
+        print("Submission successful.")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.Timeout:
+        status_message = "Submission Failed: The request timed out."
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.RequestException as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except Exception as e:
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
+# Inicializar el clasificador
+classifier = AmbiguityClassifier()
+
+def analyze_user_story(user_story: str) -> str:
+    """Analiza una historia de usuario y retorna los resultados formateados."""
+    if not user_story.strip():
+        return "Por favor, ingrese una historia de usuario para analizar."
+    
+    # Analizar la historia
+    result = classifier(user_story)
+    
+    # Formatear resultados
+    output = []
+    output.append(f"📝 Historia analizada:\n{user_story}\n")
+    output.append(f"🎯 Score de ambigüedad: {result['score_ambiguedad']}")
+    
+    if result['ambiguedad_lexica']:
+        output.append("\n📚 Ambigüedades léxicas encontradas:")
+        for amb in result['ambiguedad_lexica']:
+            output.append(f"• {amb}")
+    
+    if result['ambiguedad_sintactica']:
+        output.append("\n🔍 Ambigüedades sintácticas encontradas:")
+        for amb in result['ambiguedad_sintactica']:
+            output.append(f"• {amb}")
+    
+    if result['sugerencias']:
+        output.append("\n💡 Sugerencias de mejora:")
+        for sug in result['sugerencias']:
+            output.append(f"• {sug}")
+    
+    return "\n".join(output)
+
+def analyze_multiple_stories(user_stories: str) -> str:
+    """Analiza múltiples historias de usuario separadas por líneas."""
+    if not user_stories.strip():
+        return "Por favor, ingrese al menos una historia de usuario para analizar."
+    
+    stories = [s.strip() for s in user_stories.split('\n') if s.strip()]
+    all_results = []
+    
+    for i, story in enumerate(stories, 1):
+        result = classifier(story)
+        story_result = {
+            "historia": story,
+            "score": result['score_ambiguedad'],
+            "ambiguedades_lexicas": result['ambiguedad_lexica'],
+            "ambiguedades_sintacticas": result['ambiguedad_sintactica'],
+            "sugerencias": result['sugerencias']
+        }
+        all_results.append(story_result)
+    
+    return json.dumps(all_results, indent=2, ensure_ascii=False)
+
+# Crear la interfaz
+with gr.Blocks(title="Detector de Ambigüedades en Historias de Usuario") as demo:
+    gr.Markdown("""
+    # 🔍 Detector de Ambigüedades en Historias de Usuario
+    
+    Esta herramienta analiza historias de usuario en busca de ambigüedades léxicas y sint��cticas, 
+    proporcionando sugerencias para mejorarlas.
+    
+    ## 📝 Instrucciones:
+    1. Ingrese una historia de usuario en el campo de texto
+    2. Haga clic en "Analizar"
+    3. Revise los resultados y las sugerencias de mejora
+    """)
+    
+    with gr.Tab("Análisis Individual"):
+        input_text = gr.Textbox(
+            label="Historia de Usuario",
+            placeholder="Como usuario quiero...",
+            lines=3
+        )
+        analyze_btn = gr.Button("Analizar")
+        output = gr.Textbox(
+            label="Resultados del Análisis",
+            lines=10
+        )
+        analyze_btn.click(
+            analyze_user_story,
+            inputs=[input_text],
+            outputs=[output]
+        )
+    
+    with gr.Tab("Análisis Múltiple"):
+        input_stories = gr.Textbox(
+            label="Historias de Usuario (una por línea)",
+            placeholder="Como usuario quiero...\nComo administrador necesito...",
+            lines=5
+        )
+        analyze_multi_btn = gr.Button("Analizar Todas")
+        output_json = gr.JSON(label="Resultados del Análisis")
+        analyze_multi_btn.click(
+            analyze_multiple_stories,
+            inputs=[input_stories],
+            outputs=[output_json]
+        )
+    
+    gr.Markdown("""
+    ## 🚀 Ejemplos de Uso
+    
+    Pruebe con estas historias de usuario:
+    - Como usuario quiero un sistema rápido y eficiente para gestionar mis tareas
+    - El sistema debe permitir exportar varios tipos de archivos
+    - Como administrador necesito acceder fácilmente a los reportes
+    """)
+
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    # Check for SPACE_HOST and SPACE_ID at startup for information
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
+
+    if space_id_startup: # Print repo URLs if SPACE_ID is found
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    else:
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+
+    print("-"*(60 + len(" App Starting ")) + "\n")
+
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)

patterns.py

@@ -0,0 +1,206 @@
+"""
+Patrones comunes de ambigüedad en historias de usuario.
+"""
+
+AMBIGUITY_PATTERNS = {
+    "lexicos": {
+        # Palabras con múltiples significados comunes
+        "fácil", "simple", "rápido", "eficiente",
+        "mejor", "adecuado", "apropiado",
+        "flexible", "dinámico", "intuitivo",
+        "amigable", "óptimo", "robusto",
+        
+        # Cuantificadores ambiguos
+        "algunos", "varios", "muchos", "pocos",
+        "más", "menos", "suficiente",
+        "bastante", "demasiado", "aproximadamente",
+        
+        # Temporales ambiguos
+        "pronto", "rápidamente", "periódicamente",
+        "regularmente", "ocasionalmente", "frecuentemente",
+        "en tiempo real", "instantáneamente", "ágilmente",
+        
+        # Calificadores ambiguos
+        "moderno", "innovador", "avanzado",
+        "inteligente", "sofisticado", "elegante",
+        
+        # Términos de usabilidad ambiguos
+        "user-friendly", "intuitivo", "natural",
+        "seamless", "fluido", "sin problemas"
+    },
+    
+    "sintacticos": {
+        # Patrones de estructura ambigua
+        r"(.*?) y (.*?) con (.*?)",  # Ambigüedad de alcance de "con"
+        r"no (.*?) y (.*?)",  # Ambigüedad de alcance de negación
+        r"(.*?) o (.*?) y (.*?)",  # Ambigüedad de operadores lógicos
+        r"(.*?) pero (.*?) si (.*?)",  # Condiciones ambiguas
+        r"(.*?) cuando (.*?) o (.*?)",  # Temporalidad ambigua
+        r"(.*?) excepto (.*?) y (.*?)",  # Exclusiones ambiguas
+        r"(.*?) antes de (.*?) y (.*?)",  # Secuencia temporal ambigua
+        r"(.*?) después de (.*?) o (.*?)",  # Secuencia condicional ambigua
+    },
+    
+    "semanticos": {
+        # Frases que suelen indicar ambigüedad
+        "si es posible",
+        "cuando sea necesario",
+        "si se requiere",
+        "según corresponda",
+        "como sea apropiado",
+        "en caso de ser necesario",
+        "dependiendo del caso",
+        "si aplica",
+        "cuando corresponda",
+        "si es factible",
+        "en la medida de lo posible",
+        "siempre que sea posible"
+    },
+    
+    "contextuales": {
+        # Dependencias implícitas
+        r"(?i)similar a (.*?)",  # Referencias vagas
+        r"(?i)como en (.*?)",   # Comparaciones ambiguas
+        r"(?i)igual que (.*?)", # Referencias no específicas
+        
+        # Suposiciones de conocimiento
+        r"(?i)de la manera usual",
+        r"(?i)como siempre",
+        r"(?i)de forma estándar",
+        
+        # Referencias ambiguas
+        r"(?i)esto",
+        r"(?i)eso",
+        r"(?i)aquello",
+        r"(?i)lo mismo"
+    }
+}
+
+# Términos técnicos que no son ambiguos en el contexto
+TECHNICAL_TERMS = {
+    # Autenticación y Seguridad
+    "OAuth", "autenticación", "autorización",
+    "token", "JWT", "SSO", "2FA", "MFA",
+    
+    # Datos y Almacenamiento
+    "base de datos", "SQL", "NoSQL", "cache",
+    "índice", "backup", "restauración",
+    
+    # Frontend
+    "responsive", "CSS", "HTML", "JavaScript",
+    "React", "Angular", "Vue", "DOM",
+    
+    # Backend
+    "API", "REST", "GraphQL", "webhook",
+    "microservicio", "contenedor", "Docker",
+    
+    # Operaciones
+    "logging", "monitoreo", "alertas",
+    "deployment", "CI/CD", "pipeline",
+    
+    # Términos de negocio
+    "ROI", "KPI", "SLA", "métrica",
+    "dashboard", "reporte", "análisis"
+}
+
+# Patrones de estructura de historia de usuario
+USER_STORY_PATTERNS = {
+    'estandar': r"(?i)^como\s+(.+?),?\s+quiero\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$",
+    'modal': r"(?i)^(?:un|una|el|la)\s+(.+?)\s+(?:puede|debe|debería)\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$",
+    'pasiva': r"(?i)^(?:el|la|los|las)\s+(.+?)\s+(?:debe|deben|debería|deberían)\s+(?:ser|estar)\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$",
+    'declarativa': r"(?i)^(?:los|las)\s+(.+?)\s+(?:deben|deberían)\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$",
+    'necesidad': r"(?i)^(?:necesito|necesitamos|se\s+necesita)\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$",
+    'deseo': r"(?i)^(?:deseo|deseamos|se\s+desea)\s+(.+?)(?:\s+para\s+(?:que\s+)?(.+))?$"
+}
+
+# Patrones para detectar ambigüedades léxicas
+PATRONES_AMBIGUEDAD_LEXICA = [
+    {
+        "patron": r"\b(rápido|eficiente|fácil|simple|intuitivo|amigable|flexible|robusto)\b(?![^{]*\})",
+        "tipo": "adjetivo_subjetivo",
+        "descripcion": "Uso de adjetivos subjetivos que pueden interpretarse de diferentes maneras"
+    },
+    {
+        "patron": r"\b(varios|algunos|muchos|pocos|diversos|múltiples)\b(?!\s+(?:formatos?|tipos?|archivos?|reportes?)\s+(?:como|:|\(|\{))",
+        "tipo": "cuantificador_ambiguo",
+        "descripcion": "Uso de cuantificadores ambiguos que no especifican una cantidad concreta"
+    },
+    {
+        "patron": r"\b(etc|etcétera|entre otros|y más|y otros)\b",
+        "tipo": "enumeracion_incompleta",
+        "descripcion": "Uso de expresiones que dejan la enumeración incompleta o abierta"
+    },
+    {
+        "patron": r"\b(sistema|aplicación|plataforma|herramienta|solución)\b(?!\s+(?:debe|debería|tiene que|ha de))",
+        "tipo": "termino_generico",
+        "descripcion": "Uso de términos genéricos que no especifican la funcionalidad concreta"
+    }
+]
+
+# Patrones para detectar ambigüedades sintácticas
+PATRONES_AMBIGUEDAD_SINTACTICA = [
+    {
+        "patron": r"(?i)(?<![\w{])(y|o|y/o)(?!\s+(?:\d+|\{|\w+\s*[=:<>]))",
+        "tipo": "coordinacion_ambigua",
+        "descripcion": "Uso de coordinaciones que pueden crear ambigüedad en la interpretación"
+    },
+    {
+        "patron": r"(?i)\b(esto|eso|aquello|el cual|la cual|lo cual|que)\b(?!\s+(?:significa|implica|requiere|incluye))",
+        "tipo": "referencia_ambigua",
+        "descripcion": "Uso de referencias ambiguas que pueden tener múltiples antecedentes"
+    },
+    {
+        "patron": r"(?i)\b(si|cuando|mientras|después|antes|luego)\b(?!\s+(?:el|la|los|las|se)\s+(?:\w+\s+){0,3}(?:\d+|específico|definido))",
+        "tipo": "condicion_temporal_ambigua",
+        "descripcion": "Uso de condiciones o referencias temporales ambiguas"
+    },
+    {
+        "patron": r"(?i)(poder|deber|necesitar|querer)\s+\w+\s+(y|o)\s+\w+(?!\s+(?:en|durante|cada|por)\s+(?:\d+|un|una)\s+(?:segundo|minuto|hora)s?)",
+        "tipo": "alcance_verbo_modal",
+        "descripcion": "Ambigüedad en el alcance de verbos modales con múltiples acciones"
+    }
+]
+
+# Sugerencias de mejora para cada tipo de ambigüedad
+SUGERENCIAS_MEJORA = {
+    "adjetivo_subjetivo": [
+        "Especificar métricas o criterios medibles (ej: tiempo de respuesta en segundos)",
+        "Definir valores concretos o rangos aceptables",
+        "Usar términos más específicos y cuantificables"
+    ],
+    "cuantificador_ambiguo": [
+        "Especificar cantidades exactas o rangos definidos",
+        "Listar explícitamente los elementos o tipos",
+        "Definir límites mínimos y máximos"
+    ],
+    "enumeracion_incompleta": [
+        "Listar todos los elementos requeridos",
+        "Especificar criterios de inclusión/exclusión",
+        "Definir el alcance completo de la funcionalidad"
+    ],
+    "termino_generico": [
+        "Especificar la funcionalidad concreta",
+        "Describir las características técnicas específicas",
+        "Detallar los componentes o módulos involucrados"
+    ],
+    "coordinacion_ambigua": [
+        "Separar en historias de usuario independientes",
+        "Usar listas numeradas o viñetas para clarificar",
+        "Especificar la relación entre los elementos"
+    ],
+    "referencia_ambigua": [
+        "Repetir el sustantivo al que se hace referencia",
+        "Usar referencias específicas y directas",
+        "Evitar pronombres ambiguos"
+    ],
+    "condicion_temporal_ambigua": [
+        "Especificar intervalos de tiempo exactos",
+        "Definir el orden preciso de las acciones",
+        "Usar referencias temporales específicas (ej: cada 5 minutos)"
+    ],
+    "alcance_verbo_modal": [
+        "Separar las acciones en requisitos independientes",
+        "Especificar las condiciones para cada acción",
+        "Definir la prioridad o secuencia de las acciones"
+    ]
+} 

requirements.txt

@@ -0,0 +1,14 @@
+gradio>=5.25.2
+requests
+spacy>=3.7.0
+es-core-news-sm @ https://github.com/explosion/spacy-models/releases/download/es_core_news_sm-3.7.0/es_core_news_sm-3.7.0-py3-none-any.whl
+pytest>=8.0.0
+typing-extensions>=4.9.0
+nltk>=3.8.1
+gradio>=4.19.2
+requests>=2.31.0
+pandas>=2.2.0
+transformers>=4.30.0
+torch>=2.0.0
+numpy>=1.24.0
+setuptools>=69.1.0