Initial commit

.gitignore

@@ -0,0 +1,9 @@
+venv/
+__pycache__/
+*.py[cod]
+*.class
+.env
+.DS_Store
+.idea/
+.vscode/
+*.log

app.py

@@ -0,0 +1,595 @@
+import os
+import gradio as gr
+from datetime import datetime
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from pathlib import Path
+import tempfile
+import traceback
+import logging
+
+# Налаштування логування
+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)
+
+# Клас для аналізу даних Jira
+class JiraAnalyzer:
+    def __init__(self):
+        self.df = None
+        self.stats = None
+        self.inactive_issues = None
+    
+    def load_csv(self, file_path):
+        """Завантаження даних з CSV-файлу"""
+        try:
+            logger.info(f"Завантаження CSV-файлу: {file_path}")
+            
+            # Спробуємо різні кодування
+            try:
+                self.df = pd.read_csv(file_path, encoding='utf-8')
+            except UnicodeDecodeError:
+                logger.warning("Помилка декодування UTF-8, спроба з latin1")
+                self.df = pd.read_csv(file_path, encoding='latin1')
+            
+            logger.info(f"Успішно завантажено {len(self.df)} записів")
+            return self.df
+        except Exception as e:
+            logger.error(f"Помилка при завантаженні CSV-файлу: {e}")
+            raise
+    
+    def process_dates(self):
+        """Обробка дат у DataFrame"""
+        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')
+                except Exception as e:
+                    logger.warning(f"Не вдалося конвертувати колонку {col} до datetime: {e}")
+    
+    def prepare_data(self):
+        """Підготовка даних для аналізу"""
+        # Обробка дат
+        self.process_dates()
+        
+        # Додаткова обробка
+        if 'Status' in self.df.columns:
+            self.df['Status'] = self.df['Status'].fillna('Unknown')
+        
+        if 'Priority' in self.df.columns:
+            self.df['Priority'] = self.df['Priority'].fillna('Not set')
+        
+        # Створення додаткових колонок
+        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')
+        
+        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
+    
+    def generate_stats(self):
+        """Генерація базової статистики"""
+        self.stats = {
+            'total_tickets': len(self.df),
+            'status_counts': {},
+            'type_counts': {},
+            'priority_counts': {}
+        }
+        
+        # Статистика за статусами
+        if 'Status' in self.df.columns:
+            self.stats['status_counts'] = self.df['Status'].value_counts().to_dict()
+        
+        # Статистика за типами
+        if 'Issue Type' in self.df.columns:
+            self.stats['type_counts'] = self.df['Issue Type'].value_counts().to_dict()
+        
+        # Статистика за пріоритетами
+        if 'Priority' in self.df.columns:
+            self.stats['priority_counts'] = self.df['Priority'].value_counts().to_dict()
+        
+        return self.stats
+    
+    def find_inactive_issues(self, days=14):
+        """Аналіз неактивних тікетів"""
+        self.inactive_issues = {
+            'total_count': 0,
+            'percentage': 0,
+            'by_status': {},
+            'top_inactive': []
+        }
+        
+        if 'Updated' not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df['Updated']):
+            return self.inactive_issues
+        
+        # Визначення неактивних тікетів
+        cutoff_date = datetime.now() - pd.Timedelta(days=days)
+        inactive = self.df[self.df['Updated'] < cutoff_date]
+        
+        if len(inactive) == 0:
+            return self.inactive_issues
+        
+        self.inactive_issues['total_count'] = len(inactive)
+        self.inactive_issues['percentage'] = round(len(inactive) / len(self.df) * 100, 2) if len(self.df) > 0 else 0
+        
+        # Розподіл за статусами
+        if 'Status' in inactive.columns:
+            self.inactive_issues['by_status'] = inactive['Status'].value_counts().to_dict()
+        
+        # Топ 5 неактивних тікетів
+        top_inactive = []
+        for _, row in inactive.sort_values('Updated', ascending=True).head(5).iterrows():
+            issue_data = {
+                'key': row.get('Issue key', 'Невідомо'),
+                'summary': row.get('Summary', 'Невідомо'),
+                'status': row.get('Status', 'Невідомо'),
+                'days_inactive': (datetime.now() - row['Updated']).days if pd.notna(row['Updated']) else 'Невідомо'
+            }
+            top_inactive.append(issue_data)
+        
+        self.inactive_issues['top_inactive'] = top_inactive
+        return self.inactive_issues
+    
+    def plot_status_counts(self):
+        """Діаграма розподілу за статусами"""
+        if 'Status' not in self.df.columns:
+            return None
+        
+        status_counts = self.df['Status'].value_counts()
+        
+        fig, ax = plt.subplots(figsize=(10, 6))
+        bars = 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()
+        
+        return fig
+    
+    def plot_priority_counts(self):
+        """Діаграма розподілу за пріоритетами"""
+        if 'Priority' not in self.df.columns:
+            return None
+        
+        priority_counts = self.df['Priority'].value_counts()
+        
+        fig, ax = plt.subplots(figsize=(10, 6))
+        bars = 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()
+        
+        return fig
+    
+    def plot_created_timeline(self):
+        """Часова діаграма створення тікетів"""
+        if 'Created' not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df['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()
+        
+        return fig
+    
+    def generate_report(self, inactive_days=14):
+        """Генерація звіту"""
+        report = []
+        
+        # Заголовок звіту
+        report.append("# Звіт аналізу Jira")
+        report.append(f"*Створено: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*")
+        
+        # Загальна статистика
+        report.append("\n## Загальна статистика")
+        report.append(f"**Загальна кількість тікетів:** {len(self.df)}")
+        
+        # Статистика за статусами
+        if '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 '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 '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}%)")
+        
+        # Неактивні тікети
+        self.find_inactive_issues(inactive_days)
+        
+        if self.inactive_issues['total_count'] > 0:
+            report.append(f"\n## Неактивні тікети (>{inactive_days} днів)")
+            report.append(f"**Загальна кількість неактивних тікетів:** {self.inactive_issues['total_count']} ({self.inactive_issues['percentage']}%)")
+            
+            if self.inactive_issues['by_status']:
+                report.append("\n**Неактивні тікети за статусами:**")
+                for status, count in self.inactive_issues['by_status'].items():
+                    report.append(f"- **{status}:** {count}")
+            
+            if self.inactive_issues['top_inactive']:
+                report.append("\n**Топ 5 найбільш неактивних тікетів:**")
+                for i, ticket in enumerate(self.inactive_issues['top_inactive']):
+                    report.append(f"{i+1}. **{ticket['key']}:** {ticket['summary']}")
+                    report.append(f"   - Статус: {ticket['status']}")
+                    report.append(f"   - Днів неактивності: {ticket['days_inactive']}")
+        
+        return "\n".join(report)
+
+# Виправлена функція analyze_csv
+def analyze_csv(file_obj, inactive_days, include_ai):
+    if file_obj is None:
+        return "Помилка: файл не вибрано", None, None, None, None
+    
+    try:
+        logger.info(f"Отримано файл: {file_obj.name}, тип: {type(file_obj)}")
+        
+        # Створення тимчасового файлу
+        temp_file_path = os.path.join("temp", f"temp_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv")
+        
+        # У Gradio 5.19.0 об'єкт файлу має різну структуру
+        # file_obj може бути шляхом до файлу або містити атрибут 'name'
+        if hasattr(file_obj, 'name'):
+            source_path = file_obj.name
+            
+            # Копіювання файлу
+            import shutil
+            shutil.copy2(source_path, temp_file_path)
+        else:
+            # Якщо це не шлях до файлу, ймовірно це вже самі дані
+            with open(temp_file_path, "w", encoding="utf-8") as f:
+                f.write(str(file_obj))
+        
+        # Аналіз даних
+        analyzer = JiraAnalyzer()
+        analyzer.load_csv(temp_file_path)
+        analyzer.prepare_data()
+        analyzer.generate_stats()
+        
+        # Візуалізації
+        status_fig = analyzer.plot_status_counts()
+        priority_fig = analyzer.plot_priority_counts()
+        timeline_fig = analyzer.plot_created_timeline()
+        
+        # Генерація звіту
+        report = analyzer.generate_report(inactive_days=inactive_days)
+        
+        # AI аналіз (заглушка)
+        ai_analysis = None
+        if include_ai:
+            ai_analysis = "AI аналіз буде доступний у наступних версіях додатку."
+        
+        # Видалення тимчасового файлу
+        try:
+            os.remove(temp_file_path)
+        except:
+            pass
+        
+        return report, status_fig, priority_fig, timeline_fig, ai_analysis
+    
+    except Exception as e:
+        error_msg = f"Помилка аналізу: {str(e)}\n\n{traceback.format_exc()}"
+        logger.error(error_msg)
+        return error_msg, None, None, None, None
+
+# Функція для збереження звіту
+def save_report(report_text, format_type, include_visualizations, status_fig, priority_fig, timeline_fig):
+    if not report_text:
+        return "Помилка: спочатку виконайте аналіз даних"
+    
+    try:
+        # Створення імені файлу
+        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"
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(report_text)
+                
+            if include_visualizations:
+                # Збереження візуалізацій
+                charts_dir = reports_dir / f"{report_filename}_charts"
+                charts_dir.mkdir(exist_ok=True)
+                
+                if status_fig:
+                    status_fig.savefig(charts_dir / "status_counts.png")
+                if priority_fig:
+                    priority_fig.savefig(charts_dir / "priority_counts.png")
+                if timeline_fig:
+                    timeline_fig.savefig(charts_dir / "timeline.png")
+        
+        elif format_type == "html":
+            from markdown import markdown
+            
+            filepath = reports_dir / f"{report_filename}.html"
+            
+            # Конвертація Markdown в HTML
+            html_content = f"""<!DOCTYPE html>
+            <html>
+            <head>
+                <meta charset="utf-8">
+                <title>Звіт аналізу Jira</title>
+                <style>
+                    body {{ font-family: Arial, sans-serif; line-height: 1.6; margin: 20px; }}
+                    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; }}
+                    img {{ max-width: 100%; margin: 20px 0; }}
+                </style>
+            </head>
+            <body>
+                {markdown(report_text)}
+            """
+            
+            if include_visualizations and (status_fig or priority_fig or timeline_fig):
+                # Збереження візуалізацій
+                charts_dir = reports_dir / f"{report_filename}_charts"
+                charts_dir.mkdir(exist_ok=True)
+                
+                html_content += "<h2>Візуалізації</h2>"
+                
+                if status_fig:
+                    status_path = charts_dir / "status_counts.png"
+                    status_fig.savefig(status_path)
+                    html_content += f'<div><h3>Статуси тікетів</h3><img src="{status_path.relative_to(reports_dir)}" alt="Статуси тікетів"></div>'
+                
+                if priority_fig:
+                    priority_path = charts_dir / "priority_counts.png"
+                    priority_fig.savefig(priority_path)
+                    html_content += f'<div><h3>Пріоритети тікетів</h3><img src="{priority_path.relative_to(reports_dir)}" alt="Пріоритети тікетів"></div>'
+                
+                if timeline_fig:
+                    timeline_path = charts_dir / "timeline.png"
+                    timeline_fig.savefig(timeline_path)
+                    html_content += f'<div><h3>Часова шкала</h3><img src="{timeline_path.relative_to(reports_dir)}" alt="Часова шкала"></div>'
+            
+            html_content += "</body></html>"
+            
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(html_content)
+        
+        elif format_type == "pdf":
+            try:
+                from weasyprint import HTML
+                
+                filepath = reports_dir / f"{report_filename}.pdf"
+                
+                # Створюємо тимчасовий HTML-файл
+                temp_html_path = reports_dir / f"{report_filename}_temp.html"
+                
+                # Конвертація Markdown в HTML
+                from markdown import markdown
+                html_content = f"""<!DOCTYPE html>
+                <html>
+                <head>
+                    <meta charset="utf-8">
+                    <title>Звіт аналізу Jira</title>
+                    <style>
+                        body {{ font-family: Arial, sans-serif; line-height: 1.6; margin: 20px; }}
+                        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; }}
+                        img {{ max-width: 100%; margin: 20px 0; }}
+                    </style>
+                </head>
+                <body>
+                    {markdown(report_text)}
+                """
+                
+                if include_visualizations and (status_fig or priority_fig or timeline_fig):
+                    # Збереження візуалізацій
+                    charts_dir = reports_dir / f"{report_filename}_charts"
+                    charts_dir.mkdir(exist_ok=True)
+                    
+                    html_content += "<h2>Візуалізації</h2>"
+                    
+                    if status_fig:
+                        status_path = charts_dir / "status_counts.png"
+                        status_fig.savefig(status_path)
+                        html_content += f'<div><h3>Статуси тікетів</h3><img src="{status_path}" alt="Статуси тікетів"></div>'
+                    
+                    if priority_fig:
+                        priority_path = charts_dir / "priority_counts.png"
+                        priority_fig.savefig(priority_path)
+                        html_content += f'<div><h3>Пріоритети тікетів</h3><img src="{priority_path}" alt="Пріоритети тікетів"></div>'
+                    
+                    if timeline_fig:
+                        timeline_path = charts_dir / "timeline.png"
+                        timeline_fig.savefig(timeline_path)
+                        html_content += f'<div><h3>Часова шкала</h3><img src="{timeline_path}" alt="Часова шкала"></div>'
+                
+                html_content += "</body></html>"
+                
+                with open(temp_html_path, 'w', encoding='utf-8') as f:
+                    f.write(html_content)
+                
+                # Конвертація HTML в PDF
+                HTML(filename=str(temp_html_path)).write_pdf(filepath)
+                
+                # Видалення тимчасового HTML-файлу
+                try:
+                    os.remove(temp_html_path)
+                except:
+                    pass
+                
+            except ImportError:
+                return "Помилка: для генерації PDF потрібна бібліотека weasyprint"
+        
+        return f"Звіт успішно збережено: {filepath}"
+    
+    except Exception as e:
+        error_msg = f"Помилка при збереженні звіту: {str(e)}\n\n{traceback.format_exc()}"
+        logger.error(error_msg)
+        return error_msg
+
+# Інтерфейс Gradio
+with gr.Blocks(title="Jira AI Assistant") as app:
+    gr.Markdown("# 🔍 Jira AI Assistant")
+    
+    with gr.Tabs():
+        with gr.Tab("CSV Аналіз"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    file_input = gr.File(label="Завантажити CSV файл Jira")
+                    inactive_days = gr.Slider(minimum=1, maximum=90, value=14, step=1, 
+                                             label="Кількість днів для визначення неактивних тікетів")
+                    
+                    include_ai = gr.Checkbox(label="Включити AI аналіз", value=False)
+                    
+                    analyze_btn = gr.Button("Аналізувати", variant="primary")
+                    
+                    with gr.Accordion("Збереження звіту", open=False):
+                        format_type = gr.Dropdown(
+                            choices=["markdown", "html", "pdf"],
+                            value="markdown",
+                            label="Формат звіту"
+                        )
+                        include_visualizations = gr.Checkbox(
+                            label="Включити візуалізації", 
+                            value=True
+                        )
+                        save_btn = gr.Button("Зберегти звіт")
+                        save_output = gr.Textbox(label="Статус збереження")
+                
+                with gr.Column(scale=2):
+                    with gr.Tabs():
+                        with gr.Tab("Звіт"):
+                            report_output = gr.Markdown()
+                        
+                        with gr.Tab("Візуалізації"):
+                            with gr.Row():
+                                status_plot = gr.Plot(label="Статуси тікетів")
+                                priority_plot = gr.Plot(label="Пріоритети тікетів")
+                            
+                            timeline_plot = gr.Plot(label="Часова шкала")
+                        
+                        with gr.Tab("AI Аналіз"):
+                            ai_output = gr.Markdown()
+            
+            # Встановлюємо обробники подій
+            analyze_btn.click(
+                analyze_csv,
+                inputs=[file_input, inactive_days, include_ai],
+                outputs=[report_output, status_plot, priority_plot, timeline_plot, ai_output]
+            )
+            
+            save_btn.click(
+                save_report,
+                inputs=[report_output, format_type, include_visualizations, status_plot, priority_plot, timeline_plot],
+                outputs=[save_output]
+            )
+        
+        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="Статус підключення")
+            
+            gr.Markdown("## ⚠️ Ця функція буде доступна у наступних версіях")
+        
+        with gr.Tab("AI Асистенти"):
+            gr.Markdown("## AI Асистенти для Jira")
+            gr.Markdown("⚠️ Ця функція буде доступна у наступних версіях")
+            
+            with gr.Accordion("Зразок інтерфейсу"):
+                question = gr.Textbox(
+                    label="Запитання",
+                    placeholder="Наприклад: Які тікети мають найвищий пріоритет?",
+                    lines=2
+                )
+                answer = gr.Markdown(label="Відповідь")
+        
+        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)
+
+# Запуск додатку
+if __name__ == "__main__":
+    app.launch()

config.json

@@ -0,0 +1,13 @@
+{
+  "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
+}

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

modules/ai_analysis/llm_connector.py

@@ -0,0 +1,464 @@
+import os
+import json
+import logging
+import requests
+from typing import Dict, List, Any, Optional
+import openai
+from datetime import datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+class LLMConnector:
+    """
+    Клас для взаємодії з LLM (OpenAI, Google Gemini, тощо)
+    """
+    def __init__(self, api_key=None, model_type="openai"):
+        """
+        Ініціалізація з'єднання з LLM.
+        
+        Args:
+            api_key (str): API ключ для доступу до LLM. 
+                         Якщо None, спробує використати змінну середовища.
+            model_type (str): Тип моделі ("openai" або "gemini")
+        """
+        self.model_type = model_type.lower()
+        
+        if self.model_type == "openai":
+            self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+            
+            if not self.api_key:
+                logger.warning("API ключ OpenAI не вказано")
+                
+            self.model = "gpt-3.5-turbo"  # Стандартна модель
+            openai.api_key = self.api_key
+            
+        elif self.model_type == "gemini":
+            self.api_key = api_key or os.getenv("GEMINI_API_KEY")
+            
+            if not self.api_key:
+                logger.warning("API ключ Gemini не вказано")
+                
+            self.model = "gemini-pro"  # Стандартна модель для Gemini
+            
+        else:
+            raise ValueError(f"Непідтримуваний тип моделі: {model_type}")
+    
+    def analyze_jira_data(self, stats, inactive_issues, temperature=0.2):
+        """
+        Аналіз даних Jira за допомогою LLM.
+        
+        Args:
+            stats (dict): Базова статистика даних Jira
+            inactive_issues (dict): Дані про неактивні тікети
+            temperature (float): Параметр температури для генерації
+            
+        Returns:
+            str: Результат аналізу
+        """
+        try:
+            # Підготовка даних для аналізу
+            data_summary = self._prepare_data_for_llm(stats, inactive_issues)
+            
+            # Відправлення запиту до LLM
+            if self.model_type == "openai":
+                return self._analyze_with_openai(data_summary, temperature)
+            elif self.model_type == "gemini":
+                return self._analyze_with_gemini(data_summary, temperature)
+            
+        except Exception as e:
+            logger.error(f"Помилка при аналізі даних за допомогою LLM: {e}")
+            return f"Помилка при аналізі даних: {str(e)}"
+    
+    def _prepare_data_for_llm(self, stats, inactive_issues):
+        """
+        Підготовка даних для аналізу за допомогою LLM.
+        
+        Args:
+            stats (dict): Базова статистика
+            inactive_issues (dict): Дані про неактивні тікети
+            
+        Returns:
+            str: Дані для аналізу у текстовому форматі
+        """
+        summary = []
+        
+        # Додавання загальної статистики
+        summary.append(f"Загальна кількість тікетів: {stats.get('total_tickets', 'Невідомо')}")
+        
+        # Додавання статистики за статусами
+        if 'status_counts' in stats and stats['status_counts']:
+            summary.append("\nТікети за статусами:")
+            for status, count in stats['status_counts'].items():
+                summary.append(f"- {status}: {count}")
+        
+        # Додавання статистики за типами
+        if 'type_counts' in stats and stats['type_counts']:
+            summary.append("\nТікети за типами:")
+            for issue_type, count in stats['type_counts'].items():
+                summary.append(f"- {issue_type}: {count}")
+        
+        # Додавання статистики за пріоритетами
+        if 'priority_counts' in stats and stats['priority_counts']:
+            summary.append("\nТікети за пріоритетами:")
+            for priority, count in stats['priority_counts'].items():
+                summary.append(f"- {priority}: {count}")
+        
+        # Аналіз створених тікетів
+        if 'created_stats' in stats and stats['created_stats']:
+            summary.append("\nСтатистика створених тікетів:")
+            for key, value in stats['created_stats'].items():
+                if key == 'last_7_days':
+                    summary.append(f"- Створено за останні 7 днів: {value}")
+                elif key == 'min':
+                    summary.append(f"- Найраніший тікет створено: {value}")
+                elif key == 'max':
+                    summary.append(f"- Найпізніший тікет створено: {value}")
+        
+        # Аналіз неактивних тікетів
+        if inactive_issues:
+            total_inactive = inactive_issues.get('total_count', 0)
+            percentage = inactive_issues.get('percentage', 0)
+            summary.append(f"\nНеактивні тікети: {total_inactive} ({percentage}% від загальної кількості)")
+            
+            if 'by_status' in inactive_issues and inactive_issues['by_status']:
+                summary.append("Неактивні тікети за статусами:")
+                for status, count in inactive_issues['by_status'].items():
+                    summary.append(f"- {status}: {count}")
+            
+            if 'top_inactive' in inactive_issues and inactive_issues['top_inactive']:
+                summary.append("\nНайбільш неактивні тікети:")
+                for i, ticket in enumerate(inactive_issues['top_inactive']):
+                    key = ticket.get('key', 'Невідомо')
+                    status = ticket.get('status', 'Невідомо')
+                    days = ticket.get('days_inactive', 'Невідомо')
+                    summary.append(f"- {key} (Статус: {status}, Днів неактивності: {days})")
+        
+        return "\n".join(summary)
+    
+    def _analyze_with_openai(self, data_summary, temperature=0.2):
+        """
+        Аналіз даних за допомогою OpenAI.
+        
+        Args:
+            data_summary (str): Дані для аналізу
+            temperature (float): Параметр температури
+            
+        Returns:
+            str: Результат аналізу
+        """
+        try:
+            if not self.api_key:
+                return "Не вказано API ключ OpenAI"
+            
+            # Створення запиту до LLM
+            response = openai.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": """Ви аналітик Jira з досвідом у процесах розробки ПЗ.
+                    Проаналізуйте надані дані про тікети та надайте корисні інсайти та рекомендації
+                    для покращення процесу. Будьте конкретними та орієнтованими на дії.
+                    Виділіть сильні та слабкі сторони, а також потенційні ризики та можливості.
+                    Аналіз повинен бути структурованим і легким для сприйняття менеджерами проекту."""},
+                    {"role": "user", "content": f"Проаналізуйте наступні дані Jira та надайте рекомендації:\n\n{data_summary}"}
+                ],
+                temperature=temperature,
+            )
+            
+            # Отримання результату
+            analysis_result = response.choices[0].message.content
+            
+            logger.info("Успішно отримано аналіз від OpenAI")
+            return analysis_result
+            
+        except Exception as e:
+            logger.error(f"Помилка при взаємодії з OpenAI: {e}")
+            return f"Помилка при взаємодії з OpenAI: {str(e)}"
+    
+    def _analyze_with_gemini(self, data_summary, temperature=0.2):
+        """
+        Аналіз даних за допомогою Google Gemini.
+        
+        Args:
+            data_summary (str): Дані для аналізу
+            temperature (float): Параметр температури
+            
+        Returns:
+            str: Результат аналізу
+        """
+        try:
+            if not self.api_key:
+                return "Не вказано API ключ Gemini"
+            
+            # API endpoint
+            url = f"https://generativelanguage.googleapis.com/v1beta/models/{self.model}:generateContent?key={self.api_key}"
+            
+            # Формування запиту
+            payload = {
+                "contents": [
+                    {
+                        "parts": [
+                            {
+                                "text": """Ви аналітик Jira з досвідом у процесах розробки ПЗ.
+                                Проаналізуйте надані дані про тікети та надайте корисні інсайти та рекомендації
+                                для покращення процесу. Будьте конкретними та орієнтованими на дії.
+                                Виділіть сильні та слабкі сторони, а також потенційні ризики та можливості.
+                                Аналіз повинен бути структурованим і легким для сприйняття менеджерами проекту."""
+                            }
+                        ]
+                    },
+                    {
+                        "parts": [
+                            {
+                                "text": f"Проаналізуйте наступні дані Jira та надайте рекомендації:\n\n{data_summary}"
+                            }
+                        ]
+                    }
+                ],
+                "generationConfig": {
+                    "temperature": temperature,
+                    "maxOutputTokens": 2048
+                }
+            }
+            
+            # Відправлення запиту
+            headers = {"Content-Type": "application/json"}
+            response = requests.post(url, headers=headers, json=payload)
+            
+            # Обробка відповіді
+            if response.status_code == 200:
+                response_data = response.json()
+                
+                # Отримання тексту відповіді
+                if 'candidates' in response_data and len(response_data['candidates']) > 0:
+                    if 'content' in response_data['candidates'][0]:
+                        content = response_data['candidates'][0]['content']
+                        if 'parts' in content and len(content['parts']) > 0:
+                            result = content['parts'][0].get('text', '')
+                            logger.info("Успішно отримано аналіз від Gemini")
+                            return result
+            
+            logger.error(f"Помилка при взаємодії з Gemini: {response.text}")
+            return f"Помилка при взаємодії з Gemini: статус {response.status_code}"
+            
+        except Exception as e:
+            logger.error(f"Помилка при взаємодії з Gemini: {e}")
+            return f"Помилка при взаємодії з Gemini: {str(e)}"
+    
+    def ask_question(self, question, context=None, temperature=0.3):
+        """
+        Задати питання до LLM на основі даних Jira.
+        
+        Args:
+            question (str): Питання користувача
+            context (str): Додатковий контекст (може містити JSON дані тікетів)
+            temperature (float): Параметр температури
+            
+        Returns:
+            str: Відповідь на питання
+        """
+        try:
+            # Формування запиту для LLM
+            if self.model_type == "openai":
+                messages = [
+                    {"role": "system", "content": """Ви асистент, який допомагає аналізувати дані Jira. 
+                    Відповідайте на питання користувача на основі наданого контексту.
+                    Якщо контекст недостатній для відповіді, чесно визнайте це."""}
+                ]
+                
+                if context:
+                    messages.append({"role": "user", "content": f"Контекст: {context}"})
+                
+                messages.append({"role": "user", "content": question})
+                
+                # Відправлення запиту
+                response = openai.chat.completions.create(
+                    model=self.model,
+                    messages=messages,
+                    temperature=temperature,
+                )
+                
+                # Отримання відповіді
+                answer = response.choices[0].message.content
+                
+                logger.info("Успішно отримано відповідь від OpenAI")
+                return answer
+                
+            elif self.model_type == "gemini":
+                # TODO: Реалізувати для Gemini
+                return "Gemini API для Q&A ще не реалізовано"
+                
+        except Exception as e:
+            logger.error(f"Помилка при отриманні відповіді від LLM: {e}")
+            return f"Помилка при обробці запитання: {str(e)}"
+    
+    def generate_summary(self, jira_data, output_format="markdown", temperature=0.3):
+        """
+        Генерація підсумкового звіту по даним Jira.
+        
+        Args:
+            jira_data (str): Дані Jira для аналізу
+            output_format (str): Формат виводу ("markdown", "html", "text")
+            temperature (float): Параметр температури
+            
+        Returns:
+            str: Згенерований звіт
+        """
+        try:
+            # Формування запиту для LLM
+            if self.model_type == "openai":
+                format_instruction = ""
+                if output_format == "markdown":
+                    format_instruction = "Використовуйте Markdown для форматування звіту."
+                elif output_format == "html":
+                    format_instruction = "Створіть звіт у форматі HTML з використанням відповідних тегів."
+                else:
+                    format_instruction = "Створіть звіт у простому текстовому форматі."
+                
+                response = openai.chat.completions.create(
+                    model=self.model,
+                    messages=[
+                        {"role": "system", "content": f"""Ви аналітик, який створює професійні звіти на основі даних Jira.
+                        Проаналізуйте надані дані та створіть структурований звіт з наступними розділами:
+                        1. Короткий огляд проекту
+                        2. Аналіз поточного стану
+                        3. Ризики та проблеми
+                        4. Рекомендації
+                        {format_instruction}"""},
+                        {"role": "user", "content": f"Дані для аналізу:\n\n{jira_data}"}
+                    ],
+                    temperature=temperature,
+                )
+                
+                # Отримання звіту
+                report = response.choices[0].message.content
+                
+                logger.info(f"Успішно згенеровано звіт у форматі {output_format}")
+                return report
+                
+            elif self.model_type == "gemini":
+                # TODO: Реалізувати для Gemini
+                return "Gemini API для генерації звітів ще не реалізовано"
+                
+        except Exception as e:
+            logger.error(f"Помилка при генерації звіту: {e}")
+            return f"Помилка при генерації звіту: {str(e)}"
+
+
+class AIAgentManager:
+    """
+    Менеджер AI агентів для аналізу даних Jira
+    """
+    def __init__(self, api_key=None, model_type="openai"):
+        """
+        Ініціалізація менеджера AI агентів.
+        
+        Args:
+            api_key (str): API ключ для LLM
+            model_type (str): Тип моделі ("openai" або "gemini")
+        """
+        self.llm_connector = LLMConnector(api_key, model_type)
+        self.agents = {
+            "analytics_engineer": self._create_analytics_engineer(),
+            "project_manager": self._create_project_manager(),
+            "communication_specialist": self._create_communication_specialist()
+        }
+    
+    def _create_analytics_engineer(self):
+        """
+        Створення агента "Аналітичний інженер" для обробки даних.
+        
+        Returns:
+            dict: Конфігурація агента
+        """
+        return {
+            "name": "Аналітичний інженер",
+            "role": "Обробка та аналіз даних Jira",
+            "system_prompt": """Ви досвідчений аналітичний інженер, експерт з обробки та аналізу даних Jira.
+            Ваша задача - отримувати, обробляти та аналізувати дані з Jira, виявляти паттерни та готувати 
+            інформацію для подальшого аналізу іншими спеціалістами. Фокусуйтеся на виявленні аномалій, 
+            трендів та інсайтів у даних."""
+        }
+    
+    def _create_project_manager(self):
+        """
+        Створення агента "Проектний менеджер" для аналізу проекту.
+        
+        Returns:
+            dict: Конфігурація агента
+        """
+        return {
+            "name": "Проектний менеджер",
+            "role": "Аналіз стану проекту та вироблення рекомендацій",
+            "system_prompt": """Ви досвідчений проектний менеджер з глибоким розумінням процесів розробки ПЗ.
+            Ваша задача - аналізувати дані Jira, розуміти поточний стан проекту, виявляти ризики та проблеми,
+            та надавати конкретні дієві рекомендації для покращення процесу. Вас цікавлять дедлайни,
+            блокуючі фактори, неактивні тікети та ефективність процесу."""
+        }
+    
+    def _create_communication_specialist(self):
+        """
+        Створення агента "Комунікаційний спеціаліст" для формування повідомлень.
+        
+        Returns:
+            dict: Конфігурація агента
+        """
+        return {
+            "name": "Комунікаційний спеціаліст",
+            "role": "Формування повідомлень для стейкхолдерів",
+            "system_prompt": """Ви досвідчений комунікаційний спеціаліст, експерт з формування чітких,
+            інформативних та професійних повідомлень для стейкхолдерів проекту. Ваша задача - 
+            перетворювати технічну інформацію та аналітику в зрозумілі, структуровані повідомлення,
+            які допоможуть стейкхолдерам приймати рішення. Фокусуйтеся на ключових інсайтах, 
+            використовуйте професійний, але дружній тон."""
+        }
+    
+    def run_agent(self, agent_name, task, context=None, temperature=0.3):
+        """
+        Запуск конкретного агента для виконання задачі.
+        
+        Args:
+            agent_name (str): Назва агента ("analytics_engineer", "project_manager" або "communication_specialist")
+            task (str): Задача для агента
+            context (str): Контекст для виконання задачі
+            temperature (float): Параметр температури
+            
+        Returns:
+            str: Результат виконання задачі
+        """
+        try:
+            if agent_name not in self.agents:
+                return f"Помилка: агент '{agent_name}' не знайдений"
+            
+            agent = self.agents[agent_name]
+            
+            # Формування запиту для LLM
+            messages = [
+                {"role": "system", "content": agent["system_prompt"]}
+            ]
+            
+            if context:
+                messages.append({"role": "user", "content": f"Контекст: {context}"})
+            
+            messages.append({"role": "user", "content": task})
+            
+            # Відправлення запиту до LLM
+            if self.llm_connector.model_type == "openai":
+                response = openai.chat.completions.create(
+                    model=self.llm_connector.model,
+                    messages=messages,
+                    temperature=temperature,
+                )
+                
+                # Отримання результату
+                result = response.choices[0].message.content
+                
+                logger.info(f"Успішно отримано результат від агента '{agent_name}'")
+                return result
+                
+            elif self.llm_connector.model_type == "gemini":
+                # TODO: Реалізувати для Gemini
+                return f"Gemini API для агента '{agent_name}' ще не реалізовано"
+                
+        except Exception as e:
+            logger.error(f"Помилка при виконанні задачі агентом '{agent_name}': {e}")
+            return f"Помилка при виконанні задачі: {str(e)}"

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,266 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import logging
+
+logger = logging.getLogger(__name__)
+
+class JiraDataAnalyzer:
+    """
+    Клас для аналізу даних Jira
+    """
+    def __init__(self, df):
+        """
+        Ініціалізація аналізатора даних.
+        
+        Args:
+            df (pandas.DataFrame): DataFrame з даними Jira
+        """
+        self.df = df
+        
+    def generate_basic_statistics(self):
+        """
+        Генерація базової статистики по даним Jira.
+        
+        Returns:
+            dict: Словник з базовою статистикою
+        """
+        try:
+            stats = {
+                'total_tickets': len(self.df),
+                'status_counts': {},
+                'type_counts': {},
+                'priority_counts': {},
+                'assignee_counts': {},
+                'created_stats': {},
+                'updated_stats': {}
+            }
+            
+            # Статистика за статусами
+            if 'Status' in self.df.columns:
+                status_counts = self.df['Status'].value_counts()
+                stats['status_counts'] = status_counts.to_dict()
+            
+            # Статистика за типами
+            if 'Issue Type' in self.df.columns:
+                type_counts = self.df['Issue Type'].value_counts()
+                stats['type_counts'] = type_counts.to_dict()
+            
+            # Статистика за пріоритетами
+            if 'Priority' in self.df.columns:
+                priority_counts = self.df['Priority'].value_counts()
+                stats['priority_counts'] = priority_counts.to_dict()
+            
+            # Статистика за призначеними користувачами
+            if 'Assignee' in self.df.columns:
+                assignee_counts = self.df['Assignee'].value_counts().head(10)  # Топ 10
+                stats['assignee_counts'] = assignee_counts.to_dict()
+            
+            # Статистика за часом створення
+            if 'Created' in self.df.columns and pd.api.types.is_datetime64_dtype(self.df['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': created_min.strftime('%Y-%m-%d') if created_min else None,
+                    'max': created_max.strftime('%Y-%m-%d') if created_max else None,
+                    'last_7_days': len(self.df[self.df['Created'] > (datetime.now() - timedelta(days=7))])
+                }
+            
+            # Статистика за часом оновлення
+            if 'Updated' in self.df.columns and pd.api.types.is_datetime64_dtype(self.df['Updated']):
+                updated_min = self.df['Updated'].min()
+                updated_max = self.df['Updated'].max()
+                
+                stats['updated_stats'] = {
+                    'min': updated_min.strftime('%Y-%m-%d') if updated_min else None,
+                    'max': updated_max.strftime('%Y-%m-%d') if updated_max else None,
+                    '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 'Updated' not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df['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 'Status' in inactive_issues.columns:
+                inactive_data['by_status'] = inactive_issues['Status'].value_counts().to_dict()
+            
+            # Розподіл за пріоритетами
+            if 'Priority' in inactive_issues.columns:
+                inactive_data['by_priority'] = inactive_issues['Priority'].value_counts().to_dict()
+            
+            # Топ 5 неактивних тікетів
+            if len(inactive_issues) > 0:
+                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': row['Updated'].strftime('%Y-%m-%d') if pd.notna(row['Updated']) else 'Unknown',
+                        '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 '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
+                })
+            
+            # Створення 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 'Created' not in self.df.columns or not pd.api.types.is_datetime64_dtype(self.df['Created']):
+                logger.warning("Колонка 'Created' відсутня або не містить дат")
+                return {'error': "Неможливо аналізувати час виконання"}
+            
+            if 'Resolved' not in self.df.columns:
+                logger.warning("Колонка 'Resolved' відсутня")
+                return {'error': "Неможливо аналізувати час виконання"}
+            
+            # Конвертація колонки Resolved до datetime, якщо потрібно
+            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 {'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]
+            
+            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,450 @@
+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:
+                pass
+            
+            bars = 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:
+                pass
+            
+            # Кольори для різних пріоритетів
+            colors = ['#FF5555', '#FF9C5A', '#FFCC5A', '#5AFF96', '#5AC8FF']
+            if len(priority_counts) <= len(colors):
+                bars = sns.barplot(x=priority_counts.index, y=priority_counts.values, ax=ax, palette=colors[:len(priority_counts)])
+            else:
+                bars = 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))
+            
+            bars = 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))
+                
+                bars = 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
+                    })
+                
+                # Створення DataFrame
+                timeline_df = pd.DataFrame(timeline_data)
+                
+                # Конвертація Date до datetime
+                timeline_df['Date'] = pd.to_datetime(timeline_df['Date'])
+            else:
+                # Конвертація Date до datetime, якщо потрібно
+                if not pd.api.types.is_datetime64_dtype(timeline_df['Date']):
+                    timeline_df['Date'] = pd.to_datetime(timeline_df['Date'])
+            
+            # Отримання статусів (всі колонки, крім Date і Total)
+            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
+            
+            # Конвертація колонки Resolved до datetime, якщо потрібно
+            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
+            
+            # Обчислення 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("Немає валідних даних про час виконання")
+                return None
+            
+            # Обчислення середнього часу виконання за типами
+            lead_time_by_type = valid_lead_time.groupby('Issue Type')['Lead_Time_Days'].mean()
+            
+            # Створення діаграми
+            fig, ax = plt.subplots(figsize=(10, 6))
+            
+            bars = 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
+    
+    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['created_timeline'] = self.plot_created_timeline()
+        plots['inactive'] = self.plot_inactive_issues()
+        plots['status_timeline'] = self.plot_status_timeline()
+        plots['lead_time'] = self.plot_lead_time_by_type()
+        
+        # Збереження діаграм, якщо вказана директорія
+        if output_dir:
+            import os
+            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,217 @@
+import pandas as pd
+from datetime import datetime
+import logging
+import os
+from pathlib import Path
+
+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
+    
+    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
+            
+            # Спробуємо різні кодування
+            try:
+                self.df = pd.read_csv(self.file_path, encoding='utf-8')
+                print(f"Файл успішно прочитано з кодуванням utf-8")
+            except UnicodeDecodeError:
+                try:
+                    logger.warning("Помилка декодування UTF-8, спроба з latin1")
+                    print("Помилка декодування UTF-8, спроба з latin1")
+                    self.df = pd.read_csv(self.file_path, encoding='latin1')
+                    print(f"Файл успішно прочитано з кодуванням latin1")
+                except Exception as e:
+                    logger.error(f"Помилка при спробі прочитати з latin1: {e}")
+                    print(f"Помилка при спробі прочитати з latin1: {e}")
+                    # Спробуємо читати без вказання кодування
+                    self.df = pd.read_csv(self.file_path)
+                    print(f"Файл успішно прочитано зі стандартним кодуванням")
+            
+            # Тимчасово вимкнемо перевірку колонок для діагностики
+            # required_columns = self._check_required_columns()
+            # if not required_columns:
+            #     logger.warning("CSV-файл не містить необхідних колонок")
+            #     print("CSV-файл не містить необхідних колонок")
+            #     return None
+            
+            # Відображення наявних колонок для діагностики
+            print(f"Наявні колонки: {self.df.columns.tolist()}")
+            print(f"Кількість рядків: {len(self.df)}")
+            
+            # Обробка дат
+            self._process_dates()
+            
+            # Очищення та підготовка даних
+            self._clean_data()
+            
+            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}")
+            return None
+    
+    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/reporting/report_generator.py

@@ -0,0 +1,370 @@
+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
+
+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("\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')}")
+                
+                # Тікети за останній тиждень
+                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

reports/jira_report_20250228_094906.md

@@ -0,0 +1,54 @@
+# Звіт аналізу Jira
+*Створено: 2025-02-28 09:48:16*
+
+## Загальна статистика
+**Загальна кількість тікетів:** 33
+
+### Статуси тікетів
+- **To Do:** 22 (66.7%)
+- **Done:** 7 (21.2%)
+- **Not relevant:** 1 (3.0%)
+- **In Progress:** 1 (3.0%)
+- **Committed:** 1 (3.0%)
+- **READY FOR TEST ON UAT:** 1 (3.0%)
+
+### Типи тікетів
+- **Task:** 19 (57.6%)
+- **Sub-task:** 9 (27.3%)
+- **Epic:** 3 (9.1%)
+- **Story:** 1 (3.0%)
+- **Bug:** 1 (3.0%)
+
+### Пріоритети тікетів
+- **Medium:** 28 (84.8%)
+- **High:** 2 (6.1%)
+- **Low:** 2 (6.1%)
+- **Highest:** 1 (3.0%)
+
+## Неактивні тікети (>14 днів)
+**Загальна кількість неактивних тікетів:** 26 (78.79%)
+
+**Неактивні тікети за статусами:**
+- **To Do:** 15
+- **Done:** 7
+- **Not relevant:** 1
+- **In Progress:** 1
+- **Committed:** 1
+- **READY FOR TEST ON UAT:** 1
+
+**Топ 5 найбільш неактивних тікетів:**
+1. **IEE-788:** related outstanding keywords
+   - Статус: Done
+   - Днів неактивності: 1592
+2. **IEE-968:** Left/Right blockers
+   - Статус: Done
+   - Днів неактивності: 1353
+3. **PAT-287:** CLONE - Extract/Process Location and TS admission from ADT-05
+   - Статус: Done
+   - Днів неактивності: 1324
+4. **IEE-947:** Priority of  specifics TS 
+   - Статус: Done
+   - Днів неактивності: 1212
+5. **IEE-494:** Free Text in structured fields
+   - Статус: Done
+   - Днів неактивності: 1151

requirements.txt

@@ -0,0 +1,9 @@
+gradio==5.19.0
+jira==3.5.2
+pandas==2.1.0
+numpy==1.26.0
+matplotlib==3.7.2
+seaborn==0.12.2
+python-dotenv==1.0.0
+markdown==3.4.4
+pathlib==1.0.1