feat: add conversation logging and statistics features with export options

.gitignore

@@ -91,6 +91,7 @@ demos/
 deployment/
 docs/
 scripts/
+conversation_logs/
 
 # User/runtime profiles
 lifestyle_profile.json

CONVERSATION_LOGGING_FEATURES.md

@@ -0,0 +1,201 @@
+# Нові функції логування розмов та візуальних індикаторів
+
+## Огляд
+
+Додано нові функції для покращення користувацького досвіду та аналізу розмов:
+
+1. **Кольорові індикатори класифікації** - показують рівень духовного дистресу
+2. **Автоматичне логування розмов** - зберігає всі розмови в JSON та CSV форматах
+3. **Статистика розмов в реальному часі** - показує аналітику поточної сесії
+4. **Кнопки завантаження** - дозволяють завантажити логи розмов
+
+## Кольорові індикатори
+
+### Формат відображення
+Кожна відповідь асистента тепер починається з кольорового індикатора:
+
+```
+🟢 **GREEN** (95%)
+
+🟡 **YELLOW** (85%)
+*Indicators: anxiety, worry, work-related stress*
+
+🔴 **RED** (90%)
+*Indicators: suicidal ideation, hopelessness*
+```
+
+### Значення кольорів
+- **🟢 GREEN** - Немає ознак духовного дистресу, звичайна медична розмова
+- **🟡 YELLOW** - Потенційний дистрес, потребує уваги та підтримки
+- **🔴 RED** - Серйозний дистрес або криза, потребує негайного втручання
+
+### Додаткова інформація
+- **Відсоток впевненості** - показує наскільки впевнена система в класифікації
+- **Індикатори** - конкретні ознаки дистресу, які були виявлені
+
+## Логування розмов
+
+### Автоматичне збереження
+- Кожна розмова автоматично зберігається в папці `conversation_logs/`
+- Створюються файли в форматах JSON та CSV
+- Логування відбувається в реальному часі після кожного повідомлення
+
+### Структура JSON логу
+```json
+{
+  "session_id": "session_20251212_114257",
+  "start_time": "2025-12-12T11:42:57.849982",
+  "patient_name": "Test Patient",
+  "total_messages": 4,
+  "entries": [
+    {
+      "timestamp": "2025-12-12T11:43:06.931133",
+      "user_message": "Привіт, як справи?",
+      "assistant_response": "Привіт! Дякую...",
+      "spiritual_classification": "GREEN",
+      "classification_confidence": 0.95,
+      "classification_indicators": [],
+      "classification_reasoning": "Simple greeting...",
+      "session_id": "session_20251212_114257",
+      "message_index": 1
+    }
+  ],
+  "session_summary": {
+    "total_exchanges": 4,
+    "classification_counts": {
+      "green": 2,
+      "yellow": 2,
+      "red": 0
+    },
+    "classification_percentages": {
+      "green": 50.0,
+      "yellow": 50.0,
+      "red": 0.0
+    },
+    "average_confidence": 0.9,
+    "top_indicators": {
+      "anxiety": 1,
+      "worry": 1,
+      "work-related stress": 1
+    },
+    "session_duration_minutes": 5.2
+  }
+}
+```
+
+### CSV формат
+CSV файл містить ті ж дані в табличному форматі для аналізу в Excel або інших програмах.
+
+## Інтерфейс користувача
+
+### Нові елементи в чаті
+
+#### Кнопки завантаження
+```
+📊 Conversation Logs:
+[📥 Download JSON] [📊 Download CSV]
+```
+
+#### Статистика розмови
+```
+📈 Conversation Stats
+**📊 Conversation Statistics**
+
+**Messages:** 4 exchanges
+**Duration:** 5.2 minutes
+
+**Classifications:**
+🟢 Green: 2 (50.0%)
+🟡 Yellow: 2 (50.0%)
+🔴 Red: 0 (0.0%)
+
+**Average Confidence:** 0.9
+
+**Top Indicators:**
+• anxiety: 1
+• worry: 1
+• work-related stress: 1
+```
+
+#### Кнопка оновлення статистики
+```
+[🔄 Refresh Stats]
+```
+
+## Технічна реалізація
+
+### Нові класи
+- `ConversationLogger` - основний клас для логування
+- `ConversationEntry` - структура для одного обміну повідомленнями
+- `ConversationSession` - структура для повної сесії
+
+### Інтеграція з існуючою системою
+- Логування інтегровано в `SimplifiedMedicalApp`
+- Індикатори додаються автоматично до всіх відповідей
+- Статистика оновлюється після кожного повідомлення
+
+### Файлова структура
+```
+conversation_logs/
+├── session_20251212_114257.json
+├── session_20251212_114257.csv
+├─��� session_20251212_115430.json
+└── session_20251212_115430.csv
+```
+
+## Використання
+
+### Для користувачів
+1. **Спостерігайте за індикаторами** - кольорові позначки показують рівень дистресу
+2. **Завантажуйте логи** - використовуйте кнопки для збереження розмов
+3. **Переглядайте статистику** - слідкуйте за динамікою розмови
+
+### Для аналітиків
+1. **JSON файли** - для програмного аналізу та обробки даних
+2. **CSV файли** - для аналізу в Excel, Google Sheets тощо
+3. **Статистика сесій** - для розуміння патернів та трендів
+
+## Приклади використання
+
+### Медичний персонал
+- Відстеження емоційного стану пацієнтів
+- Виявлення патернів дистресу
+- Документування для медичних записів
+
+### Дослідники
+- Аналіз ефективності класифікації
+- Вивчення патернів духовного дистресу
+- Покращення алгоритмів
+
+### Адміністратори
+- Моніторинг використання системи
+- Оцінка якості взаємодії
+- Планування ресурсів підтримки
+
+## Конфіденційність та безпека
+
+### Локальне зберігання
+- Всі логи зберігаються локально
+- Немає передачі даних на зовнішні сервери
+- Користувач контролює свої дані
+
+### Анонімізація
+- Можливість використання псевдонімів
+- Видалення особистої інформації при потребі
+- Контроль доступу до файлів логів
+
+## Майбутні покращення
+
+### Планується додати
+- Експорт в інші формати (PDF, Word)
+- Фільтрація та пошук в логах
+- Візуалізація статистики (графіки, діаграми)
+- Автоматичні звіти та аналітика
+- Інтеграція з медичними системами
+
+### Можливі розширення
+- Порівняння сесій
+- Трендовий аналіз
+- Алерти при критичних ситуаціях
+- Інтеграція з календарем
+- Нагадування про подальші дії

src/core/conversation_logger.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+Conversation Logger for Medical Assistant.
+
+Logs conversations with spiritual classification indicators for analysis.
+"""
+
+import json
+import os
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, asdict
+from src.core.spiritual_state import SpiritualState, SpiritualAssessment
+
+@dataclass
+class ConversationEntry:
+    """Single conversation entry with classification data."""
+    timestamp: str
+    user_message: str
+    assistant_response: str
+    spiritual_classification: str  # GREEN, YELLOW, RED
+    classification_confidence: float
+    classification_indicators: List[str]
+    classification_reasoning: str
+    session_id: str
+    message_index: int
+
+@dataclass
+class ConversationSession:
+    """Complete conversation session."""
+    session_id: str
+    start_time: str
+    end_time: Optional[str]
+    patient_name: str
+    total_messages: int
+    entries: List[ConversationEntry]
+    session_summary: Dict[str, Any]
+
+class ConversationLogger:
+    """Logger for conversation sessions with spiritual classification data."""
+    
+    def __init__(self, session_id: str = None, patient_name: str = "Anonymous"):
+        """Initialize conversation logger."""
+        self.session_id = session_id or self._generate_session_id()
+        self.patient_name = patient_name
+        self.start_time = datetime.now().isoformat()
+        self.entries: List[ConversationEntry] = []
+        self.message_counter = 0
+        
+        # Create logs directory if it doesn't exist
+        self.logs_dir = "conversation_logs"
+        os.makedirs(self.logs_dir, exist_ok=True)
+    
+    def _generate_session_id(self) -> str:
+        """Generate unique session ID."""
+        return f"session_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    
+    def log_exchange(
+        self,
+        user_message: str,
+        assistant_response: str,
+        assessment: SpiritualAssessment
+    ) -> None:
+        """
+        Log a conversation exchange with spiritual classification.
+        
+        Args:
+            user_message: User's message
+            assistant_response: Assistant's response
+            assessment: Spiritual assessment of the user message
+        """
+        self.message_counter += 1
+        
+        entry = ConversationEntry(
+            timestamp=datetime.now().isoformat(),
+            user_message=user_message,
+            assistant_response=assistant_response,
+            spiritual_classification=assessment.state.value.upper(),
+            classification_confidence=assessment.confidence,
+            classification_indicators=assessment.indicators,
+            classification_reasoning=assessment.reasoning,
+            session_id=self.session_id,
+            message_index=self.message_counter
+        )
+        
+        self.entries.append(entry)
+        
+        # Auto-save after each entry
+        self._save_session()
+    
+    def get_classification_indicator(self, state: SpiritualState) -> str:
+        """Get colored emoji indicator for spiritual state."""
+        indicators = {
+            SpiritualState.GREEN: "🟢",
+            SpiritualState.YELLOW: "🟡", 
+            SpiritualState.RED: "🔴"
+        }
+        return indicators.get(state, "⚪")
+    
+    def get_classification_text(self, assessment: SpiritualAssessment) -> str:
+        """Get formatted classification text for display."""
+        indicator = self.get_classification_indicator(assessment.state)
+        confidence_percent = int(assessment.confidence * 100)
+        
+        classification_text = f"{indicator} **{assessment.state.value.upper()}** ({confidence_percent}%)"
+        
+        if assessment.indicators:
+            indicators_text = ", ".join(assessment.indicators[:3])  # Show max 3 indicators
+            if len(assessment.indicators) > 3:
+                indicators_text += f" +{len(assessment.indicators) - 3} more"
+            classification_text += f"\n*Indicators: {indicators_text}*"
+        
+        return classification_text
+    
+    def _save_session(self) -> None:
+        """Save current session to JSON file."""
+        session = ConversationSession(
+            session_id=self.session_id,
+            start_time=self.start_time,
+            end_time=None,  # Will be set when session ends
+            patient_name=self.patient_name,
+            total_messages=self.message_counter,
+            entries=self.entries,
+            session_summary=self._generate_session_summary()
+        )
+        
+        filename = f"{self.session_id}.json"
+        filepath = os.path.join(self.logs_dir, filename)
+        
+        try:
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(asdict(session), f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            print(f"Error saving conversation log: {e}")
+    
+    def _generate_session_summary(self) -> Dict[str, Any]:
+        """Generate summary statistics for the session."""
+        if not self.entries:
+            return {}
+        
+        # Count classifications
+        green_count = sum(1 for e in self.entries if e.spiritual_classification == "GREEN")
+        yellow_count = sum(1 for e in self.entries if e.spiritual_classification == "YELLOW")
+        red_count = sum(1 for e in self.entries if e.spiritual_classification == "RED")
+        
+        # Calculate average confidence
+        avg_confidence = sum(e.classification_confidence for e in self.entries) / len(self.entries)
+        
+        # Collect all indicators
+        all_indicators = []
+        for entry in self.entries:
+            all_indicators.extend(entry.classification_indicators)
+        
+        # Count unique indicators
+        indicator_counts = {}
+        for indicator in all_indicators:
+            indicator_counts[indicator] = indicator_counts.get(indicator, 0) + 1
+        
+        return {
+            "total_exchanges": len(self.entries),
+            "classification_counts": {
+                "green": green_count,
+                "yellow": yellow_count,
+                "red": red_count
+            },
+            "classification_percentages": {
+                "green": round(green_count / len(self.entries) * 100, 1),
+                "yellow": round(yellow_count / len(self.entries) * 100, 1),
+                "red": round(red_count / len(self.entries) * 100, 1)
+            },
+            "average_confidence": round(avg_confidence, 3),
+            "top_indicators": dict(sorted(indicator_counts.items(), key=lambda x: x[1], reverse=True)[:5]),
+            "session_duration_minutes": self._calculate_session_duration()
+        }
+    
+    def _calculate_session_duration(self) -> float:
+        """Calculate session duration in minutes."""
+        if not self.entries:
+            return 0.0
+        
+        start = datetime.fromisoformat(self.start_time)
+        last_entry = datetime.fromisoformat(self.entries[-1].timestamp)
+        duration = (last_entry - start).total_seconds() / 60
+        return round(duration, 1)
+    
+    def end_session(self) -> str:
+        """End the session and return final log file path."""
+        # Update end time in the last save
+        if self.entries:
+            self.entries[-1].timestamp = datetime.now().isoformat()
+        
+        self._save_session()
+        
+        filename = f"{self.session_id}.json"
+        return os.path.join(self.logs_dir, filename)
+    
+    def get_session_summary(self) -> Dict[str, Any]:
+        """Get current session summary."""
+        return self._generate_session_summary()
+    
+    def export_csv(self) -> str:
+        """Export conversation to CSV format."""
+        import csv
+        
+        csv_filename = f"{self.session_id}.csv"
+        csv_filepath = os.path.join(self.logs_dir, csv_filename)
+        
+        try:
+            with open(csv_filepath, 'w', newline='', encoding='utf-8') as csvfile:
+                fieldnames = [
+                    'timestamp', 'message_index', 'user_message', 'assistant_response',
+                    'spiritual_classification', 'classification_confidence', 
+                    'classification_indicators', 'classification_reasoning'
+                ]
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                
+                writer.writeheader()
+                for entry in self.entries:
+                    writer.writerow({
+                        'timestamp': entry.timestamp,
+                        'message_index': entry.message_index,
+                        'user_message': entry.user_message,
+                        'assistant_response': entry.assistant_response,
+                        'spiritual_classification': entry.spiritual_classification,
+                        'classification_confidence': entry.classification_confidence,
+                        'classification_indicators': '; '.join(entry.classification_indicators),
+                        'classification_reasoning': entry.classification_reasoning
+                    })
+            
+            return csv_filepath
+        except Exception as e:
+            print(f"Error exporting to CSV: {e}")
+            return ""

src/core/simplified_medical_app.py

@@ -23,6 +23,7 @@ from src.core.spiritual_state import (
 from src.core.spiritual_monitor import SpiritualMonitor
 from src.core.soft_triage_manager import SoftTriageManager
 from src.core.ai_client import AIClientManager
+from src.core.conversation_logger import ConversationLogger
 from src.core.core_classes import (
     ClinicalBackground, ChatMessage, SessionState,
     PatientDataLoader, MedicalAssistant, SoftMedicalTriage
@@ -82,6 +83,11 @@ class SimplifiedMedicalApp:
         self.spiritual_state = SessionSpiritualState()
         self.session_active = False
         
+        # Conversation logging
+        self.conversation_logger = ConversationLogger(
+            patient_name=self.clinical_background.patient_name
+        )
+        
         logger.info("✅ SimplifiedMedicalApp initialized")
     
     def process_message(
@@ -146,20 +152,44 @@ class SimplifiedMedicalApp:
                 # GREEN - normal medical dialog (Requirement 2.2)
                 response = self._handle_green_state(message)
         
+        # Get the assessment for display and logging
+        current_assessment = self.spiritual_state.last_assessment
+        if current_assessment is None:
+            # Create default assessment for GREEN state
+            current_assessment = SpiritualAssessment(
+                state=SpiritualState.GREEN,
+                indicators=[],
+                confidence=0.95,
+                reasoning="Normal medical conversation"
+            )
+        
+        # Create classification indicator text
+        classification_text = self.conversation_logger.get_classification_text(current_assessment)
+        
+        # Add classification indicator to response
+        response_with_indicator = f"{classification_text}\n\n{response}"
+        
         # Add assistant response to history
         assistant_msg = ChatMessage(
             timestamp=datetime.now().strftime("%H:%M"),
             role="assistant",
-            message=response,
+            message=response_with_indicator,
             mode=f"medical_{self.spiritual_state.spiritual_state.value}"
         )
         self.chat_history.append(assistant_msg)
         
+        # Log the conversation exchange
+        self.conversation_logger.log_exchange(
+            user_message=message,
+            assistant_response=response,
+            assessment=current_assessment
+        )
+        
         # Update Gradio history
         if history is None:
             history = []
         history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": response})
+        history.append({"role": "assistant", "content": response_with_indicator})
         
         return history, self._get_status_info()
     
@@ -475,12 +505,33 @@ RECOMMENDED ACTION: Immediate spiritual care outreach
         """
         logger.info("Resetting session")
         
+        # End current conversation log
+        if hasattr(self, 'conversation_logger'):
+            self.conversation_logger.end_session()
+        
         self.chat_history = []
         self.spiritual_state.reset()
         self.session_active = False
         
+        # Start new conversation log
+        self.conversation_logger = ConversationLogger(
+            patient_name=self.clinical_background.patient_name
+        )
+        
         return [], self._get_status_info()
     
+    def get_conversation_log_path(self) -> str:
+        """Get path to current conversation log file."""
+        return self.conversation_logger.end_session()
+    
+    def get_conversation_summary(self) -> dict:
+        """Get summary of current conversation."""
+        return self.conversation_logger.get_session_summary()
+    
+    def export_conversation_csv(self) -> str:
+        """Export conversation to CSV format."""
+        return self.conversation_logger.export_csv()
+    
     def _get_status_info(self) -> str:
         """Get current status information."""
         state_emoji = {

src/interface/simplified_gradio_app.py

@@ -296,6 +296,12 @@ def create_simplified_interface():
                         with gr.Row():
                             clear_btn = gr.Button("🗑️ Clear Chat", scale=1)
                         
+                        # Conversation logging section
+                        gr.Markdown("### 📊 Conversation Logs:")
+                        with gr.Row():
+                            download_json_btn = gr.DownloadButton("📥 Download JSON", scale=1, size="sm")
+                            download_csv_btn = gr.DownloadButton("📊 Download CSV", scale=1, size="sm")
+                        
                         # Quick examples
                         gr.Markdown("### ⚡ Quick Start:")
                         with gr.Row():
@@ -311,6 +317,15 @@ def create_simplified_interface():
                         
                         refresh_btn = gr.Button("🔄 Refresh Status", size="sm")
                         
+                        # Conversation statistics
+                        gr.Markdown("### 📈 Conversation Stats")
+                        conversation_stats = gr.Markdown(
+                            value="No conversation yet",
+                            label="Statistics"
+                        )
+                        
+                        refresh_stats_btn = gr.Button("🔄 Refresh Stats", size="sm")
+                        
                         # Debug info (only in debug mode)
                         if debug_mode:
                             gr.Markdown("### 🔧 Debug Info")
@@ -680,7 +695,11 @@ Changes apply only to your current session.
             
             session.update_activity()
             new_history, status = session.app_instance.process_message(message, history)
-            return new_history, status, session, ""
+            
+            # Get updated conversation stats
+            stats = get_conversation_stats(session)
+            
+            return new_history, status, session, "", stats
         
         def handle_clear(session: SimplifiedSessionData):
             """Handle clear chat."""
@@ -703,6 +722,62 @@ Changes apply only to your current session.
             """Send example message."""
             return handle_message(example_text, history, session)
         
+        def get_conversation_stats(session: SimplifiedSessionData):
+            """Get conversation statistics."""
+            if session is None or not hasattr(session.app_instance, 'conversation_logger'):
+                return "No conversation yet"
+            
+            try:
+                summary = session.app_instance.get_conversation_summary()
+                if not summary or summary.get('total_exchanges', 0) == 0:
+                    return "No conversation yet"
+                
+                stats_text = f"""**📊 Conversation Statistics**
+
+**Messages:** {summary['total_exchanges']} exchanges
+**Duration:** {summary['session_duration_minutes']} minutes
+
+**Classifications:**
+🟢 Green: {summary['classification_counts']['green']} ({summary['classification_percentages']['green']}%)
+🟡 Yellow: {summary['classification_counts']['yellow']} ({summary['classification_percentages']['yellow']}%)
+🔴 Red: {summary['classification_counts']['red']} ({summary['classification_percentages']['red']}%)
+
+**Average Confidence:** {summary['average_confidence']}
+
+**Top Indicators:**"""
+                
+                for indicator, count in list(summary['top_indicators'].items())[:3]:
+                    stats_text += f"\n• {indicator}: {count}"
+                
+                return stats_text
+                
+            except Exception as e:
+                return f"Error getting stats: {str(e)}"
+        
+        def download_conversation_json(session: SimplifiedSessionData):
+            """Download conversation as JSON."""
+            if session is None or not hasattr(session.app_instance, 'conversation_logger'):
+                return None
+            
+            try:
+                log_path = session.app_instance.get_conversation_log_path()
+                return log_path
+            except Exception as e:
+                print(f"Error downloading JSON: {e}")
+                return None
+        
+        def download_conversation_csv(session: SimplifiedSessionData):
+            """Download conversation as CSV."""
+            if session is None or not hasattr(session.app_instance, 'conversation_logger'):
+                return None
+            
+            try:
+                csv_path = session.app_instance.export_conversation_csv()
+                return csv_path
+            except Exception as e:
+                print(f"Error downloading CSV: {e}")
+                return None
+        
         # Prompt editing handlers
         def format_prompt_with_html(prompt_text: str) -> str:
             """Format prompt with HTML tags for better visualization."""
@@ -1742,13 +1817,13 @@ To revert, use "Reset to Default" button.
         send_btn.click(
             handle_message,
             inputs=[msg, chatbot, session_data],
-            outputs=[chatbot, status_box, session_data, msg]
+            outputs=[chatbot, status_box, session_data, msg, conversation_stats]
         )
         
         msg.submit(
             handle_message,
             inputs=[msg, chatbot, session_data],
-            outputs=[chatbot, status_box, session_data, msg]
+            outputs=[chatbot, status_box, session_data, msg, conversation_stats]
         )
         
         # Clear chat
@@ -1766,22 +1841,47 @@ To revert, use "Reset to Default" button.
         )
         
         # Example buttons
+        def send_example_with_stats(example_text: str, history, session: SimplifiedSessionData):
+            """Send example message and return stats."""
+            new_history, status, updated_session, msg, stats = handle_message(example_text, history, session)
+            return new_history, status, updated_session, msg, stats
+        
         example_medical.click(
-            lambda h, s: send_example("I have a headache and feel tired", h, s),
+            lambda h, s: send_example_with_stats("I have a headache and feel tired", h, s),
             inputs=[chatbot, session_data],
-            outputs=[chatbot, status_box, session_data, msg]
+            outputs=[chatbot, status_box, session_data, msg, conversation_stats]
         )
         
         example_wellness.click(
-            lambda h, s: send_example("I'm feeling stressed and overwhelmed lately", h, s),
+            lambda h, s: send_example_with_stats("I'm feeling stressed and overwhelmed lately", h, s),
             inputs=[chatbot, session_data],
-            outputs=[chatbot, status_box, session_data, msg]
+            outputs=[chatbot, status_box, session_data, msg, conversation_stats]
         )
         
         example_help.click(
-            lambda h, s: send_example("How can you help me with my health?", h, s),
+            lambda h, s: send_example_with_stats("How can you help me with my health?", h, s),
             inputs=[chatbot, session_data],
-            outputs=[chatbot, status_box, session_data, msg]
+            outputs=[chatbot, status_box, session_data, msg, conversation_stats]
+        )
+        
+        # Conversation logging buttons
+        download_json_btn.click(
+            download_conversation_json,
+            inputs=[session_data],
+            outputs=[download_json_btn]
+        )
+        
+        download_csv_btn.click(
+            download_conversation_csv,
+            inputs=[session_data],
+            outputs=[download_csv_btn]
+        )
+        
+        # Refresh conversation stats
+        refresh_stats_btn.click(
+            get_conversation_stats,
+            inputs=[session_data],
+            outputs=[conversation_stats]
         )
         
         # Prompt editing events