new AI features

src/pages/api/ai/query.ts

@@ -1,10 +1,8 @@
 // src/pages/api/ai/query.ts
-// src/pages/api/ai/query.ts
 import type { APIRoute } from 'astro';
 import { getSessionFromRequest, verifySession } from '../../../utils/auth.js';
 import { getCompressedToolsDataForAI } from '../../../utils/dataService.js';
 
-
 export const prerender = false;
 
 function getEnv(key: string): string {
@@ -84,8 +82,8 @@ async function loadToolsDatabase() {
   }
 }
 
-// Create system prompt
-function createSystemPrompt(toolsData: any): string {
+// Create system prompt for workflow mode
+function createWorkflowSystemPrompt(toolsData: any): string {
   const toolsList = toolsData.tools.map((tool: any) => ({
     name: tool.name,
     description: tool.description,
@@ -179,6 +177,58 @@ ANTWORT-FORMAT (strict JSON):
 Antworte NUR mit validen JSON. Keine zusätzlichen Erklärungen außerhalb des JSON.`;
 }
 
+// Create system prompt for tool-specific mode
+function createToolSystemPrompt(toolsData: any): string {
+  const toolsList = toolsData.tools.map((tool: any) => ({
+    name: tool.name,
+    description: tool.description,
+    domains: tool.domains,
+    phases: tool.phases,
+    platforms: tool.platforms,
+    skillLevel: tool.skillLevel,
+    license: tool.license,
+    tags: tool.tags,
+    url: tool.url,
+    projectUrl: tool.projectUrl
+  }));
+
+  return `Du bist ein DFIR (Digital Forensics and Incident Response) Experte, der bei der Auswahl spezifischer Tools für konkrete Probleme hilft.
+
+VERFÜGBARE TOOLS DATABASE:
+${JSON.stringify(toolsList, null, 2)}
+
+WICHTIGE REGELN:
+1. Analysiere das spezifische Problem/die Anforderung sorgfältig
+2. Empfehle 1-3 Tools, sortiert nach Eignung (beste Empfehlung zuerst)
+3. Gib detaillierte Erklärungen, WARUM und WIE jedes Tool das Problem löst
+4. Berücksichtige praktische Aspekte: Skill Level, Plattformen, Verfügbarkeit
+5. Deutsche Antworten für deutsche Anfragen, English for English queries
+6. Gib konkrete Anwendungshinweise, nicht nur allgemeine Beschreibungen
+7. Erwähne sowohl Stärken als auch Schwächen/Limitationen
+8. Schlage alternative Ansätze vor, wenn sinnvoll
+9. Gib grundsätzliche Hinweise, WIE das Tool konkret eingesetzt wird
+
+ANTWORT-FORMAT (strict JSON):
+{
+  "problem_analysis": "Detaillierte Analyse des Problems/der Anforderung",
+  "recommended_tools": [
+    {
+      "name": "EXAKTER Name aus der Database",
+      "rank": 1,
+      "suitability_score": "high|medium|low",
+      "detailed_explanation": "Detaillierte Erklärung, warum dieses Tool das Problem löst",
+      "implementation_approach": "Konkrete Schritte/Ansatz zur Anwendung für dieses spezifische Problem",
+      "pros": ["Spezifische Vorteile für diesen Anwendungsfall", "Weitere Vorteile"],
+      "cons": ["Potentielle Nachteile oder Limitationen", "Weitere Einschränkungen"],
+      "alternatives": "Alternative Ansätze oder ergänzende Tools, falls relevant"
+    }
+  ],
+  "additional_considerations": "Wichtige Überlegungen, Voraussetzungen oder Warnungen"
+}
+
+Antworte NUR mit validen JSON. Keine zusätzlichen Erklärungen außerhalb des JSON.`;
+}
+
 export const POST: APIRoute = async ({ request }) => {
   try {
     // Check if authentication is required
@@ -216,7 +266,7 @@ export const POST: APIRoute = async ({ request }) => {
 
     // Parse request body
     const body = await request.json();
-    const { query } = body;
+    const { query, mode = 'workflow' } = body;
 
     if (!query || typeof query !== 'string') {
       return new Response(JSON.stringify({ error: 'Query required' }), {
@@ -225,6 +275,13 @@ export const POST: APIRoute = async ({ request }) => {
       });
     }
 
+    if (!['workflow', 'tool'].includes(mode)) {
+      return new Response(JSON.stringify({ error: 'Invalid mode. Must be "workflow" or "tool"' }), {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+
     // Sanitize input
     const sanitizedQuery = sanitizeInput(query);
     if (sanitizedQuery.includes('[FILTERED]')) {
@@ -237,8 +294,10 @@ export const POST: APIRoute = async ({ request }) => {
     // Load tools database
     const toolsData = await loadToolsDatabase();
 
-    // Create AI request
-    const systemPrompt = createSystemPrompt(toolsData);
+    // Create appropriate system prompt based on mode
+    const systemPrompt = mode === 'workflow' 
+      ? createWorkflowSystemPrompt(toolsData)
+      : createToolSystemPrompt(toolsData);
     
     const aiResponse = await fetch(process.env.AI_API_ENDPOINT + '/v1/chat/completions', {
       method: 'POST',
@@ -247,7 +306,7 @@ export const POST: APIRoute = async ({ request }) => {
         'Authorization': `Bearer ${process.env.AI_API_KEY}`
       },
       body: JSON.stringify({
-        model: AI_MODEL, // or whatever model is available
+        model: AI_MODEL,
         messages: [
           {
             role: 'system',
@@ -263,7 +322,6 @@ export const POST: APIRoute = async ({ request }) => {
       })
     });
 
-
     if (!aiResponse.ok) {
       console.error('AI API error:', await aiResponse.text());
       return new Response(JSON.stringify({ error: 'AI service unavailable' }), {
@@ -295,24 +353,48 @@ export const POST: APIRoute = async ({ request }) => {
       });
     }
 
-    // Validate tool names against database
+    // Validate tool names against database based on mode
     const validToolNames = new Set(toolsData.tools.map((t: any) => t.name));
-    const validatedRecommendation = {
-      ...recommendation,
-      recommended_tools: recommendation.recommended_tools?.filter((tool: any) => {
-        if (!validToolNames.has(tool.name)) {
-          console.warn(`AI recommended unknown tool: ${tool.name}`);
-          return false;
-        }
-        return true;
-      }) || []
-    };
+    let validatedRecommendation;
+
+    if (mode === 'workflow') {
+      // Existing validation for workflow mode
+      validatedRecommendation = {
+        ...recommendation,
+        recommended_tools: recommendation.recommended_tools?.filter((tool: any) => {
+          if (!validToolNames.has(tool.name)) {
+            console.warn(`AI recommended unknown tool: ${tool.name}`);
+            return false;
+          }
+          return true;
+        }) || []
+      };
+    } else {
+      // New validation for tool mode
+      validatedRecommendation = {
+        ...recommendation,
+        recommended_tools: recommendation.recommended_tools?.filter((tool: any) => {
+          if (!validToolNames.has(tool.name)) {
+            console.warn(`AI recommended unknown tool: ${tool.name}`);
+            return false;
+          }
+          return true;
+        }).map((tool: any, index: number) => ({
+          ...tool,
+          rank: tool.rank || (index + 1), // Ensure rank is set
+          suitability_score: tool.suitability_score || 'medium', // Default suitability
+          pros: Array.isArray(tool.pros) ? tool.pros : [],
+          cons: Array.isArray(tool.cons) ? tool.cons : []
+        })) || []
+      };
+    }
 
     // Log successful query
-    console.log(`[AI Query] User: ${userId}, Query length: ${sanitizedQuery.length}, Tools: ${validatedRecommendation.recommended_tools.length}`);
+    console.log(`[AI Query] Mode: ${mode}, User: ${userId}, Query length: ${sanitizedQuery.length}, Tools: ${validatedRecommendation.recommended_tools.length}`);
 
     return new Response(JSON.stringify({
       success: true,
+      mode,
       recommendation: validatedRecommendation,
       query: sanitizedQuery
     }), {