Triaje de Bugs Asistido por IA: Priorización Inteligente de Defectos a Escala

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from (como se discute en [AI Code Smell Detection: Finding Problems in Test Automation with ML](/blog/ai-code-smell-detection)) sklearn.metrics import classification_report
import numpy as np

class PredictorSeveridadBug:
    def __init__(self):
        self.vectorizer = TfidfVectorizer(
            max_features=5000,
            ngram_range=(1, 3),
            stop_words='spanish'
        )
        self.classifier = RandomForestClassifier(
            n_estimators=200,
            max_depth=20,
            min_samples_split=5,
            class_weight='balanced',
            random_state=42
        )

    def preparar_caracteristicas(self, df):
        """Combinar campos de texto y extraer características"""
        # Combinar título y descripción
        df['texto_combinado'] = df['titulo'] + ' ' + df['descripcion']

        # Extraer características adicionales
        df['longitud_titulo'] = df['titulo'].str.len()
        df['longitud_desc'] = df['descripcion'].str.len()
        df['tiene_stacktrace'] = df['descripcion'].str.contains(
 (como se discute en [AI-powered Test Generation: The Future Is Already Here](/blog/ai-powered-test-generation))            'at |Traceback|Exception', regex=True
        ).astype(int)
        df['conteo_palabras_error'] = df['descripcion'].str.lower().str.count(
            'crash|error|fallo|excepción|crítico'
        )

        return df

    def entrenar(self, bugs_df):
        """Entrenar el modelo de predicción de severidad"""
        # Preparar características
        bugs_df = self.preparar_caracteristicas(bugs_df)

        # Vectorización de texto
        caracteristicas_texto = self.vectorizer.fit_transform(
            bugs_df['texto_combinado']
        )

        # Características numéricas
        caracteristicas_numericas = bugs_df[[
            'longitud_titulo', 'longitud_desc',
            'tiene_stacktrace', 'conteo_palabras_error'
        ]].values

        # Combinar características
        X = np.hstack([caracteristicas_texto.toarray(), caracteristicas_numericas])
        y = bugs_df['severidad']

        # Entrenar modelo
        X_train (como se discute en [AI Test Metrics Analytics: Intelligent Analysis of QA Metrics](/blog/ai-test-metrics)), X_test, y_train, y_test = train_test_split(
            X, y, test_size=0.2, random_state=42, stratify=y
        )

        self.classifier.fit(X_train, y_train)

        # Evaluar
        y_pred = self.classifier.predict(X_test)
        print(classification_report(y_test, y_pred))

        return self

    def predecir(self, titulo, descripcion):
        """Predecir severidad para un nuevo bug"""
        df = pd.DataFrame({
            'titulo': [titulo],
            'descripcion': [descripcion]
        })
        df = self.preparar_caracteristicas(df)

        caracteristicas_texto = self.vectorizer.transform(df['texto_combinado'])
        caracteristicas_numericas = df[[
            'longitud_titulo', 'longitud_desc',
            'tiene_stacktrace', 'conteo_palabras_error'
        ]].values

        X = np.hstack([caracteristicas_texto.toarray(), caracteristicas_numericas])

        severidad = self.classifier.predict(X)[0]
        confianza = self.classifier.predict_proba(X).max()

        return {
            'severidad': severidad,
            'confianza': confianza
        }

# Ejemplo de uso
predictor = PredictorSeveridadBug()

# Cargar datos históricos de bugs
bugs = pd.read_csv('reportes_bugs.csv')
predictor.entrenar(bugs)

# Predecir severidad para un nuevo bug
resultado = predictor.predecir(
    titulo="La aplicación se bloquea al iniciar sesión",
    descripcion="Los usuarios no pueden iniciar sesión. El sistema arroja NullPointerException en AuthService.java:245"
)
print(f"Severidad predicha: {resultado['severidad']} (confianza: {resultado['confianza']:.2%})")

from transformers import BertTokenizer, BertForSequenceClassification
import torch
from torch.utils.data import Dataset, DataLoader

class DatasetBug(Dataset):
    def __init__(self, textos, etiquetas, tokenizer, max_length=512):
        self.textos = textos
        self.etiquetas = etiquetas
        self.tokenizer = tokenizer
        self.max_length = max_length

    def __len__(self):
        return len(self.textos)

    def __getitem__(self, idx):
        texto = self.textos[idx]
        etiqueta = self.etiquetas[idx]

        encoding = self.tokenizer(
            texto,
            max_length=self.max_length,
            padding='max_length',
            truncation=True,
            return_tensors='pt'
        )

        return {
            'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'labels': torch.tensor(etiqueta, dtype=torch.long)
        }

class ClasificadorBugBERT:
    def __init__(self, num_etiquetas=4):
        self.tokenizer = BertTokenizer.from_pretrained('bert-base-multilingual-cased')
        self.model = BertForSequenceClassification.from_pretrained(
            'bert-base-multilingual-cased',
            num_labels=num_etiquetas
        )
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.model.to(self.device)

    def entrenar(self, textos_train, etiquetas_train, epochs=3, batch_size=16):
        dataset = DatasetBug(textos_train, etiquetas_train, self.tokenizer)
        dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

        optimizer = torch.optim.AdamW(self.model.parameters(), lr=2e-5)

        self.model.train()
        for epoch in range(epochs):
            perdida_total = 0
            for batch in dataloader:
                optimizer.zero_grad()

                input_ids = batch['input_ids'].to(self.device)
                attention_mask = batch['attention_mask'].to(self.device)
                labels = batch['labels'].to(self.device)

                outputs = self.model(
                    input_ids=input_ids,
                    attention_mask=attention_mask,
                    labels=labels
                )

                loss = outputs.loss
                perdida_total += loss.item()

                loss.backward()
                optimizer.step()

            print(f"Época {epoch+1}, Pérdida: {perdida_total/len(dataloader):.4f}")

    def predecir(self, texto):
        self.model.eval()
        encoding = self.tokenizer(
            texto,
            max_length=512,
            padding='max_length',
            truncation=True,
            return_tensors='pt'
        )

        with torch.no_grad():
            input_ids = encoding['input_ids'].to(self.device)
            attention_mask = encoding['attention_mask'].to(self.device)

            outputs = self.model(input_ids=input_ids, attention_mask=attention_mask)
            probabilidades = torch.nn.functional.softmax(outputs.logits, dim=1)

        mapa_severidad = {0: 'baja', 1: 'media', 2: 'alta', 3: 'crítica'}
        clase_predicha = torch.argmax(probabilidades).item()

        return {
            'severidad': mapa_severidad[clase_predicha],
            'confianza': probabilidades[0][clase_predicha].item()
        }

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
import faiss

class DetectorBugsDuplicados:
    def __init__(self):
        self.model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
        self.bug_embeddings = None
        self.bug_ids = None
        self.index = None

    def construir_indice(self, bugs_df):
        """Construir índice FAISS para búsqueda rápida de similitud"""
        # Crear textos de bugs
        textos = (bugs_df['titulo'] + ' ' + bugs_df['descripcion']).tolist()
        self.bug_ids = bugs_df['bug_id'].tolist()

        # Generar embeddings
        self.bug_embeddings = self.model.encode(textos, show_progress_bar=True)

        # Construir índice FAISS
        dimension = self.bug_embeddings.shape[1]
        self.index = faiss.IndexFlatIP(dimension)  # Producto interno para similitud coseno

        # Normalizar embeddings para similitud coseno
        faiss.normalize_L2(self.bug_embeddings)
        self.index.add(self.bug_embeddings)

        return self

    def encontrar_duplicados(self, titulo_nuevo, descripcion_nueva, umbral=0.85, top_k=5):
        """Encontrar bugs duplicados potenciales"""
        # Crear embedding para nuevo bug
        texto_nuevo = f"{titulo_nuevo} {descripcion_nueva}"
        embedding_nuevo = self.model.encode([texto_nuevo])
        faiss.normalize_L2(embedding_nuevo)

        # Buscar bugs similares
        similitudes, indices = self.index.search(embedding_nuevo, top_k)

        # Filtrar por umbral
        duplicados = []
        for similitud, idx in zip(similitudes[0], indices[0]):
            if similitud >= umbral:
                duplicados.append({
                    'bug_id': self.bug_ids[idx],
                    'puntuacion_similitud': float(similitud)
                })

        return duplicados

    def obtener_matriz_similitud(self, lista_bug_ids):
        """Calcular similitud por pares para un conjunto de bugs"""
        indices = [self.bug_ids.index(bid) for bid in lista_bug_ids]
        subset_embeddings = self.bug_embeddings[indices]

        matriz_similitud = cosine_similarity(subset_embeddings)
        return matriz_similitud

# Ejemplo de uso
detector = DetectorBugsDuplicados()

# Construir índice desde bugs existentes
bugs_df = pd.read_csv('bugs.csv')
detector.construir_indice(bugs_df)

# Verificar duplicados
duplicados = detector.encontrar_duplicados(
    titulo_nuevo="El botón de inicio de sesión no funciona",
    descripcion_nueva="Al hacer clic en el botón de inicio de sesión, no pasa nada. La consola no muestra errores.",
    umbral=0.85
)

print("Duplicados potenciales encontrados:")
for dup in duplicados:
    print(f"Bug ID: {dup['bug_id']}, Similitud: {dup['puntuacion_similitud']:.2%}")

class DetectorDuplicadosHibrido:
    def __init__(self, peso_texto=0.7, peso_metadatos=0.3):
        self.detector_texto = DetectorBugsDuplicados()
        self.peso_texto = peso_texto
        self.peso_metadatos = peso_metadatos

    def calcular_similitud_metadatos(self, bug1, bug2):
        """Calcular similitud basada en metadatos"""
        puntuacion = 0.0

        # Coincidencia de componente
        if bug1['componente'] == bug2['componente']:
            puntuacion += 0.3

        # Mismo reportador
        if bug1['reportador'] == bug2['reportador']:
            puntuacion += 0.2

        # Tiempo de creación similar (dentro de 7 días)
        diferencia_tiempo = abs((bug1['fecha_creacion'] - bug2['fecha_creacion']).days)
        if diferencia_tiempo <= 7:
            puntuacion += 0.2 * (1 - diferencia_tiempo / 7)

        # Mismo SO/navegador
        if bug1.get('so') == bug2.get('so'):
            puntuacion += 0.15
        if bug1.get('navegador') == bug2.get('navegador'):
            puntuacion += 0.15

        return puntuacion

    def encontrar_duplicados_hibrido(self, bug_nuevo, bugs_df, umbral=0.80):
        """Encontrar duplicados usando enfoque híbrido"""
        # Obtener duplicados basados en texto
        duplicados_texto = self.detector_texto.encontrar_duplicados(
            bug_nuevo['titulo'],
            bug_nuevo['descripcion'],
            umbral=0.70,  # Umbral más bajo para filtrado inicial
            top_k=20
        )

        # Calcular puntuaciones híbridas
        resultados = []
        for dup in duplicados_texto:
            datos_bug = bugs_df[bugs_df['bug_id'] == dup['bug_id']].iloc[0]

            puntuacion_texto = dup['puntuacion_similitud']
            puntuacion_metadatos = self.calcular_similitud_metadatos(bug_nuevo, datos_bug)

            puntuacion_hibrida = (
                self.peso_texto * puntuacion_texto +
                self.peso_metadatos * puntuacion_metadatos
            )

            if puntuacion_hibrida >= umbral:
                resultados.append({
                    'bug_id': dup['bug_id'],
                    'puntuacion_hibrida': puntuacion_hibrida,
                    'puntuacion_texto': puntuacion_texto,
                    'puntuacion_metadatos': puntuacion_metadatos
                })

        # Ordenar por puntuación híbrida
        resultados.sort(key=lambda x: x['puntuacion_hibrida'], reverse=True)
        return resultados

from sklearn.feature_extraction.text import TfidfVectorizer
from collections import defaultdict
import numpy as np

class RecomendadorAsignacionBugs:
    def __init__(self):
        self.perfiles_desarrolladores = {}
        self.vectorizer = TfidfVectorizer(max_features=1000)
        self.expertos_componente = defaultdict(list)

    def construir_perfiles_desarrolladores(self, bugs_historicos):
        """Construir perfiles de experiencia para desarrolladores"""
        bugs_desarrollador = defaultdict(list)

        # Agrupar bugs por asignado
        for _, bug in bugs_historicos.iterrows():
            if bug['asignado'] and bug['estado'] == 'resuelto':
                bugs_desarrollador[bug['asignado']].append(
                    f"{bug['titulo']} {bug['descripcion']}"
                )

                # Rastrear experiencia por componente
                if bug['componente']:
                    self.expertos_componente[bug['componente']].append({
                        'desarrollador': bug['asignado'],
                        'tiempo_resolucion': bug['tiempo_resolucion_horas']
                    })

        # Crear perfiles TF-IDF
        todos_desarrolladores = list(bugs_desarrollador.keys())
        todos_textos = [' '.join(bugs_desarrollador[dev]) for dev in todos_desarrolladores]

        if todos_textos:
            matriz_tfidf = self.vectorizer.fit_transform(todos_textos)

            for idx, desarrollador in enumerate(todos_desarrolladores):
                self.perfiles_desarrolladores[desarrollador] = {
                    'vector_experiencia': matriz_tfidf[idx],
                    'bugs_resueltos': len(bugs_desarrollador[desarrollador]),
                    'tiempo_promedio_resolucion': self._calcular_tiempo_promedio(
                        bugs_historicos, desarrollador
                    )
                }

        # Calcular puntuaciones de experiencia por componente
        for componente, asignaciones in self.expertos_componente.items():
            stats_dev = defaultdict(lambda: {'conteo': 0, 'tiempo_total': 0})

            for asignacion in asignaciones:
                dev = asignacion['desarrollador']
                stats_dev[dev]['conteo'] += 1
                stats_dev[dev]['tiempo_total'] += asignacion['tiempo_resolucion']

            # Calcular promedio y almacenar
            self.expertos_componente[componente] = [
                {
                    'desarrollador': dev,
                    'conteo_bugs': stats['conteo'],
                    'tiempo_promedio': stats['tiempo_total'] / stats['conteo']
                }
                for dev, stats in stats_dev.items()
            ]

    def _calcular_tiempo_promedio(self, df, desarrollador):
        """Calcular tiempo promedio de resolución para desarrollador"""
        bugs_dev = df[df['asignado'] == desarrollador]
        return bugs_dev['tiempo_resolucion_horas'].mean()

    def recomendar_asignado(self, titulo_bug, descripcion_bug, componente=None, top_k=3):
        """Recomendar mejores asignados para un nuevo bug"""
        # Crear vector del bug
        texto_bug = f"{titulo_bug} {descripcion_bug}"
        vector_bug = self.vectorizer.transform([texto_bug])

        puntuaciones = []

        for desarrollador, perfil in self.perfiles_desarrolladores.items():
            # Puntuación de similitud de texto
            similitud = cosine_similarity(
                vector_bug,
                perfil['vector_experiencia']
            )[0][0]

            # Bonificación por experiencia en componente
            bonificacion_componente = 0
            if componente and componente in self.expertos_componente:
                expertos = self.expertos_componente[componente]
                for experto in expertos:
                    if experto['desarrollador'] == desarrollador:
                        # Bonificación basada en experiencia y velocidad
                        bonificacion_componente = 0.2 * min(experto['conteo_bugs'] / 10, 1.0)
                        if experto['tiempo_promedio'] < 24:  # Resolutor rápido
                            bonificacion_componente += 0.1

            # Penalización por carga de trabajo (simplificado - se integraría con datos en tiempo real)
            penalizacion_carga = 0  # Consultaría bugs abiertos actuales

            # Puntuación combinada
            puntuacion_final = similitud + bonificacion_componente - penalizacion_carga

            puntuaciones.append({
                'desarrollador': desarrollador,
                'puntuacion': puntuacion_final,
                'similitud': similitud,
                'bonificacion_componente': bonificacion_componente,
                'tiempo_promedio_resolucion': perfil['tiempo_promedio_resolucion']
            })

        # Ordenar y devolver top K
        puntuaciones.sort(key=lambda x: x['puntuacion'], reverse=True)
        return puntuaciones[:top_k]

# Ejemplo de uso
recomendador = RecomendadorAsignacionBugs()
recomendador.construir_perfiles_desarrolladores(bugs_historicos_df)

recomendaciones = recomendador.recomendar_asignado(
    titulo_bug="Fuga de memoria en módulo de procesamiento de datos",
    descripcion_bug="La aplicación consume memoria creciente al procesar grandes conjuntos de datos",
    componente="procesamiento-datos"
)

print("Asignados recomendados:")
for idx, rec in enumerate(recomendaciones, 1):
    print(f"{idx}. {rec['desarrollador']}")
    print(f"   Puntuación: {rec['puntuacion']:.3f}")
    print(f"   Tiempo promedio de resolución: {rec['tiempo_promedio_resolucion']:.1f} horas")

from sklearn.ensemble import GradientBoostingRegressor
import pandas as pd

class OptimizadorSLA:
    def __init__(self):
        self.predictor_tiempo = GradientBoostingRegressor(
            n_estimators=100,
            learning_rate=0.1,
            max_depth=5
        )
        self.severidad_sla = {
            'crítica': 4,   # 4 horas
            'alta': 24,     # 24 horas
            'media': 72,    # 3 días
            'baja': 168     # 1 semana
        }

    def preparar_caracteristicas(self, bugs_df):
        """Extraer características para predicción de tiempo"""
        caracteristicas = pd.DataFrame()

        # Codificación de severidad
        mapa_severidad = {'baja': 1, 'media': 2, 'alta': 3, 'crítica': 4}
        caracteristicas['codigo_severidad'] = bugs_df['severidad'].map(mapa_severidad)

        # Complejidad del texto
        caracteristicas['longitud_titulo'] = bugs_df['titulo'].str.len()
        caracteristicas['longitud_desc'] = bugs_df['descripcion'].str.len()
        caracteristicas['tiene_stacktrace'] = bugs_df['descripcion'].str.contains(
            'at |Traceback', regex=True
        ).astype(int)

        # Complejidad del componente (basado en datos históricos)
        tiempo_promedio_componente = bugs_df.groupby('componente')['tiempo_resolucion_horas'].mean()
        caracteristicas['complejidad_componente'] = bugs_df['componente'].map(tiempo_promedio_componente)

        # Historial del reportador
        conteo_bugs_reportador = bugs_df.groupby('reportador').size()
        caracteristicas['experiencia_reportador'] = bugs_df['reportador'].map(conteo_bugs_reportador)

        # Características temporales
        bugs_df['fecha_creacion'] = pd.to_datetime(bugs_df['fecha_creacion'])
        caracteristicas['hora_del_dia'] = bugs_df['fecha_creacion'].dt.hour
        caracteristicas['dia_semana'] = bugs_df['fecha_creacion'].dt.dayofweek
        caracteristicas['es_fin_semana'] = (caracteristicas['dia_semana'] >= 5).astype(int)

        return caracteristicas

    def entrenar(self, bugs_df):
        """Entrenar predictor de tiempo de resolución"""
        X = self.preparar_caracteristicas(bugs_df)
        y = bugs_df['tiempo_resolucion_horas']

        self.predictor_tiempo.fit(X, y)
        return self

    def predecir_tiempo_resolucion(self, datos_bug):
        """Predecir tiempo de resolución para un bug"""
        caracteristicas = self.preparar_caracteristicas(pd.DataFrame([datos_bug]))
        horas_predichas = self.predictor_tiempo.predict(caracteristicas)[0]
        return horas_predichas

    def calcular_riesgo_sla(self, datos_bug):
        """Calcular riesgo de incumplimiento de SLA"""
        tiempo_predicho = self.predecir_tiempo_resolucion(datos_bug)
        limite_sla = self.severidad_sla.get(datos_bug['severidad'], 168)

        puntuacion_riesgo = tiempo_predicho / limite_sla

        if puntuacion_riesgo >= 1.0:
            nivel_riesgo = 'ALTO'
        elif puntuacion_riesgo >= 0.7:
            nivel_riesgo = 'MEDIO'
        else:
            nivel_riesgo = 'BAJO'

        return {
            'horas_predichas': tiempo_predicho,
            'horas_sla': limite_sla,
            'puntuacion_riesgo': puntuacion_riesgo,
            'nivel_riesgo': nivel_riesgo,
            'accion_recomendada': self._obtener_recomendacion(nivel_riesgo)
        }

    def _obtener_recomendacion(self, nivel_riesgo):
        """Obtener acciones recomendadas basadas en el riesgo"""
        if nivel_riesgo == 'ALTO':
            return "URGENTE: Asignar a desarrollador senior inmediatamente"
        elif nivel_riesgo == 'MEDIO':
            return "Monitorear de cerca, considerar escalamiento"
        else:
            return "Flujo de trabajo estándar"

    def optimizar_cola(self, bugs_abiertos_df):
        """Priorizar cola de bugs para optimizar cumplimiento de SLA"""
        prioridades = []

        for _, bug in bugs_abiertos_df.iterrows():
            analisis_sla = self.calcular_riesgo_sla(bug.to_dict())

            # Calcular puntuación de urgencia
            tiempo_restante = analisis_sla['horas_sla'] - bug['horas_abierto']
            urgencia = analisis_sla['puntuacion_riesgo'] * (1 / max(tiempo_restante, 1))

            prioridades.append({
                'bug_id': bug['bug_id'],
                'puntuacion_urgencia': urgencia,
                'riesgo_sla': analisis_sla['nivel_riesgo'],
                'tiempo_restante': tiempo_restante,
                'resolucion_predicha': analisis_sla['horas_predichas']
            })

        # Ordenar por urgencia
        prioridades.sort(key=lambda x: x['puntuacion_urgencia'], reverse=True)
        return prioridades

# Ejemplo de uso
optimizador = OptimizadorSLA()
optimizador.entrenar(bugs_historicos_df)

# Analizar un nuevo bug
bug = {
    'severidad': 'alta',
    'titulo': 'Falla en procesamiento de pagos',
    'descripcion': 'Bug crítico que afecta el checkout. Stacktrace incluido...',
    'componente': 'pasarela-pagos',
    'reportador': 'usuario@ejemplo.com',
    'fecha_creacion': '2025-10-04 14:30:00'
}

analisis_riesgo = optimizador.calcular_riesgo_sla(bug)
print(f"Riesgo SLA: {analisis_riesgo['nivel_riesgo']}")
print(f"Resolución predicha: {analisis_riesgo['horas_predichas']:.1f} horas")
print(f"Recomendación: {analisis_riesgo['accion_recomendada']}")

from jira import JIRA
import requests

class IntegracionTriajeJIRA:
    def __init__(self, servidor, email, api_token):
        self.jira = JIRA(server=servidor, basic_auth=(email, api_token))
        self.predictor = PredictorSeveridadBug()
        self.detector_duplicados = DetectorBugsDuplicados()
        self.recomendador = RecomendadorAsignacionBugs()
        self.optimizador_sla = OptimizadorSLA()

    def procesar_nueva_incidencia(self, clave_incidencia):
        """Triar automáticamente una nueva incidencia de JIRA"""
        # Obtener incidencia
        incidencia = self.jira.issue(clave_incidencia)

        titulo = incidencia.fields.summary
        descripcion = incidencia.fields.description or ""

        # 1. Predecir severidad
        resultado_severidad = self.predictor.predecir(titulo, descripcion)

        # 2. Verificar duplicados
        duplicados = self.detector_duplicados.encontrar_duplicados(
            titulo, descripcion, umbral=0.85
        )

        # 3. Recomendar asignado
        componente = incidencia.fields.components[0].name if incidencia.fields.components else None
        recomendaciones_asignado = self.recomendador.recomendar_asignado(
            titulo, descripcion, componente
        )

        # 4. Calcular riesgo SLA
        datos_bug = {
            'severidad': resultado_severidad['severidad'],
            'titulo': titulo,
            'descripcion': descripcion,
            'componente': componente,
            'reportador': incidencia.fields.reporter.emailAddress,
            'fecha_creacion': incidencia.fields.created
        }
        riesgo_sla = self.optimizador_sla.calcular_riesgo_sla(datos_bug)

        # 5. Actualizar incidencia de JIRA
        actualizaciones = {}

        # Establecer prioridad basada en severidad predicha
        mapa_prioridad = {
            'crítica': 'Highest',
            'alta': 'High',
            'media': 'Medium',
            'baja': 'Low'
        }
        actualizaciones['priority'] = {'name': mapa_prioridad[resultado_severidad['severidad']]}

        # Agregar comentario de análisis de IA
        comentario = f"""Análisis de Triaje de IA:

**Severidad Predicha:** {resultado_severidad['severidad']} (confianza: {resultado_severidad['confianza']:.1%})

**Detección de Duplicados:**
{self._formatear_duplicados(duplicados)}

**Asignados Recomendados:**
{self._formatear_recomendaciones(recomendaciones_asignado)}

**Análisis de SLA:**
- Nivel de Riesgo: {riesgo_sla['nivel_riesgo']}
- Resolución Predicha: {riesgo_sla['horas_predichas']:.1f} horas
- Límite SLA: {riesgo_sla['horas_sla']} horas
- Recomendación: {riesgo_sla['accion_recomendada']}
"""

        # Actualizar incidencia
        incidencia.update(fields=actualizaciones)
        self.jira.add_comment(incidencia, comentario)

        # Auto-asignar si hay alta confianza
        if recomendaciones_asignado and recomendaciones_asignado[0]['puntuacion'] > 0.8:
            mejor_asignado = recomendaciones_asignado[0]['desarrollador']
            incidencia.update(assignee={'name': mejor_asignado})

        # Agregar etiquetas
        etiquetas = incidencia.fields.labels or []
        etiquetas.append(f"ia-severidad-{resultado_severidad['severidad']}")
        if duplicados:
            etiquetas.append('posible-duplicado')
        if riesgo_sla['nivel_riesgo'] == 'ALTO':
            etiquetas.append('riesgo-sla')
        incidencia.update(fields={'labels': etiquetas})

        return {
            'severidad': resultado_severidad,
            'duplicados': duplicados,
            'recomendaciones_asignado': recomendaciones_asignado,
            'riesgo_sla': riesgo_sla
        }

    def _formatear_duplicados(self, duplicados):
        if not duplicados:
            return "No se encontraron duplicados"

        texto = ""
        for dup in duplicados[:3]:
            texto += f"- {dup['bug_id']} (similitud: {dup['puntuacion_similitud']:.1%})\n"
        return texto

    def _formatear_recomendaciones(self, recomendaciones):
        texto = ""
        for idx, rec in enumerate(recomendaciones, 1):
            texto += f"{idx}. {rec['desarrollador']} (puntuación: {rec['puntuacion']:.2f}, "
            texto += f"tiempo promedio: {rec['tiempo_promedio_resolucion']:.1f}h)\n"
        return texto

    def procesar_lote_sin_triar(self, consulta_jql="status = Open AND priority is EMPTY"):
        """Procesar todas las incidencias sin triar"""
        incidencias = self.jira.search_issues(consulta_jql, maxResults=100)

        resultados = []
        for incidencia in incidencias:
            try:
                resultado = self.procesar_nueva_incidencia(incidencia.key)
                resultados.append({'incidencia': incidencia.key, 'estado': 'éxito', 'resultado': resultado})
            except Exception as e:
                resultados.append({'incidencia': incidencia.key, 'estado': 'error', 'error': str(e)})

        return resultados

# Ejemplo de uso
integracion = IntegracionTriajeJIRA(
    servidor='https://tu-dominio.atlassian.net',
    email='tu-email@ejemplo.com',
    api_token='tu-api-token'
)

# Procesar una nueva incidencia
resultado = integracion.procesar_nueva_incidencia('PROJ-1234')
print(f"Triaje completado: {resultado}")

# Procesar lote de incidencias sin triar
resultados_lote = integracion.procesar_lote_sin_triar()
print(f"Procesadas {len(resultados_lote)} incidencias")

from github import Github

class BotTriajeGitHub:
    def __init__(self, token_acceso, nombre_repo):
        self.gh = Github(token_acceso)
        self.repo = self.gh.get_repo(nombre_repo)
        self.predictor = PredictorSeveridadBug()
        self.detector_duplicados = DetectorBugsDuplicados()

    def procesar_incidencia(self, numero_incidencia):
        """Triar una incidencia de GitHub"""
        incidencia = self.repo.get_issue(numero_incidencia)

        # Predecir severidad
        resultado_severidad = self.predictor.predecir(
            incidencia.title,
            incidencia.body or ""
        )

        # Encontrar duplicados
        duplicados = self.detector_duplicados.encontrar_duplicados(
            incidencia.title,
            incidencia.body or "",
            umbral=0.85
        )

        # Aplicar etiquetas
        etiquetas = []
        etiquetas.append(f"severidad:{resultado_severidad['severidad']}")

        if resultado_severidad['severidad'] in ['crítica', 'alta']:
            etiquetas.append('prioridad:alta')

        if duplicados:
            etiquetas.append('¿duplicado?')

        incidencia.add_to_labels(*etiquetas)

        # Agregar comentario con análisis
        if duplicados:
            texto_dup = "\n".join([
                f"- #{dup['bug_id']} (similitud: {dup['puntuacion_similitud']:.1%})"
                for dup in duplicados[:3]
            ])

            comentario = f"""## Análisis del Bot de Triaje de IA

**Severidad Predicha:** {resultado_severidad['severidad']} (confianza: {resultado_severidad['confianza']:.1%})

**Posibles Duplicados:**
{texto_dup}

Por favor, revisa estos duplicados potenciales antes de proceder.
"""
            incidencia.create_comment(comentario)

        return {
            'severidad': resultado_severidad,
            'duplicados': duplicados,
            'etiquetas_aplicadas': etiquetas
        }

    def manejador_webhook(self, payload):
        """Manejar webhook de GitHub para nuevas incidencias"""
        if payload['action'] == 'opened':
            numero_incidencia = payload['issue']['number']
            return self.procesar_incidencia(numero_incidencia)

# Uso
bot = BotTriajeGitHub(
    token_acceso='ghp_xxx',
    nombre_repo='usuario/repositorio'
)

resultado = bot.procesar_incidencia(42)
print(f"Resultado del triaje: {resultado}")