inital 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) 

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

@@ -1,2 +1,14 @@
-gradio
-requests
+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