334 lines
13 KiB
TypeScript
334 lines
13 KiB
TypeScript
// src/config/prompts.ts
|
|
|
|
export const AI_PROMPTS = {
|
|
|
|
toolSelection: (mode: string, userQuery: string, maxSelectedItems: number) => {
|
|
const modeInstruction = mode === 'workflow'
|
|
? 'Workflow mit 15-25 Items über alle Phasen. PFLICHT: Mindestens 40% Methoden, Rest Tools/Konzepte.'
|
|
: 'Spezifische Lösung mit 4-10 Items. PFLICHT: Mindestens 30% Methoden wenn verfügbar.';
|
|
|
|
return `Du bist ein DFIR-Experte. Wähle die BESTEN Items aus dem vorgefilterten Set.
|
|
|
|
AUSWAHLMETHODE:
|
|
'✓ Semantisch relevante Items bereits vorgefiltert\n✓ Wähle die BESTEN für die konkrete Aufgabe'}
|
|
|
|
${modeInstruction}
|
|
|
|
ANFRAGE: "${userQuery}"
|
|
|
|
VERFÜGBARE ITEM-TYPEN:
|
|
- TOOLS (type: "software"/"method") → praktische Anwendungen und Vorgehensweisen
|
|
- KONZEPTE (type: "concept") → theoretisches Wissen und Methodiken
|
|
|
|
AUSWAHLSTRATEGIE:
|
|
1. **ERSTE PRIORITÄT: Relevanz zur Anfrage**
|
|
- Direkt anwendbar auf das Problem
|
|
- Löst die Kernherausforderung
|
|
|
|
2. **ZWEITE PRIORITÄT: Ausgewogene Mischung**
|
|
- Tools/Methoden für praktische Umsetzung → selectedTools
|
|
- Konzepte für methodisches Verständnis → selectedConcepts
|
|
- WICHTIG: Auch Konzepte auswählen, nicht nur Tools!
|
|
|
|
3. **QUALITÄT > QUANTITÄT**
|
|
- Lieber weniger perfekte Items als viele mittelmäßige
|
|
- Jedes Item muss begründbar sein
|
|
|
|
4. **TASK RELEVANCE REALISM**
|
|
- Gib realistische Bewertungen (50-85% typisch)
|
|
- Vermeide übertriebene 90-100% Scores
|
|
- Nur bei perfekter Übereinstimmung >85%
|
|
|
|
AUSWAHLREGELN:
|
|
- Wähle ${mode === 'workflow' ? '15-25' : '4-10'} Items total, max ${maxSelectedItems}
|
|
- BEIDE Arrays füllen: selectedTools UND selectedConcepts
|
|
- Mindestens 1-2 Konzepte auswählen für methodische Fundierung
|
|
- Tools: 40% Methoden (type="method"), Rest Software (type="software")
|
|
|
|
ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT:
|
|
{
|
|
"selectedTools": ["ToolName1", "MethodName1", ...],
|
|
"selectedConcepts": ["ConceptName1", "ConceptName2", ...],
|
|
"reasoning": "Kurze Begründung mit Erwähnung der Tool/Konzept-Balance"
|
|
}`;
|
|
},
|
|
|
|
toolSelectionWithData: (basePrompt: string, toolsToSend: any[], conceptsToSend: any[]) => {
|
|
return `${basePrompt}
|
|
|
|
VERFÜGBARE TOOLS (${toolsToSend.length} Items - Methoden und Software):
|
|
${JSON.stringify(toolsToSend, null, 2)}
|
|
|
|
VERFÜGBARE KONZEPTE (${conceptsToSend.length} Items - theoretisches Wissen):
|
|
${JSON.stringify(conceptsToSend, null, 2)}
|
|
|
|
WICHTIGER HINWEIS: Wähle sowohl aus TOOLS als auch aus KONZEPTEN aus! Konzepte sind essentiell für methodische Fundierung.
|
|
|
|
TASK RELEVANCE GUIDELINES:
|
|
- 50-65%: Grundlegend relevant, aber nicht optimal
|
|
- 66-75%: Gut geeignet für die Aufgabe
|
|
- 76-85%: Sehr gut geeignet, klare Vorteile
|
|
- 86-100%: NUR für perfekte Übereinstimmung verwenden`;
|
|
},
|
|
|
|
scenarioAnalysis: (isWorkflow: boolean, userQuery: string) => {
|
|
const analysisType = isWorkflow ? 'Szenario' : 'Problem';
|
|
const focus = isWorkflow ?
|
|
'Angriffsvektoren, betroffene Systeme, Zeitkritikalität' :
|
|
'Kernherausforderung, verfügbare Daten, methodische Anforderungen';
|
|
|
|
return `DFIR-Experte: Analysiere das ${analysisType}.
|
|
|
|
${isWorkflow ? 'SZENARIO' : 'PROBLEM'}: "${userQuery}"
|
|
|
|
Fokus: ${focus}
|
|
|
|
Antwort: Fließtext ohne Listen, max 100 Wörter.`;
|
|
},
|
|
|
|
investigationApproach: (isWorkflow: boolean, userQuery: string) => {
|
|
const approachType = isWorkflow ? 'Untersuchungsansatz' : 'Lösungsansatz';
|
|
const focus = isWorkflow ?
|
|
'Triage-Prioritäten, Phasenabfolge, Kontaminationsvermeidung' :
|
|
'Methodenauswahl, Validierung, Integration';
|
|
|
|
return `Entwickle einen ${approachType}.
|
|
|
|
${isWorkflow ? 'SZENARIO' : 'PROBLEM'}: "${userQuery}"
|
|
|
|
Fokus: ${focus}
|
|
|
|
Antwort: Fließtext ohne Listen, max 100 Wörter.`;
|
|
},
|
|
|
|
criticalConsiderations: (isWorkflow: boolean, userQuery: string) => {
|
|
const focus = isWorkflow ?
|
|
'Beweissicherung vs. Gründlichkeit, Chain of Custody' :
|
|
'Tool-Validierung, False Positives/Negatives, Qualifikationen';
|
|
|
|
return `Identifiziere kritische Überlegungen.
|
|
|
|
${isWorkflow ? 'SZENARIO' : 'PROBLEM'}: "${userQuery}"
|
|
|
|
Fokus: ${focus}
|
|
|
|
Antwort: Fließtext ohne Listen, max 100 Wörter.`;
|
|
},
|
|
|
|
phaseToolSelection: (userQuery: string, phase: any, phaseTools: any[]) => {
|
|
const methods = phaseTools.filter(t => t.type === 'method');
|
|
const tools = phaseTools.filter(t => t.type === 'software');
|
|
|
|
if (phaseTools.length === 0) {
|
|
return `Keine Methoden/Tools für Phase "${phase.name}" verfügbar. Antworte mit leerem Array: []`;
|
|
}
|
|
|
|
return `Du bist ein DFIR-Experte. Wähle die 2-3 BESTEN Items für Phase "${phase.name}".
|
|
|
|
SZENARIO: "${userQuery}"
|
|
PHASE: ${phase.name} - ${phase.description || ''}
|
|
|
|
VERFÜGBARE ITEMS (bereits von KI vorausgewählt):
|
|
${methods.length > 0 ? `
|
|
METHODEN (${methods.length}):
|
|
${methods.map((method: any) =>
|
|
`- ${method.name}
|
|
Typ: ${method.type}
|
|
Beschreibung: ${method.description}
|
|
Domains: ${method.domains?.join(', ') || 'N/A'}
|
|
Skill Level: ${method.skillLevel}`
|
|
).join('\n\n')}
|
|
` : 'Keine Methoden verfügbar'}
|
|
|
|
${tools.length > 0 ? `
|
|
SOFTWARE TOOLS (${tools.length}):
|
|
${tools.map((tool: any) =>
|
|
`- ${tool.name}
|
|
Typ: ${tool.type}
|
|
Beschreibung: ${tool.description}
|
|
Plattformen: ${tool.platforms?.join(', ') || 'N/A'}
|
|
Skill Level: ${tool.skillLevel}`
|
|
).join('\n\n')}
|
|
` : 'Keine Software-Tools verfügbar'}
|
|
|
|
AUSWAHLREGELN FÜR PHASE "${phase.name}":
|
|
1. Wähle die 2-3 BESTEN Items für diese spezifische Phase
|
|
2. Priorisiere Items, die DIREKT für "${phase.name}" relevant sind
|
|
3. Mindestens 1 Methode wenn verfügbar, Rest Software-Tools
|
|
4. Begründe WARUM jedes Item für diese Phase optimal ist
|
|
|
|
TASK RELEVANCE GUIDELINES:
|
|
- 60-70%: Grundlegend für diese Phase geeignet
|
|
- 71-80%: Gut geeignet, klare Phasenrelevanz
|
|
- 81-90%: Sehr gut geeignet, optimal für Phase
|
|
- 91-100%: NUR für perfekte Phasenübereinstimmung
|
|
|
|
WICHTIG: Verwende EXAKT die Namen wie oben aufgelistet (ohne Präfixe wie M1./T2.)!
|
|
|
|
ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT OHNE JEGLICHEN TEXT AUSSERHALB:
|
|
[
|
|
{
|
|
"toolName": "Exakter Name aus der Liste oben",
|
|
"taskRelevance": 75,
|
|
"justification": "Detaillierte Begründung (60-80 Wörter) warum optimal für ${phase.name} - erkläre Anwendung, Vorteile und spezifische Relevanz",
|
|
"limitations": ["Mögliche Einschränkung für diese Phase"]
|
|
}
|
|
]`;
|
|
},
|
|
|
|
toolEvaluation: (userQuery: string, tool: any, rank: number, taskRelevance: number) => {
|
|
const itemType = tool.type === 'method' ? 'Methode' : 'Tool';
|
|
|
|
return `Erkläre die Anwendung dieser/dieses ${itemType}.
|
|
|
|
PROBLEM: "${userQuery}"
|
|
${itemType.toUpperCase()}: ${tool.name} (${taskRelevance}% Eignung)
|
|
TYP: ${tool.type}
|
|
|
|
Bereits als Rang ${rank} bewertet.
|
|
|
|
ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT OHNE JEGLICHEN TEXT AUSSERHALB DER JSON-STRUKTUR:
|
|
{
|
|
"detailed_explanation": "Warum und wie einsetzen",
|
|
"implementation_approach": "Konkrete Schritte",
|
|
"pros": ["Vorteil 1", "Vorteil 2"],
|
|
"limitations": ["Einschränkung 1"],
|
|
"alternatives": "Alternative Ansätze"
|
|
}`;
|
|
},
|
|
|
|
backgroundKnowledgeSelection: (userQuery: string, mode: string, selectedToolNames: string[], availableConcepts: any[]) => {
|
|
return `Wähle 2-4 relevante Konzepte.
|
|
|
|
${mode === 'workflow' ? 'SZENARIO' : 'PROBLEM'}: "${userQuery}"
|
|
AUSGEWÄHLTE TOOLS: ${selectedToolNames.join(', ')}
|
|
|
|
VERFÜGBARE KONZEPTE (${availableConcepts.length} KI-kuratiert):
|
|
${availableConcepts.map((c: any) =>
|
|
`- ${c.name}: ${c.description}...`
|
|
).join('\n')}
|
|
|
|
ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT OHNE JEGLICHEN TEXT AUSSERHALB DER JSON-STRUKTUR:
|
|
[
|
|
{
|
|
"conceptName": "Name",
|
|
"relevance": "Warum kritisch für Methodik"
|
|
}
|
|
]`;
|
|
},
|
|
|
|
phaseCompletionReasoning: (
|
|
originalQuery: string,
|
|
phase: any,
|
|
selectedToolName: string,
|
|
tool: any,
|
|
completionContext: string
|
|
) => {
|
|
return `Du bist ein DFIR-Experte. Erkläre warum dieses Tool nachträglich zur Vervollständigung hinzugefügt wurde.
|
|
|
|
KONTEXT DER NACHTRÄGLICHEN ERGÄNZUNG:
|
|
- Ursprüngliche KI-Auswahl war zu spezifisch/eng gefasst
|
|
- Phase "${phase.name}" war unterrepräsentiert in der initialen Auswahl
|
|
- Semantische Suche fand zusätzlich relevante Tools für diese Phase
|
|
- Tool wird nachträglich hinzugefügt um Vollständigkeit zu gewährleisten
|
|
|
|
URSPRÜNGLICHE ANFRAGE: "${originalQuery}"
|
|
PHASE ZU VERVOLLSTÄNDIGEN: ${phase.name} - ${phase.description || ''}
|
|
HINZUGEFÜGTES TOOL: ${selectedToolName} (${tool.type})
|
|
TOOL-BESCHREIBUNG: ${tool.description}
|
|
|
|
BEGRÜNDUNGSKONTEXT: ${completionContext}
|
|
|
|
Erstelle eine präzise Begründung (max. 40 Wörter), die erklärt:
|
|
1. WARUM dieses Tool nachträglich hinzugefügt wurde
|
|
2. WIE es die ${phase.name}-Phase ergänzt
|
|
3. DASS es die ursprünglich zu spezifische Auswahl erweitert
|
|
|
|
Antwort: Prägnanter Fließtext, knappe Begründung für Nachergänzung. Vermeide Begriffe wie "Das Tool" und gib keinen einleitenden Text wie "Begründung (40 Wörter):" an.`;
|
|
},
|
|
|
|
generatePhaseCompletionPrompt(
|
|
originalQuery: string,
|
|
phase: any,
|
|
candidateTools: any[],
|
|
candidateConcepts: any[]
|
|
): string {
|
|
return `Du bist ein DFIR-Experte. Die initiale KI-Auswahl war zu spezifisch - die Phase "${phase.name}" ist unterrepräsentiert.
|
|
|
|
KONTEXT: Die Hauptauswahl hat zu wenige Tools für "${phase.name}" identifiziert. Wähle jetzt ergänzende Tools aus semantischer Nachsuche.
|
|
|
|
ORIGINAL ANFRAGE: "${originalQuery}"
|
|
UNTERREPRÄSENTIERTE PHASE: ${phase.name} - ${phase.description || ''}
|
|
|
|
SEMANTISCH GEFUNDENE KANDIDATEN für Nachergänzung:
|
|
|
|
VERFÜGBARE TOOLS (${candidateTools.length}):
|
|
${candidateTools.map((tool: any) => `
|
|
- ${tool.name} (${tool.type})
|
|
Beschreibung: ${tool.description}
|
|
Skill Level: ${tool.skillLevel}
|
|
`).join('')}
|
|
|
|
${candidateConcepts.length > 0 ? `
|
|
VERFÜGBARE KONZEPTE (${candidateConcepts.length}):
|
|
${candidateConcepts.map((concept: any) => `
|
|
- ${concept.name}
|
|
Beschreibung: ${concept.description}
|
|
`).join('')}
|
|
` : ''}
|
|
|
|
AUSWAHLREGELN FÜR NACHERGÄNZUNG:
|
|
1. Wähle 1-2 BESTE Methoden/Tools die die ${phase.name}-Phase optimal ergänzen
|
|
2. Methoden/Tools müssen für die ursprüngliche Anfrage relevant sein
|
|
3. Ergänzen, nicht ersetzen - erweitere die zu spezifische Erstauswahl
|
|
4. Realistische Task Relevance (70-85% typisch für Nachergänzungen)
|
|
|
|
ANTWORT AUSSCHLIESSLICH IM JSON-FORMAT:
|
|
{
|
|
"selectedTools": ["ToolName1", "ToolName2"],
|
|
"selectedConcepts": ["ConceptName1"],
|
|
"completionReasoning": "Kurze Erklärung warum diese Nachergänzung für ${phase.name} notwendig war"
|
|
}`;
|
|
},
|
|
|
|
finalRecommendations: (isWorkflow: boolean, userQuery: string, selectedToolNames: string[]) => {
|
|
const focus = isWorkflow ?
|
|
'Workflow-Schritte, Best Practices, Objektivität' :
|
|
'Methodische Überlegungen, Validierung, Qualitätssicherung';
|
|
|
|
return `Erstelle ${isWorkflow ? 'Workflow-Empfehlung' : 'methodische Überlegungen'}.
|
|
|
|
${isWorkflow ? 'SZENARIO' : 'PROBLEM'}: "${userQuery}"
|
|
AUSGEWÄHLT: ${selectedToolNames.join(', ')}${selectedToolNames.length > 5 ? '...' : ''}
|
|
|
|
Fokus: ${focus}
|
|
|
|
Antwort: Fließtext ohne Listen, max ${isWorkflow ? '100' : '80'} Wörter.`;
|
|
}
|
|
} as const;
|
|
|
|
export function getPrompt(key: 'toolSelection', mode: string, userQuery: string, maxSelectedItems: number): string;
|
|
export function getPrompt(key: 'toolSelectionWithData', basePrompt: string, toolsToSend: any[], conceptsToSend: any[]): string;
|
|
export function getPrompt(key: 'scenarioAnalysis', isWorkflow: boolean, userQuery: string): string;
|
|
export function getPrompt(key: 'investigationApproach', isWorkflow: boolean, userQuery: string): string;
|
|
export function getPrompt(key: 'criticalConsiderations', isWorkflow: boolean, userQuery: string): string;
|
|
export function getPrompt(key: 'phaseToolSelection', userQuery: string, phase: any, phaseTools: any[]): string;
|
|
export function getPrompt(key: 'toolEvaluation', userQuery: string, tool: any, rank: number, taskRelevance: number): string;
|
|
export function getPrompt(key: 'backgroundKnowledgeSelection', userQuery: string, mode: string, selectedToolNames: string[], availableConcepts: any[]): string;
|
|
export function getPrompt(key: 'phaseCompletionReasoning', originalQuery: string, phase: any, selectedToolName: string, tool: any, completionContext: string): string;
|
|
export function getPrompt(key: 'finalRecommendations', isWorkflow: boolean, userQuery: string, selectedToolNames: string[]): string;
|
|
export function getPrompt(key: 'generatePhaseCompletionPrompt', originalQuery: string, phase: any, candidateTools: any[], candidateConcepts: any[]): string;
|
|
export function getPrompt(promptKey: keyof typeof AI_PROMPTS, ...args: any[]): string {
|
|
try {
|
|
const promptFunction = AI_PROMPTS[promptKey];
|
|
if (typeof promptFunction === 'function') {
|
|
return (promptFunction as (...args: any[]) => string)(...args);
|
|
} else {
|
|
console.error(`[PROMPTS] Invalid prompt key: ${promptKey}`);
|
|
return 'Error: Invalid prompt configuration';
|
|
}
|
|
} catch (error) {
|
|
console.error(`[PROMPTS] Error generating prompt ${promptKey}:`, error);
|
|
return 'Error: Failed to generate prompt';
|
|
}
|
|
} |