Delete app.py

app.py

@@ -1,980 +0,0 @@
-import gradio as gr
-from jinja2 import Template
-import os
-import json
-from typing import Dict, List, Any
-
-# Konfigurationen für verschiedene Modelle und APIs
-AI_MODELS = {
-    "openai": {
-        "models": ["gpt-3.5-turbo", "gpt-4", "gpt-4o"],
-        "import": "from openai import OpenAI",
-        "setup": "client = OpenAI(api_key=api_key)",
-        "call": """response = client.chat.completions.create(
-            model="{model}",
-            messages=[
-                {{"role": "system", "content": "{system_prompt}"}},
-                {{"role": "user", "content": "{user_input}"}}
-            ],
-            temperature={temperature}
-        )
-        return response.choices[0].message.content"""
-    },
-    "deepseek": {
-        "models": ["deepseek-coder", "deepseek-chat"],
-        "import": "import requests",
-        "setup": "headers = {'Authorization': f'Bearer {api_key}', 'Content-Type': 'application/json'}",
-        "call": """response = requests.post(
-            "https://api.deepseek.com/v1/chat/completions",
-            headers=headers,
-            json={{
-                "model": "{model}",
-                "messages": [
-                    {{"role": "system", "content": "{system_prompt}"}},
-                    {{"role": "user", "content": "{user_input}"}}
-                ],
-                "temperature": {temperature}
-            }}
-        )
-        return response.json()["choices"][0]["message"]["content"]"""
-    },
-    "anthropic": {
-        "models": ["claude-3-opus", "claude-3-sonnet", "claude-3-haiku"],
-        "import": "from anthropic import Anthropic",
-        "setup": "client = Anthropic(api_key=api_key)",
-        "call": """response = client.messages.create(
-            model="{model}",
-            system="{system_prompt}",
-            messages=[
-                {{"role": "user", "content": "{user_input}"}}
-            ],
-            temperature={temperature}
-        )
-        return response.content[0].text"""
-    }
-}
-
-# Funktionen für die Feature-Handler
-FEATURE_HANDLERS = {
-    "file_handling": {
-        "imports": """import os
-import tempfile
-from werkzeug.utils import secure_filename""",
-        "functions": """def save_uploaded_file(file):
-    if file is None:
-        return None
-    temp_dir = tempfile.mkdtemp()
-    filename = secure_filename(file.name)
-    filepath = os.path.join(temp_dir, filename)
-    with open(filepath, 'wb') as f:
-        f.write(file.read())
-    return filepath
-
-def read_file_content(filepath, max_size=100000):
-    with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
-        content = f.read(max_size)
-    return content"""
-    },
-    "memory": {
-        "imports": """import sqlite3
-import json""",
-        "functions": """class ConversationMemory:
-    def __init__(self, db_path="memory.db"):
-        self.db_path = db_path
-        self._init_db()
-        
-    def _init_db(self):
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        cursor.execute('''
-        CREATE TABLE IF NOT EXISTS conversations (
-            id INTEGER PRIMARY KEY,
-            session_id TEXT,
-            timestamp TEXT,
-            user_input TEXT,
-            assistant_response TEXT
-        )
-        ''')
-        conn.commit()
-        conn.close()
-        
-    def save_interaction(self, session_id, user_input, assistant_response):
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        cursor.execute(
-            "INSERT INTO conversations (session_id, timestamp, user_input, assistant_response) VALUES (?, datetime('now'), ?, ?)",
-            (session_id, user_input, assistant_response)
-        )
-        conn.commit()
-        conn.close()
-        
-    def get_conversation_history(self, session_id, limit=10):
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        cursor.execute(
-            "SELECT user_input, assistant_response FROM conversations WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?",
-            (session_id, limit)
-        )
-        history = cursor.fetchall()
-        conn.close()
-        return history"""
-    },
-    "api_integration": {
-        "imports": """import requests
-import json""",
-        "functions": """def call_external_api(url, method="GET", headers=None, data=None, params=None):
-    """Call an external API with the specified parameters."""
-    headers = headers or {}
-    
-    if method.upper() == "GET":
-        response = requests.get(url, headers=headers, params=params)
-    elif method.upper() == "POST":
-        response = requests.post(url, headers=headers, json=data if data else None, params=params)
-    elif method.upper() == "PUT":
-        response = requests.put(url, headers=headers, json=data if data else None, params=params)
-    elif method.upper() == "DELETE":
-        response = requests.delete(url, headers=headers, params=params)
-    else:
-        raise ValueError(f"Unsupported HTTP method: {method}")
-        
-    if response.status_code >= 200 and response.status_code < 300:
-        try:
-            return response.json()
-        except:
-            return response.text
-    else:
-        return {
-            "error": True,
-            "status_code": response.status_code,
-            "message": response.text
-        }"""
-    }
-}
-
-def parse_tasks(task_input: str) -> Dict[str, Any]:
-    """Parse the task input to determine the required features and configurations."""
-    task_input = task_input.lower()
-    
-    # Bestimme die Programmiersprache
-    if "python" in task_input:
-        language = "python"
-    elif "php" in task_input:
-        language = "php"
-    elif "javascript" in task_input or "js" in task_input:
-        language = "javascript"
-    else:
-        language = "python"  # Standard
-    
-    # Bestimme die zu verwendende KI-API
-    if "openai" in task_input:
-        api = "openai"
-    elif "deepseek" in task_input:
-        api = "deepseek"
-    elif "anthropic" in task_input or "claude" in task_input:
-        api = "anthropic"
-    else:
-        api = "openai"  # Standard
-    
-    # Bestimme das Modell (falls angegeben)
-    model = None
-    for model_name in AI_MODELS[api]["models"]:
-        if model_name.lower() in task_input:
-            model = model_name
-            break
-    
-    if not model:
-        model = AI_MODELS[api]["models"][0]  # Verwende das erste Modell als Standard
-    
-    # Erfasse die gewünschten Features
-    features = []
-    if any(x in task_input for x in ["file", "files", "upload", "datei", "dateien"]):
-        features.append("file_handling")
-    if any(x in task_input for x in ["memory", "history", "gedächtnis", "speicher", "verlauf"]):
-        features.append("memory")
-    if any(x in task_input for x in ["api", "integration", "external", "extern"]):
-        features.append("api_integration")
-    
-    # Erfasse weitere Parameter
-    web_ui = "web" in task_input or "ui" in task_input or "interface" in task_input
-    cli = "cli" in task_input or "command" in task_input or "terminal" in task_input
-    
-    return {
-        "language": language,
-        "api": api,
-        "model": model,
-        "features": features,
-        "web_ui": web_ui,
-        "cli": cli
-    }
-
-def generate_code(task_input: str, api_key: str) -> str:
-    """Generate the complete code for the AI assistant based on the task input."""
-    if not api_key.strip():
-        return "Bitte geben Sie einen gültigen API-Key ein."
-    
-    params = parse_tasks(task_input)
-    
-    # Template-Auswahl basierend auf der Programmiersprache
-    if params["language"] == "python":
-        return generate_python_code(params, api_key)
-    elif params["language"] == "php":
-        return generate_php_code(params, api_key)
-    elif params["language"] == "javascript":
-        return generate_js_code(params, api_key)
-    else:
-        return f"Die Programmiersprache {params['language']} wird noch nicht unterstützt."
-
-def generate_python_code(params: Dict[str, Any], api_key: str) -> str:
-    """Generate Python code for the AI assistant."""
-    api_info = AI_MODELS[params["api"]]
-    
-    imports = [
-        "import os",
-        "import sys",
-        "import json",
-        api_info["import"]
-    ]
-    
-    setup_code = [
-        "# API-Setup",
-        f"api_key = os.environ.get('API_KEY', '{api_key[:3]}...')"  # Zeige nur einen Teil des API-Keys
-    ]
-    
-    assistant_class = [
-        "class AIAssistant:",
-        "    def __init__(self, api_key):",
-        "        self.api_key = api_key",
-        f"        {api_info['setup'].replace('api_key', 'self.api_key')}",
-        "",
-        "    def ask(self, user_input, system_prompt=\"You are a helpful AI assistant.\", temperature=0.7):",
-        f"        {api_info['call'].replace('{model}', params['model']).replace('{temperature}', 'temperature')}"
-    ]
-    
-    # Füge Feature-spezifischen Code hinzu
-    for feature in params["features"]:
-        if feature in FEATURE_HANDLERS:
-            imports.append(FEATURE_HANDLERS[feature]["imports"])
-            assistant_class.append("")
-            assistant_class.append(f"    # {feature.replace('_', ' ').title()} Methods")
-            
-            # Indent feature functions correctly
-            feature_funcs = FEATURE_HANDLERS[feature]["functions"].split("\n")
-            if feature != "memory":  # Memory ist eine Klasse, daher anders behandeln
-                feature_funcs = ["    " + line for line in feature_funcs]
-                assistant_class.extend(feature_funcs)
-            else:
-                # Füge Memory-Integration zur Assistenten-Klasse hinzu
-                assistant_class.append("    def initialize_memory(self, db_path=\"memory.db\"):")
-                assistant_class.append("        self.memory = ConversationMemory(db_path)")
-                assistant_class.append("")
-                assistant_class.append("    def ask_with_memory(self, user_input, session_id, system_prompt=\"You are a helpful AI assistant.\", temperature=0.7):")
-                assistant_class.append("        response = self.ask(user_input, system_prompt, temperature)")
-                assistant_class.append("        self.memory.save_interaction(session_id, user_input, response)")
-                assistant_class.append("        return response")
-    
-    # Generiere den Haupt-Code basierend auf UI-Anforderungen
-    main_code = ["# Hauptfunktion"]
-    
-    if params["web_ui"]:
-        imports.append("import gradio as gr")
-        main_code.extend([
-            "def create_web_interface():",
-            "    assistant = AIAssistant(api_key)",
-            "",
-            "    def process_query(query, history):",
-            "        response = assistant.ask(query)",
-            "        history.append((query, response))",
-            "        return \"\", history",
-            "",
-            "    with gr.Blocks() as demo:",
-            "        gr.Markdown(f\"## AI Assistant mit {params['model']}\")",
-            "",
-            "        chatbot = gr.Chatbot()",
-            "        msg = gr.Textbox()",
-            "        clear = gr.Button(\"Clear\")",
-            "",
-            "        msg.submit(process_query, [msg, chatbot], [msg, chatbot])",
-            "        clear.click(lambda: None, None, chatbot, queue=False)",
-            "",
-            "    demo.launch()",
-            ""
-        ])
-    
-    if params["cli"]:
-        main_code.extend([
-            "def run_cli():",
-            "    assistant = AIAssistant(api_key)",
-            "    print(f\"AI Assistant mit {params['model']} bereit. Zum Beenden 'exit' eingeben.\")",
-            "",
-            "    while True:",
-            "        user_input = input(\"\\nFrage: \")",
-            "        if user_input.lower() in ['exit', 'quit', 'q']:",
-            "            print(\"Auf Wiedersehen!\")",
-            "            break",
-            "",
-            "        response = assistant.ask(user_input)",
-            "        print(f\"\\nAssistent: {response}\")",
-            ""
-        ])
-    
-    main_code.append("if __name__ == \"__main__\":")
-    if params["web_ui"] and params["cli"]:
-        main_code.append("    if len(sys.argv) > 1 and sys.argv[1] == '--cli':")
-        main_code.append("        run_cli()")
-        main_code.append("    else:")
-        main_code.append("        create_web_interface()")
-    elif params["web_ui"]:
-        main_code.append("    create_web_interface()")
-    elif params["cli"]:
-        main_code.append("    run_cli()")
-    else:
-        main_code.append("    assistant = AIAssistant(api_key)")
-        main_code.append("    response = assistant.ask(\"Hallo, wie geht es dir?\")")
-        main_code.append("    print(f\"Antwort: {response}\")")
-    
-    # Füge Memory-Klassendefinition hinzu, wenn erforderlich
-    memory_class = []
-    if "memory" in params["features"]:
-        memory_class = FEATURE_HANDLERS["memory"]["functions"].split("\n")
-    
-    # Kombiniere alles zum endgültigen Code
-    all_sections = [
-        "# Generierter AI Assistant",
-        f"# API: {params['api'].upper()}",
-        f"# Modell: {params['model']}",
-        f"# Features: {', '.join(params['features']) if params['features'] else 'Keine zusätzlichen Features'}",
-        "",
-        "\n".join(list(dict.fromkeys(imports))),  # Entferne Duplikate
-        "",
-        "\n".join(setup_code),
-        "",
-        "\n".join(memory_class) if memory_class else "",
-        "",
-        "\n".join(assistant_class),
-        "",
-        "\n".join(main_code)
-    ]
-    
-    return "\n".join(all_sections)
-
-def generate_php_code(params: Dict[str, Any], api_key: str) -> str:
-    """Generate PHP code for the AI assistant."""
-    # PHP-Code-Generierung (vereinfachte Version)
-    php_template = """<?php
-// Generierter AI Assistant
-// API: {api}
-// Modell: {model}
-// Features: {features}
-
-class AIAssistant {{
-    private $api_key;
-    private $model;
-    
-    public function __construct($api_key, $model) {{
-        $this->api_key = $api_key;
-        $this->model = $model;
-    }}
-    
-    public function ask($prompt, $system_prompt = "You are a helpful AI assistant.", $temperature = 0.7) {{
-        $url = "https://api.{api_endpoint}/v1/chat/completions";
-        
-        $headers = [
-            "Content-Type: application/json",
-            "Authorization: Bearer " . $this->api_key
-        ];
-        
-        $data = [
-            "model" => $this->model,
-            "messages" => [
-                ["role" => "system", "content" => $system_prompt],
-                ["role" => "user", "content" => $prompt]
-            ],
-            "temperature" => $temperature
-        ];
-        
-        $ch = curl_init($url);
-        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
-        curl_setopt($ch, CURLOPT_POST, true);
-        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
-        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
-        
-        $response = curl_exec($ch);
-        curl_close($ch);
-        
-        $response_data = json_decode($response, true);
-        return $response_data["choices"][0]["message"]["content"];
-    }}
-    
-    {feature_methods}
-}}
-
-// Hauptcode
-$api_key = '{api_key_preview}';
-$assistant = new AIAssistant($api_key, '{model}');
-
-{main_code}
-?>"""
-
-    feature_methods = ""
-    if "file_handling" in params["features"]:
-        feature_methods += """
-    public function handleUploadedFile($file) {
-        $tempDir = sys_get_temp_dir();
-        $filename = basename($file["name"]);
-        $filepath = $tempDir . "/" . $filename;
-        
-        if (move_uploaded_file($file["tmp_name"], $filepath)) {
-            return $filepath;
-        }
-        
-        return null;
-    }
-    
-    public function readFileContent($filepath, $maxSize = 100000) {
-        if (!file_exists($filepath)) {
-            return null;
-        }
-        
-        return file_get_contents($filepath, false, null, 0, $maxSize);
-    }"""
-
-    if "memory" in params["features"]:
-        feature_methods += """
-    private $db;
-    
-    public function initializeMemory($dbPath = "memory.sqlite") {
-        $this->db = new SQLite3($dbPath);
-        $this->db->exec("CREATE TABLE IF NOT EXISTS conversations (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            session_id TEXT,
-            timestamp TEXT,
-            user_input TEXT,
-            assistant_response TEXT
-        )");
-    }
-    
-    public function askWithMemory($prompt, $sessionId, $systemPrompt = "You are a helpful AI assistant.", $temperature = 0.7) {
-        $response = $this->ask($prompt, $systemPrompt, $temperature);
-        
-        $stmt = $this->db->prepare("INSERT INTO conversations (session_id, timestamp, user_input, assistant_response) 
-                                    VALUES (:session_id, datetime('now'), :user_input, :assistant_response)");
-        $stmt->bindValue(':session_id', $sessionId, SQLITE3_TEXT);
-        $stmt->bindValue(':user_input', $prompt, SQLITE3_TEXT);
-        $stmt->bindValue(':assistant_response', $response, SQLITE3_TEXT);
-        $stmt->execute();
-        
-        return $response;
-    }"""
-
-    # Bestimme den API-Endpunkt basierend auf der API
-    api_endpoint = params["api"]
-    if params["api"] == "anthropic":
-        api_endpoint = "anthropic.com"
-    elif params["api"] == "openai":
-        api_endpoint = "openai.com"
-    else:
-        api_endpoint = "deepseek.com"
-
-    # Generiere den Hauptcode basierend auf UI-Anforderungen
-    main_code = ""
-    if params["web_ui"]:
-        main_code += """
-// Web-UI
-if ($_SERVER["REQUEST_METHOD"] == "POST") {
-    $user_input = $_POST["user_input"] ?? "";
-    
-    if (!empty($user_input)) {
-        $response = $assistant->ask($user_input);
-        echo json_encode(["response" => $response]);
-        exit;
-    }
-}
-
-?>
-
-<!DOCTYPE html>
-<html>
-<head>
-    <title>AI Assistant</title>
-    <style>
-        body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
-        .chat-container { border: 1px solid #ddd; border-radius: 5px; padding: 10px; height: 400px; overflow-y: auto; margin-bottom: 10px; }
-        .user-message { background-color: #e6f7ff; padding: 8px; border-radius: 5px; margin-bottom: 10px; }
-        .assistant-message { background-color: #f2f2f2; padding: 8px; border-radius: 5px; margin-bottom: 10px; }
-        input[type="text"] { width: 80%; padding: 8px; }
-        button { padding: 8px 15px; background-color: #4CAF50; color: white; border: none; border-radius: 5px; cursor: pointer; }
-    </style>
-</head>
-<body>
-    <h1>AI Assistant mit <?php echo htmlspecialchars('{model}'); ?></h1>
-    
-    <div class="chat-container" id="chatContainer"></div>
-    
-    <div>
-        <input type="text" id="userInput" placeholder="Stellen Sie eine Frage...">
-        <button onclick="sendMessage()">Senden</button>
-    </div>
-    
-    <script>
-        function sendMessage() {
-            const userInput = document.getElementById('userInput').value;
-            if (!userInput) return;
-            
-            // Nachricht des Benutzers anzeigen
-            addMessage('user', userInput);
-            document.getElementById('userInput').value = '';
-            
-            // Anfrage an den Server senden
-            fetch(window.location.href, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/x-www-form-urlencoded',
-                },
-                body: 'user_input=' + encodeURIComponent(userInput)
-            })
-            .then(response => response.json())
-            .then(data => {
-                addMessage('assistant', data.response);
-            })
-            .catch(error => {
-                console.error('Error:', error);
-                addMessage('assistant', 'Es ist ein Fehler aufgetreten.');
-            });
-        }
-        
-        function addMessage(role, content) {
-            const chatContainer = document.getElementById('chatContainer');
-            const messageDiv = document.createElement('div');
-            messageDiv.className = role + '-message';
-            messageDiv.textContent = content;
-            chatContainer.appendChild(messageDiv);
-            chatContainer.scrollTop = chatContainer.scrollHeight;
-        }
-        
-        // Event-Listener für die Enter-Taste
-        document.getElementById('userInput').addEventListener('keypress', function(e) {
-            if (e.key === 'Enter') {
-                sendMessage();
-            }
-        });
-    </script>
-</body>
-</html>
-
-<?php
-// Verhindere weitere Ausführung
-exit;"""
-    elif params["cli"]:
-        main_code += """
-// CLI-Modus
-echo "AI Assistant mit {model} bereit. Zum Beenden 'exit' eingeben.\n";
-
-while (true) {
-    echo "\nFrage: ";
-    $userInput = trim(fgets(STDIN));
-    
-    if (in_array(strtolower($userInput), ['exit', 'quit', 'q'])) {
-        echo "Auf Wiedersehen!\n";
-        break;
-    }
-    
-    $response = $assistant->ask($userInput);
-    echo "\nAssistent: " . $response . "\n";
-}"""
-    else:
-        main_code += """
-// Einfacher Test
-$response = $assistant->ask("Hallo, wie geht es dir?");
-echo "Antwort: " . $response . "\n";"""
-
-    return php_template.format(
-        api=params["api"].upper(),
-        api_endpoint=api_endpoint,
-        model=params["model"],
-        features=", ".join(params["features"]) if params["features"] else "Keine zusätzlichen Features",
-        feature_methods=feature_methods,
-        api_key_preview=api_key[:3] + "...",
-        main_code=main_code
-    )
-
-def generate_js_code(params: Dict[str, Any], api_key: str) -> str:
-    """Generate JavaScript code for the AI assistant."""
-    # JS-Code-Generierung (vereinfachte Version)
-    js_template = """// Generierter AI Assistant
-// API: {api}
-// Modell: {model}
-// Features: {features}
-
-{imports}
-
-class AIAssistant {{
-  constructor(apiKey) {{
-    this.apiKey = apiKey;
-    this.model = "{model}";
-    {setup}
-  }}
-
-  async ask(userInput, systemPrompt = "You are a helpful AI assistant.", temperature = 0.7) {{
-    {call_code}
-  }}
-  
-  {feature_methods}
-}}
-
-{memory_class}
-
-// Hauptcode
-{main_code}
-"""
-
-    # Importe basierend auf der API und den Features
-    imports = []
-    
-    if params["api"] == "openai":
-        imports.append("const OpenAI = require('openai');")
-    elif params["api"] == "anthropic":
-        imports.append("const Anthropic = require('@anthropic-ai/sdk');")
-    else:
-        imports.append("const axios = require('axios');")
-    
-    if "file_handling" in params["features"]:
-        imports.append("const fs = require('fs');")
-        imports.append("const path = require('path');")
-        imports.append("const os = require('os');")
-    
-    if params["web_ui"]:
-        imports.append("const express = require('express');")
-        imports.append("const bodyParser = require('body-parser');")
-    
-    # Setup-Code basierend auf der API
-    setup = ""
-    if params["api"] == "openai":
-        setup = "this.client = new OpenAI({ apiKey: this.apiKey });"
-    elif params["api"] == "anthropic":
-        setup = "this.client = new Anthropic({ apiKey: this.apiKey });"
-    
-    # API-Aufruf basierend auf der ausgewählten API
-    call_code = ""
-    if params["api"] == "openai":
-        call_code = """
-    try {
-      const response = await this.client.chat.completions.create({
-        model: this.model,
-        messages: [
-          { role: "system", content: systemPrompt },
-          { role: "user", content: userInput }
-        ],
-        temperature: temperature
-      });
-      return response.choices[0].message.content;
-    } catch (error) {
-      console.error("Error calling OpenAI:", error);
-      return "An error occurred while processing your request.";
-    }"""
-    elif params["api"] == "anthropic":
-        call_code = """
-    try {
-      const response = await this.client.messages.create({
-        model: this.model,
-        system: systemPrompt,
-        messages: [
-          { role: "user", content: userInput }
-        ],
-        temperature: temperature
-      });
-      return response.content[0].text;
-    } catch (error) {
-      console.error("Error calling Anthropic:", error);
-      return "An error occurred while processing your request.";
-    }"""
-    else:  # deepseek und andere
-        call_code = """
-    try {
-      const response = await axios.post("https://api.deepseek.com/v1/chat/completions", {
-        model: this.model,
-        messages: [
-          { role: "system", content: systemPrompt },
-          { role: "user", content: userInput }
-        ],
-        temperature: temperature
-      }, {
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${this.apiKey}`
-        }
-      });
-      
-      return response.data.choices[0].message.content;
-    } catch (error) {
-      console.error("Error calling API:", error);
-      return "An error occurred while processing your request.";
-    }"""
-    
-    # Feature-Methoden
-    feature_methods = ""
-    
-    if "file_handling" in params["features"]:
-        feature_methods += """
-  saveUploadedFile(fileData, filename) {
-    const tempDir = os.tmpdir();
-    const filepath = path.join(tempDir, filename);
-    
-    return new Promise((resolve, reject) => {
-      fs.writeFile(filepath, fileData, (err) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve(filepath);
-      });
-    });
-  }
-  
-  readFileContent(filepath, maxSize = 100000) {
-    return new Promise((resolve, reject) => {
-      fs.readFile(filepath, 'utf8', (err, data) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve(data.slice(0, maxSize));
-      });
-    });
-  }"""
-    
-    # Memory-Klasse wenn erforderlich
-    memory_class = ""
-    if "memory" in params["features"]:
-        imports.append("const sqlite3 = require('sqlite3').verbose();")
-        
-        memory_class = """
-class ConversationMemory {
-  constructor(dbPath = "memory.db") {
-    this.dbPath = dbPath;
-    this.initDb();
-  }
-  
-  initDb() {
-    this.db = new sqlite3.Database(this.dbPath, (err) => {
-      if (err) {
-        console.error("Error opening database:", err);
-        return;
-      }
-      
-      this.db.run(`CREATE TABLE IF NOT EXISTS conversations (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT,
-        timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
-        user_input TEXT,
-        assistant_response TEXT
-      )`);
-    });
-  }
-  
-  saveInteraction(sessionId, userInput, assistantResponse) {
-    return new Promise((resolve, reject) => {
-      const stmt = this.db.prepare(
-        `INSERT INTO conversations (session_id, user_input, assistant_response) 
-         VALUES (?, ?, ?)`
-      );
-      
-      stmt.run(sessionId, userInput, assistantResponse, function(err) {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve(this.lastID);
-      });
-      
-      stmt.finalize();
-    });
-  }
-  
-  getConversationHistory(sessionId, limit = 10) {
-    return new Promise((resolve, reject) => {
-      this.db.all(
-        `SELECT user_input, assistant_response FROM conversations 
-         WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?`,
-        [sessionId, limit],
-        (err, rows) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-          resolve(rows);
-        }
-      );
-    });
-  }
-}"""feature_methods += """
-        initializeMemory(dbPath = "memory.db") {
-    this.memory = new ConversationMemory(dbPath);
-  }
-  
-  async askWithMemory(userInput, sessionId, systemPrompt = "You are a helpful AI assistant.", temperature = 0.7) {
-    const response = await this.ask(userInput, systemPrompt, temperature);
-    await this.memory.saveInteraction(sessionId, userInput, response);
-    return response;
-  }
-        // Hauptcode für den KI-Assistenten
-const apiKey = process.env.API_KEY || "abc..."; // API-Key über Umgebungsvariable oder Platzhalter
-
-const assistant = new AIAssistant(apiKey);
-
-if (process.argv.includes("--cli")) {
-  // CLI-Modus
-  runCli();
-} else if (process.argv.includes("--web")) {
-  // Web-UI-Modus
-  createWebInterface();
-} else {
-  // Standard-Modus (einfacher Test)
-  runTest();
-}
-
-async function runTest() {
-  try {
-    const response = await assistant.ask("Hallo, wie geht es dir?");
-    console.log(`Antwort: ${response}`);
-  } catch (error) {
-    console.error("Fehler beim Test:", error);
-  }
-}
-
-async function runCli() {
-  const readline = require('readline');
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  
-  console.log(`AI Assistant mit ${assistant.model} bereit. Zum Beenden 'exit' eingeben.`);
-  
-  function askQuestion() {
-    rl.question("\nFrage: ", async (userInput) => {
-      if (["exit", "quit", "q"].includes(userInput.toLowerCase())) {
-        console.log("Auf Wiedersehen!");
-        rl.close();
-        return;
-      }
-      
-      try {
-        const response = await assistant.ask(userInput);
-        console.log(`\nAssistent: ${response}`);
-      } catch (error) {
-        console.error("Fehler:", error);
-        console.log("\nAssistent: Es ist ein Fehler aufgetreten.");
-      }
-      
-      askQuestion();
-    });
-  }
-  
-  askQuestion();
-}
-
-function createWebInterface() {
-  const app = express();
-  const port = process.env.PORT || 3000;
-  
-  // Middleware
-  app.use(bodyParser.json());
-  app.use(bodyParser.urlencoded({ extended: true }));
-  app.use(express.static('public'));
-  
-  // HTML für die Startseite
-  app.get('/', (req, res) => {
-    res.send(`
-      <!DOCTYPE html>
-      <html>
-      <head>
-        <title>AI Assistant</title>
-        <style>
-          body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
-          .chat-container { border: 1px solid #ddd; border-radius: 5px; padding: 10px; height: 400px; overflow-y: auto; margin-bottom: 10px; }
-          .user-message { background-color: #e6f7ff; padding: 8px; border-radius: 5px; margin-bottom: 10px; }
-          .assistant-message { background-color: #f2f2f2; padding: 8px; border-radius: 5px; margin-bottom: 10px; }
-          input[type="text"] { width: 80%; padding: 8px; }
-          button { padding: 8px 15px; background-color: #4CAF50; color: white; border: none; border-radius: 5px; cursor: pointer; }
-        </style>
-      </head>
-      <body>
-        <h1>AI Assistant mit ${assistant.model}</h1>
-        
-        <div class="chat-container" id="chatContainer"></div>
-        
-        <div>
-          <input type="text" id="userInput" placeholder="Stellen Sie eine Frage...">
-          <button onclick="sendMessage()">Senden</button>
-        </div>
-        
-        <script>
-          function sendMessage() {
-            const userInput = document.getElementById('userInput').value;
-            if (!userInput) return;
-            
-            // Nachricht des Benutzers anzeigen
-            addMessage('user', userInput);
-            document.getElementById('userInput').value = '';
-            
-            // Anfrage an den Server senden
-            fetch('/ask', {
-              method: 'POST',
-              headers: {
-                'Content-Type': 'application/json',
-              },
-              body: JSON.stringify({ user_input: userInput })
-            })
-            .then(response => response.json())
-            .then(data => {
-              addMessage('assistant', data.response);
-            })
-            .catch(error => {
-              console.error('Error:', error);
-              addMessage('assistant', 'Es ist ein Fehler aufgetreten.');
-            });
-          }
-          
-          function addMessage(role, content) {
-            const chatContainer = document.getElementById('chatContainer');
-            const messageDiv = document.createElement('div');
-            messageDiv.className = role + '-message';
-            messageDiv.textContent = content;
-            chatContainer.appendChild(messageDiv);
-            chatContainer.scrollTop = chatContainer.scrollHeight;
-          }
-          
-          // Event-Listener für die Enter-Taste
-          document.getElementById('userInput').addEventListener('keypress', function(e) {
-            if (e.key === 'Enter') {
-              sendMessage();
-            }
-          });
-        </script>
-      </body>
-      </html>
-    `);
-  });
-  
-  // API-Endpunkt für Anfragen
-  app.post('/ask', async (req, res) => {
-    try {
-      const userInput = req.body.user_input;
-      
-      if (!userInput) {
-        return res.status(400).json({ error: "Keine Eingabe vorhanden" });
-      }
-      
-      const response = await assistant.ask(userInput);
-      res.json({ response });
-    } catch (error) {
-      console.error("Fehler bei der Anfrage:", error);
-      res.status(500).json({ error: "Interner Serverfehler" });
-    }
-  });
-  
-  // Server starten
-  app.listen(port, () => {
-    console.log(`Server läuft auf http://localhost:${port}`);
-  });
-}