Триаж Багов с Помощью ИИ: Интеллектуальная Приоритизация Дефектов в Масштабе

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 (как обсуждается в [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 ПредсказательСерьёзностиБагов:
    def __init__(self):
        self.vectorizer = TfidfVectorizer(
            max_features=5000,
            ngram_range=(1, 3),
            stop_words='russian'
        )
        self.classifier = RandomForestClassifier(
            n_estimators=200,
            max_depth=20,
            min_samples_split=5,
            class_weight='balanced',
            random_state=42
        )

    def подготовить_признаки(self, df):
        """Объединить текстовые поля и извлечь признаки"""
        # Объединить заголовок и описание
        df['комбинированный_текст'] = df['заголовок'] + ' ' + df['описание']

        # Извлечь дополнительные признаки
        df['длина_заголовка'] = df['заголовок'].str.len()
        df['длина_описания'] = df['описание'].str.len()
        df['есть_стектрейс'] = df['описание'].str.contains(
 (как обсуждается в [AI-powered Test Generation: The Future Is Already Here](/blog/ai-powered-test-generation))            'at |Traceback|Exception', regex=True
        ).astype(int)
        df['счёт_слов_ошибка'] = df['описание'].str.lower().str.count(
            'crash|error|fail|exception|критический|ошибка'
 (как обсуждается в [AI Test Metrics Analytics: Intelligent Analysis of QA Metrics](/blog/ai-test-metrics))        )

        return df

    def обучить(self, bugs_df):
        """Обучить модель предсказания серьёзности"""
        # Подготовить признаки
        bugs_df = self.подготовить_признаки(bugs_df)

        # Векторизация текста
        текстовые_признаки = self.vectorizer.fit_transform(
            bugs_df['комбинированный_текст']
        )

        # Числовые признаки
        числовые_признаки = bugs_df[[
            'длина_заголовка', 'длина_описания',
            'есть_стектрейс', 'счёт_слов_ошибка'
        ]].values

        # Объединить признаки
        X = np.hstack([текстовые_признаки.toarray(), числовые_признаки])
        y = bugs_df['серьёзность']

        # Обучить модель
        X_train, 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)

        # Оценить
        y_pred = self.classifier.predict(X_test)
        print(classification_report(y_test, y_pred))

        return self

    def предсказать(self, заголовок, описание):
        """Предсказать серьёзность для нового бага"""
        df = pd.DataFrame({
            'заголовок': [заголовок],
            'описание': [описание]
        })
        df = self.подготовить_признаки(df)

        текстовые_признаки = self.vectorizer.transform(df['комбинированный_текст'])
        числовые_признаки = df[[
            'длина_заголовка', 'длина_описания',
            'есть_стектрейс', 'счёт_слов_ошибка'
        ]].values

        X = np.hstack([текстовые_признаки.toarray(), числовые_признаки])

        серьёзность = self.classifier.predict(X)[0]
        уверенность = self.classifier.predict_proba(X).max()

        return {
            'серьёзность': серьёзность,
            'уверенность': уверенность
        }

# Пример использования
предсказатель = ПредсказательСерьёзностиБагов()

# Загрузить исторические данные о багах
баги = pd.read_csv('отчёты_багов.csv')
предсказатель.обучить(баги)

# Предсказать серьёзность для нового бага
результат = предсказатель.предсказать(
    заголовок="Приложение падает при входе",
    описание="Пользователи не могут войти. Система выдаёт NullPointerException в AuthService.java:245"
)
print(f"Предсказанная серьёзность: {результат['серьёзность']} (уверенность: {результат['уверенность']:.2%})")

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

class ДатасетБагов(Dataset):
    def __init__(self, тексты, метки, tokenizer, max_length=512):
        self.тексты = тексты
        self.метки = метки
        self.tokenizer = tokenizer
        self.max_length = max_length

    def __len__(self):
        return len(self.тексты)

    def __getitem__(self, idx):
        текст = self.тексты[idx]
        метка = self.метки[idx]

        encoding = self.tokenizer(
            текст,
            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(метка, dtype=torch.long)
        }

class КлассификаторБаговBERT:
    def __init__(self, num_labels=4):
        self.tokenizer = BertTokenizer.from_pretrained('bert-base-multilingual-cased')
        self.model = BertForSequenceClassification.from_pretrained(
            'bert-base-multilingual-cased',
            num_labels=num_labels
        )
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.model.to(self.device)

    def обучить(self, тексты_train, метки_train, epochs=3, batch_size=16):
        dataset = ДатасетБагов(тексты_train, метки_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):
            общая_потеря = 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
                общая_потеря += loss.item()

                loss.backward()
                optimizer.step()

            print(f"Эпоха {epoch+1}, Потеря: {общая_потеря/len(dataloader):.4f}")

    def предсказать(self, текст):
        self.model.eval()
        encoding = self.tokenizer(
            текст,
            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)
            вероятности = torch.nn.functional.softmax(outputs.logits, dim=1)

        карта_серьёзности = {0: 'низкая', 1: 'средняя', 2: 'высокая', 3: 'критическая'}
        предсказанный_класс = torch.argmax(вероятности).item()

        return {
            'серьёзность': карта_серьёзности[предсказанный_класс],
            'уверенность': вероятности[0][предсказанный_класс].item()
        }

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

class ДетекторДубликатовБагов:
    def __init__(self):
        self.model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
        self.эмбеддинги_багов = None
        self.id_багов = None
        self.index = None

    def построить_индекс(self, bugs_df):
        """Построить FAISS индекс для быстрого поиска схожести"""
        # Создать тексты багов
        тексты = (bugs_df['заголовок'] + ' ' + bugs_df['описание']).tolist()
        self.id_багов = bugs_df['id_бага'].tolist()

        # Сгенерировать эмбеддинги
        self.эмбеддинги_багов = self.model.encode(тексты, show_progress_bar=True)

        # Построить FAISS индекс
        размерность = self.эмбеддинги_багов.shape[1]
        self.index = faiss.IndexFlatIP(размерность)  # Внутреннее произведение для косинусной схожести

        # Нормализовать эмбеддинги для косинусной схожести
        faiss.normalize_L2(self.эмбеддинги_багов)
        self.index.add(self.эмбеддинги_багов)

        return self

    def найти_дубликаты(self, заголовок_нового, описание_нового, порог=0.85, top_k=5):
        """Найти потенциальные дубликаты багов"""
        # Создать эмбеддинг для нового бага
        новый_текст = f"{заголовок_нового} {описание_нового}"
        новый_эмбеддинг = self.model.encode([новый_текст])
        faiss.normalize_L2(новый_эмбеддинг)

        # Искать похожие баги
        схожести, индексы = self.index.search(новый_эмбеддинг, top_k)

        # Фильтровать по порогу
        дубликаты = []
        for схожесть, idx in zip(схожести[0], индексы[0]):
            if схожесть >= порог:
                дубликаты.append({
                    'id_бага': self.id_багов[idx],
                    'оценка_схожести': float(схожесть)
                })

        return дубликаты

    def получить_матрицу_схожести(self, список_id_багов):
        """Вычислить попарную схожесть для набора багов"""
        индексы = [self.id_багов.index(bid) for bid in список_id_багов]
        подмножество_эмбеддингов = self.эмбеддинги_багов[индексы]

        матрица_схожести = cosine_similarity(подмножество_эмбеддингов)
        return матрица_схожести

# Пример использования
детектор = ДетекторДубликатовБагов()

# Построить индекс из существующих багов
bugs_df = pd.read_csv('баги.csv')
детектор.построить_индекс(bugs_df)

# Проверить на дубликаты
дубликаты = детектор.найти_дубликаты(
    заголовок_нового="Кнопка входа не работает",
    описание_нового="При нажатии на кнопку входа ничего не происходит. Консоль не показывает ошибок.",
    порог=0.85
)

print("Найдены потенциальные дубликаты:")
for dup in дубликаты:
    print(f"ID бага: {dup['id_бага']}, Схожесть: {dup['оценка_схожести']:.2%}")

class ГибридныйДетекторДубликатов:
    def __init__(self, вес_текста=0.7, вес_метаданных=0.3):
        self.детектор_текста = ДетекторДубликатовБагов()
        self.вес_текста = вес_текста
        self.вес_метаданных = вес_метаданных

    def вычислить_схожесть_метаданных(self, баг1, баг2):
        """Вычислить схожесть на основе метаданных"""
        оценка = 0.0

        # Совпадение компонента
        if баг1['компонент'] == баг2['компонент']:
            оценка += 0.3

        # Тот же репортёр
        if баг1['репортёр'] == баг2['репортёр']:
            оценка += 0.2

        # Похожее время создания (в пределах 7 дней)
        разница_времени = abs((баг1['создан'] - баг2['создан']).days)
        if разница_времени <= 7:
            оценка += 0.2 * (1 - разница_времени / 7)

        # Та же ОС/браузер
        if баг1.get('ос') == баг2.get('ос'):
            оценка += 0.15
        if баг1.get('браузер') == баг2.get('браузер'):
            оценка += 0.15

        return оценка

    def найти_дубликаты_гибрид(self, новый_баг, bugs_df, порог=0.80):
        """Найти дубликаты используя гибридный подход"""
        # Получить дубликаты на основе текста
        дубликаты_текст = self.детектор_текста.найти_дубликаты(
            новый_баг['заголовок'],
            новый_баг['описание'],
            порог=0.70,  # Более низкий порог для начальной фильтрации
            top_k=20
        )

        # Вычислить гибридные оценки
        результаты = []
        for dup in дубликаты_текст:
            данные_бага = bugs_df[bugs_df['id_бага'] == dup['id_бага']].iloc[0]

            оценка_текст = dup['оценка_схожести']
            оценка_метаданных = self.вычислить_схожесть_метаданных(новый_баг, данные_бага)

            гибридная_оценка = (
                self.вес_текста * оценка_текст +
                self.вес_метаданных * оценка_метаданных
            )

            if гибридная_оценка >= порог:
                результаты.append({
                    'id_бага': dup['id_бага'],
                    'гибридная_оценка': гибридная_оценка,
                    'оценка_текст': оценка_текст,
                    'оценка_метаданных': оценка_метаданных
                })

        # Сортировать по гибридной оценке
        результаты.sort(key=lambda x: x['гибридная_оценка'], reverse=True)
        return результаты

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

class РекомендательНазначенияБагов:
    def __init__(self):
        self.профили_разработчиков = {}
        self.vectorizer = TfidfVectorizer(max_features=1000)
        self.эксперты_компонента = defaultdict(list)

    def построить_профили_разработчиков(self, исторические_баги):
        """Построить профили экспертизы для разработчиков"""
        баги_разработчика = defaultdict(list)

        # Группировать баги по исполнителю
        for _, баг in исторические_баги.iterrows():
            if баг['исполнитель'] and баг['статус'] == 'решён':
                баги_разработчика[баг['исполнитель']].append(
                    f"{баг['заголовок']} {баг['описание']}"
                )

                # Отслеживать экспертизу по компонентам
                if баг['компонент']:
                    self.эксперты_компонента[баг['компонент']].append({
                        'разработчик': баг['исполнитель'],
                        'время_решения': баг['время_решения_часы']
                    })

        # Создать TF-IDF профили
        все_разработчики = list(баги_разработчика.keys())
        все_тексты = [' '.join(баги_разработчика[dev]) for dev in все_разработчики]

        if все_тексты:
            матрица_tfidf = self.vectorizer.fit_transform(все_тексты)

            for idx, разработчик in enumerate(все_разработчики):
                self.профили_разработчиков[разработчик] = {
                    'вектор_экспертизы': матрица_tfidf[idx],
                    'баги_решены': len(баги_разработчика[разработчик]),
                    'среднее_время_решения': self._вычислить_среднее_время(
                        исторические_баги, разработчик
                    )
                }

        # Вычислить оценки экспертизы по компонентам
        for компонент, назначения in self.эксперты_компонента.items():
            статистика_разраб = defaultdict(lambda: {'счёт': 0, 'общее_время': 0})

            for назначение in назначения:
                разраб = назначение['разработчик']
                статистика_разраб[разраб]['счёт'] += 1
                статистика_разраб[разраб]['общее_время'] += назначение['время_решения']

            # Вычислить среднее и сохранить
            self.эксперты_компонента[компонент] = [
                {
                    'разработчик': разраб,
                    'счёт_багов': статс['счёт'],
                    'среднее_время': статс['общее_время'] / статс['счёт']
                }
                for разраб, статс in статистика_разраб.items()
            ]

    def _вычислить_среднее_время(self, df, разработчик):
        """Вычислить среднее время решения для разработчика"""
        баги_разраб = df[df['исполнитель'] == разработчик]
        return баги_разраб['время_решения_часы'].mean()

    def рекомендовать_исполнителя(self, заголовок_бага, описание_бага, компонент=None, top_k=3):
        """Рекомендовать лучших исполнителей для нового бага"""
        # Создать вектор бага
        текст_бага = f"{заголовок_бага} {описание_бага}"
        вектор_бага = self.vectorizer.transform([текст_бага])

        оценки = []

        for разработчик, профиль in self.профили_разработчиков.items():
            # Оценка схожести текста
            схожесть = cosine_similarity(
                вектор_бага,
                профиль['вектор_экспертизы']
            )[0][0]

            # Бонус за экспертизу компонента
            бонус_компонент = 0
            if компонент and компонент in self.эксперты_компонента:
                эксперты = self.эксперты_компонента[компонент]
                for эксперт in эксперты:
                    if эксперт['разработчик'] == разработчик:
                        # Бонус на основе опыта и скорости
                        бонус_компонент = 0.2 * min(эксперт['счёт_багов'] / 10, 1.0)
                        if эксперт['среднее_время'] < 24:  # Быстрый решатель
                            бонус_компонент += 0.1

            # Штраф за нагрузку (упрощённо - интегрировался бы с данными в реальном времени)
            штраф_нагрузка = 0  # Запрашивал бы текущие открытые баги

            # Комбинированная оценка
            финальная_оценка = схожесть + бонус_компонент - штраф_нагрузка

            оценки.append({
                'разработчик': разработчик,
                'оценка': финальная_оценка,
                'схожесть': схожесть,
                'бонус_компонент': бонус_компонент,
                'среднее_время_решения': профиль['среднее_время_решения']
            })

        # Сортировать и вернуть топ K
        оценки.sort(key=lambda x: x['оценка'], reverse=True)
        return оценки[:top_k]

# Пример использования
рекомендатель = РекомендательНазначенияБагов()
рекомендатель.построить_профили_разработчиков(исторические_баги_df)

рекомендации = рекомендатель.рекомендовать_исполнителя(
    заголовок_бага="Утечка памяти в модуле обработки данных",
    описание_бага="Приложение потребляет растущий объём памяти при обработке больших наборов данных",
    компонент="обработка-данных"
)

print("Рекомендованные исполнители:")
for idx, rec in enumerate(рекомендации, 1):
    print(f"{idx}. {rec['разработчик']}")
    print(f"   Оценка: {rec['оценка']:.3f}")
    print(f"   Среднее время решения: {rec['среднее_время_решения']:.1f} часов")

from sklearn.ensemble import GradientBoostingRegressor
import pandas as pd

class ОптимизаторSLA:
    def __init__(self):
        self.предсказатель_времени = GradientBoostingRegressor(
            n_estimators=100,
            learning_rate=0.1,
            max_depth=5
        )
        self.серьёзность_sla = {
            'критическая': 4,   # 4 часа
            'высокая': 24,      # 24 часа
            'средняя': 72,      # 3 дня
            'низкая': 168       # 1 неделя
        }

    def подготовить_признаки(self, bugs_df):
        """Извлечь признаки для предсказания времени"""
        признаки = pd.DataFrame()

        # Кодирование серьёзности
        карта_серьёзности = {'низкая': 1, 'средняя': 2, 'высокая': 3, 'критическая': 4}
        признаки['код_серьёзности'] = bugs_df['серьёзность'].map(карта_серьёзности)

        # Сложность текста
        признаки['длина_заголовка'] = bugs_df['заголовок'].str.len()
        признаки['длина_описания'] = bugs_df['описание'].str.len()
        признаки['есть_стектрейс'] = bugs_df['описание'].str.contains(
            'at |Traceback', regex=True
        ).astype(int)

        # Сложность компонента (на основе исторических данных)
        среднее_время_компонента = bugs_df.groupby('компонент')['время_решения_часы'].mean()
        признаки['сложность_компонента'] = bugs_df['компонент'].map(среднее_время_компонента)

        # История репортёра
        счёт_багов_репортёра = bugs_df.groupby('репортёр').size()
        признаки['опыт_репортёра'] = bugs_df['репортёр'].map(счёт_багов_репортёра)

        # Временные признаки
        bugs_df['создан'] = pd.to_datetime(bugs_df['создан'])
        признаки['час_дня'] = bugs_df['создан'].dt.hour
        признаки['день_недели'] = bugs_df['создан'].dt.dayofweek
        признаки['выходной'] = (признаки['день_недели'] >= 5).astype(int)

        return признаки

    def обучить(self, bugs_df):
        """Обучить предсказатель времени решения"""
        X = self.подготовить_признаки(bugs_df)
        y = bugs_df['время_решения_часы']

        self.предсказатель_времени.fit(X, y)
        return self

    def предсказать_время_решения(self, данные_бага):
        """Предсказать время решения для бага"""
        признаки = self.подготовить_признаки(pd.DataFrame([данные_бага]))
        предсказанные_часы = self.предсказатель_времени.predict(признаки)[0]
        return предсказанные_часы

    def вычислить_риск_sla(self, данные_бага):
        """Вычислить риск нарушения SLA"""
        предсказанное_время = self.предсказать_время_решения(данные_бага)
        лимит_sla = self.серьёзность_sla.get(данные_бага['серьёзность'], 168)

        оценка_риска = предсказанное_время / лимит_sla

        if оценка_риска >= 1.0:
            уровень_риска = 'ВЫСОКИЙ'
        elif оценка_риска >= 0.7:
            уровень_риска = 'СРЕДНИЙ'
        else:
            уровень_риска = 'НИЗКИЙ'

        return {
            'предсказано_часов': предсказанное_время,
            'часов_sla': лимит_sla,
            'оценка_риска': оценка_риска,
            'уровень_риска': уровень_риска,
            'рекомендуемое_действие': self._получить_рекомендацию(уровень_риска)
        }

    def _получить_рекомендацию(self, уровень_риска):
        """Получить рекомендуемые действия на основе риска"""
        if уровень_риска == 'ВЫСОКИЙ':
            return "СРОЧНО: Назначить старшему разработчику немедленно"
        elif уровень_риска == 'СРЕДНИЙ':
            return "Тщательно мониторить, рассмотреть эскалацию"
        else:
            return "Стандартный рабочий процесс"

    def оптимизировать_очередь(self, открытые_баги_df):
        """Приоритизировать очередь багов для оптимизации соблюдения SLA"""
        приоритеты = []

        for _, баг in открытые_баги_df.iterrows():
            анализ_sla = self.вычислить_риск_sla(баг.to_dict())

            # Вычислить оценку срочности
            оставшееся_время = анализ_sla['часов_sla'] - баг['часов_открыт']
            срочность = анализ_sla['оценка_риска'] * (1 / max(оставшееся_время, 1))

            приоритеты.append({
                'id_бага': баг['id_бага'],
                'оценка_срочности': срочность,
                'риск_sla': анализ_sla['уровень_риска'],
                'оставшееся_время': оставшееся_время,
                'предсказанное_решение': анализ_sla['предсказано_часов']
            })

        # Сортировать по срочности
        приоритеты.sort(key=lambda x: x['оценка_срочности'], reverse=True)
        return приоритеты

# Пример использования
оптимизатор = ОптимизаторSLA()
оптимизатор.обучить(исторические_баги_df)

# Проанализировать новый баг
баг = {
    'серьёзность': 'высокая',
    'заголовок': 'Обработка платежей не работает',
    'описание': 'Критический баг, влияющий на оформление заказа. Стектрейс включён...',
    'компонент': 'платёжный-шлюз',
    'репортёр': 'пользователь@пример.com',
    'создан': '2025-10-04 14:30:00'
}

анализ_риска = оптимизатор.вычислить_риск_sla(баг)
print(f"Риск SLA: {анализ_риска['уровень_риска']}")
print(f"Предсказанное решение: {анализ_риска['предсказано_часов']:.1f} часов")
print(f"Рекомендация: {анализ_риска['рекомендуемое_действие']}")

from jira import JIRA
import requests

class ИнтеграцияТриажаJIRA:
    def __init__(self, сервер, email, api_token):
        self.jira = JIRA(server=сервер, basic_auth=(email, api_token))
        self.предсказатель = ПредсказательСерьёзностиБагов()
        self.детектор_дубликатов = ДетекторДубликатовБагов()
        self.рекомендатель = РекомендательНазначенияБагов()
        self.оптимизатор_sla = ОптимизаторSLA()

    def обработать_новую_задачу(self, ключ_задачи):
        """Автоматически триажить новую задачу JIRA"""
        # Получить задачу
        задача = self.jira.issue(ключ_задачи)

        заголовок = задача.fields.summary
        описание = задача.fields.description or ""

        # 1. Предсказать серьёзность
        результат_серьёзности = self.предсказатель.предсказать(заголовок, описание)

        # 2. Проверить на дубликаты
        дубликаты = self.детектор_дубликатов.найти_дубликаты(
            заголовок, описание, порог=0.85
        )

        # 3. Рекомендовать исполнителя
        компонент = задача.fields.components[0].name if задача.fields.components else None
        рекомендации_исполнителя = self.рекомендатель.рекомендовать_исполнителя(
            заголовок, описание, компонент
        )

        # 4. Вычислить риск SLA
        данные_бага = {
            'серьёзность': результат_серьёзности['серьёзность'],
            'заголовок': заголовок,
            'описание': описание,
            'компонент': компонент,
            'репортёр': задача.fields.reporter.emailAddress,
            'создан': задача.fields.created
        }
        риск_sla = self.оптимизатор_sla.вычислить_риск_sla(данные_бага)

        # 5. Обновить задачу JIRA
        обновления = {}

        # Установить приоритет на основе предсказанной серьёзности
        карта_приоритета = {
            'критическая': 'Highest',
            'высокая': 'High',
            'средняя': 'Medium',
            'низкая': 'Low'
        }
        обновления['priority'] = {'name': карта_приоритета[результат_серьёзности['серьёзность']]}

        # Добавить комментарий с анализом ИИ
        комментарий = f"""Анализ Триажа ИИ:

**Предсказанная Серьёзность:** {результат_серьёзности['серьёзность']} (уверенность: {результат_серьёзности['уверенность']:.1%})

**Обнаружение Дубликатов:**
{self._форматировать_дубликаты(дубликаты)}

**Рекомендованные Исполнители:**
{self._форматировать_рекомендации(рекомендации_исполнителя)}

**Анализ SLA:**
- Уровень Риска: {риск_sla['уровень_риска']}
- Предсказанное Решение: {риск_sla['предсказано_часов']:.1f} часов
- Лимит SLA: {риск_sla['часов_sla']} часов
- Рекомендация: {риск_sla['рекомендуемое_действие']}
"""

        # Обновить задачу
        задача.update(fields=обновления)
        self.jira.add_comment(задача, комментарий)

        # Авто-назначить при высокой уверенности
        if рекомендации_исполнителя and рекомендации_исполнителя[0]['оценка'] > 0.8:
            лучший_исполнитель = рекомендации_исполнителя[0]['разработчик']
            задача.update(assignee={'name': лучший_исполнитель})

        # Добавить метки
        метки = задача.fields.labels or []
        метки.append(f"ии-серьёзность-{результат_серьёзности['серьёзность']}")
        if дубликаты:
            метки.append('возможный-дубликат')
        if риск_sla['уровень_риска'] == 'ВЫСОКИЙ':
            метки.append('риск-sla')
        задача.update(fields={'labels': метки})

        return {
            'серьёзность': результат_серьёзности,
            'дубликаты': дубликаты,
            'рекомендации_исполнителя': рекомендации_исполнителя,
            'риск_sla': риск_sla
        }

    def _форматировать_дубликаты(self, дубликаты):
        if not дубликаты:
            return "Дубликаты не найдены"

        текст = ""
        for dup in дубликаты[:3]:
            текст += f"- {dup['id_бага']} (схожесть: {dup['оценка_схожести']:.1%})\n"
        return текст

    def _форматировать_рекомендации(self, рекомендации):
        текст = ""
        for idx, rec in enumerate(рекомендации, 1):
            текст += f"{idx}. {rec['разработчик']} (оценка: {rec['оценка']:.2f}, "
            текст += f"среднее время: {rec['среднее_время_решения']:.1f}ч)\n"
        return текст

    def обработать_пакет_без_триажа(self, jql_запрос="status = Open AND priority is EMPTY"):
        """Обработать все задачи без триажа"""
        задачи = self.jira.search_issues(jql_запрос, maxResults=100)

        результаты = []
        for задача in задачи:
            try:
                результат = self.обработать_новую_задачу(задача.key)
                результаты.append({'задача': задача.key, 'статус': 'успех', 'результат': результат})
            except Exception as e:
                результаты.append({'задача': задача.key, 'статус': 'ошибка', 'ошибка': str(e)})

        return результаты

# Пример использования
интеграция = ИнтеграцияТриажаJIRA(
    сервер='https://ваш-домен.atlassian.net',
    email='ваш-email@пример.com',
    api_token='ваш-api-токен'
)

# Обработать новую задачу
результат = интеграция.обработать_новую_задачу('PROJ-1234')
print(f"Триаж завершён: {результат}")

# Пакетная обработка задач без триажа
результаты_пакета = интеграция.обработать_пакет_без_триажа()
print(f"Обработано {len(результаты_пакета)} задач")

from github import Github

class БотТриажаGitHub:
    def __init__(self, токен_доступа, имя_репо):
        self.gh = Github(токен_доступа)
        self.repo = self.gh.get_repo(имя_репо)
        self.предсказатель = ПредсказательСерьёзностиБагов()
        self.детектор_дубликатов = ДетекторДубликатовБагов()

    def обработать_задачу(self, номер_задачи):
        """Триажить задачу GitHub"""
        задача = self.repo.get_issue(номер_задачи)

        # Предсказать серьёзность
        результат_серьёзности = self.предсказатель.предсказать(
            задача.title,
            задача.body or ""
        )

        # Найти дубликаты
        дубликаты = self.детектор_дубликатов.найти_дубликаты(
            задача.title,
            задача.body or "",
            порог=0.85
        )

        # Применить метки
        метки = []
        метки.append(f"серьёзность:{результат_серьёзности['серьёзность']}")

        if результат_серьёзности['серьёзность'] in ['критическая', 'высокая']:
            метки.append('приоритет:высокий')

        if дубликаты:
            метки.append('дубликат?')

        задача.add_to_labels(*метки)

        # Добавить комментарий с анализом
        if дубликаты:
            текст_дуп = "\n".join([
                f"- #{dup['id_бага']} (схожесть: {dup['оценка_схожести']:.1%})"
                for dup in дубликаты[:3]
            ])

            комментарий = f"""## Анализ Бота Триажа ИИ

**Предсказанная Серьёзность:** {результат_серьёзности['серьёзность']} (уверенность: {результат_серьёзности['уверенность']:.1%})

**Возможные Дубликаты:**
{текст_дуп}

Пожалуйста, проверьте эти потенциальные дубликаты перед продолжением.
"""
            задача.create_comment(комментарий)

        return {
            'серьёзность': результат_серьёзности,
            'дубликаты': дубликаты,
            'применённые_метки': метки
        }

    def обработчик_вебхука(self, payload):
        """Обработать вебхук GitHub для новых задач"""
        if payload['action'] == 'opened':
            номер_задачи = payload['issue']['number']
            return self.обработать_задачу(номер_задачи)

# Использование
бот = БотТриажаGitHub(
    токен_доступа='ghp_xxx',
    имя_репо='пользователь/репозиторий'
)

результат = бот.обработать_задачу(42)
print(f"Результат триажа: {результат}")