Єдиний коміт - очищення історії

.gitignore

@@ -0,0 +1,14 @@
+venv/
+venv_new/
+__pycache__/
+*.py[cod]
+*.class
+.env
+.DS_Store
+.idea/
+.vscode/
+*.log
+venv_new/
+temp/
+reports/
+data/

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

HELP.md

@@ -0,0 +1,262 @@
+# Jira AI Assistant - Керівництво користувача
+
+## Загальна інформація
+
+Jira AI Assistant — це потужний інструмент для аналізу, візуалізації та інтелектуальної обробки даних Jira за допомогою штучного інтелекту. Додаток дозволяє імпортувати дані з CSV-експорту Jira, аналізувати їх, створювати різноманітні візуалізації та використовувати можливості AI для глибокого розуміння стану проєкту.
+
+### Основні можливості
+
+- Аналіз CSV-експорту з Jira з виявленням ключових метрик
+- Генерація візуалізацій різних типів для кращого розуміння даних
+- AI-аналіз даних з використанням моделей OpenAI та Google Gemini
+- Гібридний чат з відповідями на питання про проєкт
+- Автоматична генерація структурованих звітів на основі даних
+- Збереження результатів аналізу та візуалізацій
+
+
+## Інтерфейс користувача
+
+Інтерфейс додатку складається з кількох вкладок, кожна з яких відповідає за певну функціональність:
+
+1. **CSV Аналіз** - завантаження, ініціалізація та аналіз даних з CSV-файлів
+2. **Візуалізації** - створення та налаштування візуальних представлень даних
+3. **AI Асистенти** - робота з AI моделями для аналізу та генерації контенту
+4. **Jira API** - прямий зв'язок з Jira API (у розробці)
+5. **Інтеграції** - інтеграція з іншими сервісами (у розробці)
+
+
+## CSV Аналіз
+
+Ця вкладка призначена для роботи з даними Jira у форматі CSV.
+
+### Завантаження CSV-файлу
+
+1. Перейдіть на вкладку "CSV Аналіз"
+2. У блоці "Завантаження CSV" натисніть кнопку для вибору файлу або перетягніть файл у відповідну область
+3. Встановіть значення "Кількість днів для визначення неактивних тікетів" (за замовчуванням 14 днів)
+
+### Робота з локальними файлами
+
+Програма може працювати з CSV-файлами, що зберігаються в директорії `current_data`:
+
+1. Натисніть кнопку "Оновити список файлів" для відображення доступних локальних файлів
+2. У випадаючому списку "Виберіть файли з директорії current_data" виберіть один або кілька файлів
+3. Для перегляду вмісту конкретного файлу:
+   - Виберіть файл у списку "Виберіть файл для перегляду"
+   - Натисніть кнопку "Переглянути"
+
+### Ініціалізація та аналіз даних
+
+Для аналізу даних натисніть кнопку "Ініціалізація та Аналіз". Процес виконає наступні кроки:
+
+1. Завантаження та об'єднання вибраних файлів (якщо вибрано кілька)
+2. Обробка даних для аналізу
+3. Генерація статистики та виявлення неактивних тікетів
+4. Відображення звіту з результатами
+
+Звіт містить:
+- Загальну статистику проєкту (кількість тікетів, розподіл за статусами, типами, пріоритетами)
+- Аналіз неактивних тікетів (тікети без змін протягом вказаного періоду)
+- Рекомендації
+
+### Очищення тимчасових даних
+
+У розділі "Обслуговування" можна виконати очищення тимчасових даних:
+
+1. Розгорніть секцію "Обслуговування"
+2. Натисніть кнопку "Очистити тимчасові дані"
+
+Ця функція видаляє всі тимчасові файли, включаючи індекси, сесії та звіти, але не видаляє файли в директорії `current_data`.
+
+## Візуалізації
+
+Вкладка "Візуалізації" дозволяє створювати різні графічні представлення даних.
+
+### Створення візуалізацій
+
+1. Виберіть тип візуалізації зі списку:
+   - **Статуси** - розподіл тікетів за статусами
+   - **Пріоритети** - розподіл тікетів за пріоритетами
+   - **Типи тікетів** - розподіл за типами (Bugs, Tasks, Stories тощо)
+   - **Призначені користувачі** - розподіл тікетів за виконавцями
+   - **Активність створення** - кількість нових тікетів за період
+   - **Активність оновлення** - кількість оновлених тікетів за період
+   - **Кумулятивне створення** - наростаюча кількість тікетів з часом
+   - **Неактивні тікети** - аналіз тікетів без руху
+   - **Теплова карта: Типи/Статуси** - взаємозв'язок між типами та статусами
+   - **Часова шкала проекту** - загальна шкала активності
+   - **Склад статусів з часом** - зміна складу статусів з часом
+
+2. Налаштуйте параметри візуалізації (в акордеоні "Параметри візуалізації"):
+   - **Ліміт для топ-візуалізацій** - кількість елементів для відображення (для топ-списків)
+   - **Групування для часових діаграм** - рівень деталізації (день, тиждень, місяць)
+
+3. Натисніть кнопку "Генерувати" для створення візуалізації
+
+### Збереження візуалізацій
+
+Щоб зберегти створену візуалізацію:
+
+1. Введіть ім'я файлу (або залиште порожнім для автоматичного імені)
+2. Натисніть кнопку "Зберегти візуалізацію"
+3. Візуалізація буде збережена в директорії `reports/visualizations`
+
+## AI Асистенти
+
+Вкладка "AI Асистенти" надає доступ до функцій аналізу даних за допомогою штучного інтелекту.
+
+### Налаштування параметрів
+
+Для всіх режимів AI можна налаштувати:
+
+- **Модель LLM** - вибір між моделями:
+  - `gemini` - використовує Google Gemini моделі
+  - `openai` - використовує OpenAI моделі (GPT)
+- **Температура** - параметр для контролю креативності відповідей (вищі значення = більше креативності, нижчі = більше детермінованості)
+
+### Ініціалізація індексів
+
+Перед використанням режиму Гібридного чату необхідно створити індекси для ефективного пошуку:
+
+1. Переконайтеся, що дані вже завантажені через вкладку "CSV Аналіз"
+2. Натисніть кнопку "Ініціалізувати індекси"
+3. Дочекайтеся повідомлення про успішне створення індексів
+
+Цей крок створює:
+- Векторні індекси FAISS для семантичного (смислового) пошуку
+- BM25 індекси для пошуку за ключовими словами
+
+### Режими роботи з AI
+
+#### Q/A з повним контекстом
+
+Режим для загальних питань про проєкт, який надає доступ до всіх даних одночасно:
+
+1. Введіть питання у відповідне поле
+2. Натисніть "Отримати відповідь"
+3. Система аналізує всі дані та надає комплексну відповідь
+
+Приклади питань:
+- "Які тікети мають найвищий пріоритет?"
+- "Скільки помилок було виправлено за останній місяць?"
+- "Хто найактивніший розробник у проєкті?"
+
+#### Гібридний чат
+
+Режим діалогу з системою, який використовує комбінацію BM25 і векторного пошуку:
+
+1. Введіть питання у поле для повідомлення
+2. Натисніть Enter або Shift+Enter для відправки
+3. ��истема відповідає на основі аналізу даних
+4. Можна вести діалог з послідовними питаннями
+
+Переваги:
+- Підтримує контекст розмови (враховує попередні питання та відповіді)
+- Показує релевантні документи/тікети для кожної відповіді
+- Оптимальний для детальних специфічних запитань
+
+#### Генерація звіту
+
+Режим для автоматичного створення структурованого аналітичного звіту:
+
+1. Виберіть формат звіту (markdown або html)
+2. Натисніть "Згенерувати звіт"
+3. Система аналізує всі дані та створює детальний звіт
+
+Звіт зазвичай містить:
+- Короткий огляд проєкту
+- Аналіз поточного стану
+- Виявлені проблеми та ризики
+- Рекомендації для покращення процесу
+- Висновки та наступні кроки
+
+
+## Експорт даних з Jira у CSV-формат
+
+Для коректної роботи з Jira AI Assistant необхідно правильно експортувати дані з Jira у форматі CSV. Нижче наведено детальні інструкції з експорту.
+
+### Пошук та налаштування даних для експорту
+
+1. **Відкрийте Jira** та авторизуйтеся у системі
+2. **Перейдіть до функції пошуку**: натисніть "Issues" у верхньому меню, потім виберіть "Search for issues"
+3. **Налаштуйте фільтри пошуку** для відбору потрібних тікетів:
+   - Виберіть проєкт (наприклад, "IEE DS") з випадаючого списку
+   - Вкажіть тип завдань ("Type") або залиште "All"
+   - Вкажіть статус завдань ("Status") або залиште "All"
+   - За потреби вкажіть виконавця ("Assignee")
+   - Використовуйте поле пошуку для конкретного тексту
+   - Для більш складних запитів натисніть "Advanced" і використовуйте JQL-запити
+
+4. **Натисніть кнопку "Search"** для отримання результатів
+
+### Експорт результатів пошуку у CSV
+
+1. **У результатах пошуку натисніть кнопку "Export"** (знаходиться у правому верхньому куті)
+2. **Виберіть "CSV (Current fields)"** або "CSV (All fields)" залежно від того, які дані вам потрібні:
+   - "Current fields" - експортує тільки поля, що відображаються у поточному представленні
+   - "All fields" - експортує всі доступні поля (рекомендовано для повного аналізу)
+
+3. **Налаштуйте опції експорту**:
+   - Переконайтеся, що включені всі важливі поля: Issue key, Summary, Status, Issue Type, Priority, Created, Updated, Description, Assignee, Reporter
+   - Якщо використовуєте власні поля (custom fields), переконайтеся, що вони також включені
+
+4. **Підтвердіть експорт** і збережіть CSV-файл на вашому комп'ютері
+
+### Рекомендації щодо експорту
+
+- **Експортуйте всі можливі поля**, особливо якщо плануєте використовувати AI аналіз. Більше даних дозволяє отримати більш глибокі та точні інсайти.
+- **Включіть поле Description** для аналізу текстового вмісту тікетів.
+- **Включіть поля з коментарями**, якщо вони доступні у вашій конфігурації Jira.
+- **Експортуйте вкладення або посилання**, якщо вони важливі для аналізу.
+- **Для великих проєктів** розгляньте можливість створення кількох експортів з різними наборами фільтрів для більш цілеспрямованого аналізу.
+
+
+## Поради з використання
+
+### Оптимальні практики
+
+1. **Підготовка даних**:
+   - Експортуйте з Jira максимально повний набір даних з усіма важливими полям��
+   - Упевніться, що CSV-файл містить колонки: Issue key, Summary, Status, Issue Type, Priority, Created, Updated
+
+2. **Правильна послідовність дій**:
+   - Спочатку завантажте і проаналізуйте дані (вкладка "CSV Аналіз")
+   - Створіть необхідні візуалізації (вкладка "Візуалізації")
+   - Ініціалізуйте індекси перед використанням AI асистентів
+   - Використовуйте функції AI для глибшого аналізу
+
+3. **Вибір режиму AI**:
+   - "Q/A з повним контекстом" - для загальних питань про проєкт
+   - "Гібридний чат" - для детальних питань з контекстом розмови
+   - "Генерація звіту" - для створення структурованих звітів
+
+### Вирішення поширених проблем
+
+1. **Не вдається завантажити CSV**:
+   - Перевірте формат CSV-файлу та наявність необхідних колонок
+   - Переконайтеся, що файл не порожній і не пошкоджений
+   - Спробуйте скопіювати файл у директорію `current_data` і використати через локальні файли
+
+2. **Помилки при створенні індексів**:
+   - Переконайтеся, що встановлені всі необхідні бібліотеки для AI
+   - Очистіть тимчасові дані та спробуйте знову
+   - Перевірте наявність достатньої кількості вільного місця на диску
+
+3. **AI асистент не відповідає**:
+   - Перевірте наявність та валідність API ключів (OpenAI або Gemini)
+   - Для гібридного чату переконайтеся, що індекси успішно ініціалізовані
+
+
+## Додаткова інформація
+
+Для додаткових запитань і технічної підтримки звертайтеся до розробника (szabolotnii@healthprecision.com).
+
+---
+
+### Глосарій
+
+- **CSV-файл** - формат файлу для зберігання табличних даних, який можна експортувати з Jira
+- **Неактивні тікети** - тікети, які не оновлювалися протягом визначеного періоду
+- **FAISS** - бібліотека для ефективного пошуку схожих векторів, використовується для семантичного пошуку
+- **BM25** - алгоритм ранжування для пошуку за ключовими словами
+- **Гібридний пошук** - комбінація BM25 та векторного пошуку для покращення релевантності результатів

README.md

@@ -0,0 +1,27 @@
+---
+title: Jira AI Assistant
+emoji: 🔍
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 5.20.0
+app_file: app.py
+pinned: false
+---
+
+# Jira AI Assistant
+
+Інструмент для аналізу та візуалізації даних з Jira за допомогою AI.
+
+## Можливості
+
+- Аналіз CSV-експорту з Jira
+- Генерація звітів та візуалізацій
+- AI аналіз даних Jira
+- Інтеграція з OpenAI та Google Gemini
+
+## Використання
+
+1. Завантажте CSV-файл
+2. Оберіть режим аналізу
+3. Отримайте результати та візуалізації

app.py

@@ -0,0 +1,100 @@
+import os
+import logging
+from pathlib import Path
+import sys
+
+# Додаємо поточну директорію до PYTHONPATH для правильного імпорту модулів
+current_dir = os.path.dirname(os.path.abspath(__file__))
+if current_dir not in sys.path:
+    sys.path.append(current_dir)
+    
+# Налаштування логування
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("huggingface_jira_assistant.log"),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger("jira_assistant_hf")
+
+# Створення необхідних директорій
+for directory in ["data", "reports", "temp", "logs", "temp/indices", "current_data"]:
+    Path(directory).mkdir(exist_ok=True, parents=True)
+
+logger.info(f"Робоча директорія: {os.getcwd()}")
+logger.info(f"Вміст робочої директорії: {os.listdir('.')}")
+logger.info(f"Python path: {sys.path}")
+
+# Перевірка середовища Hugging Face
+is_huggingface = os.environ.get("SPACE_ID") is not None
+if is_huggingface:
+    logger.info("Виявлено середовище Hugging Face Spaces")
+
+# Спроба імпорту основного додатку
+try:
+    # Імпорт уніфікованого менеджера індексів
+    from modules.data_management.unified_index_manager import UnifiedIndexManager
+    
+    # Створюємо глобальний екземпляр менеджера індексів
+    # Це дозволить використовувати один і той же менеджер в різних модулях
+    index_manager = UnifiedIndexManager()
+    
+    # Додаємо менеджер індексів до глобальних змінних
+    import builtins
+    builtins.index_manager = index_manager
+    
+    # Імпорт основного додатку з перейменованого файлу
+    from jira_assistant import JiraAssistantApp
+    from interface import launch_interface
+    
+    # Створення екземпляру додатку
+    app = JiraAssistantApp()
+    
+    # Передаємо менеджер індексів у додаток
+    app.index_manager = index_manager
+    
+    # Отримання інтерфейсу Gradio
+    interface = launch_interface(app)
+    
+    # Запуск інтерфейсу
+    if __name__ == "__main__":
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False
+        )
+    
+except Exception as e:
+    import traceback
+    logger.error(f"Помилка при ініціалізації програми: {e}")
+    logger.error(traceback.format_exc())
+    
+    # Створення спрощеного інтерфейсу при помилці
+    import gradio as gr
+    
+    def simplified_interface():
+        with gr.Blocks(title="Jira AI Assistant") as interface:
+            gr.Markdown("# 🔍 Jira AI Assistant")
+            gr.Markdown(f"""
+            ## ⚠️ Помилка запуску
+            
+            Виникла помилка при запуску програми. Перевірте логи для детальної інформації.
+            
+            Помилка: {str(e)}
+            
+            Вміст директорії: {os.listdir('.')}
+            Python path: {sys.path}
+            """)
+            
+        return interface
+    
+    interface = simplified_interface()
+    
+    if __name__ == "__main__":
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False
+        )

config.json

@@ -0,0 +1,8 @@
+{
+  "theme": "default",
+  "share": false,
+  "additional_options": {
+    "show_api": false,
+    "show_error": true
+  }
+}

config.py

@@ -0,0 +1,88 @@
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Завантаження змінних середовища з .env файлу, якщо він існує
+load_dotenv()
+
+# Базові шляхи
+BASE_DIR = Path(__file__).parent.absolute()
+DATA_DIR = BASE_DIR / "data"
+REPORTS_DIR = BASE_DIR / "reports"
+TEMP_DIR = BASE_DIR / "temp"
+LOG_DIR = BASE_DIR / "logs"
+
+# Створення директорій, якщо вони не існують
+DATA_DIR.mkdir(exist_ok=True, parents=True)
+REPORTS_DIR.mkdir(exist_ok=True, parents=True)
+TEMP_DIR.mkdir(exist_ok=True, parents=True)
+LOG_DIR.mkdir(exist_ok=True, parents=True)
+
+# Налаштування додатку
+APP_NAME = "Jira AI Assistant"
+APP_VERSION = "1.0.0"
+DEFAULT_INACTIVE_DAYS = 14
+MAX_RESULTS = 500
+
+# API ключі та налаштування
+JIRA_URL = os.getenv("JIRA_URL", "")
+JIRA_USERNAME = os.getenv("JIRA_USERNAME", "")
+JIRA_API_TOKEN = os.getenv("JIRA_API_TOKEN", "")
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-3.5-turbo")
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
+GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-pro")
+
+SLACK_BOT_TOKEN = os.getenv("SLACK_BOT_TOKEN", "")
+
+# Налаштування логування
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
+LOG_FILE = os.getenv("LOG_FILE", LOG_DIR / f"{APP_NAME.lower().replace(' ', '_')}.log")
+
+# Додаткові налаштування для Gradio
+GRADIO_THEME = "huggingface"  # Доступні теми: default, huggingface, grass, peach
+GRADIO_AUTH = []  # Список кортежів (username, password) для авторизації
+GRADIO_SHARE = False  # Чи використовувати публічний URL для додатку
+
+# Функція для збереження налаштувань у конфігураційний файл
+def save_config():
+    import json
+    
+    config = {
+        "app_name": APP_NAME,
+        "version": APP_VERSION,
+        "data_dir": str(DATA_DIR),
+        "reports_dir": str(REPORTS_DIR),
+        "temp_dir": str(TEMP_DIR),
+        "log_dir": str(LOG_DIR),
+        "log_level": LOG_LEVEL,
+        "default_inactive_days": DEFAULT_INACTIVE_DAYS,
+        "openai_model": OPENAI_MODEL,
+        "gemini_model": GEMINI_MODEL,
+        "max_results": MAX_RESULTS,
+        "gradio_theme": GRADIO_THEME,
+        "gradio_share": GRADIO_SHARE
+    }
+    
+    with open(BASE_DIR / "config.json", "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)
+
+# Функція для завантаження налаштувань з конфігураційного файлу
+def load_config():
+    import json
+    
+    config_file = BASE_DIR / "config.json"
+    
+    if config_file.exists():
+        with open(config_file, "r", encoding="utf-8") as f:
+            config = json.load(f)
+        
+        return config
+    
+    return None
+
+# Створення конфігураційного файлу при імпорті, якщо він не існує
+if not (BASE_DIR / "config.json").exists():
+    save_config()

gradio_config.json

@@ -0,0 +1,8 @@
+{
+    "theme": "gradio/glass",
+    "share": true,
+    "additional_options": {
+      "show_api": false,
+      "show_error": true
+    }
+  }

interface.py

@@ -0,0 +1,69 @@
+import gradio as gr
+import logging
+from pathlib import Path
+
+# Імпортуємо вкладки з підмодулів
+from modules.interface.csv_analysis_ui import create_csv_analysis_tab
+from modules.interface.visualizations_ui import create_visualizations_tab
+from modules.interface.jira_api_ui import create_jira_api_tab
+from modules.interface.ai_assistant_ui import create_ai_assistant_tab
+from modules.interface.integrations_ui import create_integrations_tab
+
+logger = logging.getLogger("jira_assistant_interface")
+
+def create_help_tab(app):
+    """
+    Створює вкладку 'Довідка' з інформацією з HELP.md.
+    """
+    with gr.Tab("Довідка"):
+        try:
+            # Шлях до файлу HELP.md
+            help_file_path = Path("HELP.md")
+            
+            # Перевіряємо, чи існує файл
+            if help_file_path.exists():
+                # Читаємо вміст файлу
+                with open(help_file_path, "r", encoding="utf-8") as f:
+                    help_content = f.read()
+                
+                # Відображаємо вміст як Markdown
+                with gr.Blocks():
+                    gr.Markdown(help_content)
+            else:
+                gr.Markdown("# Довідка недоступна")
+                gr.Markdown("Файл HELP.md не знайдено. Перевірте, чи існує файл у кореневій директорії проєкту.")
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні файлу довідки: {e}")
+            gr.Markdown("# Помилка при завантаженні довідки")
+            gr.Markdown(f"Виникла помилка: {str(e)}")
+
+def launch_interface(app):
+    """
+    Запуск інтерфейсу користувача Gradio
+
+    Args:
+        app: Екземпляр JiraAssistantApp
+    """
+    interface = gr.Blocks(title="Jira AI Assistant")
+
+    with interface:
+        gr.Markdown("# 🔍 Jira AI Assistant")
+
+        # Перевіряємо, чи додаток має необхідні атрибути
+        if not hasattr(app, 'last_loaded_csv'):
+            app.last_loaded_csv = None
+        if not hasattr(app, 'current_data'):
+            app.current_data = None
+        if not hasattr(app, 'indices_path'):
+            app.indices_path = None
+
+        with gr.Tabs() as tabs:
+            # Створюємо вкладки
+            create_csv_analysis_tab(app)
+            create_visualizations_tab(app)
+            create_ai_assistant_tab(app)
+            create_jira_api_tab(app)
+            create_integrations_tab(app)
+            create_help_tab(app)  # Додана нова вкладка з довідкою
+
+    return interface

jira_assistant.py

@@ -0,0 +1,545 @@
+import os
+import logging
+from pathlib import Path
+from datetime import datetime
+import traceback
+import builtins
+import uuid
+import json
+
+# Налаштування логування
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("jira_assistant.log"),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger("jira_assistant")
+
+# Створення необхідних директорій
+for directory in ["data", "reports", "temp", "logs"]:
+    Path(directory).mkdir(exist_ok=True, parents=True)
+
+# Імпорт необхідних модулів
+from modules.data_import.csv_importer import JiraCsvImporter
+from modules.data_analysis.statistics import JiraDataAnalyzer
+from modules.data_analysis.visualizations import JiraVisualizer
+from modules.reporting.report_generator import ReportGenerator
+from modules.core.app_manager import AppManager
+
+from modules.ai_analysis.jira_hybrid_chat import JiraHybridChat
+
+
+class JiraAssistantApp:
+    """
+    Головний клас додатку, який координує роботу всіх компонентів
+    """
+    def __init__(self):
+        try:
+            # Отримуємо глобальний менеджер індексів
+            self.index_manager = builtins.index_manager
+            logger.info("Використовуємо глобальний менеджер індексів")
+        except AttributeError:
+            # Якщо глобальний менеджер не знайдено, створюємо новий
+            from modules.data_management.unified_index_manager import UnifiedIndexManager
+            self.index_manager = UnifiedIndexManager()
+            logger.info("Створено новий менеджер індексів")
+        
+        self.app_manager = AppManager()
+        self.current_data = None
+        self.current_analysis = None
+        self.visualizations = None
+        self.last_loaded_csv = None
+        self.current_session_id = None
+        
+    def analyze_csv_file(self, file_path, inactive_days=14, include_ai=False, api_key=None, model_type="openai", skip_indexing=True):
+        """
+        Аналіз CSV-файлу Jira без створення індексів.
+        
+        Args:
+            file_path (str): Шлях до CSV-файлу
+            inactive_days (int): Кількість днів для визначення неактивних тікетів
+            include_ai (bool): Чи використовувати AI-аналіз
+            api_key (str): API ключ для LLM (якщо include_ai=True)
+            model_type (str): Тип моделі LLM ("openai" або "gemini")
+            skip_indexing (bool): Пропустити створення індексів FAISS/BM25
+            
+        Returns:
+            dict: Результати аналізу
+        """
+        try:
+            logger.info(f"Аналіз файлу: {file_path}")
+            
+            # Генеруємо ідентифікатор сесії
+            import uuid
+            from datetime import datetime
+            self.current_session_id = f"{uuid.uuid4()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            
+            # Завантаження даних
+            from modules.data_import.csv_importer import JiraCsvImporter
+            csv_importer = JiraCsvImporter(file_path)
+            self.current_data = csv_importer.load_data()
+            
+            if self.current_data is None:
+                return {"error": "Не вдалося завантажити дані з CSV-файлу"}
+            
+            # Створюємо індекси для даних, тільки якщо не вказано пропустити
+            if not skip_indexing:
+                indices_result = self.index_manager.get_or_create_indices(
+                    self.current_data, 
+                    self.current_session_id
+                )
+                
+                if isinstance(indices_result, dict) and "error" not in indices_result:
+                    logger.info(f"Індекси успішно створено: {indices_result.get('indices_dir', 'невідомо')}")
+                    self.current_indices_dir = indices_result.get("indices_dir", None)
+                    self.indices_path = indices_result.get("indices_dir", None)
+            else:
+                logger.info("Створення індексів пропущено згідно з налаштуваннями")
+            
+            # Аналіз даних
+            from modules.data_analysis.statistics import JiraDataAnalyzer
+            analyzer = JiraDataAnalyzer(self.current_data)
+            
+            # Базова статистика
+            stats = analyzer.generate_basic_statistics()
+            
+            # Аналіз неактивних тікетів
+            inactive_issues = analyzer.analyze_inactive_issues(days=inactive_days)
+            
+            # Створення візуалізацій
+            from modules.data_analysis.visualizations import JiraVisualizer
+            visualizer = JiraVisualizer(self.current_data)
+            self.visualizations = {
+                "status": visualizer.plot_status_counts(),
+                "priority": visualizer.plot_priority_counts(),
+                "type": visualizer.plot_type_counts(),
+                "created_timeline": visualizer.plot_created_timeline(),
+                "inactive": visualizer.plot_inactive_issues(days=inactive_days)
+            }
+            
+            # AI аналіз, якщо потрібен
+            ai_analysis = None
+            if include_ai and api_key:
+                from modules.ai_analysis.llm_connector import LLMConnector
+                llm = LLMConnector(api_key=api_key, model_type=model_type)
+                ai_analysis = llm.analyze_jira_data(stats, inactive_issues)
+            
+            # Генерація звіту
+            from modules.reporting.report_generator import ReportGenerator
+            report_generator = ReportGenerator(self.current_data, stats, inactive_issues, ai_analysis)
+            report = report_generator.create_markdown_report(inactive_days=inactive_days)
+            
+            # Зберігаємо поточний аналіз
+            self.current_analysis = {
+                "stats": stats,
+                "inactive_issues": inactive_issues,
+                "report": report,
+                "ai_analysis": ai_analysis
+            }
+            
+            # Зберігаємо інформацію про сесію
+            session_info = {
+                "session_id": self.current_session_id,
+                "file_path": str(file_path),
+                "file_name": Path(file_path).name,
+                "rows_count": len(self.current_data),
+                "columns_count": len(self.current_data.columns),
+                "indices_dir": getattr(self, "current_indices_dir", None),
+                "created_at": datetime.now().isoformat()
+            }
+            
+            # Зберігаємо інформацію про сесію у файл
+            sessions_dir = Path("temp/sessions")
+            sessions_dir.mkdir(exist_ok=True, parents=True)
+            session_file = sessions_dir / f"{self.current_session_id}.json"
+            
+            with open(session_file, "w", encoding="utf-8") as f:
+                json.dump(session_info, f, ensure_ascii=False, indent=2)
+            
+            return {
+                "report": report,
+                "visualizations": self.visualizations,
+                "ai_analysis": ai_analysis,
+                "error": None,
+                "session_id": self.current_session_id
+            }
+            
+        except Exception as e:
+            error_msg = f"Помилка аналізу: {str(e)}\n\n{traceback.format_exc()}"
+            logger.error(error_msg)
+            return {"error": error_msg}
+
+    def save_report(self, format_type="markdown", include_visualizations=True, filepath=None):
+        """
+        Збереження звіту у файл
+        
+        Args:
+            format_type (str): Формат звіту ("markdown", "html", "pdf")
+            include_visualizations (bool): Чи включати візуалізації у звіт
+            filepath (str): Шлях для збереження файлу
+            
+        Returns:
+            str: Шлях до збереженого файлу або повідомлення про помилку
+        """
+        try:
+            if not self.current_analysis or "report" not in self.current_analysis:
+                return "Помилка: спочатку виконайте аналіз даних"
+            
+            # Створення імені файлу, якщо не вказано
+            if not filepath:
+                timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                report_filename = f"jira_report_{timestamp}"
+                reports_dir = Path("reports")
+                
+                if format_type == "markdown":
+                    filepath = reports_dir / f"{report_filename}.md"
+                elif format_type == "html":
+                    filepath = reports_dir / f"{report_filename}.html"
+                elif format_type == "pdf":
+                    filepath = reports_dir / f"{report_filename}.pdf"
+            
+            # Створення генератора звітів
+            report_generator = ReportGenerator(
+                self.current_data,
+                self.current_analysis.get("stats"),
+                self.current_analysis.get("inactive_issues"),
+                self.current_analysis.get("ai_analysis")
+            )
+            
+            # Збереження звіту
+            saved_path = report_generator.save_report(
+                filepath=filepath,
+                format=format_type,
+                include_visualizations=include_visualizations,
+                visualization_data=self.visualizations if include_visualizations else None
+            )
+            
+            if saved_path:
+                return f"Звіт успішно збережено: {saved_path}"
+            else:
+                return "Не вдалося зберегти звіт"
+            
+        except Exception as e:
+            error_msg = f"Помилка при збереженні звіту: {str(e)}\n\n{traceback.format_exc()}"
+            logger.error(error_msg)
+            return error_msg
+    
+    def test_jira_connection(self, jira_url, username, api_token):
+        """
+        Тестування підключення до Jira
+        
+        Args:
+            jira_url (str): URL сервера Jira
+            username (str): Ім'я користувача
+            api_token (str): API токен
+            
+        Returns:
+            bool: True якщо підключення успішне, False інакше
+        """
+        from modules.data_import.jira_api import JiraConnector
+        return JiraConnector.test_connection(jira_url, username, api_token)
+
+    def generate_visualization(self, viz_type, limit=10, groupby="day"):
+        """
+        Генерація конкретної візуалізації
+        
+        Args:
+            viz_type (str): Тип візуалізації
+            limit (int): Ліміт для топ-N елементів
+            groupby (str): Групування для часових діаграм ('day', 'week', 'month')
+            
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure
+        """
+        if self.current_data is None:
+            logger.error("Немає даних для візуалізації")
+            return None
+        
+        # Створюємо візуалізатор
+        visualizer = JiraVisualizer(self.current_data)
+        
+        # Вибір типу візуалізації
+        if viz_type == "Статуси":
+            return visualizer.plot_status_counts()
+        elif viz_type == "Пріоритети":
+            return visualizer.plot_priority_counts()
+        elif viz_type == "Типи тікетів":
+            return visualizer.plot_type_counts()
+        elif viz_type == "Призначені користувачі":
+            return visualizer.plot_assignee_counts(limit=limit)
+        elif viz_type == "Активність створення":
+            return visualizer.plot_timeline(date_column='Created', groupby=groupby, cumulative=False)
+        elif viz_type == "Активність оновлення":
+            return visualizer.plot_timeline(date_column='Updated', groupby=groupby, cumulative=False)
+        elif viz_type == "Кумулятивне створення":
+            return visualizer.plot_timeline(date_column='Created', groupby=groupby, cumulative=True)
+        elif viz_type == "Неактивні тікети":
+            return visualizer.plot_inactive_issues()
+        elif viz_type == "Теплова карта: Типи/Статуси":
+            return visualizer.plot_heatmap(row_col='Issue Type', column_col='Status')
+        elif viz_type == "Часова шкала проекту":
+            timeline_plots = visualizer.plot_project_timeline()
+            return timeline_plots[0] if timeline_plots[0] is not None else None
+        elif viz_type == "Склад статусів з часом":
+            timeline_plots = visualizer.plot_project_timeline()
+            return timeline_plots[1] if timeline_plots[1] is not None else None
+        else:
+            logger.error(f"Невідомий тип візуалізації: {viz_type}")
+            return None
+
+    def generate_infographic(self):
+        """
+        Генерація інфографіки з основними показниками
+        
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure з інфографікою
+        """
+        if self.current_data is None or self.current_analysis is None:
+            logger.error("Немає даних для створення інфографіки")
+            return None
+        
+        visualizer = JiraVisualizer(self.current_data)
+        return visualizer.create_infographic(self.current_analysis["stats"])
+    
+    def generate_ai_report(self, api_key, model_type="gemini", temperature=0.2, custom_prompt=None):
+        """
+        Генерація AI-звіту на основі даних
+        
+        Args:
+            api_key (str): API ключ для LLM
+            model_type (str): Тип моделі ("openai" або "gemini")
+            temperature (float): Температура генерації
+            custom_prompt (str): Користувацький промпт
+            
+        Returns:
+            str: Згенерований звіт або повідомлення про помилку
+        """
+        try:
+            if self.current_data is None or self.current_analysis is None:
+                return "Помилка: спочатку виконайте аналіз даних"
+            
+            # Перевіряємо наявність індексів
+            indices_dir = getattr(self, "current_indices_dir", None)
+            
+            # Якщо індекси не створені, створюємо їх
+            if not indices_dir:
+                logger.info("Індекси не знайдено. Створюємо нові індекси.")
+                indices_result = self.index_manager.get_or_create_indices(
+                    self.current_data, 
+                    self.current_session_id or f"temp_{uuid.uuid4()}"
+                )
+                
+                if "error" in indices_result:
+                    logger.error(f"Помилка при створенні індексів: {indices_result['error']}")
+                    return f"Помилка при створенні індексів: {indices_result['error']}"
+                
+                indices_dir = indices_result["indices_dir"]
+                self.current_indices_dir = indices_dir
+            
+            # Імпортуємо AI асистента
+            JiraHybridChat
+
+            
+            # Створюємо AI асистента
+            ai_assistant = JiraHybridChat(
+                api_key_openai=api_key if model_type == "openai" else None,
+                api_key_gemini=api_key if model_type == "gemini" else None,
+                model_type=model_type,                temperature=temperature
+            )
+            
+            # Генеруємо звіт
+            report_result = ai_assistant.generate_report(
+                self.current_data,
+                indices_dir=indices_dir,
+                custom_prompt=custom_prompt
+            )
+            
+            if "error" in report_result:
+                logger.error(f"Помилка при генерації AI-звіту: {report_result['error']}")
+                return f"Помилка при генерації AI-звіту: {report_result['error']}"
+            
+            # Зберігаємо звіт
+            report_path = Path("reports") / f"ai_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
+            with open(report_path, "w", encoding="utf-8") as f:
+                f.write(report_result["report"])
+            
+            logger.info(f"AI-звіт успішно згенеровано та збережено: {report_path}")
+            
+            return report_result["report"]
+            
+        except Exception as e:
+            error_msg = f"Помилка при генерації AI-звіту: {str(e)}\n\n{traceback.format_exc()}"
+            logger.error(error_msg)
+            return error_msg
+    
+    def chat_with_data(self, question, api_key, model_type="gemini", temperature=0.2, chat_history=None):
+        """
+        Чат з даними через AI
+        
+        Args:
+            question (str): Питання користувача
+            api_key (str): API ключ для LLM
+            model_type (str): Тип моделі ("openai" або "gemini")
+            temperature (float): Температура генерації
+            chat_history (list): Історія чату
+            
+        Returns:
+            dict: Відповідь AI та метадані
+        """
+        try:
+            if self.current_data is None:
+                return {"error": "Помилка: спочатку виконайте аналіз даних"}
+            
+            # Перевіряємо наявність індексів
+            indices_dir = getattr(self, "current_indices_dir", None)
+            
+                       
+            ai_assistant = JiraHybridChat(
+                indices_dir=indices_dir,  # Передаємо індексну директорію
+                app=self,                 # Передаємо посилання на app
+                api_key_openai=api_key if model_type == "openai" else None,
+                api_key_gemini=api_key if model_type == "gemini" else None,
+                model_type=model_type,
+                temperature=temperature
+            )
+            
+            ai_assistant.df = self.current_data
+            
+            # Виконуємо чат
+            chat_result = ai_assistant.chat_with_hybrid_search(question, chat_history)
+            
+            if "error" in chat_result:
+                logger.error(f"Помилка при виконанні чату: {chat_result['error']}")
+                return {"error": f"Помилка при виконанні чату: {chat_result['error']}"}
+            
+            logger.info(f"Чат успішн�� виконано, токенів: {chat_result['metadata']['total_tokens']}")
+            
+            return chat_result
+            
+        except Exception as e:
+            error_msg = f"Помилка при виконанні чату: {str(e)}\n\n{traceback.format_exc()}"
+            logger.error(error_msg)
+            return {"error": error_msg}
+    
+    def get_data_statistics(self):
+        """
+        Отримання статистики даних
+        
+        Returns:
+            dict: Статистика даних
+        """
+        if self.current_data is None or self.current_analysis is None:
+            return {"error": "Немає даних для отримання статистики"}
+        
+        return self.current_analysis["stats"]
+    
+    def get_inactive_issues(self):
+        """
+        Отримання неактивних тікетів
+        
+        Returns:
+            dict: Неактивні тікети
+        """
+        if self.current_data is None or self.current_analysis is None:
+            return {"error": "Немає даних для отримання неактивних тікетів"}
+        
+        return self.current_analysis["inactive_issues"]
+    
+    def get_data_sample(self, rows=5):
+        """
+        Отримання зразка даних
+        
+        Args:
+            rows (int): Кількість рядків
+            
+        Returns:
+            dict: Зразок даних
+        """
+        if self.current_data is None:
+            return {"error": "Немає даних для отримання зразка"}
+        
+        try:
+            sample = self.current_data.head(rows).to_dict(orient="records")
+            return {"sample": sample, "columns": list(self.current_data.columns)}
+        except Exception as e:
+            return {"error": f"Помилка при отриманні зразка даних: {str(e)}"}
+    
+    def get_model_info(self, api_key, model_type="gemini"):
+        """
+        Отримання інформації про модель
+        
+        Args:
+            api_key (str): API ключ для LLM
+            model_type (str): Тип моделі ("openai" або "gemini")
+            
+        Returns:
+            dict: Інформація про модель
+        """
+        try:            
+            ai_assistant = JiraHybridChat(
+                api_key_openai=api_key if model_type == "openai" else None,
+                api_key_gemini=api_key if model_type == "gemini" else None,
+                model_type=model_type
+            )
+            
+            return ai_assistant.get_model_info()
+            
+        except Exception as e:
+            error_msg = f"Помилка при отриманні інформації про модель: {str(e)}"
+            logger.error(error_msg)
+            return {"error": error_msg}
+    
+    def check_api_keys(self, api_key_openai=None, api_key_gemini=None):
+        """
+        Перевірка API ключів
+        
+        Args:
+            api_key_openai (str): API ключ для OpenAI
+            api_key_gemini (str): API ключ для Gemini
+            
+        Returns:
+            dict: Результати перевірки
+        """
+        try:
+            
+            ai_assistant = JiraHybridChat(
+                api_key_openai=api_key_openai,
+                api_key_gemini=api_key_gemini
+            )
+            
+            return ai_assistant.check_api_keys()
+            
+        except Exception as e:
+            error_msg = f"Помилка при перевірці API ключів: {str(e)}"
+            logger.error(error_msg)
+            return {"error": error_msg}
+    
+    def cleanup_old_indices(self, max_age_days=7, max_indices=20):
+        """
+        Очищення застарілих індексів
+        
+        Args:
+            max_age_days (int): Максимальний вік індексів у днях
+            max_indices (int): Максимальна кількість індексів для зберігання
+            
+        Returns:
+            dict: Результат очищення
+        """
+        try:
+            deleted_count = self.index_manager.cleanup_old_indices(max_age_days, max_indices)
+            
+            logger.info(f"Очищено {deleted_count} застарілих індексів")
+            
+            return {
+                "success": True,
+                "deleted_count": deleted_count,
+                "message": f"Очищено {deleted_count} застарілих індексів"
+            }
+            
+        except Exception as e:
+            error_msg = f"Помилка при очищенні застарілих індексів: {str(e)}"
+            logger.error(error_msg)
+            return {"error": error_msg}

modules/ai_analysis/ai_assistant.py

@@ -0,0 +1,186 @@
+import logging
+import traceback
+import os
+import json
+from pathlib import Path
+import time
+from typing import Dict, List, Any, Optional, Tuple
+
+# Імпорт необхідних модулів для роботи з індексами
+from llama_index.core import (
+    StorageContext,
+    load_index_from_storage
+)
+from llama_index.retrievers.bm25 import BM25Retriever
+from llama_index.core.query_engine import RetrieverQueryEngine
+from llama_index.core.retrievers import QueryFusionRetriever
+from llama_index.core.llms import ChatMessage
+
+# Імпорт утиліт для роботи з індексами
+from modules.data_management.index_utils import (
+    check_indexing_availability, 
+    check_index_integrity,
+    count_tokens
+)
+
+# Імпорт налаштувань
+from modules.config.ai_settings import (
+    SIMILARITY_TOP_K,
+    HYBRID_SEARCH_MODE
+)
+from prompts import system_prompt_hybrid_chat
+
+# Налаштування логування
+logger = logging.getLogger(__name__)
+
+
+class JiraAIAssistant:
+    """
+    Клас для роботи з AI асистентом для аналізу даних Jira.
+    """
+    
+    def __init__(self, indices_dir=None, model_name="gpt-3.5-turbo", temperature=0.7):
+        """
+        Ініціалізація асистента.
+        
+        Args:
+            indices_dir (str): Шлях до директорії з індексами
+            model_name (str): Назва моделі для використання
+            temperature (float): Температура для генерації
+        """
+        self.indices_dir = indices_dir
+        self.model_name = model_name
+        self.temperature = temperature
+        self.index = None
+        self.bm25_retriever = None
+        
+        # Завантажуємо індекси, якщо вказано шлях
+        if indices_dir:
+            self.load_indices(indices_dir)
+    
+    def load_indices(self, indices_path):
+        """
+        Завантаження індексів з директорії.
+        
+        Args:
+            indices_path (str): Шлях до директорії з індексами
+            
+        Returns:
+            bool: True, якщо індекси успішно завантажено
+        """
+        try:
+            logger.info(f"Завантаження індексів з {indices_path}")
+            
+            # Перевіряємо наявність директорії
+            if not os.path.exists(indices_path):
+                logger.error(f"Директорія з індексами не існує: {indices_path}")
+                return False
+            
+            # Перевіряємо наявність файлу-маркера
+            marker_path = os.path.join(indices_path, "indices.valid")
+            if not os.path.exists(marker_path):
+                logger.error(f"Файл-маркер індексів не знайдено: {marker_path}")
+                return False
+            
+            # Імпортуємо необхідні модулі
+            from llama_index.core import VectorStoreIndex, StorageContext
+            from llama_index.retrievers.bm25 import BM25Retriever
+            
+            try:
+                # Завантажуємо індекс
+                storage_context = StorageContext.from_defaults(persist_dir=str(indices_path))
+                self.index = VectorStoreIndex.from_storage_context(storage_context)
+                
+                # Завантажуємо BM25 retriever
+                docstore = storage_context.docstore
+                
+                # Завантажуємо параметри BM25
+                bm25_dir = os.path.join(indices_path, "bm25")
+                bm25_params_path = os.path.join(bm25_dir, "params.json")
+                
+                if os.path.exists(bm25_params_path):
+                    with open(bm25_params_path, "r", encoding="utf-8") as f:
+                        bm25_params = json.load(f)
+                    
+                    similarity_top_k = bm25_params.get("similarity_top_k", 10)
+                else:
+                    similarity_top_k = 10
+                
+                self.bm25_retriever = BM25Retriever.from_defaults(
+                    docstore=docstore,
+                    similarity_top_k=similarity_top_k
+                )
+                
+                logger.info(f"Індекси успішно завантажено з {indices_path}")
+                return True
+                
+            except Exception as e:
+                logger.error(f"Помилка при завантаженні індексів: {e}")
+                logger.error(traceback.format_exc())
+                return False
+                
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні індексів: {e}")
+            logger.error(traceback.format_exc())
+            return False
+    
+    def chat(self, query, history=None):
+        """
+        Відповідь на запит користувача з використанням індексів.
+        
+        Args:
+            query (str): Запит користувача
+            history (list, optional): Історія чату
+            
+        Returns:
+            str: Відповідь асистента
+        """
+        try:
+            if not self.index or not self.bm25_retriever:
+                return "Індекси не завантажено. Будь ласка, завантажте дані."
+            
+            # Отримуємо відповідні документи
+            bm25_results = self.bm25_retriever.retrieve(query)
+            vector_results = self.index.as_retriever().retrieve(query)
+            
+            # Об'єднуємо результати
+            all_results = list(bm25_results) + list(vector_results)
+            
+            # Видаляємо дублікати
+            unique_results = []
+            seen_ids = set()
+            for result in all_results:
+                if result.node_id not in seen_ids:
+                    unique_results.append(result)
+                    seen_ids.add(result.node_id)
+            
+            # Обмежуємо кількість результатів
+            unique_results = unique_results[:10]
+            
+            # Формуємо контекст
+            context = "\n\n".join([result.get_content() for result in unique_results])
+            
+            
+            # Формуємо промпт
+            prompt = f"""Використовуй надану інформацію для відповіді на запитання.
+
+Контекст:
+{context}
+
+Запитання: {query}
+
+Дай детальну відповідь на запитання, використовуючи тільки інформацію з контексту. Якщо інформації недостатньо, скажи про це.
+"""
+            
+            # Отримуємо відповідь від моделі
+            from llama_index.llms.openai import OpenAI
+            
+            llm = OpenAI(model=self.model_name, temperature=self.temperature)
+            response = llm.complete(prompt)
+            
+            return response.text
+            
+        except Exception as e:
+            logger.error(f"Помилка при обробці запиту: {e}")
+            logger.error(traceback.format_exc())
+            return f"Виникла помилка при обробці запиту: {str(e)}"

modules/ai_analysis/ai_assistant_integration_mod.py

@@ -0,0 +1,838 @@
+import os
+import logging
+import gradio as gr
+from pathlib import Path
+import traceback
+from datetime import datetime
+import pandas as pd
+import uuid
+import json
+from typing import Dict, List, Any, Optional, Tuple, Union
+from modules.ai_analysis.jira_hybrid_chat import JiraHybridChat
+
+from modules.config.ai_settings import (
+    SIMILARITY_TOP_K
+)
+
+
+# Налаштування логування
+logger = logging.getLogger("jira_assistant_interface")
+
+# Імпорт необхідних модулів
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    logger.warning("Не вдалося імпортувати python-dotenv. Змінні середовища не будуть завантажені з .env файлу.")
+
+try:
+    from modules.ai_analysis.jira_ai_report import JiraAIReport
+    REPORT_MODULE_AVAILABLE = True
+    logger.info("Успішно імпортовано JiraAIReport")
+except ImportError:
+    REPORT_MODULE_AVAILABLE = False
+    logger.warning("Модуль JiraAIReport недоступний. Буде використано стандартний JiraAIAssistant для звітів.")
+
+
+# Імпорт спеціалізованого Q/A асистента, якщо він доступний
+try:
+    from modules.ai_analysis.jira_qa_assistant import JiraQAAssistant
+    QA_ASSISTANT_AVAILABLE = True
+    logger.info("Успішно імпортовано JiraQAAssistant")
+except ImportError:
+    QA_ASSISTANT_AVAILABLE = False
+    logger.warning("Модуль JiraQAAssistant недоступний. Буде використано стандартний JiraAIAssistant для Q/A.")
+
+# Імпорт LlamaIndex компонентів (перевірка чи доступні)
+try:
+    from llama_index.core import Document, VectorStoreIndex, Settings
+    from llama_index.core.llms import ChatMessage
+    LLAMA_INDEX_AVAILABLE = True
+except ImportError:
+    LLAMA_INDEX_AVAILABLE = False
+    logger.warning("LlamaIndex не доступний. Деякі функції можуть бути недоступні.")
+
+# Допоміжні функції
+def strip_assistant_prefix(text):
+    """Видаляє префікс 'assistant:' з тексту відповіді"""
+    if isinstance(text, str) and text.startswith("assistant:"):
+        return text.replace("assistant:", "", 1).strip()
+    return text
+
+def get_indices_dir(timestamp=None):
+    """
+    Формує шлях до директорії для збереження індексів.
+    
+    Args:
+        timestamp (str, optional): Часова мітка для унікальної ідентифікації. 
+                                Якщо None, буде створена автоматично.
+                                
+    Returns:
+        str: Шлях до директорії індексів
+    """
+    # Якщо часова мітка не вказана, створюємо нову
+    if timestamp is None:
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+    
+    # Формуємо шлях до директорії
+    indices_dir = Path("temp") / "indices" / timestamp
+    
+    # Створюємо директорію, якщо вона не існує
+    os.makedirs(indices_dir, exist_ok=True)
+    
+    return str(indices_dir)
+
+# Функції для роботи з індексами FAISS
+def try_import_faiss_utils():
+    """Імпортує FAISS утиліти, якщо вони доступні"""
+    try:
+        from modules.ai_analysis.faiss_utils import (
+            find_latest_indices, 
+            find_indices_by_hash, 
+            cleanup_old_indices, 
+            generate_file_hash,
+            save_indices_metadata
+        )
+        return {
+            "find_latest_indices": find_latest_indices,
+            "find_indices_by_hash": find_indices_by_hash,
+            "cleanup_old_indices": cleanup_old_indices,
+            "generate_file_hash": generate_file_hash,
+            "save_indices_metadata": save_indices_metadata
+        }
+    except ImportError as faiss_err:
+        logger.warning(f"Не вдалося імпортувати FAISS утиліти: {faiss_err}. Будуть використані стандартні методи.")
+        return None
+    
+# Клас для управління сесіями
+class UserSessionManager:
+    """Управління сесіями користувачів"""
+    
+    def __init__(self):
+        self.user_sessions = {}
+    
+    def get_or_create_user_session(self, user_id=None):
+        """
+        Отримує існуючу сесію або створює нову.
+        
+        Args:
+            user_id (str, optional): ID користувача. Якщо не вказано, генерується випадковий.
+            
+        Returns:
+            str: ID сесії
+        """
+        # Якщо ID користувача не вказано, гене��уємо випадковий
+        if not user_id:
+            user_id = str(uuid.uuid4())
+        
+        # Якщо сесія вже існує, повертаємо її
+        if user_id in self.user_sessions:
+            return self.user_sessions[user_id]
+        
+        # Інакше створюємо нову сесію
+        session_id = f"{user_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
+        self.user_sessions[user_id] = {"session_id": session_id, "chat_history": []}
+        
+        logger.info(f"Створено нову сесію {session_id} для користувача {user_id}")
+        return self.user_sessions[user_id]
+    
+    def get_chat_history(self, user_id):
+        """Отримує історію чату користувача"""
+        session = self.get_or_create_user_session(user_id)
+        return session.get("chat_history", [])
+    
+    def update_chat_history(self, user_id, message, response):
+        """Оновлює історію чату користувача"""
+        session = self.get_or_create_user_session(user_id)
+        
+        if "chat_history" not in session:
+            session["chat_history"] = []
+        
+        session["chat_history"].append({"role": "user", "content": message})
+        session["chat_history"].append({"role": "assistant", "content": response})
+        
+        return session["chat_history"]
+    
+# Клас для інтеграції AI асистентів
+class AIAssistantIntegration:
+    """Інтеграція різних AI асистентів та інтерфейсу"""
+    
+    def __init__(self, app):
+        """
+        Ініціалізація інтеграції.
+        
+        Args:
+            app: Екземпляр JiraAssistantApp
+        """
+        self.app = app
+        self.session_manager = UserSessionManager()
+        
+        # Отримуємо ключі API з .env
+        self.api_key_openai = os.getenv("OPENAI_API_KEY", "")
+        self.api_key_gemini = os.getenv("GEMINI_API_KEY", "")
+        
+        # Імпортуємо FAISS утиліти, якщо доступні
+        self.faiss_utils = try_import_faiss_utils()
+        self.faiss_utils_available = self.faiss_utils is not None
+        
+        if self.faiss_utils_available:
+            logger.info("FAISS утиліти успішно імпортовано")
+
+    def run_full_context_qa(self, question, model_type, temperature):
+        """
+        Запускає режим Q/A з повним контекстом.
+        
+        Args:
+            question (str): Питання користувача
+            model_type (str): Тип моделі
+            temperature (float): Температура генерації
+            
+        Returns:
+            str: Відповідь на питання
+        """
+        # Перевіряємо, чи є завантажений файл або дані
+        if (not hasattr(self.app, 'last_loaded_csv') or self.app.last_loaded_csv is None) and \
+           (not hasattr(self.app, 'current_data') or self.app.current_data is None):
+            return "Помилка: спочатку завантажте CSV файл у вкладці 'CSV Аналіз' або ініціалізуйте дані з локальних файлів"
+        
+        if not question or question.strip() == "":
+            return "Будь ласка, введіть питання."
+        
+        try:
+            # Перевіряємо доступність спеціалізованого Q/A асистента
+            if QA_ASSISTANT_AVAILABLE:
+                return self._run_qa_with_specialized_assistant(question, model_type, temperature)
+            else:
+                return self._run_qa_with_standard_assistant(question, model_type, temperature)
+                
+        except Exception as e:
+            error_msg = f"Помилка при виконанні запиту: {str(e)}\n\n{traceback.format_exc()}"
+            logger.error(error_msg)
+            return error_msg
+    
+    def _run_qa_with_specialized_assistant(self, question, model_type, temperature):
+            """Виконує Q/A з використанням спеціалізованого асистента JiraQAAssistant"""
+            qa_assistant = JiraQAAssistant(
+                api_key_openai=self.api_key_openai,
+                api_key_gemini=self.api_key_gemini,
+                model_type=model_type,
+                temperature=float(temperature)
+            )
+            
+            # Отримання даних для аналізу
+            if hasattr(self.app, 'current_data') and self.app.current_data is not None:
+                # Завантаження даних з DataFrame
+                logger.info("Використовуємо DataFrame з пам'яті для Q/A")
+                success = qa_assistant.load_documents_from_dataframe(self.app.current_data)
+                
+                if not success:
+                    return "Помилка: не вдалося завантажити дані з DataFrame"
+            else:
+                # Завантаження даних з файлу
+                temp_file_path = self.app.last_loaded_csv
+                if not os.path.exists(temp_file_path):
+                    return f"Помилка: файл {temp_file_path} не знайдено"
+                
+                # Зчитуємо DataFrame з файлу
+                df = pd.read_csv(temp_file_path)
+                success = qa_assistant.load_documents_from_dataframe(df)
+                
+                if not success:
+                    return "Помилка: не вдалося завантажити дані з CSV файлу"
+            
+            # Виконуємо Q/A запит
+            result = qa_assistant.run_qa(question)
+            
+            if "error" in result:
+                return f"Помилка: {result['error']}"
+            
+            # Форматуємо відповідь з інформацією про токени
+            answer = result["answer"]
+            answer = strip_assistant_prefix(answer)  # Видаляємо префікс "assistant:"
+            metadata = result["metadata"]
+            
+            tokens_info = f"\n\n---\n*Використано токенів: питання={metadata['question_tokens']}, "
+            tokens_info += f"контекст={metadata['context_tokens']}, "
+            tokens_info += f"відповідь={metadata['response_tokens']}, "
+            tokens_info += f"всього={metadata['total_tokens']}*"
+            
+            return answer + tokens_info    
+
+    def _run_qa_with_standard_assistant(self, question, model_type, temperature):   
+        """Виконує Q/A з використанням стандартного асистента JiraAIAssistant"""
+        
+        # Перевіряємо доступність індексів
+        indices_path = None
+        
+        # 1. Спочатку перевіряємо шлях до індексів в додатку
+        if hasattr(self.app, 'indices_path') and self.app.indices_path and os.path.exists(self.app.indices_path):
+            indices_path = self.app.indices_path
+            logger.info(f"Використовуємо наявні індекси з app.indices_path: {indices_path}")
+        
+        # 2. Перевіряємо індекси, пов'язані з сесією
+        elif hasattr(self.app, 'current_session_id') and self.app.current_session_id:
+            session_indices_dir = Path("temp/sessions") / self.app.current_session_id / "indices"
+            if session_indices_dir.exists():
+                indices_path = str(session_indices_dir)
+                logger.info(f"Використовуємо індекси сесії: {indices_path}")
+                # Зберігаємо шлях для майбутнього використання
+                self.app.indices_path = indices_path
+        
+        # 3. Якщо є шлях до завантаженого файлу, шукаємо індекси для нього
+        elif hasattr(self.app, 'last_loaded_csv') and self.app.last_loaded_csv and os.path.exists(self.app.last_loaded_csv):
+            if self.faiss_utils_available:
+                try:
+                    file_path = self.app.last_loaded_csv
+                    csv_hash = self.faiss_utils["generate_file_hash"](file_path)
+                    if csv_hash:
+                        indices_exist, found_indices_path = self.faiss_utils["find_indices_by_hash"](csv_hash)
+                        if indices_exist:
+                            indices_path = found_indices_path
+                            logger.info(f"Знайдено індекси за хешем CSV: {indices_path}")
+                            # Зберігаємо шлях для майбутнього використання
+                            self.app.indices_path = indices_path
+                except Exception as e:
+                    logger.warning(f"Помилка при пошуку індексів за хешем: {e}")
+        
+        # Підготовка об'єкту для кешування індексів, якщо його немає
+        if not hasattr(self, "_indices_cache"):
+            self._indices_cache = {}
+        
+        # Пріоритет віддаємо кешованим індексам
+        assistant = None
+        if indices_path and indices_path in self._indices_cache:
+            # Використовуємо кешований асистент
+            assistant = self._indices_cache[indices_path]
+            
+            # Оновлюємо параметри
+            assistant.model_type = model_type
+            assistant.temperature = float(temperature)
+            assistant._initialize_llm()
+            
+            logger.info(f"Використовуємо кешований асистент для {indices_path}")
+        else:
+            # Створення нового асистента
+            assistant = JiraHybridChat(
+                api_key_openai=self.api_key_openai,
+                api_key_gemini=self.api_key_gemini,
+                model_type=model_type,
+                temperature=float(temperature)
+            )
+            
+            # Спроба використання індексів
+            if indices_path and os.path.exists(indices_path):
+                # Завантажуємо індекси
+                logger.info(f"Спроба завантажити індекси з шляху: {indices_path}")
+                success = assistant.load_indices(indices_path)
+                
+                if success and hasattr(assistant, 'index') and assistant.index is not None:
+                    logger.info(f"Успішно завантажено індекси з {indices_path}")
+                    
+                    # Також завантажуємо DataFrame для повної функціональності
+                    if hasattr(self.app, 'current_data') and self.app.current_data is not None:
+                        assistant.df = self.app.current_data
+                    
+                    # Додаємо в кеш
+                    self._indices_cache[indices_path] = assistant
+                    logger.info(f"Додано асистента в кеш для {indices_path}")
+                else:
+                    logger.warning(f"Не вдалося завантажити індекси з {indices_path}")
+        
+        # Якщо не вдалося завантажити індекси, завантажуємо дані напряму
+        if not hasattr(assistant, 'index') or assistant.index is None:
+            if hasattr(self.app, 'current_data') and self.app.current_data is not None:
+                # Завантаження даних з DataFrame
+                logger.info("Використовуємо DataFrame з пам'яті")
+                success = assistant.load_data_from_dataframe(self.app.current_data)
+                
+                if not success:
+                    return "Помилка: не вдалося завантажити дані з DataFrame"
+            else:
+                # Завантаження даних з файлу
+                temp_file_path = self.app.last_loaded_csv
+                if not os.path.exists(temp_file_path):
+                    return f"Помилка: файл {temp_file_path} не знайдено"
+                
+                # Завантаження даних з CSV
+                success = assistant.load_data_from_csv(temp_file_path)
+                
+                if not success:
+                    return "Помилка: не вдалося завантажити дані з CSV-файлу. Перевірте формат файлу."
+        
+        # Виконуємо запит
+        result = assistant.run_full_context_qa(question)
+        
+        if "error" in result:
+            return f"Помилка: {result['error']}"
+        
+        # Форматуємо відповідь з інформацією про токени
+        answer = result["answer"]
+        answer = strip_assistant_prefix(answer)  # Видаляємо префікс "assistant:"
+        metadata = result["metadata"]
+        
+        tokens_info = f"\n\n---\n*Використано токенів: питання={metadata['question_tokens']}, "
+        tokens_info += f"контекст={metadata['context_tokens']}, "
+        tokens_info += f"відповідь={metadata['response_tokens']}, "
+        tokens_info += f"всього={metadata['total_tokens']}*"
+        
+        # Зберігаємо індекси, якщо вони створені і ще не збережені
+        if not indices_path and hasattr(assistant, 'index') and assistant.index is not None:
+            if self.faiss_utils_available and hasattr(self.app, 'last_loaded_csv'):
+                try:
+                    file_path = self.app.last_loaded_csv
+                    csv_hash = self.faiss_utils["generate_file_hash"](file_path)
+                    
+                    if csv_hash and hasattr(assistant, 'save_indices'):
+                        logger.info("Зберігаємо індекси для майбутнього використання")
+                        new_indices_dir = get_indices_dir()
+                        if assistant.save_indices(new_indices_dir):
+                            # Збережемо метадані з хешем CSV
+                            metadata_obj = {
+                                "created_at": datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                                "csv_hash": csv_hash,
+                                "document_count": len(assistant.jira_documents) if hasattr(assistant, 'jira_documents') else 0,
+                                "storage_format": "binary"  # Додаємо інформацію про формат зберігання
+                            }
+                            self.faiss_utils["save_indices_metadata"](new_indices_dir, metadata_obj)
+                            logger.info(f"Індекси збережено у {new_indices_dir}")
+                            
+                            # Зберігаємо шлях для майбутнього використання
+                            self.app.indices_path = new_indices_dir
+                            
+                            # Додаємо в кеш
+                            self._indices_cache[new_indices_dir] = assistant
+                            
+                            # Очистимо старі індекси
+                            self.faiss_utils["cleanup_old_indices"](max_indices=3)
+                except Exception as save_err:
+                    logger.warning(f"Помилка при збереженні індексів: {save_err}")
+        
+        return answer + tokens_info
+
+    def process_chat_message(self, message, chat_history, model_type, temperature):
+        """
+        Обробка повідомлення користувача в чаті.
+        
+        Args:
+            message (str): Повідомлення користувача
+            chat_history (list): Історія чату у форматі Gradio
+            model_type (str): Тип моделі
+            temperature (float): Температура генерації
+            
+        Returns:
+            tuple: (очищене поле вводу, оновлена історія чату)
+        """
+        if not message or message.strip() == "":
+            return "", chat_history
+        
+        # Перевіряємо, чи є завантажений файл або дані
+        if (not hasattr(self.app, 'last_loaded_csv') or self.app.last_loaded_csv is None) and \
+        (not hasattr(self.app, 'current_data') or self.app.current_data is None):
+            chat_history.append((message, "Помилка: спочатку завантажте CSV файл у вкладці 'CSV Аналіз' або ініціалізуйте дані з локальних файлів"))
+            return "", chat_history
+        
+        try:
+            # Використовуємо jira_hybrid_chat для обробки запиту
+            from modules.ai_analysis.jira_hybrid_chat import JiraHybridChat
+            
+            # Створюємо екземпляр чату з передачею app
+            chat = JiraHybridChat(
+                indices_dir=self.app.indices_path if hasattr(self.app, 'indices_path') else None,
+                app=self.app,  # Передаємо app для доступу до current_data
+                api_key_openai=self.api_key_openai,
+                api_key_gemini=self.api_key_gemini,
+                model_type=model_type,
+                temperature=float(temperature)
+            )
+            
+            # Конвертуємо історію чату у формат для асистента
+            formatted_history = []
+            for user_msg, ai_msg in chat_history:
+                formatted_history.append({"role": "user", "content": user_msg})
+                formatted_history.append({"role": "assistant", "content": ai_msg})
+            
+            # Отримуємо відповідь
+            result = chat.chat_with_hybrid_search(message, formatted_history)
+            
+            if "error" in result:
+                chat_history.append((message, f"Помилка: {result['error']}"))
+                return "", chat_history
+            
+            # Форматуємо відповідь з інформацією про токени
+            answer = result["answer"]
+            metadata = result["metadata"]
+            
+            # Додаємо інформацію про релевантні документи
+            docs_info = "\n\n*Релевантні документи:*\n"
+            if "relevant_documents" in metadata:
+                for doc in metadata['relevant_documents'][:SIMILARITY_TOP_K]:  # Показуємо топ-3 документа
+                    docs_info += f"*{doc.get('rank', '?')}.* [{doc.get('ticket_id', '?')}](https://jira.healthprecision.net/browse/{doc.get('ticket_id', '?')}) "
+                    docs_info += f"(релевантність: {doc.get('relevance', 0):.4f}): {doc.get('summary', '')[:50]}...\n"
+            
+            # Додаємо інформацію про токени
+            tokens_info = f"\n\n---\n*Використано токенів: питання={metadata.get('question_tokens', 0)}, "
+            tokens_info += f"контекст={metadata.get('context_tokens', 0)}, "
+            tokens_info += f"відповідь={metadata.get('response_tokens', 0)}, "
+            tokens_info += f"всього={metadata.get('total_tokens', 0)}*"
+            
+            # Формуємо повну відповідь
+            full_answer = answer + docs_info + tokens_info
+            
+            # Оновлюємо історію чату
+            chat_history.append((message, full_answer))
+            
+            # Зберігаємо індекси, якщо вони створені і ще не збережені
+            if not hasattr(self.app, 'indices_path') and hasattr(chat, 'index') and chat.index is not None:
+                if hasattr(self, 'faiss_utils_available') and self.faiss_utils_available and hasattr(self.app, 'last_loaded_csv'):
+                    try:
+                        file_path = self.app.last_loaded_csv
+                        csv_hash = self.faiss_utils["generate_file_hash"](file_path)
+                        
+                        if csv_hash and hasattr(chat, 'save_indices'):
+                            logger.info("Зберігаємо індекси для майбутнього використання")
+                            new_indices_dir = get_indices_dir()
+                            if chat.save_indices(new_indices_dir):
+                                # Збережемо метадані з хешем CSV
+                                metadata_obj = {
+                                    "created_at": datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                                    "csv_hash": csv_hash,
+                                    "document_count": len(chat.jira_documents) if hasattr(chat, 'jira_documents') else 0,
+                                    "storage_format": "binary"
+                                }
+                                self.faiss_utils["save_indices_metadata"](new_indices_dir, metadata_obj)
+                                logger.info(f"Індекси збережено у {new_indices_dir}")
+                                
+                                # Зберігаємо шлях для майбутнього використання
+                                self.app.indices_path = new_indices_dir
+                    except Exception as save_err:
+                        logger.warning(f"Помилка при збереженні індексів: {save_err}")
+            
+            return "", chat_history
+            
+        except Exception as e:
+            import traceback
+            error_msg = f"Помилка при обробці повідомлення: {str(e)}\n\n{traceback.format_exc()}"
+            logger.error(error_msg)
+            chat_history.append((message, f"Помилка: {str(e)}"))
+            return "", chat_history
+    
+    def generate_ai_report(self, format_type, model_type, temperature):
+        """
+        Генерація аналітичного звіту на основі даних Jira.
+        
+        Args:
+            format_type (str): Формат звіту ("markdown", "html")
+            model_type (str): Тип моделі для використання
+            temperature (float): Температура для генерації
+            
+        Returns:
+            str: Згенерований звіт або повідомлення про помилку
+        """
+        try:
+            # Перевіряємо, чи є завантажений файл або дані
+            if (not hasattr(self.app, 'last_loaded_csv') or self.app.last_loaded_csv is None) and \
+            (not hasattr(self.app, 'current_data') or self.app.current_data is None):
+                return "Помилка: спочатку завантажте CSV файл у вкладці 'CSV Аналіз' або ініціалізуйте дані з локальних файлів"
+            
+            # Використовуємо спеціалізований генератор звітів, якщо доступний
+            if REPORT_MODULE_AVAILABLE:
+                logger.info("Використовуємо спеціалізований модуль JiraAIReport для генерації звіту")
+                
+                # Створення генератора звітів
+                report_generator = JiraAIReport(
+                    api_key_openai=self.api_key_openai,
+                    api_key_gemini=self.api_key_gemini,
+                    model_type=model_type,
+                    temperature=float(temperature)
+                )
+                
+                # Завантаження даних
+                if hasattr(self.app, 'current_data') and self.app.current_data is not None:
+                    # Завантаження даних з DataFrame
+                    logger.info("Використовуємо DataFrame з пам'яті для генерації звіту")
+                    success = report_generator.load_documents_from_dataframe(self.app.current_data)
+                    
+                    if not success:
+                        return "Помилка: не вдалося завантажити дані з DataFrame"
+                else:
+                    # Завантаження даних з файлу
+                    logger.info(f"Читаємо CSV файл: {self.app.last_loaded_csv}")
+                    df = pd.read_csv(self.app.last_loaded_csv)
+                    success = report_generator.load_documents_from_dataframe(df)
+                    
+                    if not success:
+                        return "Помилка: не вдалося завантажити дані з CSV файлу"
+                
+                # Генерація звіту
+                result = report_generator.generate_report(format_type=format_type)
+                
+                if "error" in result:
+                    return f"Помилка: {result['error']}"
+                
+                # Форматуємо відповідь з інформацією про токени
+                report = result["report"]
+                report = strip_assistant_prefix(report)  # Видаляємо префікс "assistant:"
+                metadata = result["metadata"]
+                
+                # Додаємо інформацію про токени
+                tokens_info = f"\n\n---\n*Використано токенів: контекст={metadata['context_tokens']}, "
+                tokens_info += f"звіт={metadata['report_tokens']}, "
+                tokens_info += f"всього={metadata['total_tokens']}, "
+                tokens_info += f"проаналізовано документів: {metadata['documents_used']}*"
+                
+                if format_type.lower() == "markdown":
+                    return report + tokens_info
+                else:
+                    # Для HTML додаємо інформацію про токени внизу
+                    tokens_html = f'<div style="margin-top: 20px; color: #666; font-size: 0.9em;">'
+                    tokens_html += f'Використано токенів: контекст={metadata["context_tokens"]}, '
+                    tokens_html += f'звіт={metadata["report_tokens"]}, '
+                    tokens_html += f'всього={metadata["total_tokens"]}, '
+                    tokens_html += f'проаналізовано документів: {metadata["documents_used"]}'
+                    tokens_html += '</div>'
+                    
+                    return report + tokens_html
+            else:
+                # Використовуємо стандартний механізм генерації звітів
+                logger.warning("Модуль JiraAIReport недоступний, використовуємо стандартний JiraAIAssistant")
+                                
+                # Створення асистента
+                assistant = JiraHybridChat(
+                    api_key_openai=self.api_key_openai,
+                    api_key_gemini=self.api_key_gemini,
+                    model_type=model_type,
+                    temperature=float(temperature)
+                )
+                
+                # Завантаження даних
+                if hasattr(self.app, 'current_data') and self.app.current_data is not None:
+                    # Завантаження даних з DataFrame
+                    success = assistant.load_data_from_dataframe(self.app.current_data)
+                    
+                    if not success:
+                        return "Помилка: не вдалося завантажити дані з DataFrame"
+                else:
+                    # Завантаження даних з файлу
+                    success = assistant.load_data_from_csv(self.app.last_loaded_csv)
+                    
+                    if not success:
+                        return "Помилка: не вдалося завантажити дані з файлу"
+                
+                # Отримуємо статистику для звіту
+                stats = assistant.get_statistics()
+                
+                # Підготовка даних для звіту
+                data_summary = f"СТАТИСТИКА ПРОЕКТУ JIRA:\n\n"
+                data_summary += f"Загальна кількість тікетів: {stats['document_count']}\n\n"
+                
+                data_summary += "Розподіл за статусами:\n"
+                for status, count in stats['status_counts'].items():
+                    percentage = (count / stats['document_count'] * 100) if stats['document_count'] > 0 else 0
+                    data_summary += f"- {status}: {count} ({percentage:.1f}%)\n"
+                
+                data_summary += "\nРозподіл за типами:\n"
+                for type_name, count in stats['type_counts'].items():
+                    percentage = (count / stats['document_count'] * 100) if stats['document_count'] > 0 else 0
+                    data_summary += f"- {type_name}: {count} ({percentage:.1f}%)\n"
+                
+                data_summary += "\nРозподіл за пріоритетами:\n"
+                for priority, count in stats['priority_counts'].items():
+                    percentage = (count / stats['document_count'] * 100) if stats['document_count'] > 0 else 0
+                    data_summary += f"- {priority}: {count} ({percentage:.1f}%)\n"
+                
+                data_summary += "\nТоп виконавці завдань:\n"
+                for assignee, count in stats['top_assignees'].items():
+                    data_summary += f"- {assignee}: {count} тікетів\n"
+                
+                # Генерація звіту
+                result = assistant.generate_report(data_summary, format_type=format_type)
+                
+                if "error" in result:
+                    return f"Помилка: {result['error']}"
+                
+                # Форматуємо відповідь з інформацією про токени
+                report = result["report"]
+                report = strip_assistant_prefix(report)  # Видаляємо префікс "assistant:"
+                metadata = result["metadata"]
+                
+                # Додаємо інформацію про токени
+                tokens_info = f"\n\n---\n*Використано токенів: контекст={metadata['context_tokens']}, "
+                tokens_info += f"звіт={metadata['report_tokens']}, "
+                tokens_info += f"всього={metadata['total_tokens']}*"
+                
+                if format_type.lower() == "markdown":
+                    return report + tokens_info
+                else:
+                    # Для HTML додаємо інформацію про токени внизу
+                    tokens_html = f'<div style="margin-top: 20px; color: #666; font-size: 0.9em;">'
+                    tokens_html += f'Використано токенів: контекст={metadata["context_tokens"]}, '
+                    tokens_html += f'звіт={metadata["report_tokens"]}, '
+                    tokens_html += f'всього={metadata["total_tokens"]}'
+                    tokens_html += '</div>'
+                    
+                    return report + tokens_html
+                    
+        except Exception as e:
+            error_msg = f"Помилка при генерації звіту: {str(e)}\n\n{traceback.format_exc()}"
+            logger.error(error_msg)
+            return error_msg
+
+def setup_ai_assistant_tab(app, interface):
+    """
+    Налаштування вкладки AI асистентів з підтримкою Q/A, чату та звітів.
+    
+    Args:
+        app: Екземпляр JiraAssistantApp
+        interface: Блок інтерфейсу Gradio
+    
+    Returns:
+        bool: True якщо ініціалізація пройшла успішно
+    """
+    try:
+        # Створюємо інтеграцію AI асистента
+        ai_integration = AIAssistantIntegration(app)
+        
+        # Створюємо вкладку для AI асистентів
+        with gr.Tab("AI Асистенти"):
+            gr.Markdown("## AI Асистенти для Jira")
+            
+            # Спільні параметри для всіх режимів (в один рядок)
+            with gr.Row():
+                model_type = gr.Dropdown(
+                    choices=["gemini", "openai"],
+                    value="gemini",
+                    label="Модель LLM",
+                    scale=1
+                )
+                temperature = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.0,
+                    value=0.2,
+                    step=0.1,
+                    label="Температура",
+                    scale=2
+                )
+            
+            # Інформація про необхідність завантажити файл
+            gr.Markdown("""
+            **❗ Примітка:** Для роботи AI асистентів спочатку завантажте CSV файл у вкладці "CSV Аналіз" або ініціалізуйте дані з локальних файлів
+            """)
+            
+            # Розділяємо режими по вкладках
+            with gr.Tabs():
+                with gr.Tab("Q/A з повним контекстом"):
+                    gr.Markdown("""
+                    **У цьому режимі бот має доступ до всіх даних тікетів одночасно.**
+                    
+                    Використовуйте цей режим для загальних питань про проект, 
+                    статистику, тренди та загальний аналіз.
+                    """)
+                    
+                    qa_question = gr.Textbox(
+                        label="Ваше питання",
+                        placeholder="Наприклад: Які тікети мають найвищий пріоритет?",
+                        lines=3
+                    )
+                    qa_button = gr.Button("Отримати відповідь")
+                    qa_answer = gr.Markdown(label="Відповідь")
+                    
+                    # Прив'язуємо обробник
+                    qa_button.click(
+                        ai_integration.run_full_context_qa,
+                        inputs=[qa_question, model_type, temperature],
+                        outputs=[qa_answer]
+                    )
+                
+                with gr.Tab("Гібридний чат"):
+                    gr.Markdown("""
+                    **У цьому режимі бот використовує гібридний пошук (BM25 + векторний) для кращої якості результатів.**
+                    
+                    Гібридний пошук поєднує переваги пошуку за ключовими словами та семантичного векторного пошуку.
+                    Підходить для більшості запитів, забезпечуючи високу релевантність відповідей.
+                    """)
+                    
+                    # Використовуємо компонент Chatbot для історії повідомлень
+                    chatbot = gr.Chatbot(
+                        height=500,
+                        avatar_images=["Human:", "AI:"]
+                    )
+                    
+                    # Поле для вводу повідомлення
+                    msg = gr.Textbox(
+                        placeholder="Після введення питанні натисність Shift+Enter",
+                        lines=2,
+                        show_label=False,
+                    )
+
+                    # Кнопка очищення історії
+                    clear = gr.Button("Очистити історію")
+                    
+                    # Прив'язуємо обробники
+                    msg.submit(
+                        ai_integration.process_chat_message,
+                        inputs=[msg, chatbot, model_type, temperature],
+                        outputs=[msg, chatbot]
+                    )
+                    
+                    # Функція для очищення історії чату
+                    clear.click(lambda: [], None, chatbot, queue=False)
+                
+                with gr.Tab("Генерація звіту"):
+                    gr.Markdown("""
+                    **Автоматична генерація аналітичного звіту на основі даних Jira.**
+                    
+                    AI проаналізує дані CSV файлу та створить структурований звіт.
+                    """)
+                    
+                    with gr.Row():
+                        format_type = gr.Radio(
+                            choices=["markdown", "html"],
+                            value="markdown",
+                            label="Формат звіту"
+                        )
+                    
+                    report_button = gr.Button("Згенерувати звіт")
+                    ai_report = gr.Markdown(label="Звіт", elem_id="ai_report_output")
+                    
+                    # Додаємо CSS для стилізації звіту
+                    gr.HTML("""
+                    <style>
+                    #ai_report_output {
+                        height: 600px;
+                        overflow-y: auto;
+                        border: 1px solid #ddd;
+                        padding: 20px;
+                        border-radius: 4px;
+                        background-color: #f9f9f9;
+                    }
+                    </style>
+                    """)
+                    
+                    # Прив'язуємо обробник
+                    report_button.click(
+                        ai_integration.generate_ai_report,
+                        inputs=[format_type, model_type, temperature],
+                        outputs=[ai_report]
+                    )
+        
+        return True
+        
+    except ImportError as e:
+        logger.error(f"Помилка імпорту модулів для AI асистента: {e}")
+        
+        # Якщо не вдалося імпортувати модулі, створюємо заглушку
+        with gr.Tab("AI Асистенти"):
+            gr.Markdown("## AI Асистенти для Jira")
+            gr.Markdown(f"""
+            ### ⚠️ Потрібні додаткові залежності
+            
+            Для роботи AI асистентів потрібно встановити додаткові бібліотеки:
+            
+            ```bash
+            pip install llama-index-llms-gemini llama-index llama-index-embeddings-openai llama-index-retrievers-bm25 llama-index-vector-stores-faiss faiss-cpu tiktoken
+            ```
+            
+            Помилка: {str(e)}
+            """)
+        
+        return False

modules/ai_analysis/ai_assistant_methods.py

@@ -0,0 +1,137 @@
+# Методи для додавання до класу JiraAIAssistant
+# Ці методи потрібно додати до існуючого файлу ai_assistant.py
+
+def load_indices(self, indices_dir):
+    """
+    Завантаження індексів з директорії.
+    
+    Args:
+        indices_dir (str): Шлях до директорії з індексами
+        
+    Returns:
+        bool: True, якщо індекси успішно завантажено, False інакше
+    """
+    try:
+        from llama_index.core import load_index_from_storage
+        from llama_index.core.storage import StorageContext
+        
+        logger.info(f"Завантаження індексів з директорії: {indices_dir}")
+        
+        # Перевірка наявності директорії
+        if not os.path.exists(indices_dir):
+            logger.error(f"Директорія індексів не існує: {indices_dir}")
+            return False
+        
+        # Перевірка наявності необхідних файлів
+        required_files = ["docstore.json"]
+        for file in required_files:
+            if not os.path.exists(os.path.join(indices_dir, file)):
+                logger.error(f"Відсутній необхідний файл: {file}")
+                return False
+        
+        # Завантажуємо контекст зберігання
+        storage_context = StorageContext.from_defaults(persist_dir=indices_dir)
+        
+        # Завантажуємо індекс
+        self.index = load_index_from_storage(storage_context)
+        
+        # Отримуємо docstore з контексту зберігання
+        self.docstore = storage_context.docstore
+        
+        # Отримуємо доступ до документів
+        node_dict = self.docstore.docs
+        self.nodes = list(node_dict.values())
+        
+        # Створюємо BM25 retriever
+        self.retriever_bm25 = BM25Retriever.from_defaults(
+            docstore=self.docstore, 
+            similarity_top_k=self.similarity_top_k
+        )
+        
+        # Створюємо векторний retriever
+        self.retriever_vector = self.index.as_retriever(
+            similarity_top_k=self.similarity_top_k
+        )
+        
+        # Створюємо гібридний retriever
+        self.retriever_fusion = QueryFusionRetriever(
+            [
+                self.retriever_bm25,  # Пошук на основі BM25 (ключові слова)
+                self.retriever_vector,  # Векторний пошук (семантичний)
+            ],
+            mode="reciprocal_rerank",  # Режим переранжування результатів
+            similarity_top_k=self.similarity_top_k,
+            num_queries=1,  # Використовуємо тільки оригінальний запит
+            use_async=True,  # Асинхронне виконання для швидкості
+        )
+        
+        # Створюємо query engine на основі гібридного ретривера
+        self.query_engine = RetrieverQueryEngine(self.retriever_fusion)
+        
+        # Відновлюємо jira_documents з вузлів
+        try:
+            self.jira_documents = []
+            for node in self.nodes:
+                # Створюємо документ з текстом та метаданими вузла
+                doc = Document(
+                    text=node.text,
+                    metadata=node.metadata
+                )
+                self.jira_documents.append(doc)
+            
+            logger.info(f"Відновлено {len(self.jira_documents)} документів")
+        except Exception as e:
+            logger.warning(f"Не вдалося відновити jira_documents: {e}")
+        
+        logger.info(f"Успішно завантажено індекси з {indices_dir}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Помилка при завантаженні індексів: {e}")
+        return False
+
+def save_indices(self, indices_dir):
+    """
+    Збереження індексів у директорію.
+    
+    Args:
+        indices_dir (str): Шлях до директорії для збереження індексів
+        
+    Returns:
+        bool: True, якщо індекси успішно збережено, False інакше
+    """
+    try:
+        logger.info(f"Збереження індексів у директорію: {indices_dir}")
+        
+        # Перевірка наявності директорії
+        if not os.path.exists(indices_dir):
+            os.makedirs(indices_dir)
+        
+        # Перевірка наявності індексу
+        if not hasattr(self, 'index') or self.index is None:
+            logger.error("В��дсутній індекс для збереження")
+            return False
+        
+        # Збереження індексу
+        self.index.storage_context.persist(persist_dir=indices_dir)
+        
+        # Збереження додаткових метаданих
+        try:
+            metadata = {
+                "created_at": datetime.now().isoformat(),
+                "documents_count": len(self.jira_documents) if hasattr(self, 'jira_documents') else 0,
+                "nodes_count": len(self.nodes) if hasattr(self, 'nodes') else 0,
+                "embedding_model": str(self.embed_model) if hasattr(self, 'embed_model') else "unknown"
+            }
+            
+            with open(os.path.join(indices_dir, "metadata.json"), "w", encoding="utf-8") as f:
+                json.dump(metadata, f, ensure_ascii=False, indent=2)
+        except Exception as meta_err:
+            logger.warning(f"Помилка при збереженні метаданих: {meta_err}")
+        
+        logger.info(f"Індекси успішно збережено у {indices_dir}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Помилка при збереженні індексів: {e}")
+        return False

modules/ai_analysis/faiss_utils.py

@@ -0,0 +1,405 @@
+"""
+Модуль утиліт для роботи з FAISS векторними індексами.
+Цей файл повинен бути розміщений у modules/ai_analysis/faiss_utils.py
+"""
+
+import logging
+import os
+from pathlib import Path
+import json
+import hashlib
+from datetime import datetime
+import shutil
+import tempfile
+import sys
+
+logger = logging.getLogger(__name__)
+
+# Перевірка наявності змінних середовища Hugging Face
+IS_HUGGINGFACE = os.environ.get("SPACE_ID") is not None
+if IS_HUGGINGFACE:
+    logger.info("Виявлено середовище Hugging Face Spaces")
+
+try:
+    import faiss
+    import numpy as np
+    from llama_index.vector_stores.faiss import FaissVectorStore
+    from llama_index.core import load_index_from_storage
+    from llama_index.core import StorageContext
+    
+    FAISS_AVAILABLE = True
+    logger.info("FAISS успішно імпортовано")
+except ImportError as e:
+    logger.warning(f"FAISS або llama-index-vector-stores-faiss не встановлено: {e}. Використання FAISS буде вимкнено.")
+    FAISS_AVAILABLE = False
+
+def check_faiss_available():
+    """
+    Перевірка доступності FAISS.
+    
+    Returns:
+        bool: True, якщо FAISS доступний, False інакше
+    """
+    return FAISS_AVAILABLE
+
+def generate_file_hash(file_path):
+    """
+    Генерує хеш для файлу на основі його вмісту.
+    
+    Args:
+        file_path (str): Шлях до файлу
+        
+    Returns:
+        str: Хеш файлу або None у випадку помилки
+    """
+    try:
+        if not os.path.exists(file_path):
+            logger.error(f"Файл не знайдено: {file_path}")
+            return None
+            
+        # Отримуємо базову інформацію про файл для додавання в хеш
+        file_stat = os.stat(file_path)
+        file_size = file_stat.st_size
+        file_mtime = file_stat.st_mtime
+        
+        # Створюємо хеш на основі вмісту файлу
+        sha256 = hashlib.sha256()
+        
+        # Додаємо базову інформацію про файл
+        sha256.update(f"{file_size}_{file_mtime}".encode())
+        
+        # Додаємо вміст файлу
+        with open(file_path, "rb") as f:
+            for byte_block in iter(lambda: f.read(4096), b""):
+                sha256.update(byte_block)
+        
+        return sha256.hexdigest()
+        
+    except Exception as e:
+        logger.error(f"Помилка при генерації хешу файлу: {e}")
+        return None
+
+def save_indices_metadata(directory_path, metadata):
+    """
+    Зберігає метадані індексів у JSON файл.
+    
+    Args:
+        directory_path (str): Шлях до директорії з індексами
+        metadata (dict): Метадані для збереження
+        
+    Returns:
+        bool: True, якщо збереження успішне, False інакше
+    """
+    try:
+        # Перевіряємо наявність директорії
+        if not os.path.exists(directory_path):
+            logger.warning(f"Директорія {directory_path} не існує. Створюємо...")
+            os.makedirs(directory_path, exist_ok=True)
+            
+        metadata_path = Path(directory_path) / "metadata.json"
+        
+        # Додаємо додаткову інформацію про оточення
+        metadata["environment"] = {
+            "is_huggingface": IS_HUGGINGFACE,
+            "python_version": sys.version,
+            "platform": sys.platform
+        }
+        
+        # Додаємо логування для діагностики
+        logger.info(f"Збереження метаданих у {metadata_path}")
+        logger.info(f"Розмір метаданих: {len(str(metadata))} символів")
+        
+        with open(metadata_path, "w", encoding="utf-8") as f:
+            json.dump(metadata, f, ensure_ascii=False, indent=2)
+        
+        # Перевіряємо, що файл було створено
+        if os.path.exists(metadata_path):
+            logger.info(f"Метадані успішно збережено у {metadata_path}")
+            return True
+        else:
+            logger.error(f"Файл {metadata_path} не було створено")
+            return False
+        
+    except Exception as e:
+        logger.error(f"Помилка при збереженні метаданих: {e}")
+        return False
+
+def load_indices_metadata(directory_path):
+    """
+    Завантажує метадані індексів з JSON файлу.
+    
+    Args:
+        directory_path (str): Шлях до директорії з індексами
+        
+    Returns:
+        dict: Метадані або пустий словник у випадку помилки
+    """
+    try:
+        metadata_path = Path(directory_path) / "metadata.json"
+        
+        if not metadata_path.exists():
+            logger.warning(f"Файл метаданих не знайдено: {metadata_path}")
+            return {}
+        
+        with open(metadata_path, "r", encoding="utf-8") as f:
+            metadata = json.load(f)
+        
+        logger.info(f"Метадані успішно завантажено з {metadata_path}")
+        return metadata
+        
+    except Exception as e:
+        logger.error(f"Помилка при завантаженні метаданих: {e}")
+        return {}
+
+def find_latest_indices(base_dir="temp/indices"):
+    """
+    Знаходить найновіші збережені індекси.
+    
+    Args:
+        base_dir (str): Базова директорія з індексами
+        
+    Returns:
+        tuple: (bool, str) - (наявність індексів, шлях до найновіших індексів)
+    """
+    try:
+        # Перевіряємо наявність базової директорії
+        indices_dir = Path(base_dir)
+        
+        if not indices_dir.exists():
+            logger.info(f"Директорія {base_dir} не існує")
+            return False, None
+            
+        if not os.path.isdir(indices_dir):
+            logger.warning(f"{base_dir} існує, але не є директорією")
+            return False, None
+            
+        if not any(indices_dir.iterdir()):
+            logger.info(f"Директорія {base_dir} порожня")
+            return False, None
+        
+        # Отримання списку піддиректорій з індексами
+        try:
+            subdirs = [d for d in indices_dir.iterdir() if d.is_dir()]
+        except Exception as iter_err:
+            logger.error(f"Помилка при перегляді директорії {base_dir}: {iter_err}")
+            return False, None
+            
+        if not subdirs:
+            logger.info("Індекси не знайдено")
+            return False, None
+        
+        # Знаходимо найновішу директорію
+        try:
+            latest_dir = max(subdirs, key=lambda x: x.stat().st_mtime)
+        except Exception as sort_err:
+            logger.error(f"Помилка при сортуванні директорій: {sort_err}")
+            return False, None
+        
+        logger.info(f"Знайдено індекси у директорії {latest_dir}")
+        return True, str(latest_dir)
+        
+    except Exception as e:
+        logger.error(f"Помилка при пошуку індексів: {e}")
+        return False, None
+
+def find_indices_by_hash(csv_hash, base_dir="temp/indices"):
+    """
+    Знаходить індекси, що відповідають вказаному хешу CSV файлу.
+    
+    Args:
+        csv_hash (str): Хеш CSV файлу
+        base_dir (str): Базова директорія з індексами
+        
+    Returns:
+        tuple: (bool, str) - (наявність індексів, шлях до відповідних індексів)
+    """
+    try:
+        if not csv_hash:
+            logger.warning("Не вказано хеш CSV файлу")
+            return False, None
+            
+        # Перевіряємо наявність базової директорії
+        indices_dir = Path(base_dir)
+        
+        if not indices_dir.exists():
+            logger.info(f"Директорія {base_dir} не існує")
+            return False, None
+            
+        if not any(indices_dir.iterdir()):
+            logger.info(f"Директорія {base_dir} порожня")
+            return False, None
+        
+        # Отримання списку піддиректорій з індексами
+        subdirs = [d for d in indices_dir.iterdir() if d.is_dir()]
+        if not subdirs:
+            logger.info("Індекси не знайдено")
+            return False, None
+        
+        # Перевіряємо кожну директорію на відповідність хешу
+        for directory in subdirs:
+            metadata_path = directory / "metadata.json"
+            if metadata_path.exists():
+                try:
+                    with open(metadata_path, "r", encoding="utf-8") as f:
+                        metadata = json.load(f)
+                    
+                    if "csv_hash" in metadata and metadata["csv_hash"] == csv_hash:
+                        # Додатково перевіряємо наявність файлів індексів
+                        if (directory / "docstore.json").exists():
+                            logger.info(f"Знайдено індекси для CSV з хешем {csv_hash} у {directory}")
+                            return True, str(directory)
+                        else:
+                            logger.warning(f"Знайдено метадані для CSV з хешем {csv_hash}, але файли індексів відсутні у {directory}")
+                except Exception as md_err:
+                    logger.warning(f"Помилка при читанні метаданих {metadata_path}: {md_err}")
+        
+        # Якщо відповідних індексів не знайдено, повертаємо найновіші
+        logger.info(f"Не знайдено індексів для CSV з хешем {csv_hash}, спроба знайти найновіші")
+        return find_latest_indices(base_dir)
+        
+    except Exception as e:
+        logger.error(f"Помилка при пошуку індексів за хешем: {e}")
+        return False, None
+
+def create_indices_directory(csv_hash=None, base_dir="temp/indices"):
+    """
+    Створює директорію для зберігання індексів з часовою міткою.
+    
+    Args:
+        csv_hash (str, optional): Хеш CSV файлу для метаданих
+        base_dir (str): Базова директорія для індексів
+        
+    Returns:
+        str: Шлях до створеної директорії
+    """
+    try:
+        # Створення базової директорії, якщо вона не існує
+        indices_dir = Path(base_dir)
+        
+        # Очищаємо старі індекси перед створенням нових, якщо ми на Hugging Face
+        if IS_HUGGINGFACE and indices_dir.exists():
+            logger.info("Очищення старих індексів перед створенням нових на Hugging Face")
+            try:
+                # Видаляємо тільки старі директорії, якщо їх більше 1
+                subdirs = [d for d in indices_dir.iterdir() if d.is_dir()]
+                if len(subdirs) > 1:
+                    # Сортуємо за часом модифікації (від найстаріших до найновіших)
+                    sorted_dirs = sorted(subdirs, key=lambda x: x.stat().st_mtime)
+                    
+                    # Залишаємо тільки найновішу директорію
+                    for directory in sorted_dirs[:-1]:
+                        try:
+                            shutil.rmtree(directory)
+                            logger.info(f"Видалено стару директорію: {directory}")
+                        except Exception as del_err:
+                            logger.warning(f"Не вдалося видалити директорію {directory}: {del_err}")
+            except Exception as clean_err:
+                logger.warning(f"Помилка при очищенні старих індексів: {clean_err}")
+        
+        # Створюємо базову директорію
+        indices_dir.mkdir(exist_ok=True, parents=True)
+        
+        # Створення унікальної директорії з часовою міткою
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        index_dir = indices_dir / timestamp
+        
+        # Спроба створити директорію
+        try:
+            index_dir.mkdir(exist_ok=True)
+        except Exception as mkdir_err:
+            logger.error(f"Не вдалося створити директорію {index_dir}: {mkdir_err}")
+            
+            # Створюємо тимчасову директорію як запасний варіант
+            try:
+                temp_dir = tempfile.mkdtemp(prefix="faiss_indices_")
+                logger.info(f"Створено тимчасову директорію: {temp_dir}")
+                return temp_dir
+            except Exception as temp_err:
+                logger.error(f"Не вдалося створити тимчасову директорію: {temp_err}")
+                return str(indices_dir / "fallback")
+        
+        # Зберігаємо базові метадані
+        metadata = {
+            "created_at": timestamp,
+            "timestamp": datetime.now().timestamp(),
+            "csv_hash": csv_hash
+        }
+        
+        save_indices_metadata(str(index_dir), metadata)
+        
+        logger.info(f"Створено директорію для індексів: {index_dir}")
+        return str(index_dir)
+        
+    except Exception as e:
+        logger.error(f"Помилка при створенні директорії індексів: {e}")
+        
+        # Створюємо тимчасову директорію як запасний варіант
+        try:
+            temp_dir = tempfile.mkdtemp(prefix="faiss_indices_")
+            logger.info(f"Створено тимчасову д��ректорію для індексів: {temp_dir}")
+            return temp_dir
+        except Exception:
+            # Якщо і це не вдалося, використовуємо директорію temp
+            logger.error("Не вдалося створити навіть тимчасову директорію, використовуємо базову temp")
+            os.makedirs("temp", exist_ok=True)
+            return "temp"
+
+def cleanup_old_indices(max_indices=3, base_dir="temp/indices"):
+    """
+    Видаляє старі індекси, залишаючи тільки вказану кількість найновіших.
+    
+    Args:
+        max_indices (int): Максимальна кількість індексів для зберігання
+        base_dir (str): Базова директорія з індексами
+        
+    Returns:
+        int: Кількість видалених директорій
+    """
+    try:
+        # На Hugging Face Space обмежуємо максимальну кількість індексів до 1
+        if IS_HUGGINGFACE:
+            max_indices = 1
+            logger.info("На Hugging Face Space обмежуємо кількість індексів до 1")
+            
+        indices_dir = Path(base_dir)
+        
+        if not indices_dir.exists():
+            logger.warning(f"Директорія {base_dir} не існує")
+            return 0
+        
+        # Отримання списку піддиректорій з індексами
+        try:
+            subdirs = [d for d in indices_dir.iterdir() if d.is_dir()]
+        except Exception as iter_err:
+            logger.error(f"Помилка при скануванні директорії {base_dir}: {iter_err}")
+            return 0
+            
+        if len(subdirs) <= max_indices:
+            logger.info(f"Кількість індексів ({len(subdirs)}) не перевищує ліміт ({max_indices})")
+            return 0
+        
+        # Сортуємо директорії за часом модифікації (від найновіших до найстаріших)
+        try:
+            sorted_dirs = sorted(subdirs, key=lambda x: x.stat().st_mtime, reverse=True)
+        except Exception as sort_err:
+            logger.error(f"Помилка при сортуванні директорій: {sort_err}")
+            return 0
+        
+        # Залишаємо тільки max_indices найновіших директорій
+        dirs_to_delete = sorted_dirs[max_indices:]
+        
+        # Видаляємо старі директорії
+        deleted_count = 0
+        for directory in dirs_to_delete:
+            try:
+                shutil.rmtree(directory)
+                deleted_count += 1
+                logger.info(f"Видалено стару директорію індексів: {directory}")
+            except Exception as del_err:
+                logger.warning(f"Не вдалося видалити директорію {directory}: {del_err}")
+        
+        return deleted_count
+        
+    except Exception as e:
+        logger.error(f"Помилка при очищенні старих індексів: {e}")
+        return 0

modules/ai_analysis/google_embeddings_utils.py

@@ -0,0 +1,175 @@
+"""
+Утиліти для роботи з Google Embeddings API.
+Цей файл повинен бути розміщений у modules/ai_analysis/google_embeddings_utils.py
+"""
+
+import os
+import logging
+from typing import List, Dict, Any, Optional
+import time
+
+logger = logging.getLogger(__name__)
+
+# Перевірка наявності необхідних бібліотек
+try:
+    from google import genai
+    GOOGLE_GENAI_AVAILABLE = True
+    logger.info("Google GenAI SDK успішно імпортовано")
+except ImportError as e:
+    logger.warning(f"Google GenAI SDK не встановлено: {e}. Використання Google Embeddings буде вимкнено.")
+    GOOGLE_GENAI_AVAILABLE = False
+
+class GoogleEmbeddingsManager:
+    """
+    Менеджер для роботи з Google Embeddings API.
+    """
+    
+    def __init__(self, api_key=None, model_name="text-embedding-004", task_type="retrieval_query"):
+        """
+        Ініціалізація менеджера Google Embeddings.
+        
+        Args:
+            api_key (str, optional): API ключ для Google API. Якщо не вказано, спробує використати GEMINI_API_KEY з середовища.
+            model_name (str): Назва моделі ембедингів.
+            task_type (str): Тип задачі для ембедингів. Може бути "retrieval_query" або "retrieval_document".
+        """
+        self.api_key = api_key or os.getenv("GEMINI_API_KEY")
+        self.model_name = model_name
+        self.task_type = task_type
+        self.client = None
+        self.initialized = False
+        
+        # Спроба ініціалізації клієнта
+        self._initialize_client()
+    
+    def _initialize_client(self):
+        """
+        Ініціалізує клієнт Google GenAI API.
+        
+        Returns:
+            bool: True, якщо ініціалізація успішна, False в іншому випадку.
+        """
+        if not GOOGLE_GENAI_AVAILABLE:
+            logger.error("Google GenAI SDK не встановлено. Встановіть пакет: pip install google-genai")
+            return False
+        
+        if not self.api_key:
+            logger.error("API ключ для Google API не вказано. Встановіть змінну GEMINI_API_KEY.")
+            return False
+        
+        try:
+            # Ініціалізація клієнта
+            genai.configure(api_key=self.api_key)
+            self.client = genai.Client()
+            self.initialized = True
+            logger.info(f"Клієнт Google GenAI успішно ініціалізовано для моделі {self.model_name}")
+            return True
+        except Exception as e:
+            logger.error(f"Помилка при ініціалізації клієнта Google GenAI: {e}")
+            return False
+    
+    def get_embeddings(self, texts, batch_size=8, retry_attempts=3, retry_delay=1):
+        """
+        Отримує ембединги для списку текстів.
+        
+        Args:
+            texts (list): Список текстів для ембедингу.
+            batch_size (int): Розмір батча для обробки.
+            retry_attempts (int): Кількість спроб у випадку помилки.
+            retry_delay (int): Затримка між спробами в секундах.
+            
+        Returns:
+            list: Список ембедингів для кожного тексту або None у випадку помилки.
+        """
+        if not self.initialized:
+            if not self._initialize_client():
+                return None
+        
+        if not texts:
+            logger.warning("Порожній список текстів для ембедингу")
+            return []
+        
+        # Переконуємося, що input завжди список
+        if not isinstance(texts, list):
+            texts = [texts]
+        
+        try:
+            all_embeddings = []
+            
+            # Обробка по батчам для ефективності
+            for i in range(0, len(texts), batch_size):
+                batch = texts[i:i + batch_size]
+                
+                # Спроби з повторами у випадку помилки
+                for attempt in range(retry_attempts):
+                    try:
+                        result = self.client.models.embed_content(
+                            model=self.model_name,
+                            contents=batch,
+                            config={"task_type": self.task_type}
+                        )
+                        
+                        # Вилучення ембедингів
+                        batch_embeddings = [embedding.values for embedding in result.embeddings]
+                        all_embeddings.extend(batch_embeddings)
+                        break
+                    except Exception as e:
+                        if attempt == retry_attempts - 1:
+                            logger.error(f"Не вдалося отримати ембединги після {retry_attempts} спроб: {e}")
+                            return None
+                        logger.warning(f"Спроба {attempt+1} невдала: {e}. Повторна спроба через {retry_delay} сек.")
+                        time.sleep(retry_delay)
+            
+            logger.info(f"Успішно отримано {len(all_embeddings)} ембедингів від Google API")
+            return all_embeddings
+            
+        except Exception as e:
+            logger.error(f"Помилка при отриманні ембедингів від Google API: {e}")
+            return None
+    
+    def get_embedding_dimension(self):
+        """
+        Отримує розмірність ембедингів.
+        
+        Returns:
+            int: Розмірність ембедингів або 0 у випадку помилки.
+        """
+        if not self.initialized:
+            if not self._initialize_client():
+                return 0
+        
+        try:
+            # Отримуємо ембединг для тестового тексту
+            result = self.client.models.embed_content(
+                model=self.model_name,
+                contents=["Test"],
+                config={"task_type": self.task_type}
+            )
+            
+            # Отримуємо розмірність
+            [embedding] = result.embeddings
+            return len(embedding.values)
+            
+        except Exception as e:
+            logger.error(f"Помилка при отриманні розмірності ембедингів: {e}")
+            return 0
+
+# Приклад використання
+if __name__ == "__main__":
+    # Налаштування логування
+    logging.basicConfig(level=logging.INFO)
+    
+    # Ініціалізація менеджера
+    manager = GoogleEmbeddingsManager()
+    
+    # Отримання розмірності ембедингів
+    dimension = manager.get_embedding_dimension()
+    print(f"Розмірність ембедингів: {dimension}")
+    
+    # Отримання ембедингів для текстів
+    texts = ["Це тестовий текст", "Це ще один тестовий текст"]
+    embeddings = manager.get_embeddings(texts)
+    
+    if embeddings:
+        print(f"Отримано {len(embeddings)} ембедингів")
+        print(f"Розмірність першого ембедингу: {len(embeddings[0])}")

modules/ai_analysis/indices_initializer.py

@@ -0,0 +1,83 @@
+import logging
+import uuid
+from datetime import datetime
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+def initialize_indices(app):
+    """
+    Ініціалізує індекси BM25 та FAISS для режиму гібридного чату.
+    
+    Args:
+        app: Екземпляр JiraAssistantApp
+        
+    Returns:
+        dict: Результат ініціалізації
+    """
+    if not hasattr(app, 'current_data') or app.current_data is None:
+        return {"error": "Немає даних для індексування. Спочатку завантажте CSV файл."}
+    
+    try:
+        # Генеруємо унікальний ідентифікатор сесії, якщо він відсутній
+        if not hasattr(app, 'current_session_id') or app.current_session_id is None:
+            app.current_session_id = f"{uuid.uuid4()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            logger.info(f"Створено новий ID сесії для індексування: {app.current_session_id}")
+        
+        # Викликаємо метод для створення індексів
+        indices_result = app.index_manager.get_or_create_indices(
+            app.current_data, 
+            app.current_session_id
+        )
+        
+        if "error" in indices_result:
+            logger.error(f"Помилка при створенні індексів: {indices_result['error']}")
+            return indices_result
+        
+        # Зберігаємо шлях до індексів у app
+        indices_dir = indices_result.get("indices_dir")
+        app.indices_path = indices_dir
+        app.current_indices_dir = indices_dir
+        
+        logger.info(f"Індекси успішно створено: {indices_dir}")
+        
+        # Зберігаємо шлях до індексів глобально для доступу з різних модулів
+        try:
+            import builtins
+            if hasattr(builtins, 'app'):
+                builtins.app.indices_path = indices_dir
+                logger.info(f"Шлях до індексів збережено глобально: {indices_dir}")
+                
+                # Якщо також є глобальний index_manager, зберігаємо в ньому
+                if hasattr(builtins, 'index_manager'):
+                    builtins.index_manager.last_indices_path = indices_dir
+                    logger.info(f"Шлях до індексів збережено в index_manager: {indices_dir}")
+        except Exception as app_err:
+            logger.warning(f"Не вдалося зберегти шлях до індексів глобально: {app_err}")
+
+        # Очищаємо кеш екземплярів чату, якщо він є
+        if hasattr(app, 'chat_instances_cache'):
+            app.chat_instances_cache = {}
+            logger.info("Скинуто кеш екземплярів чату")
+        
+        # Якщо є клас JiraHybridChat зі статичним кешем, очищаємо його
+        try:
+            from modules.ai_analysis.jira_hybrid_chat import JiraHybridChat
+            if hasattr(JiraHybridChat, 'chat_instances_cache'):
+                JiraHybridChat.chat_instances_cache = {}
+                logger.info("Скинуто статичний кеш JiraHybridChat")
+        except ImportError:
+            pass
+        
+        return {
+            "success": True,
+            "indices_dir": indices_dir,
+            "documents_count": indices_result.get("documents_count", indices_result.get("rows_count", len(app.current_data))),
+            "nodes_count": indices_result.get("nodes_count", indices_result.get("rows_count", len(app.current_data)))
+        }
+        
+    except Exception as e:
+        import traceback
+        error_details = traceback.format_exc()
+        logger.error(f"Помилка при ініціалізації індексів: {e}\n{error_details}")
+        return {"error": f"Помилка при ініціалізації індексів: {str(e)}"}

modules/ai_analysis/jira_ai_report.py

@@ -0,0 +1,398 @@
+import os
+import logging
+import tiktoken
+import pandas as pd
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+
+# Налаштування логування
+logger = logging.getLogger(__name__)
+
+# Перевірка наявності LlamaIndex
+try:
+    from llama_index.core import Document
+    from llama_index.core.llms import ChatMessage
+    LLAMA_INDEX_AVAILABLE = True
+except ImportError:
+    logger.warning("Не вдалося імпортувати LlamaIndex. Встановіть необхідні залежності для використання AI Report.")
+    LLAMA_INDEX_AVAILABLE = False
+
+# Імпорт промпта для звіту
+from prompts import get_report_prompt
+
+class JiraAIReport:
+    """
+    Клас для генерації аналітичних звітів на основі даних Jira,
+    використовуючи повний контекст даних (аналогічно режиму Q/A).
+    """
+    
+    def __init__(self, api_key_openai=None, api_key_gemini=None, model_type="gemini", temperature=0.2):
+        """
+        Ініціалізація AI генератора звітів.
+        
+        Args:
+            api_key_openai (str): API ключ для OpenAI
+            api_key_gemini (str): API ключ для Google Gemini
+            model_type (str): Тип моделі ("openai" або "gemini")
+            temperature (float): Параметр температури для генерації відповідей
+        """
+        self.model_type = model_type.lower()
+        self.temperature = temperature
+        self.api_key_openai = api_key_openai or os.getenv("OPENAI_API_KEY", "")
+        self.api_key_gemini = api_key_gemini or os.getenv("GEMINI_API_KEY", "")
+        
+        # Перевірка наявності LlamaIndex
+        if not LLAMA_INDEX_AVAILABLE:
+            logger.error("LlamaIndex не доступний. Встановіть пакети: pip install llama-index-llms-gemini llama-index")
+            raise ImportError("LlamaIndex не встановлено. Необхідний для роботи генератора звітів.")
+        
+        # Ініціалізація моделі LLM
+        self.llm = None
+        
+        # Дані Jira
+        self.df = None
+        self.jira_documents = []
+        
+        # Ініціалізуємо модель LLM
+        self._initialize_llm()
+    
+    def _initialize_llm(self):
+        """Ініціалізує модель LLM відповідно до налаштувань."""
+        try:
+            # Ініціалізація LLM моделі
+            if self.model_type == "gemini" and self.api_key_gemini:
+                os.environ["GEMINI_API_KEY"] = self.api_key_gemini
+                
+                from llama_index.llms.gemini import Gemini
+                self.llm = Gemini(
+                    model="models/gemini-2.0-flash",
+                    temperature=self.temperature,
+                    max_tokens=4096,
+                )
+                logger.info("Успішно ініціалізовано Gemini 2.0 Flash модель")
+            elif self.model_type == "openai" and self.api_key_openai:
+                os.environ["OPENAI_API_KEY"] = self.api_key_openai
+                
+                from llama_index.llms.openai import OpenAI
+                self.llm = OpenAI(
+                    model="gpt-4o-mini",
+                    temperature=self.temperature,
+                    max_tokens=4096
+                )
+                logger.info("Успішно ініціалізовано OpenAI GPT-4o-mini модель")
+            else:
+                error_msg = f"Не вдалося ініціалізувати LLM модель типу {self.model_type}. Перевірте API ключі."
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+                
+        except Exception as e:
+            logger.error(f"Помилка ініціалізації моделі LLM: {e}")
+            raise
+    
+    def load_documents_from_dataframe(self, df):
+        """
+        Завантаження документів прямо з DataFrame без створення індексів.
+        
+        Args:
+            df (pandas.DataFrame): DataFrame з даними Jira
+            
+        Returns:
+            bool: True якщо дані успішно завантажено
+        """
+        try:
+            logger.info("Завантаження даних з DataFrame для генерації звіту")
+            
+            # Зберігаємо оригінальний DataFrame
+            self.df = df.copy()
+            
+            # Конвертуємо дані в документи
+            self._convert_dataframe_to_documents()
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Помил��а при завантаженні даних з DataFrame: {e}")
+            return False
+    
+    def _convert_dataframe_to_documents(self):
+        """
+        Перетворює дані DataFrame в об'єкти Document для роботи з моделлю LLM.
+        """
+        import pandas as pd
+        
+        if self.df is None:
+            logger.error("Не вдалося створити документи: відсутні дані DataFrame")
+            return
+            
+        logger.info("Перетворення даних DataFrame в документи для звіту...")
+        
+        self.jira_documents = []
+        
+        for idx, row in self.df.iterrows():
+            # Основний текст - опис тікета
+            text = ""
+            if 'Description' in row and pd.notna(row['Description']):
+                text = str(row['Description'])
+                
+            # Додавання коментарів, якщо вони є
+            for col in self.df.columns:
+                if col.startswith('Comment') and pd.notna(row[col]):
+                    text += f"\n\nКоментар: {str(row[col])}"
+            
+            # Метадані для документа
+            metadata = {
+                "issue_key": row['Issue key'] if 'Issue key' in row and pd.notna(row['Issue key']) else "",
+                "issue_type": row['Issue Type'] if 'Issue Type' in row and pd.notna(row['Issue Type']) else "",
+                "status": row['Status'] if 'Status' in row and pd.notna(row['Status']) else "",
+                "priority": row['Priority'] if 'Priority' in row and pd.notna(row['Priority']) else "",
+                "assignee": row['Assignee'] if 'Assignee' in row and pd.notna(row['Assignee']) else "",
+                "reporter": row['Reporter'] if 'Reporter' in row and pd.notna(row['Reporter']) else "",
+                "created": str(row['Created']) if 'Created' in row and pd.notna(row['Created']) else "",
+                "updated": str(row['Updated']) if 'Updated' in row and pd.notna(row['Updated']) else "",
+                "summary": row['Summary'] if 'Summary' in row and pd.notna(row['Summary']) else "",
+                "project": row['Project name'] if 'Project name' in row and pd.notna(row['Project name']) else ""
+            }
+            
+            # Додатково перевіряємо поле зв'язків, якщо воно є
+            if 'Outward issue link (Relates)' in row and pd.notna(row['Outward issue link (Relates)']):
+                metadata["related_issues"] = row['Outward issue link (Relates)']
+            
+            # Додатково перевіряємо інші можливі поля зв'язків
+            for col in self.df.columns:
+                if col.startswith('Outward issue link') and col != 'Outward issue link (Relates)' and pd.notna(row[col]):
+                    link_type = col.replace('Outward issue link ', '').strip('()')
+                    if "links" not in metadata:
+                        metadata["links"] = {}
+                    metadata["links"][link_type] = str(row[col])
+            
+            # Створення документа
+            doc = Document(
+                text=text,
+                metadata=metadata
+            )
+            
+            self.jira_documents.append(doc)
+        
+        logger.info(f"Створено {len(self.jira_documents)} документів для генерації звіту")
+        
+    def _count_tokens(self, text: str, model: str = "gpt-3.5-turbo") -> int:
+        """
+        Підраховує приблизну кількість токенів для тексту.
+        
+        Args:
+            text (str): Текст для підрахунку токенів
+            model (str): Назва моделі для вибору енкодера
+            
+        Returns:
+            int: Кількість токенів
+        """
+        try:
+            encoding = tiktoken.encoding_for_model(model)
+            tokens = encoding.encode(text)
+            return len(tokens)
+        except Exception as e:
+            logger.warning(f"Не вдалося підрахувати токени через tiktoken: {e}")
+            # Якщо не можемо використати tiktoken, робимо просту оцінку
+            # В середньому 1 токен ≈ 3 символи для змішаного тексту
+            return len(text) // 3  # Приблизна оцінка
+    
+    def _prepare_context_data(self):
+        """
+        Підготовка даних для контексту звіту.
+        
+        Returns:
+            str: Підготовлений контекст з даних
+        """
+        if not self.jira_documents:
+            logger.error("Відсутні документи для підготовки контексту")
+            return ""
+        
+        # Статистика по тікетах
+        status_counts = {}
+        type_counts = {}
+        priority_counts = {}
+        assignee_counts = {}
+        
+        for doc in self.jira_documents:
+            status = doc.metadata.get("status", "")
+            issue_type = doc.metadata.get("issue_type", "")
+            priority = doc.metadata.get("priority", "")
+            assignee = doc.metadata.get("assignee", "")
+            
+            if status:
+                status_counts[status] = status_counts.get(status, 0) + 1
+            if issue_type:
+                type_counts[issue_type] = type_counts.get(issue_type, 0) + 1
+            if priority:
+                priority_counts[priority] = priority_counts.get(priority, 0) + 1
+            if assignee:
+                assignee_counts[assignee] = assignee_counts.get(assignee, 0) + 1
+        
+        # Формуємо текстовий опис для LLM
+        data_summary = f"СТАТИСТИКА ПРОЕКТУ JIRA:\n\n"
+        data_summary += f"Загальна кількість тікетів: {len(self.jira_documents)}\n\n"
+        
+        data_summary += "Розподіл за статусами:\n"
+        for status, count in sorted(status_counts.items(), key=lambda x: x[1], reverse=True):
+            percentage = (count / len(self.jira_documents) * 100)
+            data_summary += f"- {status}: {count} ({percentage:.1f}%)\n"
+        
+        data_summary += "\nРозподіл за типами:\n"
+        for type_name, count in sorted(type_counts.items(), key=lambda x: x[1], reverse=True):
+            percentage = (count / len(self.jira_documents) * 100)
+            data_summary += f"- {type_name}: {count} ({percentage:.1f}%)\n"
+        
+        data_summary += "\nРозподіл за пріоритетами:\n"
+        for priority, count in sorted(priority_counts.items(), key=lambda x: x[1], reverse=True):
+            percentage = (count / len(self.jira_documents) * 100)
+            data_summary += f"- {priority}: {count} ({percentage:.1f}%)\n"
+        
+        # Топ-5 виконавців
+        if assignee_counts:
+            data_summary += "\nТоп виконавці завдань:\n"
+            for assignee, count in sorted(assignee_counts.items(), key=lambda x: x[1], reverse=True)[:5]:
+                data_summary += f"- {assignee}: {count} тікетів\n"
+        
+        # Додаємо інформацію про важливі тікети (з високим пріоритетом)
+        high_priority_tickets = []
+        for doc in self.jira_documents:
+            if doc.metadata.get("priority", "").lower() in ["high", "highest", "critical", "blocker", "високий", "критичний"]:
+                high_priority_tickets.append(doc)
+        
+        if high_priority_tickets:
+            data_summary += "\nВажливі тікети (високий пріоритет):\n"
+            for doc in high_priority_tickets[:5]:  # Обмежуємо кількість для економії токенів
+                issue_key = doc.metadata.get("issue_key", "")
+                summary = doc.metadata.get("summary", "")
+                status = doc.metadata.get("status", "")
+                data_summary += f"- {issue_key}: '{summary}' (Статус: {status})\n"
+        
+        # Додаємо інформацію про останні оновлені тікети
+        try:
+            # Спочатку намагаємося отримати список тікетів з датами оновлення
+            tickets_with_dates = []
+            for doc in self.jira_documents:
+                updated = doc.metadata.get("updated", "")
+                if updated:
+                    try:
+                        # Спроба парсингу дати
+                        updated_date = pd.to_datetime(updated)
+                        tickets_with_dates.append((doc, updated_date))
+                    except:
+                        pass
+            
+            # Сортуємо за датою оновлення (від найновіших до найстаріших)
+            tickets_with_dates.sort(key=lambda x: x[1], reverse=True)
+            
+            # Додаємо інформацію про останні оновлені тікети
+            if tickets_with_dates:
+                data_summary += "\nОстанні оновлені тікети:\n"
+                for doc, date in tickets_with_dates[:5]:
+                    issue_key = doc.metadata.get("issue_key", "")
+                    summary = doc.metadata.get("summary", "")
+                    status = doc.metadata.get("status", "")
+                    data_summary += f"- {issue_key}: '{summary}' (Статус: {status}, Оновлено: {date.strftime('%Y-%m-%d')})\n"
+        except Exception as e:
+            logger.warning(f"Помилка при обробці дат оновлення: {e}")
+        
+        return data_summary
+
+    def generate_report(self, format_type="markdown") -> Dict[str, Any]:
+        """
+        Генерація аналітичного звіту на основі даних Jira.
+        
+        Args:
+            format_type (str): Формат звіту ("markdown", "html")
+            
+        Returns:
+            Dict[str, Any]: Словник з результатами, включаючи звіт та метадані
+        """
+        try:
+            if not self.jira_documents or not self.llm:
+                error_msg = "Не вдалося виконати запит: відсутні документи або LLM"
+                logger.error(error_msg)
+                return {"error": error_msg}
+            
+            logger.info(f"Запуск генерації звіту у форматі {format_type}")
+            
+            # Підготовка контексту з даних
+            data_summary = self._prepare_context_data()
+            
+            # Підрахунок токенів для контексту
+            context_tokens = self._count_tokens(data_summary)
+            logger.info(f"Підготовлено контекст для звіту: {context_tokens} токенів")
+            
+            # Отримуємо системний промпт відповідно до формату
+            system_prompt = get_report_prompt(format_type)
+            
+            # Формуємо повідомлення для чату
+            messages = [
+                ChatMessage(role="system", content=system_prompt),
+                ChatMessage(role="user", content=f"Ось дані для аналізу:\n\n{data_summary}")
+            ]
+            
+            # Отримуємо відповідь від LLM
+            logger.info("Генерація звіту...")
+            response = self.llm.chat(messages)
+            
+            # Підрахунок токенів для відповіді
+            report_text = str(response)
+            response_tokens = self._count_tokens(report_text)
+            
+            logger.info(f"Звіт успішно згенеровано, токенів: {response_tokens}")
+            
+            return {
+                "report": report_text,
+                "metadata": {
+                    "context_tokens": context_tokens,
+                    "report_tokens": response_tokens,
+                    "total_tokens": context_tokens + response_tokens,
+                    "format": format_type,
+                    "documents_used": len(self.jira_documents)
+                }
+            }
+        
+        except Exception as e:
+            error_msg = f"Помилка при генерації звіту: {e}"
+            logger.error(error_msg)
+            return {"error": error_msg}
+    
+    def get_statistics(self) -> Dict[str, Any]:
+        """
+        Повертає загальну статистику за документами.
+        
+        Returns:
+            Dict[str, Any]: Словник зі статистикою
+        """
+        if not self.jira_documents:
+            return {"error": "Немає завантажених документів"}
+        
+        # Статистика по тікетах
+        status_counts = {}
+        type_counts = {}
+        priority_counts = {}
+        assignee_counts = {}
+        
+        for doc in self.jira_documents:
+            status = doc.metadata.get("status", "")
+            issue_type = doc.metadata.get("issue_type", "")
+            priority = doc.metadata.get("priority", "")
+            assignee = doc.metadata.get("assignee", "")
+            
+            if status:
+                status_counts[status] = status_counts.get(status, 0) + 1
+            if issue_type:
+                type_counts[issue_type] = type_counts.get(issue_type, 0) + 1
+            if priority:
+                priority_counts[priority] = priority_counts.get(priority, 0) + 1
+            if assignee:
+                assignee_counts[assignee] = assignee_counts.get(assignee, 0) + 1
+        
+        # Формуємо результат
+        return {
+            "document_count": len(self.jira_documents),
+            "status_counts": status_counts,
+            "type_counts": type_counts,
+            "priority_counts": priority_counts,
+            "top_assignees": dict(sorted(assignee_counts.items(), key=lambda x: x[1], reverse=True)[:5])
+        }

modules/ai_analysis/jira_hybrid_chat.py

@@ -0,0 +1,669 @@
+import logging
+import traceback
+import os
+import json
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+import tiktoken
+import pandas as pd
+from datetime import datetime
+
+from modules.config.ai_settings import (
+    get_metadata_csv,
+    MAX_TOKENS,
+    CHUNK_SIZE, CHUNK_OVERLAP, 
+    EXCLUDED_EMBED_METADATA_KEYS,
+    EXCLUDED_LLM_METADATA_KEYS,
+    SIMILARITY_TOP_K, HYBRID_SEARCH_MODE
+)
+from prompts import system_prompt_hybrid_chat
+
+# Імпорт базових компонентів LlamaIndex
+from llama_index.core import (
+    VectorStoreIndex,
+    Document,
+    StorageContext,
+    load_index_from_storage,
+    Settings
+)
+from llama_index.vector_stores.faiss import FaissVectorStore
+from llama_index.retrievers.bm25 import BM25Retriever
+from llama_index.core.query_engine import RetrieverQueryEngine
+from llama_index.core.retrievers import QueryFusionRetriever
+from llama_index.core.llms import ChatMessage
+
+# Імпорт уніфікованого менеджера індексів
+import builtins
+
+# Забезпечення бінарного формату для всіх операцій
+Settings.persist_json_format = False
+
+from modules.data_management.index_utils import count_tokens, initialize_embedding_model, check_index_integrity
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+os.environ["TORCH_DEVICE"] = "cpu"
+
+logger = logging.getLogger(__name__)
+
+class JiraHybridChat:
+    """
+    Клас для роботи з гібридним чатом на основі даних Jira.
+    Використовує комбінацію BM25 та векторного пошуку для покращення релевантності.
+    """
+    # Ліміт кешу екземплярів
+    MAX_CACHE_SIZE = 5
+    # Глобальний кеш екземплярів чату
+    chat_instances_cache = {}
+
+    def __init__(
+        self,
+        indices_dir=None,
+        app=None,
+        api_key_openai=None,
+        api_key_gemini=None,
+        model_type="gemini",
+        model_name=None,
+        temperature=0.2,
+    ):
+        """
+        Args:
+            indices_dir (str): Шлях до директорії з індексами
+            app: будь-який об'єкт, звідки беремо current_data (DataFrame)
+            api_key_openai (str): ключ OpenAI
+            api_key_gemini (str): ключ Google Gemini
+            model_type (str): "gemini" або "openai"
+            model_name (str): назва моделі
+            temperature (float): температура LLM
+        """
+        self.indices_dir = indices_dir
+        self.app = app
+        self.model_type = model_type.lower()
+        self.model_name = model_name
+        self.temperature = temperature
+
+        self.llm_initialized = False
+        self.indices_loaded = False
+
+        self.api_key_openai = api_key_openai or os.getenv("OPENAI_API_KEY", "")
+        self.api_key_gemini = api_key_gemini or os.getenv("GEMINI_API_KEY", "")
+
+        # Проставляємо змінні середовища
+        if self.api_key_openai:
+            os.environ["OPENAI_API_KEY"] = self.api_key_openai
+        if self.api_key_gemini:
+            os.environ["GEMINI_API_KEY"] = self.api_key_gemini
+
+        # Основні поля
+        self.llm = None
+        self.index = None
+        self.retriever_bm25 = None
+        self.retriever_vector = None
+        self.retriever_fusion = None
+        self.query_engine = None
+        self.df = None
+        self.jira_documents = []
+        self.nodes = []
+        
+        # Отримуємо index_manager з глобальної змінної, якщо доступний
+        self.index_manager = None
+        if hasattr(builtins, 'index_manager'):
+            self.index_manager = builtins.index_manager
+            logger.info("Використовується глобальний index_manager")
+
+        # Додаткові параметри
+        self.similarity_top_k = SIMILARITY_TOP_K
+        self.hybrid_mode = HYBRID_SEARCH_MODE
+
+        # Ініціалізація в оптимізованому порядку
+        self._initialize()
+    
+    def _initialize(self):
+        """Ініціалізація в правильному порядку для уникнення дублювання."""
+        # 1) Ініціалізуємо LLM
+        self._initialize_llm()
+        
+        # 2) Перевіряємо кеш
+        if self.indices_dir and self.indices_dir in JiraHybridChat.chat_instances_cache:
+            cached_instance = JiraHybridChat.chat_instances_cache[self.indices_dir]
+            if cached_instance.index is not None:
+                self._load_from_cache(cached_instance)
+                self.indices_loaded = True
+                logger.info(f"Використано кешований екземпляр для {self.indices_dir}")
+                return
+
+        # 3) Спробуємо завантажити з вказаного шляху
+        if self.indices_dir and self.load_indices(self.indices_dir):
+            self.indices_loaded = True
+            return
+
+        # 4) Завантажуємо дані для створення нових індексів
+        df = self._get_dataframe()
+        if df is None:
+            return
+
+        # 5) Створюємо документи
+        self.df = df
+        self.jira_documents = self._create_documents_from_dataframe(df)
+        if not self.jira_documents:
+            return
+
+        # 6) Створюємо індекси в пам'яті
+        if self._create_indices_in_memory():
+            self.indices_loaded = True
+            
+            # 7) Зберігаємо на диск, якщо вказано indices_dir
+            if self.indices_dir:
+                self._persist_indices_to_disk(self.indices_dir)
+            
+            # 8) Кешуємо екземпляр
+            self._add_to_cache()
+
+    def _initialize_llm(self):
+        """Ініціалізація LLM залежно від model_type (gemini / openai)."""
+        try:
+            if self.model_type == "gemini" and self.api_key_gemini:
+                from llama_index.llms.gemini import Gemini
+                if not self.model_name:
+                    self.model_name = "models/gemini-2.0-flash"
+
+                self.llm = Gemini(
+                    model=self.model_name,
+                    temperature=self.temperature,
+                    max_tokens=MAX_TOKENS,
+                )
+                logger.info(f"Успішно ініціалізовано Gemini модель: {self.model_name}")
+                self.llm_initialized = True
+
+            elif self.model_type == "openai" and self.api_key_openai:
+                from llama_index.llms.openai import OpenAI
+                if not self.model_name:
+                    self.model_name = "gpt-4o-mini"
+
+                self.llm = OpenAI(
+                    model=self.model_name,
+                    temperature=self.temperature,
+                    max_tokens=MAX_TOKENS
+                )
+                logger.info(f"Успішно ініціалізовано OpenAI модель: {self.model_name}")
+                self.llm_initialized = True
+
+            else:
+                error_msg = f"Не вдалося ініціалізувати LLM {self.model_type}. Перевірте ключі."
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+
+        except Exception as e:
+            logger.error(f"Помилка ініціалізації LLM: {e}")
+            logger.error(traceback.format_exc())
+
+    def _load_from_cache(self, cached_instance):
+        """Копіюємо дані з кешованого екземпляра."""
+        self.index = cached_instance.index
+        self.retriever_bm25 = cached_instance.retriever_bm25
+        self.retriever_vector = cached_instance.retriever_vector
+        self.retriever_fusion = cached_instance.retriever_fusion
+        self.query_engine = cached_instance.query_engine
+        self.jira_documents = cached_instance.jira_documents
+        self.nodes = cached_instance.nodes
+        self.df = cached_instance.df
+
+    def _add_to_cache(self):
+        """Додаємо поточний екземпляр у кеш."""
+        if not self.index or self.indices_dir is None:
+            return
+            
+        # Якщо кеш переповнений, видаляємо найстаріший запис
+        if len(JiraHybridChat.chat_instances_cache) >= self.MAX_CACHE_SIZE:
+            oldest_key = next(iter(JiraHybridChat.chat_instances_cache))
+            JiraHybridChat.chat_instances_cache.pop(oldest_key)
+            
+        # Додаємо поточний екземпляр у кеш
+        JiraHybridChat.chat_instances_cache[self.indices_dir] = self
+        logger.info(f"Додано екземпляр у кеш для {self.indices_dir}")
+
+    def _get_dataframe(self):
+        """Отримуємо DataFrame з app.current_data або з CSV файлу."""
+        # Спочатку пробуємо отримати з app.current_data
+        if hasattr(self, "app") and hasattr(self.app, "current_data"):
+            if isinstance(self.app.current_data, pd.DataFrame) and not self.app.current_data.empty:
+                logger.info(f"Отримано DataFrame з app.current_data: {len(self.app.current_data)} рядків")
+                return self.app.current_data
+
+        # Пробуємо отримати з app.last_loaded_csv
+        if hasattr(self, "app") and hasattr(self.app, "last_loaded_csv"):
+            csv_path = self.app.last_loaded_csv
+            if csv_path and os.path.exists(csv_path):
+                try:
+                    df = pd.read_csv(csv_path)
+                    logger.info(f"Завантажено DataFrame з CSV: {len(df)} рядків")
+                    return df
+                except Exception as e:
+                    logger.warning(f"Помилка при читанні CSV: {e}")
+
+        logger.warning("Немає доступних даних для створення індексів.")
+        return None
+
+    def _create_documents_from_dataframe(self, df):
+        """Конвертуємо DataFrame у список документів."""
+        documents = []
+        
+        for idx, row in df.iterrows():
+            # Основний текст документа
+            text = ""
+            if 'Description' in row and pd.notna(row['Description']):
+                text = str(row['Description'])
+
+            # Додаємо коментарі до тексту
+            for col in df.columns:
+                if col.startswith("Comment") and pd.notna(row[col]):
+                    text += f"\n\nКоментар: {row[col]}"
+
+            # Метадані документа
+            metadata = get_metadata_csv(row, idx)
+            excluded_embed_metadata_keys = []
+            excluded_llm_metadata_keys = []
+
+            # Створюємо документ
+            doc = Document(
+                text=text,
+                metadata=metadata,
+                metadata_seperator="::",
+                excluded_embed_metadata_keys=excluded_embed_metadata_keys,
+                excluded_llm_metadata_keys=excluded_llm_metadata_keys,
+                text_template="Metadata: {metadata_str}\n-----\nContent: {content}",
+            )
+            documents.append(doc)
+
+        logger.info(f"Створено {len(documents)} документів для індексів")
+        return documents
+
+    def _create_indices_in_memory(self):
+        """Створюємо індекси FAISS в пам'яті."""
+        try:
+            if not self.jira_documents:
+                return False
+                
+            # Ініціалізуємо модель ембедингів
+            try:
+                embed_model = initialize_embedding_model()
+                
+                if embed_model is None:
+                    logger.error("Не вдалося отримати модель ембедингів")
+                    return False
+                
+                # Встановлюємо модель ембедингів у глобальних налаштуваннях
+                Settings.embed_model = embed_model
+                
+                # Перевіряємо, чи це Google Embeddings
+                if "CustomEmbedding" in str(type(embed_model)):
+                    logger.info("Виявлено Google Embeddings API")
+                    # Отримуємо розмірність ембедингів через тестовий запит
+                    test_embedding = embed_model.get_text_embedding("Test")
+                    embed_dim = len(test_embedding)
+                    logger.info(f"Розмірність ембедингів Google: {embed_dim}")
+                else:
+                    # Це HuggingFace або інший тип ембедингів
+                    sample_embedding = embed_model.get_text_embedding("Test")
+                    embed_dim = len(sample_embedding)
+                    logger.info(f"Розмірність локальних ембедингів: {embed_dim}")
+                
+            except Exception as embed_error:
+                logger.error(f"Помилка при ініціалізації моделі ембедингів: {embed_error}")
+                logger.error(traceback.format_exc())
+                return False
+            
+            # Створюємо та налаштовуємо індекс
+            from llama_index.core.node_parser import TokenTextSplitter
+            
+            # Розділювач тексту для чанкінгу
+            text_splitter = TokenTextSplitter(
+                chunk_size=CHUNK_SIZE,
+                chunk_overlap=CHUNK_OVERLAP
+            )
+            
+            # Створюємо FAISS індекс
+            try:
+                import faiss
+                faiss_index = faiss.IndexFlatL2(embed_dim)
+                vector_store = FaissVectorStore(faiss_index=faiss_index)
+                
+                # Створюємо контекст зберігання
+                storage_context = StorageContext.from_defaults(vector_store=vector_store)
+                
+                # Створюємо індекс
+                self.index = VectorStoreIndex.from_documents(
+                    self.jira_documents,
+                    storage_context=storage_context,
+                    transformations=[text_splitter]
+                )
+                
+                # Зберігаємо вузли для подальшого використання
+                self.nodes = list(self.index.storage_context.docstore.docs.values())
+                
+                # Налаштування retrievers
+                self._setup_retrievers()
+                
+                logger.info("Індекси успішно створено в пам'яті")
+                return True
+                
+            except Exception as index_error:
+                logger.error(f"Помилка при створенні FAISS індексу: {index_error}")
+                logger.error(traceback.format_exc())
+                return False
+                
+        except Exception as e:
+            logger.error(f"Загальна помилка при створенні індексів: {e}")
+            logger.error(traceback.format_exc())
+            return False
+
+    def _setup_retrievers(self):
+        """Налаштовуємо різні типи retrievers для пошуку."""
+        docstore = self.index.storage_context.docstore
+        
+        # BM25 retriever (пошук за ключовими словами)
+        self.retriever_bm25 = BM25Retriever.from_defaults(
+            docstore=docstore, 
+            similarity_top_k=self.similarity_top_k
+        )
+        
+        # Векторний retriever (семантичний пошук)
+        self.retriever_vector = self.index.as_retriever(
+            similarity_top_k=self.similarity_top_k
+        )
+        
+        # Гібридний retriever (комбінація BM25 та векторного)
+        self.retriever_fusion = QueryFusionRetriever(
+            [self.retriever_bm25, self.retriever_vector],
+            mode=self.hybrid_mode,
+            similarity_top_k=self.similarity_top_k,
+            num_queries=1,
+            use_async=True
+        )
+        
+        # Query engine для виконання запитів
+        self.query_engine = RetrieverQueryEngine(self.retriever_fusion)
+
+    def _persist_indices_to_disk(self, indices_dir):
+        """Зберігаємо індекси на диск."""
+        try:
+            # Створюємо директорію, якщо її не існує
+            Path(indices_dir).mkdir(parents=True, exist_ok=True)
+
+            # Якщо індекси вже створені в пам'яті, просто зберігаємо їх на диск
+            if self.index is not None:
+                # Забезпечуємо бінарний формат збереження
+                Settings.persist_json_format = False
+                
+                # Очищаємо директорію перед збереженням
+                path_dir = Path(indices_dir)
+                if path_dir.exists():
+                    for item in path_dir.iterdir():
+                        if item.is_file():
+                            item.unlink()
+                        elif item.is_dir():
+                            import shutil
+                            shutil.rmtree(item)
+                
+                # Зберігаємо індекси
+                self.index.storage_context.persist(persist_dir=indices_dir)
+                
+                # Створюємо BM25 директорію і зберігаємо параметри
+                bm25_dir = Path(indices_dir) / "bm25"
+                bm25_dir.mkdir(exist_ok=True)
+                
+                # Зберігаємо параметри BM25
+                bm25_params = {
+                    "similarity_top_k": self.retriever_bm25.similarity_top_k,
+                    "index_creation_time": datetime.now().isoformat()
+                }
+                
+                with open(bm25_dir / "params.json", "w", encoding="utf-8") as f:
+                    json.dump(bm25_params, f, ensure_ascii=False, indent=2)
+                
+                # Створюємо маркерний файл
+                with open(os.path.join(indices_dir, "indices.valid"), "w") as f:
+                    f.write(f"Indices created at {datetime.now().isoformat()}")
+                
+                # Зберігаємо метадані
+                metadata = {
+                    "created_at": datetime.now().isoformat(),
+                    "documents_count": len(self.jira_documents),
+                    "storage_format": "binary"
+                }
+                
+                with open(os.path.join(indices_dir, "metadata.json"), "w", encoding="utf-8") as f:
+                    json.dump(metadata, f, ensure_ascii=False, indent=2)
+                
+                # Оновлюємо шлях у глобальному index_manager, якщо він доступний
+                if self.index_manager and hasattr(self.index_manager, 'register_indices_path'):
+                    session_id = getattr(self.app, 'current_session_id', None)
+                    self.index_manager.register_indices_path(indices_dir, session_id)
+                
+                self.indices_dir = indices_dir
+                logger.info(f"Індекси успішно збережено у: {indices_dir}")
+                return True
+            
+            # Якщо індекси ще не створено, але є index_manager - використовуємо його
+            elif self.index_manager and self.df is not None:
+                # Генеруємо унікальний ідентифікатор сесії, якщо він відсутній
+                if not hasattr(self.app, 'current_session_id') or self.app.current_session_id is None:
+                    import uuid
+                    session_id = f"{uuid.uuid4()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+                else:
+                    session_id = self.app.current_session_id
+                
+                # Реєструємо або створюємо нові індекси
+                if hasattr(self.index_manager, 'register_indices_path'):
+                    self.index_manager.register_indices_path(indices_dir, session_id)
+                    self.indices_dir = indices_dir
+                    return True
+                else:
+                    # Резервний варіант - створюємо нові індекси через manager
+                    index_result = self.index_manager.get_or_create_indices(self.df, session_id)
+                    
+                    if "indices_dir" in index_result:
+                        self.indices_dir = index_result["indices_dir"]
+                        logger.info(f"Індекси збережені через index_manager: {self.indices_dir}")
+                        return True
+                    else:
+                        logger.error(f"Помилка при збереженні індексів через index_manager: {index_result.get('error', 'невідома помилка')}")
+                        return False
+            else:
+                logger.error("Немає індексів для збереження")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Помилка при збереженні індексів: {e}")
+            logger.error(traceback.format_exc())
+            return False
+
+    def load_indices(self, indices_dir):
+        """Завантаження індексів з директорії, якщо вони існують."""
+        try:
+            # Перевіряємо цілісність індексів
+            is_valid, error_msg = check_index_integrity(indices_dir)
+            if not is_valid:
+                logger.warning(f"Файл маркера не знайдено в {indices_dir}: {error_msg}")
+                return False
+                
+            # Забезпечуємо бінарний формат для завантаження
+            Settings.persist_json_format = False
+            
+            # Діагностика вмісту директорії
+            import glob
+            logger.info(f"Файли у директорії {indices_dir}: {glob.glob(os.path.join(indices_dir, '*'))}")
+            
+            # Завантаження за приклад з LlamaIndex
+            try:
+                # Створюємо vector_store з директорії
+                vector_store = FaissVectorStore.from_persist_dir(indices_dir)
+                
+                # Створюємо storage_context
+                storage_context = StorageContext.from_defaults(
+                    vector_store=vector_store,
+                    persist_dir=indices_dir
+                )
+                
+                # Завантажуємо індекс
+                self.index = load_index_from_storage(
+                    storage_context=storage_context,
+                    index_cls=VectorStoreIndex
+                )
+                
+                # Налаштовуємо retrievers
+                self._setup_retrievers()
+                
+                logger.info(f"Індекси успішно завантажені з: {indices_dir}")
+                return True
+                
+            except Exception as e:
+                logger.error(f"Проблема при завантаженні індексів: {e}")
+                logger.error(traceback.format_exc())
+                return False
+                
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні індексів: {e}")
+            logger.error(traceback.format_exc())
+            return False
+
+    def chat_with_hybrid_search(self, question, chat_history=None):
+        """Виконуємо гібридний пошук і отримуємо відповідь від LLM."""
+        if not self.llm or not self.retriever_fusion:
+            error_msg = "Не вдалося виконати запит: LLM або індекси не ініціалізовано."
+            logger.error(error_msg)
+            return {"error": error_msg}
+            
+        try:
+            logger.info(f"Обробка запиту: {question}")
+            question_tokens = count_tokens(question)
+            
+            # Виконуємо пошук
+            logger.info("Виконання гібридного пошуку за запитом")
+            nodes = self.retriever_fusion.retrieve(question)
+            
+            # Формуємо контекст
+            context = "ЗНАЙДЕНІ РЕЛЕВАНТНІ ДОКУМЕНТИ:\n\n"
+            relevant_docs = []
+            
+            for i, node in enumerate(nodes):
+                context += f"Документ {i+1} (релевантність: {node.score:.4f}):\n"
+                ticket_id = node.metadata.get("issue_key", f"TICKET-{i+1}")
+                summary = node.metadata.get("summary", "Без опису")
+                context += f"ТІКЕТ {ticket_id}: {summary}\n"
+                
+                # Додаємо метадані
+                for k, v in node.metadata.items():
+                    if k in EXCLUDED_LLM_METADATA_KEYS or k in ["summary", "issue_key", "node_info"]:
+                        continue
+                    if v:
+                        context += f"{k}: {v}\n"
+                
+                # Додаємо текст документа
+                if node.text:
+                    context += f"Опис: {node.text}\n"
+                
+                context += "\n" + "-"*40 + "\n\n"
+                
+                # Зберігаємо інформацію про документ
+                relevant_docs.append({
+                    "rank": i+1,
+                    "relevance": node.score,
+                    "ticket_id": ticket_id,
+                    "summary": summary
+                })
+            
+            # Рахуємо токени в контексті
+            context_tokens = count_tokens(context)
+            
+            # Формуємо повідомлення для LLM
+            messages = []
+            messages.append(ChatMessage(role="system", content=system_prompt_hybrid_chat))
+            
+            # Додаємо історію чату, якщо вона є
+            if chat_history:
+                for h in chat_history:
+                    role_ = h.get("role", "user")
+                    content_ = h.get("content", "")
+                    if role_ in ["user", "assistant", "system"]:
+                        messages.append(ChatMessage(role=role_, content=content_))
+            
+            # Додаємо контекст і питання
+            messages.append(ChatMessage(role="system", content=f"Контекст:\n\n{context}"))
+            messages.append(ChatMessage(role="user", content=question))
+            
+            # Відправляємо запит до LLM
+            logger.info(f"Відправка запиту до LLM (токени: питання={question_tokens}, контекст={context_tokens})")
+            response = self.llm.chat(messages)
+            response_text = str(response)
+            
+            # Рахуємо токени відповіді
+            response_tokens = count_tokens(response_text)
+            logger.info(f"Отримано відповідь від LLM (токени: відповідь={response_tokens})")
+            
+            # Формуємо результат
+            return {
+                "answer": response_text,
+                "metadata": {
+                    "question_tokens": question_tokens,
+                    "context_tokens": context_tokens,
+                    "response_tokens": response_tokens,
+                    "total_tokens": question_tokens + context_tokens + response_tokens,
+                    "relevant_documents": relevant_docs[:self.similarity_top_k]
+                }
+            }
+            
+        except Exception as e:
+            error_msg = f"Помилка при виконанні запиту: {e}"
+            logger.error(error_msg)
+            logger.error(traceback.format_exc())
+            return {"error": error_msg}
+
+    # --- Допоміжні методи для сумісності ---
+
+    def chat(self, question, history=None):
+        """Скорочений метод, повертає лише текст відповіді."""
+        result = self.chat_with_hybrid_search(question, history)
+        if "error" in result:
+            return f"Помилка: {result['error']}"
+        return result["answer"]
+
+    def run_qa(self, question, history=None):
+        """Сумісність із jira_qa_assistant.py"""
+        return self.chat_with_hybrid_search(question, history)
+
+    def run_full_context_qa(self, question):
+        """Запит без історії."""
+        return self.chat_with_hybrid_search(question)
+
+    def load_data_from_dataframe(self, df):
+        """Завантаження даних з DataFrame."""
+        try:
+            self.df = df.copy()
+            self.jira_documents = self._create_documents_from_dataframe(df)
+            if self._create_indices_in_memory():
+                self.indices_loaded = True
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні даних з DataFrame: {e}")
+            return False
+
+    def load_data_from_csv(self, file_path):
+        """Завантаження даних з CSV файлу."""
+        try:
+            df = pd.read_csv(file_path)
+            return self.load_data_from_dataframe(df)
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні даних з CSV: {e}")
+            return False
+
+    def save_indices(self, indices_dir=None):
+        """Публічний метод для збереження індексів."""
+        if indices_dir is None and self.indices_dir is not None:
+            indices_dir = self.indices_dir
+        
+        if indices_dir:
+            return self._persist_indices_to_disk(indices_dir)
+        else:
+            logger.error("Не вказано директорію для збереження індексів")
+            return False

modules/ai_analysis/jira_qa_assistant.py

@@ -0,0 +1,418 @@
+import os
+import logging
+import tiktoken
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+from modules.config.ai_settings import DEFAULT_EMBEDDING_MODEL, FALLBACK_EMBEDDING_MODEL
+from prompts import system_prompt_qa_assistant
+
+# Налаштування логування
+logger = logging.getLogger(__name__)
+
+# Імпорти з LlamaIndex
+try:
+    from llama_index.core import Document
+    from llama_index.core.llms import ChatMessage
+    LLAMA_INDEX_AVAILABLE = True
+except ImportError:
+    logger.warning("Не вдалося імпортувати LlamaIndex. Встановіть необхідні залежності для використання Q/A асистента.")
+    LLAMA_INDEX_AVAILABLE = False
+
+class JiraQAAssistant:
+    """
+    Клас асистента для режиму Q/A з повним контекстом для даних Jira.
+    Дозволяє задавати питання по всім документам Jira без використання пошукових індексів.
+    """
+    def __init__(self, api_key_openai=None, api_key_gemini=None, model_type="gemini", temperature=0.2):
+        """
+        Ініціалізація Q/A асистента.
+        
+        Args:
+            api_key_openai (str): API ключ для OpenAI
+            api_key_gemini (str): API ключ для Google Gemini
+            model_type (str): Тип моделі ("openai" або "gemini")
+            temperature (float): Параметр температури для генерації відповідей
+        """
+        self.model_type = model_type.lower()
+        self.temperature = temperature
+        self.api_key_openai = api_key_openai or os.getenv("OPENAI_API_KEY", "")
+        self.api_key_gemini = api_key_gemini or os.getenv("GEMINI_API_KEY", "")
+        
+        # Перевірка наявності LlamaIndex
+        if not LLAMA_INDEX_AVAILABLE:
+            logger.error("LlamaIndex не доступний. Встановіть пакети: pip install llama-index-llms-gemini llama-index")
+            raise ImportError("LlamaIndex не встановлено. Необхідний для роботи Q/A асистента.")
+        
+        # Ініціалізація моделі LLM
+        self.llm = None
+        
+        # Дані Jira
+        self.df = None
+        self.jira_documents = []
+        
+        # Ініціалізуємо модель LLM
+        self._initialize_llm()
+    
+    def _initialize_llm(self):
+        """Ініціалізує модель LLM відповідно до налаштувань."""
+        try:
+            # Ініціалізація LLM моделі
+            if self.model_type == "gemini" and self.api_key_gemini:
+                os.environ["GEMINI_API_KEY"] = self.api_key_gemini
+                
+                from llama_index.llms.gemini import Gemini
+                self.llm = Gemini(
+                    model="models/gemini-2.0-flash",
+                    temperature=self.temperature,
+                    max_tokens=4096,
+                )
+                logger.info("Успішно ініціалізовано Gemini 2.0 Flash модель")
+            elif self.model_type == "openai" and self.api_key_openai:
+                os.environ["OPENAI_API_KEY"] = self.api_key_openai
+                
+                from llama_index.llms.openai import OpenAI
+                self.llm = OpenAI(
+                    model="gpt-4o-mini",
+                    temperature=self.temperature,
+                    max_tokens=4096
+                )
+                logger.info("Успішно ініціалізовано OpenAI GPT-4o-mini модель")
+            else:
+                error_msg = f"Не вдалося ініціалізувати LLM модель типу {self.model_type}. Перевірте API ключі."
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+                
+        except Exception as e:
+            logger.error(f"Помилка ініціалізації моделі LLM: {e}")
+            raise
+    
+    def load_documents_from_dataframe(self, df):
+        """
+        Завантаження документів прямо з DataFrame без створення індексів.
+        
+        Args:
+            df (pandas.DataFrame): DataFrame з даними Jira
+            
+        Returns:
+            bool: True якщо дані успішно завантажено
+        """
+        try:
+            logger.info("Завантаження даних з DataFrame для Q/A")
+            
+            # Зберігаємо оригінальний DataFrame
+            self.df = df.copy()
+            
+            # Конвертуємо дані в документи
+            self._convert_dataframe_to_documents()
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні даних з DataFrame: {e}")
+            return False
+    
+    def _convert_dataframe_to_documents(self):
+        """
+        Перетворює дані DataFrame в об'єкти Document для роботи з моделлю LLM.
+        """
+        import pandas as pd
+        
+        if self.df is None:
+            logger.error("Не вдалося створити документи: відсутні дані DataFrame")
+            return
+            
+        logger.info("Перетворення даних DataFrame в документи для Q/A...")
+        
+        self.jira_documents = []
+        
+        for idx, row in self.df.iterrows():
+            # Основний текст - опис тікета
+            text = ""
+            if 'Description' in row and pd.notna(row['Description']):
+                text = str(row['Description'])
+                
+            # Додавання коментарів, якщо вони є
+            for col in self.df.columns:
+                if col.startswith('Comment') and pd.notna(row[col]):
+                    text += f"\n\nКоментар: {str(row[col])}"
+            
+            # Метадані для документа
+            metadata = {
+                "issue_key": row['Issue key'] if 'Issue key' in row and pd.notna(row['Issue key']) else "",
+                "issue_type": row['Issue Type'] if 'Issue Type' in row and pd.notna(row['Issue Type']) else "",
+                "status": row['Status'] if 'Status' in row and pd.notna(row['Status']) else "",
+                "priority": row['Priority'] if 'Priority' in row and pd.notna(row['Priority']) else "",
+                "assignee": row['Assignee'] if 'Assignee' in row and pd.notna(row['Assignee']) else "",
+                "reporter": row['Reporter'] if 'Reporter' in row and pd.notna(row['Reporter']) else "",
+                "created": str(row['Created']) if 'Created' in row and pd.notna(row['Created']) else "",
+                "updated": str(row['Updated']) if 'Updated' in row and pd.notna(row['Updated']) else "",
+                "summary": row['Summary'] if 'Summary' in row and pd.notna(row['Summary']) else "",
+                "project": row['Project name'] if 'Project name' in row and pd.notna(row['Project name']) else ""
+            }
+            
+            # Додатково перевіряємо поле зв'язків, якщо воно є
+            if 'Outward issue link (Relates)' in row and pd.notna(row['Outward issue link (Relates)']):
+                metadata["related_issues"] = row['Outward issue link (Relates)']
+            
+            # Додатково перевіряємо інші можливі поля зв'язків
+            for col in self.df.columns:
+                if col.startswith('Outward issue link') and col != 'Outward issue link (Relates)' and pd.notna(row[col]):
+                    link_type = col.replace('Outward issue link ', '').strip('()')
+                    if "links" not in metadata:
+                        metadata["links"] = {}
+                    metadata["links"][link_type] = str(row[col])
+            
+            # Створення документа
+            doc = Document(
+                text=text,
+                metadata=metadata
+            )
+            
+            self.jira_documents.append(doc)
+        
+        logger.info(f"Створено {len(self.jira_documents)} документів для Q/A")
+        
+    def _count_tokens(self, text: str, model: str = "gpt-3.5-turbo") -> int:
+        """
+        Підраховує приблизну кількість токенів для тексту.
+        
+        Args:
+            text (str): Текст для підрахунку токенів
+            model (str): Назва моделі для вибору енкодера
+            
+        Returns:
+            int: Кількість токенів
+        """
+        try:
+            encoding = tiktoken.encoding_for_model(model)
+            tokens = encoding.encode(text)
+            return len(tokens)
+        except Exception as e:
+            logger.warning(f"Не вдалося підрахувати токени через tiktoken: {e}")
+            # Якщо не можемо використати tiktoken, робимо просту оцінку
+            # В середньому 1 токен ≈ 3 символи для змішаного тексту
+            return len(text) // 3  # Приблизна оцінка
+
+    def run_qa(self, question: str) -> Dict[str, Any]:
+        """
+        Запускає режим Q/A з повним контекстом.
+        
+        Args:
+            question (str): Питання користувача
+            
+        Returns:
+            Dict[str, Any]: Словник з результатами, включаючи відповідь та метадані
+        """
+        if not self.jira_documents or not self.llm:
+            error_msg = "Не вдалося виконати запит: відсутні документи або LLM"
+            logger.error(error_msg)
+            return {"error": error_msg}
+        
+        try:
+            logger.info(f"Запуск режиму Q/A з повним контекстом для питання: {question}")
+            
+            # Підготовка повного контексту з усіх документів
+            full_context = "ПОВНИЙ КОНТЕКСТ JIRA ТІКЕТІВ:\n\n"
+            
+            # Додаємо статистику по тікетах
+            status_counts = {}
+            type_counts = {}
+            priority_counts = {}
+            assignee_counts = {}
+            
+            for doc in self.jira_documents:
+                status = doc.metadata.get("status", "")
+                issue_type = doc.metadata.get("issue_type", "")
+                priority = doc.metadata.get("priority", "")
+                assignee = doc.metadata.get("assignee", "")
+                
+                if status:
+                    status_counts[status] = status_counts.get(status, 0) + 1
+                if issue_type:
+                    type_counts[issue_type] = type_counts.get(issue_type, 0) + 1
+                if priority:
+                    priority_counts[priority] = priority_counts.get(priority, 0) + 1
+                if assignee:
+                    assignee_counts[assignee] = assignee_counts.get(assignee, 0) + 1
+            
+            # Додаємо статистику до контексту
+            full_context += f"Всього тікетів: {len(self.jira_documents)}\n\n"
+            
+            full_context += "Статуси:\n"
+            for status, count in sorted(status_counts.items(), key=lambda x: x[1], reverse=True):
+                full_context += f"- {status}: {count}\n"
+            
+            full_context += "\nТипи тікетів:\n"
+            for issue_type, count in sorted(type_counts.items(), key=lambda x: x[1], reverse=True):
+                full_context += f"- {issue_type}: {count}\n"
+            
+            full_context += "\nПріоритети:\n"
+            for priority, count in sorted(priority_counts.items(), key=lambda x: x[1], reverse=True):
+                full_context += f"- {priority}: {count}\n"
+            
+            # Додаємо топ-5 виконавців
+            if assignee_counts:
+                full_context += "\nТоп виконавців:\n"
+                for assignee, count in sorted(assignee_counts.items(), key=lambda x: x[1], reverse=True)[:5]:
+                    full_context += f"- {assignee}: {count} тікетів\n"
+            
+            # Додаємо всі тікети з метаданими та текстом
+            full_context += "\nДЕТАЛЬНА ІНФОРМАЦІЯ ПРО ТІКЕТИ:\n\n"
+            
+            for i, doc in enumerate(self.jira_documents):
+                # Використовуємо ключ тікета, якщо доступний, інакше номер
+                ticket_id = doc.metadata.get("issue_key", f"TICKET-{i+1}")
+                summary = doc.metadata.get("summary", "Без опису")
+                
+                full_context += f"ТІКЕТ {ticket_id}: {summary}\n"
+                
+                # Додаємо всі метадані
+                for key, value in doc.metadata.items():
+                    # Пропускаємо виключені поля та вже виведені поля
+                    if key == "project" or key == "summary" or key == "issue_key":
+                        continue
+                    
+                    if isinstance(value, dict):
+                        # Обробка вкладених словників (наприклад, links)
+                        full_context += f"{key}:\n"
+                        for sub_key, sub_value in value.items():
+                            if sub_value:
+                                full_context += f"  - {sub_key}: {sub_value}\n"
+                    elif value:  # Додаємо тільки непорожні значення
+                        full_context += f"{key}: {value}\n"
+                
+                # Додаємо текст документа
+                if doc.text:
+                    # Якщо текст дуже довгий, обмежуємо його для економії токенів
+                    if len(doc.text) > 1000:
+                        truncated_text = doc.text[:1000] + "... [текст скорочено]"
+                        full_context += f"Опис: {truncated_text}\n"
+                    else:
+                        full_context += f"Опис: {doc.text}\n"
+                
+                full_context += "\n" + "-"*40 + "\n\n"
+            
+            # Підрахуємо токени для по��ного контексту
+            full_context_tokens = self._count_tokens(full_context)
+            logger.info(f"Приблизна кількість токенів у повному контексті: {full_context_tokens}")
+            
+            # Перевірка на перевищення ліміту токенів (для Gemini 2.0 Flash - 1,048,576 вхідних токенів)
+            max_input_tokens = 1048576
+            if full_context_tokens > max_input_tokens:
+                logger.warning(f"Контекст перевищує ліміт вхідних токенів моделі ({full_context_tokens} > {max_input_tokens}).")
+                logger.info("Виконується скорочення контексту...")
+                
+                # Обчислюємо, скільки можна включити тікетів
+                tokens_per_ticket = full_context_tokens / len(self.jira_documents)
+                safe_ticket_count = int(max_input_tokens * 0.8 / tokens_per_ticket)  # 80% від ліміту для безпеки
+                
+                # Обчислюємо новий контекст з меншою кількістю тікетів
+                full_context = full_context.split("ДЕТАЛЬНА ІНФОРМАЦІЯ ПРО ТІКЕТИ:")[0]
+                full_context += "\nДЕТАЛЬНА ІНФОРМАЦІЯ ПРО ТІКЕТИ (скорочено):\n\n"
+                
+                for i, doc in enumerate(self.jira_documents[:safe_ticket_count]):
+                    ticket_id = doc.metadata.get("issue_key", f"TICKET-{i+1}")
+                    summary = doc.metadata.get("summary", "Без опису")
+                    
+                    full_context += f"ТІКЕТ {ticket_id}: {summary}\n"
+                    
+                    # Додаємо найважливіші метадані
+                    important_fields = ["status", "priority", "assignee", "created", "updated"]
+                    for key in important_fields:
+                        value = doc.metadata.get(key, "")
+                        if value:
+                            full_context += f"{key}: {value}\n"
+                    
+                    # Додаємо скорочений опис
+                    if doc.text:
+                        short_text = doc.text[:300] + "..." if len(doc.text) > 300 else doc.text
+                        full_context += f"Опис: {short_text}\n"
+                    
+                    full_context += "\n" + "-"*30 + "\n\n"
+                
+                full_context += f"\n[Показано {safe_ticket_count} з {len(self.jira_documents)} тікетів через обмеження контексту]\n"
+                
+                # Перераховуємо токени для скороченого контексту
+                full_context_tokens = self._count_tokens(full_context)
+                logger.info(f"Скорочений контекст: {full_context_tokens} токенів")
+            
+            # Системний промпт для режиму Q/A
+            system_prompt = system_prompt_qa_assistant
+            
+            # Підрахунок токенів для питання
+            question_tokens = self._count_tokens(question)
+            
+            # Формуємо повідомлення для чату
+            messages = [
+                ChatMessage(role="system", content=system_prompt),
+                ChatMessage(role="system", content=full_context),
+                ChatMessage(role="user", content=question)
+            ]
+            
+            # Отримуємо відповідь від LLM
+            logger.info("Генерація відповіді...")
+            response = self.llm.chat(messages)
+            
+            # Підрахунок токенів для відповіді
+            response_text = str(response)
+            response_tokens = self._count_tokens(response_text)
+            
+            logger.info(f"Відповідь успішно згенеровано, токенів: {response_tokens}")
+            
+            return {
+                "answer": response_text,
+                "metadata": {
+                    "question_tokens": question_tokens,
+                    "context_tokens": full_context_tokens,
+                    "response_tokens": response_tokens,
+                    "total_tokens": question_tokens + full_context_tokens + response_tokens,
+                    "documents_used": len(self.jira_documents)
+                }
+            }
+        
+        except Exception as e:
+            error_msg = f"Помилка при виконанні Q/A з повним контекстом: {e}"
+            logger.error(error_msg)
+            return {"error": error_msg}
+        
+    def get_statistics(self) -> Dict[str, Any]:
+        """
+        Повертає загальну статистику за документами.
+        
+        Returns:
+            Dict[str, Any]: Словник зі статистикою
+        """
+        if not self.jira_documents:
+            return {"error": "Немає завантажених документів"}
+        
+        # Статистика по тікетах
+        status_counts = {}
+        type_counts = {}
+        priority_counts = {}
+        assignee_counts = {}
+        
+        for doc in self.jira_documents:
+            status = doc.metadata.get("status", "")
+            issue_type = doc.metadata.get("issue_type", "")
+            priority = doc.metadata.get("priority", "")
+            assignee = doc.metadata.get("assignee", "")
+            
+            if status:
+                status_counts[status] = status_counts.get(status, 0) + 1
+            if issue_type:
+                type_counts[issue_type] = type_counts.get(issue_type, 0) + 1
+            if priority:
+                priority_counts[priority] = priority_counts.get(priority, 0) + 1
+            if assignee:
+                assignee_counts[assignee] = assignee_counts.get(assignee, 0) + 1
+        
+        # Формуємо результат
+        return {
+            "document_count": len(self.jira_documents),
+            "status_counts": status_counts,
+            "type_counts": type_counts,
+            "priority_counts": priority_counts,
+            "top_assignees": dict(sorted(assignee_counts.items(), key=lambda x: x[1], reverse=True)[:5])
+        }

modules/config/ai_settings.py

@@ -0,0 +1,47 @@
+import pandas as pd
+
+
+# Налаштування Google Embeddings
+GOOGLE_EMBEDDING_MODEL = "text-embedding-004"  # Модель Google Embeddings
+USE_GOOGLE_EMBEDDINGS = True  # Прапорець для вмикання/вимикання Google Embeddings
+
+
+# Налаштування для моделей ембедингів
+DEFAULT_EMBEDDING_MODEL = "paraphrase-multilingual-MiniLM-L12-v2"
+FALLBACK_EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+
+# Налаштування для індексування
+CHUNK_SIZE = 2048  # Розмір чанка для розбиття документів
+CHUNK_OVERLAP = 128  # Перекриття між чанками
+SIMILARITY_TOP_K = 10  # Кількість найбільш релевантних документів для пошуку
+
+# Додаткові налаштування для форсування CPU
+FORCE_CPU = True
+
+# Налаштування LLM
+MAX_TOKENS = 8192
+
+# Виключені метадані
+EXCLUDED_EMBED_METADATA_KEYS = ["node_info", "project"]  # Метадані, які не використовуються для ембедингів
+EXCLUDED_LLM_METADATA_KEYS = ["node_info", "project"]  # Метадані, які не передаються в LLM
+
+# Налаштування для гібридного пошуку
+HYBRID_SEARCH_MODE = "reciprocal_rerank"  # Режим гібридного пошуку (reciprocal_rerank, simple)
+
+def get_metadata_csv(row, idx):
+    return {
+        "issue_key": row.get('Issue key', '') if pd.notna(row.get('Issue key', '')) else "",
+        "issue_type": row.get('Issue Type', '') if pd.notna(row.get('Issue Type', '')) else "",
+        "status": row.get('Status', '') if pd.notna(row.get('Status', '')) else "",
+        "priority": row.get('Priority', '') if pd.notna(row.get('Priority', '')) else "",
+        "assignee": row.get('Assignee', '') if pd.notna(row.get('Assignee', '')) else "",
+        "reporter": row.get('Reporter', '') if pd.notna(row.get('Reporter', '')) else "",
+        "created": str(row.get('Created', '')) if pd.notna(row.get('Created', '')) else "",
+        "updated": str(row.get('Updated', '')) if pd.notna(row.get('Updated', '')) else "",
+        "summary": row.get('Summary', '') if pd.notna(row.get('Summary', '')) else "",
+        "project": row.get('Project name', '') if pd.notna(row.get('Project name', '')) else "",
+        "project_key": row.get('Project key', '') if pd.notna(row.get('Project key', '')) else "",
+        "labels": row.get('Labels', '') if pd.notna(row.get('Labels', '')) else "",
+        "comment": row.get('Comment', '') if pd.notna(row.get('Comment', '')) else "",
+        "row_index": idx
+    }

modules/config/logging_config.py

@@ -0,0 +1,52 @@
+import logging
+import os
+from pathlib import Path
+
+def setup_logging(log_dir="logs", log_level=logging.INFO):
+    """
+    Налаштування логування.
+    
+    Args:
+        log_dir (str): Директорія для зберігання логів
+        log_level (int): Рівень логування
+    """
+    # Створюємо директорію для логів, якщо вона не існує
+    log_path = Path(log_dir)
+    log_path.mkdir(exist_ok=True, parents=True)
+    
+    # Налаштовуємо формат логів
+    log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    date_format = "%Y-%m-%d %H:%M:%S"
+    
+    # Налаштовуємо базовий логер
+    logging.basicConfig(
+        level=log_level,
+        format=log_format,
+        datefmt=date_format,
+        handlers=[
+            logging.FileHandler(log_path / "app.log", encoding="utf-8"),
+            logging.StreamHandler()
+        ]
+    )
+    
+    # Налаштовуємо окремий логер для індексів
+    index_logger = logging.getLogger("modules.data_management")
+    index_file_handler = logging.FileHandler(log_path / "indices.log", encoding="utf-8")
+    index_file_handler.setFormatter(logging.Formatter(log_format, date_format))
+    index_logger.addHandler(index_file_handler)
+    index_logger.setLevel(log_level)
+    
+    # Налаштовуємо окремий логер для AI аналізу
+    ai_logger = logging.getLogger("modules.ai_analysis")
+    ai_file_handler = logging.FileHandler(log_path / "ai_analysis.log", encoding="utf-8")
+    ai_file_handler.setFormatter(logging.Formatter(log_format, date_format))
+    ai_logger.addHandler(ai_file_handler)
+    ai_logger.setLevel(log_level)
+    
+    # Зменшуємо рівень логування для деяких бібліотек
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore").setLevel(logging.WARNING)
+    
+    # Логуємо початок роботи
+    logging.info("Логування налаштовано")

modules/config/paths.py

@@ -0,0 +1,9 @@
+import os
+from pathlib import Path
+
+# Базові директорії
+BASE_DIR = Path(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+TEMP_DIR = BASE_DIR / "temp"
+
+# Директорії для індексів
+INDICES_DIR = TEMP_DIR / "indices"

modules/core/app_manager.py

@@ -0,0 +1,648 @@
+import os
+import logging
+import pandas as pd
+import json
+from datetime import datetime
+from pathlib import Path
+import importlib
+import requests
+
+logger = logging.getLogger(__name__)
+
+class AppManager:
+    """
+    Класс, який керує роботою додатку Jira AI Assistant
+    """
+    def __init__(self):
+        """
+        Ініціалізація менеджера додатку
+        """
+        self.config = self._load_config()
+        self.setup_logging()
+        self.data = None
+        self.analyses = {}
+        self.reports = {}
+        
+        # Створення директорій для даних, якщо вони не існують
+        self._create_directories()
+    
+    def _load_config(self):
+        """
+        Завантаження конфігурації додатку
+        
+        Returns:
+            dict: Конфігурація додатку
+        """
+        try:
+            # Спочатку спробуємо завантажити з файлу
+            config_path = Path("config.json")
+            
+            if config_path.exists():
+                with open(config_path, 'r', encoding='utf-8') as f:
+                    config = json.load(f)
+                logger.info("Конфігурація завантажена з файлу")
+                return config
+            
+            # Якщо файл не існує, використовуємо стандартну конфігурацію
+            config = {
+                "app_name": "Jira AI Assistant",
+                "version": "1.0.0",
+                "data_dir": "data",
+                "reports_dir": "reports",
+                "temp_dir": "temp",
+                "log_dir": "logs",
+                "log_level": "INFO",
+                "default_inactive_days": 14,
+                "openai_model": "gpt-3.5-turbo",
+                "gemini_model": "gemini-pro",
+                "max_results": 500
+            }
+            
+            # Зберігаємо стандартну конфігурацію у файл
+            with open(config_path, 'w', encoding='utf-8') as f:
+                json.dump(config, f, indent=2)
+            
+            logger.info("Створено стандартну конфігурацію")
+            return config
+            
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні конфігурації: {e}")
+            
+            # Аварійна конфігурація
+            return {
+                "app_name": "Jira AI Assistant",
+                "version": "1.0.0",
+                "data_dir": "data",
+                "reports_dir": "reports",
+                "temp_dir": "temp",
+                "log_dir": "logs",
+                "log_level": "INFO",
+                "default_inactive_days": 14,
+                "openai_model": "gpt-3.5-turbo",
+                "gemini_model": "gemini-pro",
+                "max_results": 500
+            }
+    
+    def setup_logging(self):
+        """
+        Налаштування логування
+        """
+        try:
+            log_dir = Path(self.config.get("log_dir", "logs"))
+            log_dir.mkdir(exist_ok=True, parents=True)
+            
+            log_file = log_dir / f"app_{datetime.now().strftime('%Y%m%d')}.log"
+            
+            # Рівень логування з конфігурації
+            log_level_str = self.config.get("log_level", "INFO")
+            log_level = getattr(logging, log_level_str, logging.INFO)
+            
+            # Налаштування логера
+            logging.basicConfig(
+                level=log_level,
+                format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                handlers=[
+                    logging.FileHandler(log_file),
+                    logging.StreamHandler()
+                ]
+            )
+            
+            logger.info(f"Логування налаштовано. Рівень: {log_level_str}, файл: {log_file}")
+            
+        except Exception as e:
+            print(f"Помилка при налаштуванні логування: {e}")
+            
+            # Аварійне налаштування логування
+            logging.basicConfig(
+                level=logging.INFO,
+                format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+            )
+    
+    def _create_directories(self):
+        """
+        Створення необхідних директорій
+        """
+        try:
+            directories = [
+                self.config.get("data_dir", "data"),
+                self.config.get("reports_dir", "reports"),
+                self.config.get("temp_dir", "temp"),
+                self.config.get("log_dir", "logs")
+            ]
+            
+            for directory in directories:
+                Path(directory).mkdir(exist_ok=True, parents=True)
+                
+            logger.info("Створено необхідні директорії")
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні директорій: {e}")
+    
+    def load_csv_data(self, file_path):
+        """
+        Завантаження даних з CSV файлу
+        
+        Args:
+            file_path (str): Шлях до CSV файлу
+            
+        Returns:
+            pandas.DataFrame: Завантажені дані або None у випадку помилки
+        """
+        try:
+            logger.info(f"Завантаження даних з CSV файлу: {file_path}")
+            
+            # Імпортуємо необхідний модуль
+            from modules.data_import.csv_importer import JiraCsvImporter
+            
+            # Створюємо імпортер та завантажуємо дані
+            importer = JiraCsvImporter(file_path)
+            self.data = importer.load_data()
+            
+            if self.data is None:
+                logger.error("Не вдалося завантажити дані з CSV файлу")
+                return None
+            
+            logger.info(f"Успішно завантажено {len(self.data)} записів")
+            
+            # Зберігаємо копію даних
+            self._save_data_copy(file_path)
+            
+            return self.data
+            
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні даних з CSV: {e}")
+            return None
+    
+    def _save_data_copy(self, original_file_path):
+        """
+        Збереження копії даних
+        
+        Args:
+            original_file_path (str): Шлях до оригінального файлу
+        """
+        try:
+            if self.data is None:
+                return
+            
+            # Створюємо ім'я файлу на основі оригінального
+            file_name = os.path.basename(original_file_path)
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            new_file_name = f"{os.path.splitext(file_name)[0]}_{timestamp}.csv"
+            
+            # Шлях для збереження
+            data_dir = Path(self.config.get("data_dir", "data"))
+            save_path = data_dir / new_file_name
+            
+            # Зберігаємо дані
+            self.data.to_csv(save_path, index=False, encoding='utf-8')
+            
+            logger.info(f"Збережено копію даних у {save_path}")
+            
+        except Exception as e:
+            logger.error(f"Помилка при збереженні копії даних: {e}")
+    
+    def connect_to_jira(self, jira_url, username, api_token):
+        """
+        Підключення до Jira API
+        
+        Args:
+            jira_url (str): URL Jira сервера
+            username (str): Ім'я користувача
+            api_token (str): API токен
+            
+        Returns:
+            bool: True, якщо підключення успішне, False у іншому випадку
+        """
+        try:
+            logger.info(f"Тестування підключення до Jira: {jira_url}")
+            
+            # Спроба прямого HTTP запиту до сервера
+            response = requests.get(
+                f"{jira_url}/rest/api/2/serverInfo",
+                auth=(username, api_token),
+                timeout=10,
+                verify=True
+            )
+            
+            if response.status_code == 200:
+                logger.info("Успішне підключення до Jira API")
+                
+                # Зберігаємо дані про підключення
+                self.jira_connection = {
+                    "url": jira_url,
+                    "username": username,
+                    "api_token": api_token
+                }
+                
+                return True
+            else:
+                logger.error(f"Помилка підключення до Jira: {response.status_code}, {response.text}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Помилка при підключенні до Jira: {e}")
+            return False
+    
+    def get_jira_data(self, project_key, board_id=None, max_results=None):
+        """
+        Отримання даних з Jira API
+        
+        Args:
+            project_key (str): Ключ проекту
+            board_id (int): ID дошки (необов'язково)
+            max_results (int): Максимальна кількість результатів
+            
+        Returns:
+            pandas.DataFrame: Отримані дані або None у випадку помилки
+        """
+        try:
+            if not hasattr(self, 'jira_connection'):
+                logger.error("Немає з'єднання з Jira")
+                return None
+            
+            logger.info(f"Отримання даних з Jira для проекту {project_key}")
+            
+            # Імпортуємо необхідний модуль
+            from modules.data_import.jira_api import JiraConnector
+            
+            # Параметри з'єднання
+            jira_url = self.jira_connection["url"]
+            username = self.jira_connection["username"]
+            api_token = self.jira_connection["api_token"]
+            
+            # Створюємо коннектор
+            connector = JiraConnector(jira_url, username, api_token)
+            
+            # Отримуємо дані
+            if board_id:
+                issues = connector.get_board_issues(
+                    board_id, 
+                    project_key, 
+                    max_results=max_results or self.config.get("max_results", 500)
+                )
+            else:
+                issues = connector.get_project_issues(
+                    project_key, 
+                    max_results=max_results or self.config.get("max_results", 500)
+                )
+            
+            if not issues:
+                logger.error("Не вдалося отримати тікети з Jira")
+                return None
+            
+            # Експортуємо у CSV та завантажуємо дані
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            temp_dir = Path(self.config.get("temp_dir", "temp"))
+            temp_csv_path = temp_dir / f"jira_export_{project_key}_{timestamp}.csv"
+            
+            df = connector.export_issues_to_csv(issues, temp_csv_path)
+            self.data = df
+            
+            logger.info(f"Успішно отримано {len(df)} тікетів з Jira")
+            return df
+            
+        except Exception as e:
+            logger.error(f"Помилка при отриманні даних з Jira: {e}")
+            return None
+    
+    def analyze_data(self, inactive_days=None):
+        """
+        Аналіз завантажених даних
+        
+        Args:
+            inactive_days (int): Кількість днів для визначення неактивних тікетів
+            
+        Returns:
+            dict: Результати аналізу
+        """
+        try:
+            if self.data is None:
+                logger.error("Немає даних для аналізу")
+                return None
+            
+            logger.info("Аналіз даних...")
+            
+            # Параметри аналізу
+            if inactive_days is None:
+                inactive_days = self.config.get("default_inactive_days", 14)
+            
+            # Імпортуємо необхідний модуль
+            from modules.data_analysis.statistics import JiraDataAnalyzer
+            
+            # Створюємо аналізатор та виконуємо аналіз
+            analyzer = JiraDataAnalyzer(self.data)
+            
+            # Генеруємо базову статистику
+            stats = analyzer.generate_basic_statistics()
+            
+            # Аналізуємо неактивні тікети
+            inactive_issues = analyzer.analyze_inactive_issues(days=inactive_days)
+            
+            # Аналізуємо часову шкалу
+            timeline = analyzer.analyze_timeline()
+            
+            # Аналізуємо час виконання
+            lead_time = analyzer.analyze_lead_time()
+            
+            # Зберігаємо результати аналізу
+            analysis_result = {
+                "stats": stats,
+                "inactive_issues": inactive_issues,
+                "timeline": timeline.to_dict() if isinstance(timeline, pd.DataFrame) else None,
+                "lead_time": lead_time
+            }
+            
+            # Зберігаємо в історії аналізів
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            self.analyses[timestamp] = analysis_result
+            
+            logger.info("Аналіз даних успішно завершено")
+            return analysis_result
+            
+        except Exception as e:
+            logger.error(f"Помилка при аналізі даних: {e}")
+            return None
+    
+    def generate_visualizations(self, analysis_result=None):
+        """
+        Генерація візуалізацій на основі аналізу
+        
+        Args:
+            analysis_result (dict): Результати аналізу або None для використання останнього аналізу
+            
+        Returns:
+            dict: Об'єкти Figure для різних візуалізацій
+        """
+        try:
+            if self.data is None:
+                logger.error("Немає даних для візуалізації")
+                return None
+            
+            # Якщо аналіз не вказано, використовуємо останній
+            if analysis_result is None:
+                if not self.analyses:
+                    logger.error("Немає результатів аналізу для візуалізації")
+                    return None
+                
+                # Отримуємо останній аналіз
+                last_timestamp = max(self.analyses.keys())
+                analysis_result = self.analyses[last_timestamp]
+            
+            logger.info("Генерація візуалізацій...")
+            
+            # Імпортуємо необхідний модуль
+            from modules.data_analysis.visualizations import JiraVisualizer
+            
+            # Створюємо візуалізатор
+            visualizer = JiraVisualizer(self.data)
+            
+            # Генеруємо візуалізації
+            visualizations = visualizer.plot_all()
+            
+            logger.info("Візуалізації успішно згенеровано")
+            return visualizations
+            
+        except Exception as e:
+            logger.error(f"Помилка при генерації візуалізацій: {e}")
+            return None
+    
+    def analyze_with_ai(self, analysis_result=None, api_key=None, model_type="openai"):
+        """
+        Аналіз даних за допомогою AI
+        
+        Args:
+            analysis_result (dict): Результати аналізу або None для використання останнього аналізу
+            api_key (str): API ключ для LLM
+            model_type (str): Тип моделі ("openai" або "gemini")
+            
+        Returns:
+            str: Результат AI аналізу
+        """
+        try:
+            # Якщо аналіз не вказано, використовуємо останній
+            if analysis_result is None:
+                if not self.analyses:
+                    logger.error("Немає результатів аналізу для AI")
+                    return None
+                
+                # Отримуємо останній аналіз
+                last_timestamp = max(self.analyses.keys())
+                analysis_result = self.analyses[last_timestamp]
+            
+            logger.info(f"Аналіз даних за допомогою AI ({model_type})...")
+            
+            # Імпортуємо необхідний модуль
+            from modules.ai_analysis.llm_connector import LLMConnector
+            
+            # Створюємо коннектор до LLM
+            llm = LLMConnector(api_key=api_key, model_type=model_type)
+            
+            # Виконуємо аналіз
+            stats = analysis_result.get("stats", {})
+            inactive_issues = analysis_result.get("inactive_issues", {})
+            
+            ai_analysis = llm.analyze_jira_data(stats, inactive_issues)
+            
+            logger.info("AI аналіз успішно завершено")
+            return ai_analysis
+            
+        except Exception as e:
+            logger.error(f"Помилка при AI аналізі: {e}")
+            return f"Помилка при виконанні AI аналізу: {str(e)}"
+    
+    def generate_report(self, analysis_result=None, ai_analysis=None, format="markdown", include_visualizations=True):
+        """
+        Генерація звіту на основі аналізу
+        
+        Args:
+            analysis_result (dict): Результати аналізу або None для використання останнього аналізу
+            ai_analysis (str): Результат AI аналізу
+            format (str): Формат звіту ("markdown", "html", "pdf")
+            include_visualizations (bool): Чи включати візуалізації у звіт
+            
+        Returns:
+            str: Текст звіту
+        """
+        try:
+            if self.data is None:
+                logger.error("Немає даних для генерації звіту")
+                return None
+            
+            # Якщо аналіз не вказано, використовуємо останній
+            if analysis_result is None:
+                if not self.analyses:
+                    logger.error("Немає результатів аналізу для звіту")
+                    return None
+                
+                # Отримуємо останній ана��із
+                last_timestamp = max(self.analyses.keys())
+                analysis_result = self.analyses[last_timestamp]
+            
+            logger.info(f"Генерація звіту у форматі {format}...")
+            
+            # Імпортуємо необхідний модуль
+            from modules.reporting.report_generator import ReportGenerator
+            
+            # Отримуємо дані з аналізу
+            stats = analysis_result.get("stats", {})
+            inactive_issues = analysis_result.get("inactive_issues", {})
+            
+            # Генеруємо візуалізації, якщо потрібно
+            visualization_data = None
+            if include_visualizations:
+                visualization_data = self.generate_visualizations(analysis_result)
+            
+            # Створюємо генератор звітів
+            report_generator = ReportGenerator(self.data, stats, inactive_issues, ai_analysis)
+            
+            # Генеруємо звіт у потрібному форматі
+            if format.lower() == "markdown":
+                report = report_generator.create_markdown_report()
+            elif format.lower() == "html":
+                report = report_generator.create_html_report(include_visualizations=include_visualizations,
+                                                            visualization_data=visualization_data)
+            else:
+                # Для інших форматів спочатку генеруємо HTML
+                temp_html = report_generator.create_html_report(include_visualizations=include_visualizations,
+                                                              visualization_data=visualization_data)
+                report = temp_html
+            
+            # Зберігаємо звіт в історії
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            self.reports[timestamp] = {
+                "format": format,
+                "report": report
+            }
+            
+            logger.info(f"Звіт успішно згенеровано у форматі {format}")
+            return report
+            
+        except Exception as e:
+            logger.error(f"Помилка при генерації звіту: {e}")
+            return f"Помилка при генерації звіту: {str(e)}"
+    
+    def save_report(self, report=None, filepath=None, format="markdown", include_visualizations=True):
+        """
+        Збереження звіту у файл
+        
+        Args:
+            report (str): Текст звіту або None для генерації нового
+            filepath (str): Шлях для збереження файлу
+            format (str): Формат звіту ("markdown", "html", "pdf")
+            include_visualizations (bool): Чи включати візуалізації у звіт
+            
+        Returns:
+            str: Шлях до збереженого файлу
+        """
+        try:
+            # Якщо звіт не вказано, генеруємо новий
+            if report is None:
+                report = self.generate_report(format=format, include_visualizations=include_visualizations)
+                
+                if report is None:
+                    logger.error("Не вдалося згенерувати звіт")
+                    return None
+            
+            # Якщо шлях не вказано, створюємо стандартний
+            if filepath is None:
+                reports_dir = Path(self.config.get("reports_dir", "reports"))
+                timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                
+                if format.lower() == "markdown":
+                    filepath = reports_dir / f"jira_report_{timestamp}.md"
+                elif format.lower() == "html":
+                    filepath = reports_dir / f"jira_report_{timestamp}.html"
+                else:
+                    filepath = reports_dir / f"jira_report_{timestamp}.pdf"
+            
+            # Імпортуємо необхідний модуль
+            from modules.reporting.report_generator import ReportGenerator
+            
+            # Створюємо генератор звітів (лише для використання методу save_report)
+            report_generator = ReportGenerator(self.data)
+            
+            # Генеруємо візуалізації, якщо потрібно
+            visualization_data = None
+            if include_visualizations:
+                visualization_data = self.generate_visualizations()
+            
+            # Зберігаємо звіт
+            saved_path = report_generator.save_report(
+                filepath=str(filepath),
+                format=format,
+                include_visualizations=include_visualizations,
+                visualization_data=visualization_data
+            )
+            
+            if saved_path:
+                logger.info(f"Звіт успішно збережено у {saved_path}")
+                return saved_path
+            else:
+                logger.error("Не вдалося зберегти звіт")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Помилка при збереженні звіту: {e}")
+            return None
+    
+    def send_to_slack(self, channel, message, report=None, api_token=None):
+        """
+        Відправлення повідомлення в Slack
+        
+        Args:
+            channel (str): Назва каналу (наприклад, '#general')
+            message (str): Текст повідомлення
+            report (str): URL або шлях до звіту (необов'язково)
+            api_token (str): Slack Bot Token
+            
+        Returns:
+            bool: True, якщо повідомлення успішно відправлено, False у іншому випадку
+        """
+        try:
+            logger.info(f"Відправлення повідомлення в Slack канал {channel}...")
+            
+            # Отримуємо токен
+            token = api_token or os.getenv("SLACK_BOT_TOKEN")
+            
+            if not token:
+                logger.error("Не вказано Slack Bot Token")
+                return False
+            
+            # Формуємо дані для запиту
+            slack_message = {
+                "channel": channel,
+                "text": message
+            }
+            
+            # Якщо є звіт, додаємо його як вкладення
+            if report and report.startswith(("http://", "https://")):
+                slack_message["attachments"] = [
+                    {
+                        "title": "Звіт аналізу Jira",
+                        "title_link": report,
+                        "text": "Завантажити звіт"
+                    }
+                ]
+            
+            # Відправляємо запит до Slack API
+            headers = {
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json"
+            }
+            
+            response = requests.post(
+                "https://slack.com/api/chat.postMessage",
+                headers=headers,
+                json=slack_message
+            )
+            
+            if response.status_code == 200 and response.json().get("ok"):
+                logger.info("Повідомлення успішно відправлено в Slack")
+                return True
+            else:
+                logger.error(f"Помилка при відправленні повідомлення в Slack: {response.text}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Помилка при відправленні повідомлення в Slack: {e}")
+            return False

modules/data_analysis/statistics.py

@@ -0,0 +1,278 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import logging
+
+from modules.data_management.data_manager import safe_strftime
+
+logger = logging.getLogger(__name__)
+
+class JiraDataAnalyzer:
+    """
+    Клас для аналізу даних Jira
+    """
+    def __init__(self, df):
+        """
+        Ініціалізація аналізатора даних.
+        
+        Args:
+            df (pandas.DataFrame): DataFrame з даними Jira
+        """
+        self.df = df
+    
+    def _get_column_counts(self, column_name, limit=None):
+        """
+        Допоміжний метод для отримання частот значень колонки.
+        
+        Args:
+            column_name (str): Назва колонки
+            limit (int, optional): Обмеження кількості результатів
+            
+        Returns:
+            dict: Словник з частотами або порожній словник
+        """
+        if column_name not in self.df.columns:
+            return {}
+            
+        counts = self.df[column_name].value_counts()
+        if limit:
+            counts = counts.head(limit)
+            
+        return counts.to_dict()
+    
+    def _check_datetime_column(self, column_name):
+        """
+        Перевірка наявності та коректності колонки з датами.
+        
+        Args:
+            column_name (str): Назва колонки
+            
+        Returns:
+            bool: True якщо колонка існує і містить дати, False інакше
+        """
+        return (column_name in self.df.columns and 
+                pd.api.types.is_datetime64_dtype(self.df[column_name]))
+        
+    def generate_basic_statistics(self):
+        """
+        Генерація базової статистики по даним Jira.
+        
+        Returns:
+            dict: Словник з базовою статистикою
+        """
+        try:
+            stats = {
+                'total_tickets': len(self.df),
+                'status_counts': self._get_column_counts('Status'),
+                'type_counts': self._get_column_counts('Issue Type'),
+                'priority_counts': self._get_column_counts('Priority'),
+                'assignee_counts': self._get_column_counts('Assignee', limit=10),
+                'created_stats': {},
+                'updated_stats': {}
+            }
+            
+            # Статистика за часом створення
+            if self._check_datetime_column('Created'):
+                created_min = self.df['Created'].min()
+                created_max = self.df['Created'].max()
+                
+                # Групування за місяцями
+                if 'Created_Month' in self.df.columns:
+                    created_by_month = self.df['Created_Month'].value_counts().sort_index()
+                    stats['created_by_month'] = {str(k): v for k, v in created_by_month.items()}
+                
+                stats['created_stats'] = {
+                    'min': safe_strftime(created_min, "%Y-%m-%d"),
+                    'max': safe_strftime(created_max, "%Y-%m-%d"),
+                    'last_7_days': len(self.df[self.df['Created'] > (datetime.now() - timedelta(days=7))])
+                }
+            
+            # Статистика за часом оновлення
+            if self._check_datetime_column('Updated'):
+                updated_min = self.df['Updated'].min()
+                updated_max = self.df['Updated'].max()
+                
+                stats['updated_stats'] = {
+                    'min': safe_strftime(updated_min, "%Y-%m-%d"),
+                    'max': safe_strftime(updated_max, "%Y-%m-%d"),
+                    'last_7_days': len(self.df[self.df['Updated'] > (datetime.now() - timedelta(days=7))])
+                }
+            
+            logger.info("Базова статистика успішно згенерована")
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Помилка при генерації базової статистики: {e}")
+            return {'error': str(e)}
+    
+    def analyze_inactive_issues(self, days=14):
+        """
+        Аналіз неактивних тікетів (не оновлювались протягом певної кількості днів).
+        
+        Args:
+            days (int): Кількість днів неактивності
+            
+        Returns:
+            dict: Інформація про неактивні тікети
+        """
+        try:
+            if not self._check_datetime_column('Updated'):
+                logger.warning("Колонка 'Updated' відсутня або не містить дат")
+                return {'error': "Неможливо аналізувати н��активні тікети"}
+            
+            # Визначення неактивних тікетів
+            cutoff_date = datetime.now() - timedelta(days=days)
+            inactive_issues = self.df[self.df['Updated'] < cutoff_date]
+            
+            inactive_data = {
+                'total_count': len(inactive_issues),
+                'percentage': round(len(inactive_issues) / len(self.df) * 100, 2) if len(self.df) > 0 else 0,
+                'by_status': {},
+                'by_priority': {},
+                'top_inactive': []
+            }
+            
+            # Розподіл за статусами та пріоритетами
+            if len(inactive_issues) > 0:
+                inactive_data['by_status'] = inactive_issues['Status'].value_counts().to_dict() if 'Status' in inactive_issues.columns else {}
+                inactive_data['by_priority'] = inactive_issues['Priority'].value_counts().to_dict() if 'Priority' in inactive_issues.columns else {}
+                
+                # Топ 5 неактивних тікетів
+                top_inactive = inactive_issues.sort_values('Updated', ascending=True).head(5)
+                
+                for _, row in top_inactive.iterrows():
+                    issue_data = {
+                        'key': row.get('Issue key', 'Unknown'),
+                        'summary': row.get('Summary', 'Unknown'),
+                        'status': row.get('Status', 'Unknown'),
+                        'last_updated': safe_strftime(row['Updated'], '%Y-%m-%d'),
+                        'days_inactive': (datetime.now() - row['Updated']).days if pd.notna(row['Updated']) else 'Unknown'
+                    }
+                    inactive_data['top_inactive'].append(issue_data)
+            
+            logger.info(f"Знайдено {len(inactive_issues)} неактивних тікетів (>{days} днів)")
+            return inactive_data
+            
+        except Exception as e:
+            logger.error(f"Помилка при аналізі неактивних тікетів: {e}")
+            return {'error': str(e)}
+    
+    def analyze_timeline(self):
+        """
+        Аналіз часової шкали проекту (зміна стану тікетів з часом).
+        
+        Returns:
+            pandas.DataFrame: Дані для візуалізації або None у випадку помилки
+        """
+        try:
+            if not self._check_datetime_column('Created') or not self._check_datetime_column('Updated'):
+                logger.warning("Відсутні необхідні колонки з датами для аналізу часової шкали")
+                return None
+            
+            # Визначення часового діапазону
+            min_date = self.df['Created'].min().date()
+            max_date = self.df['Updated'].max().date()
+            
+            # Створення часового ряду для кожного дня
+            date_range = pd.date_range(start=min_date, end=max_date, freq='D')
+            timeline_data = []
+            
+            for date in date_range:
+                current_date = date.date()
+                date_str = safe_strftime(date, '%Y-%m-%d')
+                
+                # Тікети, створені до цієї дати
+                created_until = self.df[self.df['Created'].dt.date <= current_date]
+                
+                # Статуси тікетів на цю дату
+                status_counts = {}
+                
+                # Для кожного тікета визначаємо його статус на цю дату
+                for _, row in created_until.iterrows():
+                    if pd.notna(row['Updated']) and row['Updated'].date() >= current_date:
+                        status = row.get('Status', 'Unknown')
+                        status_counts[status] = status_counts.get(status, 0) + 1
+                
+                # Додаємо запис для цієї дати
+                timeline_data.append({
+                    'Date': date_str,
+                    'Total': len(created_until),
+                    **status_counts
+                })
+            
+            # Створення DataFrame
+            timeline_df = pd.DataFrame(timeline_data)
+            
+            logger.info("Часова шкала успішно проаналізована")
+            return timeline_df
+            
+        except Exception as e:
+            logger.error(f"Помилка при аналізі часової шкали: {e}")
+            return None
+    
+    def analyze_lead_time(self):
+        """
+        Аналіз часу виконання тікетів (Lead Time).
+        
+        Returns:
+            dict: Статистика по часу виконання
+        """
+        try:
+            if not self._check_datetime_column('Created'):
+                logger.warning("Колонка 'Created' відсутня або не містить дат")
+                return {'error': "Неможливо аналізувати час виконання"}
+            
+            if 'Resolved' not in self.df.columns:
+                logger.warning("Колонка 'Resolved' відсутня")
+                return {'error': "Неможливо аналізувати час виконання"}
+            
+            # Конвертація колонки Resolved до datetime, якщо потрібно
+            resolved_column = self.df['Resolved']
+            if not pd.api.types.is_datetime64_dtype(resolved_column):
+                resolved_column = pd.to_datetime(resolved_column, errors='coerce')
+            
+            # Фільтрація завершених тікетів
+            df_with_resolved = self.df.copy()
+            df_with_resolved['Resolved'] = resolved_column
+            completed_issues = df_with_resolved.dropna(subset=['Resolved'])
+            
+            if len(completed_issues) == 0:
+                logger.warning("Немає завершених тікетів для аналізу")
+                return {'total_count': 0}
+            
+            # Обчислення Lead Time (в днях)
+            completed_issues['Lead_Time_Days'] = (completed_issues['Resolved'] - completed_issues['Created']).dt.days
+            
+            # Фільтрація некоректних значень
+            valid_lead_time = completed_issues[completed_issues['Lead_Time_Days'] >= 0]
+            
+            # Якщо немає валідних записів після фільтрації
+            if len(valid_lead_time) == 0:
+                logger.warning("Немає валідних записів для аналізу Lead Time")
+                return {'total_count': 0, 'error': "Немає валідних записів для аналізу Lead Time"}
+            
+            lead_time_stats = {
+                'total_count': len(valid_lead_time),
+                'avg_lead_time': round(valid_lead_time['Lead_Time_Days'].mean(), 2),
+                'median_lead_time': round(valid_lead_time['Lead_Time_Days'].median(), 2),
+                'min_lead_time': valid_lead_time['Lead_Time_Days'].min(),
+                'max_lead_time': valid_lead_time['Lead_Time_Days'].max(),
+                'by_type': {},
+                'by_priority': {}
+            }
+            
+            # Розподіл за типами і пріоритетами
+            if 'Issue Type' in valid_lead_time.columns:
+                lead_time_by_type = valid_lead_time.groupby('Issue Type')['Lead_Time_Days'].mean().round(2)
+                lead_time_stats['by_type'] = lead_time_by_type.to_dict()
+            
+            if 'Priority' in valid_lead_time.columns:
+                lead_time_by_priority = valid_lead_time.groupby('Priority')['Lead_Time_Days'].mean().round(2)
+                lead_time_stats['by_priority'] = lead_time_by_priority.to_dict()
+            
+            logger.info("Час виконання успішно проаналізований")
+            return lead_time_stats
+            
+        except Exception as e:
+            logger.error(f"Помилка при аналізі часу виконання: {e}")
+            return {'error': str(e)}

modules/data_analysis/visualizations.py

@@ -0,0 +1,640 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime, timedelta
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class JiraVisualizer:
+    """
+    Клас для створення візуалізацій даних Jira
+    """
+    def __init__(self, df):
+        """
+        Ініціалізація візуалізатора.
+        
+        Args:
+            df (pandas.DataFrame): DataFrame з даними Jira
+        """
+        self.df = df
+        self._setup_plot_style()
+    
+    def _setup_plot_style(self):
+        """
+        Налаштування стилю візуалізацій.
+        """
+        plt.style.use('ggplot')
+        sns.set(style="whitegrid")
+        # Налаштування для українських символів
+        plt.rcParams['font.family'] = 'DejaVu Sans'
+    
+    def plot_status_counts(self):
+        """
+        Створення діаграми розподілу тікетів за статусами.
+        
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure або None у випадку помилки
+        """
+        try:
+            if 'Status' not in self.df.columns:
+                logger.warning("Колонка 'Status' відсутня")
+                return None
+            
+            status_counts = self.df['Status'].value_counts()
+            fig, ax = plt.subplots(figsize=(10, 6))
+            
+            # Спроба впорядкувати статуси логічно
+            try:
+                status_order = ['To Do', 'In Progress', 'In Review', 'Done', 'Closed']
+                available_statuses = [s for s in status_order if s in status_counts.index]
+                other_statuses = [s for s in status_counts.index if s not in status_order]
+                ordered_statuses = available_statuses + other_statuses
+                status_counts = status_counts.reindex(ordered_statuses)
+            except Exception as ex:
+                logger.warning(f"Не вдалося впорядкувати статуси: {ex}")
+            
+            sns.barplot(x=status_counts.index, y=status_counts.values, ax=ax)
+            for i, v in enumerate(status_counts.values):
+                ax.text(i, v + 0.5, str(v), ha='center')
+            
+            ax.set_title('Розподіл тікетів за статусами')
+            ax.set_xlabel('Статус')
+            ax.set_ylabel('Кількість')
+            plt.xticks(rotation=45)
+            plt.tight_layout()
+            
+            logger.info("Діаграма статусів успішно створена")
+            return fig
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні діаграми статусів: {e}")
+            return None
+
+    def plot_priority_counts(self):
+        """
+        Створення діаграми розподілу тікетів за пріоритетами.
+        
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure або None у випадку помилки
+        """
+        try:
+            if 'Priority' not in self.df.columns:
+                logger.warning("Колонка 'Priority' відсутня")
+                return None
+            
+            priority_counts = self.df['Priority'].value_counts()
+            fig, ax = plt.subplots(figsize=(10, 6))
+            
+            # Спроба впорядкувати пріоритети логічно
+            try:
+                priority_order = ['Highest', 'High', 'Medium', 'Low', 'Lowest']
+                available_priorities = [p for p in priority_order if p in priority_counts.index]
+                other_priorities = [p for p in priority_counts.index if p not in priority_order]
+                ordered_priorities = available_priorities + other_priorities
+                priority_counts = priority_counts.reindex(ordered_priorities)
+            except Exception as ex:
+                logger.warning(f"Не вдалося впорядкувати пріоритети: {ex}")
+            
+            colors = ['#FF5555', '#FF9C5A', '#FFCC5A', '#5AFF96', '#5AC8FF']
+            if len(priority_counts) <= len(colors):
+                sns.barplot(x=priority_counts.index, y=priority_counts.values, ax=ax, palette=colors[:len(priority_counts)])
+            else:
+                sns.barplot(x=priority_counts.index, y=priority_counts.values, ax=ax)
+            
+            for i, v in enumerate(priority_counts.values):
+                ax.text(i, v + 0.5, str(v), ha='center')
+            
+            ax.set_title('Розподіл тікетів за пріоритетами')
+            ax.set_xlabel('Пріоритет')
+            ax.set_ylabel('Кількість')
+            plt.xticks(rotation=45)
+            plt.tight_layout()
+            
+            logger.info("Діаграма пріоритетів успішно створена")
+            return fig
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні діаграми пріоритетів: {e}")
+            return None
+
+    def plot_type_counts(self):
+        """
+        Створення діаграми розподілу тікетів за типами.
+        
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure або None у випадку помилки
+        """
+        try:
+            if 'Issue Type' not in self.df.columns:
+                logger.warning("Колонка 'Issue Type' відсутня")
+                return None
+            
+            type_counts = self.df['Issue Type'].value_counts()
+            fig, ax = plt.subplots(figsize=(10, 6))
+            sns.barplot(x=type_counts.index, y=type_counts.values, ax=ax)
+            
+            for i, v in enumerate(type_counts.values):
+                ax.text(i, v + 0.5, str(v), ha='center')
+            
+            ax.set_title('Розподіл тікетів за типами')
+            ax.set_xlabel('Тип')
+            ax.set_ylabel('Кількість')
+            plt.xticks(rotation=45)
+            plt.tight_layout()
+            
+            logger.info("Діаграма типів успішно створена")
+            return fig
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні діаграми типів: {e}")
+            return None
+
+    def plot_created_timeline(self):
+        """
+        Створення часової діаграми створення тікетів.
+        
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure або None у випадку помилки
+        """
+        try:
+            if 'Created' not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df['Created']):
+                logger.warning("Колонка 'Created' відсутня або не містить дат")
+                return None
+            
+            if 'Created_Date' not in self.df.columns:
+                self.df['Created_Date'] = self.df['Created'].dt.date
+            
+            created_by_date = self.df['Created_Date'].value_counts().sort_index()
+            fig, ax = plt.subplots(figsize=(12, 6))
+            created_by_date.plot(kind='line', marker='o', ax=ax)
+            
+            ax.set_title('Кількість створених тікетів за датами')
+            ax.set_xlabel('Дата')
+            ax.set_ylabel('Кількість')
+            ax.grid(True)
+            plt.tight_layout()
+            
+            logger.info("Часова діаграма успішно створена")
+            return fig
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні часової діаграми: {e}")
+            return None
+
+    def plot_inactive_issues(self, days=14):
+        """
+        Створення діаграми неактивних тікетів.
+        
+        Args:
+            days (int): Кількість днів неактивності
+            
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure або None у випадку помилки
+        """
+        try:
+            if 'Updated' not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df['Updated']):
+                logger.warning("Колонка 'Updated' відсутня або не містить дат")
+                return None
+            
+            cutoff_date = datetime.now() - timedelta(days=days)
+            inactive_issues = self.df[self.df['Updated'] < cutoff_date]
+            
+            if len(inactive_issues) == 0:
+                logger.warning("Немає неактивних тікетів для візуалізації")
+                return None
+            
+            if 'Status' in inactive_issues.columns:
+                inactive_by_status = inactive_issues['Status'].value_counts()
+                fig, ax = plt.subplots(figsize=(10, 6))
+                sns.barplot(x=inactive_by_status.index, y=inactive_by_status.values, ax=ax)
+                for i, v in enumerate(inactive_by_status.values):
+                    ax.text(i, v + 0.5, str(v), ha='center')
+                
+                ax.set_title(f'Розподіл неактивних тікетів за статусами (>{days} днів)')
+                ax.set_xlabel('Статус')
+                ax.set_ylabel('Кількість')
+                plt.xticks(rotation=45)
+                plt.tight_layout()
+                
+                logger.info("Діаграма неактивних тікетів успішно створена")
+                return fig
+            else:
+                logger.warning("Колонка 'Status' відсутня для неактивних тікетів")
+                return None
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні діаграми неактивних тікетів: {e}")
+            return None
+
+    def plot_status_timeline(self, timeline_df=None):
+        """
+        Створення діаграми зміни статусів з часом.
+        
+        Args:
+            timeline_df (pandas.DataFrame): DataFrame з часовими даними або None для автоматичного генерування
+            
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure або None у випадку помилки
+        """
+        try:
+            if timeline_df is None:
+                if 'Created' not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df['Created']):
+                    logger.warning("Колонка 'Created' відсутня або не містить дат")
+                    return None
+                
+                if 'Updated' not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df['Updated']):
+                    logger.warning("Колонка 'Updated' відсутня або не містить дат")
+                    return None
+                
+                min_date = self.df['Created'].min().date()
+                max_date = self.df['Updated'].max().date()
+                date_range = pd.date_range(start=min_date, end=max_date, freq='D')
+                timeline_data = []
+                
+                for date in date_range:
+                    date_str = date.strftime('%Y-%m-%d')
+                    created_until = self.df[self.df['Created'].dt.date <= date.date()]
+                    status_counts = {}
+                    for _, row in created_until.iterrows():
+                        if row['Updated'].date() >= date.date():
+                            status = row.get('Status', 'Unknown')
+                            status_counts[status] = status_counts.get(status, 0) + 1
+                    timeline_data.append({
+                        'Date': date_str,
+                        'Total': len(created_until),
+                        **status_counts
+                    })
+                
+                timeline_df = pd.DataFrame(timeline_data)
+                timeline_df['Date'] = pd.to_datetime(timeline_df['Date'])
+            else:
+                if not pd.api.types.is_datetime64_dtype(timeline_df['Date']):
+                    timeline_df['Date'] = pd.to_datetime(timeline_df['Date'])
+            
+            status_columns = [col for col in timeline_df.columns if col not in ['Date', 'Total']]
+            if not status_columns:
+                logger.warning("Немає даних про статуси для візуалізації")
+                return None
+            
+            fig, ax = plt.subplots(figsize=(14, 8))
+            status_data = timeline_df[['Date'] + status_columns].set_index('Date')
+            status_data.plot.area(ax=ax, stacked=True, alpha=0.7)
+            
+            ax.set_title('Зміна статусів тікетів з часом')
+            ax.set_xlabel('Дата')
+            ax.set_ylabel('Кількість тікетів')
+            ax.grid(True)
+            plt.tight_layout()
+            
+            logger.info("Часова діаграма статусів успішно створена")
+            return fig
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні часової діаграми статусів: {e}")
+            return None
+
+    def plot_lead_time_by_type(self):
+        """
+        Створення діаграми часу виконання за типами тікетів.
+        
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure або None у випадку помилки
+        """
+        try:
+            if 'Created' not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df['Created']):
+                logger.warning("Колонка 'Created' відсутня або не містить дат")
+                return None
+            
+            if 'Resolved' not in self.df.columns:
+                logger.warning("Колонка 'Resolved' відсутня")
+                return None
+            
+            if 'Issue Type' not in self.df.columns:
+                logger.warning("Колонка 'Issue Type' відсутня")
+                return None
+            
+            if not pd.api.types.is_datetime64_dtype(self.df['Resolved']):
+                self.df['Resolved'] = pd.to_datetime(self.df['Resolved'], errors='coerce')
+            
+            completed_issues = self.df.dropna(subset=['Resolved'])
+            if len(completed_issues) == 0:
+                logger.warning("Немає завершених тікетів для ан��лізу")
+                return None
+            
+            completed_issues['Lead_Time_Days'] = (completed_issues['Resolved'] - completed_issues['Created']).dt.days
+            valid_lead_time = completed_issues[completed_issues['Lead_Time_Days'] >= 0]
+            if len(valid_lead_time) == 0:
+                logger.warning("Немає валідних даних про час виконання")
+                return None
+            
+            lead_time_by_type = valid_lead_time.groupby('Issue Type')['Lead_Time_Days'].mean()
+            fig, ax = plt.subplots(figsize=(10, 6))
+            sns.barplot(x=lead_time_by_type.index, y=lead_time_by_type.values, ax=ax)
+            for i, v in enumerate(lead_time_by_type.values):
+                ax.text(i, v + 0.5, f"{v:.1f}", ha='center')
+            
+            ax.set_title('Середній час виконання тікетів за типами (дні)')
+            ax.set_xlabel('Тип')
+            ax.set_ylabel('Дні')
+            plt.xticks(rotation=45)
+            plt.tight_layout()
+            
+            logger.info("Діаграма часу виконання успішно створена")
+            return fig
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні діаграми часу виконання: {e}")
+            return None
+
+    # Нові методи, додані до класу JiraVisualizer
+
+    def plot_assignee_counts(self, limit=10):
+        """
+        Створення діаграми розподілу тікетів за призначеними користувачами.
+        
+        Args:
+            limit (int): Обмеження на кількість користувачів для відображення
+            
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure або None у випадку помилки
+        """
+        try:
+            if 'Assignee' not in self.df.columns:
+                logger.warning("Колонка 'Assignee' відсутня")
+                return None
+            
+            assignee_counts = self.df['Assignee'].value_counts().head(limit)
+            fig, ax = plt.subplots(figsize=(14, 6))
+            sns.barplot(x=assignee_counts.index, y=assignee_counts.values, ax=ax)
+            for i, v in enumerate(assignee_counts.values):
+                ax.text(i, v + 0.5, str(v), ha='center')
+            
+            ax.set_title(f'Кількість тікетів за призначеними користувачами (Топ {limit})')
+            ax.set_xlabel('Призначений користувач')
+            ax.set_ylabel('Кількість')
+            plt.xticks(rotation=45)
+            plt.tight_layout()
+            
+            logger.info("Діаграма призначених користувачів успішно створена")
+            return fig
+        except Exception as e:
+            logger.error(f"Помилка при створенні діаграми призначених користувачів: {e}")
+            return None
+
+    def plot_timeline(self, date_column='Created', groupby='day', cumulative=False):
+        """
+        Створення часової діаграми тікетів.
+        
+        Args:
+            date_column (str): Колонка з датою ('Created' або 'Updated')
+            groupby (str): Рівень групування ('day', 'week', 'month')
+            cumulative (bool): Чи показувати кумулятивну суму
+            
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure або None у випадку помилки
+        """
+        try:
+            if date_column not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df[date_column]):
+                logger.warning(f"Колонка '{date_column}' відсутня або не містить дати")
+                return None
+            
+            date_col = f"{date_column}_Date" if f"{date_column}_Date" in self.df.columns else date_column
+            if f"{date_column}_Date" not in self.df.columns:
+                self.df[f"{date_column}_Date"] = self.df[date_column].dt.date
+                date_col = f"{date_column}_Date"
+            
+            if groupby == 'week':
+                grouped = self.df[date_column].dt.to_period('W').value_counts().sort_index()
+                title_period = 'тижнями'
+            elif groupby == 'month':
+                grouped = self.df[date_column].dt.to_period('M').value_counts().sort_index()
+                title_period = 'місяцями'
+            else:
+                grouped = self.df[date_col].value_counts().sort_index()
+                title_period = 'датами'
+            
+            if cumulative:
+                grouped = grouped.cumsum()
+                title_prefix = 'Загальна кількість'
+            else:
+                title_prefix = 'Кількість'
+            
+            fig, ax = plt.subplots(figsize=(14, 6))
+            grouped.plot(kind='line', marker='o', ax=ax)
+            
+            ax.set_title(f'{title_prefix} {date_column.lower()}них тікетів за {title_period}')
+            ax.set_xlabel('Період')
+            ax.set_ylabel('Кількість')
+            ax.grid(True)
+            plt.tight_layout()
+            
+            logger.info(f"Часова діаграма для {date_column} успішно створена")
+            return fig
+        except Exception as e:
+            logger.error(f"Помилка при створенні часової діаграми: {e}")
+            return None
+
+    def plot_heatmap(self, row_col='Issue Type', column_col='Status'):
+        """
+        Створення теплової карти для візуалізації взаємозв'язку між двома категоріями.
+        
+        Args:
+            row_col (str): Назва колонки для рядків (наприклад, 'Issue Type')
+            column_col (str): Назва колонки для стовпців (наприклад, 'Status')
+            
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure або None у випадку помилки
+        """
+        try:
+            if row_col not in self.df.columns or column_col not in self.df.columns:
+                logger.warning(f"Колонки '{row_col}' або '{column_col}' відсутні в даних")
+                return None
+            
+            pivot_table = pd.crosstab(self.df[row_col], self.df[column_col])
+            fig, ax = plt.subplots(figsize=(14, 8))
+            sns.heatmap(pivot_table, annot=True, fmt='d', cmap='YlGnBu', ax=ax)
+            
+            ax.set_title(f'Розподіл тікетів: {row_col} за {column_col}')
+            plt.tight_layout()
+            
+            logger.info(f"Теплова карта для {row_col} за {column_col} успішно створена")
+            return fig
+        except Exception as e:
+            logger.error(f"Помилка при створенні теплової карти: {e}")
+            return None
+
+    def plot_project_timeline(self):
+        """
+        Створення часової шкали проекту, що показує зміну статусів з часом.
+        
+        Returns:
+            tuple: (fig1, fig2) - об'єкти figure для різних візуалізацій або (None, None) у випадку помилки
+        """
+        try:
+            if 'Created' not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df['Created']):
+                logger.warning("Колонка 'Created' відсутня або не містить дати")
+                return None, None
+            
+            if 'Updated' not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df['Updated']):
+                logger.warning("Колонка 'Updated' відсутня або не містить дати")
+                return None, None
+            
+            if 'Status' not in self.df.columns:
+                logger.warning("Колонка 'Status' відсутня")
+                return None, None
+            
+            min_date = self.df['Created'].min().date()
+            max_date = self.df['Updated'].max().date()
+            date_range = pd.date_range(start=min_date, end=max_date, freq='D')
+            timeline_data = []
+            
+            for date in date_range:
+                date_str = date.strftime('%Y-%m-%d')
+                created_until = self.df[self.df['Created'].dt.date <= date.date()]
+                status_counts = {}
+                for _, row in created_until.iterrows():
+                    if row['Updated'].date() >= date.date():
+                        status = row.get('Status', 'Unknown')
+                        status_counts[status] = status_counts.get(status, 0) + 1
+                timeline_data.append({
+                    'Date': date_str,
+                    'Total': len(created_until),
+                    **status_counts
+                })
+            
+            timeline_df = pd.DataFrame(timeline_data)
+            timeline_df['Date'] = pd.to_datetime(timeline_df['Date'])
+            
+            fig1, ax1 = plt.subplots(figsize=(16, 8))
+            ax1.plot(timeline_df['Date'], timeline_df['Total'], marker='o', linewidth=2, label='Загальна кількість')
+            status_columns = [col for col in timeline_df.columns if col not in ['Date', 'Total']]
+            for status in status_columns:
+                ax1.plot(timeline_df['Date'], timeline_df[status], marker='.', linestyle='--', label=status)
+            
+            ax1.set_title('Зміна стану проекту з часом')
+            ax1.set_xlabel('Дата')
+            ax1.set_ylabel('Кількість тікетів')
+            plt.xticks(rotation=45)
+            ax1.grid(True)
+            ax1.legend()
+            plt.tight_layout()
+            
+            fig2, ax2 = plt.subplots(figsize=(16, 8))
+            status_data = timeline_df[['Date'] + status_columns].set_index('Date')
+            status_data.plot.area(ax=ax2, stacked=True, alpha=0.7)
+            
+            ax2.set_title('Склад тікетів за статусами')
+            ax2.set_xlabel('Дата')
+            ax2.set_ylabel('Кількість тікетів')
+            ax2.grid(True)
+            plt.tight_layout()
+            
+            logger.info("Часова шкала проекту успішно створена")
+            return fig1, fig2
+        except Exception as e:
+            logger.error(f"Помилка при створенні часової шкали проекту: {e}")
+            return None, None
+
+    def generate_infographic(self):
+        """
+        Генерація комплексної інфографіки з ключовими показниками
+        
+        Returns:
+            matplotlib.figure.Figure: Об'єкт figure з інфографікою
+        """
+        try:
+            fig = plt.figure(figsize=(20, 15))
+            fig.suptitle('Зведений аналіз проекту в Jira', fontsize=24)
+            
+            ax1 = fig.add_subplot(2, 2, 1)
+            if 'Status' in self.df.columns:
+                status_counts = self.df['Status'].value_counts()
+                sns.barplot(x=status_counts.index, y=status_counts.values, ax=ax1)
+                ax1.set_title('Розподіл за статусами')
+                ax1.set_xlabel('Статус')
+                ax1.set_ylabel('Кількість')
+                ax1.tick_params(axis='x', rotation=45)
+            
+            ax2 = fig.add_subplot(2, 2, 2)
+            if 'Priority' in self.df.columns:
+                priority_counts = self.df['Priority'].value_counts()
+                try:
+                    priority_order = ['Highest', 'High', 'Medium', 'Low', 'Lowest']
+                    priority_counts = priority_counts.reindex(priority_order, fill_value=0)
+                except Exception as ex:
+                    logger.warning(f"Не вдалося впорядкувати пріоритети: {ex}")
+                colors = ['#FF5555', '#FF9C5A', '#FFCC5A', '#5AFF96', '#5AC8FF']
+                sns.barplot(x=priority_counts.index, y=priority_counts.values, ax=ax2, palette=colors[:len(priority_counts)])
+                ax2.set_title('Розподіл за пріоритетами')
+                ax2.set_xlabel('Пріоритет')
+                ax2.set_ylabel('Кількість')
+                ax2.tick_params(axis='x', rotation=45)
+            
+            ax3 = fig.add_subplot(2, 2, 3)
+            if 'Created' in self.df.columns and pd.api.types.is_datetime64_dtype(self.df['Created']):
+                created_dates = self.df['Created'].dt.date.value_counts().sort_index()
+                created_cumulative = created_dates.cumsum()
+                created_cumulative.plot(ax=ax3, marker='o')
+                ax3.set_title('Кумулятивне створення тікетів')
+                ax3.set_xlabel('Дата')
+                ax3.set_ylabel('Кількість')
+                ax3.grid(True)
+            
+            ax4 = fig.add_subplot(2, 2, 4)
+            if 'Status' in self.df.columns and 'Issue Type' in self.df.columns:
+                pivot_table = pd.crosstab(self.df['Issue Type'], self.df['Status'])
+                sns.heatmap(pivot_table, annot=True, fmt='d', cmap='YlGnBu', ax=ax4)
+                ax4.set_title('Розподіл: Типи за Статусами')
+                ax4.tick_params(axis='x', rotation=45)
+            
+            plt.tight_layout(rect=[0, 0, 1, 0.96])
+            
+            logger.info("Інфографіка успішно створена")
+            return fig
+        except Exception as e:
+            logger.error(f"Помилка при створенні інфографіки: {e}")
+            return None
+
+    def plot_all(self, output_dir=None):
+        """
+        Створення та збереження всіх діаграм.
+        
+        Args:
+            output_dir (str): Директорія для збереження діаграм. 
+                              Якщо None, діаграми не зберігаються.
+                             
+        Returns:
+            dict: Словник з об'єктами figure для всіх діаграм
+        """
+        plots = {}
+        
+        plots['status'] = self.plot_status_counts()
+        plots['priority'] = self.plot_priority_counts()
+        plots['type'] = self.plot_type_counts()
+        
+        plots['assignee'] = self.plot_assignee_counts(limit=10)
+        plots['created_timeline'] = self.plot_timeline(date_column='Created', groupby='day')
+        plots['updated_timeline'] = self.plot_timeline(date_column='Updated', groupby='day')
+        plots['created_cumulative'] = self.plot_timeline(date_column='Created', cumulative=True)
+        plots['inactive'] = self.plot_inactive_issues()
+        plots['heatmap_type_status'] = self.plot_heatmap(row_col='Issue Type', column_col='Status')
+        
+        timeline_plots = self.plot_project_timeline()
+        if timeline_plots[0] is not None:
+            plots['project_timeline'] = timeline_plots[0]
+            plots['project_composition'] = timeline_plots[1]
+        
+        if output_dir:
+            from pathlib import Path
+            output_path = Path(output_dir)
+            output_path.mkdir(exist_ok=True, parents=True)
+            for name, fig in plots.items():
+                if fig:
+                    fig_path = output_path / f"{name}.png"
+                    fig.savefig(fig_path, dpi=300)
+                    logger.info(f"Діаграма {name} збережена у {fig_path}")
+        
+        return plots

modules/data_import/csv_importer.py

@@ -0,0 +1,347 @@
+import pandas as pd
+from datetime import datetime
+import logging
+import os
+from pathlib import Path
+import io
+import hashlib
+
+logger = logging.getLogger(__name__)
+
+class JiraCsvImporter:
+    """
+    Клас для імпорту даних з CSV-файлів Jira
+    """
+    def __init__(self, file_path):
+        """
+        Ініціалізація імпортера CSV.
+        
+        Args:
+            file_path (str): Шлях до CSV-файлу
+        """
+        self.file_path = file_path
+        self.df = None
+        self.file_hash = None
+    
+    def load_data(self):
+        """
+        Завантаження даних з CSV-файлу.
+        
+        Returns:
+            pandas.DataFrame: Завантажені дані або None у випадку помилки
+        """
+        try:
+            logger.info(f"Завантаження CSV-файлу: {self.file_path}")
+            print(f"Завантаження CSV-файлу: {self.file_path}")  # Додаткове логування в консоль
+            
+            # Перевірка існування файлу
+            if not os.path.exists(self.file_path):
+                logger.error(f"Файл не знайдено: {self.file_path}")
+                print(f"Файл не знайдено: {self.file_path}")
+                return None
+            
+            # Перевірка розміру файлу
+            file_size = os.path.getsize(self.file_path)
+            logger.info(f"Розмір файлу: {file_size} байт")
+            
+            if file_size == 0:
+                logger.error("Файл порожній")
+                return None
+            
+            # Генеруємо хеш файлу для відстеження змін
+            self.file_hash = self._generate_file_hash()
+            if self.file_hash:
+                logger.info(f"Згенеровано хеш CSV файлу: {self.file_hash}")
+            
+            # Додаткове логування дозволів на файл
+            try:
+                import stat
+                st = os.stat(self.file_path)
+                permissions = stat.filemode(st.st_mode)
+                logger.info(f"Дозволи файлу: {permissions}")
+            except Exception as e:
+                logger.warning(f"Не вдалося отримати дозволи файлу: {e}")
+            
+            # Спробуємо різні методи зчитування файлу
+            success = False
+            
+            # Метод 1: Стандартний pandas.read_csv
+            try:
+                self.df = pd.read_csv(self.file_path)
+                logger.info("Метод 1 (стандартний read_csv) успішний")
+                success = True
+            except Exception as e1:
+                logger.warning(f"Помилка методу 1: {e1}")
+            
+            # Метод 2: Явно вказуємо кодування
+            if not success:
+                try:
+                    self.df = pd.read_csv(self.file_path, encoding='utf-8')
+                    logger.info("Метод 2 (utf-8) успішний")
+                    success = True
+                except Exception as e2:
+                    logger.warning(f"Помилка методу 2: {e2}")
+            
+            # Метод 3: Альтернативне кодування
+            if not success:
+                try:
+                    self.df = pd.read_csv(self.file_path, encoding='latin1')
+                    logger.info("Метод 3 (latin1) успішний")
+                    success = True
+                except Exception as e3:
+                    logger.warning(f"Помилка методу 3: {e3}")
+            
+            # Метод 4: Читаємо вміст файлу та використовуємо StringIO
+            if not success:
+                try:
+                    with open(self.file_path, 'rb') as f:
+                        content = f.read()
+                    self.df = pd.read_csv(io.StringIO(content.decode('utf-8', errors='replace')))
+                    logger.info("Метод 4 (StringIO з utf-8 і errors='replace') успішний")
+                    success = True
+                except Exception as e4:
+                    logger.warning(f"Помилка методу 4: {e4}")
+            
+            # Метод 5: Спроба з latin1 і StringIO
+            if not success:
+                try:
+                    with open(self.file_path, 'rb') as f:
+                        content = f.read()
+                    self.df = pd.read_csv(io.StringIO(content.decode('latin1', errors='replace')))
+                    logger.info("Метод 5 (StringIO з latin1 і errors='replace') успішний")
+                    success = True
+                except Exception as e5:
+                    logger.warning(f"По��илка методу 5: {e5}")
+            
+            if not success:
+                logger.error("Всі методи зчитування файлу невдалі")
+                return None
+            
+            # Відображення наявних колонок для діагностики
+            print(f"Наявні колонки: {self.df.columns.tolist()}")
+            print(f"Кількість рядків: {len(self.df)}")
+            logger.info(f"Наявні колонки: {self.df.columns.tolist()}")
+            logger.info(f"Кількість рядків: {len(self.df)}")
+            
+            # Обробка дат
+            self._process_dates()
+            
+            # Очищення та підготовка даних
+            self._clean_data()
+            
+            # Перевіряємо наявність індексів для цього CSV
+            if self.file_hash:
+                # Перевіряємо та оновлюємо метадані файлу
+                self._check_indices_metadata()
+            
+            logger.info(f"Успішно завантажено {len(self.df)} записів")
+            print(f"Успішно завантажено {len(self.df)} записів")
+            return self.df
+            
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні CSV-файлу: {e}")
+            import traceback
+            error_details = traceback.format_exc()
+            print(f"Помилка при завантаженні CSV-файлу: {e}")
+            print(f"Деталі помилки: {error_details}")
+            logger.error(error_details)
+            return None
+    
+    def _generate_file_hash(self):
+        """
+        Генерує хеш для CSV файлу на основі його вмісту
+        
+        Returns:
+            str: Хеш файлу або None у випадку помилки
+        """
+        try:
+            # Читаємо файл блоками для ефективного хешування великих файлів
+            sha256 = hashlib.sha256()
+            with open(self.file_path, "rb") as f:
+                for byte_block in iter(lambda: f.read(4096), b""):
+                    sha256.update(byte_block)
+            
+            return sha256.hexdigest()
+            
+        except Exception as e:
+            logger.error(f"Помилка при генерації хешу CSV: {e}")
+            return None
+    
+    def _check_indices_metadata(self):
+        """
+        Перевіряє наявність індексів для поточного CSV файлу
+        та оновлює метадані при необхідності.
+        """
+        try:
+            import json
+            from pathlib import Path
+            
+            # Шлях до директорії індексів
+            indices_dir = Path("temp/indices")
+            
+            if not indices_dir.exists():
+                return
+            
+            # Отримання списку піддиректорій з індексами
+            subdirs = [d for d in indices_dir.iterdir() if d.is_dir()]
+            if not subdirs:
+                return
+            
+            # Перевіряємо кожну директорію на відповідність хешу
+            for directory in subdirs:
+                metadata_path = directory / "metadata.json"
+                if metadata_path.exists():
+                    try:
+                        with open(metadata_path, "r", encoding="utf-8") as f:
+                            metadata = json.load(f)
+                        
+                        # Якщо знайдено відповідні індекси, додаємо інформацію про колонки
+                        if "csv_hash" in metadata and metadata["csv_hash"] == self.file_hash:
+                            # Оновлюємо інформацію про колонки
+                            metadata["columns"] = self.df.columns.tolist()
+                            metadata["rows_count"] = len(self.df)
+                            metadata["last_used"] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                            
+                            # Оновлюємо файл метаданих
+                            with open(metadata_path, "w", encoding="utf-8") as f:
+                                json.dump(metadata, f, ensure_ascii=False, indent=2)
+                                
+                            logger.info(f"Оновлено метадані для індексів: {directory}")
+                            break
+                    except Exception as md_err:
+                        logger.warning(f"Помилка при перевірці метаданих {metadata_path}: {md_err}")
+        except Exception as e:
+            logger.warning(f"Помилка при перевірці метаданих індексів: {e}")
+    
+    def _check_required_columns(self):
+        """
+        Перевірка наявності необхідних колонок у CSV-файлі.
+        
+        Returns:
+            bool: True, якщо всі необхідні колонки присутні
+        """
+        # Основні колонки, які очікуються у файлі Jira
+        basic_columns = ['Summary', 'Issue key', 'Status', 'Issue Type', 'Priority', 'Created', 'Updated']
+        
+        # Альтернативні назви колонок
+        alternative_columns = {
+            'Summary': ['Summary', 'Короткий опис'],
+            'Issue key': ['Issue key', 'Key', 'Ключ'],
+            'Status': ['Status', 'Статус'],
+            'Issue Type': ['Issue Type', 'Type', 'Тип'],
+            'Priority': ['Priority', 'Пріоритет'],
+            'Created': ['Created', 'Створено'],
+            'Updated': ['Updated', 'Оновлено']
+        }
+        
+        # Перевірка наявності колонок
+        missing_columns = []
+        
+        for col in basic_columns:
+            found = False
+            
+            # Перевірка основної назви
+            if col in self.df.columns:
+                found = True
+            else:
+                # Перевірка альтернативних назв
+                for alt_col in alternative_columns.get(col, []):
+                    if alt_col in self.df.columns:
+                        # Перейменування колонки до стандартного імені
+                        self.df.rename(columns={alt_col: col}, inplace=True)
+                        found = True
+                        break
+            
+            if not found:
+                missing_columns.append(col)
+        
+        if missing_columns:
+            logger.warning(f"Відсутні колонки: {', '.join(missing_columns)}")
+            print(f"Відсутні колонки: {', '.join(missing_columns)}")
+            return False
+        
+        return True
+    
+    def _process_dates(self):
+        """
+        Обробка дат у DataFrame.
+        """
+        try:
+            # Перетворення колонок з датами
+            date_columns = ['Created', 'Updated', 'Resolved', 'Due Date']
+            
+            for col in date_columns:
+                if col in self.df.columns:
+                    try:
+                        self.df[col] = pd.to_datetime(self.df[col], errors='coerce')
+                        print(f"Колонку {col} успішно конвертовано до datetime")
+                    except Exception as e:
+                        logger.warning(f"Не вдалося конвертувати колонку {col} до datetime: {e}")
+                        print(f"Не вдалося конвертувати колонку {col} до datetime: {e}")
+            
+        except Exception as e:
+            logger.error(f"Помилка при обробці дат: {e}")
+            print(f"Помилка при обробці дат: {e}")
+    
+    def _clean_data(self):
+        """
+        Очищення та підготовка даних.
+        """
+        try:
+            # Видалення порожніх рядків
+            if 'Issue key' in self.df.columns:
+                self.df.dropna(subset=['Issue key'], inplace=True)
+                print(f"Видалено порожні рядки за колонкою 'Issue key'")
+            
+            # Додаткова обробка даних
+            if 'Status' in self.df.columns:
+                self.df['Status'] = self.df['Status'].fillna('Unknown')
+                print(f"Заповнено відсутні значення в колонці 'Status'")
+            
+            if 'Priority' in self.df.columns:
+                self.df['Priority'] = self.df['Priority'].fillna('Not set')
+                print(f"Заповнено відсутні значення в колонці 'Priority'")
+            
+            # Створення додаткових колонок для аналізу
+            if 'Created' in self.df.columns and pd.api.types.is_datetime64_dtype(self.df['Created']):
+                self.df['Created_Date'] = self.df['Created'].dt.date
+                self.df['Created_Month'] = self.df['Created'].dt.to_period('M')
+                print(f"Створено додаткові колонки для дат створення")
+            
+            if 'Updated' in self.df.columns and pd.api.types.is_datetime64_dtype(self.df['Updated']):
+                self.df['Updated_Date'] = self.df['Updated'].dt.date
+                self.df['Days_Since_Update'] = (datetime.now() - self.df['Updated']).dt.days
+                print(f"Створено додаткові колонки для дат оновлення")
+                
+        except Exception as e:
+            logger.error(f"Помилка при очищенні даних: {e}")
+            print(f"Помилка при очищенні даних: {e}")
+    
+    def export_to_csv(self, output_path=None):
+        """
+        Експорт оброблених даних у CSV-файл.
+        
+        Args:
+            output_path (str): Шлях для збереження файлу. Якщо None, створюється автоматично.
+            
+        Returns:
+            str: Шлях до збереженого файлу або None у випадку помилки
+        """
+        if self.df is None:
+            logger.error("Немає даних для експорту")
+            return None
+        
+        try:
+            if output_path is None:
+                timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                output_dir = Path("exported_data")
+                output_dir.mkdir(exist_ok=True)
+                output_path = output_dir / f"jira_data_{timestamp}.csv"
+            
+            self.df.to_csv(output_path, index=False, encoding='utf-8')
+            logger.info(f"Дані успішно експортовано у {output_path}")
+            return str(output_path)
+            
+        except Exception as e:
+            logger.error(f"Помилка при експорті даних: {e}")
+            return None

modules/data_import/jira_api.py

@@ -0,0 +1,384 @@
+import os
+import json
+import pandas as pd
+import logging
+import requests
+from datetime import datetime, timedelta
+from pathlib import Path
+from jira import JIRA
+import urllib3
+
+logger = logging.getLogger(__name__)
+
+class JiraConnector:
+    """
+    Клас для взаємодії з API Jira та отримання даних
+    """
+    def __init__(self, jira_url, jira_username, jira_api_token):
+        """
+        Ініціалізація з'єднання з Jira.
+        
+        Args:
+            jira_url (str): URL Jira сервера
+            jira_username (str): Ім'я користувача (email)
+            jira_api_token (str): API токен
+        """
+        self.jira_url = jira_url
+        self.jira_username = jira_username
+        self.jira_api_token = jira_api_token
+        self.jira = self._connect()
+    
+    def _connect(self):
+        """
+        Підключення до Jira API.
+        
+        Returns:
+            jira.JIRA: Об'єкт для взаємодії з Jira або None у випадку помилки
+        """
+        try:
+            jira = JIRA(
+                server=self.jira_url,
+                basic_auth=(self.jira_username, self.jira_api_token),
+                options={'timeout': 30}
+            )
+            logger.info("Успішне підключення до Jira")
+            return jira
+        except Exception as e:
+            logger.error(f"Помилка підключення до Jira: {e}")
+            return None
+    
+    def get_project_issues(self, project_key, max_results=500):
+        """
+        Отримання тікетів проекту.
+        
+        Args:
+            project_key (str): Ключ проекту Jira
+            max_results (int): Максимальна кількість тікетів для отримання
+            
+        Returns:
+            list: Список тікетів або [] у випадку помилки
+        """
+        try:
+            if self.jira is None:
+                logger.error("Немає з'єднання з Jira")
+                return []
+            
+            jql = f'project = {project_key} ORDER BY updated DESC'
+            logger.info(f"Виконання JQL запиту: {jql}")
+            
+            issues = self.jira.search_issues(
+                jql,
+                maxResults=max_results,
+                fields="summary,status,issuetype,priority,labels,components,created,updated,assignee,reporter,description,comment"
+            )
+            
+            logger.info(f"Отримано {len(issues)} тікетів для проекту {project_key}")
+            return issues
+            
+        except Exception as e:
+            logger.error(f"Помилка отримання тікетів: {e}")
+            return []
+    
+    def get_board_issues(self, board_id, project_key, max_results=500):
+        """
+        Отримання тікетів дошки.
+        
+        Args:
+            board_id (int): ID дошки Jira
+            project_key (str): Ключ проекту для фільтрації
+            max_results (int): Максимальна кількість тікетів для отримання
+            
+        Returns:
+            list: Список тікетів або [] у випадку помилки
+        """
+        try:
+            if self.jira is None:
+                logger.error("Немає з'єднання з Jira")
+                return []
+            
+            issues = []
+            start_at = 0
+            logger.info(f"Отримання тікетів з дошки ID: {board_id}, проект: {project_key}...")
+            
+            while True:
+                logger.info(f"  Отримання тікетів (з {start_at}, максимум 100)...")
+                
+                batch = self.jira.search_issues(
+                    f'project = {project_key} ORDER BY updated DESC',
+                    startAt=start_at,
+                    maxResults=100,
+                    fields="summary,status,issuetype,priority,labels,components,created,updated,assignee,reporter,description,comment"
+                )
+                
+                if not batch:
+                    break
+                
+                issues.extend(batch)
+                start_at += len(batch)
+                logger.info(f"  Отримано {len(batch)} тікетів, загалом {len(issues)}")
+                
+                if len(batch) < 100 or len(issues) >= max_results:
+                    break
+            
+            logger.info(f"Загалом отримано {len(issues)} тікетів з дошки {board_id}")
+            return issues
+            
+        except Exception as e:
+            logger.error(f"Помилка отримання тікетів дошки: {e}")
+            logger.error(f"Деталі помилки: {str(e)}")
+            return []
+    
+    def export_issues_to_csv(self, issues, filepath):
+        """
+        Експорт тікетів у CSV-файл.
+        
+        Args:
+            issues (list): Список тікетів Jira
+            filepath (str): Шлях для збереження CSV-файлу
+            
+        Returns:
+            pandas.DataFrame: DataFrame з даними або None у випадку помилки
+        """
+        if not issues:
+            logger.warning("Немає тікетів для експорту")
+            return None
+        
+        try:
+            data = []
+            
+            for issue in issues:
+                # Визначення даних тікета з коректною обробкою потенційно відсутніх полів
+                issue_data = {
+                    'Issue key': issue.key,
+                    'Summary': getattr(issue.fields, 'summary', None),
+                    'Status': getattr(issue.fields.status, 'name', None) if hasattr(issue.fields, 'status') else None,
+                    'Issue Type': getattr(issue.fields.issuetype, 'name', None) if hasattr(issue.fields, 'issuetype') else None,
+                    'Priority': getattr(issue.fields.priority, 'name', None) if hasattr(issue.fields, 'priority') else None,
+                    'Components': ','.join([c.name for c in issue.fields.components]) if hasattr(issue.fields, 'components') and issue.fields.components else '',
+                    'Labels': ','.join(issue.fields.labels) if hasattr(issue.fields, 'labels') and issue.fields.labels else '',
+                    'Created': getattr(issue.fields, 'created', None),
+                    'Updated': getattr(issue.fields, 'updated', None),
+                    'Assignee': getattr(issue.fields.assignee, 'displayName', None) if hasattr(issue.fields, 'assignee') and issue.fields.assignee else None,
+                    'Reporter': getattr(issue.fields.reporter, 'displayName', None) if hasattr(issue.fields, 'reporter') and issue.fields.reporter else None,
+                    'Description': getattr(issue.fields, 'description', None),
+                    'Comments Count': len(issue.fields.comment.comments) if hasattr(issue.fields, 'comment') and hasattr(issue.fields.comment, 'comments') else 0
+                }
+                
+                # Додаємо коментарі, якщо вони є
+                if hasattr(issue.fields, 'comment') and hasattr(issue.fields.comment, 'comments'):
+                    for i, comment in enumerate(issue.fields.comment.comments[:3]):  # Беремо перші 3 коментарі
+                        issue_data[f'Comment {i+1}'] = comment.body
+                
+                data.append(issue_data)
+            
+            # Створення DataFrame
+            df = pd.DataFrame(data)
+            
+            # Збереження в CSV
+            df.to_csv(filepath, index=False, encoding='utf-8')
+            logger.info(f"Дані експортовано у {filepath}")
+            
+            return df
+            
+        except Exception as e:
+            logger.error(f"Помилка при експорті даних: {e}")
+            return None
+    
+    def get_project_info(self, project_key):
+        """
+        Отримання інформації про проект.
+        
+        Args:
+            project_key (str): Ключ проекту Jira
+            
+        Returns:
+            dict: Інформація про проект або None у випадку помилки
+        """
+        try:
+            if self.jira is None:
+                logger.error("Немає з'єднання з Jira")
+                return None
+            
+            project = self.jira.project(project_key)
+            
+            project_info = {
+                'key': project.key,
+                'name': project.name,
+                'lead': project.lead.displayName,
+                'description': project.description,
+                'url': f"{self.jira_url}/projects/{project.key}"
+            }
+            
+            logger.info(f"Отримано інформацію про проект {project_key}")
+            return project_info
+            
+        except Exception as e:
+            logger.error(f"Помилка отримання інформації про проект: {e}")
+            return None
+    
+    def get_boards_list(self, project_key=None):
+        """
+        Отримання списку дошок.
+        
+        Args:
+            project_key (str): Ключ проекту для фільтрації (необов'язково)
+            
+        Returns:
+            list: Список дошок або [] у випадку помилки
+        """
+        try:
+            if self.jira is None:
+                logger.error("Немає з'єднання з Jira")
+                return []
+            
+            # Отримання всіх дошок
+            all_boards = self.jira.boards()
+            
+            # Фільтрація за проектом, якщо вказано
+            if project_key:
+                boards = []
+                for board in all_boards:
+                    # Перевірка, чи дошка належить до вказаного проекту
+                    if hasattr(board, 'location') and hasattr(board.location, 'projectKey') and board.location.projectKey == project_key:
+                        boards.append(board)
+                    # Або якщо назва дошки містить ключ проекту
+                    elif project_key in board.name:
+                        boards.append(board)
+            else:
+                boards = all_boards
+            
+            # Формування результату
+            result = []
+            for board in boards:
+                board_info = {
+                    'id': board.id,
+                    'name': board.name,
+                    'type': board.type
+                }
+                
+                if hasattr(board, 'location'):
+                    board_info['project_key'] = getattr(board.location, 'projectKey', None)
+                    board_info['project_name'] = getattr(board.location, 'projectName', None)
+                
+                result.append(board_info)
+            
+            logger.info(f"Отримано {len(result)} дошок")
+            return result
+            
+        except Exception as e:
+            logger.error(f"Помилка отримання списку дошок: {e}")
+            return []
+    
+    def get_issue_details(self, issue_key):
+        """
+        Отримання детальної інформації про тікет.
+        
+        Args:
+            issue_key (str): Ключ тікета
+            
+        Returns:
+            dict: Детальна інформація про тікет або None у випадку помилки
+        """
+        try:
+            if self.jira is None:
+                logger.error("Немає з'єднання з Jira")
+                return None
+            
+            issue = self.jira.issue(issue_key)
+            
+            # Базова інформація
+            issue_details = {
+                'key': issue.key,
+                'summary': issue.fields.summary,
+                'status': issue.fields.status.name,
+                'issue_type': issue.fields.issuetype.name,
+                'priority': issue.fields.priority.name if hasattr(issue.fields, 'priority') and issue.fields.priority else None,
+                'created': issue.fields.created,
+                'updated': issue.fields.updated,
+                'description': issue.fields.description,
+                'assignee': issue.fields.assignee.displayName if hasattr(issue.fields, 'assignee') and issue.fields.assignee else None,
+                'reporter': issue.fields.reporter.displayName if hasattr(issue.fields, 'reporter') and issue.fields.reporter else None,
+                'url': f"{self.jira_url}/browse/{issue.key}"
+            }
+            
+            # Додаємо коментарі
+            comments = []
+            if hasattr(issue.fields, 'comment') and hasattr(issue.fields.comment, 'comments'):
+                for comment in issue.fields.comment.comments:
+                    comments.append({
+                        'author': comment.author.displayName,
+                        'created': comment.created,
+                        'body': comment.body
+                    })
+            
+            issue_details['comments'] = comments
+            
+            # Додаємо історію змін
+            changelog = self.jira.issue(issue_key, expand='changelog').changelog
+            history = []
+            
+            for history_item in changelog.histories:
+                item_info = {
+                    'author': history_item.author.displayName,
+                    'created': history_item.created,
+                    'changes': []
+                }
+                
+                for item in history_item.items:
+                    item_info['changes'].append({
+                        'field': item.field,
+                        'from_value': item.fromString,
+                        'to_value': item.toString
+                    })
+                
+                history.append(item_info)
+            
+            issue_details['history'] = history
+            
+            logger.info(f"Отримано детальну інформацію про тікет {issue_key}")
+            return issue_details
+            
+        except Exception as e:
+            logger.error(f"Помилка отримання деталей тікета: {e}")
+            return None
+    
+    @staticmethod
+    def test_connection(url, username, api_token):
+        """
+        Тестування підключення до Jira.
+        
+        Args:
+            url (str): URL Jira сервера
+            username (str): Ім'я користувача (email)
+            api_token (str): API токен
+            
+        Returns:
+            bool: True, якщо підключення успішне, False у іншому випадку
+        """
+        logger.info(f"Тестування підключення до Jira: {url}")
+        logger.info(f"Користувач: {username}")
+        
+        # Спроба прямого HTTP запиту до сервера
+        try:
+            logger.info("Спроба прямого HTTP запиту до сервера...")
+            
+            response = requests.get(
+                f"{url}/rest/api/2/serverInfo",
+                auth=(username, api_token),
+                timeout=10,
+                verify=True  # Змініть на False, якщо у вас самопідписаний сертифікат
+            )
+            
+            logger.info(f"Статус відповіді: {response.status_code}")
+            
+            if response.status_code == 200:
+                logger.info(f"Відповідь: {response.text[:200]}...")
+                return True
+            else:
+                logger.error(f"Помилка: {response.text}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Помилка HTTP запиту: {type(e).__name__}: {str(e)}")
+            logger.error(f"Деталі винятку: {repr(e)}")
+            return False

modules/data_management/data_manager.py

@@ -0,0 +1,500 @@
+import os
+import shutil
+import logging
+import pandas as pd
+import hashlib
+from pathlib import Path
+from datetime import datetime
+from modules.data_management.session_manager import SessionManager
+
+logger = logging.getLogger(__name__)
+
+class DataManager:
+    """
+    Менеджер даних для роботи з файлами CSV та їх обробки.
+    """
+    def __init__(self, current_data_dir="current_data", session_manager=None):
+        """
+        Ініціалізація менеджера даних.
+        
+        Args:
+            current_data_dir (str): Директорія з локальними файлами даних
+            session_manager (SessionManager, optional): Менеджер сесій або None для створення нового
+        """
+        self.current_data_dir = Path(current_data_dir)
+        self.current_data_dir.mkdir(exist_ok=True, parents=True)
+        
+        # Ініціалізація менеджера сесій
+        self.session_manager = session_manager or SessionManager()
+    
+    def get_local_files(self):
+        """
+        Отримання списку локальних CSV-файлів.
+        
+        Returns:
+            list: Список словників з інформацією про файли
+        """
+        files_info = []
+        
+        if not self.current_data_dir.exists():
+            logger.warning(f"Директорія {self.current_data_dir} не існує")
+            return files_info
+        
+        for file_path in self.current_data_dir.glob("*.csv"):
+            try:
+                # Отримуємо базову інформацію про файл
+                stat = file_path.stat()
+                size_kb = stat.st_size / 1024
+                modified = datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M:%S')
+                
+                # Спроба зчитати перші рядки для отримання інформації про структуру
+                try:
+                    df_preview = pd.read_csv(file_path, nrows=5)
+                    rows_preview = len(df_preview)
+                    columns_preview = len(df_preview.columns)
+                    columns_list = df_preview.columns.tolist()
+                except Exception as e:
+                    logger.warning(f"Не вдалося прочитати файл {file_path}: {e}")
+                    rows_preview = "?"
+                    columns_preview = "?"
+                    columns_list = []
+                
+                # Формуємо інформацію про файл
+                files_info.append({
+                    "path": str(file_path),
+                    "name": file_path.name,
+                    "size_kb": round(size_kb, 2),
+                    "modified": modified,
+                    "rows_preview": rows_preview,
+                    "columns_preview": columns_preview,
+                    "columns_list": columns_list
+                })
+            except Exception as e:
+                logger.error(f"Помилка при обробці файлу {file_path}: {e}")
+        
+        # Сортуємо за часом модифікації (від найновіших до найстаріших)
+        files_info.sort(key=lambda x: x["modified"], reverse=True)
+        
+        return files_info
+    
+    def validate_csv_file(self, file_path):
+        """
+        Перевірка валідності CSV-файлу.
+        
+        Args:
+            file_path (str): Шлях до файлу
+            
+        Returns:
+            tuple: (is_valid, info_dict) 
+                   is_valid - True, якщо файл валідний
+                   info_dict - словник з інформацією про файл
+        """
+        if not Path(file_path).exists():
+            return False, {"error": f"Файл не знайдено: {file_path}"}
+        
+        try:
+            # Отримуємо інформацію про файл
+            file_stat = Path(file_path).stat()
+            size_kb = file_stat.st_size / 1024
+            
+            if size_kb == 0:
+                return False, {"error": "Файл порожній"}
+            
+            # Спроба зчитати файл
+            df = pd.read_csv(file_path)
+            
+            # Перевірка наявності очікуваних колонок
+            required_columns = ['Summary', 'Issue key', 'Status']
+            missing_columns = [col for col in required_columns if col not in df.columns]
+            
+            if missing_columns:
+                return False, {
+                    "error": f"Відсутні необхідні колонки: {', '.join(missing_columns)}",
+                    "rows": len(df),
+                    "columns": len(df.columns),
+                    "columns_list": df.columns.tolist()
+                }
+            
+            # Формуємо інформацію про файл
+            info = {
+                "rows": len(df),
+                "columns": len(df.columns),
+                "columns_list": df.columns.tolist(),
+                "size_kb": round(size_kb, 2),
+                "first_rows": df.head(5).to_dict('records')
+            }
+            
+            return True, info
+            
+        except Exception as e:
+            logger.error(f"Помилка при валідації CSV-файлу {file_path}: {e}")
+            return False, {"error": f"Помилка при читанні файлу: {str(e)}"}
+    
+    def copy_files_to_session(self, session_id, file_paths_list):
+        """
+        Копіювання вибраних файлів до сесії користувача.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            file_paths_list (list): Список шляхів до файлів для копіювання
+            
+        Returns:
+            list: Список скопійованих файлів у сесії
+        """
+        session_data_dir = self.session_manager.get_session_data_dir(session_id)
+        if not session_data_dir:
+            logger.error(f"Не вдалося отримати директорію даних для сесії {session_id}")
+            return []
+        
+        copied_files = []
+        
+        for file_path in file_paths_list:
+            try:
+                source_path = Path(file_path)
+                if not source_path.exists():
+                    logger.warning(f"Файл не знайдено: {file_path}")
+                    continue
+                
+                # Створюємо унікальне ім'я файлу в сесії
+                timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                dest_filename = f"local_{timestamp}_{source_path.name}"
+                dest_path = session_data_dir / dest_filename
+                
+                # Копіюємо файл
+                shutil.copyfile(source_path, dest_path)
+                
+                # Додаємо інформацію про файл до сесії
+                if self.session_manager.add_data_file(
+                    session_id, 
+                    str(dest_path), 
+                    file_type="local", 
+                    description=f"Local file: {source_path.name}"
+                ):
+                    copied_files.append(str(dest_path))
+                    logger.info(f"Файл {source_path.name} скопійовано до сесії {session_id}")
+                
+            except Exception as e:
+                logger.error(f"Помилка при копіюванні файлу {file_path} до сесії {session_id}: {e}")
+        
+        return copied_files
+    
+    def merge_dataframes(self, session_id, dataframes, output_name=None):
+        """
+        Об'єднання кількох DataFrame та збереження результату в сесії.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            dataframes (list): Список DataFrame для об'єднання
+            output_name (str, optional): Ім'я файлу для збереження результату
+            
+        Returns:
+            tuple: (merged_df, output_path) - об'єднаний DataFrame та шлях до збереженого файлу
+        """
+        if not dataframes:
+            logger.warning("Немає даних для об'єднання")
+            return None, None
+        
+        try:
+            # Якщо є тільки один DataFrame, використовуємо його як базовий
+            if len(dataframes) == 1:
+                merged_df = dataframes[0].copy()
+            else:
+                # Об'єднуємо всі DataFrame по рядках з ігноруванням індексів
+                merged_df = pd.concat(dataframes, ignore_index=True)
+            
+            # Видаляємо дублікати за ключовими колонками
+            if 'Issue key' in merged_df.columns:
+                merged_df.drop_duplicates(subset=['Issue key'], keep='first', inplace=True)
+            
+            # Зберігаємо результат
+            output_path = self.session_manager.save_merged_data(session_id, merged_df, output_name)
+            
+            return merged_df, output_path
+            
+        except Exception as e:
+            logger.error(f"Помилка при об'єднанні даних: {e}")
+            return None, None
+    
+    def load_data_from_files(self, session_id, file_paths_list):
+        """
+        Завантаження даних з файлів у DataFrame.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            file_paths_list (list): Список шляхів до файлів для завантаження
+            
+        Returns:
+            list: Список кортежів (file_path, dataframe, success)
+        """
+        results = []
+        
+        for file_path in file_paths_list:
+            try:
+                # Перевіряємо, чи існує файл
+                if not Path(file_path).exists():
+                    logger.warning(f"Файл не знайдено: {file_path}")
+                    results.append((file_path, None, False))
+                    continue
+                
+                # Завантажуємо файл
+                df = pd.read_csv(file_path)
+                
+                # Обробка дат
+                for date_col in ['Created', 'Updated', 'Resolved', 'Due Date']:
+                    if date_col in df.columns:
+                              df[date_col] = pd.to_datetime(df[date_col], format='%Y-%m-%dT%H:%M:%S', errors='coerce')
+                
+                # Підготовка додаткових колонок для аналізу
+                if 'Created' in df.columns and pd.api.types.is_datetime64_dtype(df[date_col]):
+                    df['Created_Date'] = df['Created'].dt.date
+                    df['Created_Month'] = df['Created'].dt.to_period('M')
+                
+                if 'Updated' in df.columns and pd.api.types.is_datetime64_dtype(df[date_col]):
+                    df['Updated_Date'] = df['Updated'].dt.date
+                    df['Days_Since_Update'] = (datetime.now() - df['Updated']).dt.days
+                
+                results.append((file_path, df, True))
+                logger.info(f"Успішно завантажено файл {file_path}, {len(df)} рядків")
+                
+            except Exception as e:
+                logger.error(f"Помилка при завантаженні файлу {file_path}: {e}")
+                results.append((file_path, None, False))
+        
+        return results
+    
+    def initialize_session_data(self, session_id, local_files, uploaded_file=None):
+        """
+        Ініціалізація даних сесії з локальних та завантажених файлів.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            local_files (list): Список шляхів до локальних файлів
+            uploaded_file (str, optional): Шлях до завантаженого файлу
+            
+        Returns:
+            tuple: (success, result_info) - успішність операції та інформація про результат
+        """
+        try:
+            # Копіюємо локальні файли до сесії
+            copied_files = self.copy_files_to_session(session_id, local_files)
+            
+            # Додаємо завантажений файл, якщо він є
+            if uploaded_file and Path(uploaded_file).exists():
+                # Копіюємо файл до сесії
+                session_data_dir = self.session_manager.get_session_data_dir(session_id)
+                if not session_data_dir:
+                    return False, {"error": "Не вдалося отримати директорію даних сесії"}
+                
+                # Створюємо унікальне ім'я для завантаженого файлу
+                timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                dest_filename = f"uploaded_{timestamp}_{Path(uploaded_file).name}"
+                dest_path = session_data_dir / dest_filename
+                
+                # Копіюємо файл
+                shutil.copyfile(uploaded_file, dest_path)
+                
+                # Додаємо інформацію про файл до сесії
+                self.session_manager.add_data_file(
+                    session_id, 
+                    str(dest_path), 
+                    file_type="uploaded", 
+                    description=f"Uploaded file: {Path(uploaded_file).name}"
+                )
+                
+                copied_files.append(str(dest_path))
+            
+            # Якщо немає файлів для обробки, повертаємо помилку
+            if not copied_files:
+                return False, {"error": "Не вибрано жодного файлу для обробки"}
+            
+            # Завантажуємо дані з усіх файлів
+            loaded_data = self.load_data_from_files(session_id, copied_files)
+            
+            # Фільтруємо тільки успішно завантажені файли
+            valid_data = [(path, df) for path, df, success in loaded_data if success and df is not None]
+            
+            if not valid_data:
+                return False, {"error": "Не вдалося завантажити жодного файлу"}
+            
+            # Отримуємо список DataFrame
+            dataframes = [df for _, df in valid_data]
+            
+            # Об'єднуємо дані
+            merged_df, output_path = self.merge_dataframes(
+                session_id, 
+                dataframes, 
+                output_name=f"merged_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+            )
+            
+            if merged_df is None or not output_path:
+                return False, {"error": "Не вдалося об'єднати дані"}
+            
+            result_info = {
+                "merged_file": output_path,
+                "rows_count": len(merged_df),
+                "columns_count": len(merged_df.columns),
+                "source_files_count": len(valid_data),
+                "merged_df": merged_df  # Передаємо DataFrame для подальшого використання
+            }
+            
+            return True, result_info
+            
+        except Exception as e:
+            logger.error(f"Помилка при ініціалізації даних сесії {session_id}: {e}")
+            return False, {"error": f"Помилка при ініціалізації даних: {str(e)}"}
+            
+    def get_file_preview(self, file_path, max_rows=10):
+        """
+        Отримання попереднього перегляду файлу CSV.
+        
+        Args:
+            file_path (str): Шлях до файлу
+            max_rows (int): Максимальна кількість рядків для перегляду
+            
+        Returns:
+            dict: Словник з інформацією про файл та його вмістом
+        """
+        try:
+            if not Path(file_path).exists():
+                return {"error": f"Файл не знайдено: {file_path}"}
+            
+            # Зчитуємо перші max_rows рядків
+            df = pd.read_csv(file_path, nrows=max_rows)
+            
+            # Отримуємо інформацію про файл
+            file_stat = Path(file_path).stat()
+            size_kb = file_stat.st_size / 1024
+            modified = datetime.fromtimestamp(file_stat.st_mtime).strftime('%Y-%m-%d %H:%M:%S')
+            
+            # Підраховуємо загальну кількість рядків (обережно з великими файлами)
+            total_rows = sum(1 for _ in open(file_path, 'r')) - 1  # -1 для заголовка
+            
+            # Формуємо результат
+            result = {
+                "filename": Path(file_path).name,
+                "path": file_path,
+                "size_kb": round(size_kb, 2),
+                "modified": modified,
+                "total_rows": total_rows,
+                "columns": df.columns.tolist(),
+                "columns_count": len(df.columns),
+                "preview_rows": df.to_dict('records')
+            }
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Помилка при отриманні попереднього перегляду файлу {file_path}: {e}")
+            return {"error": f"Помилка при читанні файлу: {str(e)}"}
+
+    def cleanup_temp_data(self):
+        """
+        Очищення тимчасових даних, крім файлів у папці current_data.
+        
+        Returns:
+            dict: Інформація про результати очищення
+        """
+        try:
+            import shutil
+            import os
+            from pathlib import Path
+            
+            cleanup_stats = {
+                "temp_files_removed": 0,
+                "session_dirs_removed": 0,
+                "indices_dirs_removed": 0,
+                "reports_removed": 0,
+                "temp_directories": []
+            }
+            
+            # Очищення тимчасових індексів
+            indices_dir = Path("temp/indices")
+            if indices_dir.exists():
+                for item in indices_dir.iterdir():
+                    if item.is_dir():
+                        try:
+                            shutil.rmtree(item)
+                            cleanup_stats["indices_dirs_removed"] += 1
+                        except Exception as e:
+                            logger.error(f"Помилка при видаленні директорії індексів {item}: {e}")
+            
+            # Очищення тимчасових сесій
+            sessions_dir = Path("temp/sessions")
+            if sessions_dir.exists():
+                for item in sessions_dir.iterdir():
+                    if item.is_dir():
+                        try:
+                            shutil.rmtree(item)
+                            cleanup_stats["session_dirs_removed"] += 1
+                        except Exception as e:
+                            logger.error(f"Помилка при видаленні директорії сесій {item}: {e}")
+            
+            # Очищення інших файлів у temp
+            temp_dir = Path("temp")
+            if temp_dir.exists():
+                for item in temp_dir.iterdir():
+                    if item.is_file():
+                        try:
+                            item.unlink()
+                            cleanup_stats["temp_files_removed"] += 1
+                        except Exception as e:
+                            logger.error(f"Помилка при видаленні файлу {item}: {e}")
+            
+            # Очищення тимчасових звітів
+            reports_dir = Path("reports")
+            if reports_dir.exists():
+                reports_count = 0
+                
+                # Видаляємо файли у головній директорії reports
+                for item in reports_dir.iterdir():
+                    if item.is_file():
+                        try:
+                            item.unlink()
+                            reports_count += 1
+                        except Exception as e:
+                            logger.error(f"Помилка при видаленні звіту {item}: {e}")
+                
+                # Перевіряємо і очищаємо підпапку візуалізацій
+                viz_dir = reports_dir / "visualizations"
+                if viz_dir.exists():
+                    for item in viz_dir.iterdir():
+                        if item.is_file():
+                            try:
+                                item.unlink()
+                                reports_count += 1
+                            except Exception as e:
+                                logger.error(f"Помилка при видаленні візуалізації {item}: {e}")
+                
+                cleanup_stats["reports_removed"] = reports_count
+            
+            # Запам'ятовуємо всі очищені директорії
+            cleanup_stats["temp_directories"] = ["temp/indices", "temp/sessions", "reports", "temp"]
+            
+            # Створюємо наново всі необхідні директорії
+            for directory in ["temp", "temp/indices", "temp/sessions", "reports", "reports/visualizations"]:
+                Path(directory).mkdir(exist_ok=True, parents=True)
+            
+            logger.info(f"Тимчасові дані успішно очищено: {cleanup_stats}")
+            return {
+                "success": True,
+                "stats": cleanup_stats
+            }
+        
+        except Exception as e:
+            logger.error(f"Помилка при очищенні тимчасових даних: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+# Додано функцію в модуль для обробка дат
+def safe_strftime(date_value, format_str="%Y-%m-%d"):
+    """Безпечне форматування дати з обробкою None та NaT значень."""
+    import pandas as pd
+    
+    if date_value is None or pd.isna(date_value):
+        return "Н/Д"  # або будь-яке інше значення за замовчуванням
+    try:
+        return date_value.strftime(format_str)
+    except Exception:
+        return "Неправильна дата"

modules/data_management/data_processor.py

@@ -0,0 +1,23 @@
+from modules.data_management.unified_index_manager import UnifiedIndexManager
+
+class DataProcessor:
+    def __init__(self):
+        # ... existing code ...
+        self.index_manager = UnifiedIndexManager()
+    
+    def process_data(self, df, session_id):
+        # ... existing code ...
+        
+        # Створюємо індекси
+        indices_result = self.index_manager.get_or_create_indices(df, session_id)
+        
+        if "error" in indices_result:
+            logger.error(f"Помилка при створенні індексів: {indices_result['error']}")
+        else:
+            logger.info(f"Індекси успішно створено: {indices_result['indices_dir']}")
+            
+        return {
+            "success": True,
+            "processed_data": df,
+            "indices_info": indices_result
+        }

modules/data_management/hash_utils.py

@@ -0,0 +1,51 @@
+import hashlib
+import pandas as pd
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+def generate_data_hash(data, key_columns=None):
+    """
+    Генерація хешу для даних.
+    
+    Args:
+        data: DataFrame або словник з даними
+        key_columns (list, optional): Список ключових колонок для хешування
+        
+    Returns:
+        str: Хеш даних
+    """
+    try:
+        if isinstance(data, pd.DataFrame):
+            # Якщо передано DataFrame
+            if key_columns:
+                # Фільтруємо тільки наявні колонки
+                available_columns = [col for col in key_columns if col in data.columns]
+                
+                if not available_columns:
+                    # Якщо немає жодної ключової колонки, використовуємо всі дані
+                    data_str = data.to_json(orient='records')
+                else:
+                    # Інакше використовуємо тільки ключові колонки
+                    data_str = data[available_columns].to_json(orient='records')
+            else:
+                # Якщо не вказано ключові колонки, використовуємо всі дані
+                data_str = data.to_json(orient='records')
+        elif isinstance(data, dict):
+            # Якщо передано словник
+            data_str = json.dumps(data, sort_keys=True)
+        else:
+            # Інакше конвертуємо в рядок
+            data_str = str(data)
+        
+        # Створюємо хеш
+        hash_object = hashlib.sha256(data_str.encode())
+        data_hash = hash_object.hexdigest()
+        
+        return data_hash
+        
+    except Exception as e:
+        logger.error(f"Помилка при генерації хешу даних: {e}")
+        # У випадку помилки повертаємо None
+        return None

modules/data_management/index_manager.py

@@ -0,0 +1,606 @@
+import os
+import logging
+import json
+import shutil
+from pathlib import Path
+import pandas as pd
+from datetime import datetime, timedelta
+import hashlib
+import uuid
+import faiss
+
+from modules.data_management.index_utils import validate_index_directory
+from modules.data_management.index_utils import check_indexing_availability, initialize_embedding_model
+from modules.data_management.hash_utils import generate_data_hash
+from modules.data_management.index_utils import check_index_integrity
+
+from modules.config.paths import INDICES_DIR
+
+from modules.config.ai_settings import (
+    CHUNK_SIZE,
+    CHUNK_OVERLAP,
+    EXCLUDED_EMBED_METADATA_KEYS,
+    EXCLUDED_LLM_METADATA_KEYS
+)
+
+logger = logging.getLogger(__name__)
+
+# Перевірка доступності модулів для індексування
+INDEXING_AVAILABLE = check_indexing_availability()
+INDEXING_MODULES = {
+    "VectorStoreIndex": None,
+    "StorageContext": None,
+    "SimpleDocumentStore": None,
+    "TokenTextSplitter": None,
+    "BM25Retriever": None,
+    "FaissVectorStore": None,
+    "Settings": None
+}
+
+
+
+def _generate_data_hash(self, df):
+    """
+    Генерація хешу для DataFrame для ідентифікації унікальних даних.
+    
+    Args:
+        df (pandas.DataFrame): DataFrame для хешування
+        
+    Returns:
+        str: Хеш даних
+    """
+    # Використовуємо основні колонки для хешування
+    key_columns = ['Issue key', 'Summary', 'Status', 'Issue Type', 'Created', 'Updated']
+    
+    return generate_data_hash(df, key_columns)
+
+class IndexManager:
+    """
+    Менеджер для створення та управління індексами даних (FAISS, BM25).
+    """
+    def __init__(self, base_indices_dir="temp/indices"):
+        """
+        Ініціалізація менеджера індексів.
+        
+        Args:
+            base_indices_dir (str): Базова директорія для зберігання індексів
+        """
+        self.base_indices_dir = Path(base_indices_dir) if base_indices_dir else INDICES_DIR
+        self.base_indices_dir.mkdir(exist_ok=True, parents=True)
+        
+        # Перевірка доступності модулів для індексування
+        self.indexing_available = INDEXING_AVAILABLE
+        if not self.indexing_available:
+            logger.warning("Функціональність індексування недоступна. Встановіть необхідні пакети.")
+    
+    def create_indices_for_session(self, session_id, merged_df, indices_dir=None):
+        """
+        Створення індексів для даних сесії.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            merged_df (pandas.DataFrame): DataFrame з об'єднаними даними
+            indices_dir (str, optional): Директорія для збереження індексів. 
+                                        Якщо None, використовується директорія сесії.
+                                        
+        Returns:
+            dict: Інформація про створені індекси
+        """
+        if not self.indexing_available:
+            return {"error": "Функціональність індексування недоступна. Встановіть необхідні пакети."}
+        
+        try:
+            # Визначаємо директорію для індексів
+            indices_path = Path(indices_dir) if indices_dir else self.base_indices_dir / session_id
+            indices_path.mkdir(exist_ok=True, parents=True)
+            
+            # Генеруємо хеш для даних
+            data_hash = self._generate_data_hash(merged_df)
+            
+            # Перевіряємо, чи існують індекси для цих даних
+            existing_indices = self._find_indices_by_hash(data_hash)
+            
+            if existing_indices:
+                return self._reuse_existing_indices(existing_indices, indices_path, session_id, data_hash, merged_df)
+            
+            # Створюємо нові індекси
+            return self._create_new_indices(indices_path, session_id, data_hash, merged_df)
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні індексів: {e}")
+            return {"error": f"Помилка при створенні індексів: {str(e)}"}
+    
+    def _reuse_existing_indices(self, existing_indices, indices_path, session_id, data_hash, merged_df):
+        """
+        Повторне використання існуючих індексів.
+        
+        Args:
+            existing_indices (str): Шлях до існуючих індексів
+            indices_path (Path): Шлях для нових індексів
+            session_id (str): Ідентифікатор сесії
+            data_hash (str): Хеш даних
+            merged_df (pandas.DataFrame): DataFrame з даними
+            
+        Returns:
+            dict: Інформація про скопійовані індекси
+        """
+        logger.info(f"Знайдено існуючі індекси для даних з хешем {data_hash}")
+        
+        try:
+            # Спочатку очищаємо цільову директорію
+            if indices_path.exists():
+                for item in indices_path.iterdir():
+                    if item.is_file():
+                        item.unlink()
+                    elif item.is_dir():
+                        shutil.rmtree(item)
+            
+            # Копіюємо індекси
+            for item in Path(existing_indices).iterdir():
+                if item.is_file():
+                    shutil.copy2(item, indices_path)
+                elif item.is_dir():
+                    shutil.copytree(item, indices_path / item.name)
+            
+            logger.info(f"Індекси успішно скопійовано в {indices_path}")
+            
+            # Оновлюємо метадані
+            metadata = {
+                "session_id": session_id,
+                "created_at": datetime.now().isoformat(),
+                "data_hash": data_hash,
+                "rows_count": len(merged_df),
+                "columns_count": len(merged_df.columns),
+                "copied_from": str(existing_indices)
+            }
+            
+            with open(indices_path / "metadata.json", "w", encoding="utf-8") as f:
+                json.dump(metadata, f, ensure_ascii=False, indent=2)
+            
+            return {
+                "success": True,
+                "indices_dir": str(indices_path),
+                "data_hash": data_hash,
+                "reused_existing": True,
+                "source": str(existing_indices)
+            }
+                
+        except Exception as copy_err:
+            logger.error(f"Помилка при копіюванні індексів: {copy_err}")
+            # Продовжуємо створення нових індексів
+            return self._create_new_indices(indices_path, session_id, data_hash, merged_df)
+    
+    def _create_new_indices(self, indices_path, session_id, data_hash, merged_df):
+        """
+        Створення нових індексів.
+        Зберігає індекси у форматі, сумісному з jira_hybrid_chat.py.
+        """
+        if not INDEXING_AVAILABLE:
+            return {"error": "Функціональність індексування недоступна"}
+                    
+        try:
+            logger.info(f"Створення нових індексів для сесії {session_id}")
+            
+            # Імпортуємо необхідні модулі напряму
+            from llama_index.core import VectorStoreIndex, StorageContext, Settings
+            from llama_index.core.storage.docstore import SimpleDocumentStore
+            from llama_index.core.node_parser import TokenTextSplitter
+            from llama_index.retrievers.bm25 import BM25Retriever
+            from llama_index.vector_stores.faiss import FaissVectorStore
+            import faiss
+            
+            # Ініціалізуємо модель ембедингів
+            from modules.data_management.index_utils import initialize_embedding_model
+            embed_model = initialize_embedding_model()
+            
+            # Отримуємо розмірність ембедингів динамічно
+            import numpy as np
+            test_embedding = embed_model.get_text_embedding("Тестовий текст")
+            embed_dim = len(test_embedding)
+            logger.info(f"Розмірність ембедингів: {embed_dim}")
+            
+            # Конвертуємо DataFrame в документи
+            documents = self._convert_dataframe_to_documents(merged_df)
+            
+            # Створюємо розділювач тексту
+            text_splitter = TokenTextSplitter(
+                chunk_size=CHUNK_SIZE,
+                chunk_overlap=CHUNK_OVERLAP
+            )
+            
+            # Встановлюємо формат збереження на JSON через глобальні налаштування
+            # Це важливо для сумісності з jira_hybrid_chat.py
+            Settings.persist_json_format = True
+            
+            # Створюємо FAISS індекс
+            faiss_index = faiss.IndexFlatL2(embed_dim)
+            
+            # Створюємо контекст зберігання
+            docstore = SimpleDocumentStore()
+            vector_store = FaissVectorStore(faiss_index=faiss_index)
+            
+            storage_context = StorageContext.from_defaults(
+                docstore=docstore,
+                vector_store=vector_store
+            )
+            
+            # Встановлюємо модель ембедингів у налаштуваннях
+            Settings.embed_model = embed_model
+            
+            # Створюємо індекс
+            index = VectorStoreIndex.from_documents(
+                documents,
+                storage_context=storage_context,
+                transformations=[text_splitter]
+            )
+            
+            # Зберігаємо індекс у форматі JSON (через глобальні налаштування)
+            # НЕ передаємо json_format як аргумент
+            index.storage_context.persist(persist_dir=str(indices_path))
+            
+            # Створюємо BM25 retriever
+            bm25_retriever = BM25Retriever.from_defaults(
+                docstore=docstore,
+                similarity_top_k=10
+            )
+            
+            # Зберігаємо параметри BM25
+            bm25_dir = indices_path / "bm25"
+            bm25_dir.mkdir(exist_ok=True)
+            
+            with open(bm25_dir / "params.json", "w", encoding="utf-8") as f:
+                json.dump({"similarity_top_k": 10}, f)
+            
+            # Зберігаємо метадані
+            metadata = {
+                "session_id": session_id,
+                "created_at": datetime.now().isoformat(),
+                "data_hash": data_hash,
+                "rows_count": len(merged_df),
+                "columns_count": len(merged_df.columns),
+                "embedding_model": embed_model.__class__.__name__,
+                "embedding_dim": embed_dim,
+                "format": "json"  # Вказуємо використаний формат збереження
+            }
+            
+            with open(indices_path / "metadata.json", "w", encoding="utf-8") as f:
+                json.dump(metadata, f, ensure_ascii=False, indent=2)
+
+            with open(indices_path / "indices.valid", "w", encoding="utf-8") as f:
+                f.write(f"Indices created at {datetime.now().isoformat()}")
+
+            logger.info(f"Створено файл-маркер indices.valid")
+            
+            return {
+                "success": True,
+                "indices_dir": str(indices_path),
+                "data_hash": data_hash
+            }
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні нових індексів: {e}")
+            return {"error": f"Помилка при створенні нових індексів: {str(e)}"}
+
+    def _save_bm25_data(self, indices_path, bm25_retriever):
+        """
+        Збереження даних для BM25 retriever.
+        
+        Args:
+            indices_path (Path): Шлях до директорії індексів
+            bm25_retriever (BM25Retriever): Об'єкт BM25Retriever
+            
+        Returns:
+            bool: True, якщо дані успішно збережені, False у випадку помилки
+        """
+        try:
+            # Створюємо директорію для BM25
+            bm25_dir = indices_path / "bm25"
+            bm25_dir.mkdir(exist_ok=True)
+            
+            # Зберігаємо параметри BM25
+            bm25_params = {
+                "similarity_top_k": bm25_retriever.similarity_top_k,
+                "alpha": getattr(bm25_retriever, "alpha", 0.75),
+                "beta": getattr(bm25_retriever, "beta", 0.75),
+                "index_creation_time": datetime.now().isoformat()
+            }
+            
+            with open(bm25_dir / "params.json", "w", encoding="utf-8") as f:
+                json.dump(bm25_params, f, ensure_ascii=False, indent=2)
+            
+            logger.info(f"Дані BM25 збережено в {bm25_dir}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Помилка при збереженні даних BM25: {e}")
+            return False
+    
+    def _convert_dataframe_to_documents(self, df):
+        """
+        Конвертує DataFrame в документи для індексування.
+        
+        Args:
+            df (pandas.DataFrame): DataFrame для конвертації
+            
+        Returns:
+            list: Список документів
+        """
+        try:
+            # Імпортуємо Document напряму
+            from llama_index.core import Document
+            
+            documents = []
+            
+            # Перебираємо рядки DataFrame
+            for idx, row in df.iterrows():
+                # Створюємо текст документа
+                text = f"Issue Key: {row.get('Issue key', '')}\n"
+                text += f"Summary: {row.get('Summary', '')}\n"
+                text += f"Status: {row.get('Status', '')}\n"
+                text += f"Issue Type: {row.get('Issue Type', '')}\n"
+                
+                # Додаємо опис, якщо він є
+                if 'Description' in row and pd.notna(row['Description']):
+                    text += f"Description: {row['Description']}\n"
+                
+                # Додаємо коментарі, якщо вони є
+                if 'Comments' in row and pd.notna(row['Comments']):
+                    text += f"Comments: {row['Comments']}\n"
+                
+                # Створюємо метадані
+                metadata = {
+                    "issue_key": row.get('Issue key', ''),
+                    "summary": row.get('Summary', ''),
+                    "status": row.get('Status', ''),
+                    "issue_type": row.get('Issue Type', ''),
+                    "created": str(row.get('Created', '')),
+                    "updated": str(row.get('Updated', ''))
+                }
+                
+                # Створюємо документ
+                doc = Document(
+                    text=text,
+                    metadata=metadata
+                )
+                
+                documents.append(doc)
+            
+            logger.info(f"Створено {len(documents)} документів з DataFrame")
+            return documents
+            
+        except Exception as e:
+            logger.error(f"Помилка при конвертації DataFrame в документи: {e}")
+            raise
+
+    def _generate_data_hash(self, df):
+        """
+        Генерація хешу для DataFrame для ідентифікації унікальних даних.
+        
+        Args:
+            df (pandas.DataFrame): DataFrame для хешування
+            
+        Returns:
+            str: Хеш даних
+        """
+        try:
+            # Використовуємо основні колонки для хешування
+            key_columns = ['Issue key', 'Summary', 'Status', 'Issue Type', 'Created', 'Updated']
+            
+            # Фільтруємо тільки наявні колонки
+            available_columns = [col for col in key_columns if col in df.columns]
+            
+            if not available_columns:
+                # Якщо немає жодної ключової колонки, використовуємо всі дані
+                data_str = df.to_json()
+            else:
+                # Інакше використовуємо тільки ключові колонки
+                data_str = df[available_columns].to_json()
+            
+            # Створюємо хеш
+            hash_object = hashlib.sha256(data_str.encode())
+            data_hash = hash_object.hexdigest()
+            
+            return data_hash
+            
+        except Exception as e:
+            logger.error(f"Помилка при генерації хешу даних: {e}")
+            # У випадку помилки повертаємо випадковий хеш
+            return str(uuid.uuid4())
+    
+    def _find_indices_by_hash(self, data_hash):
+        """
+        Пошук існуючих індексів за хешем даних.
+        
+        Args:
+            data_hash (str): Хеш даних
+            
+        Returns:
+            str: Шлях до директорії з індексами або None, якщо не знайдено
+        """
+        try:
+            # Перебираємо всі піддиректорії в базовій директорії індексів
+            for index_dir in self.base_indices_dir.iterdir():
+                if not index_dir.is_dir():
+                    continue
+                
+                # Перевіряємо метадані
+                metadata_file = index_dir / "metadata.json"
+                if not metadata_file.exists():
+                    continue
+                
+                try:
+                    with open(metadata_file, "r", encoding="utf-8") as f:
+                        metadata = json.load(f)
+                    
+                    # Перевіряємо хеш
+                    if metadata.get("data_hash") == data_hash:
+                        # Перевіряємо наявність необхідних файлів
+                        if validate_index_directory(index_dir):
+                            logger.info(f"Знайдено існуючі індекси з відповідним хешем: {index_dir}")
+                            return str(index_dir)
+                        else:
+                            logger.warning(f"Знайдено індекси з відповідним хешем, але вони неповні: {index_dir}")
+                except Exception as e:
+                    logger.error(f"Помилка при перевірці метаданих {metadata_file}: {e}")
+            
+            logger.info(f"Не знайдено існуючих індексів з хешем {data_hash}")
+            return None
+            
+        except Exception as e:
+            logger.error(f"Помилка при пошуку індексів за хешем: {e}")
+            return None
+
+    def cleanup_old_indices(self, max_age_days=7, max_indices=20):
+        """
+        Очищення застарілих індексів.
+        
+        Args:
+            max_age_days (int): Максимальний вік індексів у днях
+            max_indices (int): Максимальна кількість індексів для зберігання
+            
+        Returns:
+            int: Кількість видалених директорій індексів
+        """
+        try:
+            # Перевіряємо, чи існує базова директорія
+            if not self.base_indices_dir.exists():
+                return 0
+            
+            # Отримуємо список директорій індексів
+            index_dirs = []
+            
+            for index_dir in self.base_indices_dir.iterdir():
+                if not index_dir.is_dir():
+                    continue
+                
+                # Перевіряємо метадані для отримання часу створення
+                metadata_file = index_dir / "metadata.json"
+                created_at = None
+                
+                if metadata_file.exists():
+                    try:
+                        with open(metadata_file, "r", encoding="utf-8") as f:
+                            metadata = json.load(f)
+                        created_at = metadata.get("created_at")
+                    except Exception:
+                        pass
+                
+                # Якщо немає метаданих, використовуємо час створення директорії
+                if not created_at:
+                    created_at = datetime.fromtimestamp(index_dir.stat().st_mtime).isoformat()
+                
+                # Додаємо інформацію про директорію
+                index_dirs.append({
+                    "path": str(index_dir),
+                    "created_at": created_at
+                })
+            
+            # Якщо немає директорій для обробки, повертаємо 0
+            if not index_dirs:
+                return 0
+            
+            # Сортуємо директорії за часом створення (від найновіших до найстаріших)
+            index_dirs.sort(key=lambda x: x["created_at"], reverse=True)
+            
+            # Визначаємо директорії для видалення
+            dirs_to_delete = []
+            
+            # 1. Залишаємо max_indices найновіших директорій
+            if len(index_dirs) > max_indices:
+                dirs_to_delete.extend(index_dirs[max_indices:])
+            
+            # 2. Перевіряємо, чи є серед залишених застарілі директорії
+            cutoff_date = (datetime.now() - timedelta(days=max_age_days)).isoformat()
+            
+            for index_info in index_dirs[:max_indices]:
+                if index_info["created_at"] < cutoff_date:
+                    dirs_to_delete.append(index_info)
+            
+            # Видаляємо директорії
+            deleted_count = 0
+            
+            for dir_info in dirs_to_delete:
+                try:
+                    dir_path = Path(dir_info["path"])
+                    if dir_path.exists():
+                        shutil.rmtree(dir_path)
+                        logger.info(f"Видалено застарілу директорію індексів: {dir_path}")
+                        deleted_count += 1
+                except Exception as e:
+                    logger.error(f"Помилка при видаленні директорії {dir_info['path']}: {e}")
+            
+            return deleted_count
+            
+        except Exception as e:
+            logger.error(f"Помилка при очищенні застарілих індексів: {e}")
+            return 0
+    
+    def load_indices(self, indices_dir):
+        """
+        Завантаження індексів з директорії.
+        
+        Args:
+            indices_dir (str): Шлях до директорії з індексами
+            
+        Returns:
+            tuple: (VectorStoreIndex, BM25Retriever) або (None, None) у випадку помилки
+        """
+        if not self.indexing_available:
+            logger.warning("Функціональність індексування недоступна. Встановіть необхідні пакети.")
+            return None, None
+        
+        try:
+            # Перевіряємо цілісність індексів
+            is_valid, message = check_index_integrity(indices_dir)
+            if not is_valid:
+                logger.error(f"Індекси не пройшли перевірку цілісності: {message}")
+                return None, None
+
+            indices_path = Path(indices_dir)
+            
+            if not indices_path.exists():
+                logger.error(f"Директорія індексів не існує: {indices_dir}")
+                return None, None
+            
+            # Перевіряємо наявність необхідних файлів
+            if not (indices_path / "docstore.json").exists():
+                logger.error(f"Директорія індексів не містить необхідних файлів: {indices_dir}")
+                return None, None
+            
+            # Імпортуємо необхідні модулі
+            StorageContext = INDEXING_MODULES.get("StorageContext")
+            VectorStoreIndex = INDEXING_MODULES.get("VectorStoreIndex")
+            BM25Retriever = INDEXING_MODULES.get("BM25Retriever")
+            
+            # Завантажуємо контекст зберігання
+            storage_context = StorageContext.from_defaults(persist_dir=str(indices_path))
+            
+            # Завантажуємо індекс
+            index = VectorStoreIndex.from_storage_context(storage_context)
+            
+            # Створюємо BM25 retriever
+            bm25_retriever = BM25Retriever.from_defaults(
+                docstore=storage_context.docstore,
+                similarity_top_k=10
+            )
+            
+            # Завантажуємо параметри BM25, якщо вони є
+            bm25_params_file = indices_path / "bm25" / "params.json"
+            if bm25_params_file.exists():
+                try:
+                    with open(bm25_params_file, "r", encoding="utf-8") as f:
+                        bm25_params = json.load(f)
+                    
+                    # Встановлюємо параметри
+                    if "similarity_top_k" in bm25_params:
+                        bm25_retriever.similarity_top_k = bm25_params["similarity_top_k"]
+                except Exception as e:
+                    logger.warning(f"Помилка при завантаженні параметрів BM25: {e}")
+            
+            logger.info(f"Індекси успішно завантажено з {indices_dir}")
+            
+            return index, bm25_retriever
+            
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні індексів: {e}")
+            return None, None

modules/data_management/index_utils.py

@@ -0,0 +1,457 @@
+import logging
+import os
+import json
+import traceback
+from pathlib import Path
+import pandas as pd
+import tiktoken
+from typing import List, Dict, Any, Optional, Tuple
+
+from llama_index.core import (
+    Document,
+)
+
+
+# Встановлюємо змінну середовища, щоб примусово використовувати CPU
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+os.environ["TORCH_DEVICE"] = "cpu"
+
+from modules.config.ai_settings import (
+    get_metadata_csv,
+    CHUNK_SIZE,
+    CHUNK_OVERLAP,
+    EXCLUDED_EMBED_METADATA_KEYS,
+    EXCLUDED_LLM_METADATA_KEYS,
+    GOOGLE_EMBEDDING_MODEL
+)
+
+# Налаштування логування
+logger = logging.getLogger(__name__)
+
+def initialize_embedding_model():
+    """
+    Ініціалізує модель ембедингів згідно налаштувань.
+    Використовує офіційний пакет GeminiEmbedding для Google Embeddings.
+    
+    Returns:
+        object: Модель ембедингів
+    """
+    try:
+        # ПЕРША СПРОБА: Google Embeddings через офіційний пакет
+        google_api_key = os.getenv("GEMINI_API_KEY")
+        
+        # Перевіряємо наявність API ключа
+        if google_api_key:
+            try:
+                logger.info("Спроба ініціалізації Google Embeddings API через GeminiEmbedding...")
+                
+                from llama_index.embeddings.gemini import GeminiEmbedding
+                
+                # Використовуємо модель Gemini для ембедингів
+                model_name = "models/embedding-004"  # або "models/text-embedding-001"
+                
+                # Створюємо модель ембедингів Gemini
+                embed_model = GeminiEmbedding(
+                    model_name=model_name,
+                    api_key=google_api_key,
+                    task_type="retrieval_query"  # або "retrieval_document"
+                )
+                
+                # Тестуємо модель
+                logger.info("Виконуємо тестовий запит до Gemini Embeddings API...")
+                test_embedding = embed_model.get_text_embedding("Тестовий запит до Gemini Embeddings API")
+                
+                if test_embedding:
+                    logger.info(f"Тестовий запит успішний, отримано ембединг розмірністю {len(test_embedding)}")
+                    logger.info(f"Успішно ініціалізовано модель ембедингів Google Gemini: {model_name}")
+                    return embed_model
+                else:
+                    raise Exception("Тестове підключення до Google API не вдалося - отримано порожній результат")
+                
+            except ImportError as imp_err:
+                logger.error(f"Помилка імпорту модуля GeminiEmbedding: {imp_err}")
+                logger.error("Можливо, потрібно встановити пакет: pip install llama-index-embeddings-gemini")
+                logger.warning("Спробуємо альтернативні методи...")
+                
+                # Спробуємо альтернативний імпорт для Google AI SDK
+                try:
+                    # Через Google GenAI SDK безпосередньо
+                    from google import genai
+                    
+                    logger.info("Спроба ініціалізації через Google GenAI API безпосередньо...")
+                    
+                    # Ініціалізуємо клієнт Google GenAI
+                    genai.configure(api_key=google_api_key)
+                    client = genai.Client()
+                    
+                    # Функція для отримання ембедингів від Google API
+                    def get_google_embeddings(texts):
+                        if not isinstance(texts, list):
+                            texts = [texts]
+                        
+                        try:
+                            # Використовуємо Google Embeddings API
+                            result = client.models.embed_content(
+                                model=GOOGLE_EMBEDDING_MODEL,
+                                contents=texts,
+                                config={"task_type": "retrieval_query"}
+                            )
+                            
+                            # Виймаємо ембединги
+                            embeddings = [embedding.values for embedding in result.embeddings]
+                            
+                            # Повертаємо в правильному форматі для LlamaIndex
+                            return embeddings[0] if len(embeddings) == 1 else embeddings
+                        except Exception as e:
+                            logger.error(f"Помилка при отриманні ембедингів від Google API: {e}")
+                            logger.error(traceback.format_exc())
+                            raise
+                    
+                    # Тестуємо
+                    test_result = get_google_embeddings(["Тестовий запит до Google GenAI API"])
+                    if test_result:
+                        # Створюємо кастомну модель ембедингів
+                        embed_model = CustomEmbedding(
+                            embed_func=get_google_embeddings,
+                            embed_batch_size=8
+                        )
+                        
+                        logger.info(f"Успішно ініціалізовано кастомну модель ембедингів Google через GenAI SDK")
+                        return embed_model
+                    else:
+                        raise Exception("Тестове підключення до Google API не вдалося")
+                except ImportError:
+                    logger.error("Не вдалося імпортувати ні llama-index-embeddings-gemini, ні google.genai")
+                except Exception as e:
+                    logger.error(f"Помилка при альтернативній ініціалізації Google Embeddings: {e}")
+                    logger.error(traceback.format_exc())
+                    
+            except Exception as e:
+                logger.error(f"Не вдалося ініціалізувати Google Embeddings API: {e}")
+                logger.error(traceback.format_exc())
+                
+        else:
+            logger.warning("API ключ Google не знайдено (змінна GOOGLE_API_KEY не встановлена)")
+            logger.warning("Будь ласка, додайте GOOGLE_API_KEY у файл .env або змінні середовища")
+        
+        # ДРУГА СПРОБА: HuggingFace ембединги
+        logger.info("Використання локальних HuggingFace ембедингів...")
+        from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+        from modules.config.ai_settings import DEFAULT_EMBEDDING_MODEL, FALLBACK_EMBEDDING_MODEL
+        
+        try:
+            # Явно вказуємо використання CPU
+            embed_model = HuggingFaceEmbedding(
+                model_name=DEFAULT_EMBEDDING_MODEL,
+                device="cpu"  # Явно вказуємо CPU
+            )
+            logger.info(f"Успішно ініціалізовано модель ембедингів HuggingFace на CPU: {DEFAULT_EMBEDDING_MODEL}")
+            return embed_model
+        except Exception as e:
+            logger.warning(f"Не вдалося ініціалізувати основну модель HuggingFace ембедингів: {e}")
+            
+            # Спробуємо резервну модель
+            try:
+                embed_model = HuggingFaceEmbedding(
+                    model_name=FALLBACK_EMBEDDING_MODEL,
+                    device="cpu"  # Явно вказуємо CPU
+                )
+                logger.info(f"Успішно ініціалізовано резервну модель HuggingFace ембедингів на CPU: {FALLBACK_EMBEDDING_MODEL}")
+                return embed_model
+            except Exception as fallback_error:
+                logger.error(f"Не вдалося ініціалізувати резервну модель HuggingFace: {fallback_error}")
+                
+                # Створення найпростішого фальшивого ембедера для аварійної ситуації
+                try:
+                    from llama_index.embeddings.custom import CustomEmbedding
+                except ImportError:
+                    # Для сумісності зі старими версіями бібліотеки
+                    from llama_index.core.embeddings.custom import CustomEmbedding
+                    
+                import numpy as np
+                
+                def fallback_embedding_func(texts):
+                    if not isinstance(texts, list):
+                        texts = [texts]
+                    
+                    # Генеруємо фіктивні ембедінги (розмірність 768 - типова)
+                    embeddings = [np.random.rand(768).tolist() for _ in texts]
+                    return embeddings[0] if len(embeddings) == 1 else embeddings
+                
+                logger.warning("Використовуємо аварійний фальшивий ембедер")
+                return CustomEmbedding(embed_func=fallback_embedding_func)
+            
+    except Exception as e:
+        logger.error(f"Критична помилка при ініціалізації моделей ембедингів: {e}")
+        logger.error(traceback.format_exc())
+        
+        # Аварійний фальшивий ембедер
+        try:
+            from llama_index.embeddings.custom import CustomEmbedding
+        except ImportError:
+            # Для сумісності зі старими версіями бібліотеки
+            from llama_index.core.embeddings.custom import CustomEmbedding
+            
+        import numpy as np
+        
+        def emergency_embedding_func(texts):
+            if not isinstance(texts, list):
+                texts = [texts]
+            return [np.random.rand(768).tolist() for _ in texts]
+        
+        logger.warning("Використовуємо аварійний фальшивий ембедер через критичну помилку")
+        return CustomEmbedding(embed_func=emergency_embedding_func)
+
+
+def count_tokens(text, model="gpt-3.5-turbo"):
+    """
+    Підраховує приблизну кількість токенів для тексту.
+    
+    Args:
+        text (str): Текст для підрахунку токенів
+        model (str): Назва моделі для вибору енкодера
+        
+    Returns:
+        int: Кількість токенів
+    """
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+        tokens = encoding.encode(text)
+        return len(tokens)
+    except Exception as e:
+        logger.warning(f"Не вдалося підрахувати токени через tiktoken: {e}")
+        # Якщо не можемо використати tiktoken, робимо просту оцінку
+        return len(text) // 3  # Приблизна оцінка
+
+def convert_dataframe_to_documents(df: pd.DataFrame) -> List[Document]:
+    """
+    Перетворює DataFrame з даними Jira в документи для індексування.
+    
+    Args:
+        df (pd.DataFrame): DataFrame з даними Jira
+        
+    Returns:
+        List[Document]: Список документів для індексування
+    """
+    logger.info("Перетворення даних DataFrame в документи для LlamaIndex...")
+    
+    jira_documents = []
+    total_tokens = 0
+    
+    for idx, row in df.iterrows():
+        # Основний текст - опис тікета
+        text = ""
+        if 'Description' in row and pd.notnull(row['Description']):
+            text = str(row['Description'])
+            
+        # Додавання коментарів, якщо вони є
+        for col in df.columns:
+            if col.startswith('Comment') and pd.notnull(row[col]):
+                text += f"\n\nКоментар: {str(row[col])}"
+        
+        # Метадані для документа
+        metadata = metadata = get_metadata_csv(row, idx)
+        
+        # Додатково перевіряємо поле зв'язків, якщо воно є
+        if 'Outward issue link (Relates)' in row and pd.notnull(row['Outward issue link (Relates)']):
+            metadata["related_issues"] = row['Outward issue link (Relates)']
+        
+        # Додатково перевіряємо інші можливі поля зв'язків
+        for col in df.columns:
+            if col.startswith('Outward issue link') and col != 'Outward issue link (Relates)' and pd.notnull(row[col]):
+                link_type = col.replace('Outward issue link (', '').replace(')', '')
+                if "links" not in metadata:
+                    metadata["links"] = {}
+                metadata["links"][link_type] = str(row[col])
+        
+        # Створюємо документ з вказаними виключеннями
+        doc = Document(
+            text=text,
+            metadata=metadata,
+            excluded_embed_metadata_keys=EXCLUDED_EMBED_METADATA_KEYS,
+            excluded_llm_metadata_keys=EXCLUDED_LLM_METADATA_KEYS
+        )
+        
+        # Підраховуємо токени
+        token_count = count_tokens(text)
+        total_tokens += token_count
+        
+        # Додаємо документ до списку
+        jira_documents.append(doc)
+    
+    logger.info(f"Створено {len(jira_documents)} документів з {total_tokens} токенами")
+    return jira_documents
+
+def check_index_integrity(indices_path: str) -> Tuple[bool, str]:
+    """
+    Перевіряє цілісність індексів.
+    
+    Args:
+        indices_path (str): Шлях до директорії з індексами
+        
+    Returns:
+        Tuple[bool, str]: (True, '') якщо індекси валідні, (False, 'повідомлення про помилку') в іншому випадку
+    """
+    try:
+        indices_path = Path(indices_path)
+        
+        # Перевірка наявності директо��ії
+        if not indices_path.exists() or not indices_path.is_dir():
+            return False, f"Директорія з індексами не існує: {indices_path}"
+        
+        # Перевірка наявності маркера валідності
+        valid_marker = indices_path / "indices.valid"
+        if not valid_marker.exists():
+            return False, f"Маркер валідності індексів не знайдено в {indices_path}"
+        
+        # Перевірка наявності файлів індексів
+        required_files = ["docstore.json"]
+        for file in required_files:
+            if not (indices_path / file).exists():
+                return False, f"Файл {file} не знайдено в {indices_path}"
+        
+        # Перевірка наявності BM25 індексу
+        bm25_path = indices_path / "bm25"
+        if not bm25_path.exists() or not bm25_path.is_dir():
+            return False, f"Директорія з BM25 індексом не знайдено в {indices_path}"
+        
+        return True, ""
+        
+    except Exception as e:
+        return False, f"Помилка при перевірці цілісності індексів: {str(e)}"
+
+def check_indexing_availability(indices_path=None):
+    """
+    Перевіряє доступність функціональності індексування.
+    
+    Returns:
+        bool: True, якщо функціональність доступна, False - інакше
+    """
+    try:
+        # Перевіряємо наявність необхідних модулів
+        import importlib
+        
+        # Список необхідних модулів
+        required_modules = [
+            "llama_index.core",
+            "llama_index.retrievers.bm25",
+            "llama_index.vector_stores.faiss",
+            "llama_index.embeddings.huggingface"
+        ]
+        
+        # Додаємо Google Embeddings до списку, якщо встановлено змінну середовища
+        if os.getenv("GEMINI_API_KEY"):
+            required_modules.append("google.genai")
+        
+        # Перевіряємо кожен модуль
+        for module_name in required_modules:
+            try:
+                importlib.import_module(module_name)
+            except ImportError:
+                logger.warning(f"Модуль {module_name} не знайдено")
+                return False
+        
+        # Всі модулі доступні
+        logger.info("Всі необхідні модулі для індексування доступні")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Помилка при перевірці доступності індексування: {e}")
+        return False
+    
+def validate_index_directory(indices_path):
+    """
+    Перевіряє, чи директорія з індексами існує та містить необхідні файли.
+    
+    Args:
+        indices_path (str): Шлях до директорії з індексами
+        
+    Returns:
+        bool: True, якщо директорія валідна, False - інакше
+    """
+    try:
+        from pathlib import Path
+        
+        indices_path = Path(indices_path)
+        
+        # Перевірка наявності директорії
+        if not indices_path.exists() or not indices_path.is_dir():
+            return False
+        
+        # Перевірка наявності необхідних файлів
+        required_files = ["docstore.json"]
+        for file in required_files:
+            if not (indices_path / file).exists():
+                return False
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"Помилка при валідації директорії індексів: {str(e)}")
+        return False
+
+def test_google_embeddings():
+    """
+    Функція для тестування та відлагодження Google Embeddings API.
+    Можна запустити як окремий скрипт для перевірки роботи API.
+    
+    Запуск з командного рядка:
+    python -c "from modules.data_management.index_utils import test_google_embeddings; test_google_embeddings()"
+    """
+    import os
+    import logging
+    
+    # Налаштування логування
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(__name__)
+    
+    logger.info("Тестування Google Embeddings API...")
+    
+    # Отримання API ключа
+    api_key = os.getenv("GEMINI_API_KEY")
+    if not api_key:
+        logger.error("GEMINI_API_KEY не знайдений. Перевірте ваш .env файл або змінні середовища.")
+        return False
+    
+    logger.info(f"API ключ Google знайде��о: {api_key[:5]}...{api_key[-5:] if len(api_key) > 10 else '***'}")
+    
+    try:
+        from google import genai
+        
+        # Ініціалізація клієнта
+        genai.configure(api_key=api_key)
+        client = genai.Client()
+        logger.info("Google GenAI клієнт успішно ініціалізовано")
+        
+        # Спроба отримати ембединги
+        text = ["Тестовий текст українською мовою"]
+        model = "text-embedding-004"
+        
+        logger.info(f"Запит до моделі {model} з текстом: {text}")
+        
+        result = client.models.embed_content(
+            model=model,
+            contents=text,
+            config={"task_type": "retrieval_query"}
+        )
+        
+        # Отримання ембедингів
+        [embedding] = result.embeddings
+        embedding_values = embedding.values
+        
+        logger.info(f"Ембединг успішно отримано, розмірність: {len(embedding_values)}")
+        logger.info(f"Перші 5 значень: {embedding_values[:5]}")
+        
+        return True
+        
+    except ImportError:
+        logger.error("Модуль google.genai не знайдено. Будь ласка, встановіть його: pip install google-genai")
+        return False
+    except Exception as e:
+        import traceback
+        logger.error(f"Помилка при тестуванні Google Embeddings API: {e}")
+        logger.error(traceback.format_exc())
+        return False
+
+if __name__ == "__main__":
+    test_google_embeddings()

modules/data_management/session_manager.py

@@ -0,0 +1,463 @@
+import os
+import hashlib
+import uuid
+import json
+import logging
+import shutil
+from pathlib import Path
+from datetime import datetime, timedelta
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+class SessionManager:
+    """
+    Менеджер сесій користувачів для управління даними в багатокористувацькому середовищі.
+    Забезпечує ізоляцію даних між користувачами та уникнення конфліктів.
+    """
+    def __init__(self, base_dir="temp/sessions"):
+        """
+        Ініціалізація менеджера сесій.
+        
+        Args:
+            base_dir (str): Базова директорія для зберігання сесій
+        """
+        self.base_dir = Path(base_dir)
+        self.base_dir.mkdir(exist_ok=True, parents=True)
+        
+        # Очищення застарілих сесій при ініціалізації
+        self.cleanup_old_sessions()
+    
+    def create_session(self, user_id=None):
+        """
+        Створення нової сесії користувача.
+        
+        Args:
+            user_id (str, optional): Ідентифікатор користувача. Якщо None, генерується випадковий.
+            
+        Returns:
+            str: Ідентифікатор сесії
+        """
+        # Якщо user_id не вказано, генеруємо випадковий
+        if not user_id:
+            user_id = str(uuid.uuid4())
+        
+        # Генеруємо унікальний ідентифікатор сесії
+        session_id = f"{user_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
+        
+        # Створюємо директорію для сесії
+        session_dir = self.base_dir / session_id
+        session_dir.mkdir(exist_ok=True)
+        
+        # Створюємо підпапки для різних типів даних
+        (session_dir / "data").mkdir(exist_ok=True)  # Для CSV та DataFrame
+        (session_dir / "indices").mkdir(exist_ok=True)  # Для індексів FAISS та BM25
+        (session_dir / "reports").mkdir(exist_ok=True)  # Для звітів
+        (session_dir / "viz").mkdir(exist_ok=True)  # Для візуалізацій
+        
+        # Зберігаємо метадані сесії
+        metadata = {
+            "user_id": user_id,
+            "created_at": datetime.now().isoformat(),
+            "last_accessed": datetime.now().isoformat(),
+            "status": "active",
+            "data_files": []
+        }
+        
+        self._save_session_metadata(session_id, metadata)
+        
+        logger.info(f"Створено нову сесію: {session_id}")
+        return session_id
+    
+    def get_session_dir(self, session_id):
+        """
+        Отримання шляху до директорії сесії.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            
+        Returns:
+            Path: Шлях до директорії сесії або None, якщо сесія не існує
+        """
+        session_dir = self.base_dir / session_id
+        
+        if not session_dir.exists():
+            logger.warning(f"Сесія не знайдена: {session_id}")
+            return None
+        
+        # Оновлюємо час останнього доступу
+        self._update_session_access_time(session_id)
+        
+        return session_dir
+    
+    def get_session_data_dir(self, session_id):
+        """
+        Отримання шляху до директорії даних сесії.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            
+        Returns:
+            Path: Шлях до директорії даних або None, якщо сесія не існує
+        """
+        session_dir = self.get_session_dir(session_id)
+        if not session_dir:
+            return None
+        
+        return session_dir / "data"
+    
+    def get_session_indices_dir(self, session_id):
+        """
+        Отримання шляху до директорії індексів сесії.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            
+        Returns:
+            Path: Шлях до директорії індексів або None, якщо сесія не існує
+        """
+        session_dir = self.get_session_dir(session_id)
+        if not session_dir:
+            return None
+        
+        return session_dir / "indices"
+    
+    def add_data_file(self, session_id, file_path, file_type="uploaded", description=None):
+        """
+        Додавання інформації про файл даних до сесії.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            file_path (str): Шлях до файлу
+            file_type (str): Тип файлу ("uploaded", "local", "merged")
+            description (str, optional): Опис файлу
+            
+        Returns:
+            bool: True, якщо дані успішно додані, False у випадку помилки
+        """
+        session_dir = self.get_session_dir(session_id)
+        if not session_dir:
+            return False
+        
+        # Отримуємо поточні метадані сесії
+        metadata = self._get_session_metadata(session_id)
+        if not metadata:
+            return False
+        
+        # Генеруємо хеш файлу для відстеження дублікатів
+        file_hash = self._generate_file_hash(file_path)
+        
+        # Додаємо інформацію про файл
+        file_info = {
+            "path": str(file_path),
+            "filename": os.path.basename(file_path),
+            "type": file_type,
+            "hash": file_hash,
+            "size": os.path.getsize(file_path) if os.path.exists(file_path) else 0,
+            "added_at": datetime.now().isoformat(),
+            "description": description or ""
+        }
+        
+        # Перевіряємо на дублікати
+        for existing_file in metadata.get("data_files", []):
+            if existing_file.get("hash") == file_hash:
+                logger.warning(f"Файл вже існує в сесії: {file_path}")
+                return True
+        
+        # Додаємо файл до списку
+        metadata.setdefault("data_files", []).append(file_info)
+        
+        # Оновлюємо метадані
+        self._save_session_metadata(session_id, metadata)
+        
+        logger.info(f"Додано файл даних до сесії {session_id}: {file_path}")
+        return True
+    
+    def remove_data_file(self, session_id, file_path_or_hash):
+        """
+        Видалення інформації про файл даних із сесії.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            file_path_or_hash (str): Шлях до файлу або його хеш
+            
+        Returns:
+            bool: True, якщо дані успішно видалені, False у випадку помилки
+        """
+        session_dir = self.get_session_dir(session_id)
+        if not session_dir:
+            return False
+        
+        # Отримуємо поточні метадані сесії
+        metadata = self._get_session_metadata(session_id)
+        if not metadata:
+            return False
+        
+        # Шукаємо файл за шляхом або хешем
+        file_found = False
+        updated_files = []
+        
+        for file_info in metadata.get("data_files", []):
+            if file_info.get("path") == file_path_or_hash or file_info.get("hash") == file_path_or_hash:
+                file_found = True
+                # Файл може бути фізично видалений, якщо він знаходиться в директорії сесії
+                if file_info.get("path").startswith(str(session_dir)):
+                    try:
+                        os.remove(file_info.get("path"))
+                        logger.info(f"Фізично видалено файл: {file_info.get('path')}")
+                    except Exception as e:
+                        logger.warning(f"Не вдалося видалити файл {file_info.get('path')}: {e}")
+            else:
+                updated_files.append(file_info)
+        
+        if not file_found:
+            logger.warning(f"Файл не знайдено в сесії: {file_path_or_hash}")
+            return False
+        
+        # Оновлюємо список файлів
+        metadata["data_files"] = updated_files
+        
+        # Оновлюємо метадані
+        self._save_session_metadata(session_id, metadata)
+        
+        logger.info(f"Видалено файл з сесії {session_id}: {file_path_or_hash}")
+        return True
+    
+    def get_session_files(self, session_id):
+        """
+        Отримання списку файлів даних сесії.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            
+        Returns:
+            list: Список інформації про файли або порожній список у випадку помилки
+        """
+        # Отримуємо поточні метадані сесії
+        metadata = self._get_session_metadata(session_id)
+        if not metadata:
+            return []
+        
+        return metadata.get("data_files", [])
+    
+    def save_merged_data(self, session_id, merged_df, output_filename=None):
+        """
+        З��ереження об'єднаних даних у сесію.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            merged_df (pandas.DataFrame): DataFrame з об'єднаними даними
+            output_filename (str, optional): Ім'я файлу для збереження. Якщо None, генерується автоматично.
+            
+        Returns:
+            str: Шлях до збереженого файлу або None у випадку помилки
+        """
+        session_data_dir = self.get_session_data_dir(session_id)
+        if not session_data_dir:
+            return None
+        
+        try:
+            # Генеруємо ім'я файлу, якщо не вказано
+            if not output_filename:
+                timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                output_filename = f"merged_data_{timestamp}.csv"
+            
+            # Переконуємося, що файл має розширення .csv
+            if not output_filename.lower().endswith(".csv"):
+                output_filename += ".csv"
+            
+            # Шлях для збереження
+            output_path = session_data_dir / output_filename
+            
+            # Зберігаємо DataFrame у CSV
+            merged_df.to_csv(output_path, index=False)
+            
+            # Додаємо інформацію про файл до сесії
+            self.add_data_file(
+                session_id, 
+                str(output_path), 
+                file_type="merged", 
+                description="Об'єднані дані"
+            )
+            
+            logger.info(f"Збережено об'єднані дані у сесії {session_id}: {output_path}")
+            return str(output_path)
+            
+        except Exception as e:
+            logger.error(f"Помилка при збереженні об'єднаних даних: {e}")
+            return None
+    
+    def cleanup_session(self, session_id):
+        """
+        Очищення сесії (видалення всіх файлів і директорій).
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            
+        Returns:
+            bool: True, якщо сесія успішно очищена, False у випадку помилки
+        """
+        session_dir = self.base_dir / session_id
+        
+        if not session_dir.exists():
+            logger.warning(f"Сесія не знайдена: {session_id}")
+            return False
+        
+        try:
+            # Видаляємо всю директорію сесії
+            shutil.rmtree(session_dir)
+            logger.info(f"Сесію {session_id} успішно очищено")
+            return True
+        except Exception as e:
+            logger.error(f"Помилка при очищенні сесії {session_id}: {e}")
+            return False
+    
+    def cleanup_old_sessions(self, max_age_hours=24):
+        """
+        Очищення застарілих сесій.
+        
+        Args:
+            max_age_hours (int): Максимальний вік сесії в годинах для збереження
+            
+        Returns:
+            int: Кількість видалених сесій
+        """
+        cutoff_time = datetime.now() - timedelta(hours=max_age_hours)
+        deleted_count = 0
+        
+        # Перебираємо всі підпапки в базовій директорії
+        for session_dir in self.base_dir.iterdir():
+            if not session_dir.is_dir():
+                continue
+            
+            # Перевіряємо час останнього доступу до сесії
+            metadata_file = session_dir / "metadata.json"
+            if not metadata_file.exists():
+                # Якщо немає метаданих, видаляємо директорію
+                try:
+                    shutil.rmtree(session_dir)
+                    deleted_count += 1
+                    logger.info(f"Видалено сесію без метаданих: {session_dir.name}")
+                except Exception as e:
+                    logger.error(f"Помилка при видаленні сесії {session_dir.name}: {e}")
+                continue
+            
+            try:
+                with open(metadata_file, "r", encoding="utf-8") as f:
+                    metadata = json.load(f)
+                
+                last_accessed = datetime.fromisoformat(metadata.get("last_accessed", metadata.get("created_at")))
+                
+                if last_accessed < cutoff_time:
+                    # Сесія застаріла, видаляємо її
+                    shutil.rmtree(session_dir)
+                    deleted_count += 1
+                    logger.info(f"Видалено застарілу сесію: {session_dir.name}, " 
+                                f"останній доступ: {last_accessed.isoformat()}")
+            except Exception as e:
+                logger.error(f"Помилка при перевірці сесії {session_dir.name}: {e}")
+        
+        logger.info(f"Очищено {deleted_count} застарілих сесій")
+        return deleted_count
+    
+    def _save_session_metadata(self, session_id, metadata):
+        """
+        Збереження метаданих сесії.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            metadata (dict): Метадані для збереження
+            
+        Returns:
+            bool: True, якщо метадані успішно збережені, False у випадку помилки
+        """
+        session_dir = self.base_dir / session_id
+        
+        if not session_dir.exists():
+            logger.warning(f"Сесія не знайдена: {session_id}")
+            return False
+        
+        metadata_file = session_dir / "metadata.json"
+        
+        try:
+            with open(metadata_file, "w", encoding="utf-8") as f:
+                json.dump(metadata, f, ensure_ascii=False, indent=2)
+            return True
+        except Exception as e:
+            logger.error(f"Помилка при збереженні метаданих сесії {session_id}: {e}")
+            return False
+    
+    def _get_session_metadata(self, session_id):
+        """
+        Отримання метаданих сесії.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            
+        Returns:
+            dict: Метадані сесії або None у випадку помилки
+        """
+        session_dir = self.base_dir / session_id
+        metadata_file = session_dir / "metadata.json"
+        
+        if not metadata_file.exists():
+            logger.warning(f"Метадані сесії не знайдені: {session_id}")
+            return None
+        
+        try:
+            with open(metadata_file, "r", encoding="utf-8") as f:
+                metadata = json.load(f)
+            return metadata
+        except Exception as e:
+            logger.error(f"Помилка при читанні метаданих сесії {session_id}: {e}")
+            return None
+    
+    def _update_session_access_time(self, session_id):
+        """
+        Оновлення часу останнього доступу до сесії.
+        
+        Args:
+            session_id (str): Ідентифікатор сесії
+            
+        Returns:
+            bool: True, якщо час доступу успішно оновлено, False у випадку помилки
+        """
+        metadata = self._get_session_metadata(session_id)
+        if not metadata:
+            return False
+        
+        metadata["last_accessed"] = datetime.now().isoformat()
+        return self._save_session_metadata(session_id, metadata)
+    
+    @staticmethod
+    def _generate_file_hash(file_path):
+        """
+        Генерує хеш для файлу на основі його вмісту або шляху.
+        
+        Args:
+            file_path (str): Шлях до файлу
+            
+        Returns:
+            str: Хеш файлу
+        """
+        try:
+            if os.path.exists(file_path):
+                # Для невеликих файлів використовуємо вміст файлу
+                if os.path.getsize(file_path) < 10 * 1024 * 1024:  # < 10 MB
+                    sha256 = hashlib.sha256()
+                    with open(file_path, "rb") as f:
+                        for byte_block in iter(lambda: f.read(4096), b""):
+                            sha256.update(byte_block)
+                    return sha256.hexdigest()
+                else:
+                    # Для великих файлів використовуємо шлях, розмір і час модифікації
+                    file_stat = os.stat(file_path)
+                    hash_input = f"{file_path}_{file_stat.st_size}_{file_stat.st_mtime}"
+                    return hashlib.md5(hash_input.encode()).hexdigest()
+            else:
+                # Якщо файл не існує, повертаємо хеш шляху
+                return hashlib.md5(file_path.encode()).hexdigest()
+        except Exception as e:
+            logger.warning(f"Помилка при генерації хешу файлу {file_path}: {e}")
+            # У випадку помилки, повертаємо хеш шляху
+            return hashlib.md5(str(file_path).encode()).hexdigest()

modules/data_management/unified_index_manager.py

@@ -0,0 +1,571 @@
+import os
+import logging
+import json
+import shutil
+from pathlib import Path
+import pandas as pd
+from datetime import datetime, timedelta
+
+# Імпорт LlamaIndex компонентів
+from llama_index.core import (
+    VectorStoreIndex, 
+    Document, 
+    StorageContext,
+    load_index_from_storage,
+    Settings
+)
+from llama_index.core.node_parser import TokenTextSplitter
+from llama_index.retrievers.bm25 import BM25Retriever
+from llama_index.vector_stores.faiss import FaissVectorStore
+from llama_index.core.schema import TextNode
+from llama_index.core.storage.docstore import SimpleDocumentStore
+import faiss
+
+from modules.config.paths import INDICES_DIR
+from modules.data_management.hash_utils import generate_data_hash
+from modules.data_management.index_utils import (
+    check_indexing_availability, 
+    initialize_embedding_model,
+    check_index_integrity
+)
+
+from modules.config.ai_settings import (
+    get_metadata_csv,
+)
+
+# Встановлюємо формат збереження на бінарний (не JSON)
+Settings.persist_json_format = False
+
+logger = logging.getLogger(__name__)
+
+class UnifiedIndexManager:
+    """
+    Уніфікований менеджер для створення та управління індексами даних.
+    """
+    def __init__(self, base_indices_dir=None):
+        """
+        Ініціалізація менеджера індексів.
+        
+        Args:
+            base_indices_dir (str, optional): Базова директорія для зберігання індексів
+        """
+        self.base_indices_dir = Path(base_indices_dir) if base_indices_dir else INDICES_DIR
+        self.base_indices_dir.mkdir(exist_ok=True, parents=True)
+        
+        # Перевірка доступності модулів для індексування
+        self.indexing_available = check_indexing_availability("temp/indices")
+        if not self.indexing_available:
+            logger.warning("Функціональність індексування недоступна. Встановіть необхідні пакети.")
+    
+    def get_or_create_indices(self, df, session_id=None):
+        """
+        Отримання або створення індексів для даних.
+        
+        Args:
+            df (pandas.DataFrame): DataFrame з даними
+            session_id (str, optional): Ідентифікатор сесії
+            
+        Returns:
+            dict: Інформація про індекси
+        """
+        if not self.indexing_available:
+            return {"error": "Функціональність індексування недоступна. Встановіть необхідні пакети."}
+        
+        try:
+            # Генеруємо хеш для даних
+            data_hash = generate_data_hash(df, key_columns=['Issue key', 'Summary', 'Status', 'Issue Type', 'Created', 'Updated'])
+            
+            if not data_hash:
+                return {"error": "Не вдалося згенерувати хеш для даних"}
+            
+            # Перевіряємо, чи існують індекси для цих даних
+            existing_indices = self._find_indices_by_hash(data_hash)
+            
+            if existing_indices:
+                # Перевіряємо цілісність індексів
+                is_valid, message = check_index_integrity(existing_indices)
+                if is_valid:
+                    logger.info(f"Знайдено існуючі індекси для даних з хешем {data_hash}")
+                    return {
+                        "success": True,
+                        "indices_dir": str(existing_indices),
+                        "data_hash": data_hash,
+                        "reused_existing": True
+                    }
+                else:
+                    logger.warning(f"Знайдено індекси з відповідним хешем, але вони не пройшли перевірку цілісності: {message}")
+            
+            # Створюємо нові індекси
+            # Визначаємо директорію для індексів
+            if session_id:
+                indices_path = self.base_indices_dir / session_id
+            else:
+                # Якщо не вказано session_id, використовуємо поточну дату і час
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                indices_path = self.base_indices_dir / timestamp
+            
+            indices_path.mkdir(exist_ok=True, parents=True)
+            
+            # Створюємо нові індекси
+            result = self._create_new_indices(indices_path, session_id, data_hash, df)
+            
+            # Форматуємо результат
+            if isinstance(result, dict):
+                return result
+            else:
+                return {
+                    "success": True,
+                    "indices_dir": str(indices_path),
+                    "data_hash": data_hash
+                }
+            
+        except Exception as e:
+            logger.error(f"Помилка при отриманні або створенні індексів: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            return {"error": f"Помилка при отриманні або створенні індексів: {str(e)}"}
+
+    def _find_indices_by_hash(self, data_hash):
+        """
+        Пошук існуючих індексів за хешем даних.
+        
+        Args:
+            data_hash (str): Хеш даних
+            
+        Returns:
+            Path: Шлях до директорії з індексами або None, якщо не знайдено
+        """
+        try:
+            # Перебираємо всі піддиректорії в базовій директорії індексів
+            for index_dir in self.base_indices_dir.iterdir():
+                if not index_dir.is_dir():
+                    continue
+                
+                # Перевіряємо метадані
+                metadata_file = index_dir / "metadata.json"
+                if not metadata_file.exists():
+                    continue
+                
+                try:
+                    with open(metadata_file, "r", encoding="utf-8") as f:
+                        metadata = json.load(f)
+                    
+                    # Перевіряємо хеш
+                    if metadata.get("data_hash") == data_hash:
+                        return index_dir
+                except Exception as e:
+                    logger.error(f"Помилка при перевірці метаданих {metadata_file}: {e}")
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"Помилка при пошуку індексів за хешем: {e}")
+            return None
+    
+    def _create_new_indices(self, indices_path, session_id, data_hash, df):
+        """
+        Створення нових індексів.
+        
+        Args:
+            indices_path (Path): Шлях для збереження індексів
+            session_id (str): Ідентифікатор сесії
+            data_hash (str): Хеш даних
+            df (pandas.DataFrame): DataFrame з даними
+            
+        Returns:
+            dict: Інформація про створені індекси
+        """
+        try:
+            # Ініціалізуємо модель ембедингів
+            embed_model = initialize_embedding_model()
+            if not embed_model:
+                return {"error": "Не вдалося ініціалізувати модель ембедингів"}
+            
+            # Отримуємо розмірність ембедингів
+            sample_embedding = embed_model.get_text_embedding("Test")
+            embedding_dim = len(sample_embedding)
+            logger.info(f"Розмірність ембедингів: {embedding_dim}")
+            
+            # Конвертуємо DataFrame в документи
+            documents = self._convert_dataframe_to_documents(df)
+            if not documents:
+                return {"error": "Не вдалося конвертувати дані в документи"}
+            
+            # Створюємо ноди з документів
+            nodes = [TextNode(text=doc.text, metadata=doc.metadata) for doc in documents]
+            
+            # Створюємо FAISS індекс
+            faiss_index = faiss.IndexFlatL2(embedding_dim)
+            vector_store = FaissVectorStore(faiss_index=faiss_index)
+            
+            # Створюємо документне сховище
+            docstore = SimpleDocumentStore()
+            docstore.add_documents(nodes)
+            
+            # Створюємо контекст зберігання
+            storage_context = StorageContext.from_defaults(
+                docstore=docstore,
+                vector_store=vector_store
+            )
+            
+            # Встановлюємо модель ембедингів
+            Settings.embed_model = embed_model
+            
+            # Створюємо індекс
+            index = VectorStoreIndex.from_documents(
+                documents,
+                storage_context=storage_context
+            )
+            
+            # Зберігаємо індекс у файл (бінарний формат)
+            index.storage_context.persist(str(indices_path))
+            
+            # Створюємо BM25 retriever і зберігаємо його параметри
+            bm25_retriever = BM25Retriever.from_defaults(
+                docstore=docstore, 
+                similarity_top_k=10
+            )
+            self._save_bm25_data(indices_path, bm25_retriever)
+            
+            # Зберігаємо метадані
+            self._save_indices_metadata(indices_path, {
+                "session_id": session_id,
+                "created_at": datetime.now().isoformat(),
+                "data_hash": data_hash,
+                "documents_count": len(documents),
+                "nodes_count": len(nodes),
+                "rows_count": len(df),
+                "columns_count": len(df.columns),
+                "embedding_model": str(embed_model),
+                "embedding_dim": embedding_dim,
+                "storage_format": "binary"
+            })
+            
+            # Створюємо маркерний файл для перевірки валідності індексів
+            with open(indices_path / "indices.valid", "w") as f:
+                f.write(f"Indices created at {datetime.now().isoformat()}")
+            
+            logger.info(f"Індекси успішно створено в {indices_path}")
+            
+            # Зберігаємо шлях глобально, якщо доступно
+            self._save_indices_path_globally(str(indices_path))
+            
+            return {
+                "success": True,
+                "indices_dir": str(indices_path),
+                "data_hash": data_hash,
+                "documents_count": len(documents),
+                "nodes_count": len(nodes),
+                "rows_count": len(df),
+                "reused_existing": False
+            }
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні нових індексів: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            return {"error": f"Помилка при створенні нових індексів: {str(e)}"}
+
+    def _save_indices_metadata(self, indices_path, metadata):
+        """Зберігає метадані індексів у файл."""
+        try:
+            with open(indices_path / "metadata.json", "w", encoding="utf-8") as f:
+                json.dump(metadata, f, ensure_ascii=False, indent=2)
+            return True
+        except Exception as e:
+            logger.error(f"Помилка при збереженні метаданих: {e}")
+            return False
+
+    def _save_indices_path_globally(self, indices_path):
+        """Зберігає шлях до індексів у глобальних об'єктах (app, index_manager)."""
+        try:
+            import builtins
+            if hasattr(builtins, 'app'):
+                builtins.app.indices_path = indices_path
+                logger.info(f"Шлях до індексів збережено глобально: {indices_path}")
+                
+                # Якщо також є глобальний index_manager, зберігаємо в ньому
+                if hasattr(builtins, 'index_manager'):
+                    builtins.index_manager.last_indices_path = indices_path
+            return True
+        except Exception as e:
+            logger.warning(f"Не вдалося зберегти шлях до індексів глобально: {e}")
+            return False
+
+    def _convert_dataframe_to_documents(self, df):
+        """
+        Конвертує DataFrame у документи для індексування.
+        Кожен документ представляє один рядок CSV з усіма його полями.
+        """
+        try:
+            # Перевірка типу даних
+            if not hasattr(df, 'iterrows'):
+                logger.error(f"Отримано не DataFrame: {type(df)}")
+                return None
+                
+            # Конвертація в документи
+            documents = []
+            for idx, row in df.iterrows():
+                # Формуємо текст документа, включаючи всі основні поля
+                text_parts = []
+                
+                # Додаємо основні поля
+                key_fields = [
+                    ('Issue key', 'Ключ задачі'),
+                    ('Summary', 'Заголовок'),
+                    ('Issue Type', 'Тип задачі'),
+                    ('Status', 'Статус'),
+                    ('Priority', 'Пріоритет'),
+                    ('Assignee', 'Виконавець'),
+                    ('Reporter', 'Автор'),
+                    ('Created', 'Створено'),
+                    ('Updated', 'Оновлено'),
+                    ('Project name', 'Проект')
+                ]
+                
+                for field, title in key_fields:
+                    if field in row and pd.notna(row[field]):
+                        text_parts.append(f"{title}: {str(row[field])}")
+                
+                # Додаємо опис, якщо він є
+                if 'Description' in row and pd.notna(row['Description']):
+                    text_parts.append(f"Опис: {str(row['Description'])}")
+                
+                # Додаємо коментарі, якщо вони є
+                comments = []
+                for col in df.columns:
+                    if col.startswith('Comment') and pd.notna(row[col]):
+                        comments.append(str(row[col]))
+                
+                if comments:
+                    text_parts.append("Коментарі:")
+                    for i, comment in enumerate(comments, 1):
+                        text_parts.append(f"Коментар {i}: {comment}")
+                
+                # Додаємо інформацію про зв'язки, якщо вона є
+                links = []
+                for col in df.columns:
+                    if col.startswith('Outward issue link') and pd.notna(row[col]):
+                        link_type = col.replace('Outward issue link (', '').replace(')', '')
+                        links.append(f"{link_type}: {str(row[col])}")
+                
+                if links:
+                    text_parts.append("Зв'язки:")
+                    for link in links:
+                        text_parts.append(link)
+                
+                # Додаємо користувацькі поля
+                custom_fields = []
+                for col in df.columns:
+                    if (col.startswith('Custom field') or col.startswith('Sprint')) and pd.notna(row[col]):
+                        field_name = col.replace('Custom field (', '').replace(')', '')
+                        custom_fields.append(f"{field_name}: {str(row[col])}")
+                
+                if custom_fields:
+                    text_parts.append("Додаткові поля:")
+                    for field in custom_fields:
+                        text_parts.append(field)
+                
+                # Об'єднуємо все в один текст
+                text = "\n".join(text_parts)
+                
+                # Якщо текст порожній, використовуємо хоча б заголовок
+                if not text and 'Summary' in row and pd.notna(row['Summary']):
+                    text = f"Заголовок: {str(row['Summary'])}"
+                elif not text:
+                    text = f"Задача {idx}"
+                
+                # Створюємо метадані - включаємо всі основні поля
+                metadata = get_metadata_csv(row, idx)
+                
+                # Додаємо інформацію про зв'язки в метадані
+                if 'Outward issue link (Relates)' in row and pd.notna(row['Outward issue link (Relates)']):
+                    metadata["related_issues"] = row['Outward issue link (Relates)']
+                
+                # Створення документа
+                doc = Document(
+                    text=text,
+                    metadata=metadata
+                )
+                
+                documents.append(doc)
+            
+            logger.info(f"Створено {len(documents)} документів з DataFrame")
+            return documents
+            
+        except Exception as e:
+            logger.error(f"Помилка при конвертації DataFrame в документи: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            return []
+
+    def _save_bm25_data(self, indices_path, bm25_retriever):
+        """
+        Збереження даних для BM25 retriever.
+        """
+        try:
+            # Створюємо директорію для BM25
+            bm25_dir = indices_path / "bm25"
+            bm25_dir.mkdir(exist_ok=True)
+            
+            # Зберігаємо параметри BM25
+            bm25_params = {
+                "similarity_top_k": bm25_retriever.similarity_top_k,
+                "alpha": getattr(bm25_retriever, "alpha", 0.75),
+                "beta": getattr(bm25_retriever, "beta", 0.75),
+                "index_creation_time": datetime.now().isoformat()
+            }
+            
+            with open(bm25_dir / "params.json", "w", encoding="utf-8") as f:
+                json.dump(bm25_params, f, ensure_ascii=False, indent=2)
+            
+            logger.info(f"Дані BM25 збережено в {bm25_dir}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Помилка при збереженні даних BM25: {e}")
+            return False
+    
+    def load_indices(self, indices_dir):
+        """Завантаження індексів з директорії."""
+        try:
+            # Перевірка наявності директорії
+            indices_path = Path(indices_dir)
+            if not indices_path.exists():
+                logger.error(f"Директорія індексів не існує: {indices_dir}")
+                return None, None
+                    
+            # Перевірка наявності маркерного файлу
+            marker_path = indices_path / "indices.valid"
+            if not marker_path.exists():
+                logger.warning(f"Файл маркера не знайдено в {indices_dir}. Індекси не завантажено.")
+                return None, None
+                
+            try:
+                # Спробуємо завантажити vector_store
+                vector_store = FaissVectorStore.from_persist_dir(indices_dir)
+                
+                # Створюємо контекст зберігання
+                storage_context = StorageContext.from_defaults(
+                    vector_store=vector_store,
+                    persist_dir=indices_dir
+                )
+                
+                # Завантажуємо індекс
+                index = load_index_from_storage(
+                    storage_context=storage_context,
+                    index_cls=VectorStoreIndex
+                )
+                
+                # Створюємо BM25 retriever
+                bm25_retriever = BM25Retriever.from_defaults(
+                    docstore=storage_context.docstore,
+                    similarity_top_k=10
+                )
+                
+                # Перевіряємо наявність параметрів BM25
+                bm25_params_path = indices_path / "bm25" / "params.json"
+                if bm25_params_path.exists():
+                    try:
+                        with open(bm25_params_path, "r", encoding="utf-8") as f:
+                            bm25_params = json.load(f)
+                        
+                        if "similarity_top_k" in bm25_params:
+                            bm25_retriever.similarity_top_k = bm25_params["similarity_top_k"]
+                    except Exception as e:
+                        logger.warning(f"Не вдалося завантажити параметри BM25: {e}")
+                
+                logger.info(f"Індекси успішно завантажено з {indices_dir}")
+                return index, bm25_retriever
+                
+            except Exception as e:
+                logger.error(f"Помилка при завантаженні індексів: {e}")
+                import traceback
+                logger.error(traceback.format_exc())
+                
+                # Діагностичні повідомлення
+                logger.info(f"Файли у директорії {indices_dir}: {[f.name for f in indices_path.iterdir() if f.is_file()]}")
+                
+                return None, None
+                
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні індексів: {e}")
+            return None, None
+
+    def cleanup_old_indices(self, max_age_days=7, max_indices=20):
+        """
+        Очищення застарілих індексів.
+        
+        Args:
+            max_age_days (int): Максимальний вік індексів у днях
+            max_indices (int): Максимальна кількість індексів для зберігання
+            
+        Returns:
+            int: Кількість видалених директорій
+        """
+        try:
+            # Збираємо інформацію про всі директорії індексів
+            index_dirs = []
+            
+            for index_dir in self.base_indices_dir.iterdir():
+                if not index_dir.is_dir():
+                    continue
+                
+                # Перевіряємо метадані
+                metadata_file = index_dir / "metadata.json"
+                if not metadata_file.exists():
+                    continue
+                
+                try:
+                    with open(metadata_file, "r", encoding="utf-8") as f:
+                        metadata = json.load(f)
+                    
+                    # Отримуємо час створення
+                    created_at = metadata.get("created_at", "")
+                    
+                    index_dirs.append({
+                        "path": str(index_dir),
+                        "created_at": created_at
+                    })
+                except Exception as e:
+                    logger.error(f"Помилка при перевірці метаданих {metadata_file}: {e}")
+            
+            # Якщо немає директорій, виходимо
+            if not index_dirs:
+                return 0
+            
+            # Сортуємо директорії за часом створення (від найновіших до найстаріших)
+            index_dirs.sort(key=lambda x: x["created_at"], reverse=True)
+            
+            # Визначаємо директорії для видалення
+            dirs_to_delete = []
+            
+            # 1. Залишаємо max_indices найновіших директорій
+            if len(index_dirs) > max_indices:
+                dirs_to_delete.extend(index_dirs[max_indices:])
+            
+            # 2. Перевіряємо, чи є серед залишених застарілі директорії
+            cutoff_date = (datetime.now() - timedelta(days=max_age_days)).isoformat()
+            
+            for index_info in index_dirs[:max_indices]:
+                if index_info["created_at"] < cutoff_date:
+                    dirs_to_delete.append(index_info)
+            
+            # Видаляємо директорії
+            deleted_count = 0
+            
+            for dir_info in dirs_to_delete:
+                try:
+                    dir_path = Path(dir_info["path"])
+                    if dir_path.exists():
+                        shutil.rmtree(dir_path)
+                        logger.info(f"Видалено застарілу директорію індексів: {dir_path}")
+                        deleted_count += 1
+                except Exception as e:
+                    logger.error(f"Помилка при видаленні директорії {dir_info['path']}: {e}")
+            
+            return deleted_count
+            
+        except Exception as e:
+            logger.error(f"Помилка при очищенні застарілих індексів: {e}")
+            return 0

modules/interface/ai_assistant_ui.py

@@ -0,0 +1,139 @@
+import gradio as gr
+import logging
+import os
+
+logger = logging.getLogger("jira_assistant_interface")
+
+def init_indices_handler(app):
+    """
+    Обробник для кнопки ініціалізації індексів для гібридного чату.
+    Використовує безпосередньо логіку JiraHybridChat для створення індексів.
+    
+    Args:
+        app: Екземпляр JiraAssistantApp
+        
+    Returns:
+        str: HTML-повідомлення про результат
+    """
+    if not hasattr(app, 'current_data') or app.current_data is None:
+        return "<p style='color:red;'>❌ Помилка: спочатку завантажте дані CSV</p>"
+    
+    try:
+        # Функція для ініціалізації індексів через JiraHybridChat
+        def initialize_chat_indices():
+            try:
+                from modules.ai_analysis.jira_hybrid_chat import JiraHybridChat
+                
+                # Визначаємо директорію для індексів
+                indices_dir = None
+                if hasattr(app, 'current_session_id') and app.current_session_id is not None:
+                    indices_dir = f"temp/indices/{app.current_session_id}"
+                    os.makedirs(indices_dir, exist_ok=True)
+                
+                # Створюємо екземпляр JiraHybridChat
+                chat = JiraHybridChat(
+                    indices_dir=indices_dir,
+                    app=app
+                )
+                
+                # Якщо хочемо примусово перезавантажити/створити індекси,
+                # викликаємо load_indices
+                success = chat.load_indices(indices_dir)
+                if not success:
+                    return {"error": "Не вдалося створити або завантажити індекси"}
+                
+                # Отримуємо потрібні посилання на створені ретривери/індекси
+                vector_index = chat.index
+                bm25_retriever = chat.retriever_bm25
+                
+                if not vector_index or not bm25_retriever:
+                    return {"error": "Не вдалося створити індекси"}
+                
+                # Зберігаємо шлях до індексів
+                app.indices_path = indices_dir
+                
+                # Очищуємо кеш чату для перезавантаження з новими індексами
+                if hasattr(JiraHybridChat, 'chat_instances_cache'):
+                    JiraHybridChat.chat_instances_cache = {}
+                
+                return {
+                    "success": True,
+                    "indices_dir": indices_dir
+                }
+                
+            except Exception as e:
+                import traceback
+                logger.error(f"Помилка при ініціалізації індексів: {e}\n{traceback.format_exc()}")
+                return {"error": str(e)}
+            
+        # Викликаємо функцію ініціалізації
+        result = initialize_chat_indices()
+        
+        if "error" in result:
+            return f"<p style='color:red;'>❌ Помилка при створенні індексів: {result['error']}</p>"
+        
+        # Формуємо HTML для відображення результату
+        html_result = f"""
+        <div style='background-color:#e6f7e6; padding:15px; border-left:4px solid #28a745; border-radius:5px;'>
+            <p style='color:#28a745; font-weight:bold; font-size:16px;'>✅ Індекси успішно створено!</p>
+            <p>Директорія індексів: {result.get('indices_dir')}</p>
+            <p><b>Тепер можна використовувати гібридний чат!</b></p>
+        </div>
+        """
+        
+        return html_result
+        
+    except Exception as e:
+        import traceback
+        error_details = traceback.format_exc()
+        logger.error(f"Помилка при ініціалізації індексів: {e}\n{error_details}")
+        return f"<p style='color:red;'>❌ Помилка при ініціалізації індексів: {str(e)}</p>"
+
+def create_ai_assistant_tab(app):
+    """
+    Створює вкладку 'AI Асистенти' у Gradio інтерфейсі.
+    Спроба завантажити або модифікований, або стандартний AI асистент.
+    Якщо імпорт не вдається, показується повідомлення про залежності.
+    """
+    with gr.Tab("AI Асистенти"):
+        try:
+            # Додаємо секцію для ініціалізації індексів
+            gr.Markdown("## Ініціалізація індексів для гібридного пошуку")
+            gr.Markdown("""
+            Для роботи гібридного чату потрібно створити індекси FAISS і BM25.
+            Це потрібно зробити один раз після завантаження нових даних.
+            Кожен рядок CSV буде конвертовано в окрему ноду для пошуку.
+            """)
+            
+            init_indices_btn = gr.Button("Ініціалізувати індекси", variant="primary")
+            indices_status = gr.HTML(label="Статус індексів")
+            
+            # Прив'язуємо обробник до кнопки
+            init_indices_btn.click(
+                fn=lambda: init_indices_handler(app),
+                inputs=[],
+                outputs=[indices_status]
+            )
+            
+            # Спробуємо модифіковану версію
+            try:
+                from modules.ai_analysis.ai_assistant_integration_mod import setup_ai_assistant_tab
+                setup_ai_assistant_tab(app, gr)
+                logger.info("Успішно завантажено модифіковану версію AI асистента")
+            except ImportError:
+                logger.info("Помилка завантаження модифікованої версії AI асистента")
+
+        except ImportError as e:
+            logger.error(f"Помилка імпорту модулів для AI асистента: {e}")
+            gr.Markdown("## AI Асистенти для Jira")
+            gr.Markdown(f"""
+            ### ⚠️ Потрібні додаткові залежності
+
+            Для роботи AI асистентів необхідно встановити додаткові бібліотеки:
+
+            ```bash
+            pip install llama-index-llms-gemini llama-index llama-index-embeddings-openai llama-index-retrievers-bm25 llama-index-vector-stores-faiss faiss-cpu tiktoken
+            ```
+
+            Помилка: {str(e)}
+            """)

modules/interface/csv_analysis_ui.py

@@ -0,0 +1,551 @@
+import os
+import gradio as gr
+import logging
+from modules.interface.local_data_helper import LocalDataHelper
+
+from datetime import datetime
+
+logger = logging.getLogger("jira_assistant_interface")
+
+def simplified_analyze_csv(file_obj, inactive_days, app):
+    """
+    Спрощений аналіз CSV-файлу, викликає методи app для аналізу (без індексування).
+    """
+    if file_obj is None:
+        return "Помилка: файл не вибрано"
+
+    from pathlib import Path
+    import shutil
+    import pandas as pd
+
+    try:
+        logger.info(f"Отримано файл: {file_obj.name}, тип: {type(file_obj)}")
+
+        # Створення директорій
+        Path("temp/indices").mkdir(exist_ok=True, parents=True)
+        data_dir = Path("data")
+        data_dir.mkdir(exist_ok=True, parents=True)
+
+        # Формування шляху для збереження
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        base_dir = os.path.dirname(os.path.abspath(__file__))
+        temp_file_path = os.path.join(base_dir, "../../data", f"imported_data_{timestamp}.csv")
+
+        logger.info(f"Шлях для збереження: {temp_file_path}")
+        logger.info(f"Робоча директорія: {os.getcwd()}")
+
+        # Копіюємо/записуємо файл
+        if hasattr(file_obj, 'name'):
+            source_path = file_obj.name
+            shutil.copy2(source_path, temp_file_path)
+            logger.info(f"Файл скопійовано з {source_path} у {temp_file_path}")
+        else:
+            with open(temp_file_path, "wb") as f:
+                f.write(file_obj.read())
+            logger.info(f"Файл створено у {temp_file_path}")
+
+        if not os.path.exists(temp_file_path):
+            logger.error(f"Помилка: файл {temp_file_path} не було створено")
+            return "Помилка: не вдалося створити файл даних"
+
+        file_size = os.path.getsize(temp_file_path)
+        logger.info(f"Розмір файлу: {file_size} байт")
+        if file_size == 0:
+            logger.error("Помилка: порожній файл")
+            return "Помилка: файл порожній"
+
+        # Перевірка, що CSV читається
+        try:
+            df_test = pd.read_csv(temp_file_path)
+            logger.info(f"Файл успішно прочитано. Кількість рядків: {len(df_test)}, колонок: {len(df_test.columns)}")
+            app.current_data = df_test
+        except Exception as csv_err:
+            logger.error(f"Помилка при читанні CSV: {csv_err}")
+
+        # Виклик методу аналізу без AI і без індексування
+        result = app.analyze_csv_file(
+            temp_file_path,
+            inactive_days=inactive_days,
+            include_ai=False,
+            skip_indexing=True  # Важливо: пропускаємо створення індексів
+        )
+
+        if result.get("error"):
+            logger.error(f"Помилка аналізу: {result.get('error')}")
+            return result.get("error")
+
+        report = result.get("report", "")
+        app.last_loaded_csv = temp_file_path
+        logger.info(f"Шлях до файлу збережено в app.last_loaded_csv: {app.last_loaded_csv}")
+
+        if not os.path.exists(app.last_loaded_csv):
+            logger.error(f"Помилка: файл {app.last_loaded_csv} зник після аналізу")
+            return "Файл проаналізовано, але не збережено для подальшого використання. Спробуйте ще раз."
+
+        # Логування вмісту директорії data
+        try:
+            logger.info(f"Вміст директорії data: {os.listdir(os.path.join(base_dir, '../../data'))}")
+        except Exception as dir_err:
+            logger.error(f"Не вдалося отримати вміст директорії: {dir_err}")
+
+        return report
+
+    except Exception as e:
+        import traceback
+        error_msg = f"Помилка аналізу: {str(e)}\n\n{traceback.format_exc()}"
+        logger.error(error_msg)
+        return error_msg
+
+def local_files_analyze_csv(file_obj, inactive_days, app):
+    """
+    Аналіз CSV з локальних файлів або через нове завантаження.
+    Якщо file_obj = None, використовуємо дані з app.last_loaded_csv.
+    """
+    if file_obj is None:
+        if hasattr(app, 'current_data') and app.current_data is not None and \
+           hasattr(app, 'last_loaded_csv') and app.last_loaded_csv is not None:
+            try:
+                temp_file_path = app.last_loaded_csv
+                if not os.path.exists(temp_file_path):
+                    return "Помилка: файл не знайдено. Спочатку ініціалізуйте дані."
+
+                # Аналіз без індексування
+                result = app.analyze_csv_file(
+                    temp_file_path,
+                    inactive_days=inactive_days,
+                    include_ai=False,
+                    skip_indexing=True  # Важливо: пропускаємо створення індексів
+                )
+                if result.get("error"):
+                    return result.get("error")
+
+                return result.get("report", "")
+            except Exception as e:
+                return f"Помилка аналізу: {str(e)}"
+        else:
+            return "Помилка: файл не вибрано. Спочатку ініціалізуйте дані або завантажте CSV файл."
+
+    return simplified_analyze_csv(file_obj, inactive_days, app)
+
+def init_and_analyze(selected_files, uploaded_file, inactive_days, app, local_helper):
+    """
+    Об'єднує ініціалізацію даних та аналіз без створення індексів FAISS/BM25:
+      1) Викликається initialize_data_without_indices для підготовки даних без індексування
+      2) Якщо ініціалізація успішна, викликається local_files_analyze_csv
+      
+    Повертає об'єднаний звіт у форматі Markdown, який містить статус ініціалізації та результати аналізу.
+    """
+    # КРОК 1: Ініціалізація - без створення індексів
+    status_md, data_info = initialize_data_without_indices(selected_files, uploaded_file, app, local_helper)
+    if data_info is None:
+        return status_md
+
+    # КРОК 2: Аналіз
+    analysis_report = local_files_analyze_csv(uploaded_file, inactive_days, app)
+    
+    # Об'єднуємо результати (форматуємо як Markdown)
+    combined_md = (
+        f"{status_md}\n\n---\n\n"
+        "### Результати аналізу\n\n"
+        f"{analysis_report}"
+    )
+    return combined_md
+
+def initialize_data_without_indices(selected_files, uploaded_file, app, local_helper):
+    """
+    Модифікована версія initialize_data, яка не створює індекси FAISS/BM25.
+    Виконує тільки підготовку даних для аналізу.
+    
+    Args:
+        selected_files (list): Список вибраних файлів
+        uploaded_file: Завантажений файл
+        app: Екземпляр JiraAssistantApp
+        local_helper: Екземпляр LocalDataHelper
+        
+    Returns:
+        tuple: (status_html, data_info) - статус ініціалізації та інформація про дані
+    """
+    try:
+        session_id = local_helper.get_or_create_session()
+        app.current_session_id = session_id
+
+        # Отримуємо інформацію про локальні файли
+        local_files_info = local_helper.data_manager.get_local_files()
+        local_files_dict = {info['name']: info['path'] for info in local_files_info}
+
+        # Визначаємо шляхи до вибраних файлів
+        selected_paths = []
+        for selected in selected_files:
+            file_name = selected.split(" (")[0].strip() if " (" in selected else selected.strip()
+            if file_name in local_files_dict:
+                selected_paths.append(local_files_dict[file_name])
+
+        # Обробка завантаженого файлу
+        uploaded_file_path = None
+        if uploaded_file:
+            if hasattr(uploaded_file, 'name'):
+                uploaded_file_path = uploaded_file.name
+            else:
+                uploaded_file_path = uploaded_file
+
+        # Перевірка наявності файлів
+        if not selected_paths and not uploaded_file_path:
+            return "<p style='color:red;'>Помилка: не вибрано жодного файлу для обробки</p>", None
+
+        # Ініціалізація даних без створення індексів
+        success, result_info = initialize_session_data_no_indices(
+            local_helper.data_manager, 
+            session_id,
+            selected_paths,
+            uploaded_file_path
+        )
+        
+        if not success:
+            error_msg = result_info.get("error", "Невідома помилка")
+            return f"<p style='color:red;'>Помилка при ініціалізації даних: {error_msg}</p>", None
+
+        # Зберігаємо результати в app
+        merged_df = result_info.get("merged_df")
+        if merged_df is not None:
+            app.current_data = merged_df
+            app.last_loaded_csv = result_info.get("merged_file")
+            
+            # ВАЖЛ��ВО: НЕ встановлюємо шлях до індексів, щоб уникнути їх створення
+            # Це відрізняється від оригінальної функції initialize_data
+            logger.info("Успішна ініціалізація даних без створення індексів")
+
+        # Формуємо HTML-відповідь про успішну ініціалізацію
+        status_html = "<h3 style='color:green;'>✅ Дані успішно ініціалізовано</h3>"
+        status_html += f"<p>Об'єднано {result_info.get('source_files_count', 0)} файлів</p>"
+        status_html += f"<p>Загальна кількість рядків: {result_info.get('rows_count', 0)}</p>"
+        status_html += f"<p>Кількість колонок: {result_info.get('columns_count', 0)}</p>"
+
+        files_info = {
+            "session_id": session_id,
+            "merged_file": result_info.get("merged_file"),
+            "rows_count": result_info.get("rows_count", 0),
+            "columns_count": result_info.get("columns_count", 0),
+            "source_files_count": result_info.get("source_files_count", 0)
+        }
+
+        return status_html, files_info
+
+    except Exception as e:
+        logger.error(f"Помилка при ініціалізації даних без індексів: {e}")
+        import traceback
+        error_details = traceback.format_exc()
+        logger.error(error_details)
+        return f"<p style='color:red;'>Помилка при ініціалізації даних: {str(e)}</p>", None
+
+def initialize_session_data_no_indices(data_manager, session_id, selected_paths, uploaded_file_path=None):
+    """
+    Модифікована версія initialize_session_data, яка не створює індекси.
+    
+    Args:
+        data_manager: Екземпляр DataManager
+        session_id (str): ID сесії
+        selected_paths (list): Список шляхів до вибраних файлів
+        uploaded_file_path (str, optional): Шлях до завантаженого файлу
+        
+    Returns:
+        tuple: (success, result_info) - успішність операції та інформація про результат
+    """
+    try:
+        # Копіюємо вибрані файли в сесію
+        copied_files = data_manager.copy_files_to_session(session_id, selected_paths)
+        
+        # Додаємо завантажений файл, якщо він є
+        if uploaded_file_path and os.path.exists(uploaded_file_path):
+            # Копіюємо файл до сесії
+            session_data_dir = data_manager.session_manager.get_session_data_dir(session_id)
+            if not session_data_dir:
+                return False, {"error": "Не вдалося отримати директорію даних сесії"}
+            
+            # Створюємо унікальне ім'я для завантаженого файлу
+            from pathlib import Path
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            dest_filename = f"uploaded_{timestamp}_{Path(uploaded_file_path).name}"
+            dest_path = session_data_dir / dest_filename
+            
+            # Копіюємо файл
+            import shutil
+            shutil.copyfile(uploaded_file_path, dest_path)
+            
+            # Додаємо інформацію про файл до сесії
+            data_manager.session_manager.add_data_file(
+                session_id, 
+                str(dest_path), 
+                file_type="uploaded", 
+                description=f"Uploaded file: {Path(uploaded_file_path).name}"
+            )
+            
+            copied_files.append(str(dest_path))
+        
+        # Якщо немає файлів для обробки, повертаємо помилку
+        if not copied_files:
+            return False, {"error": "Не вибрано жодного файлу для обробки"}
+        
+        # Завантажуємо дані з усіх файлів
+        loaded_data = data_manager.load_data_from_files(session_id, copied_files)
+        
+        # Фільтруємо тільки успішно завантажені файли
+        valid_data = [(path, df) for path, df, success in loaded_data if success and df is not None]
+        
+        if not valid_data:
+            return False, {"error": "Не вдалося завантажити жодного файлу"}
+        
+        # Отримуємо список DataFrame
+        dataframes = [df for _, df in valid_data]
+        
+        # Об'єднуємо дані
+        merged_df, output_path = data_manager.merge_dataframes(
+            session_id, 
+            dataframes, 
+            output_name=f"merged_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+        )
+        
+        if merged_df is None or not output_path:
+            return False, {"error": "Не вдалося об'єднати дані"}
+        
+        result_info = {
+            "merged_file": output_path,
+            "rows_count": len(merged_df),
+            "columns_count": len(merged_df.columns),
+            "source_files_count": len(valid_data),
+            "merged_df": merged_df  # Передаємо DataFrame для подальшого використання
+        }
+        
+        logger.info(f"Дані успішно ініціалізовано без створення індексів: {output_path}")
+        return True, result_info
+        
+    except Exception as e:
+        logger.error(f"Помилка при ініціалізації даних сесії {session_id}: {e}")
+        return False, {"error": f"Помилка при ініціалізації даних: {str(e)}"} 
+
+def cleanup_temp_data_handler(app):
+    """
+    Обробник для кнопки очищення тимчасових даних.
+    Виконує очищення даних та скидає відповідні змінні в додатку.
+    
+    Args:
+        app: Екземпляр JiraAssistantApp
+        
+    Returns:
+        str: HTML-відформатований результат очищення
+    """
+    try:
+        import builtins
+        from pathlib import Path
+        
+        # Перевіряємо, чи є data_manager у додатку
+        if hasattr(app, 'data_manager'):
+            data_manager = app.data_manager
+        else:
+            # Створюємо новий екземпляр, якщо відсутній
+            from modules.data_management.data_manager import DataManager
+            data_manager = DataManager()
+        
+        # Запам'ятовуємо стан перед очищенням
+        had_indices_path = hasattr(app, 'indices_path') and app.indices_path is not None
+        had_session_id = hasattr(app, 'current_session_id') and app.current_session_id is not None
+        had_loaded_csv = hasattr(app, 'last_loaded_csv') and app.last_loaded_csv is not None
+        
+        # Виконуємо очищення
+        result = data_manager.cleanup_temp_data()
+        
+        # Скидаємо змінні додатку, які вказують на видалені дані
+        reset_info = ""
+        
+        # Скидаємо indices_path
+        if hasattr(app, 'indices_path'):
+            old_path = app.indices_path
+            app.indices_path = None
+            reset_info += f"<p>• Скинуто шлях до індексів: {old_path}</p>"
+        
+        # Скидаємо current_session_id
+        if hasattr(app, 'current_session_id'):
+            old_session = app.current_session_id
+            app.current_session_id = None
+            reset_info += f"<p>• Скинуто ID сесії: {old_session}</p>"
+        
+        # Скидаємо шлях до останнього завантаженого файлу, якщо він був у тимчасовій папці
+        if hasattr(app, 'last_loaded_csv') and app.last_loaded_csv:
+            last_file_path = Path(app.last_loaded_csv)
+            if any(temp_dir in str(last_file_path) for temp_dir in ["temp/", "reports/", "data/"]):
+                old_path = app.last_loaded_csv
+                app.last_loaded_csv = None
+                reset_info += f"<p>• Скинуто шлях до файлу CSV: {old_path}</p>"
+                
+                # Також скидаємо current_data, якщо він був завантажений з цього файлу
+                if hasattr(app, 'current_data') and app.current_data is not None:
+                    app.current_data = None
+                    reset_info += "<p>• Очищено завантажені дані DataFrame</p>"
+        
+        # Скидаємо кешовані індекси в глобальних об'єктах
+        try:
+            # Скидаємо глобальні змінні, якщо вони існують
+            if hasattr(builtins, 'app') and hasattr(builtins.app, 'indices_path'):
+                builtins.app.indices_path = None
+                reset_info += "<p>• Скинуто глобальний шлях до індексів</p>"
+                
+            if hasattr(builtins, 'index_manager') and hasattr(builtins.index_manager, 'last_indices_path'):
+                builtins.index_manager.last_indices_path = None
+                reset_info += "<p>• Скинуто глобальний шлях до останніх індексів</p>"
+                
+            # Якщо є кеш індексів в JiraHybridChat, очищаємо його
+            if hasattr(app, 'chat_instances_cache'):
+                app.chat_instances_cache = {}
+                reset_info += "<p>• Очищено кеш екземплярів чату</p>"
+                
+            # Перевірка наявності статичного кешу у класі JiraHybridChat
+            from modules.ai_analysis.jira_hybrid_chat import JiraHybridChat
+            if hasattr(JiraHybridChat, 'chat_instances_cache') and JiraHybridChat.chat_instances_cache:
+                JiraHybridChat.chat_instances_cache = {}
+                reset_info += "<p>• Очищено статичний кеш чату</p>"
+                
+        except Exception as e:
+            logger.warning(f"Помилка при очищенні глобальних змінних: {e}")
+        
+        if result.get("success", False):
+            stats = result.get("stats", {})
+            
+            # Формуємо HTML-відповідь
+            html_response = "<h3 style='color:green;'>✅ Тимчасові дані успішно очищено</h3>"
+            html_response += "<div style='background-color:#e9f7ef; padding:15px; border-radius:5px; margin-top:10px;'>"
+            html_response += "<p><b>Результати очищення:</b></p>"
+            html_response += f"<p>• Видалено тимчасових файлів: {stats.get('temp_files_removed', 0)}</p>"
+            html_response += f"<p>• Видалено директорій сесій: {stats.get('session_dirs_removed', 0)}</p>"
+            html_response += f"<p>• Видалено директорій індексів: {stats.get('indices_dirs_removed', 0)}</p>"
+            html_response += f"<p>• Видалено звітів і візуалізацій: {stats.get('reports_removed', 0)}</p>"
+            html_response += "</div>"
+            
+            # Додаємо інформацію про скинуті змінні
+            if reset_info:
+                html_response += "<div style='background-color:#FDEBD0; padding:15px; border-radius:5px; margin-top:10px;'>"
+                html_response += "<p><b>Скинуто наступні посилання на дані:</b></p>"
+                html_response += reset_info
+                html_response += "</div>"
+            
+            # Додаємо інформацію про стан перед/після
+            if had_indices_path or had_session_id or had_loaded_csv:
+                html_response += """
+                <div style='margin-top:15px;'>
+                    <p><i>⚠️ Увага: Для подальшого аналізу потрібно заново ініціалізувати дані</i></p>
+                </div>
+                """
+            
+            return html_response
+        else:
+            error_msg = result.get("error", "Невідома помилка")
+            return f"<h3 style='color:red;'>❌ Помилка при очищенні тимчасових даних</h3><p>{error_msg}</p>"
+    
+    except Exception as e:
+        import traceback
+        error_details = traceback.format_exc()
+        logger.error(f"Помилка при очищенні тимчасових даних: {e}\n{error_details}")
+        return f"<h3 style='color:red;'>❌ Помилка при очищенні тимчасових даних</h3><p>{str(e)}</p>"
+
+def create_csv_analysis_tab(app):
+    """
+    Створює вкладку "CSV Аналіз" у Gradio інтерфейсі:
+      - Завантаження файлів та перегляд локальних файлів.
+      - Об'єднаний аналіз: ініціалізація даних та аналіз через одну кнопку.
+      - Очищення тимчасових даних через кнопку.
+    В результаті звіт відображається як Markdown.
+    """
+    with gr.Tab("CSV Аналіз"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### Завантаження CSV")
+                local_file_input = gr.File(label="Завантажити CSV файл Jira")
+                local_inactive_days = gr.Slider(
+                    minimum=1, maximum=90, value=14, step=1,
+                    label="Кількість днів для визначення неактивних тікетів"
+                )
+
+                gr.Markdown("### Локальні файли")
+                refresh_btn = gr.Button("Оновити список файлів", variant="secondary")
+
+                local_helper = LocalDataHelper(app)
+                local_files_list, local_files_info = local_helper.list_local_files()
+
+                local_files_dropdown = gr.Dropdown(
+                    choices=local_files_list,
+                    multiselect=True,
+                    label="Виберіть файли з директорії current_data"
+                )
+                local_files_info_md = gr.Markdown(local_files_info)
+
+                gr.Markdown("### Перегляд вибраного файлу")
+                preview_file_dropdown = gr.Dropdown(
+                    choices=local_files_list,
+                    multiselect=False,
+                    label="Виберіть файл для перегляду"
+                )
+                preview_btn = gr.Button("Переглянути", variant="secondary")
+                file_preview_md = gr.Markdown("Виберіть файл для перегляду")
+
+                # Секція для очищення тимчасових даних
+                with gr.Accordion("Обслуговування", open=False):
+                    gr.Markdown("""
+                    ### Очищення тимчасових даних
+                    
+                    Ця функція видаляє всі тимчасові файли і директорії, крім файлів у папці **current_data**.
+                    
+                    **Будуть очищені:**
+                    - Тимчасові файли індексів (temp/indices)
+                    - Сесії користувачів (temp/sessions)
+                    - Тимчасові звіти (reports)
+                    - Інші файли в директорії temp
+                    """)
+                    cleanup_btn = gr.Button("🧹 Очистити тимчасові дані", variant="secondary")
+                    cleanup_result = gr.HTML(label="Результат очищення", visible=True)
+
+                gr.Markdown("### Об'єднаний аналіз (Ініціалізація + Аналіз)")
+                init_analyze_btn = gr.Button("Ініціалізація та Аналіз", variant="primary")
+
+            with gr.Column(scale=2):
+                gr.Markdown("### Результати ініціалізації")
+                combined_output = gr.Markdown(
+                    label="Об'єднаний звіт",
+                    value="Тут буде відображено статус ініціалізації та результати аналізу"
+                )
+
+                gr.Markdown("""
+                <style>
+                /* Додаткова стилізація */
+                .cleanup-note {
+                    margin-top: 15px;
+                    padding: 10px;
+                    background-color: #f8f9fa;
+                    border-left: 4px solid #6c757d;
+                }
+                </style>
+                """)
+
+        def refresh_local_files():
+            files_list, files_info = local_helper.list_local_files()
+            return files_list, files_info, files_list
+
+        refresh_btn.click(
+            refresh_local_files,
+            inputs=[],
+            outputs=[local_files_dropdown, local_files_info_md, preview_file_dropdown]
+        )
+        preview_btn.click(
+            local_helper.get_file_preview,
+            inputs=[preview_file_dropdown],
+            outputs=[file_preview_md]
+        )
+        init_analyze_btn.click(
+            fn=lambda sel_files, upl_file, days: init_and_analyze(sel_files, upl_file, days, app, local_helper),
+            inputs=[local_files_dropdown, local_file_input, local_inactive_days],
+            outputs=[combined_output]
+        )
+        
+        # Підключаємо обробник до кнопки очищення тимчасових даних
+        cleanup_btn.click(
+            fn=lambda: cleanup_temp_data_handler(app),
+            inputs=[],
+            outputs=[cleanup_result]
+        )

modules/interface/integrations_ui.py

@@ -0,0 +1,34 @@
+import gradio as gr
+import logging
+
+logger = logging.getLogger("jira_assistant_interface")
+
+def create_integrations_tab(app):
+    """
+    Створює вкладку 'Інтеграції' у Gradio інтерфейсі.
+    """
+    with gr.Tab("Інтеграції"):
+        gr.Markdown("## Інтеграції з зовнішніми системами")
+        gr.Markdown("⚠️ Ця функція буде доступна у наступних версіях")
+
+        with gr.Accordion("Slack інтеграція"):
+            slack_channel = gr.Textbox(
+                label="Slack канал",
+                placeholder="#project-updates"
+            )
+            slack_message = gr.Textbox(
+                label="Повідомлення",
+                placeholder="Тижневий звіт по проекту",
+                lines=3
+            )
+            slack_send_btn = gr.Button("Надіслати у Slack", interactive=False)
+
+        save_settings_btn = gr.Button("Зберегти налаштування", variant="primary")
+        settings_status = gr.Textbox(label="Статус")
+
+        # Заглушка
+        save_settings_btn.click(
+            lambda: "Налаштування збережено. Зміни набудуть чинності після перезапуску програми.",
+            inputs=[],
+            outputs=[settings_status]
+        )

modules/interface/jira_api_ui.py

@@ -0,0 +1,46 @@
+import gradio as gr
+import logging
+
+logger = logging.getLogger("jira_assistant_interface")
+
+def test_jira_connection_handler(url, username, api_token, app):
+    if not url or not username or not api_token:
+        return "Помилка: необхідно заповнити всі поля (URL, користувач, API токен)"
+
+    success = app.test_jira_connection(url, username, api_token)
+    if success:
+        return "✅ Успішне підключення до Jira API"
+    else:
+        return "❌ Помилка підключення до Jira. Перевірте введені дані."
+
+def create_jira_api_tab(app):
+    """
+    Створює вкладку 'Jira API' у Gradio інтерфейсі.
+    """
+    with gr.Tab("Jira API"):
+        gr.Markdown("## Підключення до Jira API")
+
+        with gr.Row():
+            jira_url = gr.Textbox(
+                label="Jira URL",
+                placeholder="https://your-company.atlassian.net"
+            )
+            jira_username = gr.Textbox(
+                label="Ім'я користувача Jira",
+                placeholder="email@example.com"
+            )
+            jira_api_token = gr.Textbox(
+                label="Jira API Token",
+                type="password"
+            )
+
+        test_connection_btn = gr.Button("Тестувати з'єднання")
+        connection_status = gr.Textbox(label="Статус підключення")
+
+        test_connection_btn.click(
+            lambda u, usr, tkn: test_jira_connection_handler(u, usr, tkn, app),
+            inputs=[jira_url, jira_username, jira_api_token],
+            outputs=[connection_status]
+        )
+
+        gr.Markdown("## ⚠️ Ця функція буде доступна у наступних версіях")

modules/interface/local_data_helper.py

@@ -0,0 +1,207 @@
+import os
+import logging
+from pathlib import Path
+import traceback
+
+from modules.data_management.data_manager import DataManager
+from modules.data_management.session_manager import SessionManager
+from modules.data_management.index_manager import IndexManager
+
+logger = logging.getLogger("jira_assistant_interface")
+
+class LocalDataHelper:
+    """
+    Клас для роботи з локальними CSV-файлами, сесіями та попереднім переглядом даних.
+    """
+    def __init__(self, app, current_data_dir="current_data"):
+        self.app = app
+        self.current_data_dir = Path(current_data_dir)
+        self.current_data_dir.mkdir(exist_ok=True, parents=True)
+
+        # Ініціалізація менеджерів
+        self.session_manager = SessionManager()
+        self.data_manager = DataManager(current_data_dir, self.session_manager)
+        self.index_manager = IndexManager()
+
+        # Словник сесій для користувачів
+        self.user_sessions = {}
+
+    def get_or_create_session(self, user_id=None):
+        if not user_id:
+            import uuid
+            user_id = str(uuid.uuid4())
+
+        if user_id in self.user_sessions:
+            return self.user_sessions[user_id]
+
+        session_id = self.session_manager.create_session(user_id)
+        self.user_sessions[user_id] = session_id
+
+        logger.info(f"Створено нову сесію {session_id} для користувача {user_id}")
+        return session_id
+
+    def list_local_files(self):
+        try:
+            files_info = self.data_manager.get_local_files()
+            if not files_info:
+                return [], "<p>Не знайдено файлів CSV у директорії current_data.</p>"
+
+            # Використовуємо реальні дані, якщо доступні, інакше fallback до preview
+            files_list = [
+                f"{info['name']} ({info['size_kb']} KB, рядків: {info.get('rows_count', info.get('rows_preview', 'N/A'))}, колонок: {info.get('columns_count', info.get('columns_preview', 'N/A'))})"
+                for info in files_info
+            ]
+
+            # Формуємо HTML
+            html_output = "<h3>Доступні файли в директорії current_data:</h3>"
+            html_output += "<table style='width:100%; border-collapse: collapse;'>"
+            html_output += "<tr style='background-color: #f2f2f2;'><th>Файл</th><th>Розмір</th><th>Змінено</th><th>Рядки</th><th>Колонки</th></tr>"
+
+            for info in files_info:
+                html_output += "<tr style='border-bottom: 1px solid #ddd;'>"
+                html_output += f"<td>{info['name']}</td>"
+                html_output += f"<td>{info['size_kb']} KB</td>"
+                html_output += f"<td>{info['modified']}</td>"
+                html_output += f"<td>{info.get('rows_count', info.get('rows_preview', 'N/A'))}</td>"
+                html_output += f"<td>{info.get('columns_count', info.get('columns_preview', 'N/A'))}</td>"
+                html_output += "</tr>"
+
+            html_output += "</table>"
+
+            # Приховане поле з шляхами
+            html_output += "<div id='file_paths' style='display:none;'>"
+            for info in files_info:
+                html_output += f"<div data-name='{info['name']}'>{info['path']}</div>"
+            html_output += "</div>"
+
+            return files_list, html_output
+
+        except Exception as e:
+            logger.error(f"Помилка при отриманні списку локальних файлів: {e}")
+            return [], f"<p>Помилка при отриманні списку файлів: {str(e)}</p>"
+
+    def get_file_preview(self, selected_file):
+        try:
+            if not selected_file:
+                return "<p>Виберіть файл для перегляду</p>"
+
+            local_files_info = self.data_manager.get_local_files()
+            local_files_dict = {info['name']: info['path'] for info in local_files_info}
+
+            file_name = selected_file.split(" (")[0].strip() if " (" in selected_file else selected_file.strip()
+            if file_name not in local_files_dict:
+                return f"<p>Файл {file_name} не знайдено</p>"
+
+            file_path = local_files_dict[file_name]
+            preview_info = self.data_manager.get_file_preview(file_path, max_rows=5)
+
+            if "error" in preview_info:
+                return f"<p style='color:red;'>Помилка при читанні файлу: {preview_info['error']}</p>"
+
+            # Формуємо HTML
+            html_output = f"<h3>Попередній перегляд файлу: {file_name}</h3>"
+            html_output += f"<p>Загальна кількість рядків: {preview_info['total_rows']}</p>"
+            html_output += f"<p>Кількість колонок: {preview_info['columns_count']}</p>"
+
+            html_output += "<table style='width:100%; border-collapse: collapse; font-size: 14px;'>"
+            # Заголовки
+            html_output += "<tr style='background-color: #4472C4; color: white;'>"
+            for col in preview_info['columns']:
+                html_output += f"<th style='padding: 8px; text-align: left;'>{col}</th>"
+            html_output += "</tr>"
+
+            # Дані
+            for i, row in enumerate(preview_info['preview_rows']):
+                row_style = "background-color: #E9EDF5;" if i % 2 == 0 else ""
+                html_output += f"<tr style='{row_style}'>"
+                for col in preview_info['columns']:
+                    value = row.get(col, "")
+                    if isinstance(value, str) and len(value) > 100:
+                        value = value[:100] + "..."
+                    html_output += f"<td style='padding: 8px; border-bottom: 1px solid #ddd;'>{value}</td>"
+                html_output += "</tr>"
+
+            html_output += "</table>"
+            return html_output
+
+        except Exception as e:
+            logger.error(f"Помилка при отриманні попереднього перегляду файлу: {e}")
+            return f"<p style='color:red;'>Помилка при перегляді файлу: {str(e)}</p>"
+
+    def initialize_data(self, selected_files, uploaded_file=None, user_id=None):
+        try:
+            session_id = self.get_or_create_session(user_id)
+            self.app.current_session_id = session_id
+
+            local_files_info = self.data_manager.get_local_files()
+            local_files_dict = {info['name']: info['path'] for info in local_files_info}
+
+            selected_paths = []
+            for selected in selected_files:
+                file_name = selected.split(" (")[0].strip() if " (" in selected else selected.strip()
+                if file_name in local_files_dict:
+                    selected_paths.append(local_files_dict[file_name])
+
+            uploaded_file_path = None
+            if uploaded_file:
+                if hasattr(uploaded_file, 'name'):
+                    uploaded_file_path = uploaded_file.name
+                else:
+                    uploaded_file_path = uploaded_file
+
+            if not selected_paths and not uploaded_file_path:
+                return "<p style='color:red;'>Помилка: не вибрано жодного файлу для обробки</p>", None
+
+            success, result_info = self.data_manager.initialize_session_data(
+                session_id,
+                selected_paths,
+                uploaded_file_path
+            )
+            if not success:
+                error_msg = result_info.get("error", "Невідома помилка")
+                return f"<p style='color:red;'>Помилка при ініціалізації даних: {error_msg}</p>", None
+
+            merged_df = result_info.get("merged_df")
+            if merged_df is not None:
+                self.app.current_data = merged_df
+                self.app.last_loaded_csv = result_info.get("merged_file")
+
+                indices_dir = self.session_manager.get_session_indices_dir(session_id)
+                if indices_dir:
+                    abs_indices_path = os.path.abspath(indices_dir)
+                    self.app.indices_path = abs_indices_path
+                    logger.info(f"Встановлено шлях до директорії для індексів в app: {abs_indices_path}")
+
+                    # Спроба зберегти шлях глобально
+                    try:
+                        import builtins
+                        if hasattr(builtins, 'app'):
+                            builtins.app.indices_path = self.app.indices_path
+                            logger.info("Збережено шлях до директорії індексів у глобальному об'єкті app")
+                        if hasattr(builtins, 'index_manager'):
+                            builtins.index_manager.last_indices_path = self.app.indices_path
+                            logger.info("Збережено шлях до директорії індексів у глобальному об'єкті index_manager")
+                    except Exception as e:
+                        logger.warning(f"Не вдалося зберегти шлях глобально: {e}")
+
+            status_html = "<h3 style='color:green;'>Дані успішно ініціалізовано</h3>"
+            status_html += f"<p>Об'єднано {result_info.get('source_files_count', 0)} файлів</p>"
+            status_html += f"<p>Загальна кількість рядків: {result_info.get('rows_count', 0)}</p>"
+            status_html += f"<p>Кількість колонок: {result_info.get('columns_count', 0)}</p>"
+
+            files_info = {
+                "session_id": session_id,
+                "merged_file": result_info.get("merged_file"),
+                "rows_count": result_info.get("rows_count", 0),
+                "columns_count": result_info.get("columns_count", 0),
+                "source_files_count": result_info.get("source_files_count", 0),
+                "indices_dir": indices_dir if indices_dir else None
+            }
+
+            return status_html, files_info
+
+        except Exception as e:
+            logger.error(f"Помилка при ініціалізації даних: {e}")
+            error_details = traceback.format_exc()
+            logger.error(error_details)
+            return f"<p style='color:red;'>Помилка при ініціалізації даних: {str(e)}</p>", None

modules/interface/visualizations_ui.py

@@ -0,0 +1,112 @@
+import gradio as gr
+import logging
+from datetime import datetime
+from pathlib import Path
+import matplotlib.pyplot as plt
+
+logger = logging.getLogger("jira_assistant_interface")
+
+def on_viz_generate_clicked(viz_type, limit, groupby_text, app):
+    """
+    Обробник для кнопки "Генерувати".
+    """
+    groupby_map = {"день": "day", "тиждень": "week", "місяць": "month"}
+    groupby = groupby_map.get(groupby_text, "day")
+
+    if not hasattr(app, 'current_data') or app.current_data is None:
+        return gr.Plot.update(value=None), "Спочатку завантажте та проаналізуйте дані"
+
+    fig = app.generate_visualization(viz_type, limit=limit, groupby=groupby)
+    if fig:
+        return fig, None
+    else:
+        return None, f"Не вдалося згенерувати візуалізацію типу '{viz_type}'"
+
+def save_visualization(viz_type, limit, groupby_text, filename, app):
+    """
+    Зберігає згенеровану візуалізацію у файл.
+    """
+    try:
+        groupby_map = {"день": "day", "тиждень": "week", "місяць": "month"}
+        groupby = groupby_map.get(groupby_text, "day")
+
+        fig = app.generate_visualization(viz_type, limit=limit, groupby=groupby)
+        if fig is None:
+            return "Помилка: не вдалося створити візуалізацію"
+
+        if not filename:
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            viz_type_clean = viz_type.lower().replace(' ', '_').replace(':', '_')
+            filename = f"viz_{viz_type_clean}_{timestamp}.png"
+
+        if not any(filename.lower().endswith(ext) for ext in ['.png', '.jpg', '.svg', '.pdf']):
+            filename += '.png'
+
+        reports_dir = Path("reports/visualizations")
+        reports_dir.mkdir(parents=True, exist_ok=True)
+
+        filepath = reports_dir / filename
+        fig.savefig(filepath, dpi=300, bbox_inches='tight')
+        plt.close(fig)
+
+        return f"✅ Візуалізацію збережено: {filepath}"
+    except Exception as e:
+        import traceback
+        error_msg = f"Помилка збереження візуалізації: {str(e)}\n\n{traceback.format_exc()}"
+        logger.error(error_msg)
+        return error_msg
+
+def create_visualizations_tab(app):
+    """
+    Створює вкладку 'Візуалізації' у Gradio інтерфейсі.
+    """
+    with gr.Tab("Візуалізації"):
+        gr.Markdown("## Типи візуалізацій")
+
+        with gr.Row():
+            viz_type = gr.Dropdown(
+                choices=[
+                    "Статуси", "Пріоритети", "Типи тікетів", "Призначені користувачі",
+                    "Активність створення", "Активність оновлення", "Кумулятивне створення",
+                    "Неактивні тікети", "Теплова карта: Типи/Статуси",
+                    "Часова шкала проекту", "Склад статусів з часом"
+                ],
+                value="Статуси",
+                label="Тип візуалізації"
+            )
+            viz_generate_btn = gr.Button("Генерувати", variant="primary")
+
+        with gr.Accordion("Параметри візуалізації", open=False):
+            with gr.Row():
+                viz_param_limit = gr.Slider(minimum=5, maximum=20, value=10, step=1,
+                                            label="Ліміт для топ-візуалізацій")
+                viz_param_groupby = gr.Dropdown(
+                    choices=["день", "тиждень", "місяць"],
+                    value="день",
+                    label="Групування для часових діаграм"
+                )
+
+        with gr.Row():
+            viz_plot = gr.Plot(label="Візуалізація")
+            viz_status = gr.Textbox(label="Статус", visible=False)
+
+        with gr.Row():
+            viz_filename = gr.Textbox(
+                label="Ім'я файлу (опціонально)",
+                placeholder="Залиште порожнім для автоматичного імені"
+            )
+            viz_save_btn = gr.Button("Зберегти візуалізацію", variant="secondary")
+            viz_save_status = gr.Textbox(label="Статус збереження")
+
+        # Прив'язка подій
+        viz_generate_btn.click(
+            lambda t, l, g: on_viz_generate_clicked(t, l, g, app),
+            inputs=[viz_type, viz_param_limit, viz_param_groupby],
+            outputs=[viz_plot, viz_status]
+        )
+
+        viz_save_btn.click(
+            lambda t, l, g, f: save_visualization(t, l, g, f, app),
+            inputs=[viz_type, viz_param_limit, viz_param_groupby, viz_filename],
+            outputs=[viz_save_status]
+        )

modules/reporting/report_generator.py

@@ -0,0 +1,374 @@
+import os
+import logging
+import pandas as pd
+import re
+from datetime import datetime
+from pathlib import Path
+import markdown
+import matplotlib.pyplot as plt
+import base64
+from io import BytesIO
+
+from modules.data_management.data_manager import safe_strftime
+
+logger = logging.getLogger(__name__)
+
+class ReportGenerator:
+    """
+    Клас для генерації звітів на основі аналізу даних Jira
+    """
+    def __init__(self, df, stats=None, inactive_issues=None, ai_analysis=None):
+        """
+        Ініціалізація генератора звітів.
+        
+        Args:
+            df (pandas.DataFrame): DataFrame з даними Jira
+            stats (dict): Словник зі статистикою (або None)
+            inactive_issues (dict): Дані про неактивні тікети (або None)
+            ai_analysis (str): Текст AI аналізу (або None)
+        """
+        self.df = df
+        self.stats = stats
+        self.inactive_issues = inactive_issues
+        self.ai_analysis = ai_analysis
+    
+    def create_markdown_report(self, inactive_days=14):
+        """
+        Створення звіту у форматі Markdown.
+        
+        Args:
+            inactive_days (int): Кількість днів для визначення неактивних тікетів
+            
+        Returns:
+            str: Текст звіту у форматі Markdown
+        """
+        try:
+            report = []
+            
+            # Заголовок звіту
+            report.append("# Звіт аналізу Jira")
+            # report.append(f"*Створено: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*")
+            report.append(f'*Створено: {safe_strftime(datetime.now(), "%Y-%m-%d")}*')
+            
+            # Загальна статистика
+            report.append("\n## Загальна статистика")
+            
+            if self.stats and 'total_tickets' in self.stats:
+                report.append(f"**Загальна кількість тікетів:** {self.stats['total_tickets']}")
+            else:
+                report.append(f"**Загальна кількість тікетів:** {len(self.df)}")
+            
+            # Статистика за статусами
+            if self.stats and 'status_counts' in self.stats and self.stats['status_counts']:
+                report.append("\n### Статуси тікетів")
+                
+                for status, count in self.stats['status_counts'].items():
+                    percentage = count / self.stats['total_tickets'] * 100 if self.stats['total_tickets'] > 0 else 0
+                    report.append(f"- **{status}:** {count} ({percentage:.1f}%)")
+            elif 'Status' in self.df.columns:
+                status_counts = self.df['Status'].value_counts()
+                report.append("\n### Статуси тікетів")
+                
+                for status, count in status_counts.items():
+                    percentage = count / len(self.df) * 100 if len(self.df) > 0 else 0
+                    report.append(f"- **{status}:** {count} ({percentage:.1f}%)")
+            
+            # Статистика за типами
+            if self.stats and 'type_counts' in self.stats and self.stats['type_counts']:
+                report.append("\n### Типи тікетів")
+                
+                for type_name, count in self.stats['type_counts'].items():
+                    percentage = count / self.stats['total_tickets'] * 100 if self.stats['total_tickets'] > 0 else 0
+                    report.append(f"- **{type_name}:** {count} ({percentage:.1f}%)")
+            elif 'Issue Type' in self.df.columns:
+                type_counts = self.df['Issue Type'].value_counts()
+                report.append("\n### Типи тікетів")
+                
+                for type_name, count in type_counts.items():
+                    percentage = count / len(self.df) * 100 if len(self.df) > 0 else 0
+                    report.append(f"- **{type_name}:** {count} ({percentage:.1f}%)")
+            
+            # Статистика за пріоритетами
+            if self.stats and 'priority_counts' in self.stats and self.stats['priority_counts']:
+                report.append("\n### Пріоритети тікетів")
+                
+                for priority, count in self.stats['priority_counts'].items():
+                    percentage = count / self.stats['total_tickets'] * 100 if self.stats['total_tickets'] > 0 else 0
+                    report.append(f"- **{priority}:** {count} ({percentage:.1f}%)")
+            elif 'Priority' in self.df.columns:
+                priority_counts = self.df['Priority'].value_counts()
+                report.append("\n### Пріоритети тікетів")
+                
+                for priority, count in priority_counts.items():
+                    percentage = count / len(self.df) * 100 if len(self.df) > 0 else 0
+                    report.append(f"- **{priority}:** {count} ({percentage:.1f}%)")
+            
+            # Аналіз часових показників
+            if 'Created' in self.df.columns and pd.api.types.is_datetime64_dtype(self.df['Created']):
+                report.append("\n## Часові показники")
+                
+                min_date = self.df['Created'].min()
+                max_date = self.df['Created'].max()
+                
+                # report.append(f"**Період створення тікетів:** з {min_date.strftime('%Y-%m-%d')} по {max_date.strftime('%Y-%m-%d')}")
+                report.append(f'**Період створення тікетів:** з {safe_strftime(min_date, "%Y-%m-%d")} по {safe_strftime(max_date, "%Y-%m-%d")}')
+
+                # Тікети за останній тиждень
+                last_week = (datetime.now() - pd.Timedelta(days=7))
+                recent_tickets = self.df[self.df['Created'] >= last_week]
+                report.append(f"**Тікети, створені за останній тиждень:** {len(recent_tickets)}")
+            
+            # Неактивні тікети
+            if self.inactive_issues:
+                report.append(f"\n## Неактивні тікети (>{inactive_days} днів)")
+                
+                total_inactive = self.inactive_issues.get('total_count', 0)
+                percentage = self.inactive_issues.get('percentage', 0)
+                
+                report.append(f"**Загальна кількість неактивних тікетів:** {total_inactive} ({percentage:.1f}%)")
+                
+                if 'by_status' in self.inactive_issues and self.inactive_issues['by_status']:
+                    report.append("\n**Неактивні тікети за статусами:**")
+                    
+                    for status, count in self.inactive_issues['by_status'].items():
+                        report.append(f"- **{status}:** {count}")
+                
+                if 'top_inactive' in self.inactive_issues and self.inactive_issues['top_inactive']:
+                    report.append("\n**Топ 5 найбільш неактивних тікетів:**")
+                    
+                    for i, ticket in enumerate(self.inactive_issues['top_inactive']):
+                        key = ticket.get('key', 'Невідомо')
+                        summary = ticket.get('summary', 'Невідомо')
+                        status = ticket.get('status', 'Невідомо')
+                        days = ticket.get('days_inactive', 'Невідомо')
+                        
+                        report.append(f"{i+1}. **{key}:** {summary}")
+                        report.append(f"   - Статус: {status}")
+                        report.append(f"   - Днів неактивності: {days}")
+            
+            # AI Аналіз
+            if self.ai_analysis:
+                report.append("\n## AI Аналіз")
+                report.append(self.ai_analysis)
+            
+            logger.info("Звіт успішно згенеровано у форматі Markdown")
+            return "\n".join(report)
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні звіту: {e}")
+            return f"Помилка при створенні звіту: {str(e)}"
+    
+    def create_html_report(self, inactive_days=14, include_visualizations=False, visualization_data=None):
+        """
+        Створення звіту у форматі HTML.
+        
+        Args:
+            inactive_days (int): Кількість днів для визначення неактивних тікетів
+            include_visualizations (bool): Чи включати візуалізації у звіт
+            visualization_data (dict): Словник з об'єктами Figure для візуалізацій
+            
+        Returns:
+            str: Текст звіту у форматі HTML
+        """
+        try:
+            # Спочатку створюємо звіт у форматі Markdown
+            md_report = self.create_markdown_report(inactive_days)
+            
+            # Конвертуємо Markdown у HTML
+            html_report = self.convert_markdown_to_html(md_report)
+            
+            # Додаємо візуалізації, якщо потрібно
+            if include_visualizations and visualization_data:
+                html_with_charts = self._add_visualizations_to_html(html_report, visualization_data)
+                return html_with_charts
+            
+            return html_report
+            
+        except Exception as e:
+            logger.error(f"Помилка при створенні HTML звіту: {e}")
+            return f"<h1>Помилка при створенні звіту</h1><p>{str(e)}</p>"
+    
+    def convert_markdown_to_html(self, md_text):
+        """
+        Конвертація тексту з формату Markdown у HTML.
+        
+        Args:
+            md_text (str): Текст у форматі Markdown
+            
+        Returns:
+            str: Текст у форматі HTML
+        """
+        try:
+            # Додаємо CSS стилі
+            css = """
+            <style>
+                body { font-family: Arial, sans-serif; line-height: 1.6; margin: 20px; max-width: 1200px; margin: 0 auto; }
+                h1, h2, h3 { color: #0052CC; }
+                table { border-collapse: collapse; width: 100%; margin-bottom: 20px; }
+                th, td { padding: 12px; text-align: left; border-bottom: 1px solid #ddd; }
+                th { background-color: #0052CC; color: white; }
+                tr:hover { background-color: #f5f5f5; }
+                .progress-container { width: 100%; background-color: #f1f1f1; border-radius: 3px; }
+                .progress-bar { height: 20px; border-radius: 3px; }
+                img { max-width: 100%; }
+            </style>
+            """
+            
+            # Конвертація Markdown в HTML
+            html_content = markdown.markdown(md_text, extensions=['tables', 'fenced_code'])
+            
+            # Складаємо повний HTML документ
+            html = f"""<!DOCTYPE html>
+            <html lang="uk">
+            <head>
+                <meta charset="UTF-8">
+                <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                <title>Звіт аналізу Jira</title>
+                {css}
+            </head>
+            <body>
+                {html_content}
+            </body>
+            </html>
+            """
+            
+            return html
+            
+        except Exception as e:
+            logger.error(f"Помилка при конвертації Markdown в HTML: {e}")
+            return f"<h1>Помилка при конвертації звіту</h1><p>{str(e)}</p>"
+    
+    def _add_visualizations_to_html(self, html_content, visualization_data):
+        """
+        Додавання візуалізацій до HTML звіту.
+        
+        Args:
+            html_content (str): Текст HTML звіту
+            visualization_data (dict): Словник з об'єктами Figure для візуалізацій
+            
+        Returns:
+            str: HTML звіт з візуалізаціями
+        """
+        try:
+            # Додаємо розділ з візуалізаціями перед закриваючим тегом body
+            charts_html = "<h2>Візуалізації</h2>"
+            
+            # Конвертуємо кожну візуалізацію у base64 та додаємо до HTML
+            for name, fig in visualization_data.items():
+                if fig:
+                    # Зберігаємо фігуру в байтовий потік
+                    buf = BytesIO()
+                    fig.savefig(buf, format='png', dpi=100)
+                    buf.seek(0)
+                    
+                    # Конвертуємо в base64
+                    img_str = base64.b64encode(buf.read()).decode('utf-8')
+                    
+                    # Додаємо зображення до HTML
+                    title_map = {
+                        'status': 'Статуси тікетів',
+                        'priority': 'Пріоритети тікетів',
+                        'type': 'Типи тікетів',
+                        'created_timeline': 'Часова шкала створення тікетів',
+                        'inactive': 'Неактивні тікети',
+                        'status_timeline': 'Зміна статусів з часом',
+                        'lead_time': 'Час виконання тікетів за типами'
+                    }
+                    
+                    title = title_map.get(name, name.replace('_', ' ').title())
+                    
+                    charts_html += f"""
+                    <div style="text-align: center; margin-bottom: 30px;">
+                        <h3>{title}</h3>
+                        <img src="data:image/png;base64,{img_str}" alt="{title}" style="max-width: 100%;">
+                    </div>
+                    """
+            
+            # Вставляємо візуалізації перед закриваючим тегом body
+            html_with_charts = html_content.replace("</body>", f"{charts_html}</body>")
+            
+            return html_with_charts
+            
+        except Exception as e:
+            logger.error(f"Помилка при додаванні візуалізацій до HTML: {e}")
+            return html_content
+    
+    def save_report(self, filepath, format='markdown', include_visualizations=False, visualization_data=None):
+        """
+        Збереження звіту у файл.
+        
+        Args:
+            filepath (str): Шлях до файлу для збереження
+            format (str): Формат звіту ('markdown', 'html', 'pdf')
+            include_visualizations (bool): Чи включати візуалізації у звіт
+            visualization_data (dict): Словник з об'єктами Figure для візуалізацій
+            
+        Returns:
+            str: Шлях до збереженого файлу або None у випадку помилки
+        """
+        try:
+            # Створення директорії для файлу, якщо вона не існує
+            directory = os.path.dirname(filepath)
+            if directory and not os.path.exists(directory):
+                os.makedirs(directory)
+            
+            # Вибір формату та створення звіту
+            if format.lower() == 'markdown':
+                report_text = self.create_markdown_report()
+                
+                # Перевірка розширення файлу
+                if not filepath.lower().endswith('.md'):
+                    filepath += '.md'
+                
+                # Збереження у файл
+                with open(filepath, 'w', encoding='utf-8') as f:
+                    f.write(report_text)
+                
+            elif format.lower() == 'html':
+                html_report = self.create_html_report(include_visualizations=include_visualizations, 
+                                                     visualization_data=visualization_data)
+                
+                # Перевірка розширення файлу
+                if not filepath.lower().endswith('.html'):
+                    filepath += '.html'
+                
+                # Збереження у файл
+                with open(filepath, 'w', encoding='utf-8') as f:
+                    f.write(html_report)
+                
+            elif format.lower() == 'pdf':
+                # Створення спочатку HTML
+                html_report = self.create_html_report(include_visualizations=include_visualizations, 
+                                                     visualization_data=visualization_data)
+                
+                # Перевірка розширення файлу
+                if not filepath.lower().endswith('.pdf'):
+                    filepath += '.pdf'
+                
+                # Створення тимчасового HTML-файлу
+                temp_html_path = filepath + "_temp.html"
+                with open(temp_html_path, 'w', encoding='utf-8') as f:
+                    f.write(html_report)
+                
+                try:
+                    # Конвертація HTML в PDF
+                    from weasyprint import HTML
+                    HTML(filename=temp_html_path).write_pdf(filepath)
+                    
+                    # Видалення тимчасового HTML-файлу
+                    if os.path.exists(temp_html_path):
+                        os.remove(temp_html_path)
+                        
+                except Exception as e:
+                    logger.error(f"Помилка при конвертації в PDF: {e}")
+                    return None
+            else:
+                logger.error(f"Непідтримуваний формат звіту: {format}")
+                return None
+            
+            logger.info(f"Звіт успішно збережено у файл: {filepath}")
+            return filepath
+            
+        except Exception as e:
+            logger.error(f"Помилка при збереженні звіту: {e}")
+            return None

prompts.py

@@ -0,0 +1,111 @@
+# Стандартні промпти для різних режимів
+system_prompt_qa_assistant = """Ти асистент з аналізу даних Jira.
+            Тобі подається повний контекст з усіма тікетами проекту.
+            Використовуй усі доступні метадані та текстові дані для відповіді на питання.
+            Відповідай українською мовою, якщо не вказано інше.
+            При посиланні на таск (цитуванні) обов'язково використовуй формат лінки https://jira.healthprecision.net/browse/IEE-[номеp]
+            
+            """
+
+
+system_prompt_hybrid_chat = """Ви - AI асистент для аналізу даних Jira.
+Ваше завдання - допомагати користувачам аналізувати дані з Jira та відповідати на їхні запитання.
+Використовуйте надані документи як контекст для відповідей.
+Відповідайте українською мовою, якщо не вказано інше.
+Будьте точними, інформативними та корисними."""
+
+
+def get_report_prompt(format_type):
+    """
+    Повертає системний промпт для генерації найінформативнішого звіту з Jira.
+
+    Функція генерує покращений системний промпт, що допомагає створити глибокий аналітичний звіт для
+    проджект-менеджерів та тім-лідів. Звіт містить ключові аспекти стану проекту, проблеми, ризики,
+    рекомендації та висновки.
+
+    Args:
+        format_type (str): Тип формату, наприклад "markdown" або "html".
+
+    Returns:
+        str: Розширений системний промпт з інструкціями форматування.
+    """
+    # Встановлюємо базові інструкції щодо формату
+    format_instruction = ""
+    if format_type.lower() == "markdown":
+        format_instruction = (
+            "Використовуйте розмітку Markdown (заголовки, списки, таблиці) для візуальної структури. "
+            "Додавайте підзаголовки для ключових секцій, використовуйте списки для відображення ризиків "
+            "та рекомендацій, а також зверніть увагу на чітке відокремлення розділів за допомогою заголовків різного рівня."
+        )
+    elif format_type.lower() == "html":
+        format_instruction = (
+            "Створіть структурований звіт з використанням тегів <h1>, <h2> тощо для заголовків, "
+            "<ul>/<ol> для списків, <table> для табличних даних, та розташовуйте ключові частини звіту "
+            "по розділах, що легко читати."
+        )
+
+    # Створюємо базовий текст промпту
+    prompt_template = """Ви досвідчений аналітик даних з Jira.
+Вам надано докладні дані про проект для аналізу та створення професійного, глибокого звіту.
+
+Сформуйте детальний звіт, який містить такі розділи:
+1. Короткий огляд проекту (ключова мета, тривалість, основні учасники).
+2. Аналіз поточного стану:
+   - Статус відкритих, закритих та в роботі тікетів (підсумок та тренди).
+   - Розподіл тікетів за типами (Bug, Task, Story, Sub-task, тощо).
+   - Пріоритети та їх розподіл.
+   - Середній час до вирішення (якщо доступно).
+3. Виявлені проблеми та ризики:
+   - Потенційно заблоковані або прострочені тікети.
+   - Можливі конфлікти у пріоритизації.
+   - Зони ризику, що впливають на загальний план.
+4. Рекомендації для покращення процесу:
+   - Пропозиції щодо оптимізації робочих процесів, планування спринтів та ресурсів.
+   - Ідеї для покращення комунікації між командами.
+   - Шляхи зниження ризиків та покращення якості коду.
+5. Висновки:
+   - Підсумок ключових моментів та наступні кроки.
+
+"""
+
+    prompt_template += format_instruction + "\n\n"
+    prompt_template += (
+        "Звіт повинен бути максимально конкретним, з реальними метриками або доказами, "
+        "де це можливо, і орієнтованим на подальші дії. Використовуйте українську мову.\n"
+    )
+
+    return prompt_template
+
+
+
+# def get_report_prompt(format_type):
+#     """
+#     Повертає системний промпт для генерації звіту з відповідним форматуванням.
+    
+#     Args:
+#         format_type (str): Тип формату ("markdown" або "html")
+        
+#     Returns:
+#         str: Системний промпт з інструкціями форматування
+#     """
+#     format_instruction = ""
+#     if format_type.lower() == "markdown":
+#         format_instruction = "Використовуйте Markdown для форматування звіту."
+#     elif format_type.lower() == "html":
+#         format_instruction = "Створіть звіт у форматі HTML з використанням відповідних тегів."
+    
+#     return f"""Ви досвідчений аналітик даних з Jira.
+#     Вам надано дані про проект для аналізу та створення професійного звіту.
+    
+#     Створіть структурований звіт з такими розділами:
+#     1. Короткий огляд проекту
+#     2. Аналіз поточного стану (статус тікетів, розподіл за типами та пріоритетами)
+#     3. Виявлені проблеми та ризики
+#     4. Рекомендації для покращення процесу
+#     5. Висновки
+    
+#     {format_instruction}
+    
+#     Звіт повинен бути інформативним, конкретним та орієнтованим на дії.
+#     Використовуйте українську мову.
+#     """

requirements.txt

@@ -0,0 +1,173 @@
+accelerate==1.4.0
+aiofiles==23.2.1
+aiohappyeyeballs==2.4.8
+aiohttp==3.11.13
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.8.0
+async-timeout==5.0.1
+attrs==25.1.0
+beautifulsoup4==4.13.3
+bm25s==0.2.7.post1
+cachetools==5.5.2
+certifi==2025.1.31
+chardet==5.2.0
+charset-normalizer==3.4.1
+click==8.1.8
+contourpy==1.3.1
+cycler==0.12.1
+dataclasses-json==0.6.7
+defusedxml==0.7.1
+Deprecated==1.2.18
+dirtyjson==1.0.8
+distro==1.9.0
+et_xmlfile==2.0.0
+exceptiongroup==1.2.2
+faiss-cpu==1.7.4
+fastapi==0.115.11
+ffmpy==0.5.0
+filelock==3.17.0
+filetype==1.2.0
+fonttools==4.56.0
+frozenlist==1.5.0
+fsspec==2025.2.0
+google-ai-generativelanguage==0.6.15
+google-api-core==2.24.1
+google-api-python-client==2.162.0
+google-auth==2.38.0
+google-auth-httplib2==0.2.0
+google-genai==1.3.0
+google-generativeai==0.8.4
+googleapis-common-protos==1.69.0
+gradio==5.20.0
+gradio_client==1.7.2
+greenlet==3.1.1
+groovy==0.1.2
+grpcio==1.70.0
+grpcio-status==1.70.0
+h11==0.14.0
+httpcore==1.0.7
+httplib2==0.22.0
+httpx==0.28.1
+huggingface-hub==0.29.1
+idna==3.10
+Jinja2==3.1.5
+jira==3.8.0
+jiter==0.8.2
+joblib==1.4.2
+kiwisolver==1.4.8
+llama-cloud==0.1.13
+llama-cloud-services==0.6.3
+llama-index==0.12.22
+llama-index-agent-openai==0.4.6
+llama-index-cli==0.4.1
+llama-index-core==0.12.22
+llama-index-embeddings-gemini==0.3.2
+llama-index-embeddings-huggingface==0.5.2
+llama-index-embeddings-openai==0.3.1
+llama-index-indices-managed-llama-cloud==0.6.8
+llama-index-llms-gemini==0.4.11
+llama-index-llms-openai==0.3.25
+llama-index-multi-modal-llms-openai==0.4.3
+llama-index-program-openai==0.3.1
+llama-index-question-gen-openai==0.3.0
+llama-index-readers-file==0.4.6
+llama-index-readers-llama-parse==0.4.0
+llama-index-retrievers-bm25==0.5.2
+llama-index-vector-stores-faiss==0.3.0
+llama-parse==0.6.2
+Markdown==3.7
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+marshmallow==3.26.1
+matplotlib==3.7.5
+mdurl==0.1.2
+mpmath==1.3.0
+multidict==6.1.0
+mypy-extensions==1.0.0
+narwhals==1.29.1
+nest-asyncio==1.6.0
+networkx==3.4.2
+nltk==3.9.1
+numpy==1.26.4
+nvidia-cublas-cu12==12.4.5.8
+nvidia-cuda-cupti-cu12==12.4.127
+nvidia-cuda-nvrtc-cu12==12.4.127
+nvidia-cuda-runtime-cu12==12.4.127
+nvidia-cudnn-cu12==9.1.0.70
+nvidia-cufft-cu12==11.2.1.3
+nvidia-curand-cu12==10.3.5.147
+nvidia-cusolver-cu12==11.6.1.9
+nvidia-cusparse-cu12==12.3.1.170
+nvidia-cusparselt-cu12==0.6.2
+nvidia-nccl-cu12==2.21.5
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nvtx-cu12==12.4.127
+oauthlib==3.2.2
+openai==1.65.2
+openpyxl==3.1.5
+orjson==3.10.15
+packaging==24.2
+pandas==2.1.4
+pathlib==1.0.1
+pillow==10.4.0
+plotly==6.0.0
+propcache==0.3.0
+proto-plus==1.26.0
+protobuf==5.29.3
+psutil==7.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.1
+pydantic==2.10.6
+pydantic_core==2.27.2
+pydub==0.25.1
+Pygments==2.19.1
+pyparsing==3.2.1
+pypdf==5.3.1
+PyStemmer==2.2.0.3
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+python-multipart==0.0.20
+pytz==2025.1
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.3
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rich==13.9.4
+rsa==4.9
+ruff==0.9.9
+safehttpx==0.1.6
+safetensors==0.5.3
+scikit-learn==1.6.1
+scipy==1.15.2
+seaborn==0.12.2
+semantic-version==2.10.0
+sentence-transformers==3.4.1
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.6
+SQLAlchemy==2.0.38
+starlette==0.46.0
+striprtf==0.0.26
+sympy==1.13.1
+tenacity==9.0.0
+threadpoolctl==3.5.0
+tiktoken==0.9.0
+tokenizers==0.21.0
+tomlkit==0.13.2
+torch==2.6.0
+tqdm==4.67.1
+transformers==4.49.0
+triton==3.2.0
+typer==0.15.2
+typing-inspect==0.9.0
+typing_extensions==4.12.2
+tzdata==2025.1
+uritemplate==4.1.1
+urllib3==2.3.0
+uvicorn==0.34.0
+websockets==14.2
+wrapt==1.17.2
+yarl==1.18.3