gateway/gwserver/modules/agentservice_agent_coder.py

"""
Coder-Agent für die Entwicklung und Implementierung von Code.
"""

import logging
from typing import List, Dict, Any, Optional
from modules.agentservice_base import BaseAgent

logger = logging.getLogger(__name__)

class CoderAgent(BaseAgent):
    """Agent für die Entwicklung und Implementierung von Code"""

    _instance = None
    
    @classmethod
    def get_instance(cls):
        """Gibt eine Singleton-Instanz zurück"""
        if cls._instance is None:
            cls._instance = cls()
        return cls._instance
        
    def __init__(self):
        """Initialisiert den Coder-Agenten"""
        super().__init__()
        self.id = "coder_agent"
        self.name = "Entwickler"
        self.type = "coder"
        self.description = "Programmiert und führt Code aus"
        self.capabilities = "Programmierung, Softwareentwicklung, technische Problemlösung und Implementierung von Algorithmen"
        self.instructions = """
        Du bist der Codeentwicklungsagent, ein Spezialist für die Erstellung von Softwarelösungen und technischen Implementierungen. Deine Aufgabe ist es:

        1. Technische Anforderungen in funktionierenden, effizienten Code zu übersetzen
        2. Geeignete Programmiersprachen, Frameworks und Bibliotheken für spezifische Aufgaben auszuwählen
        3. Algorithmen und Datenstrukturen für die optimale Lösung von Problemen zu entwickeln
        4. Lesbaren, gut dokumentierten und wartbaren Code zu schreiben
        5. Sicherheitsaspekte und Best Practices in der Softwareentwicklung zu berücksichtigen
        6. Potenzielle technische Schwierigkeiten vorherzusehen und Lösungen vorzuschlagen
        7. APIs und Integrationen mit anderen Systemen zu konzipieren und implementieren

        Bei der Präsentation deiner Softwarelösungen:
        - Erkläre zunächst den Lösungsansatz und die gewählte Technologie
        - Stelle den Code in logischen, gut kommentierten Abschnitten dar
        - Erläutere kritische oder komplexe Teile des Codes im Detail
        - Beschreibe Annahmen und getroffene Designentscheidungen
        - Gib Hinweise zur Installation, Konfiguration und Verwendung
        - Erwähne mögliche Erweiterungen und Verbesserungsmöglichkeiten
        - Adressiere potenzielle Einschränkungen oder bekannte Probleme

        Dein Code sollte nicht nur funktional, sondern auch effizient, sicher und gut strukturiert sein. Achte auf Lesbarkeit, Performance und Skalierbarkeit deiner Lösungen. Verwende moderne Entwicklungspraktiken und orientiere dich an etablierten Standards der jeweiligen Programmiersprache.
        """
    
    def get_prompt(self, message_context: Dict[str, Any]) -> str:
        """
        Generiert einen angepassten Prompt für den Coder-Agenten.
        
        Args:
            message_context: Kontext der Nachricht
            
        Returns:
            Formatierter Prompt für den Coder-Agenten
        """
        # Basis-Prompt vom BaseAgent holen
        base_prompt = super().get_prompt(message_context)
        
        # Zusätzliche Anweisungen für Coding
        coding_instructions = """
        CODING-RICHTLINIEN:
        
        1. Wähle die geeignete Programmiersprache basierend auf den Anforderungen
        2. Verfolge einen modularen, gut strukturierten Ansatz
        3. Füge ausreichend Kommentare und Dokumentation hinzu
        4. Beachte Sicherheitsaspekte und Best Practices
        5. Behandle mögliche Fehler und Ausnahmefälle
        6. Stelle sicher, dass der Code vollständig und ausführbar ist
        7. Teste deine Implementierung mit Beispieldaten
        
        Für jede Code-Implementierung:
        - Beginne mit einer kurzen Erklärung des Lösungsansatzes
        - Strukturiere den Code in logische Funktionen/Klassen
        - Erkläre komplexe Teile durch inline-Kommentare
        - Gib am Ende Hinweise zur Verwendung oder Erweiterung
        """
        
        # Prüfen, ob bestimmte Dateitypen vorhanden sind und spezifische Anweisungen hinzufügen
        document_types = self._get_document_types(message_context)
        
        file_specific_instructions = ""
        
        if "csv" in document_types or "excel" in document_types:
            file_specific_instructions += """
            DATENVERARBEITUNG:
            - Verwende geeignete Bibliotheken für Datenverarbeitung (pandas, numpy, etc.)
            - Berücksichtige Speichereffizienz und Performance bei großen Datensätzen
            - Implementiere robustes Fehler-Handling für verschiedene Datenformate
            """
        
        if "py" in document_types or "js" in document_types or "java" in document_types:
            file_specific_instructions += """
            CODE-ANALYSE:
            - Analysiere den vorhandenen Code auf Struktur und Funktionalität
            - Identifiziere Verbesserungspotenziale und mögliche Fehler
            - Schlage konkrete Refactoring-Maßnahmen vor
            - Erweitere den Code gemäß den neuen Anforderungen
            """
        
        # Task aus dem Kontext extrahieren
        task = message_context.get("task", "")
        task_instructions = f"\nAKTUELLE AUFGABE:\n{task}\n" if task else ""
        
        # Vollständigen Prompt zusammenbauen
        complete_prompt = f"{base_prompt}\n\n{coding_instructions}\n\n{file_specific_instructions}\n{task_instructions}"
        
        return complete_prompt.strip()
    
    def _get_document_types(self, message_context: Dict[str, Any]) -> List[str]:
        """
        Extrahiert die Dateitypen aus dem Nachrichtenkontext.
        
        Args:
            message_context: Kontext der Nachricht
            
        Returns:
            Liste der Dateitypen
        """
        document_types = []
        
        # Versuche Dokumente aus dem Kontext zu extrahieren
        documents = message_context.get("documents", [])
        
        for doc in documents:
            source = doc.get("source", {})
            name = source.get("name", "").lower()
            content_type = source.get("content_type", "").lower()
            
            # Dateityp aus Namen oder Content-Type ableiten
            if name.endswith(".py"):
                document_types.append("py")
            elif name.endswith((".js", ".ts")):
                document_types.append("js")
            elif name.endswith((".java", ".kt")):
                document_types.append("java")
            elif name.endswith(".csv") or "csv" in content_type:
                document_types.append("csv")
            elif name.endswith((".xls", ".xlsx")) or "excel" in content_type:
                document_types.append("excel")
        
        return document_types
    
    async def process_message(self, message: Dict[str, Any], context: Dict[str, Any] = None) -> Dict[str, Any]:
        """
        Verarbeitet eine Nachricht und generiert Code.
        
        Args:
            message: Die zu verarbeitende Nachricht
            context: Zusätzlicher Kontext
            
        Returns:
            Die generierte Antwort mit Code
        """
        # In einer realen Implementierung würde hier die Verbindung zum KI-Service hergestellt
        # und die eigentliche Code-Generierung durchgeführt werden.
        
        # Als Beispiel geben wir eine Standardantwort zurück
        coding_response = {
            "role": "assistant",
            "content": f"""Ich habe als {self.name} die Anforderungen analysiert und folgenden Code entwickelt:

```python
def process_data(input_file, output_file):
    \"\"\"
    Verarbeitet Daten aus einer Eingabedatei und speichert die Ergebnisse.
    
    Args:
        input_file: Pfad zur Eingabedatei
        output_file: Pfad zur Ausgabedatei
    \"\"\"
    import pandas as pd
    
    # Daten einlesen
    df = pd.read_csv(input_file)
    
    # Daten verarbeiten
    # Hier würde die eigentliche Datenverarbeitung stattfinden
    processed_df = df.copy()
    
    # Beispiel: Spalten filtern und transformieren
    if 'data' in processed_df.columns:
        processed_df['transformed'] = processed_df['data'] * 2
    
    # Ergebnis speichern
    processed_df.to_csv(output_file, index=False)
    
    return len(processed_df)

# Beispielaufruf
if __name__ == "__main__":
    result = process_data("input.csv", "output.csv")
    print(f"Verarbeitet: result Datensätze")
```

Der Code liest eine CSV-Datei ein, führt eine einfache Transformation durch und speichert das Ergebnis. 
Die Hauptfunktion `process_data` ist modular gestaltet und kann leicht erweitert werden.

Zur Verwendung:
1. Stelle sicher, dass pandas installiert ist (`pip install pandas`)
2. Passe die Dateipfade im Beispielaufruf an
3. Erweitere die Verarbeitung je nach deinen spezifischen Anforderungen

[STATUS: ERGEBNIS]""",
            "agent_type": self.type
        }
        
        # Extrahiere den Status aus der Antwort und aktualisiere den Inhalt
        content, status = self.extract_status(coding_response["content"])
        coding_response["content"] = content
        
        # Setze den Status im Kontext, falls vorhanden
        if context is not None:
            context["status"] = status
        
        return coding_response

# Singleton-Instanz
_coder_agent = None

def get_coder_agent():
    """Gibt eine Singleton-Instanz des Coder-Agenten zurück"""
    global _coder_agent
    if _coder_agent is None:
        _coder_agent = CoderAgent()
    return _coder_agent