src/core/engine/optimizer.ts

typescript
import { TargetKI, FrameworkName, Mode } from '../models/optimizationConfig';

interface RaceTemplate {
    ROLE: string; 
    ACTION: string; 
    CONTEXT: string; 
    EXPECTATION: string;
    REASONING_FRAMEWORK?: string; 
    VALIDATION_GATE?: string; 
    SCRATCHPAD_INSTRUCTION?: string; 
    SECURITY_DISCLAIMER?: string;
}

const applyFrameworkStrategy = (prompt: string, ki: TargetKI, framework: FrameworkName, mode: Mode): RaceTemplate => {
    const base: Partial<RaceTemplate> = {
        ROLE: `Du bist ein hochspezialisierter ${framework} Experte, der den Prompt für ${ki} optimiert.`,
        ACTION: `Optimiere den folgenden Prompt basierend auf dem Modus "${mode}" und dem Framework "${framework}".`,
        CONTEXT: `Original Prompt: """${prompt.trim()}"""`,
        EXPECTATION: `Liefere den optimierten Prompt im finalen Codeblock und füge einen Konstruktions-Report an.`
    };

    if (ki.includes('Claude') || ki.includes('Gemini')) {
        base.ROLE += ' Du bist auf die Einhaltung komplexer logischer Bedingungen spezialisiert.';
    } else if (ki.includes('Agent') || ki.includes('Copilot') || ki.includes('v0.dev')) {
        base.CONTEXT += ' **ACHTUNG:** Spezifiziere explizit den Technologie-Stack, funktionale Anforderungen und Code-Stil (Prompt Engineer Protokoll).';
    }

    switch (mode) {
        case 'Basic': 
        case 'Quick Boost': 
        case 'Simple':
            base.ROLE += ' Fokus auf schnelle, strukturelle Korrektur.'; 
            break;
        case 'Detail': 
        case 'Pro': 
        case 'Deep Dive':
            base.REASONING_FRAMEWORK = 'Chain-of-Thought (CoT) MUSS vor der Antwort intern ausgeführt werden, um die Logik zu prüfen.';
            base.EXPECTATION += ' Fügen Sie im optimierten Prompt eine Anweisung zur Nutzung dieses Reasoning-Frameworks hinzu.';
            base.VALIDATION_GATE = 'Interne Überprüfung auf 4-D-Methoden Vollständigkeit und Logikbruch vor der Ausgabe.'; 
            break;
        case 'Revolutionär': 
        case 'Critical':
            base.REASONING_FRAMEWORK = 'Chain-of-Verification (CoVe) MUSS obligatorisch angewendet werden, um alle Fakten und Annahmen zu validieren.';
            base.SCRATCHPAD_INSTRUCTION = 'Nutze ein internes "SCRATCHPAD" für alle Zwischenberechnungen und Validierungen. Das SCRATCHPAD darf NICHT Teil der finalen Ausgabe sein.';
            base.VALIDATION_GATE = 'Führe ein Validierungs-Gate durch: Prüfe auf Halluzinationen, Bias und Einhaltung von Sicherheitsrichtlinien.';
            base.SECURITY_DISCLAIMER = 'Füge einen obligatorischen Haftungsausschluss am Ende des Prompts ein, falls das Thema Code, Finanzen oder Recht betrifft.'; 
            break;
    }

    return { 
        ROLE: base.ROLE!, 
        ACTION: base.ACTION!, 
        CONTEXT: base.CONTEXT!, 
        EXPECTATION: base.EXPECTATION!,
        REASONING_FRAMEWORK: base.REASONING_FRAMEWORK,
        VALIDATION_GATE: base.VALIDATION_GATE,
        SCRATCHPAD_INSTRUCTION: base.SCRATCHPAD_INSTRUCTION,
        SECURITY_DISCLAIMER: base.SECURITY_DISCLAIMER
    };
};

export const generateOptimizedPrompt = (originalPrompt: string, targetKI: TargetKI, framework: FrameworkName, mode: Mode): string => {
    if (!originalPrompt.trim()) return "Bitte geben Sie einen Prompt ein, um die Optimierung zu starten.";
    const r = applyFrameworkStrategy(originalPrompt, targetKI, framework, mode);
    return `[SYSTEM-DEFINITION]
ROLE: ${r.ROLE}
TARGET_PLATFORM: ${targetKI}

[REASONING-MODEL]
${r.REASONING_FRAMEWORK ? `REASONING: ${r.REASONING_FRAMEWORK}` : 'REASONING: Direkte Ausführung ohne spezielle kognitive Schleife (Basic Mode).'}
${r.SCRATCHPAD_INSTRUCTION ? `SCRATCHPAD: ${r.SCRATCHPAD_INSTRUCTION}` : ''}
${r.VALIDATION_GATE ? `VALIDATION_CHECK: ${r.VALIDATION_GATE}` : ''}

[TASK-ARCHITECTURE (RACE)]
ACTION: ${r.ACTION}
CONTEXT: ${r.CONTEXT}
EXPECTATION: ${r.EXPECTATION}

[FINAL-OUTPUT-FORMAT]
${r.SECURITY_DISCLAIMER || ''}
---
// Liefere nun die Antwort, beginnend mit: [OPTIMIZED-RESPONSE]`.trim();
};

</html>