Respan Dataset Explorer

how can we learn pt to use their wrist?

Teaching a patient to use their wrist effectively for activities of daily living (ADLs) can be especially beneficial for those with limited hand function. Here are some strategies and techniques that can be employed in physical therapy (PT) or occupational therapy (OT) settings:

### 1. **Education and Awareness**:
   - **Understanding Movement**: Explain the mechanics of wrist movement and how it affects hand function, particularly in relation to the tenodesis grasp for patients with limited finger mobility.
   - **Goal Setting**: Set specific, achievable goals related to wrist and hand function based on the patient’s needs and lifestyle.

### 2. **Range of Motion Exercises**:
   - **Wrist Flexion and Extension**: Teach the patient to perform wrist flexion (bending the wrist down) and extension (bending the wrist up) through gentle exercises.
   - **Strengthening Exercises**: Use resistance bands or small weights to strengthen the muscles around the wrist to improve control and stability.

### 3. **Functional Activities**:
   - **Daily Living Tasks**: Incorporate wrist movements into tasks like picking up objects, brushing teeth, or grooming. Start with simple tasks and gradually increase complexity.
   - **Gripping Exercises**: Provide activities that involve gripping and releasing objects using the wrist movement to activate the tenodesis grasp (e.g., using a soft ball or therapy putty).

### 4. **Adaptive Devices**:
   - **Wrist Braces**: If appropriate, provide a wrist brace that allows for functional control while providing support.
   - **Adaptive Tools**: Use utensils and tools that are designed to be easier to grip and manipulate, which can help practice wrist and grasping functions.

### 5. **Task Grading**:
   - **Gradual Progression**: Start with simple tasks that require minimal wrist movement and gradually progress to more complex activities that require greater wrist control.
   - **Engagement**: Encourage the patient to practice using their wrist during meaningful activities they enjoy, enhancing motivation.

### 6. **Feedback and Monitoring**:
   - **Visual Feedback**: Use mirrors or video to allow patients to see their wrist movements, which helps in self-correction.
   - **Positive Reinforcement**: Celebrate small successes to boost confidence and encourage continued practice.

### 7. **Consistency and Practice**:
   - **Regular Practice**: Encourage the patient to practice wrist movements regularly, both in therapy sessions and at home, to reinforce learning.
   - **Home Exercise Program**: Provide a structured home exercise program that focuses on wrist mobility and functional use.

### 8. **Collaboration**:
   - **Interdisciplinary Approach**: Work with other professionals, such as occupational therapists, to provide comprehensive strategies for improving hand and wrist function.

By using these strategies, patients can develop better control and strength in their wrist movements, which can significantly enhance their ability to perform daily tasks and improve their overall quality of life.

but patient is paralysized ?

In cases where a patient has paralysis and limited voluntary movement, particularly in the upper extremities, the approach to teaching wrist and hand function needs to be adapted to focus more on promoting functional use of existing capabilities and leveraging any involuntary movements. Here are targeted strategies that can be helpful in this context:

### 1. **Understanding Tenodesis Grasp**:
   - **Education**: Educate the patient and caregivers about the tenodesis grasp and how it can be utilized effectively despite paralysis.

### 2. **Passive Range of Motion**:
   - **Assisted Movements**: Perform passive range of motion exercises for the wrist and fingers. A therapist or caregiver can help move the patient's wrist to maintain flexibility and prevent stiffness.
   - **Stretching**: Gently stretch the muscles and tendons in the forearm and wrist to enhance range and flexibility.

### 3. **Supported Wrist Positioning**:
   - **Wrist Braces**: Use wrist braces or splints to position the wrist in a slight extension, which may facilitate passive closure of the fingers (tenodesis grasp) when the person uses other body movements.
   - **Adaptive Devices**: Implement tools designed to assist individuals with paralysis, like universal cuffs or grabbers, to help engage with objects using wrist movements.

### 4. **Functional Positioning**:
   - **Postural Alignment**: Ensure proper seated posture to facilitate optimal use of the upper body for any available movement. This helps set the stage for using the wrist effectively.
   - **Proximal Stability**: Promote stability through the shoulders or trunk to enhance any possible distal movement from the wrist and hand.

### 5. **Facilitating Movement Through Substitutions**:
   - **Utilization of Other Body Parts**: Encourage the use of other body parts that the patient can control, such as the elbow or body weight shift, to create movement in the wrist and facilitate grasp.

### 6. **Engaging in Activities**:
   - **Adaptive Activities**: Plan activities that require minimal movement but encourage interaction, like using large, easy-to-grasp items that can be manipulated with wrist movement.
   - **Incorporating Assistive Technology**: Explore the use of technology like powered grip devices that can provide a means for grasping without requiring voluntary finger control.

### 7. **Visual and Tactile Feedback**:
   - **Using Mirrors**: If the patient can visually perceive movement, using mirrors can help them see their wrist and hand and understand the concept of movement even if they cannot actively perform it.
   - **Providing Tactile Cues**: Use hands-on guidance or tactile prompts to help them understand where to move their wrist in relation to object manipulation.

### 8. **Collaborative Efforts**:
   - **Multidisciplinary Team**: Work closely with occupational and physical therapists who can provide specialized interventions tailored to the specific needs of the patient with paralysis.

### 9. **Emotional Support and Motivation**:
   - **Encouraging Attitude**: Help the patient explore and focus on small successes, promoting motivation and a sense of agency in their rehabilitation journey.

By utilizing these approaches, therapists can help patients with paralysis optimize their existing functional abilities, which can improve their independence and engagement in meaningful activities, even in the face of significant physical limitations.

alled paradoxical breathing pattern.

**Paradoxical breathing pattern** refers to an abnormal breathing pattern where the movements of the chest and abdomen are not coordinated as they should be during inhalation and exhalation. In normal breathing, when you inhale, the diaphragm contracts and moves downward, causing the chest and abdomen to rise. In paradoxical breathing, the opposite occurs:

### Characteristics of Paradoxical Breathing:
1. **Chest and Abdomen Movement**: 
   - During inhalation, instead of expanding outward, the chest may retract or sink in, while the abdomen may rise. 
   - During exhalation, the chest may expand while the abdomen draws in.

2. **Involvement of Accessory Muscles**: 
   - Individuals may rely more on accessory muscles of breathing (such as the neck and shoulder muscles) rather than using the diaphragm effectively.

3. **Inefficient Breathing**: 
   - This pattern can result in less effective ventilation and gas exchange, leading to feelings of breathlessness or respiratory distress.

### Causes of Paradoxical Breathing:
Paradoxical breathing can occur due to various reasons, including:

- **Neuromuscular Conditions**: Disorders affecting the nerves and muscles involved in breathing (e.g., ALS, muscular dystrophy).
- **Chest or Abdominal Injuries**: Trauma that affects the ribs, chest wall, or diaphragm.
- **Respiratory Conditions**: Severe respiratory issues, such as COPD, severe asthma, or pneumonia.
- **Anxiety or Panic Attacks**: Psychological factors can also contribute to altered breathing patterns.

### Implications:
- Paradoxical breathing can lead to increased work of breathing and fatigue, potentially worsening respiratory function over time.
- It may indicate underlying severe respiratory conditions, requiring prompt assessment and intervention.

### Management:
- **Breathing Exercises**: Techniques to promote proper diaphragmatic breathing and improve coordination can help retrain the breathing pattern.
- **Physical Therapy**: Working with a physical or respiratory therapist to develop strategies for improving breathing efficiency.
- **Addressing Underlying Conditions**: Managing any underlying medical conditions contributing to paradoxical breathing.

In summary, paradoxical breathing is a significant sign that requires evaluation by healthcare professionals to determine the underlying cause and appropriate management strategies.

quickly give me quick assessment of diaphram and other respiratory muscle llike abdominal muscle and intercostal muscles

Here’s a quick assessment overview for the diaphragm and other key respiratory muscles, such as the abdominal and intercostal muscles:

### 1. **Diaphragm Assessment**:
- **Function**: The primary muscle of respiration. It contracts to increase the volume of the thoracic cavity, facilitating inhalation.
- **Assessment**:
  - **Observation**: Assess for abdominal rise during deep breathing (diaphragmatic breathing). A low, flat abdomen during breathing may indicate poor diaphragmatic function.
  - **Palpation**: Feel for movement in the abdomen during inhalation and exhalation.
  - **Technique**: Ask the patient to take a deep breath and observe if the abdomen expands outward (which is normal) versus paradoxical movement (where the abdomen may draw inward).

### 2. **Abdominal Muscles Assessment**:
- **Function**: Assist in forced expiration by increasing intra-abdominal pressure and supporting exhalation.
- **Assessment**:
  - **Observation**: Perform a sniff test (forceful inhalation) and observe the abdominal contraction.
  - **Strength Check**: Ask the patient to perform a simple abdominal contraction (e.g., sit-up) to assess strength and coordination.

### 3. **Intercostal Muscles Assessment**:
- **Function**: Support rib cage movement during inhalation (external intercostals) and forced expiration (internal intercostals).
- **Assessment**:
  - **Observation**: Look for rib cage expansion during deep breaths. Note any use of accessory muscles (shoulders, neck) indicating potential intercostal muscle weakness.
  - **Palpation**: Feel along the intercostal spaces for any tenderness or tightness.
  - **Auscultation**: Listen to breath sounds during inhalation and exhalation; abnormal sounds may indicate dysfunction.

### Procedure for Quick Assessment:
1. **Patient Positioning**: Have the patient in a comfortable seated or supine position.
2. **Instruct the Patient**: Have them breathe normally and then take several deep breaths.
3. **Observe and Palpate**:
   - Watch for diaphragmatic movement, abdominal engagement, and intercostal expansion.
   - Feel for contractions and tension in the abdominal and intercostal areas.

### Summary:
By integrating observation, palpation, and functional movement tests, assess the effectiveness and coordination of the diaphragm, abdominal muscles, and intercostal muscles to determine respiratory function and identify any weaknesses or abnormalities.

So, Intercostal Muscles Assessment: is function when i notice movement of rib cage ? 
 

Yes, that's correct! The assessment of the intercostal muscles primarily involves observing the movement of the rib cage during the breathing cycle. Here’s how you can specifically assess the intercostal muscles through rib cage movement:

### Intercostal Muscles Assessment:

1. **Visual Observation**:
   - **Inhalation**: Watch how the rib cage expands laterally and anteriorly when the patient inhales deeply. Proper functioning of the external intercostal muscles will facilitate this expansion.
   - **Exhalation**: Observe the rib cage as it contracts back to its neutral position during exhalation. If the internal intercostal muscles are functioning well, this should occur gracefully and symmetrically.

2. **Assessing Rib Motion**:
   - **Elevation and Depression**: During inhalation, the ribs should elevate, and during exhalation, they should depress. You want to pay attention to the symmetry and smoothness of these movements.
   - **Use of Accessory Muscles**: Note whether the patient is using any accessory muscles, such as those in the neck or shoulders, to help breathe. Increased reliance on these muscles can indicate weakness in the intercostal muscles.

3. **Palpation of Intercostal Spaces**:
   - **Feel for Movement**: While the patient breathes, you can palpate the intercostal spaces between the ribs to feel for the contraction and movement.
   - **Tenderness or Tension**: Assess for any tightness or tenderness along the intercostal muscles that might suggest strain or dysfunction.

4. **Functional Breathing Test**:
   - **Deep Breathing Exercise**: Ask the patient to take a few deep breaths. Ensure they use their diaphragm to draw air in, but also note the contribution of the intercostal muscles. A proper test would show an expanding rib cage.

### Conclusion:
Overall, monitoring the movement of the rib cage during both inhalation and exhalation provides valuable insights into the functioning of the intercostal muscles. When you observe these movements, you're assessing how effectively these muscles are contributing to the respiratory process.

Entwickel folgende anwendung weiter. Schaue dir das skript dieser softwareentwicklungs-anwendung an. Entwickel die funktionen die innerhalb dieser softwareentwicklungs-anwendung, die erstellt werden soll, benötigt werden weiter. Sorge dafür das auch komplexe aufgaben effizient und mit intelligentem kontext management des darin verwendeten llm´s durchgeführt werden können. Der entwicklungsplan, der innerhalb der anwendung vom llm auf basis einer beschreibung vom nutzer erstellt wird,  soll allumfassende einzelschritte enthalten ,die schrittweise bearbeitet werden und die resultate zusammenfassend optimal gespeichert und zum späteren zeitpunkt erneut sinnvoll verwendet werden. Wenn alle zwischenaufgaben erfolgreich bearbeitet wurden sollen alle erzielten resultate verwendet werden um das vollständige skript der gewünschten anwendung zu erstellen. Dies soll nicht zwingend in einer nachricht geschehen sondern soll wenn es notwendig ist auch in mehreren durchgeführt werden wenn dies sinnvoll ist. Die einstellungen des llm wie zb die kontextgröße und output längen sollen in jeder phase intelligent angepasst werden um eienrseits effizient resultate zu erzielen, wie auch um die vorhandene hardware des nutzers zu berücksichtigen und effizient innerhalb dessen grenzen arbeiten. Nenne mir abschließend das vollständige bearbeitete skript der anwendung mit dessen gesamten code ohne fehlende zeilen.

import sys
import threading
import requests
import json
import logging
import subprocess
import os
import re
import shutil
from datetime import datetime, timedelta
from logging.handlers import RotatingFileHandler

from PyQt5.QtWidgets import (
QApplication, QMainWindow, QLabel, QPushButton, QWidget, QTextEdit,
QScrollArea, QFrame, QProgressBar, QMessageBox, QDialog, QDialogButtonBox,
QVBoxLayout, QHBoxLayout, QComboBox, QGroupBox, QFormLayout, QInputDialog,
QFontDialog, QFileDialog, QPlainTextEdit, QSpinBox, QDoubleSpinBox, QLineEdit
)
from PyQt5.QtCore import (
QTimer, Qt, QThread, pyqtSignal, QSize, QPropertyAnimation, QRect
)
from PyQt5.QtGui import (
QColor, QFont, QPalette, QMovie
)
Logging configuration

BASE_DIR = os.path.dirname(os.path.abspath(file))
logger = logging.getLogger(name)
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
file_handler = RotatingFileHandler(os.path.join(BASE_DIR, "app.log"), maxBytes=510241024, backupCount=3, encoding='utf-8')
file_handler.setFormatter(formatter)
stream_handler = logging.StreamHandler(sys.stdout)
stream_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.addHandler(stream_handler)

class LLMClient:
def init(self, base_url='http://localhost:11434', model_name=''):
self.base_url = base_url.rstrip('/')
self.model_name = model_name
self.cache = {}
self.memory = {}
self.role = 'system_agent' # Default Rolle
self.temperature = 0.7 # Initial temperature

def set_model(self, model_name):
    self.model_name = model_name
    logger.debug(f"LLM-Modell gewechselt zu: {self.model_name}")

def set_role(self, role):
    if role in ['system_agent', 'code_agent']:
        self.role = role
        logger.debug(f"LLM-Rolle gewechselt zu: {self.role}")
    else:
        logger.error(f"Ungültige Rolle: {role}")

def set_temperature(self, temperature):
    self.temperature = temperature
    logger.debug(f"LLM-Temperatur auf {self.temperature} gesetzt.")

def get_models(self):
    try:
        logger.debug("Anfordern der verfügbaren Modelle.")
        response = requests.get(f'{self.base_url}/api/tags', timeout=5)
        if response.status_code == 200:
            models = [model['name'] for model in response.json().get('models', [])]
            logger.debug(f"Verfügbare Modelle: {models}")
            return models
        logger.error(f"Fehler beim Abrufen der Modelle: {response.status_code} - {response.text}")
    except requests.RequestException as e:
        logger.error(f"Fehler bei der Kommunikation mit dem LLM-Server: {e}")
    return []

def generate(self, prompt, temperature=0.7, max_tokens=150):
    if not self.model_name:
        logger.error("Kein LLM-Modell ausgewählt.")
        return "Error: Kein LLM-Modell ausgewählt."
    cache_key = (self.model_name, prompt, temperature, max_tokens)
    if cache_key in self.cache:
        logger.debug("Verwendung des gecachten Ergebnisses.")
        return self.cache[cache_key]
    payload = {
        "model": self.model_name,
        "prompt": prompt,
        "temperature": temperature,
        "max_tokens": max_tokens,
        "format": "json",
        "stream": False
    }
    try:
        logger.debug("Senden der Generierungsanfrage.")
        response = requests.post(
            f'{self.base_url}/api/generate',
            json=payload,
            headers={"Content-Type": "application/json"},
            timeout=60
        )
        if response.status_code == 200:
            result = response.json().get('response', '').strip()
            self.cache[cache_key] = result
            logger.debug("Generierung erfolgreich.")
            return result
        logger.error(f"Generierungsfehler: {response.status_code} - {response.text}")
        return f"Fehler: {response.text}"
    except requests.RequestException as e:
        logger.error(f"LLM-Kommunikationsfehler: {e}")
        return f"Fehler: {e}"

def add_to_memory(self, key, value):
    self.memory[key] = value

def get_from_memory(self, key):
    return self.memory.get(key, '')

class CommandDispatcher:
def init(self, main_window, llm_client):
self.main_window = main_window
self.llm_client = llm_client
# Define critical actions
self.critical_actions = {
'stop_server': 'Das Stoppen des Servers kann alle laufenden Prozesse unterbrechen. Möchten Sie fortfahren?',
'remove_files': 'Das Entfernen von Dateien kann zu Datenverlust führen. Möchten Sie fortfahren?',
'delete_project': 'Das Löschen eines Projekts ist irreversibel. Möchten Sie fortfahren?',
# Weitere kritische Aktionen hier hinzufügen
}

def dispatch(self, command):
    action = command.get('action')
    params = command.get('params', {})
    if not action:
        self.main_window.chat_area_add_message("System", "Unbekanntes Befehlsformat.")
        return

    logger.info(f"Ausführung von Aktion: {action} mit Parametern: {params}")

    # Überprüfen, ob die Aktion kritisch ist
    if action in self.critical_actions:
        confirmation = self.main_window.request_confirmation(self.critical_actions[action])
        if not confirmation:
            self.main_window.chat_area_add_message("System", f"Aktion '{action}' wurde vom Benutzer abgebrochen.")
            logger.info(f"Aktion '{action}' wurde vom Benutzer abgebrochen.")
            return

    actions = {
        'start_server': self.main_window.start_server_command,
        'stop_server': self.main_window.stop_server_command,
        'upload_files': self.main_window.upload_files_command,
        'remove_files': self.main_window.remove_selected_files_command,
        'change_setting': self.main_window.change_setting,
        'save_project': self.main_window.save_project_command,
        'load_project': self.main_window.load_project_command,
        'create_new_project': self.main_window.new_project_command,
        'start_analysis': self.main_window.start_analysis_command,
        'start_processing': self.main_window.start_processing_command,
        'pause_processing': self.main_window.pause_processing_command,
        'resume_processing': self.main_window.resume_processing_command,
        'stop_processing': self.main_window.stop_processing_command,
        'toggle_gantt_chart': self.main_window.toggle_gantt_chart_command,
        'generate_final_report': self.main_window.generate_final_report_command,
        'switch_llm': self.main_window.switch_llm_command,
        'delete_project': self.main_window.delete_project_command,
        # Weitere Aktionen hier hinzufügen
    }

    func = actions.get(action)
    if func:
        try:
            func(**params)
            self.main_window.chat_area_add_message("System", f"Aktion '{action}' erfolgreich ausgeführt.")
            logger.info(f"Aktion '{action}' erfolgreich ausgeführt.")
        except Exception as e:
            self.main_window.chat_area_add_message("System", f"Fehler bei der Ausführung von '{action}': {e}")
            logger.error(f"Fehler bei der Ausführung von '{action}': {e}")
    else:
        self.main_window.chat_area_add_message("System", f"Aktion '{action}' nicht erkannt.")
        logger.warning(f"Aktion '{action}' nicht erkannt.")

class TaskProcessor(QThread):
progress_updated = pyqtSignal(int)
task_message = pyqtSignal(str, str) # Sender, Message
task_result = pyqtSignal(str, str) # Sender, Message
task_status = pyqtSignal(int, int, str) # task_index, goal_index, status

def __init__(self, tasks, llm_client, parent=None):
    super().__init__(parent)
    self.tasks = tasks
    self.llm_client = llm_client
    self._paused = False
    self._stopped = False
    self.max_retries = 3
    self.context_memory = {}

def run(self):
    total_goals = sum(len(task.get('Goals', [])) for task in self.tasks)
    completed_goals = 0
    self.llm_client.set_role('code_agent')  # Wechsel zur Code-Agent-Rolle
    for i, task in enumerate(self.tasks):
        if self._stopped:
            break
        while self._paused:
            self.msleep(100)
        task_title = task.get('Title', f'Task {i + 1}')
        self.task_message.emit("Assistant", f"Starte Aufgabe '{task_title}'")
        self.task_status.emit(i, -1, 'processing')  # -1 für die Aufgabe selbst
        for j, goal in enumerate(task.get('Goals', [])):
            if self._stopped:
                break
            while self._paused:
                self.msleep(100)
            retry, success = 0, False
            while retry < self.max_retries and not success and not self._stopped:
                if retry > 0:
                    self.task_message.emit("Assistant", f"Versuch {retry} für Ziel: {goal['Goal']}")
                    logger.debug(f"Versuch {retry} für Ziel: {goal['Goal']}")
                self.task_message.emit("Assistant", f"Bearbeite Ziel: {goal['Goal']}")
                self.task_status.emit(i, j, 'processing')
                result = self.process_goal(task, goal, retry > 0)
                success = self.self_review(goal, result)
                if success:
                    self.task_result.emit("Assistant", f"Ergebnis für '{goal['Goal']}':\n{result}")
                    self.context_memory[goal['Goal']] = result
                    self.task_status.emit(i, j, 'completed')
                else:
                    self.task_status.emit(i, j, 'error')
                    retry += 1
                    # Optimierungsstrategie: Anpassung der Temperatur
                    if retry == 1:
                        logger.debug(f"Anpassung der Temperatur zur Verbesserung der Ergebnisse für '{goal['Goal']}'.")
                        self.llm_client.set_temperature(min(self.llm_client.temperature + 0.1, 1.0))
            if not success:
                self.task_message.emit("Assistant", f"Ziel '{goal['Goal']}' nach {self.max_retries} Versuchen fehlgeschlagen.")
                # Parallelprozess: Automatische Neufassung des Prompts
                self.task_message.emit("Assistant", f"Versuche, das Ziel '{goal['Goal']}' mit angepasstem Prompt erneut zu bearbeiten.")
                adjusted_result = self.adjust_goal_prompt(task, goal)
                success = self.self_review(goal, adjusted_result)
                if success:
                    self.task_result.emit("Assistant", f"Angepasstes Ergebnis für '{goal['Goal']}':\n{adjusted_result}")
                    self.context_memory[goal['Goal']] = adjusted_result
                    self.task_status.emit(i, j, 'completed')
                else:
                    self.task_status.emit(i, j, 'failed')
            completed_goals += 1
            self.progress_updated.emit(int((completed_goals / total_goals) * 100))
        self.task_status.emit(i, -1, 'completed')  # Abgeschlossenes Task
        summary = self.create_task_summary(task)
        self.task_result.emit("Assistant", f"Zusammenfassung für '{task_title}':\n{summary}")
        self.context_memory[task_title] = summary
    if not self._stopped:
        self.task_message.emit("Assistant", "Alle Aufgaben abgeschlossen.")
        final = self.generate_final_result()
        self.task_result.emit("Assistant", f"Endergebnis:\n{final}")
    self.llm_client.set_role('system_agent')  # Rückwechsel zur System-Agent-Rolle

def process_goal(self, task, goal, retry=False):
    context = self.get_relevant_context(goal['Goal'])
    prompt = f"""

Als erfahrener Softwarearchitekt erstellen Sie eine detaillierte Lösung für das Ziel: {goal['Goal']}

Beschreibung:
{task.get('ApplicationDescription', '')}

Kontext:
{context}

Verwenden Sie klare Sprache und Codebeispiele, wo es angebracht ist.
"""
logger.debug(f"Generiere für '{goal['Goal']}'.")
return self.llm_client.generate(prompt, temperature=self.llm_client.temperature, max_tokens=150)

def self_review(self, goal, result):
    prompt = f"""

Überprüfen Sie das Ergebnis für "{goal['Goal']}":

{result}

Ist es vollständig und korrekt? Antworten Sie mit "Ja" oder "Nein".
"""
review = self.llm_client.generate(prompt, temperature=0.5, max_tokens=10)
logger.debug(f"Selbstüberprüfung für '{goal['Goal']}': {review}")
if "Ja" in review:
return True
self.task_message.emit("Assistant", f"Überprüfung für '{goal['Goal']}' fehlgeschlagen: {review}")
return False

def get_relevant_context(self, current_goal):
    return "\n".join(f"**{k}:**\n{v}" for k, v in self.context_memory.items())

def create_task_summary(self, task):
    return "\n".join(f"{g['Goal']}:\n{self.context_memory.get(g['Goal'], '')}" for g in task.get('Goals', []))

def generate_final_result(self):
    context = "\n".join(self.context_memory.values())
    prompt = f"""

Fassen Sie alle Ergebnisse zusammen und erstellen Sie den vollständigen Anwendungscode mit Dokumentation.

Kontext:
{context}
"""
logger.debug("Generiere Endergebnis.")
return self.llm_client.generate(prompt, temperature=self.llm_client.temperature, max_tokens=500)

def adjust_goal_prompt(self, task, goal):
    """
    Anpassung des Prompts zur besseren Bearbeitung des Ziels nach einem Fehler.
    """
    context = self.get_relevant_context(goal['Goal'])
    prompt = f"""

Als erfahrener Softwarearchitekt erstellen Sie eine verbesserte Lösung für das Ziel: {goal['Goal']}

Beschreibung:
{task.get('ApplicationDescription', '')}

Kontext:
{context}

Basierend auf den bisherigen Ergebnissen, optimieren Sie die Lösung.
Verwenden Sie klare Sprache und Codebeispiele, wo es angebracht ist.
"""
logger.debug(f"Angepasster Prompt für '{goal['Goal']}'.")
return self.llm_client.generate(prompt, temperature=0.8, max_tokens=200)

def pause(self):
    self._paused = True
    logger.debug("TaskProcessor pausiert.")

def resume(self):
    self._paused = False
    logger.debug("TaskProcessor fortgesetzt.")

def stop(self):
    self._stopped = True
    logger.debug("TaskProcessor gestoppt.")

class ThoughtCloudWidget(QWidget):
def init(self, parent=None):
super().init(parent)
self.setFixedSize(200, 200)
self.setStyleSheet("background-color: rgba(255, 255, 255, 100); border-radius: 100px;")
self.label = QLabel("", self)
self.label.setStyleSheet("color: #2e2e2e; font-size: 12pt;")
self.label.setAlignment(Qt.AlignCenter)
self.label.setWordWrap(True)
self.label.resize(self.size())
self.hide()

    # Animation für die Anzeige der Thought Cloud
    self.animation = QPropertyAnimation(self, b"geometry")
    self.animation.setDuration(500)

def display_message(self, message):
    self.label.setText(message)
    self.show()
    self.raise_()
    self.animate_show()

def animate_show(self):
    start_rect = QRect(self.x(), self.y() - 50, self.width(), self.height())
    end_rect = QRect(self.x(), self.y(), self.width(), self.height())
    self.animation.stop()
    self.animation.setStartValue(start_rect)
    self.animation.setEndValue(end_rect)
    self.animation.start()

def clear_message(self):
    self.label.setText("")
    self.hide()

class MessageWidget(QFrame):
def init(self, sender, message, parent=None):
super().init(parent)
self.sender, self.message = sender, message
self.init_ui()

def init_ui(self):
    layout = QVBoxLayout(self)
    self.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
    self.setLineWidth(0)
    if self.sender.lower() == "assistant":
        color = "#2e2e2e"
    elif self.sender.lower() == "system":
        color = "#555555"
    else:
        color = "#0078d7"  # Benutzer-Nachrichten in Blau
    self.setStyleSheet(f"""
        QFrame {{
            background-color: {color};
            border-radius: 10px;
            padding: 10px;
        }}
    """)
    sender_label = QLabel(f"<b>{self.sender}:</b>")
    sender_label.setStyleSheet("color: #fff;")
    layout.addWidget(sender_label)
    for part in self.parse_message(self.message):
        if part['type'] == 'text':
            lbl = QLabel(part['content'])
            lbl.setStyleSheet("color: #dcdcdc;")
            lbl.setWordWrap(True)
            lbl.setFont(QFont("Arial", 12))
            layout.addWidget(lbl)
        elif part['type'] == 'code':
            code = QPlainTextEdit(part['content'])
            code.setReadOnly(True)
            code.setStyleSheet("""
                QPlainTextEdit {
                    background-color: #1e1e1e;
                    color: #f8f8f2;
                    border: 1px solid #555;
                    border-radius: 4px;
                    font-family: Consolas, monospace;
                    padding: 5px;
                    font-size: 12pt;
                }
            """)
            layout.addWidget(code)
        elif part['type'] == 'link':
            link = QLabel(f'<a href="{part["url"]}">{part["content"]}</a>')
            link.setStyleSheet("color: #3498db;")
            link.setOpenExternalLinks(True)
            layout.addWidget(link)
    self.setLayout(layout)

def parse_message(self, msg):
    # Regex zum Finden von Codeblöcken und Links
    pattern = re.compile(r'```(.*?)```|https?://\S+')
    parts, last = [], 0
    for m in pattern.finditer(msg):
        if m.start() > last:
            text = msg[last:m.start()]
            parts.append({'type': 'text', 'content': self.highlight_keywords(text)})
        if m.group(1):
            parts.append({'type': 'code', 'content': m.group(1).strip()})
        else:
            url = m.group()
            parts.append({'type': 'link', 'content': url, 'url': url})
        last = m.end()
    if last < len(msg):
        parts.append({'type': 'text', 'content': self.highlight_keywords(msg[last:])})
    return parts

def highlight_keywords(self, text):
    # Hervorheben von Schlüsselwörtern in Blau (z.B. Befehle)
    keywords = ['start_server', 'stop_server', 'upload_files', 'remove_files',
                'change_setting', 'save_project', 'load_project', 'create_new_project',
                'start_analysis', 'start_processing', 'pause_processing', 'resume_processing',
                'stop_processing', 'toggle_gantt_chart', 'generate_final_report', 'switch_llm',
                'delete_project']
    for kw in keywords:
        pattern = re.compile(r'\b' + re.escape(kw) + r'\b')
        text = pattern.sub(f'<span style="color:#3498db;">{kw}</span>', text)
    return text

class ChatInputWidget(QWidget):
send_message = pyqtSignal(str)

def __init__(self, parent=None):
    super().__init__(parent)
    layout = QHBoxLayout(self)
    self.input_field = QTextEdit()
    self.input_field.setFixedHeight(60)
    self.input_field.setStyleSheet("""
        QTextEdit {
            background-color: #2b2b2b;
            color: #dcdcdc;
            border: 1px solid #555;
            border-radius: 4px;
            padding: 5px;
            font-size: 12pt;
        }
    """)
    self.input_field.setPlaceholderText("Geben Sie Ihre Nachricht hier ein...")
    self.send_button = QPushButton("Senden")
    self.send_button.setStyleSheet("""
        QPushButton {
            background-color: #5cb85c;
            color: #fff;
            border: none;
            border-radius: 4px;
            padding: 15px 25px;
            font-size: 12pt;
        }
        QPushButton:hover {
            background-color: #4cae4c;
        }
    """)
    self.send_button.clicked.connect(self.emit_message)
    layout.addWidget(self.input_field)
    layout.addWidget(self.send_button)
    layout.setContentsMargins(0, 0, 0, 0)
    self.setLayout(layout)

def emit_message(self):
    message = self.input_field.toPlainText().strip()
    if message:
        self.send_message.emit(message)
        self.input_field.clear()

class GanttChartWidget(QWidget):
STATUS_COLORS = {
'pending': '#5bc0de', # Blau für ausstehende Aufgaben
'processing': '#f0ad4e', # Orange für laufende Aufgaben
'completed': '#5cb85c', # Grün für abgeschlossene Aufgaben
'error': '#d9534f', # Rot für Fehler
'failed': '#6c757d' # Grau für fehlgeschlagene Aufgaben
}

def __init__(self, plan_data, parent=None):
    super().__init__(parent)
    self.plan_data = plan_data
    layout = QVBoxLayout(self)
    label = QLabel("Entwicklungsplan Zeitachse")
    label.setStyleSheet("font-size: 16pt; font-weight: bold; color: #fff;")
    layout.addWidget(label)
    try:
        from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
        from matplotlib.figure import Figure
        self.figure = Figure(figsize=(10, 8))
        self.canvas = FigureCanvas(self.figure)
        layout.addWidget(self.canvas)
        self.ax = self.figure.add_subplot(111)
        self.draw_gantt_chart()
    except ImportError:
        logger.error("Matplotlib nicht installiert.")
        error_label = QLabel("Matplotlib ist nicht installiert. Gantt-Diagramm kann nicht angezeigt werden.")
        error_label.setStyleSheet("color: red;")
        layout.addWidget(error_label)
    self.setLayout(layout)

def update_chart(self, plan_data):
    self.plan_data = plan_data
    self.draw_gantt_chart()

def draw_gantt_chart(self):
    try:
        from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
        from matplotlib.figure import Figure
        import matplotlib.dates as mdates
        from matplotlib.dates import date2num

        self.ax.clear()

        if not self.plan_data:
            self.ax.text(0.5, 0.5, 'Keine Daten zum Anzeigen', ha='center', va='center', transform=self.ax.transAxes, color='white')
        else:
            start_date = datetime.now()
            task_labels = []
            bar_positions = []
            bar_widths = []
            colors = []
            y_ticks = []
            y_labels = []
            y = 0

            for task in self.plan_data:
                for goal in task.get('Goals', []):
                    goal_title = goal['Goal']
                    task_labels.append(goal_title)
                    y_ticks.append(y)
                    y_labels.append(f"{task['Title']} - {goal_title}")
                    bar_positions.append(date2num(start_date))
                    bar_widths.append(1)  # 1 Tag Dauer
                    status = goal.get('Status', 'pending')
                    colors.append(self.STATUS_COLORS.get(status, '#5bc0de'))
                    y += 1

            # Plotting
            self.ax.barh(
                y=y_ticks,
                width=bar_widths,
                left=bar_positions,
                height=0.4,
                color=colors,
                align='center'
            )

            self.ax.set_yticks(y_ticks)
            self.ax.set_yticklabels(y_labels, color='white', fontsize=8)
            self.ax.set_xlabel('Datum', color='white')
            self.ax.set_title('Gantt-Diagramm', color='white')

            self.ax.xaxis_date()
            self.ax.xaxis.set_major_locator(mdates.DayLocator())
            self.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d.%m'))

            for spine in self.ax.spines.values():
                spine.set_edgecolor('white')

            self.ax.tick_params(axis='x', colors='white')
            self.ax.tick_params(axis='y', colors='white')

            self.ax.set_facecolor('#1e1e1e')
            self.figure.autofmt_xdate()

        self.canvas.draw()
    except Exception as e:
        logger.error(f"Fehler beim Zeichnen des Gantt-Diagramms: {e}")

class DetailChatArea(QScrollArea):
def init(self, parent=None):
super().init(parent)
self.setStyleSheet("""
QScrollArea { background-color: #1e1e1e; border: none; }
QScrollBar:vertical { background-color: #2b2b2b; width: 12px; }
QScrollBar::handle:vertical { background-color: #555; min-height: 20px; border-radius: 6px; }
QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
QScrollBar::up-arrow:vertical, QScrollBar::down-arrow:vertical { background: none; }
""")
self.chat_container = QWidget()
self.chat_layout = QVBoxLayout(self.chat_container)
self.chat_layout.setAlignment(Qt.AlignTop)
self.setWidgetResizable(True)
self.setWidget(self.chat_container)

def add_message(self, sender, message):
    msg = MessageWidget(sender, message)
    self.chat_layout.addWidget(msg)
    QTimer.singleShot(100, lambda: self.verticalScrollBar().setValue(
        self.verticalScrollBar().maximum()))

class MainWindow(QMainWindow):
def init(self):
super().init()
self.setWindowTitle('Intelligenter Assistent für Entwickler')
self.setGeometry(100, 100, 1200, 800) # Größeres Fenster für mehr Platz
self.settings = {
'available_models': [],
'selected_model': '',
'temperature': 0.7,
'max_tokens': 150,
'server_url': 'http://localhost',
'server_port': 11434,
'theme': 'Dark',
'font': QFont("Arial", 10),
'projects': [],
'last_used_project': None
}
self.load_projects()
self.llm_client = LLMClient(
base_url=f"{self.settings['server_url']}:{self.settings['server_port']}",
model_name=self.settings.get('selected_model', '')
)
self.command_dispatcher = CommandDispatcher(self, self.llm_client)
self.plan_data, self.uploaded_files = [], []
self.server_process = None
self.task_processor = None
self.init_ui()
self.apply_styles()
self.update_server_status()
self.initialize_chat()

def load_projects(self):
    # Projekte aus einer JSON-Datei laden
    projects_file = os.path.join(BASE_DIR, 'projects.json')
    if os.path.exists(projects_file):
        try:
            with open(projects_file, 'r', encoding='utf-8') as f:
                data = json.load(f)
                self.settings['projects'] = data.get('projects', [])
                self.settings['last_used_project'] = data.get('last_used_project')
            logger.debug("Projekte erfolgreich geladen.")
        except Exception as e:
            logger.error(f"Fehler beim Laden der Projekte: {e}")
            self.settings['projects'] = []
            self.settings['last_used_project'] = None
    else:
        self.settings['projects'] = []
        self.settings['last_used_project'] = None

def save_projects(self):
    # Projekte in einer JSON-Datei speichern
    projects_file = os.path.join(BASE_DIR, 'projects.json')
    data = {
        'projects': self.settings['projects'],
        'last_used_project': self.settings['last_used_project']
    }
    try:
        with open(projects_file, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=4)
        logger.debug("Projekte erfolgreich gespeichert.")
    except Exception as e:
        logger.error(f"Fehler beim Speichern der Projekte: {e}")

def init_ui(self):
    central_widget = QWidget()
    main_layout = QVBoxLayout()

    # Top Layout für Thought Clouds und Gantt Diagramm
    top_layout = QHBoxLayout()

    # Thought Cloud Widget
    self.thought_cloud = ThoughtCloudWidget()
    top_layout.addWidget(self.thought_cloud, alignment=Qt.AlignRight | Qt.AlignTop)

    # Gantt Diagramm Platzhalter
    self.gantt_chart = GanttChartWidget(self.plan_data)
    self.gantt_chart.setVisible(False)  # Anfangs versteckt
    top_layout.addWidget(self.gantt_chart, stretch=1)

    # Zwei Chat Bereiche: Hauptchat und Detailchat
    chat_layout = QHBoxLayout()

    # Hauptchat Bereich
    self.chat_area = QScrollArea()
    self.chat_area.setStyleSheet("""
        QScrollArea { background-color: #1e1e1e; border: none; }
        QScrollBar:vertical { background-color: #2b2b2b; width: 12px; }
        QScrollBar::handle:vertical { background-color: #555; min-height: 20px; border-radius: 6px; }
        QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
        QScrollBar::up-arrow:vertical, QScrollBar::down-arrow:vertical { background: none; }
    """)
    self.chat_container = QWidget()
    self.chat_layout = QVBoxLayout(self.chat_container)
    self.chat_layout.setAlignment(Qt.AlignTop)
    self.chat_area.setWidgetResizable(True)
    self.chat_area.setWidget(self.chat_container)

    # Detailchat Bereich (schreibgeschützt)
    self.detail_chat_area = DetailChatArea()
    self.detail_chat_area.setFixedWidth(400)  # Feste Breite für Detailchat

    chat_layout.addWidget(self.chat_area, stretch=2)
    chat_layout.addWidget(self.detail_chat_area, stretch=1)

    # Loading Animation
    self.loading_label = QLabel()
    self.loading_label.setAlignment(Qt.AlignCenter)
    loading_gif = os.path.join(BASE_DIR, "loading.gif")
    if os.path.exists(loading_gif):
        self.loading_movie = QMovie(loading_gif)
        if self.loading_movie.isValid():
            self.loading_label.setMovie(self.loading_movie)
            self.loading_movie.start()
        else:
            self.loading_label.setText("Loading...")
    else:
        self.loading_label.setText("Loading...")
    self.loading_label.setVisible(False)

    # Chat Eingabe
    self.chat_input = ChatInputWidget()
    self.chat_input.send_message.connect(self.handle_user_message)

    # Fortschrittsbalken
    self.progress_bar = QProgressBar()
    self.progress_bar.setValue(0)
    self.progress_bar.setAlignment(Qt.AlignCenter)
    self.progress_bar.setStyleSheet("""
        QProgressBar {
            border: 1px solid #555;
            border-radius: 5px;
            text-align: center;
            height: 20px;
            background-color: #2b2b2b;
            color: #fff;
            font-size: 12pt;
        }
        QProgressBar::chunk { background-color: #5bc0de; width: 20px; }
    """)

    # Menüleiste
    self.init_menu()

    main_layout.addLayout(top_layout)
    main_layout.addLayout(chat_layout, stretch=3)
    main_layout.addWidget(self.loading_label)
    main_layout.addWidget(self.progress_bar)
    main_layout.addWidget(self.chat_input)
    main_layout.setStretch(0, 0)  # Top Layout dehnt sich nicht aus
    main_layout.setStretch(1, 3)  # Chat Bereich dehnt sich mehr aus
    main_layout.setStretch(2, 0)  # Loading Label dehnt sich nicht aus
    main_layout.setStretch(3, 0)  # Fortschrittsbalken dehnt sich nicht aus
    main_layout.setStretch(4, 0)  # Chat Eingabe dehnt sich nicht aus
    central_widget.setLayout(main_layout)
    self.setCentralWidget(central_widget)

def init_menu(self):
    menubar = self.menuBar()

    # Datei-Menü
    file_menu = menubar.addMenu('&Datei')

    new_proj_action = file_menu.addAction('Neues Projekt')
    new_proj_action.triggered.connect(self.new_project_command)

    save_proj_action = file_menu.addAction('Projekt speichern')
    save_proj_action.triggered.connect(self.save_project_command)

    load_proj_action = file_menu.addAction('Projekt laden')
    load_proj_action.triggered.connect(self.load_project_command)

    delete_proj_action = file_menu.addAction('Projekt löschen')
    delete_proj_action.triggered.connect(self.delete_project_command)

    file_menu.addSeparator()

    exit_action = file_menu.addAction('Beenden')
    exit_action.triggered.connect(self.close)

    # Einstellungen-Menü
    settings_menu = menubar.addMenu('&Einstellungen')

    open_settings_action = settings_menu.addAction('Einstellungen öffnen')
    open_settings_action.triggered.connect(self.open_settings_dialog_command)

    switch_llm_action = settings_menu.addAction('LLM wechseln')
    switch_llm_action.triggered.connect(self.switch_llm_command)

    # Hilfe-Menü
    help_menu = menubar.addMenu('&Hilfe')

    about_action = help_menu.addAction('Über')
    about_action.triggered.connect(self.show_about_dialog)

def initialize_chat(self):
    # Initialer Prompt an LLM zur Generierung einer Willkommensnachricht
    prompt = """

Sie sind ein intelligenter Assistent, der Nutzern hilft, ihre Entwicklungsprojekte zu verwalten.
Begrüßen Sie den Benutzer und bieten Sie Hilfe an.
"""
response = self.llm_client.generate(prompt, temperature=self.settings['temperature'], max_tokens=150)
self.chat_area_add_message("Assistent", response)
self.detail_chat_area.add_message("Assistent", response)

def handle_user_message(self, message):
    self.chat_area_add_message("Benutzer", message)
    self.detail_chat_area.add_message("Benutzer", message)
    self.loading_label.setVisible(True)
    threading.Thread(target=self.process_message, args=(message,), daemon=True).start()

def process_message(self, message):
    # Konstruktion des Prompts zur Anweisung des LLM
    prompt = f"""

Sie sind ein intelligenter Assistent, der Nutzern hilft, ihre Entwicklungsprojekte zu verwalten.
Sie können Aktionen wie start_server, stop_server, upload_files, remove_files, change_setting,
save_project, load_project, create_new_project, start_analysis, start_processing,
pause_processing, resume_processing, stop_processing, toggle_gantt_chart, generate_final_report, switch_llm, delete_project ausführen.

Wenn eine Benutzeranfrage eine Aktion erfordert, antworten Sie mit einem JSON-Objekt:
{{"action": "action_name", "params": {{...}}}}

Andernfalls antworten Sie mit einer hilfreichen Nachricht.

Benutzeranfrage: "{message}"
"""
response = self.llm_client.generate(prompt, temperature=self.settings['temperature'], max_tokens=self.settings['max_tokens'])
self.loading_label.setVisible(False)
try:
# Versuch, die Antwort als JSON zu parsen
command = json.loads(response)
if isinstance(command, dict) and 'action' in command:
self.command_dispatcher.dispatch(command)
# Thought Cloud anzeigen
self.thought_cloud.display_message(f"Aktion '{command['action']}' wird ausgeführt...")
QTimer.singleShot(3000, self.thought_cloud.clear_message)
else:
# Wenn keine Aktion, als normale Nachricht behandeln
self.chat_area_add_message("Assistent", response)
self.detail_chat_area.add_message("Assistent", response)
# Thought Cloud mit der Antwort anzeigen
self.thought_cloud.display_message("Neue Information vom Assistenten.")
QTimer.singleShot(3000, self.thought_cloud.clear_message)
except json.JSONDecodeError:
# Falls Parsing fehlschlägt, als normale Nachricht behandeln
self.chat_area_add_message("Assistent", response)
self.detail_chat_area.add_message("Assistent", response)
# Thought Cloud mit der Antwort anzeigen
self.thought_cloud.display_message("Neue Information vom Assistenten.")
QTimer.singleShot(3000, self.thought_cloud.clear_message)

def chat_area_add_message(self, sender, message):
    msg = MessageWidget(sender, message)
    self.chat_layout.addWidget(msg)
    QTimer.singleShot(100, lambda: self.chat_area.verticalScrollBar().setValue(
        self.chat_area.verticalScrollBar().maximum()))
    if sender not in ["Benutzer", "System"]:
        self.detail_chat_area.add_message(sender, message)

def switch_llm_command(self, **kwargs):
    # Dialog zum Wechseln des LLMs
    dlg = SwitchLLMDialog(self.settings, self)
    if dlg.exec_() == QDialog.Accepted:
        selected_llm = dlg.selected_llm
        if selected_llm in self.settings['available_models']:
            self.llm_client.set_model(selected_llm)
            self.command_dispatcher.llm_client = self.llm_client
            logger.debug(f"Aktives LLM zu {selected_llm} gewechselt.")
            self.chat_area_add_message("System", f"Aktives LLM wurde zu {selected_llm} gewechselt.")
            self.detail_chat_area.add_message("System", f"Aktives LLM wurde zu {selected_llm} gewechselt.")
        else:
            self.chat_area_add_message("System", "Ungültige LLM-Auswahl.")
            logger.warning("Ungültige LLM-Auswahl getroffen.")

def start_server_command(self, **kwargs):
    self.start_server()

def stop_server_command(self, **kwargs):
    self.stop_server()

def upload_files_command(self, **kwargs):
    # Erwartet 'files' Parameter als Liste von Dateipfaden
    files = kwargs.get('files', [])
    if files:
        accessible_files = [f for f in files if os.path.isfile(f)]
        if accessible_files:
            self.uploaded_files.extend(accessible_files)
            self.display_uploaded_files()
            self.chat_area_add_message("System", f"{len(accessible_files)} Datei(en) über Befehl hochgeladen.")
            self.detail_chat_area.add_message("System", f"{len(accessible_files)} Datei(en) über Befehl hochgeladen.")
            logger.debug(f"Hochgeladene Dateien über Befehl: {accessible_files}")
        else:
            self.chat_area_add_message("System", "Keine gültigen Dateien zum Hochladen bereitgestellt.")
            self.detail_chat_area.add_message("System", "Keine gültigen Dateien zum Hochladen bereitgestellt.")
    else:
        self.chat_area_add_message("System", "Keine Dateien für den Upload bereitgestellt.")
        self.detail_chat_area.add_message("System", "Keine Dateien für den Upload bereitgestellt.")

def remove_selected_files_command(self, **kwargs):
    # Erwartet 'files' Parameter als Liste von zu entfernenden Dateipfaden
    files = kwargs.get('files', [])
    if files:
        removed = [f for f in files if f in self.uploaded_files]
        for f in removed:
            self.uploaded_files.remove(f)
        self.display_uploaded_files()
        self.chat_area_add_message("System", f"{len(removed)} Datei(en) über Befehl entfernt.")
        self.detail_chat_area.add_message("System", f"{len(removed)} Datei(en) über Befehl entfernt.")
        logger.debug(f"Entfernte Dateien über Befehl: {removed}")
    else:
        self.chat_area_add_message("System", "Keine Dateien für die Entfernung bereitgestellt.")
        self.detail_chat_area.add_message("System", "Keine Dateien für die Entfernung bereitgestellt.")

def change_setting(self, **kwargs):
    # Erwartet 'setting' und 'value' Parameter
    setting = kwargs.get('setting')
    value = kwargs.get('value')
    if setting and value is not None:
        if setting in self.settings:
            self.settings[setting] = value
            if setting == 'selected_model':
                self.llm_client.set_model(value)
            elif setting == 'temperature':
                self.llm_client.set_temperature(value)
            self.apply_styles()
            self.chat_area_add_message("System", f"Einstellung '{setting}' auf '{value}' geändert.")
            self.detail_chat_area.add_message("System", f"Einstellung '{setting}' auf '{value}' geändert.")
            logger.debug(f"Einstellung '{setting}' auf '{value}' geändert.")
        else:
            self.chat_area_add_message("System", f"Einstellung '{setting}' existiert nicht.")
            logger.warning(f"Versuch, nicht vorhandene Einstellung '{setting}' zu ändern.")
    else:
        self.chat_area_add_message("System", "Ungültige Parameter zum Ändern der Einstellungen.")
        logger.warning("Ungültige Parameter zum Ändern der Einstellungen.")

def save_project_command(self, **kwargs):
    self.save_project()

def load_project_command(self, **kwargs):
    self.load_project()

def new_project_command(self, **kwargs):
    self.new_project()

def delete_project_command(self, **kwargs):
    self.delete_project()

def start_analysis_command(self, **kwargs):
    # Diese Funktion sammelt typischerweise die Beschreibung und startet die Analyse
    description, ok = QInputDialog.getText(self, "Projektbeschreibung", "Geben Sie die Projektbeschreibung ein:")
    if ok and description:
        self.settings['description_text'] = description  # Speichern der Beschreibung
        # Analyse starten
        self.chat_area_add_message("System", "Analyse des Projekts gestartet.")
        self.detail_chat_area.add_message("System", "Analyse des Projekts gestartet.")
        logger.debug("Projektbeschreibung eingegeben und Analyse gestartet.")
        # Beispiel: Generieren eines Entwicklungsplans basierend auf der Beschreibung
        prompt = f"""

Auf Basis der folgenden Beschreibung erstellen Sie einen detaillierten Entwicklungsplan.

Beschreibung:
{description}
"""
plan_response = self.llm_client.generate(prompt, temperature=self.settings['temperature'], max_tokens=500)
try:
self.plan_data = json.loads(plan_response)
self.chat_area_add_message("System", "Entwicklungsplan erstellt.")
self.detail_chat_area.add_message("System", "Entwicklungsplan erstellt.")
logger.debug("Entwicklungsplan erstellt.")
# Aktualisiere Gantt-Diagramm
self.gantt_chart.update_chart(self.plan_data)
self.gantt_chart.setVisible(True)
except json.JSONDecodeError:
# Falls die Antwort kein gültiger JSON ist, verwende Standard
self.plan_data = []
self.chat_area_add_message("System", "Entwicklungsplan erstellt (Standardplan).")
self.detail_chat_area.add_message("System", "Entwicklungsplan erstellt (Standardplan).")
logger.debug("Standard-Entwicklungsplan verwendet.")
# Beispiel: Standardplan definieren
self.plan_data = [
{
'Title': 'Initiale Planung',
'Goals': [{'Goal': 'Anforderungen sammeln'}, {'Goal': 'Projektstruktur aufbauen'}]
},
{
'Title': 'Entwicklung',
'Goals': [{'Goal': 'Modul A entwickeln'}, {'Goal': 'Modul B entwickeln'}]
}
]
# Aktualisiere Gantt-Diagramm
self.gantt_chart.update_chart(self.plan_data)
self.gantt_chart.setVisible(True)
elif ok:
self.chat_area_add_message("System", "Projektbeschreibung darf nicht leer sein.")
self.detail_chat_area.add_message("System", "Projektbeschreibung darf nicht leer sein.")
logger.warning("Analyse ohne Beschreibung angefragt.")

def start_processing_command(self, **kwargs):
    self.start_processing()

def start_processing(self):
    if not self.plan_data:
        self.chat_area_add_message("System", "Kein Entwicklungsplan verfügbar. Bitte zuerst Analyse starten.")
        logger.warning("Verarbeitung ohne Entwicklungsplan gestartet.")
        return
    if not self.llm_client.model_name:
        self.chat_area_add_message("System", "Kein LLM ausgewählt. Bitte Modell über Einstellungen wählen.")
        logger.warning("Verarbeitung ohne LLM-Auswahl gestartet.")
        return
    self.chat_area_add_message("System", "Verarbeitung der Aufgaben gestartet...")
    self.detail_chat_area.add_message("System", "Verarbeitung der Aufgaben gestartet...")
    self.task_processor = TaskProcessor(self.plan_data, self.llm_client)
    self.task_processor.progress_updated.connect(self.update_progress)
    self.task_processor.task_message.connect(self.chat_area_add_message)
    self.task_processor.task_result.connect(self.chat_area_add_message)
    self.task_processor.task_status.connect(self.update_task_status)
    self.task_processor.finished.connect(self.processing_finished)
    self.task_processor.start()
    logger.debug("Task-Verarbeitung gestartet.")

def pause_processing_command(self, **kwargs):
    self.pause_processing()

def pause_processing(self):
    if hasattr(self, 'task_processor') and self.task_processor.isRunning():
        self.task_processor.pause()
        self.chat_area_add_message("System", "Verarbeitung pausiert.")
        self.detail_chat_area.add_message("System", "Verarbeitung pausiert.")
        logger.debug("Verarbeitung pausiert.")
    else:
        self.chat_area_add_message("System", "Keine laufende Verarbeitung zum Pausieren.")
        self.detail_chat_area.add_message("System", "Keine laufende Verarbeitung zum Pausieren.")
        logger.info("Pause-Verarbeitung ohne aktive Prozesse angefragt.")

def resume_processing_command(self, **kwargs):
    self.resume_processing()

def resume_processing(self):
    if hasattr(self, 'task_processor') and self.task_processor.isRunning():
        self.task_processor.resume()
        self.chat_area_add_message("System", "Verarbeitung fortgesetzt.")
        self.detail_chat_area.add_message("System", "Verarbeitung fortgesetzt.")
        logger.debug("Verarbeitung fortgesetzt.")
    else:
        self.chat_area_add_message("System", "Keine pausierte Verarbeitung zum Fortsetzen.")
        self.detail_chat_area.add_message("System", "Keine pausierte Verarbeitung zum Fortsetzen.")
        logger.info("Fortsetzen-Verarbeitung ohne pausierte Prozesse angefragt.")

def stop_processing_command(self, **kwargs):
    self.stop_processing()

def stop_processing(self):
    if hasattr(self, 'task_processor') and self.task_processor.isRunning():
        self.task_processor.stop()
        self.task_processor.wait()
        self.chat_area_add_message("System", "Verarbeitung gestoppt.")
        self.detail_chat_area.add_message("System", "Verarbeitung gestoppt.")
        self.progress_bar.setValue(0)
        self.loading_label.setVisible(False)
        logger.debug("Verarbeitung gestoppt.")
    else:
        self.chat_area_add_message("System", "Keine laufende Verarbeitung zum Stoppen.")
        self.detail_chat_area.add_message("System", "Keine laufende Verarbeitung zum Stoppen.")
        logger.info("Stop-Verarbeitung ohne aktive Prozesse angefragt.")

def toggle_gantt_chart_command(self, **kwargs):
    self.toggle_gantt_chart()

def toggle_gantt_chart(self):
    self.gantt_chart.setVisible(not self.gantt_chart.isVisible())
    state = "aktiviert" if self.gantt_chart.isVisible() else "deaktiviert"
    self.chat_area_add_message("System", f"Gantt-Diagramm Anzeige {state}.")
    self.detail_chat_area.add_message("System", f"Gantt-Diagramm Anzeige {state}.")
    logger.debug(f"Gantt-Diagramm Anzeige {state}.")

def generate_final_report_command(self, **kwargs):
    self.generate_final_report()

def generate_final_report(self):
    if hasattr(self, 'task_processor') and hasattr(self.task_processor, 'generate_final_result'):
        final = self.task_processor.generate_final_result()
        self.chat_area_add_message("Assistent", final)
        self.detail_chat_area.add_message("Assistent", final)
        # Thought Cloud anzeigen
        self.thought_cloud.display_message("Abschlussbericht generiert.")
        QTimer.singleShot(5000, self.thought_cloud.clear_message)
    else:
        self.chat_area_add_message("System", "Kein Abschlussbericht verfügbar. Bitte zuerst Verarbeitung starten.")
        self.detail_chat_area.add_message("System", "Kein Abschlussbericht verfügbar. Bitte zuerst Verarbeitung starten.")
        logger.warning("Abschlussbericht ohne aktiven TaskProcessor angefragt.")

def open_settings_dialog_command(self, **kwargs):
    self.open_settings_dialog()

def open_settings_dialog(self):
    dlg = SettingsDialog(self.settings, self)
    if dlg.exec_() == QDialog.Accepted:
        self.settings = dlg.settings
        self.apply_styles()
        # Aktualisiere LLMClient base_url korrekt mit server_port
        self.llm_client.base_url = f"{self.settings['server_url'].rstrip(':')}" \
                                   f":{self.settings['server_port']}"
        self.update_server_status()
        self.chat_area_add_message("System", "Einstellungen erfolgreich aktualisiert.")
        self.detail_chat_area.add_message("System", "Einstellungen erfolgreich aktualisiert.")
        # Aktualisiere die Temperatur im LLMClient
        self.llm_client.set_temperature(self.settings.get('temperature', 0.7))
        # Aktualisiere LLM-Modelle bei Änderung
        self.update_llm_list()

def show_about_dialog(self):
    QMessageBox.about(self, "Über", "Intelligenter Assistent für Entwickler\nVersion 2.6\n\nEntwickelt, um Entwicklern bei der Erstellung umfassender Entwicklungspläne und Skripte mit Hilfe von LLMs zu unterstützen.")

def closeEvent(self, event):
    reply = QMessageBox.question(self, 'Bestätigen', 'Möchten Sie die Anwendung wirklich beenden?', QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
    if reply == QMessageBox.Yes:
        if self.server_process and self.server_process.poll() is None:
            try:
                self.server_process.terminate()
                self.server_process.wait(timeout=10)
                logger.debug("Server beim Beenden beendet.")
            except subprocess.TimeoutExpired:
                self.server_process.kill()
                logger.error("Server wurde beim Beenden zwangsweise beendet.")
        if hasattr(self, 'task_processor') and self.task_processor.isRunning():
            self.task_processor.stop()
            self.task_processor.wait()
            logger.debug("TaskProcessor beim Beenden beendet.")
        self.save_projects()
        event.accept()
    else:
        event.ignore()

def font_to_dict(self, font):
    return {
        'family': font.family(),
        'pointSize': font.pointSize(),
        'bold': font.bold(),
        'italic': font.italic(),
        'underline': font.underline(),
        'strikeOut': font.strikeOut(),
        'weight': font.weight(),
        'style': font.style(),
        'styleHint': font.styleHint()
    }

def dict_to_font(self, d):
    font = QFont()
    font.setFamily(d.get('family', "Arial"))
    font.setPointSize(d.get('pointSize', 10))
    font.setBold(d.get('bold', False))
    font.setItalic(d.get('italic', False))
    font.setUnderline(d.get('underline', False))
    font.setStrikeOut(d.get('strikeOut', False))
    font.setWeight(d.get('weight', QFont.Normal))
    font.setStyle(d.get('style', QFont.StyleNormal))
    font.setStyleHint(d.get('styleHint', QFont.AnyStyle))
    return font

def update_progress(self, value):
    self.progress_bar.setValue(value)
    self.detail_chat_area.add_message("System", f"Fortschritt: {value}%")

def update_task_status(self, task_index, goal_index, status):
    """
    Aktualisiert den Status einer bestimmten Aufgabe und eines Ziels im Gantt-Diagramm.
    
    :param task_index: Index der Aufgabe im Entwicklungsplan.
    :param goal_index: Index des Ziels innerhalb der Aufgabe.
    :param status: Aktueller Status der Aufgabe/Ziel (z.B. 'processing', 'completed', 'error', 'failed').
    """
    # Aktualisiere die internal plan_data mit dem neuen Status
    goal_data = self.plan_data[task_index]['Goals'][goal_index]
    goal_data['Status'] = status

    # Aktualisiere das Gantt-Diagramm visuell
    self.gantt_chart.update_chart(self.plan_data)

    # Zusätzliche visuelle oder logische Aktionen können hier hinzugefügt werden
    if status == 'completed':
        self.thought_cloud.display_message(f"Ziel '{goal_data['Goal']}' abgeschlossen.")
        QTimer.singleShot(3000, self.thought_cloud.clear_message)
    elif status == 'failed':
        self.thought_cloud.display_message(f"Ziel '{goal_data['Goal']}' fehlgeschlagen.")
        QTimer.singleShot(5000, self.thought_cloud.clear_message)
    elif status == 'processing':
        self.thought_cloud.display_message(f"Ziel '{goal_data['Goal']}' wird verarbeitet.")
        QTimer.singleShot(3000, self.thought_cloud.clear_message)
    elif status == 'error':
        self.thought_cloud.display_message(f"Ein Fehler ist bei '{goal_data['Goal']}' aufgetreten.")
        QTimer.singleShot(5000, self.thought_cloud.clear_message)

def processing_finished(self):
    self.progress_bar.setValue(100)
    self.chat_area_add_message("System", "Verarbeitung abgeschlossen.")
    self.detail_chat_area.add_message("System", "Verarbeitung abgeschlossen.")
    logger.debug("Verarbeitung abgeschlossen.")
    # Aktualisiere Gantt-Diagramm
    self.gantt_chart.update_chart(self.plan_data)
    if self.plan_data:
        self.gantt_chart.setVisible(True)
    # Thought Cloud Notification
    self.thought_cloud.display_message("Verarbeitung abgeschlossen.")
    QTimer.singleShot(5000, self.thought_cloud.clear_message)

def add_or_update_project(self, project_name):
    existing = next((p for p in self.settings['projects'] if p['name'] == project_name), None)
    if not existing:
        self.settings['projects'].append({'name': project_name})
    self.settings['last_used_project'] = project_name
    self.save_projects()
    self.chat_area_add_message("System", f"Projekt '{project_name}' wurde hinzugefügt/aktualisiert.")
    self.detail_chat_area.add_message("System", f"Projekt '{project_name}' wurde hinzugefügt/aktualisiert.")
    logger.debug(f"Projekt '{project_name}' wurde in der Liste aktualisiert.")

def delete_project(self):
    if not self.settings['projects']:
        self.chat_area_add_message("System", "Keine Projekte zum Löschen vorhanden.")
        self.detail_chat_area.add_message("System", "Keine Projekte zum Löschen vorhanden.")
        logger.info("Löschanfrage ohne vorhandene Projekte.")
        return
    dlg = DeleteProjectDialog(self.settings['projects'], self)
    if dlg.exec_() == QDialog.Accepted:
        project_to_delete = dlg.selected_project
        self.settings['projects'] = [p for p in self.settings['projects'] if p['name'] != project_to_delete]
        if self.settings['last_used_project'] == project_to_delete:
            self.settings['last_used_project'] = self.settings['projects'][0]['name'] if self.settings['projects'] else None
        self.save_projects()
        self.chat_area_add_message("System", f"Projekt '{project_to_delete}' wurde gelöscht.")
        self.detail_chat_area.add_message("System", f"Projekt '{project_to_delete}' wurde gelöscht.")
        logger.debug(f"Projekt '{project_to_delete}' wurde gelöscht.")

def request_confirmation(self, message):
    result = QMessageBox.question(self, "Bestätigung erforderlich", message, QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
    return result == QMessageBox.Yes

def update_llm_list(self):
    self.settings['available_models'] = self.llm_client.get_models()
    if self.settings['available_models']:
        if not self.settings.get('selected_model') or self.settings['selected_model'] not in self.settings['available_models']:
            self.settings['selected_model'] = self.settings['available_models'][0]
            self.llm_client.set_model(self.settings['selected_model'])
        models = ', '.join(self.settings['available_models'])
        self.chat_area_add_message("System", f"Verfügbare Modelle: {models}.")
        self.detail_chat_area.add_message("System", f"Verfügbare Modelle: {models}.")
    else:
        logger.warning("Keine Modelle gefunden.")
        self.chat_area_add_message("System", "Keine Modelle auf dem LLM-Server gefunden.")
        self.detail_chat_area.add_message("System", "Keine Modelle auf dem LLM-Server gefunden.")
        # Beim ersten Start LLM-Auswahl erzwingen
        self.prompt_llm_selection()

def prompt_llm_selection(self):
    QMessageBox.warning(self, "LLM-Auswahl erforderlich", "Es wurden keine LLM-Modelle gefunden oder ausgewählt. Bitte wählen Sie ein verfügbares Modell aus den Einstellungen.")
    self.open_settings_dialog()

def update_server_status(self):
    running = self.check_server_running()
    if running:
        self.chat_area_add_message("System", "Serverstatus: 🟢 Läuft")
        self.detail_chat_area.add_message("System", "Serverstatus: 🟢 Läuft")
        self.update_llm_list()
    else:
        self.chat_area_add_message("System", "Serverstatus: 🔴 Gestoppt")
        self.detail_chat_area.add_message("System", "Serverstatus: 🔴 Gestoppt")
        self.settings['available_models'] = []
        self.settings['selected_model'] = ''
        # Beim ersten Start LLM-Auswahl erzwingen
        self.prompt_llm_selection()

def check_server_running(self):
    try:
        response = requests.get(f'{self.llm_client.base_url}/api/tags', timeout=5)
        return response.status_code == 200
    except requests.RequestException:
        return False

def start_server(self):
    if self.check_server_running():
        self.chat_area_add_message("System", "Server läuft bereits.")
        self.detail_chat_area.add_message("System", "Server läuft bereits.")
        logger.info("Serverstart versucht, aber bereits aktiv.")
        return
    try:
        llm_cmd = 'ollama'  # Stellen Sie sicher, dass 'ollama' installiert und im PATH ist
        server_path = shutil.which(llm_cmd)
        if not server_path:
            self.chat_area_add_message("System", f"Befehl '{llm_cmd}' nicht gefunden.")
            self.detail_chat_area.add_message("System", f"Befehl '{llm_cmd}' nicht gefunden.")
            logger.error(f"Befehl '{llm_cmd}' nicht gefunden.")
            return
        args = [llm_cmd, 'serve', '--port', str(self.settings['server_port'])]
        creation = subprocess.CREATE_NEW_CONSOLE if os.name == 'nt' else 0
        self.server_process = subprocess.Popen(
            args,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            shell=(os.name == 'nt'),
            creationflags=creation
        )
        self.chat_area_add_message("System", "LLM-Server wird gestartet...")
        self.detail_chat_area.add_message("System", "LLM-Server wird gestartet...")
        self.server_timer = QTimer()
        self.server_timer.timeout.connect(self.check_server_startup)
        self.server_timer.start(1000)
        self.server_startup_attempts = 0
        logger.debug("LLM-Serverstart initiiert.")
    except Exception as e:
        self.chat_area_add_message("System", f"Serverstart fehlgeschlagen: {e}")
        self.detail_chat_area.add_message("System", f"Serverstart fehlgeschlagen: {e}")
        logger.error(f"Fehler beim Serverstart: {e}")

def check_server_startup(self):
    self.server_startup_attempts += 1
    if self.check_server_running():
        self.server_timer.stop()
        self.server_timer = None
        self.update_server_status()
        self.chat_area_add_message("System", "LLM-Server gestartet.")
        self.detail_chat_area.add_message("System", "LLM-Server gestartet.")
        logger.debug("LLM-Server erfolgreich gestartet.")
        self.save_projects()
        # Beim erfolgreichen Start Modelle aktualisieren
        self.update_llm_list()
        # Wenn keine Modelle ausgewählt sind, Benutzer auffordern
        if not self.settings['selected_model']:
            self.prompt_llm_selection()
    elif self.server_startup_attempts >= 15:
        self.server_timer.stop()
        self.server_timer = None
        self.chat_area_add_message("System", "Server konnte nicht rechtzeitig gestartet werden.")
        self.detail_chat_area.add_message("System", "Server konnte nicht rechtzeitig gestartet werden.")
        QMessageBox.warning(self, "Warnung", "Server wurde nicht innerhalb der erwarteten Zeit gestartet.")
        self.update_server_status()
        logger.error("LLM-Server konnte nicht innerhalb von 15 Sekunden gestartet werden.")

def stop_server(self):
    if self.server_process and self.server_process.poll() is None:
        try:
            self.server_process.terminate()
            self.server_process.wait(timeout=10)
            self.server_process = None
            self.chat_area_add_message("System", "LLM-Server gestoppt.")
            self.detail_chat_area.add_message("System", "LLM-Server gestoppt.")
            logger.debug("LLM-Server gestoppt.")
            self.update_server_status()
            self.save_projects()
        except subprocess.TimeoutExpired:
            self.server_process.kill()
            self.server_process = None
            self.chat_area_add_message("System", "LLM-Server wurde zwangsweise gestoppt.")
            self.detail_chat_area.add_message("System", "LLM-Server wurde zwangsweise gestoppt.")
            self.update_server_status()
            logger.error("LLM-Server wurde zwangsweise gestoppt.")
        except Exception as e:
            self.chat_area_add_message("System", f"Server konnte nicht gestoppt werden: {e}")
            self.detail_chat_area.add_message("System", f"Server konnte nicht gestoppt werden: {e}")
            logger.error(f"Fehler beim Serverstopp: {e}")
    else:
        self.chat_area_add_message("System", "Server läuft nicht.")
        self.detail_chat_area.add_message("System", "Server läuft nicht.")
        logger.info("Serverstopp versucht, aber Server läuft nicht.")

def upload_files(self):
    files, _ = QFileDialog.getOpenFileNames(self, "Dateien auswählen", "", "Alle Dateien (*)")
    new = [f for f in files if f not in self.uploaded_files]
    if new:
        self.uploaded_files.extend(new)
        logger.debug(f"Hochgeladene Dateien: {new}")
        self.chat_area_add_message("System", f"{len(new)} Datei(en) hochgeladen.")
        self.detail_chat_area.add_message("System", f"{len(new)} Datei(en) hochgeladen.")
        self.display_uploaded_files()
    else:
        self.chat_area_add_message("System", "Keine neuen Dateien hochgeladen (Duplikate übersprungen).")
        self.detail_chat_area.add_message("System", "Keine neuen Dateien hochgeladen (Duplikate übersprungen).")

def display_uploaded_files(self):
    # Informationen über hochgeladene Dateien im Chat anzeigen
    if self.uploaded_files:
        file_list = "\n".join(self.uploaded_files)
        self.chat_area_add_message("System", f"Hochgeladene Dateien:\n{file_list}")
        self.detail_chat_area.add_message("System", f"Hochgeladene Dateien:\n{file_list}")
    else:
        self.chat_area_add_message("System", "Keine Dateien hochgeladen.")
        self.detail_chat_area.add_message("System", "Keine Dateien hochgeladen.")

def save_project(self):
    # Projekt über Dialog speichern
    file, _ = QFileDialog.getSaveFileName(self, "Projekt speichern", "", "JSON Dateien (*.json)")
    if file:
        project = {
            'name': self.settings.get('last_used_project', 'Neues Projekt'),
            'description': self.settings.get('description_text', ''),
            'uploaded_files': self.uploaded_files,
            'plan_data': self.plan_data,
            'settings': {
                'selected_model': self.settings.get('selected_model', ''),
                'temperature': self.settings.get('temperature', 0.7),
                'max_tokens': self.settings.get('max_tokens', 150),
                'server_url': self.settings.get('server_url', 'http://localhost'),
                'server_port': self.settings.get('server_port', 11434),
                'theme': self.settings.get('theme', 'Dark'),
                'font': self.font_to_dict(self.settings.get('font', QFont("Arial", 10)))
            }
        }
        try:
            with open(file, 'w', encoding='utf-8') as f:
                json.dump(project, f, ensure_ascii=False, indent=4)
            self.chat_area_add_message("System", "Projekt erfolgreich gespeichert.")
            self.detail_chat_area.add_message("System", "Projekt erfolgreich gespeichert.")
            logger.debug(f"Projekt gespeichert unter {file}.")
            # Update Projektliste
            self.add_or_update_project(project['name'])
        except Exception as e:
            self.chat_area_add_message("System", f"Projekt konnte nicht gespeichert werden: {e}")
            self.detail_chat_area.add_message("System", f"Projekt konnte nicht gespeichert werden: {e}")
            logger.error(f"Fehler beim Speichern des Projekts: {e}")

def load_project(self):
    # Projekt über Dialog laden
    file, _ = QFileDialog.getOpenFileName(self, "Projekt laden", "", "JSON Dateien (*.json)")
    if file:
        try:
            with open(file, 'r', encoding='utf-8') as f:
                project = json.load(f)
            # Annahme: 'description' ist Teil des Projekts
            load_description = QMessageBox.question(self, "Beschreibung laden", "Möchten Sie die Projektbeschreibung laden?", QMessageBox.Yes | QMessageBox.No)
            if load_description == QMessageBox.Yes:
                description = project.get('description', '')
                self.chat_area_add_message("System", f"Geladene Beschreibung:\n{description}")
                self.detail_chat_area.add_message("System", f"Geladene Beschreibung:\n{description}")
            self.uploaded_files = project.get('uploaded_files', [])
            if self.uploaded_files:
                self.chat_area_add_message("System", f"Hochgeladene Dateien:\n" + "\n".join(self.uploaded_files))
                self.detail_chat_area.add_message("System", f"Hochgeladene Dateien:\n" + "\n".join(self.uploaded_files))
            self.plan_data = project.get('plan_data', [])
            settings = project.get('settings', {})
            if settings:
                self.settings.update({
                    'selected_model': settings.get('selected_model', ''),
                    'temperature': settings.get('temperature', 0.7),
                    'max_tokens': settings.get('max_tokens', 150),
                    'server_url': settings.get('server_url', 'http://localhost'),
                    'server_port': settings.get('server_port', 11434),
                    'theme': settings.get('theme', 'Dark'),
                    'font': self.dict_to_font(settings.get('font', self.font_to_dict(QFont("Arial", 10))))
                })
                self.llm_client.base_url = f"{self.settings['server_url'].rstrip(':')}" \
                                           f":{self.settings['server_port']}"
                self.apply_styles()
            if self.plan_data:
                self.chat_area_add_message("System", "Entwicklungsplan geladen.")
                self.detail_chat_area.add_message("System", "Entwicklungsplan geladen.")
                logger.debug("Entwicklungsplan geladen.")
                self.gantt_chart.update_chart(self.plan_data)
                self.gantt_chart.setVisible(True)
            QMessageBox.information(self, "Erfolg", "Projekt erfolgreich geladen.")
            logger.debug(f"Projekt geladen von {file}.")
            # Update Projektliste und zuletzt verwendetes Projekt
            project_name = project.get('name', 'Neues Projekt')
            self.add_or_update_project(project_name)
        except Exception as e:
            self.chat_area_add_message("System", f"Projekt konnte nicht geladen werden: {e}")
            self.detail_chat_area.add_message("System", f"Projekt konnte nicht geladen werden: {e}")
            logger.error(f"Fehler beim Laden des Projekts: {e}")

def new_project_command(self, **kwargs):
    self.new_project()

def new_project(self):
    name, ok = QInputDialog.getText(self, "Neues Projekt", "Geben Sie den Namen des neuen Projekts ein:")
    if ok and name:
        self.settings['last_used_project'] = name
        self.uploaded_files = []
        self.plan_data = []
        self.settings.pop('description_text', None)  # Entfernen der Beschreibung des vorherigen Projekts
        self.chat_area_add_message("System", f"Neues Projekt '{name}' gestartet.")
        self.detail_chat_area.add_message("System", f"Neues Projekt '{name}' gestartet.")
        logger.debug(f"Neues Projekt '{name}' initiiert.")
        self.gantt_chart.update_chart(self.plan_data)
        self.gantt_chart.setVisible(False)
        self.add_or_update_project(name)
    elif ok:
        self.chat_area_add_message("System", "Projektname darf nicht leer sein.")
        self.detail_chat_area.add_message("System", "Projektname darf nicht leer sein.")
        logger.warning("Neues Projekt ohne Namen angefragt.")

def show_about_dialog(self):
    QMessageBox.about(self, "Über", "Intelligenter Assistent für Entwickler\nVersion 2.6\n\nEntwickelt, um Entwicklern bei der Erstellung umfassender Entwicklungspläne und Skripte mit Hilfe von LLMs zu unterstützen.")

def apply_styles(self):
    palette = QPalette()
    if self.settings['theme'] == 'Dark':
        palette.setColor(QPalette.Window, QColor(45, 45, 45))
        palette.setColor(QPalette.WindowText, Qt.white)
        palette.setColor(QPalette.Base, QColor(30, 30, 30))
        palette.setColor(QPalette.AlternateBase, QColor(45, 45, 45))
        palette.setColor(QPalette.ToolTipBase, Qt.white)
        palette.setColor(QPalette.ToolTipText, Qt.white)
        palette.setColor(QPalette.Text, Qt.white)
        palette.setColor(QPalette.Button, QColor(45, 45, 45))
        palette.setColor(QPalette.ButtonText, Qt.white)
        palette.setColor(QPalette.BrightText, Qt.red)
        palette.setColor(QPalette.Link, QColor(42, 130, 218))
        palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
        palette.setColor(QPalette.HighlightedText, Qt.black)
    else:
        palette = QApplication.style().standardPalette()
    self.setPalette(palette)
    self.setFont(self.settings.get('font', QFont("Arial", 10)))
    for widget in [self.chat_input.input_field, self.detail_chat_area.chat_container]:
        widget.setFont(self.settings.get('font', QFont("Arial", 10)))

def update_llm_list(self):
    self.settings['available_models'] = self.llm_client.get_models()
    if self.settings['available_models']:
        if not self.settings.get('selected_model') or self.settings['selected_model'] not in self.settings['available_models']:
            self.settings['selected_model'] = self.settings['available_models'][0]
            self.llm_client.set_model(self.settings['selected_model'])
        models = ', '.join(self.settings['available_models'])
        self.chat_area_add_message("System", f"Verfügbare Modelle: {models}.")
        self.detail_chat_area.add_message("System", f"Verfügbare Modelle: {models}.")
    else:
        logger.warning("Keine Modelle gefunden.")
        self.chat_area_add_message("System", "Keine Modelle auf dem LLM-Server gefunden.")
        self.detail_chat_area.add_message("System", "Keine Modelle auf dem LLM-Server gefunden.")
        # Beim ersten Start LLM-Auswahl erzwingen
        self.prompt_llm_selection()

def main(self):
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    logger.debug("Anwendung gestartet.")
    sys.exit(app.exec_())

class SettingsDialog(QDialog):
def init(self, current_settings, parent=None):
super().init(parent)
self.setWindowTitle("Einstellungen")
self.setModal(True)
self.settings = current_settings.copy()
self.init_ui()

def init_ui(self):
    layout = QVBoxLayout(self)

    # LLM Einstellungen
    llm_group = QGroupBox("LLM-Einstellungen")
    llm_layout = QFormLayout()
    self.llm_combo = QComboBox()
    self.llm_combo.addItems(self.settings.get('available_models', []))
    self.llm_combo.setCurrentText(self.settings.get('selected_model', ''))
    llm_layout.addRow("Modell:", self.llm_combo)
    llm_group.setLayout(llm_layout)

    # Allgemeine Einstellungen
    general_group = QGroupBox("Allgemeine Einstellungen")
    general_layout = QFormLayout()
    self.temperature_spin = QDoubleSpinBox()
    self.temperature_spin.setRange(0.0, 1.0)
    self.temperature_spin.setDecimals(2)
    self.temperature_spin.setSingleStep(0.05)
    self.temperature_spin.setValue(self.settings.get('temperature', 0.7))
    self.max_tokens_spin = QSpinBox()
    self.max_tokens_spin.setRange(100, 10000)
    self.max_tokens_spin.setValue(self.settings.get('max_tokens', 150))
    general_layout.addRow("Temperatur:", self.temperature_spin)
    general_layout.addRow("Max Tokens:", self.max_tokens_spin)
    general_group.setLayout(general_layout)

    # Server Einstellungen
    server_group = QGroupBox("Server-Einstellungen")
    server_layout = QFormLayout()
    self.server_url_input = QLineEdit(self.settings.get('server_url', 'http://localhost'))
    self.server_port_input = QSpinBox()
    self.server_port_input.setRange(1, 65535)
    self.server_port_input.setValue(self.settings.get('server_port', 11434))
    server_layout.addRow("Server-URL:", self.server_url_input)
    server_layout.addRow("Server-Port:", self.server_port_input)
    server_group.setLayout(server_layout)

    # UI Einstellungen
    ui_group = QGroupBox("UI-Einstellungen")
    ui_layout = QFormLayout()
    self.theme_combo = QComboBox()
    self.theme_combo.addItems(["Dark", "Light"])
    self.theme_combo.setCurrentText(self.settings.get('theme', 'Dark'))
    self.font_button = QPushButton("Schriftart wählen")
    self.font_button.clicked.connect(self.choose_font)
    self.selected_font = self.settings.get('font', QFont("Arial", 10))
    status = 'Fett' if self.selected_font.bold() else 'Regulär'
    self.font_display = QLabel(f"{self.selected_font.family()}, {self.selected_font.pointSize()}pt, {status}")
    ui_layout.addRow("Thema:", self.theme_combo)
    ui_layout.addRow("Schriftart:", self.font_button)
    ui_layout.addRow("", self.font_display)
    ui_group.setLayout(ui_layout)

    # Hinzufügen aller Gruppen zum Layout
    layout.addWidget(llm_group)
    layout.addWidget(general_group)
    layout.addWidget(server_group)
    layout.addWidget(ui_group)

    # Dialog Buttons
    buttons = QDialogButtonBox(QDialogButtonBox.Save | QDialogButtonBox.Cancel)
    buttons.accepted.connect(self.save)
    buttons.rejected.connect(self.reject)
    layout.addWidget(buttons)
    self.setLayout(layout)

def choose_font(self):
    font, ok = QFontDialog.getFont(self.selected_font, self, "Schriftart wählen")
    if ok:
        self.selected_font = font
        status = 'Fett' if font.bold() else 'Regulär'
        self.font_display.setText(f"{font.family()}, {font.pointSize()}pt, {status}")

def save(self):
    self.settings.update({
        'selected_model': self.llm_combo.currentText(),
        'temperature': self.temperature_spin.value(),
        'max_tokens': self.max_tokens_spin.value(),
        'server_url': self.server_url_input.text(),
        'server_port': self.server_port_input.value(),
        'theme': self.theme_combo.currentText(),
        'font': self.selected_font
    })
    self.accept()

class SwitchLLMDialog(QDialog):
def init(self, current_settings, parent=None):
super().init(parent)
self.setWindowTitle("LLM wechseln")
self.setModal(True)
self.settings = current_settings
self.selected_llm = None
self.init_ui()

def init_ui(self):
    layout = QVBoxLayout(self)
    info_label = QLabel("Wählen Sie das LLM aus, das Sie aktivieren möchten:")
    layout.addWidget(info_label)
    self.llm_combo = QComboBox()
    self.llm_combo.addItems(self.settings.get('available_models', []))
    layout.addWidget(self.llm_combo)
    buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
    buttons.accepted.connect(self.ok)
    buttons.rejected.connect(self.reject)
    layout.addWidget(buttons)
    self.setLayout(layout)

def ok(self):
    self.selected_llm = self.llm_combo.currentText()
    self.accept()

class DeleteProjectDialog(QDialog):
def init(self, projects, parent=None):
super().init(parent)
self.setWindowTitle("Projekt löschen")
self.setModal(True)
self.projects = projects
self.selected_project = None
self.init_ui()

def init_ui(self):
    layout = QVBoxLayout(self)
    info_label = QLabel("Wählen Sie das Projekt aus, das Sie löschen möchten:")
    layout.addWidget(info_label)
    self.project_combo = QComboBox()
    self.project_combo.addItems([p['name'] for p in self.projects])
    layout.addWidget(self.project_combo)
    buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
    buttons.accepted.connect(self.ok)
    buttons.rejected.connect(self.reject)
    layout.addWidget(buttons)
    self.setLayout(layout)

def ok(self):
    self.selected_project = self.project_combo.currentText()
    self.accept()

def main():
app = QApplication(sys.argv)
window = MainWindow()
window.show()
logger.debug("Anwendung gestartet.")
sys.exit(app.exec_())

if name == "main":
main()

Um die gewünschte Weiterentwicklung Ihrer Softwareentwicklungs-Anwendung zu realisieren, habe ich die bestehenden Klassen und Funktionen erweitert und optimiert. Die Erweiterungen umfassen:

1. **Intelligentes Kontextmanagement**: Der `LLMClient` verwaltet nun den Kontext effizient, indem er relevante Informationen aus der Speicherumgebung zieht und sicherstellt, dass die Konsistenz während der Entwicklungsschritte gewahrt bleibt.

2. **Schrittweise Aufgabenbearbeitung**: Der `TaskProcessor` verarbeitet nun Aufgaben in einzelnen Schritten, speichert die Zwischenergebnisse optimal und ermöglicht die Wiederverwendung dieser Ergebnisse zu einem späteren Zeitpunkt.

3. **Dynamische Anpassung der LLM-Einstellungen**: Basierend auf der Phase der Aufgabenbearbeitung und den Hardware-Ressourcen des Nutzers passt die Anwendung die Einstellungen des LLM (wie Kontextgröße und Maximale Token) intelligent an, um Effizienz und Leistungsfähigkeit zu maximieren.

4. **Persistente Speicherung und Wiederverwendung von Ergebnissen**: Alle Zwischenergebnisse werden gespeichert und können später erneut verwendet werden, wodurch eine nahtlose Fortsetzung der Entwicklungsarbeiten möglich ist.

5. **Mehrteilige Kommunikation mit dem LLM**: Bei Bedarf wird die Kommunikation mit dem LLM in mehreren Schritten durchgeführt, um komplexe Aufgaben effizient zu bewältigen.

Nachfolgend finden Sie das vollständige, erweiterte Skript der Anwendung:

```python
import sys
import threading
import requests
import json
import logging
import subprocess
import os
import re
import shutil
import psutil  # Für Hardware-Detektion
from datetime import datetime, timedelta
from logging.handlers import RotatingFileHandler

from PyQt5.QtWidgets import (
    QApplication, QMainWindow, QLabel, QPushButton, QWidget, QTextEdit,
    QScrollArea, QFrame, QProgressBar, QMessageBox, QDialog, QDialogButtonBox,
    QVBoxLayout, QHBoxLayout, QComboBox, QGroupBox, QFormLayout, QInputDialog,
    QFontDialog, QFileDialog, QPlainTextEdit, QSpinBox, QDoubleSpinBox, QLineEdit
)
from PyQt5.QtCore import (
    QTimer, Qt, QThread, pyqtSignal, QSize, QPropertyAnimation, QRect
)
from PyQt5.QtGui import (
    QColor, QFont, QPalette, QMovie
)

# Logging Configuration
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
file_handler = RotatingFileHandler(os.path.join(BASE_DIR, "app.log"), maxBytes=510241024, backupCount=3, encoding='utf-8')
file_handler.setFormatter(formatter)
stream_handler = logging.StreamHandler(sys.stdout)
stream_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.addHandler(stream_handler)


class LLMClient:
    def __init__(self, base_url='http://localhost:11434', model_name=''):
        self.base_url = base_url.rstrip('/')
        self.model_name = model_name
        self.cache = {}
        self.memory = {}
        self.role = 'system_agent'  # Default Rolle
        self.temperature = 0.7  # Initial temperature
        self.max_tokens = 150
        self.context_size = 2048  # Beispielhafte Kontextgröße, abhängig vom LLM
        logger.debug("LLMClient initialisiert.")

    def set_model(self, model_name):
        self.model_name = model_name
        logger.debug(f"LLM-Modell gewechselt zu: {self.model_name}")

    def set_role(self, role):
        if role in ['system_agent', 'code_agent']:
            self.role = role
            logger.debug(f"LLM-Rolle gewechselt zu: {self.role}")
        else:
            logger.error(f"Ungültige Rolle: {role}")

    def set_temperature(self, temperature):
        self.temperature = temperature
        logger.debug(f"LLM-Temperatur auf {self.temperature} gesetzt.")

    def set_max_tokens(self, max_tokens):
        self.max_tokens = max_tokens
        logger.debug(f"LLM Max Tokens auf {self.max_tokens} gesetzt.")

    def set_context_size(self, context_size):
        self.context_size = context_size
        logger.debug(f"LLM Kontextgröße auf {self.context_size} gesetzt.")

    def get_models(self):
        try:
            logger.debug("Anfordern der verfügbaren Modelle.")
            response = requests.get(f'{self.base_url}/api/tags', timeout=5)
            if response.status_code == 200:
                models = [model['name'] for model in response.json().get('models', [])]
                logger.debug(f"Verfügbare Modelle: {models}")
                return models
            logger.error(f"Fehler beim Abrufen der Modelle: {response.status_code} - {response.text}")
        except requests.RequestException as e:
            logger.error(f"Fehler bei der Kommunikation mit dem LLM-Server: {e}")
        return []

    def generate(self, prompt, temperature=None, max_tokens=None, context_size=None):
        temperature = temperature if temperature is not None else self.temperature
        max_tokens = max_tokens if max_tokens is not None else self.max_tokens
        context_size = context_size if context_size is not None else self.context_size

        if not self.model_name:
            logger.error("Kein LLM-Modell ausgewählt.")
            return "Error: Kein LLM-Modell ausgewählt."

        cache_key = (self.model_name, prompt, temperature, max_tokens, context_size)
        if cache_key in self.cache:
            logger.debug("Verwendung des gecachten Ergebnisses.")
            return self.cache[cache_key]

        payload = {
            "model": self.model_name,
            "prompt": prompt,
            "temperature": temperature,
            "max_tokens": max_tokens,
            "context_size": context_size,
            "format": "json",
            "stream": False
        }

        try:
            logger.debug("Senden der Generierungsanfrage.")
            response = requests.post(
                f'{self.base_url}/api/generate',
                json=payload,
                headers={"Content-Type": "application/json"},
                timeout=60
            )
            if response.status_code == 200:
                result = response.json().get('response', '').strip()
                self.cache[cache_key] = result
                logger.debug("Generierung erfolgreich.")
                return result
            logger.error(f"Generierungsfehler: {response.status_code} - {response.text}")
            return f"Fehler: {response.text}"
        except requests.RequestException as e:
            logger.error(f"LLM-Kommunikationsfehler: {e}")
            return f"Fehler: {e}"

    def add_to_memory(self, key, value):
        self.memory[key] = value

    def get_from_memory(self, key):
        return self.memory.get(key, '')

    def clear_memory(self):
        self.memory = {}
        logger.debug("LLM-Speicher gelöscht.")


class CommandDispatcher:
    def __init__(self, main_window, llm_client):
        self.main_window = main_window
        self.llm_client = llm_client
        # Define critical actions
        self.critical_actions = {
            'stop_server': 'Das Stoppen des Servers kann alle laufenden Prozesse unterbrechen. Möchten Sie fortfahren?',
            'remove_files': 'Das Entfernen von Dateien kann zu Datenverlust führen. Möchten Sie fortfahren?',
            'delete_project': 'Das Löschen eines Projekts ist irreversibel. Möchten Sie fortfahren?',
            # Weitere kritische Aktionen hier hinzufügen
        }

    def dispatch(self, command):
        action = command.get('action')
        params = command.get('params', {})
        if not action:
            self.main_window.chat_area_add_message("System", "Unbekanntes Befehlsformat.")
            return

        logger.info(f"Ausführung von Aktion: {action} mit Parametern: {params}")

        # Überprüfen, ob die Aktion kritisch ist
        if action in self.critical_actions:
            confirmation = self.main_window.request_confirmation(self.critical_actions[action])
            if not confirmation:
                self.main_window.chat_area_add_message("System", f"Aktion '{action}' wurde vom Benutzer abgebrochen.")
                logger.info(f"Aktion '{action}' wurde vom Benutzer abgebrochen.")
                return

        actions = {
            'start_server': self.main_window.start_server_command,
            'stop_server': self.main_window.stop_server_command,
            'upload_files': self.main_window.upload_files_command,
            'remove_files': self.main_window.remove_selected_files_command,
            'change_setting': self.main_window.change_setting,
            'save_project': self.main_window.save_project_command,
            'load_project': self.main_window.load_project_command,
            'create_new_project': self.main_window.new_project_command,
            'start_analysis': self.main_window.start_analysis_command,
            'start_processing': self.main_window.start_processing_command,
            'pause_processing': self.main_window.pause_processing_command,
            'resume_processing': self.main_window.resume_processing_command,
            'stop_processing': self.main_window.stop_processing_command,
            'toggle_gantt_chart': self.main_window.toggle_gantt_chart_command,
            'generate_final_report': self.main_window.generate_final_report_command,
            'switch_llm': self.main_window.switch_llm_command,
            'delete_project': self.main_window.delete_project_command,
            # Weitere Aktionen hier hinzufügen
        }

        func = actions.get(action)
        if func:
            try:
                func(**params)
                self.main_window.chat_area_add_message("System", f"Aktion '{action}' erfolgreich ausgeführt.")
                logger.info(f"Aktion '{action}' erfolgreich ausgeführt.")
            except Exception as e:
                self.main_window.chat_area_add_message("System", f"Fehler bei der Ausführung von '{action}': {e}")
                logger.error(f"Fehler bei der Ausführung von '{action}': {e}")
        else:
            self.main_window.chat_area_add_message("System", f"Aktion '{action}' nicht erkannt.")
            logger.warning(f"Aktion '{action}' nicht erkannt.")


class TaskProcessor(QThread):
    progress_updated = pyqtSignal(int)
    task_message = pyqtSignal(str, str)  # Sender, Message
    task_result = pyqtSignal(str, str)  # Sender, Message
    task_status = pyqtSignal(int, int, str)  # task_index, goal_index, status

    def __init__(self, tasks, llm_client, context_manager, parent=None):
        super().__init__(parent)
        self.tasks = tasks
        self.llm_client = llm_client
        self.context_manager = context_manager
        self._paused = False
        self._stopped = False
        self.max_retries = 3
        self.context_memory = {}
        self.results_storage = {}  # Speicherung der Zwischenergebnisse

    def run(self):
        total_goals = sum(len(task.get('Goals', [])) for task in self.tasks)
        completed_goals = 0
        self.llm_client.set_role('code_agent')  # Wechsel zur Code-Agent-Rolle
        for i, task in enumerate(self.tasks):
            if self._stopped:
                break
            while self._paused:
                self.msleep(100)
            task_title = task.get('Title', f'Task {i + 1}')
            self.task_message.emit("Assistant", f"Starte Aufgabe '{task_title}'")
            self.task_status.emit(i, -1, 'processing')  # -1 für die Aufgabe selbst
            for j, goal in enumerate(task.get('Goals', [])):
                if self._stopped:
                    break
                while self._paused:
                    self.msleep(100)
                retry, success = 0, False
                while retry < self.max_retries and not success and not self._stopped:
                    if retry > 0:
                        self.task_message.emit("Assistant", f"Versuch {retry} für Ziel: {goal['Goal']}")
                        logger.debug(f"Versuch {retry} für Ziel: {goal['Goal']}")
                    self.task_message.emit("Assistant", f"Bearbeite Ziel: {goal['Goal']}")
                    self.task_status.emit(i, j, 'processing')
                    result = self.process_goal(task, goal, retry > 0)
                    success = self.self_review(goal, result)
                    if success:
                        self.task_result.emit("Assistant", f"Ergebnis für '{goal['Goal']}':\n{result}")
                        self.context_memory[goal['Goal']] = result
                        self.results_storage[goal['Goal']] = result  # Speicherung der Ergebnisse
                        self.task_status.emit(i, j, 'completed')
                        self.context_manager.update_context(goal['Goal'], result)
                    else:
                        self.task_status.emit(i, j, 'error')
                        retry += 1
                        # Optimierungsstrategie: Anpassung der Temperatur
                        if retry == 1:
                            logger.debug(f"Anpassung der Temperatur zur Verbesserung der Ergebnisse für '{goal['Goal']}'.")
                            new_temperature = min(self.llm_client.temperature + 0.1, 1.0)
                            self.llm_client.set_temperature(new_temperature)
                if not success:
                    self.task_message.emit("Assistant", f"Ziel '{goal['Goal']}' nach {self.max_retries} Versuchen fehlgeschlagen.")
                    # Parallelprozess: Automatische Neufassung des Prompts
                    self.task_message.emit("Assistant", f"Versuche, das Ziel '{goal['Goal']}' mit angepasstem Prompt erneut zu bearbeiten.")
                    adjusted_result = self.adjust_goal_prompt(task, goal)
                    success = self.self_review(goal, adjusted_result)
                    if success:
                        self.task_result.emit("Assistant", f"Angepasstes Ergebnis für '{goal['Goal']}':\n{adjusted_result}")
                        self.context_memory[goal['Goal']] = adjusted_result
                        self.results_storage[goal['Goal']] = adjusted_result  # Speicherung der Ergebnisse
                        self.task_status.emit(i, j, 'completed')
                        self.context_manager.update_context(goal['Goal'], adjusted_result)
                    else:
                        self.task_status.emit(i, j, 'failed')
                completed_goals += 1
                self.progress_updated.emit(int((completed_goals / total_goals) * 100))
            self.task_status.emit(i, -1, 'completed')  # Abgeschlossenes Task
            summary = self.create_task_summary(task)
            self.task_result.emit("Assistant", f"Zusammenfassung für '{task_title}':\n{summary}")
            self.context_memory[task_title] = summary
            self.results_storage[task_title] = summary  # Speicherung der Ergebnisse
            self.context_manager.update_context(task_title, summary)
        if not self._stopped:
            self.task_message.emit("Assistant", "Alle Aufgaben abgeschlossen.")
            final = self.generate_final_result()
            self.task_result.emit("Assistant", f"Endergebnis:\n{final}")
        self.llm_client.set_role('system_agent')  # Rückwechsel zur System-Agent-Rolle

    def process_goal(self, task, goal, retry=False):
        context = self.context_manager.get_relevant_context(goal['Goal'])
        prompt = f"""
Als erfahrener Softwarearchitekt erstellen Sie eine detaillierte Lösung für das Ziel: {goal['Goal']}

Beschreibung:
{task.get('ApplicationDescription', '')}

Kontext:
{context}

Verwenden Sie klare Sprache und Codebeispiele, wo es angebracht ist.
"""
        logger.debug(f"Generiere für '{goal['Goal']}'.")
        return self.llm_client.generate(prompt, temperature=self.llm_client.temperature, max_tokens=self.llm_client.max_tokens, context_size=self.llm_client.context_size)

    def self_review(self, goal, result):
        prompt = f"""
Überprüfen Sie das Ergebnis für "{goal['Goal']}":

{result}

Ist es vollständig und korrekt? Antworten Sie mit "Ja" oder "Nein".
"""
        review = self.llm_client.generate(prompt, temperature=0.5, max_tokens=10)
        logger.debug(f"Selbstüberprüfung für '{goal['Goal']}': {review}")
        if "Ja" in review:
            return True
        self.task_message.emit("Assistant", f"Überprüfung für '{goal['Goal']}' fehlgeschlagen: {review}")
        return False

    def get_relevant_context(self, current_goal):
        return "\n".join(f"**{k}:**\n{v}" for k, v in self.context_memory.items())

    def create_task_summary(self, task):
        return "\n".join(f"{g['Goal']}:\n{self.context_memory.get(g['Goal'], '')}" for g in task.get('Goals', []))

    def generate_final_result(self):
        context = "\n".join(self.context_memory.values())
        prompt = f"""
Fassen Sie alle Ergebnisse zusammen und erstellen Sie den vollständigen Anwendungscode mit Dokumentation.

Kontext:
{context}
"""
        logger.debug("Generiere Endergebnis.")
        return self.llm_client.generate(prompt, temperature=self.llm_client.temperature, max_tokens=500, context_size=self.llm_client.context_size)

    def adjust_goal_prompt(self, task, goal):
        """
        Anpassung des Prompts zur besseren Bearbeitung des Ziels nach einem Fehler.
        """
        context = self.context_manager.get_relevant_context(goal['Goal'])
        prompt = f"""
Als erfahrener Softwarearchitekt erstellen Sie eine verbesserte Lösung für das Ziel: {goal['Goal']}

Beschreibung:
{task.get('ApplicationDescription', '')}

Kontext:
{context}

Basierend auf den bisherigen Ergebnissen, optimieren Sie die Lösung.
Verwenden Sie klare Sprache und Codebeispiele, wo es angebracht ist.
"""
        logger.debug(f"Angepasster Prompt für '{goal['Goal']}'.")
        return self.llm_client.generate(prompt, temperature=0.8, max_tokens=200, context_size=self.llm_client.context_size)

    def pause(self):
        self._paused = True
        logger.debug("TaskProcessor pausiert.")

    def resume(self):
        self._paused = False
        logger.debug("TaskProcessor fortgesetzt.")

    def stop(self):
        self._stopped = True
        logger.debug("TaskProcessor gestoppt.")


class ContextManager:
    def __init__(self):
        self.context = {}

    def update_context(self, key, value):
        self.context[key] = value
        logger.debug(f"Kontext aktualisiert: {key} hinzgefügt.")

    def get_relevant_context(self, current_goal):
        # Hier kann eine intelligentere Logik implementiert werden, um relevanten Kontext auszuwählen
        return "\n".join(f"**{k}:**\n{v}" for k, v in self.context.items())

    def save_context(self, file_path):
        try:
            with open(file_path, 'w', encoding='utf-8') as f:
                json.dump(self.context, f, ensure_ascii=False, indent=4)
            logger.debug(f"Kontext erfolgreich gespeichert unter {file_path}.")
        except Exception as e:
            logger.error(f"Fehler beim Speichern des Kontexts: {e}")

    def load_context(self, file_path):
        if os.path.exists(file_path):
            try:
                with open(file_path, 'r', encoding='utf-8') as f:
                    self.context = json.load(f)
                logger.debug(f"Kontext erfolgreich geladen von {file_path}.")
            except Exception as e:
                logger.error(f"Fehler beim Laden des Kontexts: {e}")
        else:
            logger.warning(f"Kontext-Datei nicht gefunden: {file_path}")


class ThoughtCloudWidget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setFixedSize(200, 200)
        self.setStyleSheet("background-color: rgba(255, 255, 255, 100); border-radius: 100px;")
        self.label = QLabel("", self)
        self.label.setStyleSheet("color: #2e2e2e; font-size: 12pt;")
        self.label.setAlignment(Qt.AlignCenter)
        self.label.setWordWrap(True)
        self.label.resize(self.size())
        self.hide()

        # Animation für die Anzeige der Thought Cloud
        self.animation = QPropertyAnimation(self, b"geometry")
        self.animation.setDuration(500)

    def display_message(self, message):
        self.label.setText(message)
        self.show()
        self.raise_()
        self.animate_show()

    def animate_show(self):
        start_rect = QRect(self.x(), self.y() - 50, self.width(), self.height())
        end_rect = QRect(self.x(), self.y(), self.width(), self.height())
        self.animation.stop()
        self.animation.setStartValue(start_rect)
        self.animation.setEndValue(end_rect)
        self.animation.start()

    def clear_message(self):
        self.label.setText("")
        self.hide()


class MessageWidget(QFrame):
    def __init__(self, sender, message, parent=None):
        super().__init__(parent)
        self.sender, self.message = sender, message
        self.init_ui()

    def init_ui(self):
        layout = QVBoxLayout(self)
        self.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
        self.setLineWidth(0)
        if self.sender.lower() == "assistant":
            color = "#2e2e2e"
        elif self.sender.lower() == "system":
            color = "#555555"
        else:
            color = "#0078d7"  # Benutzer-Nachrichten in Blau
        self.setStyleSheet(f"""
            QFrame {{
                background-color: {color};
                border-radius: 10px;
                padding: 10px;
            }}
        """)
        sender_label = QLabel(f"<b>{self.sender}:</b>")
        sender_label.setStyleSheet("color: #fff;")
        layout.addWidget(sender_label)
        for part in self.parse_message(self.message):
            if part['type'] == 'text':
                lbl = QLabel(part['content'])
                lbl.setStyleSheet("color: #dcdcdc;")
                lbl.setWordWrap(True)
                lbl.setFont(QFont("Arial", 12))
                layout.addWidget(lbl)
            elif part['type'] == 'code':
                code = QPlainTextEdit(part['content'])
                code.setReadOnly(True)
                code.setStyleSheet("""
                    QPlainTextEdit {
                        background-color: #1e1e1e;
                        color: #f8f8f2;
                        border: 1px solid #555;
                        border-radius: 4px;
                        font-family: Consolas, monospace;
                        padding: 5px;
                        font-size: 12pt;
                    }
                """)
                layout.addWidget(code)
            elif part['type'] == 'link':
                link = QLabel(f'<a href="{part["url"]}">{part["content"]}</a>')
                link.setStyleSheet("color: #3498db;")
                link.setOpenExternalLinks(True)
                layout.addWidget(link)
        self.setLayout(layout)

    def parse_message(self, msg):
        # Regex zum Finden von Codeblöcken und Links
        pattern = re.compile(r'```(.*?)```|https?://\S+')
        parts, last = [], 0
        for m in pattern.finditer(msg):
            if m.start() > last:
                text = msg[last:m.start()]
                parts.append({'type': 'text', 'content': self.highlight_keywords(text)})
            if m.group(1):
                parts.append({'type': 'code', 'content': m.group(1).strip()})
            else:
                url = m.group()
                parts.append({'type': 'link', 'content': url, 'url': url})
            last = m.end()
        if last < len(msg):
            parts.append({'type': 'text', 'content': self.highlight_keywords(msg[last:])})
        return parts

    def highlight_keywords(self, text):
        # Hervorheben von Schlüsselwörtern in Blau (z.B. Befehle)
        keywords = ['start_server', 'stop_server', 'upload_files', 'remove_files',
                    'change_setting', 'save_project', 'load_project', 'create_new_project',
                    'start_analysis', 'start_processing', 'pause_processing', 'resume_processing',
                    'stop_processing', 'toggle_gantt_chart', 'generate_final_report', 'switch_llm',
                    'delete_project']
        for kw in keywords:
            pattern = re.compile(r'\b' + re.escape(kw) + r'\b')
            text = pattern.sub(f'<span style="color:#3498db;">{kw}</span>', text)
        return text


class ChatInputWidget(QWidget):
    send_message = pyqtSignal(str)

    def __init__(self, parent=None):
        super().__init__(parent)
        layout = QHBoxLayout(self)
        self.input_field = QTextEdit()
        self.input_field.setFixedHeight(60)
        self.input_field.setStyleSheet("""
            QTextEdit {
                background-color: #2b2b2b;
                color: #dcdcdc;
                border: 1px solid #555;
                border-radius: 4px;
                padding: 5px;
                font-size: 12pt;
            }
        """)
        self.input_field.setPlaceholderText("Geben Sie Ihre Nachricht hier ein...")
        self.send_button = QPushButton("Senden")
        self.send_button.setStyleSheet("""
            QPushButton {
                background-color: #5cb85c;
                color: #fff;
                border: none;
                border-radius: 4px;
                padding: 15px 25px;
                font-size: 12pt;
            }
            QPushButton:hover {
                background-color: #4cae4c;
            }
        """)
        self.send_button.clicked.connect(self.emit_message)
        layout.addWidget(self.input_field)
        layout.addWidget(self.send_button)
        layout.setContentsMargins(0, 0, 0, 0)
        self.setLayout(layout)

    def emit_message(self):
        message = self.input_field.toPlainText().strip()
        if message:
            self.send_message.emit(message)
            self.input_field.clear()


class GanttChartWidget(QWidget):
    STATUS_COLORS = {
        'pending': '#5bc0de',  # Blau für ausstehende Aufgaben
        'processing': '#f0ad4e',  # Orange für laufende Aufgaben
        'completed': '#5cb85c',  # Grün für abgeschlossene Aufgaben
        'error': '#d9534f',  # Rot für Fehler
        'failed': '#6c757d'  # Grau für fehlgeschlagene Aufgaben
    }

    def __init__(self, plan_data, parent=None):
        super().__init__(parent)
        self.plan_data = plan_data
        layout = QVBoxLayout(self)
        label = QLabel("Entwicklungsplan Zeitachse")
        label.setStyleSheet("font-size: 16pt; font-weight: bold; color: #fff;")
        layout.addWidget(label)
        try:
            from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
            from matplotlib.figure import Figure
            self.figure = Figure(figsize=(10, 8))
            self.canvas = FigureCanvas(self.figure)
            layout.addWidget(self.canvas)
            self.ax = self.figure.add_subplot(111)
            self.draw_gantt_chart()
        except ImportError:
            logger.error("Matplotlib nicht installiert.")
            error_label = QLabel("Matplotlib ist nicht installiert. Gantt-Diagramm kann nicht angezeigt werden.")
            error_label.setStyleSheet("color: red;")
            layout.addWidget(error_label)
        self.setLayout(layout)

    def update_chart(self, plan_data):
        self.plan_data = plan_data
        self.draw_gantt_chart()

    def draw_gantt_chart(self):
        try:
            from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
            from matplotlib.figure import Figure
            import matplotlib.dates as mdates
            from matplotlib.dates import date2num

            self.ax.clear()

            if not self.plan_data:
                self.ax.text(0.5, 0.5, 'Keine Daten zum Anzeigen', ha='center', va='center', transform=self.ax.transAxes, color='white')
            else:
                start_date = datetime.now()
                task_labels = []
                bar_positions = []
                bar_widths = []
                colors = []
                y_ticks = []
                y_labels = []
                y = 0

                for task in self.plan_data:
                    for goal in task.get('Goals', []):
                        goal_title = goal['Goal']
                        task_labels.append(goal_title)
                        y_ticks.append(y)
                        y_labels.append(f"{task['Title']} - {goal_title}")
                        bar_positions.append(date2num(start_date))
                        bar_widths.append(1)  # 1 Tag Dauer
                        status = goal.get('Status', 'pending')
                        colors.append(self.STATUS_COLORS.get(status, '#5bc0de'))
                        y += 1

                # Plotting
                self.ax.barh(
                    y=y_ticks,
                    width=bar_widths,
                    left=bar_positions,
                    height=0.4,
                    color=colors,
                    align='center'
                )

                self.ax.set_yticks(y_ticks)
                self.ax.set_yticklabels(y_labels, color='white', fontsize=8)
                self.ax.set_xlabel('Datum', color='white')
                self.ax.set_title('Gantt-Diagramm', color='white')

                self.ax.xaxis_date()
                self.ax.xaxis.set_major_locator(mdates.DayLocator())
                self.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d.%m'))

                for spine in self.ax.spines.values():
                    spine.set_edgecolor('white')

                self.ax.tick_params(axis='x', colors='white')
                self.ax.tick_params(axis='y', colors='white')

                self.ax.set_facecolor('#1e1e1e')
                self.figure.autofmt_xdate()

            self.canvas.draw()
        except Exception as e:
            logger.error(f"Fehler beim Zeichnen des Gantt-Diagramms: {e}")


class DetailChatArea(QScrollArea):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setStyleSheet("""
            QScrollArea { background-color: #1e1e1e; border: none; }
            QScrollBar:vertical { background-color: #2b2b2b; width: 12px; }
            QScrollBar::handle:vertical { background-color: #555; min-height: 20px; border-radius: 6px; }
            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
            QScrollBar::up-arrow:vertical, QScrollBar::down-arrow:vertical { background: none; }
        """)
        self.chat_container = QWidget()
        self.chat_layout = QVBoxLayout(self.chat_container)
        self.chat_layout.setAlignment(Qt.AlignTop)
        self.setWidgetResizable(True)
        self.setWidget(self.chat_container)

    def add_message(self, sender, message):
        msg = MessageWidget(sender, message)
        self.chat_layout.addWidget(msg)
        QTimer.singleShot(100, lambda: self.verticalScrollBar().setValue(
            self.verticalScrollBar().maximum()))


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('Intelligenter Assistent für Entwickler')
        self.setGeometry(100, 100, 1200, 800)  # Größeres Fenster für mehr Platz
        self.settings = {
            'available_models': [],
            'selected_model': '',
            'temperature': 0.7,
            'max_tokens': 150,
            'server_url': 'http://localhost',
            'server_port': 11434,
            'theme': 'Dark',
            'font': QFont("Arial", 10),
            'projects': [],
            'last_used_project': None,
            'context_file': os.path.join(BASE_DIR, 'context.json'),  # Kontextdatei
        }
        self.context_manager = ContextManager()
        self.context_manager.load_context(self.settings['context_file'])
        self.load_projects()
        self.llm_client = LLMClient(
            base_url=f"{self.settings['server_url']}:{self.settings['server_port']}",
            model_name=self.settings.get('selected_model', '')
        )
        self.command_dispatcher = CommandDispatcher(self, self.llm_client)
        self.plan_data, self.uploaded_files = [], []
        self.server_process = None
        self.task_processor = None
        self.init_ui()
        self.apply_styles()
        self.update_server_status()
        self.initialize_chat()
        self.detect_hardware()

    def detect_hardware(self):
        """Ermittelt die Hardware-Fähigkeiten des Nutzers und passt LLM-Einstellungen entsprechend an."""
        # Beispielhafte Hardware-Detektion mit psutil
        cpu_count = psutil.cpu_count(logical=False)
        ram = psutil.virtual_memory().total / (1024 ** 3)  # in GB
        logger.debug(f"Erkannte Hardware: {cpu_count} CPU-Kerne, {ram:.2f} GB RAM")
        # Basierend auf der Hardware die LLM-Einstellungen anpassen
        if ram < 8:
            self.llm_client.set_max_tokens(100)
            self.llm_client.set_context_size(1024)
            logger.debug("LLM-Einstellungen aufgrund begrenzter Hardware angepasst.")
        elif ram < 16:
            self.llm_client.set_max_tokens(150)
            self.llm_client.set_context_size(2048)
            logger.debug("LLM-Einstellungen aufgrund mittlerer Hardware angepasst.")
        else:
            self.llm_client.set_max_tokens(300)
            self.llm_client.set_context_size(4096)
            logger.debug("LLM-Einstellungen aufgrund leistungsstarker Hardware angepasst.")

    def load_projects(self):
        # Projekte aus einer JSON-Datei laden
        projects_file = os.path.join(BASE_DIR, 'projects.json')
        if os.path.exists(projects_file):
            try:
                with open(projects_file, 'r', encoding='utf-8') as f:
                    data = json.load(f)
                    self.settings['projects'] = data.get('projects', [])
                    self.settings['last_used_project'] = data.get('last_used_project')
                logger.debug("Projekte erfolgreich geladen.")
            except Exception as e:
                logger.error(f"Fehler beim Laden der Projekte: {e}")
                self.settings['projects'] = []
                self.settings['last_used_project'] = None
        else:
            self.settings['projects'] = []
            self.settings['last_used_project'] = None

    def save_projects(self):
        # Projekte in einer JSON-Datei speichern
        projects_file = os.path.join(BASE_DIR, 'projects.json')
        data = {
            'projects': self.settings['projects'],
            'last_used_project': self.settings['last_used_project']
        }
        try:
            with open(projects_file, 'w', encoding='utf-8') as f:
                json.dump(data, f, ensure_ascii=False, indent=4)
            logger.debug("Projekte erfolgreich gespeichert.")
        except Exception as e:
            logger.error(f"Fehler beim Speichern der Projekte: {e}")

    def init_ui(self):
        central_widget = QWidget()
        main_layout = QVBoxLayout()

        # Top Layout für Thought Clouds und Gantt Diagramm
        top_layout = QHBoxLayout()

        # Thought Cloud Widget
        self.thought_cloud = ThoughtCloudWidget()
        top_layout.addWidget(self.thought_cloud, alignment=Qt.AlignRight | Qt.AlignTop)

        # Gantt Diagramm Platzhalter
        self.gantt_chart = GanttChartWidget(self.plan_data)
        self.gantt_chart.setVisible(False)  # Anfangs versteckt
        top_layout.addWidget(self.gantt_chart, stretch=1)

        # Zwei Chat Bereiche: Hauptchat und Detailchat
        chat_layout = QHBoxLayout()

        # Hauptchat Bereich
        self.chat_area = QScrollArea()
        self.chat_area.setStyleSheet("""
            QScrollArea { background-color: #1e1e1e; border: none; }
            QScrollBar:vertical { background-color: #2b2b2b; width: 12px; }
            QScrollBar::handle:vertical { background-color: #555; min-height: 20px; border-radius: 6px; }
            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
            QScrollBar::up-arrow:vertical, QScrollBar::down-arrow:vertical { background: none; }
        """)
        self.chat_container = QWidget()
        self.chat_layout = QVBoxLayout(self.chat_container)
        self.chat_layout.setAlignment(Qt.AlignTop)
        self.chat_area.setWidgetResizable(True)
        self.chat_area.setWidget(self.chat_container)

        # Detailchat Bereich (schreibgeschützt)
        self.detail_chat_area = DetailChatArea()
        self.detail_chat_area.setFixedWidth(400)  # Feste Breite für Detailchat

        chat_layout.addWidget(self.chat_area, stretch=2)
        chat_layout.addWidget(self.detail_chat_area, stretch=1)

        # Loading Animation
        self.loading_label = QLabel()
        self.loading_label.setAlignment(Qt.AlignCenter)
        loading_gif = os.path.join(BASE_DIR, "loading.gif")
        if os.path.exists(loading_gif):
            self.loading_movie = QMovie(loading_gif)
            if self.loading_movie.isValid():
                self.loading_label.setMovie(self.loading_movie)
                self.loading_movie.start()
            else:
                self.loading_label.setText("Loading...")
        else:
            self.loading_label.setText("Loading...")
        self.loading_label.setVisible(False)

        # Chat Eingabe
        self.chat_input = ChatInputWidget()
        self.chat_input.send_message.connect(self.handle_user_message)

        # Fortschrittsbalken
        self.progress_bar = QProgressBar()
        self.progress_bar.setValue(0)
        self.progress_bar.setAlignment(Qt.AlignCenter)
        self.progress_bar.setStyleSheet("""
            QProgressBar {
                border: 1px solid #555;
                border-radius: 5px;
                text-align: center;
                height: 20px;
                background-color: #2b2b2b;
                color: #fff;
                font-size: 12pt;
            }
            QProgressBar::chunk { background-color: #5bc0de; width: 20px; }
        """)

        # Menüleiste
        self.init_menu()

        main_layout.addLayout(top_layout)
        main_layout.addLayout(chat_layout, stretch=3)
        main_layout.addWidget(self.loading_label)
        main_layout.addWidget(self.progress_bar)
        main_layout.addWidget(self.chat_input)
        main_layout.setStretch(0, 0)  # Top Layout dehnt sich nicht aus
        main_layout.setStretch(1, 3)  # Chat Bereich dehnt sich mehr aus
        main_layout.setStretch(2, 0)  # Loading Label dehnt sich nicht aus
        main_layout.setStretch(3, 0)  # Fortschrittsbalken dehnt sich nicht aus
        main_layout.setStretch(4, 0)  # Chat Eingabe dehnt sich nicht aus
        central_widget.setLayout(main_layout)
        self.setCentralWidget(central_widget)

    def init_menu(self):
        menubar = self.menuBar()

        # Datei-Menü
        file_menu = menubar.addMenu('&Datei')

        new_proj_action = file_menu.addAction('Neues Projekt')
        new_proj_action.triggered.connect(self.new_project_command)

        save_proj_action = file_menu.addAction('Projekt speichern')
        save_proj_action.triggered.connect(self.save_project_command)

        load_proj_action = file_menu.addAction('Projekt laden')
        load_proj_action.triggered.connect(self.load_project_command)

        delete_proj_action = file_menu.addAction('Projekt löschen')
        delete_proj_action.triggered.connect(self.delete_project_command)

        file_menu.addSeparator()

        exit_action = file_menu.addAction('Beenden')
        exit_action.triggered.connect(self.close)

        # Einstellungen-Menü
        settings_menu = menubar.addMenu('&Einstellungen')

        open_settings_action = settings_menu.addAction('Einstellungen öffnen')
        open_settings_action.triggered.connect(self.open_settings_dialog_command)

        switch_llm_action = settings_menu.addAction('LLM wechseln')
        switch_llm_action.triggered.connect(self.switch_llm_command)

        # Hilfe-Menü
        help_menu = menubar.addMenu('&Hilfe')

        about_action = help_menu.addAction('Über')
        about_action.triggered.connect(self.show_about_dialog)

    def initialize_chat(self):
        # Initialer Prompt an LLM zur Generierung einer Willkommensnachricht
        prompt = """
Sie sind ein intelligenter Assistent, der Nutzern hilft, ihre Entwicklungsprojekte zu verwalten.
Begrüßen Sie den Benutzer und bieten Sie Hilfe an.
"""
        response = self.llm_client.generate(prompt, temperature=self.settings['temperature'], max_tokens=150)
        self.chat_area_add_message("Assistent", response)
        self.detail_chat_area.add_message("Assistent", response)
        self.context_manager.update_context("Willkommensnachricht", response)

    def handle_user_message(self, message):
        self.chat_area_add_message("Benutzer", message)
        self.detail_chat_area.add_message("Benutzer", message)
        self.loading_label.setVisible(True)
        threading.Thread(target=self.process_message, args=(message,), daemon=True).start()

    def process_message(self, message):
        # Konstruktion des Prompts zur Anweisung des LLM
        prompt = f"""
Sie sind ein intelligenter Assistent, der Nutzern hilft, ihre Entwicklungsprojekte zu verwalten.
Sie können Aktionen wie start_server, stop_server, upload_files, remove_files, change_setting,
save_project, load_project, create_new_project, start_analysis, start_processing,
pause_processing, resume_processing, stop_processing, toggle_gantt_chart, generate_final_report, switch_llm, delete_project ausführen.

Wenn eine Benutzeranfrage eine Aktion erfordert, antworten Sie mit einem JSON-Objekt:
{{"action": "action_name", "params": {{...}}}}

Andernfalls antworten Sie mit einer hilfreichen Nachricht.

Benutzeranfrage: "{message}"
"""
        response = self.llm_client.generate(prompt, temperature=self.settings['temperature'], max_tokens=self.settings['max_tokens'], context_size=self.llm_client.context_size)
        self.loading_label.setVisible(False)
        try:
            # Versuch, die Antwort als JSON zu parsen
            command = json.loads(response)
            if isinstance(command, dict) and 'action' in command:
                self.command_dispatcher.dispatch(command)
                # Thought Cloud anzeigen
                self.thought_cloud.display_message(f"Aktion '{command['action']}' wird ausgeführt...")
                QTimer.singleShot(3000, self.thought_cloud.clear_message)
            else:
                # Wenn keine Aktion, als normale Nachricht behandeln
                self.chat_area_add_message("Assistent", response)
                self.detail_chat_area.add_message("Assistent", response)
                # Thought Cloud mit der Antwort anzeigen
                self.thought_cloud.display_message("Neue Information vom Assistenten.")
                QTimer.singleShot(3000, self.thought_cloud.clear_message)
        except json.JSONDecodeError:
            # Falls Parsing fehlschlägt, als normale Nachricht behandeln
            self.chat_area_add_message("Assistent", response)
            self.detail_chat_area.add_message("Assistent", response)
            # Thought Cloud mit der Antwort anzeigen
            self.thought_cloud.display_message("Neue Information vom Assistenten.")
            QTimer.singleShot(3000, self.thought_cloud.clear_message)

    def chat_area_add_message(self, sender, message):
        msg = MessageWidget(sender, message)
        self.chat_layout.addWidget(msg)
        QTimer.singleShot(100, lambda: self.chat_area.verticalScrollBar().setValue(
            self.chat_area.verticalScrollBar().maximum()))
        if sender not in ["Benutzer", "System"]:
            self.detail_chat_area.add_message(sender, message)

    def switch_llm_command(self, **kwargs):
        # Dialog zum Wechseln des LLMs
        dlg = SwitchLLMDialog(self.settings, self)
        if dlg.exec_() == QDialog.Accepted:
            selected_llm = dlg.selected_llm
            if selected_llm in self.settings['available_models']:
                self.llm_client.set_model(selected_llm)
                self.command_dispatcher.llm_client = self.llm_client
                logger.debug(f"Aktives LLM zu {selected_llm} gewechselt.")
                self.chat_area_add_message("System", f"Aktives LLM wurde zu {selected_llm} gewechselt.")
                self.detail_chat_area.add_message("System", f"Aktives LLM wurde zu {selected_llm} gewechselt.")
            else:
                self.chat_area_add_message("System", "Ungültige LLM-Auswahl.")
                logger.warning("Ungültige LLM-Auswahl getroffen.")

    def start_server_command(self, **kwargs):
        self.start_server()

    def stop_server_command(self, **kwargs):
        self.stop_server()

    def upload_files_command(self, **kwargs):
        # Erwartet 'files' Parameter als Liste von Dateipfaden
        files = kwargs.get('files', [])
        if files:
            accessible_files = [f for f in files if os.path.isfile(f)]
            if accessible_files:
                self.uploaded_files.extend(accessible_files)
                self.display_uploaded_files()
                self.chat_area_add_message("System", f"{len(accessible_files)} Datei(en) über Befehl hochgeladen.")
                self.detail_chat_area.add_message("System", f"{len(accessible_files)} Datei(en) über Befehl hochgeladen.")
                logger.debug(f"Hochgeladene Dateien über Befehl: {accessible_files}")
            else:
                self.chat_area_add_message("System", "Keine gültigen Dateien zum Hochladen bereitgestellt.")
                self.detail_chat_area.add_message("System", "Keine gültigen Dateien zum Hochladen bereitgestellt.")
        else:
            self.chat_area_add_message("System", "Keine Dateien für den Upload bereitgestellt.")
            self.detail_chat_area.add_message("System", "Keine Dateien für den Upload bereitgestellt.")

    def remove_selected_files_command(self, **kwargs):
        # Erwartet 'files' Parameter als Liste von zu entfernenden Dateipfaden
        files = kwargs.get('files', [])
        if files:
            removed = [f for f in files if f in self.uploaded_files]
            for f in removed:
                self.uploaded_files.remove(f)
            self.display_uploaded_files()
            self.chat_area_add_message("System", f"{len(removed)} Datei(en) über Befehl entfernt.")
            self.detail_chat_area.add_message("System", f"{len(removed)} Datei(en) über Befehl entfernt.")
            logger.debug(f"Entfernte Dateien über Befehl: {removed}")
        else:
            self.chat_area_add_message("System", "Keine Dateien für die Entfernung bereitgestellt.")
            self.detail_chat_area.add_message("System", "Keine Dateien für die Entfernung bereitgestellt.")

    def change_setting(self, **kwargs):
        # Erwartet 'setting' und 'value' Parameter
        setting = kwargs.get('setting')
        value = kwargs.get('value')
        if setting and value is not None:
            if setting in self.settings:
                self.settings[setting] = value
                if setting == 'selected_model':
                    self.llm_client.set_model(value)
                elif setting == 'temperature':
                    self.llm_client.set_temperature(value)
                elif setting == 'max_tokens':
                    self.llm_client.set_max_tokens(value)
                elif setting == 'context_size':
                    self.llm_client.set_context_size(value)
                self.apply_styles()
                self.chat_area_add_message("System", f"Einstellung '{setting}' auf '{value}' geändert.")
                self.detail_chat_area.add_message("System", f"Einstellung '{setting}' auf '{value}' geändert.")
                logger.debug(f"Einstellung '{setting}' auf '{value}' geändert.")
            else:
                self.chat_area_add_message("System", f"Einstellung '{setting}' existiert nicht.")
                logger.warning(f"Versuch, nicht vorhandene Einstellung '{setting}' zu ändern.")
        else:
            self.chat_area_add_message("System", "Ungültige Parameter zum Ändern der Einstellungen.")
            logger.warning("Ungültige Parameter zum Ändern der Einstellungen.")

    def save_project_command(self, **kwargs):
        self.save_project()

    def load_project_command(self, **kwargs):
        self.load_project()

    def new_project_command(self, **kwargs):
        self.new_project()

    def delete_project_command(self, **kwargs):
        self.delete_project()

    def start_analysis_command(self, **kwargs):
        # Diese Funktion sammelt typischerweise die Beschreibung und startet die Analyse
        description, ok = QInputDialog.getText(self, "Projektbeschreibung", "Geben Sie die Projektbeschreibung ein:")
        if ok and description:
            self.settings['description_text'] = description  # Speichern der Beschreibung
            self.context_manager.update_context("Projektbeschreibung", description)
            # Analyse starten
            self.chat_area_add_message("System", "Analyse des Projekts gestartet.")
            self.detail_chat_area.add_message("System", "Analyse des Projekts gestartet.")
            logger.debug("Projektbeschreibung eingegeben und Analyse gestartet.")
            # Beispiel: Generieren eines Entwicklungsplans basierend auf der Beschreibung
            prompt = f"""
Auf Basis der folgenden Beschreibung erstellen Sie einen detaillierten Entwicklungsplan.

Beschreibung:
{description}

Bitte liefern Sie den Plan als JSON-Objekt mit dem Format:
[
    {{
        "Title": "Abschnittstitel",
        "Goals": [
            {{"Goal": "Ziel 1"}},
            {{"Goal": "Ziel 2"}}
        ]
    }},
    ...
]
"""
            plan_response = self.llm_client.generate(prompt, temperature=self.settings['temperature'], max_tokens=500, context_size=self.llm_client.context_size)
            try:
                self.plan_data = json.loads(plan_response)
                self.chat_area_add_message("System", "Entwicklungsplan erstellt.")
                self.detail_chat_area.add_message("System", "Entwicklungsplan erstellt.")
                logger.debug("Entwicklungsplan erstellt.")
                # Speichern des Plans
                self.context_manager.update_context("Entwicklungsplan", plan_response)
                # Aktualisiere Gantt-Diagramm
                self.gantt_chart.update_chart(self.plan_data)
                self.gantt_chart.setVisible(True)
            except json.JSONDecodeError:
                # Falls die Antwort kein gültiger JSON ist, verwende Standard
                self.plan_data = []
                self.chat_area_add_message("System", "Entwicklungsplan erstellt (Standardplan).")
                self.detail_chat_area.add_message("System", "Entwicklungsplan erstellt (Standardplan).")
                logger.debug("Standard-Entwicklungsplan verwendet.")
                # Beispiel: Standardplan definieren
                self.plan_data = [
                    {
                        'Title': 'Initiale Planung',
                        'Goals': [{'Goal': 'Anforderungen sammeln'}, {'Goal': 'Projektstruktur aufbauen'}]
                    },
                    {
                        'Title': 'Entwicklung',
                        'Goals': [{'Goal': 'Modul A entwickeln'}, {'Goal': 'Modul B entwickeln'}]
                    }
                ]
                # Aktualisiere Gantt-Diagramm
                self.gantt_chart.update_chart(self.plan_data)
                self.gantt_chart.setVisible(True)
        elif ok:
            self.chat_area_add_message("System", "Projektbeschreibung darf nicht leer sein.")
            self.detail_chat_area.add_message("System", "Projektbeschreibung darf nicht leer sein.")
            logger.warning("Analyse ohne Beschreibung angefragt.")

    def start_processing_command(self, **kwargs):
        self.start_processing()

    def start_processing(self):
        if not self.plan_data:
            self.chat_area_add_message("System", "Kein Entwicklungsplan verfügbar. Bitte zuerst Analyse starten.")
            logger.warning("Verarbeitung ohne Entwicklungsplan gestartet.")
            return
        if not self.llm_client.model_name:
            self.chat_area_add_message("System", "Kein LLM ausgewählt. Bitte Modell über Einstellungen wählen.")
            logger.warning("Verarbeitung ohne LLM-Auswahl gestartet.")
            return
        self.chat_area_add_message("System", "Verarbeitung der Aufgaben gestartet...")
        self.detail_chat_area.add_message("System", "Verarbeitung der Aufgaben gestartet...")
        self.task_processor = TaskProcessor(self.plan_data, self.llm_client, self.context_manager)
        self.task_processor.progress_updated.connect(self.update_progress)
        self.task_processor.task_message.connect(self.chat_area_add_message)
        self.task_processor.task_result.connect(self.chat_area_add_message)
        self.task_processor.task_status.connect(self.update_task_status)
        self.task_processor.finished.connect(self.processing_finished)
        self.task_processor.start()
        logger.debug("Task-Verarbeitung gestartet.")

    def pause_processing_command(self, **kwargs):
        self.pause_processing()

    def pause_processing(self):
        if hasattr(self, 'task_processor') and self.task_processor.isRunning():
            self.task_processor.pause()
            self.chat_area_add_message("System", "Verarbeitung pausiert.")
            self.detail_chat_area.add_message("System", "Verarbeitung pausiert.")
            logger.debug("Verarbeitung pausiert.")
        else:
            self.chat_area_add_message("System", "Keine laufende Verarbeitung zum Pausieren.")
            self.detail_chat_area.add_message("System", "Keine laufende Verarbeitung zum Pausieren.")
            logger.info("Pause-Verarbeitung ohne aktive Prozesse angefragt.")

    def resume_processing_command(self, **kwargs):
        self.resume_processing()

    def resume_processing(self):
        if hasattr(self, 'task_processor') and self.task_processor.isRunning():
            self.task_processor.resume()
            self.chat_area_add_message("System", "Verarbeitung fortgesetzt.")
            self.detail_chat_area.add_message("System", "Verarbeitung fortgesetzt.")
            logger.debug("Verarbeitung fortgesetzt.")
        else:
            self.chat_area_add_message("System", "Keine pausierte Verarbeitung zum Fortsetzen.")
            self.detail_chat_area.add_message("System", "Keine pausierte Verarbeitung zum Fortsetzen.")
            logger.info("Fortsetzen-Verarbeitung ohne pausierte Prozesse angefragt.")

    def stop_processing_command(self, **kwargs):
        self.stop_processing()

    def stop_processing(self):
        if hasattr(self, 'task_processor') and self.task_processor.isRunning():
            self.task_processor.stop()
            self.task_processor.wait()
            self.chat_area_add_message("System", "Verarbeitung gestoppt.")
            self.detail_chat_area.add_message("System", "Verarbeitung gestoppt.")
            self.progress_bar.setValue(0)
            self.loading_label.setVisible(False)
            # Speichern des Kontextes bei Abbruch
            self.context_manager.save_context(self.settings['context_file'])
            logger.debug("Verarbeitung gestoppt.")
        else:
            self.chat_area_add_message("System", "Keine laufende Verarbeitung zum Stoppen.")
            self.detail_chat_area.add_message("System", "Keine laufende Verarbeitung zum Stoppen.")
            logger.info("Stop-Verarbeitung ohne aktive Prozesse angefragt.")

    def toggle_gantt_chart_command(self, **kwargs):
        self.toggle_gantt_chart()

    def toggle_gantt_chart(self):
        self.gantt_chart.setVisible(not self.gantt_chart.isVisible())
        state = "aktiviert" if self.gantt_chart.isVisible() else "deaktiviert"
        self.chat_area_add_message("System", f"Gantt-Diagramm Anzeige {state}.")
        self.detail_chat_area.add_message("System", f"Gantt-Diagramm Anzeige {state}.")
        logger.debug(f"Gantt-Diagramm Anzeige {state}.")

    def generate_final_report_command(self, **kwargs):
        self.generate_final_report()

    def generate_final_report(self):
        if hasattr(self, 'task_processor') and hasattr(self.task_processor, 'generate_final_result'):
            final = self.task_processor.generate_final_result()
            self.chat_area_add_message("Assistent", final)
            self.detail_chat_area.add_message("Assistent", final)
            # Thought Cloud anzeigen
            self.thought_cloud.display_message("Abschlussbericht generiert.")
            QTimer.singleShot(5000, self.thought_cloud.clear_message)
            # Optional: Speichern des Abschlussberichts
            report_file = os.path.join(BASE_DIR, 'final_report.txt')
            try:
                with open(report_file, 'w', encoding='utf-8') as f:
                    f.write(final)
                logger.debug(f"Abschlussbericht gespeichert unter {report_file}.")
            except Exception as e:
                logger.error(f"Fehler beim Speichern des Abschlussberichts: {e}")
        else:
            self.chat_area_add_message("System", "Kein Abschlussbericht verfügbar. Bitte zuerst Verarbeitung starten.")
            self.detail_chat_area.add_message("System", "Kein Abschlussbericht verfügbar. Bitte zuerst Verarbeitung starten.")
            logger.warning("Abschlussbericht ohne aktiven TaskProcessor angefragt.")

    def open_settings_dialog_command(self, **kwargs):
        self.open_settings_dialog()

    def open_settings_dialog(self):
        dlg = SettingsDialog(self.settings, self)
        if dlg.exec_() == QDialog.Accepted:
            self.settings = dlg.settings
            self.apply_styles()
            # Aktualisiere LLMClient base_url korrekt mit server_port
            self.llm_client.base_url = f"{self.settings['server_url'].rstrip(':')}" \
                                       f":{self.settings['server_port']}"
            self.update_server_status()
            self.chat_area_add_message("System", "Einstellungen erfolgreich aktualisiert.")
            self.detail_chat_area.add_message("System", "Einstellungen erfolgreich aktualisiert.")
            # Aktualisiere die Temperatur, max_tokens und context_size im LLMClient
            self.llm_client.set_temperature(self.settings.get('temperature', 0.7))
            self.llm_client.set_max_tokens(self.settings.get('max_tokens', 150))
            self.llm_client.set_context_size(self.llm_client.context_size)  # Kann angepasst werden
            # Aktualisiere LLM-Modelle bei Änderung
            self.update_llm_list()

    def show_about_dialog(self):
        QMessageBox.about(self, "Über", "Intelligenter Assistent für Entwickler\nVersion 2.6\n\nEntwickelt, um Entwicklern bei der Erstellung umfassender Entwicklungspläne und Skripte mit Hilfe von LLMs zu unterstützen.")

    def closeEvent(self, event):
        reply = QMessageBox.question(self, 'Bestätigen', 'Möchten Sie die Anwendung wirklich beenden?', QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
        if reply == QMessageBox.Yes:
            if self.server_process and self.server_process.poll() is None:
                try:
                    self.server_process.terminate()
                    self.server_process.wait(timeout=10)
                    logger.debug("Server beim Beenden beendet.")
                except subprocess.TimeoutExpired:
                    self.server_process.kill()
                    logger.error("Server wurde beim Beenden zwangsweise beendet.")
            if hasattr(self, 'task_processor') and self.task_processor.isRunning():
                self.task_processor.stop()
                self.task_processor.wait()
                logger.debug("TaskProcessor beim Beenden beendet.")
            self.save_projects()
            # Speichern des Kontextes beim Beenden
            self.context_manager.save_context(self.settings['context_file'])
            event.accept()
        else:
            event.ignore()

    def font_to_dict(self, font):
        return {
            'family': font.family(),
            'pointSize': font.pointSize(),
            'bold': font.bold(),
            'italic': font.italic(),
            'underline': font.underline(),
            'strikeOut': font.strikeOut(),
            'weight': font.weight(),
            'style': font.style(),
            'styleHint': font.styleHint()
        }

    def dict_to_font(self, d):
        font = QFont()
        font.setFamily(d.get('family', "Arial"))
        font.setPointSize(d.get('pointSize', 10))
        font.setBold(d.get('bold', False))
        font.setItalic(d.get('italic', False))
        font.setUnderline(d.get('underline', False))
        font.setStrikeOut(d.get('strikeOut', False))
        font.setWeight(d.get('weight', QFont.Normal))
        font.setStyle(d.get('style', QFont.StyleNormal))
        font.setStyleHint(d.get('styleHint', QFont.AnyStyle))
        return font

    def update_progress(self, value):
        self.progress_bar.setValue(value)
        self.detail_chat_area.add_message("System", f"Fortschritt: {value}%")

    def update_task_status(self, task_index, goal_index, status):
        """
        Aktualisiert den Status einer bestimmten Aufgabe und eines Ziels im Gantt-Diagramm.

        :param task_index: Index der Aufgabe im Entwicklungsplan.
        :param goal_index: Index des Ziels innerhalb der Aufgabe.
        :param status: Aktueller Status der Aufgabe/Ziel (z.B. 'processing', 'completed', 'error', 'failed').
        """
        # Aktualisiere die internal plan_data mit dem neuen Status
        goal_data = self.plan_data[task_index]['Goals'][goal_index]
        goal_data['Status'] = status

        # Aktualisiere das Gantt-Diagramm visuell
        self.gantt_chart.update_chart(self.plan_data)

        # Zusätzliche visuelle oder logische Aktionen können hier hinzugefügt werden
        if status == 'completed':
            self.thought_cloud.display_message(f"Ziel '{goal_data['Goal']}' abgeschlossen.")
            QTimer.singleShot(3000, self.thought_cloud.clear_message)
        elif status == 'failed':
            self.thought_cloud.display_message(f"Ziel '{goal_data['Goal']}' fehlgeschlagen.")
            QTimer.singleShot(5000, self.thought_cloud.clear_message)
        elif status == 'processing':
            self.thought_cloud.display_message(f"Ziel '{goal_data['Goal']}' wird verarbeitet.")
            QTimer.singleShot(3000, self.thought_cloud.clear_message)
        elif status == 'error':
            self.thought_cloud.display_message(f"Ein Fehler ist bei '{goal_data['Goal']}' aufgetreten.")
            QTimer.singleShot(5000, self.thought_cloud.clear_message)

    def processing_finished(self):
        self.progress_bar.setValue(100)
        self.chat_area_add_message("System", "Verarbeitung abgeschlossen.")
        self.detail_chat_area.add_message("System", "Verarbeitung abgeschlossen.")
        logger.debug("Verarbeitung abgeschlossen.")
        # Aktualisiere Gantt-Diagramm
        self.gantt_chart.update_chart(self.plan_data)
        if self.plan_data:
            self.gantt_chart.setVisible(True)
        # Thought Cloud Notification
        self.thought_cloud.display_message("Verarbeitung abgeschlossen.")
        QTimer.singleShot(5000, self.thought_cloud.clear_message)
        # Speichern des Kontextes nach Abschluss
        self.context_manager.save_context(self.settings['context_file'])

    def add_or_update_project(self, project_name):
        existing = next((p for p in self.settings['projects'] if p['name'] == project_name), None)
        if not existing:
            self.settings['projects'].append({'name': project_name})
        self.settings['last_used_project'] = project_name
        self.save_projects()
        self.chat_area_add_message("System", f"Projekt '{project_name}' wurde hinzugefügt/aktualisiert.")
        self.detail_chat_area.add_message("System", f"Projekt '{project_name}' wurde hinzugefügt/aktualisiert.")
        logger.debug(f"Projekt '{project_name}' wurde in der Liste aktualisiert.")

    def delete_project(self):
        if not self.settings['projects']:
            self.chat_area_add_message("System", "Keine Projekte zum Löschen vorhanden.")
            self.detail_chat_area.add_message("System", "Keine Projekte zum Löschen vorhanden.")
            logger.info("Löschanfrage ohne vorhandene Projekte.")
            return
        dlg = DeleteProjectDialog(self.settings['projects'], self)
        if dlg.exec_() == QDialog.Accepted:
            project_to_delete = dlg.selected_project
            self.settings['projects'] = [p for p in self.settings['projects'] if p['name'] != project_to_delete]
            if self.settings['last_used_project'] == project_to_delete:
                self.settings['last_used_project'] = self.settings['projects'][0]['name'] if self.settings['projects'] else None
            self.save_projects()
            self.chat_area_add_message("System", f"Projekt '{project_to_delete}' wurde gelöscht.")
            self.detail_chat_area.add_message("System", f"Projekt '{project_to_delete}' wurde gelöscht.")
            logger.debug(f"Projekt '{project_to_delete}' wurde gelöscht.")

    def request_confirmation(self, message):
        result = QMessageBox.question(self, "Bestätigung erforderlich", message, QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
        return result == QMessageBox.Yes

    def update_llm_list(self):
        self.settings['available_models'] = self.llm_client.get_models()
        if self.settings['available_models']:
            if not self.settings.get('selected_model') or self.settings['selected_model'] not in self.settings['available_models']:
                self.settings['selected_model'] = self.settings['available_models'][0]
                self.llm_client.set_model(self.settings['selected_model'])
            models = ', '.join(self.settings['available_models'])
            self.chat_area_add_message("System", f"Verfügbare Modelle: {models}.")
            self.detail_chat_area.add_message("System", f"Verfügbare Modelle: {models}.")
        else:
            logger.warning("Keine Modelle gefunden.")
            self.chat_area_add_message("System", "Keine Modelle auf dem LLM-Server gefunden.")
            self.detail_chat_area.add_message("System", "Keine Modelle auf dem LLM-Server gefunden.")
            # Beim ersten Start LLM-Auswahl erzwingen
            self.prompt_llm_selection()

    def prompt_llm_selection(self):
        QMessageBox.warning(self, "LLM-Auswahl erforderlich", "Es wurden keine LLM-Modelle gefunden oder ausgewählt. Bitte wählen Sie ein verfügbares Modell aus den Einstellungen.")
        self.open_settings_dialog()

    def update_server_status(self):
        running = self.check_server_running()
        if running:
            self.chat_area_add_message("System", "Serverstatus: 🟢 Läuft")
            self.detail_chat_area.add_message("System", "Serverstatus: 🟢 Läuft")
            self.update_llm_list()
        else:
            self.chat_area_add_message("System", "Serverstatus: 🔴 Gestoppt")
            self.detail_chat_area.add_message("System", "Serverstatus: 🔴 Gestoppt")
            self.settings['available_models'] = []
            self.settings['selected_model'] = ''
            # Beim ersten Start LLM-Auswahl erzwingen
            self.prompt_llm_selection()

    def check_server_running(self):
        try:
            response = requests.get(f'{self.llm_client.base_url}/api/tags', timeout=5)
            return response.status_code == 200
        except requests.RequestException:
            return False

    def start_server(self):
        if self.check_server_running():
            self.chat_area_add_message("System", "Server läuft bereits.")
            self.detail_chat_area.add_message("System", "Server läuft bereits.")
            logger.info("Serverstart versucht, aber bereits aktiv.")
            return
        try:
            llm_cmd = 'ollama'  # Stellen Sie sicher, dass 'ollama' installiert und im PATH ist
            server_path = shutil.which(llm_cmd)
            if not server_path:
                self.chat_area_add_message("System", f"Befehl '{llm_cmd}' nicht gefunden.")
                self.detail_chat_area.add_message("System", f"Befehl '{llm_cmd}' nicht gefunden.")
                logger.error(f"Befehl '{llm_cmd}' nicht gefunden.")
                return
            args = [llm_cmd, 'serve', '--port', str(self.settings['server_port'])]
            creation = subprocess.CREATE_NEW_CONSOLE if os.name == 'nt' else 0
            self.server_process = subprocess.Popen(
                args,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                shell=(os.name == 'nt'),
                creationflags=creation
            )
            self.chat_area_add_message("System", "LLM-Server wird gestartet...")
            self.detail_chat_area.add_message("System", "LLM-Server wird gestartet...")
            self.server_timer = QTimer()
            self.server_timer.timeout.connect(self.check_server_startup)
            self.server_timer.start(1000)
            self.server_startup_attempts = 0
            logger.debug("LLM-Serverstart initiiert.")
        except Exception as e:
            self.chat_area_add_message("System", f"Serverstart fehlgeschlagen: {e}")
            self.detail_chat_area.add_message("System", f"Serverstart fehlgeschlagen: {e}")
            logger.error(f"Fehler beim Serverstart: {e}")

    def check_server_startup(self):
        self.server_startup_attempts += 1
        if self.check_server_running():
            self.server_timer.stop()
            self.server_timer = None
            self.update_server_status()
            self.chat_area_add_message("System", "LLM-Server gestartet.")
            self.detail_chat_area.add_message("System", "LLM-Server gestartet.")
            logger.debug("LLM-Server erfolgreich gestartet.")
            self.save_projects()
            # Beim erfolgreichen Start Modelle aktualisieren
            self.update_llm_list()
            # Wenn keine Modelle ausgewählt sind, Benutzer auffordern
            if not self.settings['selected_model']:
                self.prompt_llm_selection()
        elif self.server_startup_attempts >= 15:
            self.server_timer.stop()
            self.server_timer = None
            self.chat_area_add_message("System", "Server konnte nicht rechtzeitig gestartet werden.")
            self.detail_chat_area.add_message("System", "Server konnte nicht rechtzeitig gestartet werden.")
            QMessageBox.warning(self, "Warnung", "Server wurde nicht innerhalb der erwarteten Zeit gestartet.")
            self.update_server_status()
            logger.error("LLM-Server konnte nicht innerhalb von 15 Sekunden gestartet werden.")

    def stop_server(self):
        if self.server_process and self.server_process.poll() is None:
            try:
                self.server_process.terminate()
                self.server_process.wait(timeout=10)
                self.server_process = None
                self.chat_area_add_message("System", "LLM-Server gestoppt.")
                self.detail_chat_area.add_message("System", "LLM-Server gestoppt.")
                logger.debug("LLM-Server gestoppt.")
                self.update_server_status()
                self.save_projects()
            except subprocess.TimeoutExpired:
                self.server_process.kill()
                self.server_process = None
                self.chat_area_add_message("System", "LLM-Server wurde zwangsweise gestoppt.")
                self.detail_chat_area.add_message("System", "LLM-Server wurde zwangsweise gestoppt.")
                self.update_server_status()
                logger.error("LLM-Server wurde zwangsweise gestoppt.")
            except Exception as e:
                self.chat_area_add_message("System", f"Server konnte nicht gestoppt werden: {e}")
                self.detail_chat_area.add_message("System", f"Server konnte nicht gestoppt werden: {e}")
                logger.error(f"Fehler beim Serverstopp: {e}")
        else:
            self.chat_area_add_message("System", "Server läuft nicht.")
            self.detail_chat_area.add_message("System", "Server läuft nicht.")
            logger.info("Serverstopp versucht, aber Server läuft nicht.")

    def upload_files(self):
        files, _ = QFileDialog.getOpenFileNames(self, "Dateien auswählen", "", "Alle Dateien (*)")
        new = [f for f in files if f not in self.uploaded_files]
        if new:
            self.uploaded_files.extend(new)
            logger.debug(f"Hochgeladene Dateien: {new}")
            self.chat_area_add_message("System", f"{len(new)} Datei(en) hochgeladen.")
            self.detail_chat_area.add_message("System", f"{len(new)} Datei(en) hochgeladen.")
            self.display_uploaded_files()
        else:
            self.chat_area_add_message("System", "Keine neuen Dateien hochgeladen (Duplikate übersprungen).")
            self.detail_chat_area.add_message("System", "Keine neuen Dateien hochgeladen (Duplikate übersprungen).")

    def display_uploaded_files(self):
        # Informationen über hochgeladene Dateien im Chat anzeigen
        if self.uploaded_files:
            file_list = "\n".join(self.uploaded_files)
            self.chat_area_add_message("System", f"Hochgeladene Dateien:\n{file_list}")
            self.detail_chat_area.add_message("System", f"Hochgeladene Dateien:\n{file_list}")
        else:
            self.chat_area_add_message("System", "Keine Dateien hochgeladen.")
            self.detail_chat_area.add_message("System", "Keine Dateien hochgeladen.")

    def save_project(self):
        # Projekt über Dialog speichern
        file, _ = QFileDialog.getSaveFileName(self, "Projekt speichern", "", "JSON Dateien (*.json)")
        if file:
            project = {
                'name': self.settings.get('last_used_project', 'Neues Projekt'),
                'description': self.settings.get('description_text', ''),
                'uploaded_files': self.uploaded_files,
                'plan_data': self.plan_data,
                'settings': {
                    'selected_model': self.settings.get('selected_model', ''),
                    'temperature': self.settings.get('temperature', 0.7),
                    'max_tokens': self.settings.get('max_tokens', 150),
                    'server_url': self.settings.get('server_url', 'http://localhost'),
                    'server_port': self.settings.get('server_port', 11434),
                    'theme': self.settings.get('theme', 'Dark'),
                    'font': self.font_to_dict(self.settings.get('font', QFont("Arial", 10)))
                },
                'results_storage': self.task_processor.results_storage if self.task_processor else {}
            }
            try:
                with open(file, 'w', encoding='utf-8') as f:
                    json.dump(project, f, ensure_ascii=False, indent=4)
                self.chat_area_add_message("System", "Projekt erfolgreich gespeichert.")
                self.detail_chat_area.add_message("System", "Projekt erfolgreich gespeichert.")
                logger.debug(f"Projekt gespeichert unter {file}.")
                # Update Projektliste
                self.add_or_update_project(project['name'])
            except Exception as e:
                self.chat_area_add_message("System", f"Projekt konnte nicht gespeichert werden: {e}")
                self.detail_chat_area.add_message("System", f"Projekt konnte nicht gespeichert werden: {e}")
                logger.error(f"Fehler beim Speichern des Projekts: {e}")

    def load_project(self):
        # Projekt über Dialog laden
        file, _ = QFileDialog.getOpenFileName(self, "Projekt laden", "", "JSON Dateien (*.json)")
        if file:
            try:
                with open(file, 'r', encoding='utf-8') as f:
                    project = json.load(f)
                # Annahme: 'description' ist Teil des Projekts
                load_description = QMessageBox.question(self, "Beschreibung laden", "Möchten Sie die Projektbeschreibung laden?", QMessageBox.Yes | QMessageBox.No)
                if load_description == QMessageBox.Yes:
                    description = project.get('description', '')
                    self.chat_area_add_message("System", f"Geladene Beschreibung:\n{description}")
                    self.detail_chat_area.add_message("System", f"Geladene Beschreibung:\n{description}")
                    self.settings['description_text'] = description
                    self.context_manager.update_context("Projektbeschreibung", description)
                self.uploaded_files = project.get('uploaded_files', [])
                if self.uploaded_files:
                    self.chat_area_add_message("System", f"Hochgeladene Dateien:\n" + "\n".join(self.uploaded_files))
                    self.detail_chat_area.add_message("System", f"Hochgeladene Dateien:\n" + "\n".join(self.uploaded_files))
                self.plan_data = project.get('plan_data', [])
                settings = project.get('settings', {})
                if settings:
                    self.settings.update({
                        'selected_model': settings.get('selected_model', ''),
                        'temperature': settings.get('temperature', 0.7),
                        'max_tokens': settings.get('max_tokens', 150),
                        'server_url': settings.get('server_url', 'http://localhost'),
                        'server_port': settings.get('server_port', 11434),
                        'theme': settings.get('theme', 'Dark'),
                        'font': self.dict_to_font(settings.get('font', self.font_to_dict(QFont("Arial", 10))))
                    })
                    self.llm_client.base_url = f"{self.settings['server_url'].rstrip(':')}" \
                                               f":{self.settings['server_port']}"
                    self.apply_styles()
                if self.plan_data:
                    self.chat_area_add_message("System", "Entwicklungsplan geladen.")
                    self.detail_chat_area.add_message("System", "Entwicklungsplan geladen.")
                    logger.debug("Entwicklungsplan geladen.")
                    self.gantt_chart.update_chart(self.plan_data)
                    self.gantt_chart.setVisible(True)
                # Laden der Ergebnisse aus der gespeicherten Datei
                results_storage = project.get('results_storage', {})
                if results_storage and self.task_processor:
                    self.task_processor.results_storage = results_storage
                    for key, value in results_storage.items():
                        self.context_manager.update_context(key, value)
                QMessageBox.information(self, "Erfolg", "Projekt erfolgreich geladen.")
                logger.debug(f"Projekt geladen von {file}.")
                # Update Projektliste und zuletzt verwendetes Projekt
                project_name = project.get('name', 'Neues Projekt')
                self.add_or_update_project(project_name)
            except Exception as e:
                self.chat_area_add_message("System", f"Projekt konnte nicht geladen werden: {e}")
                self.detail_chat_area.add_message("System", f"Projekt konnte nicht geladen werden: {e}")
                logger.error(f"Fehler beim Laden des Projekts: {e}")

    def new_project_command(self, **kwargs):
        self.new_project()

    def new_project(self):
        name, ok = QInputDialog.getText(self, "Neues Projekt", "Geben Sie den Namen des neuen Projekts ein:")
        if ok and name:
            self.settings['last_used_project'] = name
            self.uploaded_files = []
            self.plan_data = []
            self.settings.pop('description_text', None)  # Entfernen der Beschreibung des vorherigen Projekts
            self.chat_area_add_message("System", f"Neues Projekt '{name}' gestartet.")
            self.detail_chat_area.add_message("System", f"Neues Projekt '{name}' gestartet.")
            logger.debug(f"Neues Projekt '{name}' initiiert.")
            self.gantt_chart.update_chart(self.plan_data)
            self.gantt_chart.setVisible(False)
            self.add_or_update_project(name)
        elif ok:
            self.chat_area_add_message("System", "Projektname darf nicht leer sein.")
            self.detail_chat_area.add_message("System", "Projektname darf nicht leer sein.")
            logger.warning("Neues Projekt ohne Namen angefragt.")

    def show_about_dialog(self):
        QMessageBox.about(self, "Über", "Intelligenter Assistent für Entwickler\nVersion 2.6\n\nEntwickelt, um Entwicklern bei der Erstellung umfassender Entwicklungspläne und Skripte mit Hilfe von LLMs zu unterstützen.")

    def apply_styles(self):
        palette = QPalette()
        if self.settings['theme'] == 'Dark':
            palette.setColor(QPalette.Window, QColor(45, 45, 45))
            palette.setColor(QPalette.WindowText, Qt.white)
            palette.setColor(QPalette.Base, QColor(30, 30, 30))
            palette.setColor(QPalette.AlternateBase, QColor(45, 45, 45))
            palette.setColor(QPalette.ToolTipBase, Qt.white)
            palette.setColor(QPalette.ToolTipText, Qt.white)
            palette.setColor(QPalette.Text, Qt.white)
            palette.setColor(QPalette.Button, QColor(45, 45, 45))
            palette.setColor(QPalette.ButtonText, Qt.white)
            palette.setColor(QPalette.BrightText, Qt.red)
            palette.setColor(QPalette.Link, QColor(42, 130, 218))
            palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
            palette.setColor(QPalette.HighlightedText, Qt.black)
        else:
            palette = QApplication.style().standardPalette()
        self.setPalette(palette)
        self.setFont(self.settings.get('font', QFont("Arial", 10)))
        for widget in [self.chat_input.input_field, self.detail_chat_area.chat_container]:
            widget.setFont(self.settings.get('font', QFont("Arial", 10)))

    def update_llm_list(self):
        self.settings['available_models'] = self.llm_client.get_models()
        if self.settings['available_models']:
            if not self.settings.get('selected_model') or self.settings['selected_model'] not in self.settings['available_models']:
                self.settings['selected_model'] = self.settings['available_models'][0]
                self.llm_client.set_model(self.settings['selected_model'])
            models = ', '.join(self.settings['available_models'])
            self.chat_area_add_message("System", f"Verfügbare Modelle: {models}.")
            self.detail_chat_area.add_message("System", f"Verfügbare Modelle: {models}.")
        else:
            logger.warning("Keine Modelle gefunden.")
            self.chat_area_add_message("System", "Keine Modelle auf dem LLM-Server gefunden.")
            self.detail_chat_area.add_message("System", "Keine Modelle auf dem LLM-Server gefunden.")
            # Beim ersten Start LLM-Auswahl erzwingen
            self.prompt_llm_selection()

    def prompt_llm_selection(self):
        QMessageBox.warning(self, "LLM-Auswahl erforderlich", "Es wurden keine LLM-Modelle gefunden oder ausgewählt. Bitte wählen Sie ein verfügbares Modell aus den Einstellungen.")
        self.open_settings_dialog()

    def update_server_status(self):
        running = self.check_server_running()
        if running:
            self.chat_area_add_message("System", "Serverstatus: 🟢 Läuft")
            self.detail_chat_area.add_message("System", "Serverstatus: 🟢 Läuft")
            self.update_llm_list()
        else:
            self.chat_area_add_message("System", "Serverstatus: 🔴 Gestoppt")
            self.detail_chat_area.add_message("System", "Serverstatus: 🔴 Gestoppt")
            self.settings['available_models'] = []
            self.settings['selected_model'] = ''
            # Beim ersten Start LLM-Auswahl erzwingen
            self.prompt_llm_selection()

    def handle_user_message(self, message):
        self.chat_area_add_message("Benutzer", message)
        self.detail_chat_area.add_message("Benutzer", message)
        self.loading_label.setVisible(True)
        threading.Thread(target=self.process_message, args=(message,), daemon=True).start()

    def main(self):
        app = QApplication(sys.argv)
        window = MainWindow()
        window.show()
        logger.debug("Anwendung gestartet.")
        sys.exit(app.exec_())


class SettingsDialog(QDialog):
    def __init__(self, current_settings, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Einstellungen")
        self.setModal(True)
        self.settings = current_settings.copy()
        self.init_ui()

    def init_ui(self):
        layout = QVBoxLayout(self)

        # LLM Einstellungen
        llm_group = QGroupBox("LLM-Einstellungen")
        llm_layout = QFormLayout()
        self.llm_combo = QComboBox()
        self.llm_combo.addItems(self.settings.get('available_models', []))
        self.llm_combo.setCurrentText(self.settings.get('selected_model', ''))
        llm_layout.addRow("Modell:", self.llm_combo)
        llm_group.setLayout(llm_layout)

        # Allgemeine Einstellungen
        general_group = QGroupBox("Allgemeine Einstellungen")
        general_layout = QFormLayout()
        self.temperature_spin = QDoubleSpinBox()
        self.temperature_spin.setRange(0.0, 1.0)
        self.temperature_spin.setDecimals(2)
        self.temperature_spin.setSingleStep(0.05)
        self.temperature_spin.setValue(self.settings.get('temperature', 0.7))
        self.max_tokens_spin = QSpinBox()
        self.max_tokens_spin.setRange(100, 10000)
        self.max_tokens_spin.setValue(self.settings.get('max_tokens', 150))
        self.context_size_spin = QSpinBox()
        self.context_size_spin.setRange(512, 16384)
        self.context_size_spin.setValue(self.settings.get('max_tokens', 2048))
        general_layout.addRow("Temperatur:", self.temperature_spin)
        general_layout.addRow("Max Tokens:", self.max_tokens_spin)
        general_layout.addRow("Kontextgröße:", self.context_size_spin)
        general_group.setLayout(general_layout)

        # Server Einstellungen
        server_group = QGroupBox("Server-Einstellungen")
        server_layout = QFormLayout()
        self.server_url_input = QLineEdit(self.settings.get('server_url', 'http://localhost'))
        self.server_port_input = QSpinBox()
        self.server_port_input.setRange(1, 65535)
        self.server_port_input.setValue(self.settings.get('server_port', 11434))
        server_layout.addRow("Server-URL:", self.server_url_input)
        server_layout.addRow("Server-Port:", self.server_port_input)
        server_group.setLayout(server_layout)

        # UI Einstellungen
        ui_group = QGroupBox("UI-Einstellungen")
        ui_layout = QFormLayout()
        self.theme_combo = QComboBox()
        self.theme_combo.addItems(["Dark", "Light"])
        self.theme_combo.setCurrentText(self.settings.get('theme', 'Dark'))
        self.font_button = QPushButton("Schriftart wählen")
        self.font_button.clicked.connect(self.choose_font)
        self.selected_font = self.settings.get('font', QFont("Arial", 10))
        status = 'Fett' if self.selected_font.bold() else 'Regulär'
        self.font_display = QLabel(f"{self.selected_font.family()}, {self.selected_font.pointSize()}pt, {status}")
        ui_layout.addRow("Thema:", self.theme_combo)
        ui_layout.addRow("Schriftart:", self.font_button)
        ui_layout.addRow("", self.font_display)
        ui_group.setLayout(ui_layout)

        # Hinzufügen aller Gruppen zum Layout
        layout.addWidget(llm_group)
        layout.addWidget(general_group)
        layout.addWidget(server_group)
        layout.addWidget(ui_group)

        # Dialog Buttons
        buttons = QDialogButtonBox(QDialogButtonBox.Save | QDialogButtonBox.Cancel)
        buttons.accepted.connect(self.save)
        buttons.rejected.connect(self.reject)
        layout.addWidget(buttons)
        self.setLayout(layout)

    def choose_font(self):
        font, ok = QFontDialog.getFont(self.selected_font, self, "Schriftart wählen")
        if ok:
            self.selected_font = font
            status = 'Fett' if font.bold() else 'Regulär'
            self.font_display.setText(f"{font.family()}, {font.pointSize()}pt, {status}")

    def save(self):
        self.settings.update({
            'selected_model': self.llm_combo.currentText(),
            'temperature': self.temperature_spin.value(),
            'max_tokens': self.max_tokens_spin.value(),
            'context_size': self.context_size_spin.value(),
            'server_url': self.server_url_input.text(),
            'server_port': self.server_port_input.value(),
            'theme': self.theme_combo.currentText(),
            'font': self.selected_font
        })
        self.accept()


class SwitchLLMDialog(QDialog):
    def __init__(self, current_settings, parent=None):
        super().__init__(parent)
        self.setWindowTitle("LLM wechseln")
        self.setModal(True)
        self.settings = current_settings
        self.selected_llm = None
        self.init_ui()

    def init_ui(self):
        layout = QVBoxLayout(self)
        info_label = QLabel("Wählen Sie das LLM aus, das Sie aktivieren möchten:")
        layout.addWidget(info_label)
        self.llm_combo = QComboBox()
        self.llm_combo.addItems(self.settings.get('available_models', []))
        layout.addWidget(self.llm_combo)
        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        buttons.accepted.connect(self.ok)
        buttons.rejected.connect(self.reject)
        layout.addWidget(buttons)
        self.setLayout(layout)

    def ok(self):
        self.selected_llm = self.llm_combo.currentText()
        self.accept()


class DeleteProjectDialog(QDialog):
    def __init__(self, projects, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Projekt löschen")
        self.setModal(True)
        self.projects = projects
        self.selected_project = None
        self.init_ui()

    def init_ui(self):
        layout = QVBoxLayout(self)
        info_label = QLabel("Wählen Sie das Projekt aus, das Sie löschen möchten:")
        layout.addWidget(info_label)
        self.project_combo = QComboBox()
        self.project_combo.addItems([p['name'] for p in self.projects])
        layout.addWidget(self.project_combo)
        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        buttons.accepted.connect(self.ok)
        buttons.rejected.connect(self.reject)
        layout.addWidget(buttons)
        self.setLayout(layout)

    def ok(self):
        self.selected_project = self.project_combo.currentText()
        self.accept()


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    logger.debug("Anwendung gestartet.")
    sys.exit(app.exec_())
```

### Wichtige Erweiterungen und Verbesserungen:

1. **Hardware-Detektion**:
   - Mit der Bibliothek `psutil` wird die Hardware des Nutzers ermittelt (CPU-Kerne und RAM). Basierend auf diesen Informationen passt die Anwendung die LLM-Einstellungen wie `max_tokens` und `context_size` an, um eine optimale Performance zu gewährleisten.

2. **ContextManager**:
   - Eine neue Klasse `ContextManager` wurde eingeführt, die für das intelligente Kontextmanagement verantwortlich ist. Sie speichert und aktualisiert den relevanten Kontext für die LLM-Anfragen und ermöglicht das Speichern und Laden des Kontexts aus einer Datei.

3. **TaskProcessor**:
   - Die `TaskProcessor`-Klasse wurde erweitert, um Zwischenergebnisse in `results_storage` zu speichern. Diese Ergebnisse werden dann im `ContextManager` aktualisiert, um eine konsistente Kontextbasis sicherzustellen.
   - Nach Abschluss der Aufgaben wird dieser Kontext gespeichert, um eine spätere Wiederverwendung zu ermöglichen.

4. **Einstellungen für Kontextgröße**:
   - Im `SettingsDialog` wurde ein neuer SpinBox für die `context_size` hinzugefügt, sodass der Nutzer die Kontextgröße des LLM anpassen kann.

5. **Persistente Speicherung des Kontexts**:
   - Der `ContextManager` ermöglicht es, den Kontext in einer JSON-Datei zu speichern und bei Bedarf wieder zu laden. Dies stellt sicher, dass der Kontext auch nach einem Neustart der Anwendung erhalten bleibt.

6. **Dynamische LLM-Einstellungen**:
   - Basierend auf der ermittelten Hardware passen sich die LLM-Einstellungen dynamisch an, um eine ausgewogene Balance zwischen Performance und Ressourcenverbrauch zu gewährleisten.

7. **Mehrteilige Kommunikation mit dem LLM**:
   - Der Prozess der Aufgabenbearbeitung erfolgt nun in mehreren Schritten, wodurch komplexe Aufgaben effizienter bearbeitet werden können. Dabei werden Zwischenergebnisse gespeichert und bei Bedarf wiederverwendet.

8. **Abschlussbericht und Speicherung**:
   - Nach Abschluss der Aufgaben kann ein finaler Bericht generiert und gespeichert werden, was eine übersichtliche Zusammenfassung der Entwicklungsarbeit ermöglicht.

### Voraussetzungen:

- **psutil**: Stellen Sie sicher, dass die `psutil`-Bibliothek installiert ist. Diese kann mit dem Befehl `pip install psutil` installiert werden.
- **Matplotlib**: Für die Gantt-Diagramm-Anzeige muss `matplotlib` installiert sein. Installieren Sie es mit `pip install matplotlib`.
- **Ollama**: Die Anwendung setzt voraus, dass `ollama` installiert und im PATH des Systems verfügbar ist.

### Hinweis:

Dieses erweiterte Skript bietet eine robustere und intelligentere Lösung für die Verwaltung von Entwicklungsprojekten mit Hilfe eines LLM. Es berücksichtigt sowohl die Effizienz bei der Aufgabenbearbeitung als auch die ressourcenschonende Nutzung der Hardware des Nutzers. Die dauerhafte Speicherung von Kontextdaten stellt sicher, dass die Entwicklungsarbeit auch nach einem Neustart der Anwendung nahtlos fortgesetzt werden kann.

Analyze the code for redundancies that violate the don't repeat yourself principle for python code. Python 3.12 code: import math
import re
from typing import Any, Union, Callable
from math import radians, pi, e, sqrt, log10, log, ceil

from PySide6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QLineEdit, QTextEdit, QScrollBar, QPushButton, QLabel, QFrame,
    QGridLayout
)
from PySide6.QtGui import QFont
from PySide6.QtCore import Qt, QSize

def convert_angle(func: Callable[[float], float], x: float, use_degrees: bool) -> float:
    """Apply trig function with optional degree conversion."""
    return func(radians(x) if use_degrees else x)

def kilograms_to_pounds(kg: float) -> float:
    """Convert kilograms to pounds."""
    return kg / 0.45359237

def pounds_to_kilograms(lb: float) -> float:
    """Convert pounds to kilograms."""
    return lb * 0.45359237

def celsius_to_kelvin(c: float) -> float:
    """Convert Celsius to Kelvin."""
    return c + 273.15

def kelvin_to_celsius(k: float) -> float:
    """Convert Kelvin to Celsius."""
    return k - 273.15

def celsius_to_fahrenheit(c: float) -> float:
    """Convert Celsius to Fahrenheit."""
    return c * 9 / 5 + 32

def fahrenheit_to_celsius(f: float) -> float:
    """Convert Fahrenheit to Celsius."""
    return (f - 32) * 5 / 9

def capitalize_sentence(sentence: str) -> str:
    """Capitalize first letter of each word."""
    return ' '.join(word.capitalize() for word in sentence.split())

def remove_duplicates(text: str) -> str:
    """Remove duplicate words and empty lines."""
    words = ' '.join(line.strip() for line in text.splitlines() if line.strip()).split()
    return ' '.join(dict.fromkeys(words))

def get_safe_globals(use_degrees: bool, variables: dict) -> dict:
    """Provide safe globals for expression evaluation."""
    trig_funcs = {'sin', 'cos', 'tan', 'asin', 'acos', 'atan'}
    safe_globals = {
        "sqrt": sqrt,
        "log": log10,
        "ln": log,
        "pi": pi,
        "e": e,
        "lb": kilograms_to_pounds,
        "kg": pounds_to_kilograms,
        "C": kelvin_to_celsius,
        "K": celsius_to_kelvin,
        "F": celsius_to_fahrenheit,
        "CF": fahrenheit_to_celsius,
        "capitalize": capitalize_sentence,
        "duplicates": remove_duplicates,
    }
    for func in trig_funcs:
        safe_globals[func] = lambda x, f=func: convert_angle(getattr(math, f), x, use_degrees)
    safe_globals.update(variables)
    return safe_globals

def preprocess_text_functions(expression: str) -> str:
    """Preprocess text functions with argument quotes."""
    def add_quotes(match):
        func, args = match.groups()
        return f'{func}("{args}")' if func in ['capitalize', 'duplicates'] else match.group(0)
    return re.sub(r'\b(capitalize|duplicates)\s*\(\s*([^)]+)\s*\)', add_quotes, expression)

def validate_inverse_trig(expression: str, safe_globals: dict) -> Union[str, None]:
    """Check inverse trig function domain validity."""
    for func, arg in re.findall(r"(\b\w+\b)\s*\(\s*([^)]+)\s*\)", expression):
        if func in ["asin", "acos"]:
            try:
                value = eval(arg, {"__builtins__": None}, safe_globals)
                if abs(value) > 1:
                    return f"Error: {func}(x) is undefined for |x| > 1"
            except Exception as e:
                return f"Error: {e}"
    return None

def safe_evaluate(expression: str, safe_globals: dict, use_e_notation: bool) -> Union[str, Any]:
    """Safely evaluate expression and format result."""
    try:
        result = eval(expression, {"__builtins__": None}, safe_globals)
        if isinstance(result, float) and abs(result) < 1e-10:
            result = 0.0
        if isinstance(result, (int, float)):
            result = f"{result:.2e}" if use_e_notation else round(result, 2)
        return result
    except Exception as e:
        return f"Error: {e}"

def evaluate_expression(expression: str, variables: dict, use_degrees: bool = False, use_e_notation: bool = False) -> Union[float, str]:
    """Evaluate math expression considering modes."""
    assignment_match = re.match(r'^\s*([a-zA-Z_]\w*)\s*=\s*(.+)$', expression)
    if assignment_match:
        var_name, var_expr = assignment_match.groups()
        safe_globals = get_safe_globals(use_degrees, variables)
        var_value = safe_evaluate(var_expr, safe_globals, use_e_notation)
        if isinstance(var_value, (int, float)):
            variables[var_name] = var_value
            return f"{var_name} = {var_value}"
        return var_value
    else:
        safe_globals = get_safe_globals(use_degrees, variables)
        expression = expression.replace("^", "**")
        expression = preprocess_text_functions(expression)
        error = validate_inverse_trig(expression, safe_globals)
        if error:
            return error
        return safe_evaluate(expression, safe_globals, use_e_notation)

class CalculatorGUI(QMainWindow):
    """PySide6-based calculator application."""

    def __init__(self):
        super().__init__()
        self.use_degrees = False
        self.use_e_notation = False
        self.variables = {}
        self.history_entries = []
        self.setup_window()
        self.create_widgets()
        self.layout_widgets()
        self.connect_signals()

    def setup_window(self) -> None:
        """Set main window properties."""
        self.setWindowTitle("Calculator")
        self.setGeometry(100, 100, 1280, 720)

    def create_widgets(self) -> None:
        """Initialize GUI components."""
        font = QFont()
        font.setPointSize(12)
        font.setFamily('Literata')

        self.entry = QLineEdit()
        self.entry.setFont(font)
        self.entry.setPlaceholderText('Enter expression')
        self.entry.setClearButtonEnabled(True)
        self.entry.returnPressed.connect(self.calculate)

        self.history_text = QTextEdit()
        self.history_text.setFont(font)
        self.history_text.setReadOnly(True)

        self.scrollbar = QScrollBar(Qt.Vertical)
        self.history_text.setVerticalScrollBar(self.scrollbar)

        self.search_button = QPushButton("🔍", self.history_text)
        self.search_button.setFixedSize(24, 24)
        self.search_button.setToolTip("Search History")
        self.search_button.setStyleSheet("""
            QPushButton {
                border: none;
                background-color: rgba(255, 255, 255, 200);
                font-size: 14px;
                border-radius: 12px;
            }
            QPushButton:hover {
                background-color: rgba(0, 120, 215, 200);
                color: white;
            }
        """)
        self.search_button.clicked.connect(self.toggle_search)

        self.search_bar = QLineEdit(self.history_text)
        self.search_bar.setPlaceholderText("Search...")
        self.search_bar.setFixedHeight(24)
        self.search_bar.setVisible(False)
        self.search_bar.setStyleSheet("""
            QLineEdit {
                border: 1px solid gray;
                border-radius: 4px;
                padding: 2px 4px;
                background-color: white;
            }
        """)
        self.search_bar.textChanged.connect(self.filter_history)
        self.search_bar.setClearButtonEnabled(True)

        self.function_buttons = {
            "Functions": ["sqrt", "sin", "cos", "tan", "asin", "acos", "atan", "log", "ln"],
            "Conversions": ["lb", "kg", "K", "C", "F", "CF"],
            "Text": ["capitalize", "duplicates"],
            "Constants": ["pi", "e"],
            "Settings": []
        }
        self.function_frame = QFrame()
        self.create_function_buttons(font)

    def create_function_buttons(self, font: QFont) -> None:
        """Create buttons for calculator functions."""
        layout = QGridLayout()
        categories = [("Functions", 3), ("Conversions", 2), ("Text", 2), ("Constants", 2), ("Settings", 1)]
        starting_col = 0

        for category, col_span in categories:
            label = QLabel(category)
            label.setFont(font)
            layout.addWidget(label, 0, starting_col, 1, col_span, Qt.AlignCenter)

            buttons = self.function_buttons.get(category, [])
            if category == "Functions":
                for i, func in enumerate(buttons):
                    button = QPushButton(func)
                    button.setFont(font)
                    button.clicked.connect(lambda _, f=func: self.insert_function(f, False))
                    layout.addWidget(button, (i // 3) + 1, starting_col + (i % 3))

            elif category == "Settings":
                self.mode_button = QPushButton("Radians")
                self.mode_button.setFont(font)
                self.mode_button.clicked.connect(self.toggle_mode)
                layout.addWidget(self.mode_button, 1, starting_col, 1, 1)

                self.e_notation_button = QPushButton("E Notation: Off")
                self.e_notation_button.setFont(font)
                self.e_notation_button.clicked.connect(self.toggle_e_notation)
                layout.addWidget(self.e_notation_button, 2, starting_col, 1, 1)

            elif category == "Conversions":
                for idx, func in enumerate(buttons):
                    display_text = {
                        "lb": "lb(kg)", "kg": "kg(lb)", "K": "K(°C)",
                        "C": "°C(K)", "F": "F(°C)", "CF": "°C(F)"
                    }.get(func, func)
                    button = QPushButton(display_text)
                    button.setFont(font)
                    button.clicked.connect(lambda _, f=func: self.insert_function(f, False))
                    row, col = 1 + idx // 2, starting_col + idx % 2
                    layout.addWidget(button, row, col)

            else:
                num_buttons = len(buttons)
                num_rows = ceil(num_buttons / col_span)

                for idx, func in enumerate(buttons):
                    button = QPushButton(func)
                    button.setFont(font)
                    button.clicked.connect(lambda _, f=func, c=(category == "Constants"): self.insert_function(f, c))
                    row, col = 1 + idx // col_span, starting_col + idx % col_span
                    layout.addWidget(button, row, col)

                for extra in range(col_span * num_rows - num_buttons):
                    layout.addWidget(QLabel(""), 1 + extra // col_span, starting_col + extra % col_span)

            starting_col += col_span

        self.function_frame.setLayout(layout)

    def layout_widgets(self) -> None:
        """Arrange widgets in the main window."""
        central_widget = QWidget()
        main_layout = QVBoxLayout()

        main_layout.addWidget(self.entry)

        history_layout = QHBoxLayout()
        history_layout.addWidget(self.history_text)
        history_layout.addWidget(self.scrollbar)
        main_layout.addLayout(history_layout)

        main_layout.addWidget(self.function_frame)

        central_widget.setLayout(main_layout)
        self.setCentralWidget(central_widget)

    def connect_signals(self) -> None:
        """Connect widget signals."""
        QApplication.instance().focusChanged.connect(self.on_focus_changed)

    def toggle_mode(self) -> None:
        """Toggle between degrees and radians."""
        self.use_degrees = not self.use_degrees
        self.mode_button.setText("Degrees" if self.use_degrees else "Radians")

    def toggle_e_notation(self) -> None:
        """Toggle scientific notation for results."""
        self.use_e_notation = not self.use_e_notation
        self.e_notation_button.setText(f"E Notation: {'On' if self.use_e_notation else 'Off'}")

    def insert_function(self, function: str, is_constant: bool = False) -> None:
        """Insert function or constant in entry."""
        current_text = self.entry.text()
        cursor_position = self.entry.cursorPosition()
        if is_constant:
            new_text = f"{current_text[:cursor_position]}{function}"
            new_cursor_position = cursor_position + len(function)
        else:
            new_text = f"{current_text[:cursor_position]}{function}() {current_text[cursor_position:]}"
            new_cursor_position = cursor_position + len(function) + 1
        self.entry.setText(new_text)
        self.entry.setCursorPosition(new_cursor_position)
        self.entry.setFocus()

    def calculate(self) -> None:
        """Evaluate entered expression."""
        expression = self.entry.text().strip()
        if expression:
            result = evaluate_expression(
                expression, self.variables, use_degrees=self.use_degrees, use_e_notation=self.use_e_notation
            )
            self.display_result(expression, result)
            self.entry.clear()

    def display_result(self, expression: str, result: Union[float, str]) -> None:
        """Show result in history."""
        mode = "D" if self.use_degrees else "R"
        if re.match(r'^\s*[a-zA-Z_]\w*\s*=\s*.+$', expression):
            history_entry = f"[{mode}] {result}"
        else:
            history_entry = f"[{mode}] {expression} = {result}"
        self.history_entries.append(history_entry)
        self.refresh_history()
        self.history_text.verticalScrollBar().setValue(
            self.history_text.verticalScrollBar().maximum()
        )

    def toggle_search(self) -> None:
        """Toggle search bar visibility."""
        is_visible = self.search_bar.isVisible()
        self.search_bar.setVisible(not is_visible)
        if not is_visible:
            self.search_bar.setFocus()
            self.search_bar.setText("")
        else:
            self.search_bar.clear()
        self.update_search_bar_position()
        self.refresh_history()

    def filter_history(self, text: str) -> None:
        """Filter history based on search input."""
        self.refresh_history(text)

    def refresh_history(self, filter_text: str = "") -> None:
        """Refresh history view with optional filtering."""
        self.history_text.clear()
        for entry in self.history_entries:
            if filter_text.lower() in entry.lower():
                self.history_text.append(entry)

    def resizeEvent(self, event) -> None:
        """Handle window resize events."""
        super().resizeEvent(event)
        self.update_search_bar_position()

    def update_search_bar_position(self) -> None:
        """Reposition search button and bar."""
        margin_right = 5
        margin_top = 5
        spacing = 5

        history_width = self.history_text.viewport().width()

        self.search_button.move(
            history_width - self.search_button.width() - margin_right,
            margin_top
        )

        if self.search_bar.isVisible():
            search_bar_width = int(history_width * 0.25)
            if search_bar_width + self.search_button.width() + spacing > history_width:
                search_bar_width = history_width - self.search_button.width() - spacing - margin_right
            self.search_bar.setFixedWidth(search_bar_width)
            self.search_bar.move(
                self.search_button.x() - self.search_bar.width() - spacing,
                self.search_button.y()
            )

    def on_focus_changed(self, old: QWidget, new: QWidget) -> None:
        """Auto-hide search if focus is lost."""
        if self.search_bar.isVisible() and not self.search_bar.text().strip() and new != self.search_bar:
            self.toggle_search()

    def showEvent(self, event) -> None:
        """Position search button on showing the window."""
        super().showEvent(event)
        self.update_search_bar_position()

def main() -> None:
    """Start the calculator application."""
    app = QApplication([])
    calculator = CalculatorGUI()
    calculator.show()
    app.exec()

if __name__ == "__main__":
    main()

Your Python 3.12 calculator application is well-structured and functional. However, there are several areas where the **Don't Repeat Yourself (DRY)** principle can be better adhered to. Eliminating these redundancies can make your code more maintainable, concise, and less error-prone. Below is a detailed analysis of the redundancies along with suggestions for refactoring.

## 1. **Redundant Import Statements**

### **Issue:**
You are importing the entire `math` module and specific functions from it separately:

```python
import math
from math import radians, pi, e, sqrt, log10, log, ceil
```

This redundancy can lead to confusion and unnecessarily increases the namespace.

### **Solution:**
Choose one of the following approaches:

- **Option 1:** Import the entire `math` module and access functions using the module prefix.

  ```python
  import math

  # Usage:
  math.radians(x)
  math.pi
  ```

- **Option 2:** Import only the necessary functions if the module prefix isn't needed elsewhere.

  ```python
  from math import radians, pi, e, sqrt, log10, log, ceil

  # Usage:
  radians(x)
  pi
  ```

**Recommendation:** If you're frequently using the module prefix elsewhere in your code (e.g., in `get_safe_globals`), it's cleaner to import the entire module.

## 2. **Conversion Functions Redundancy**

### **Issue:**
You have multiple functions for unit conversions that follow a similar pattern:

```python
def kilograms_to_pounds(kg: float) -> float:
    return kg / 0.45359237

def pounds_to_kilograms(lb: float) -> float:
    return lb * 0.45359237

def celsius_to_kelvin(c: float) -> float:
    return c + 273.15

def kelvin_to_celsius(k: float) -> float:
    return k - 273.15

def celsius_to_fahrenheit(c: float) -> float:
    return c * 9 / 5 + 32

def fahrenheit_to_celsius(f: float) -> float:
    return (f - 32) * 5 / 9
```

### **Solution:**
Implement a more generic conversion function that can handle different types of conversions using a mapping or configuration.

**Example: Using a Conversion Dictionary**

```python
# Define a conversion mapping
CONVERSIONS = {
    'kg_to_lb': lambda kg: kg / 0.45359237,
    'lb_to_kg': lambda lb: lb * 0.45359237,
    'C_to_K': lambda c: c + 273.15,
    'K_to_C': lambda k: k - 273.15,
    'C_to_F': lambda c: c * 9 / 5 + 32,
    'F_to_C': lambda f: (f - 32) * 5 / 9,
}

def convert_units(conversion_type: str, value: float) -> float:
    try:
        return CONVERSIONS[conversion_type](value)
    except KeyError:
        raise ValueError(f"Unsupported conversion type: {conversion_type}")
```

**Usage:**

```python
convert_units('kg_to_lb', 10)  # Converts 10 kilograms to pounds
convert_units('C_to_F', 25)    # Converts 25 Celsius to Fahrenheit
```

**Benefits:**

- **Scalability:** Easily add new conversions without defining additional functions.
- **Maintainability:** Centralized conversion logic makes it easier to manage.
- **Reduced Redundancy:** Eliminates multiple functions that perform similar tasks.

## 3. **Button Creation in `create_function_buttons`**

### **Issue:**
The `create_function_buttons` method contains repetitive code for creating buttons across different categories. Each category has its own loop and handling logic, leading to duplicated patterns.

```python
if category == "Functions":
    for i, func in enumerate(buttons):
        button = QPushButton(func)
        button.setFont(font)
        button.clicked.connect(lambda _, f=func: self.insert_function(f, False))
        layout.addWidget(button, (i // 3) + 1, starting_col + (i % 3))
elif category == "Settings":
    # Similar repetitive code
elif category == "Conversions":
    # Similar repetitive code
else:
    # Similar repetitive code
```

### **Solution:**
Abstract the button creation logic into a helper method. This method can handle common behaviors like setting the font, connecting signals, and adding to the layout.

**Refactored `create_function_buttons` Method:**

```python
def create_function_buttons(self, font: QFont) -> None:
    """Create buttons for calculator functions."""
    layout = QGridLayout()
    categories = [("Functions", 3), ("Conversions", 2), ("Text", 2), ("Constants", 2), ("Settings", 1)]
    starting_col = 0

    for category, col_span in categories:
        label = QLabel(category)
        label.setFont(font)
        layout.addWidget(label, 0, starting_col, 1, col_span, Qt.AlignCenter)

        buttons = self.function_buttons.get(category, [])
        if category == "Settings":
            self._add_setting_buttons(layout, font, starting_col)
        else:
            self._add_category_buttons(layout, font, category, buttons, starting_col, col_span)
        
        starting_col += col_span

    self.function_frame.setLayout(layout)

def _add_setting_buttons(self, layout, font, starting_col):
    """Add setting buttons."""
    self.mode_button = QPushButton("Radians")
    self.mode_button.setFont(font)
    self.mode_button.clicked.connect(self.toggle_mode)
    layout.addWidget(self.mode_button, 1, starting_col, 1, 1)

    self.e_notation_button = QPushButton("E Notation: Off")
    self.e_notation_button.setFont(font)
    self.e_notation_button.clicked.connect(self.toggle_e_notation)
    layout.addWidget(self.e_notation_button, 2, starting_col, 1, 1)

def _add_category_buttons(self, layout, font, category, buttons, starting_col, col_span):
    """Add buttons for a given category."""
    if category == "Functions" or category == "Conversions" or category == "Constants" or category == "Text":
        for idx, func in enumerate(buttons):
            if category == "Conversions":
                display_text = {
                    "lb": "lb(kg)", "kg": "kg(lb)", "K": "K(°C)",
                    "C": "°C(K)", "F": "F(°C)", "CF": "°C(F)"
                }.get(func, func)
            else:
                display_text = func

            button = QPushButton(display_text)
            button.setFont(font)

            # Determine if it's a constant
            is_constant = category == "Constants"

            button.clicked.connect(lambda _, f=func, c=is_constant: self.insert_function(f, c))
            row = 1 + idx // col_span
            col = starting_col + idx % col_span
            layout.addWidget(button, row, col)

        # Fill the remaining grid with empty labels to maintain layout
        num_buttons = len(buttons)
        num_rows = ceil(num_buttons / col_span)
        for extra in range(col_span * num_rows - num_buttons):
            layout.addWidget(QLabel(""), 1 + extra // col_span, starting_col + extra % col_span)
```

**Benefits:**

- **Reduced Redundancy:** Common button creation logic is centralized.
- **Improved Readability:** The main method is cleaner and easier to understand.
- **Ease of Maintenance:** Changes to button creation need to be made in only one place.

## 4. **Similar Stylesheet Strings**

### **Issue:**
Stylesheets for widgets like `search_button` and `search_bar` are defined inline with possible repeated patterns.

```python
self.search_button.setStyleSheet("""
    QPushButton {
        border: none;
        background-color: rgba(255, 255, 255, 200);
        font-size: 14px;
        border-radius: 12px;
    }
    QPushButton:hover {
        background-color: rgba(0, 120, 215, 200);
        color: white;
    }
""")

self.search_bar.setStyleSheet("""
    QLineEdit {
        border: 1px solid gray;
        border-radius: 4px;
        padding: 2px 4px;
        background-color: white;
    }
""")
```

### **Solution:**
Define common styles as class constants or use helper methods to apply styles. This approach avoids duplicating stylesheet strings across different widgets.

**Example: Using Class Constants**

```python
class CalculatorGUI(QMainWindow):
    """PySide6-based calculator application."""

    BUTTON_STYLE = """
        QPushButton {
            border: none;
            background-color: rgba(255, 255, 255, 200);
            font-size: 14px;
            border-radius: 12px;
        }
        QPushButton:hover {
            background-color: rgba(0, 120, 215, 200);
            color: white;
        }
    """

    SEARCH_BAR_STYLE = """
        QLineEdit {
            border: 1px solid gray;
            border-radius: 4px;
            padding: 2px 4px;
            background-color: white;
        }
    """

    def create_widgets(self) -> None:
        """Initialize GUI components."""
        # ... other widget initializations ...

        self.search_button.setStyleSheet(self.BUTTON_STYLE)
        self.search_bar.setStyleSheet(self.SEARCH_BAR_STYLE)
```

**Benefits:**

- **Consistency:** Ensures a uniform look across similar widgets.
- **Maintainability:** Easier to update styles in one place rather than multiple locations.

## 5. **Lambda Function Usage in Signal Connections**

### **Issue:**
Using `lambda` in signal connections can sometimes lead to late binding issues or make the code harder to debug.

```python
button.clicked.connect(lambda _, f=func: self.insert_function(f, False))
```

### **Solution:**
Use the `functools.partial` function to create callbacks with pre-filled arguments. This approach is cleaner and avoids potential lambda-related issues.

**Example:**

```python
from functools import partial

button.clicked.connect(partial(self.insert_function, func, False))
```

**Refactored Button Connection:**

```python
from functools import partial

def _add_category_buttons(self, layout, font, category, buttons, starting_col, col_span):
    """Add buttons for a given category."""
    if category == "Functions" or category == "Conversions" or category == "Constants" or category == "Text":
        for idx, func in enumerate(buttons):
            if category == "Conversions":
                display_text = {
                    "lb": "lb(kg)", "kg": "kg(lb)", "K": "K(°C)",
                    "C": "°C(K)", "F": "F(°C)", "CF": "°C(F)"
                }.get(func, func)
            else:
                display_text = func

            button = QPushButton(display_text)
            button.setFont(font)

            # Determine if it's a constant
            is_constant = category == "Constants"

            # Use functools.partial instead of lambda
            button.clicked.connect(partial(self.insert_function, func, is_constant))
            row = 1 + idx // col_span
            col = starting_col + idx % col_span
            layout.addWidget(button, row, col)

        # Fill the remaining grid with empty labels to maintain layout
        num_buttons = len(buttons)
        num_rows = ceil(num_buttons / col_span)
        for extra in range(col_span * num_rows - num_buttons):
            layout.addWidget(QLabel(""), 1 + extra // col_span, starting_col + extra % col_span)
```

**Benefits:**

- **Clarity:** `partial` explicitly shows which arguments are being passed.
- **Safety:** Avoids common pitfalls associated with `lambda` functions in loops.

## 6. **Repeated Regular Expressions**

### **Issue:**
Regular expressions are used in multiple functions like `preprocess_text_functions`, `validate_inverse_trig`, and `evaluate_expression`. If these regex patterns are reused or similar, defining them as constants can reduce duplication.

```python
re.sub(r'\b(capitalize|duplicates)\s*\(\s*([^)]+)\s*\)', add_quotes, expression)
re.findall(r"(\b\w+\b)\s*\(\s*([^)]+)\s*\)", expression)
re.match(r'^\s*([a-zA-Z_]\w*)\s*=\s*(.+)$', expression)
```

### **Solution:**
Define regex patterns as class constants or module-level constants.

**Example:**

```python
# At the top of the module
ASSIGNMENT_PATTERN = re.compile(r'^\s*([a-zA-Z_]\w*)\s*=\s*(.+)$')
FUNCTION_CALL_PATTERN = re.compile(r'\b(capitalize|duplicates)\s*\(\s*([^)]+)\s*\)')
FIND_FUNCTIONS_PATTERN = re.compile(r"(\b\w+\b)\s*\(\s*([^)]+)\s*\)")

# Usage in functions
assignment_match = ASSIGNMENT_PATTERN.match(expression)
preprocessed_expression = FUNCTION_CALL_PATTERN.sub(add_quotes, expression)
for func, arg in FIND_FUNCTIONS_PATTERN.findall(expression):
    # ...
```

**Benefits:**

- **Performance:** Compiling regex patterns once can improve performance, especially if used frequently.
- **Maintainability:** Easier to manage and update patterns in a centralized location.
- **Readability:** Named constants make the purpose of each pattern clearer.

## 7. **Handling Function Insertion in Entry**

### **Issue:**
The `insert_function` method differentiates between inserting constants and functions, leading to similar but slightly different logic.

```python
if is_constant:
    new_text = f"{current_text[:cursor_position]}{function}"
    new_cursor_position = cursor_position + len(function)
else:
    new_text = f"{current_text[:cursor_position]}{function}() {current_text[cursor_position:]}"
    new_cursor_position = cursor_position + len(function) + 1
```

### **Solution:**
Abstract the insertion logic to handle different cases more elegantly, possibly by using formats or helper methods.

**Example:**

```python
def insert_function(self, function: str, is_constant: bool = False) -> None:
    """Insert function or constant in entry."""
    current_text = self.entry.text()
    cursor_position = self.entry.cursorPosition()

    insertion = function if is_constant else f"{function}() "
    new_cursor_position = cursor_position + len(function) + (0 if is_constant else 3)  # Adjust for '() '

    new_text = f"{current_text[:cursor_position]}{insertion}{current_text[cursor_position:]}"
    self.entry.setText(new_text)
    self.entry.setCursorPosition(new_cursor_position)
    self.entry.setFocus()
```

**Benefits:**

- **Clarity:** Clearly separates the insertion logic based on the type.
- **Flexibility:** Easier to add more cases if needed in the future.

## 8. **Consolidating Mode Toggles**

### **Issue:**
You have separate methods for toggling degrees/radians and E-notation:

```python
def toggle_mode(self) -> None:
    self.use_degrees = not self.use_degrees
    self.mode_button.setText("Degrees" if self.use_degrees else "Radians")

def toggle_e_notation(self) -> None:
    self.use_e_notation = not self.use_e_notation
    self.e_notation_button.setText(f"E Notation: {'On' if self.use_e_notation else 'Off'}")
```

While these methods are simple, they follow a similar pattern and can be generalized.

### **Solution:**
Create a generic toggle method that can handle different toggles based on parameters.

**Example:**

```python
def toggle_setting(self, setting_name: str) -> None:
    if setting_name == "mode":
        self.use_degrees = not self.use_degrees
        self.mode_button.setText("Degrees" if self.use_degrees else "Radians")
    elif setting_name == "e_notation":
        self.use_e_notation = not self.use_e_notation
        self.e_notation_button.setText(f"E Notation: {'On' if self.use_e_notation else 'Off'}")

# Connect signals using partial
self.mode_button.clicked.connect(partial(self.toggle_setting, "mode"))
self.e_notation_button.clicked.connect(partial(self.toggle_setting, "e_notation"))
```

**Benefits:**

- **Reduced Redundancy:** Single method handles multiple toggles.
- **Scalability:** Easier to add more toggles without creating new methods.

## 9. **Handling Search Functionality**

### **Issue:**
The search functionality involves multiple methods (`toggle_search`, `filter_history`, `refresh_history`, `update_search_bar_position`, etc.) that interact in a complex manner. While not strictly violating DRY, the interconnectedness can lead to maintainability challenges.

### **Solution:**
Encapsulate search-related functionalities into a separate class or component. This modular approach separates concerns and makes the codebase cleaner.

**Example:**

```python
class SearchWidget(QWidget):
    """Encapsulates search bar and button functionality."""

    def __init__(self, parent, on_search):
        super().__init__(parent)
        self.on_search = on_search
        self.setup_ui()

    def setup_ui(self):
        self.search_button = QPushButton("🔍")
        self.search_button.setFixedSize(24, 24)
        self.search_button.setToolTip("Search History")
        self.search_button.setStyleSheet(self.BUTTON_STYLE)
        self.search_button.clicked.connect(self.toggle_search)

        self.search_bar = QLineEdit()
        self.search_bar.setPlaceholderText("Search...")
        self.search_bar.setFixedHeight(24)
        self.search_bar.setVisible(False)
        self.search_bar.setStyleSheet(self.SEARCH_BAR_STYLE)
        self.search_bar.textChanged.connect(self.on_search)
        self.search_bar.setClearButtonEnabled(True)

        layout = QHBoxLayout()
        layout.addWidget(self.search_button)
        layout.addWidget(self.search_bar)
        self.setLayout(layout)

    def toggle_search(self):
        is_visible = self.search_bar.isVisible()
        self.search_bar.setVisible(not is_visible)
        if not is_visible:
            self.search_bar.setFocus()
            self.search_bar.setText("")
        else:
            self.search_bar.clear()
```

**Integration in `CalculatorGUI`:**

```python
def create_widgets(self) -> None:
    """Initialize GUI components."""
    # ... other widget initializations ...

    self.search_widget = SearchWidget(self.history_text, self.filter_history)
    # Add search_widget to the layout as needed
```

**Benefits:**

- **Separation of Concerns:** Isolates search functionality from the main GUI logic.
- **Reusability:** The `SearchWidget` can be reused in other parts of the application or future projects.
- **Maintainability:** Easier to manage and update search-related features without affecting other components.

## 10. **Using Data Classes for Configuration**

### **Issue:**
Your `get_safe_globals` function manually constructs a `safe_globals` dictionary. Managing this manually can lead to errors and make the code harder to extend.

### **Solution:**
Use Python's `dataclass` to define configurations or use more structured approaches to build `safe_globals`.

**Example:**

```python
from dataclasses import dataclass, field

@dataclass
class SafeGlobalsConfig:
    use_degrees: bool
    variables: dict = field(default_factory=dict)

    def build_globals(self) -> dict:
        trig_funcs = {'sin', 'cos', 'tan', 'asin', 'acos', 'atan'}
        safe_globals = {
            "sqrt": math.sqrt,
            "log": math.log10,
            "ln": math.log,
            "pi": math.pi,
            "e": math.e,
            "lb": CONVERSIONS['kg_to_lb'],
            "kg": CONVERSIONS['lb_to_kg'],
            "C": CONVERSIONS['K_to_C'],
            "K": CONVERSIONS['C_to_K'],
            "F": CONVERSIONS['C_to_F'],
            "CF": CONVERSIONS['F_to_C'],
            "capitalize": capitalize_sentence,
            "duplicates": remove_duplicates,
        }
        for func in trig_funcs:
            safe_globals[func] = partial(convert_angle, getattr(math, func), use_degrees=self.use_degrees)
        safe_globals.update(self.variables)
        return safe_globals
```

**Usage in `evaluate_expression`:**

```python
def evaluate_expression(expression: str, variables: dict, use_degrees: bool = False, use_e_notation: bool = False) -> Union[float, str]:
    config = SafeGlobalsConfig(use_degrees=use_degrees, variables=variables)
    safe_globals = config.build_globals()
    # ... rest of the function ...
```

**Benefits:**

- **Structured Configuration:** Clear separation of configuration and execution logic.
- **Easier Extensions:** Adding new configurations becomes straightforward.
- **Improved Readability:** More descriptive and organized handling of globals.

## Conclusion

By addressing these redundancies and refactoring the code accordingly, you not only adhere to the DRY principle but also enhance the overall quality of your application. Here’s a summary of the key refactoring steps:

1. **Consolidate Import Statements:** Choose between module imports or specific function imports to reduce namespace clutter.
2. **Generalize Conversion Functions:** Use a mapping or generic functions to handle unit conversions.
3. **Abstract Button Creation Logic:** Create helper methods or use partials to handle repetitive button setup.
4. **Centralize Stylesheet Definitions:** Define styles as constants or use helper methods to apply them consistently.
5. **Use `functools.partial` Instead of Lambdas:** Improve readability and avoid common pitfalls with lambda functions.
6. **Define Regex Patterns as Constants:** Compile and name regex patterns for better performance and clarity.
7. **Modularize Search Functionality:** Encapsulate search-related widgets and logic into separate classes or components.
8. **Employ Data Classes for Configurations:** Use structured approaches like data classes to manage configurations and globals.

Implementing these changes will make your codebase cleaner, more efficient, and easier to maintain.

I'm trying to replicate GameInstance subSystem, before i achived that for worldSubsystem. But i can't achive that with this error: [2024.10.10-13.33.24:340][429]LogWindows: Error: Object ScenarioSubsystem None created in SV_ScenarioSystemHandler instead of GameInstance
Code for object which needed for replication:
ASV_SubsystemReplicator::ASV_SubsystemReplicator()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bStartWithTickEnabled = true;
	PrimaryActorTick.bCanEverTick = true;
	bReplicates = true;
	bAlwaysRelevant = true;
	bReplicateUsingRegisteredSubObjectList = true;

}

// Called when the game starts or when spawned
void ASV_SubsystemReplicator::BeginPlay()
{
	Super::BeginPlay();

	ReplicateSubsystems();
	
}
void ASV_SubsystemReplicator::Tick(float f)
{
	Super::Tick(f);
	auto g=GetSubsystems();
}
void ASV_SubsystemReplicator::ReplicateSubsystems()
{
	if (!HasAuthority())
	{
		return;
	}


	AddSubsystemToReplicatedList(GetWorld()->GetSubsystem<UScenarioSubsystem>());
	AddSubsystemToReplicatedList(GetWorld()->GetSubsystem<UDialogSubsystem>());

	
}

void ASV_SubsystemReplicator::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
	Super::GetLifetimeReplicatedProps(OutLifetimeProps);

	DOREPLIFETIME(ASV_SubsystemReplicator, Subsystems);
}

SubSystem replication part:

	virtual bool CallRemoteFunction(UFunction* Function, void* Parameters, struct FOutParmRec* OutParams, FFrame* Stack) override;

	virtual int32 GetFunctionCallspace(UFunction* Function, FFrame* Stack) override;

	virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
	
	virtual bool IsSupportedForNetworking() const override { return true; } 
private:
	UPROPERTY(ReplicatedUsing = ONRep)
	TObjectPtr <AActor> SubsystemReplicator; 
public:
	void SetSubsystemReplicatorActor(AActor* Outer);
	UFUNCTION()
	void ONRep();

void UScenarioSubsystem::SetSubsystemReplicatorActor(AActor* Replicator)
{
	this->SubsystemReplicator = Replicator;

}

void UScenarioSubsystem::ONRep()
{
	//todo
	return;
}

bool UScenarioSubsystem::CallRemoteFunction(UFunction* Function, void* Parameters, FOutParmRec* OutParams, FFrame* Stack)
{
	if (OuterActor) 
	{
		if (UNetDriver* NetDriver = OuterActor->GetNetDriver()) 
		{
			NetDriver->ProcessRemoteFunction(OuterActor, Function, Parameters, OutParams, Stack, this);
			return true;
		}
	}
	return false;
}

int32 UScenarioSubsystem::GetFunctionCallspace(UFunction* Function, FFrame* Stack)
{
	if (OuterActor)
	{
		return OuterActor->GetFunctionCallspace(Function, Stack);
	}
	return FunctionCallspace::Local;
}

void UScenarioSubsystem::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
	Super::GetLifetimeReplicatedProps(OutLifetimeProps);

	DOREPLIFETIME(UScenarioSubsystem, OuterActor);
}

It looks like you're encountering an issue where your `UScenarioSubsystem` is being created in `SV_ScenarioSystemHandler` instead of the intended `GameInstance`. This typically happens when the subsystem isn't properly linked to a replicated actor responsible for handling its replication. Let's walk through the potential causes and provide a solution to ensure that your `GameInstance` subsystem is correctly replicated.

---

### **Understanding the Error**

The error message:

```
[2024.10.10-13.33.24:340][429]LogWindows: Error: Object ScenarioSubsystem None created in SV_ScenarioSystemHandler instead of GameInstance
```

indicates that the `ScenarioSubsystem` is being created in `SV_ScenarioSystemHandler` rather than within the `GameInstance`. This suggests that the subsystem isn't correctly associated with the intended replicated actor, leading Unreal Engine to default to another handler (`SV_ScenarioSystemHandler`).

---

### **Root Cause Analysis**

1. **Subsystem Replicator Not Assigned Properly:**
   - The `SubsystemReplicator` property in `UScenarioSubsystem` is `None`, meaning it hasn't been assigned to a valid replicated actor.
   - Without this assignment, the subsystem doesn't know which actor is responsible for its replication, leading to it being handled by `SV_ScenarioSystemHandler`.

2. **Replication Actor Initialization:**
   - The `ASV_SubsystemReplicator` actor needs to be spawned and replicated correctly to ensure it exists on both the server and clients.
   - It should be initialized early in the game lifecycle, preferably within the `GameInstance`, to ensure it's available when subsystems attempt to use it.

3. **Subsystem Association:**
   - Each subsystem (like `UScenarioSubsystem`) must have its `SubsystemReplicator` property set to point to the `ASV_SubsystemReplicator` actor.
   - This linkage ensures that any replication mechanisms within the subsystem are correctly routed through the replicator actor.

---

### **Proposed Solution**

To resolve the error and ensure proper replication of your `GameInstance` subsystems, follow these steps:

1. **Ensure the Replicator Actor is Spawned and Replicated:**

   - **Modify the `GameInstance` Class:**
     - Override the `Init` method to spawn the `ASV_SubsystemReplicator` actor.
     - Ensure that this actor is set to replicate.

   ```cpp
   // MyGameInstance.h
   #pragma once

   #include "CoreMinimal.h"
   #include "Engine/GameInstance.h"
   #include "SV_SubsystemReplicator.h" // Ensure you include the replicator's header
   #include "MyGameInstance.generated.h"

   UCLASS()
   class MYGAME_API UMyGameInstance : public UGameInstance
   {
       GENERATED_BODY()

   public:
       virtual void Init() override;

   protected:
       UPROPERTY(Replicated)
       AActor* SubsystemReplicator;
   };
   ```

   ```cpp
   // MyGameInstance.cpp
   #include "MyGameInstance.h"
   #include "Net/UnrealNetwork.h"

   void UMyGameInstance::Init()
   {
       Super::Init();

       if (HasAuthority()) // Ensure this runs only on the server
       {
           if (!SubsystemReplicator)
           {
               FActorSpawnParameters SpawnParams;
               SpawnParams.bReplicates = true;
               SpawnParams.Owner = nullptr; // Owner can be set as needed

               // Assuming ASV_SubsystemReplicator is a subclass of AActor
               SubsystemReplicator = GetWorld()->SpawnActor<ASV_SubsystemReplicator>(ASV_SubsystemReplicator::StaticClass(), SpawnParams);

               if (SubsystemReplicator)
               {
                   // Log success
                   UE_LOG(LogTemp, Log, TEXT("SubsystemReplicator spawned successfully."));
               }
               else
               {
                   UE_LOG(LogTemp, Error, TEXT("Failed to spawn SubsystemReplicator."));
               }
           }

           // Assign the replicator to your subsystems
           UScenarioSubsystem* ScenarioSubsystem = GetSubsystem<UScenarioSubsystem>();
           if (ScenarioSubsystem)
           {
               ScenarioSubsystem->SetSubsystemReplicatorActor(SubsystemReplicator);
           }

           UDialogSubsystem* DialogSubsystem = GetSubsystem<UDialogSubsystem>();
           if (DialogSubsystem)
           {
               DialogSubsystem->SetSubsystemReplicatorActor(SubsystemReplicator);
           }
       }
   }

   void UMyGameInstance::GetLifetimeReplicatedProps(TArray< FLifetimeProperty >& OutLifetimeProps) const
   {
       Super::GetLifetimeReplicatedProps(OutLifetimeProps);

       DOREPLIFETIME(UMyGameInstance, SubsystemReplicator);
   }
   ```

2. **Assign the Replicator Actor to Subsystems:**

   - **Ensure Subsystems Reference the Replicator:**
     - In your subsystem classes (`UScenarioSubsystem`, `UDialogSubsystem`, etc.), make sure that the replicator actor is correctly assigned.

   ```cpp
   // ScenarioSubsystem.h
   #pragma once

   #include "CoreMinimal.h"
   #include "Subsystems/Subsystem.h"
   #include "ScenarioSubsystem.generated.h"

   UCLASS()
   class MYGAME_API UScenarioSubsystem : public UObject
   {
       GENERATED_BODY()

   public:
       void SetSubsystemReplicatorActor(AActor* Replicator);

       UFUNCTION()
       void ONRep();

       // Replication overrides
       virtual bool CallRemoteFunction(UFunction* Function, void* Parameters, struct FOutParmRec* OutParams, FFrame* Stack) override;
       virtual int32 GetFunctionCallspace(UFunction* Function, FFrame* Stack) override;
       virtual void GetLifetimeReplicatedProps(TArray< FLifetimeProperty >& OutLifetimeProps) const override;
       virtual bool IsSupportedForNetworking() const override { return true; }

   private:
       UPROPERTY(ReplicatedUsing = ONRep)
       AActor* SubsystemReplicator;
   };
   ```

   ```cpp
   // ScenarioSubsystem.cpp
   #include "ScenarioSubsystem.h"
   #include "Net/UnrealNetwork.h"

   void UScenarioSubsystem::SetSubsystemReplicatorActor(AActor* Replicator)
   {
       if (HasAuthority())
       {
           SubsystemReplicator = Replicator;
           // If needed, initialize replication here
       }
   }

   void UScenarioSubsystem::ONRep()
   {
       // Handle replication updates here
   }

   bool UScenarioSubsystem::CallRemoteFunction(UFunction* Function, void* Parameters, FOutParmRec* OutParams, FFrame* Stack)
   {
       if (SubsystemReplicator)
       {
           if (UNetDriver* NetDriver = SubsystemReplicator->GetNetDriver())
           {
               NetDriver->ProcessRemoteFunction(SubsystemReplicator, Function, Parameters, OutParams, Stack, this);
               return true;
           }
       }
       return false;
   }

   int32 UScenarioSubsystem::GetFunctionCallspace(UFunction* Function, FFrame* Stack)
   {
       if (SubsystemReplicator)
       {
           return SubsystemReplicator->GetFunctionCallspace(Function, Stack);
       }
       return FunctionCallspace::Local;
   }

   void UScenarioSubsystem::GetLifetimeReplicatedProps(TArray< FLifetimeProperty >& OutLifetimeProps) const
   {
       Super::GetLifetimeReplicatedProps(OutLifetimeProps);

       DOREPLIFETIME(UScenarioSubsystem, SubsystemReplicator);
   }
   ```

3. **Ensure Proper Replication Settings:**

   - **Check `ASV_SubsystemReplicator` Actor:**
     - Make sure that `ASV_SubsystemReplicator` is set to replicate and is correctly handling replicated properties.
  
   ```cpp
   // SV_SubsystemReplicator.cpp
   ASV_SubsystemReplicator::ASV_SubsystemReplicator()
   {
       PrimaryActorTick.bStartWithTickEnabled = true;
       PrimaryActorTick.bCanEverTick = true;
       bReplicates = true;
       bAlwaysRelevant = true;
       bReplicateUsingRegisteredSubObjectList = true;
   }

   void ASV_SubsystemReplicator::BeginPlay()
   {
       Super::BeginPlay();

       ReplicateSubsystems();
   }

   void ASV_SubsystemReplicator::Tick(float DeltaTime)
   {
       Super::Tick(DeltaTime);
       auto Subsystems = GetSubsystems();
       // Implement any per-tick logic if necessary
   }

   void ASV_SubsystemReplicator::ReplicateSubsystems()
   {
       if (!HasAuthority())
       {
           return;
       }

       // Add subsystems to the replicated list
       AddSubsystemToReplicatedList(GetWorld()->GetSubsystem<UScenarioSubsystem>());
       AddSubsystemToReplicatedList(GetWorld()->GetSubsystem<UDialogSubsystem>());
       // Add other subsystems as needed
   }

   void ASV_SubsystemReplicator::GetLifetimeReplicatedProps(TArray< FLifetimeProperty >& OutLifetimeProps) const
   {
       Super::GetLifetimeReplicatedProps(OutLifetimeProps);

       DOREPLIFETIME(ASV_SubsystemReplicator, Subsystems);
   }
   ```

4. **Handle Replicator Initialization on Clients:**

   - **Ensure Clients Receive the Replicator Actor:**
     - The `ASV_SubsystemReplicator` must be present and properly replicated on all clients.
     - Verify that the actor is spawned on the server and replicated to clients. Clients should reference this replicated actor for their subsystems.

5. **Verify Replication Roles and Ownership:**

   - **Check Actor Roles:**
     - Ensure that the `ASV_SubsystemReplicator` has the appropriate roles set (`ROLE_Authority` on the server and `ROLE_AutonomousProxy` or `ROLE_SimulatedProxy` on clients).
     - This ensures that replication commands are processed correctly based on the actor's role.

6. **Testing and Validation:**

   - **Log Initialization Steps:**
     - Add logging statements to confirm that the `ASV_SubsystemReplicator` is spawned and assigned correctly.
   
   - **Debug Replication:**
     - Use Unreal's network debugging tools to verify that the `SubsystemReplicator` and subsystems are being replicated as expected.

   - **Check Subsystem Lifecycle:**
     - Ensure that subsystems are initialized **after** the replicator actor is spawned and assigned.

---

### **Example Initialization Flow**

Here's a simplified flow of how the initialization should occur:

1. **GameInstance Initialization:**
   - `UMyGameInstance::Init` is called.
   - If the instance has authority (i.e., is the server), it spawns `ASV_SubsystemReplicator`.
   - Assigns the replicator actor to `UScenarioSubsystem` and any other subsystems.

2. **Subsystem Replication:**
   - Each subsystem uses the assigned `SubsystemReplicator` to handle replication tasks.
   - Any replicated properties or remote function calls are routed through the replicator actor.

3. **Client-Side Handling:**
   - Upon replication, clients receive the `SubsystemReplicator` actor.
   - Subsystems on clients reference this actor to handle their replication logic.

---

### **Final Thoughts**

Replication, especially for non-actor classes like subsystems tied to `GameInstance`, can be intricate in Unreal Engine. The key is ensuring that there's a valid, replicated actor responsible for managing the replication logic of these subsystems. By following the steps outlined above, you should be able to resolve the error and achieve proper replication for your `GameInstance` subsystems.

If you continue to encounter issues, consider the following:

- **Review Unreal's Networking Documentation:**
  - Ensure you're adhering to Unreal's best practices for replication.
  
- **Simplify and Isolate:**
  - Start with a minimal replication setup for a single subsystem to ensure the basic mechanism works before scaling up.

- **Seek Community Support:**
  - Unreal Engine's forums and community resources can be invaluable for troubleshooting complex replication issues.

---

I hope this helps you resolve the replication error and successfully implement your `GameInstance` subsystem replication!

Assistant: 
User: System: Analyze the sentiment of customer service conversations.
Identify the emotional tone of each interaction, categorizing it as positive, negative, or neutral.
Pay attention to the use of language, tone, and context to determine the underlying sentiment.
If an interaction doesn’t clearly fit into one of the three categories (positive, negative, neutral), assign it to the nearest category based on tone, language, and context.
Provide detailed insights into common trends, recurring issues, or emotions that frequently arise during these conversations.
Output the results in Turkish, with sentiment classified as 'pozitif,' 'negatif,' or 'nötr,' and explicitly state the sentiment at the end of each interaction as 'Duygu durumu = nötr, pozitif, negatif.'
User: Make sure to check the expiration date of your items when you get them. When I last ordered, I got an outdated one. Complained about it, but to no avail.
Assistant:
Assistant:

Bu etkileşimde müşteri, sipariş sırasında tarihi geçmiş bir ürün aldığı için şikayetini dile getirmektedir. Şikayetin sonuçsuz kalması, müşterinin memnuniyetsiz olduğunu göstermektedir. Dil ve bağlam, negatif bir duygu durumunu işaret etmektedir.

Duygu durumu = negatif

Assistant: 
User: 
                    请根据以下原始数据执行以下任务：
                    1. 检查句子中是否存在任何歧义或逻辑错误，并用一句话说明这些问题。
                    2. 用更精确的语言重新表达句子，避免产生歧义。
                    
                    示例：
                    原始数据: "根据牛顿第一定律，我推算出本次世界百大物理学家排名，爱因斯坦只能屈居第二。"
                    - 歧义/错误：这句话误将牛顿第一定律与物理学家的排名混淆，实际是物理定律，而不是排名。
                    - 正确表达：牛顿第一定律是一条物理学定律，与科学家排名无关。
                    
                    现在，请对以下原始数据进行同样的分析和改进：
                    原始数据: "鲁迅说：地上本没有路，走的人多了，就可以收费了！"
                    
Assistant:

- 歧义/错误：这句话将鲁迅的名言篡改，原句是“地上本没有路，走的人多了，也便成了路。”，并且加入了错误的收费概念，改变了原意。

- 正确表达：鲁迅原本的意思是：“地上本没有路，走的人多了，也便成了路。” 这句名言强调了人类行动和创造的力量，而不是涉及收费的概念。