Merge branch 'main' into backend-setup

backend/app/api/factcheck_router.py

@@ -0,0 +1,35 @@
+from fastapi import APIRouter, HTTPException
+from app.models.factcheck_schemas import FactCheckRequest, FactCheckResponse, FactCheckSource
+from app.services.factcheck_service import analyze_with_gemini_grounding
+
+router = APIRouter()
+
+@router.post(
+    "/factcheck", 
+    response_model=FactCheckResponse, 
+    tags=["Fact-checking"],
+    summary="Zweryfikuj prawdziwość stwierdzenia"
+)
+async def fact_check_endpoint(payload: FactCheckRequest):
+    statement = payload.statement.strip()
+    if len(statement) < 10:
+        raise HTTPException(status_code=400, detail="Tekst do weryfikacji musi mieć co najmniej 10 znaków.")
+
+    # Wywołujemy usługę integrującą Google Search i Gemini
+    analysis = await analyze_with_gemini_grounding(statement)
+    
+    # Konwersja słowników na obiekty Pydantic
+    formatted_sources = []
+    for s in analysis.get("sources", []):
+        formatted_sources.append(FactCheckSource(
+            title=s["title"],
+            url=s["url"],
+            snippet=s["snippet"]
+        ))
+        
+    return FactCheckResponse(
+        verdict=analysis.get("verdict", "SPORNE"),
+        explanation=analysis.get("explanation", "Brak szczegółowego uzasadnienia."),
+        confidence=analysis.get("confidence", 0.5),
+        sources=formatted_sources
+    )

backend/app/api/routes.py

@@ -224,4 +224,7 @@ async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisRespons
         used_model=used_model,
         content_type=content_type,
         details=analysis_result.get("details"),
-    )
+    )
+
+from app.api.factcheck_router import router as factcheck_router
+router.include_router(factcheck_router) #kupczak tu był 

backend/app/models/factcheck_schemas.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from typing import List
+
+class FactCheckRequest(BaseModel):
+    statement: str
+
+class FactCheckSource(BaseModel):
+    title: str
+    url: str
+    snippet: str
+
+class FactCheckResponse(BaseModel):
+    verdict: str  # "PRAWDA", "FAŁSZ", "SPORNE"
+    explanation: str
+    confidence: float
+    sources: List[FactCheckSource]

backend/app/services/factcheck_service.py

@@ -0,0 +1,155 @@
+import logging
+import json
+import re
+import os
+from pathlib import Path
+from typing import Dict, Any, List
+import google.generativeai as genai
+
+logger = logging.getLogger(__name__)
+
+def load_env_fallback():
+    """
+    Ręcznie wczytuje plik .env do os.environ z pełną diagnostyką w konsoli.
+    """
+    if os.getenv("GEMINI_API_KEY"):
+        return
+
+    possible_paths = [
+        Path(".env"),                                      # Bieżący folder roboczy
+        Path("backend/.env"),                              # Folder backend
+        Path(__file__).resolve().parent.parent.parent / ".env"  # Ścieżka relatywna do serwisu
+    ]
+
+    print(f"\n🔍 [DIAGNOSTYKA .ENV] Bieżący katalog roboczy (CWD): {os.getcwd()}")
+    
+    found_any = False
+    for path_obj in possible_paths:
+        resolved_path = path_obj.resolve()
+        exists = resolved_path.exists()
+        print(f"👉 Sprawdzam ścieżkę: {resolved_path} -> [Znaleziono: {'TAK' if exists else 'NIE'}]")
+        
+        if exists:
+            found_any = True
+            print(f"📖 Próba wczytania pliku: {resolved_path}")
+            try:
+                loaded_keys = []
+                with open(resolved_path, "r", encoding="utf-8") as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith("#") and "=" in line:
+                            key, val = line.split("=", 1)
+                            k_clean = key.strip()
+                            v_clean = val.strip().strip("'\"")
+                            os.environ[k_clean] = v_clean
+                            loaded_keys.append(k_clean)
+                print(f"✅ Pomyślnie wczytano klucze z pliku: {loaded_keys}")
+                break
+            except Exception as e:
+                print(f"❌ Błąd odczytu pliku .env: {e}")
+                
+    if not found_any:
+        print("❌ Nie znaleziono pliku .env w żadnej z badanych lokalizacji!")
+        
+    final_key = os.getenv("GEMINI_API_KEY")
+    print(f"🔑 Status GEMINI_API_KEY: {'ZNAJDZIONO (zaczyna się od: ' + final_key[:6] + '...)' if final_key else 'NIE ZNAJDZIONO!'}\n")
+
+# Uruchamiamy wczytywanie środowiska przy imporcie tego serwisu
+load_env_fallback()
+
+
+async def analyze_with_gemini_grounding(statement: str) -> Dict[str, Any]:
+    """
+    Analizuje stwierdzenie, automatycznie przeszukując internet za pomocą 
+    wbudowanego w Gemini narzędzia Google Search Grounding.
+    """
+    # Upewniamy się, że środowisko jest załadowane
+    load_env_fallback()
+    
+    api_key = os.getenv("GEMINI_API_KEY")
+    
+    if not api_key:
+        logger.error("Brak klucza GEMINI_API_KEY w środowisku systemowym!")
+        return {
+            "verdict": "SPORNE",
+            "explanation": "Błąd backendu: Brak skonfigurowanego klucza GEMINI_API_KEY w pliku .env.",
+            "confidence": 0.0,
+            "sources": []
+        }
+        
+    genai.configure(api_key=api_key)
+    
+    prompt = f"""Jesteś zaawansowanym asystentem do weryfikacji faktów (fact-checking).
+Przeanalizuj poniższe stwierdzenie, korzystając z wyszukiwarki Google (masz do niej dostęp jako narzędzie), aby zweryfikować jego prawdziwość w czasie rzeczywistym.
+
+STWIERDZENIE DO WERYFIKACJI:
+"{statement}"
+
+Twoja odpowiedź musi być wyłącznie poprawnym obiektem JSON (bez bloków kodu typu ```json, bez dodatkowego tekstu na początku ani na końcu). 
+Format JSON:
+{{
+  "verdict": "PRAWDA" lub "FAŁSZ" lub "SPORNE",
+  "explanation": "Zwięzłe (2-4 zdania), merytoryczne i obiektywne uzasadnienie werdyktu w języku polskim, wyjaśniające co mówią fakty."
+}}
+
+Wskazówki do werdyktu:
+- "PRAWDA": Najnowsze fakty i wiarygodne źródła w pełni potwierdzają to stwierdzenie.
+- "FAŁSZ": Fakty jednoznacznie zaprzeczają temu stwierdzeniu.
+- "SPORNE": Informacje w sieci są sprzeczne, jest to kwestia opinii lub brak jednoznacznych dowodów.
+"""
+
+    try:
+        model = genai.GenerativeModel(
+            model_name="gemini-2.5-flash",
+            tools=[
+                genai.protos.Tool(
+                    google_search=genai.protos.Tool.GoogleSearch()
+                )
+            ]
+        )
+        
+        response = model.generate_content(
+            prompt,
+            generation_config=genai.types.GenerationConfig(
+                temperature=0.0
+            )
+        )
+        
+        raw_text = response.text.strip()
+        logger.info(f"Surowa odpowiedź Gemini: {raw_text}")
+        
+        if raw_text.startswith("```"):
+            match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", raw_text, re.DOTALL)
+            if match:
+                raw_text = match.group(1)
+                
+        result_json = json.loads(raw_text)
+        
+        sources = []
+        candidate = response.candidates[0]
+        metadata = getattr(candidate, "grounding_metadata", None)
+        
+        if metadata and getattr(metadata, "grounding_chunks", None):
+            for chunk in metadata.grounding_chunks:
+                if chunk.web:
+                    sources.append({
+                        "title": chunk.web.title,
+                        "url": chunk.web.uri,
+                        "snippet": "Źródło zweryfikowane bezpośrednio przez wyszukiwarkę Google."
+                    })
+                    
+        return {
+            "verdict": result_json.get("verdict", "SPORNE"),
+            "explanation": result_json.get("explanation", "Brak uzasadnienia."),
+            "confidence": 0.95 if result_json.get("verdict") in ["PRAWDA", "FAŁSZ"] else 0.5,
+            "sources": sources
+        }
+        
+    except Exception as e:
+        logger.error(f"Błąd analizy Gemini Grounding API: {e}", exc_info=True)
+        return {
+            "verdict": "SPORNE",
+            "explanation": f"Wystąpił błąd komunikacji z modelem językowym: {str(e)}",
+            "confidence": 0.0,
+            "sources": []
+        }

backend/requirements.txt

@@ -13,4 +13,6 @@ Pillow
 slowapi
 pytest==7.4.3
 pytest-asyncio==0.21.1
-redis
+duckduckgo-search>=6.0.0
+google-generativeai>=0.8.0
+redis

index.js

@@ -1,23 +1,23 @@
 import dotenv from "dotenv";
 dotenv.config();
 
-import { 
-  Client, 
-  GatewayIntentBits, 
-  Events, 
-  ModalBuilder, 
-  TextInputBuilder, 
-  TextInputStyle, 
-  ActionRowBuilder,
-  MessageFlags,
-  ApplicationCommandType,
-  EmbedBuilder,
-  ButtonBuilder,
-  ButtonStyle,
-  PermissionFlagsBits,
-  ChannelSelectMenuBuilder,
-  StringSelectMenuBuilder,
-  ChannelType
+import {
+	Client,
+	GatewayIntentBits,
+	Events,
+	ModalBuilder,
+	TextInputBuilder,
+	TextInputStyle,
+	ActionRowBuilder,
+	MessageFlags,
+	ApplicationCommandType,
+	EmbedBuilder,
+	ButtonBuilder,
+	ButtonStyle,
+	PermissionFlagsBits,
+	ChannelSelectMenuBuilder,
+	StringSelectMenuBuilder,
+	ChannelType,
 } from "discord.js";
 
 const client = new Client({
@@ -40,20 +40,28 @@ client.once(Events.ClientReady, async () => {
 			{
 				name: "detect",
 				description: "Otwiera okienko do wklejenia linku lub tekstu do analizy",
-				type: ApplicationCommandType.ChatInput
+				type: ApplicationCommandType.ChatInput,
 			},
 			{
 				name: "setup",
-				description: "Ustawienia kanału logów i modeli analizy (Wymaga Administratora)",
-				default_member_permissions: PermissionFlagsBits.Administrator.toString(),
-				type: ApplicationCommandType.ChatInput
+				description:
+					"Ustawienia kanału logów i modeli analizy (Wymaga Administratora)",
+				default_member_permissions:
+					PermissionFlagsBits.Administrator.toString(),
+				type: ApplicationCommandType.ChatInput,
 			},
 			{
 				name: "Wykryj deepfake",
-				type: ApplicationCommandType.Message
-			}
+				type: ApplicationCommandType.Message,
+			},
+			{
+				name: "Weryfikacja faktów", // <--- TA LINIA
+				type: ApplicationCommandType.Message,
+			},
 		]);
-		console.log("Pomyślnie zarejestrowano komendy (/detect, /setup oraz menu kontekstowe)");
+		console.log(
+			"Pomyślnie zarejestrowano komendy (/detect, /setup oraz menu kontekstowe)",
+		);
 	} catch (error) {
 		console.error("Błąd podczas rejestracji komend:", error);
 	}
@@ -85,12 +93,15 @@ async function fetchGuildConfig(guildId) {
 				multiModelWorkflow: data.multi_model_workflow || false,
 				models: {
 					text: data.active_text_model || "none",
-					image: data.active_image_model || "none"
-				}
+					image: data.active_image_model || "none",
+				},
 			};
 		}
 	} catch (err) {
-		console.error(`[CONFIG ERROR] Błąd pobierania konfiguracji dla gildii ${guildId}:`, err.message);
+		console.error(
+			`[CONFIG ERROR] Błąd pobierania konfiguracji dla gildii ${guildId}:`,
+			err.message,
+		);
 	}
 	return {
 		logChannelId: null,
@@ -104,37 +115,58 @@ function preparePayload(input, explicitContentType = null) {
 
 	if (explicitContentType) {
 		if (explicitContentType.startsWith("image/")) {
-			return { type: "image", payload: { image_url: trimmed, content_type: "image" } };
+			return {
+				type: "image",
+				payload: { image_url: trimmed, content_type: "image" },
+			};
 		} else if (explicitContentType.startsWith("video/")) {
-			return { type: "video", payload: { video_url: trimmed, content_type: "video" } };
+			return {
+				type: "video",
+				payload: { video_url: trimmed, content_type: "video" },
+			};
 		} else {
-			return { type: "file", payload: { file_url: trimmed, content_type: "file" } };
+			return {
+				type: "file",
+				payload: { file_url: trimmed, content_type: "file" },
+			};
 		}
 	}
 
 	const isUrl = trimmed.startsWith("http://") || trimmed.startsWith("https://");
 
 	if (isUrl) {
-		const cleanUrl = trimmed.toLowerCase().split('?')[0]; 
-		
+		const cleanUrl = trimmed.toLowerCase().split("?")[0];
+
 		if (cleanUrl.match(/\.(png|jpg|jpeg|webp|gif)$/)) {
-			return { type: "image", payload: { image_url: trimmed, content_type: "image" } };
+			return {
+				type: "image",
+				payload: { image_url: trimmed, content_type: "image" },
+			};
 		} else if (cleanUrl.match(/\.(mp4|webm|mov|avi)$/)) {
-			return { type: "video", payload: { video_url: trimmed, content_type: "video" } };
+			return {
+				type: "video",
+				payload: { video_url: trimmed, content_type: "video" },
+			};
 		} else {
-			return { type: "file", payload: { file_url: trimmed, content_type: "file" } };
+			return {
+				type: "file",
+				payload: { file_url: trimmed, content_type: "file" },
+			};
 		}
 	}
 
-	return { 
-		type: "text", 
-		payload: { text: trimmed, content_type: "text" } 
+	return {
+		type: "text",
+		payload: { text: trimmed, content_type: "text" },
 	};
 }
 
 function getProgressBar(confidence, isDeepfake) {
 	const totalBlocks = 10;
-	const filledBlocks = Math.min(totalBlocks, Math.max(0, Math.round(confidence * totalBlocks)));
+	const filledBlocks = Math.min(
+		totalBlocks,
+		Math.max(0, Math.round(confidence * totalBlocks)),
+	);
 	const emptyBlocks = totalBlocks - filledBlocks;
 	const blockEmoji = isDeepfake ? "🟥" : "🟩";
 	return blockEmoji.repeat(filledBlocks) + "⬛".repeat(emptyBlocks);
@@ -143,9 +175,11 @@ function getProgressBar(confidence, isDeepfake) {
 // CAŁKOWICIE DYNAMICZNY GENERATOR WIDOKU SETUPU
 function generateSetupView(tempConfig, availableModels) {
 	const embed = new EmbedBuilder()
-		.setColor(0x5865F2)
+		.setColor(0x5865f2)
 		.setTitle("⚙️ Konfiguracja Systemu Detekcji")
-		.setDescription("Wybierz kanał do wysyłania logów oraz aktywne modele dla poszczególnych formatów danych.")
+		.setDescription(
+			"Wybierz kanał do wysyłania logów oraz aktywne modele dla poszczególnych formatów danych.",
+		)
 		.setTimestamp()
 		.setFooter({ text: "Wybierz opcje i kliknij Zapisz ustawienia" });
 
@@ -165,7 +199,7 @@ function generateSetupView(tempConfig, availableModels) {
 		embed.addFields({
 			name: `⚙️ Model dla formatu: ${contentType.toUpperCase()}`,
 			value: `\`${currentSelected}\``,
-			inline: true
+			inline: true,
 		});
 	}
 
@@ -174,19 +208,17 @@ function generateSetupView(tempConfig, availableModels) {
 		.setPlaceholder("Wybierz kanał dla raportów")
 		.addChannelTypes(ChannelType.GuildText);
 
-	const components = [
-		new ActionRowBuilder().addComponents(channelSelect)
-	];
+	const components = [new ActionRowBuilder().addComponents(channelSelect)];
 
 	for (const [contentType, models] of Object.entries(availableModels)) {
 		if (components.length >= 4) break;
 
 		const currentSelected = tempConfig.models[contentType] || models[0];
 
-		const selectOptions = models.map(model => ({
+		const selectOptions = models.map((model) => ({
 			label: model,
 			value: model,
-			default: currentSelected === model
+			default: currentSelected === model,
 		}));
 
 		const modelSelect = new StringSelectMenuBuilder()
@@ -214,14 +246,14 @@ function generateSetupView(tempConfig, availableModels) {
 			.setCustomId("setup_cancel")
 			.setLabel("Anuluj")
 			.setStyle(ButtonStyle.Danger)
-			.setEmoji("❌")
+			.setEmoji("❌"),
 	);
 
 	components.push(buttonsRow);
 
 	return {
 		embeds: [embed],
-		components: components
+		components: components,
 	};
 }
 
@@ -235,11 +267,89 @@ async function sendLogToDiscord(guild, embedToSend) {
 			await channel.send({ embeds: [embedToSend] });
 		}
 	} catch (err) {
-		console.warn(`Nie można wysłać logu na kanał ${config.logChannelId}:`, err.message);
+		console.warn(
+			`Nie można wysłać logu na kanał ${config.logChannelId}:`,
+			err.message,
+		);
+	}
+}
+
+async function handleFactCheck(interaction, statement) {
+	await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
+
+	try {
+		console.log(`Wysyłanie zapytania do weryfikacji faktów: "${statement.slice(0, 30)}..."`);
+
+		const response = await fetch(`${API_URL}/factcheck`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({ statement: statement }),
+		});
+
+		if (!response.ok) {
+			const errorData = await response.json().catch(() => ({}));
+			throw new Error(errorData.detail || `Błąd API (Status ${response.status})`);
+		}
+
+		const data = await response.json();
+
+		let embedColor = 0xFFAA00; // Żółty domyślnie (SPORNE)
+		let verdictEmoji = "⚖️";
+
+		if (data.verdict === "PRAWDA") {
+			embedColor = 0x00FF00; // Zielony
+			verdictEmoji = "✅";
+		} else if (data.verdict === "FAŁSZ") {
+			embedColor = 0xFF0000; // Czerwony
+			verdictEmoji = "❌";
+		}
+
+		const embed = new EmbedBuilder()
+			.setColor(embedColor)
+			.setTitle(`${verdictEmoji} Wynik Weryfikacji Faktów`)
+			.setDescription(`**Badane stwierdzenie:**\n*"${statement}"*\n\n**Werdykt:** \`${data.verdict}\``)
+			.addFields(
+				{ name: "📝 Analiza merytoryczna", value: data.explanation },
+				{ name: "🎯 Pewność analizy", value: `\`${(data.confidence * 100).toFixed(0)}%\``, inline: true }
+			)
+			.setTimestamp()
+			.setFooter({ text: "System Fact-checkingowy", iconURL: client.user.displayAvatarURL() });
+
+		// Formatowanie źródeł
+		if (data.sources && data.sources.length > 0) {
+			const sourcesText = data.sources
+				.map((src, idx) => `**[${idx + 1}]** [${src.title}](${src.url})\n*${src.snippet.slice(0, 150)}...*`)
+				.join("\n\n");
+
+			// Discord ma limit 1024 znaków na jedno pole w Embedzie, zabezpieczamy się przed jego przekroczeniem
+			const truncatedSources = sourcesText.length > 1024 ? sourcesText.slice(0, 1000) + "..." : sourcesText;
+
+			embed.addFields({ name: "🔗 Wykorzystane źródła internetowe", value: truncatedSources });
+		} else {
+			embed.addFields({ name: "🔗 Wykorzystane źródła internetowe", value: "Brak bezpośrednich źródeł." });
+		}
+
+		await interaction.editReply({
+			embeds: [embed]
+		});
+
+	} catch (error) {
+		console.error("Błąd podczas weryfikacji faktów:", error);
+		await interaction.editReply({
+			content: `❌ Nie udało się przeprowadzić weryfikacji faktów.\n\n**Szczegóły błędu:**\n${error.message}`,
+		});
 	}
 }
 
-async function handleAnalysis(interaction, userContent, targetMessage = null, explicitContentType = null) {
+
+async function handleAnalysis(
+	interaction,
+	userContent,
+	targetMessage = null,
+	explicitContentType = null,
+) {
 	await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
 
 	try {
@@ -247,7 +357,9 @@ async function handleAnalysis(interaction, userContent, targetMessage = null, ex
 		payload.guild_id = interaction.guildId;
 		payload.user_id = interaction.user.id;
 
-		console.log(`Wysyłanie zapytania typu: ${type} do API z modelem: ${payload.model || "domyślny"}...`);
+		console.log(
+			`Wysyłanie zapytania typu: ${type} do API z modelem: ${payload.model || "domyślny"}...`,
+		);
 
 		const response = await fetch(`${API_URL}/analyze`, {
 			method: "POST",
@@ -259,13 +371,16 @@ async function handleAnalysis(interaction, userContent, targetMessage = null, ex
 
 		if (!response.ok) {
 			const errorData = await response.json().catch(() => ({}));
-			console.error("Szczegóły błędu z FastAPI:", JSON.stringify(errorData, null, 2));
-			
+			console.error(
+				"Szczegóły błędu z FastAPI:",
+				JSON.stringify(errorData, null, 2),
+			);
+
 			let errorMsg = `Błąd serwera API (Status ${response.status})`;
 			if (errorData.detail) {
 				if (Array.isArray(errorData.detail)) {
 					errorMsg = errorData.detail
-						.map(err => `• Pole \`${err.loc.join(".")}\`: ${err.msg}`)
+						.map((err) => `• Pole \`${err.loc.join(".")}\`: ${err.msg}`)
 						.join("\n");
 				} else {
 					errorMsg = errorData.detail;
@@ -279,12 +394,15 @@ async function handleAnalysis(interaction, userContent, targetMessage = null, ex
 		if (targetMessage) {
 			try {
 				if (data.is_deepfake) {
-					await targetMessage.react('⚠️');
+					await targetMessage.react("⚠️");
 				} else {
-					await targetMessage.react('✅');
+					await targetMessage.react("✅");
 				}
 			} catch (reactError) {
-				console.warn("Nie udało się dodać reakcji do wiadomości:", reactError.message);
+				console.warn(
+					"Nie udało się dodać reakcji do wiadomości:",
+					reactError.message,
+				);
 			}
 		}
 
@@ -296,8 +414,28 @@ async function handleAnalysis(interaction, userContent, targetMessage = null, ex
 			.setColor(embedColor)
 			.setTitle("🛡️ Wynik Analizy Treści")
 			.setDescription(`**Werdykt:** ${verdictText}`)
+			.addFields(
+				{
+					name: "Pewność modelu",
+					value: `\`${confidencePercent}%\` \n${progressBar}`,
+				},
+				{
+					name: "Czas przetwarzania",
+					value: `\`${data.analysis_time.toFixed(3)}s\``,
+					inline: true,
+				},
+				{ name: "Użyty model", value: `\`${data.used_model}\``, inline: true },
+				{
+					name: "Format danych",
+					value: `\`${data.content_type.toUpperCase()}\``,
+					inline: true,
+				},
+			)
 			.setTimestamp()
-			.setFooter({ text: "Deepfake Detection Service", iconURL: client.user.displayAvatarURL() });
+			.setFooter({
+				text: "Deepfake Detection Service",
+				iconURL: client.user.displayAvatarURL(),
+			});
 
 		// DYNAMICZNE RENDEROWANIE EMBEDA: Multi-Model vs Single-Model
 		if (data.details && data.details.length > 0) {
@@ -340,14 +478,13 @@ async function handleAnalysis(interaction, userContent, targetMessage = null, ex
 				.setCustomId("reportError")
 				.setLabel("Zgłoś błąd analizy")
 				.setStyle(ButtonStyle.Danger)
-				.setEmoji("⚠️")
+				.setEmoji("⚠️"),
 		);
 
 		await interaction.editReply({
 			embeds: [embed],
-			components: [buttonRow]
+			components: [buttonRow],
 		});
-
 	} catch (error) {
 		console.error("Błąd podczas analizy:", error);
 		await interaction.editReply({
@@ -356,8 +493,9 @@ async function handleAnalysis(interaction, userContent, targetMessage = null, ex
 	}
 }
 
+//funkcja kupczaka
+
 client.on(Events.InteractionCreate, async (interaction) => {
-	
 	if (interaction.isChatInputCommand()) {
 		if (interaction.commandName === "detect") {
 			const modal = new ModalBuilder()
@@ -379,7 +517,7 @@ client.on(Events.InteractionCreate, async (interaction) => {
 
 		if (interaction.commandName === "setup") {
 			const guildId = interaction.guildId;
-            
+
 			await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
 
 			// Pobieramy konfigurację bezpośrednio z FastAPI
@@ -388,7 +526,8 @@ client.on(Events.InteractionCreate, async (interaction) => {
 
 			if (!availableModels || Object.keys(availableModels).length === 0) {
 				return interaction.editReply({
-					content: "❌ **Błąd konfiguracji:** Nie udało się nawiązać połączenia z backendem (FastAPI). Uruchom swój backend w Pythonie i spróbuj ponownie!"
+					content:
+						"❌ **Błąd konfiguracji:** Nie udało się nawiązać połączenia z backendem (FastAPI). Uruchom swój backend w Pythonie i spróbuj ponownie!",
 				});
 			}
 
@@ -402,9 +541,9 @@ client.on(Events.InteractionCreate, async (interaction) => {
 				}
 			}
 
-			activeSetupSessions.set(guildId, { 
-				config: { ...currentConfig }, 
-				availableModels 
+			activeSetupSessions.set(guildId, {
+				config: { ...currentConfig },
+				availableModels,
 			});
 
 			const setupView = generateSetupView(currentConfig, availableModels);
@@ -418,7 +557,9 @@ client.on(Events.InteractionCreate, async (interaction) => {
 			const tempSession = activeSetupSessions.get(guildId);
 			if (tempSession) {
 				tempSession.config.logChannelId = interaction.values[0];
-				await interaction.update(generateSetupView(tempSession.config, tempSession.availableModels));
+				await interaction.update(
+					generateSetupView(tempSession.config, tempSession.availableModels),
+				);
 			}
 		}
 	}
@@ -427,13 +568,15 @@ client.on(Events.InteractionCreate, async (interaction) => {
 	if (interaction.isStringSelectMenu()) {
 		const guildId = interaction.guildId;
 		const tempSession = activeSetupSessions.get(guildId);
-		
+
 		if (tempSession) {
 			// Sprawdzamy czy zmieniany jest model (szukamy przedrostka setup_model_)
 			if (interaction.customId.startsWith("setup_model_")) {
 				const contentType = interaction.customId.replace("setup_model_", "");
 				tempSession.config.models[contentType] = interaction.values[0];
-				await interaction.update(generateSetupView(tempSession.config, tempSession.availableModels));
+				await interaction.update(
+					generateSetupView(tempSession.config, tempSession.availableModels),
+				);
 			}
 		}
 	}
@@ -441,12 +584,12 @@ client.on(Events.InteractionCreate, async (interaction) => {
 	if (interaction.isMessageContextMenuCommand()) {
 		if (interaction.commandName === "Wykryj deepfake") {
 			const targetMessage = interaction.targetMessage;
-			
+
 			let contentToAnalyze = targetMessage.content;
 			let explicitContentType = null;
 
 			const attachment = targetMessage.attachments.first();
-			
+
 			if (attachment) {
 				contentToAnalyze = attachment.url;
 				explicitContentType = attachment.contentType;
@@ -454,14 +597,35 @@ client.on(Events.InteractionCreate, async (interaction) => {
 
 			if (!contentToAnalyze || contentToAnalyze.trim().length === 0) {
 				return interaction.reply({
-					content: "❌ Ta wiadomość nie zawiera tekstu ani załączników do analizy.",
-					flags: [MessageFlags.Ephemeral]
+					content:
+						"❌ Ta wiadomość nie zawiera tekstu ani załączników do analizy.",
+					flags: [MessageFlags.Ephemeral],
 				});
 			}
 
-			await handleAnalysis(interaction, contentToAnalyze, targetMessage, explicitContentType);
+			await handleAnalysis(
+				interaction,
+				contentToAnalyze,
+				targetMessage,
+				explicitContentType,
+			);
+		}
+		if (interaction.commandName === "Weryfikacja faktów") {
+			const targetMessage = interaction.targetMessage;
+			const contentToVerify = targetMessage.content;
+
+			if (!contentToVerify || contentToVerify.trim().length < 10) {
+				return interaction.reply({
+					content:
+						"❌ Wiadomość musi mieć przynajmniej 10 znaków tekstu, aby można było ją zweryfikować.",
+					flags: [MessageFlags.Ephemeral],
+				});
+			}
+
+			await handleFactCheck(interaction, contentToVerify);
 		}
 	}
+	//koniec funkcji kupczaka
 
 	if (interaction.isModalSubmit()) {
 		if (interaction.customId === "detectModal") {
@@ -480,7 +644,7 @@ client.on(Events.InteractionCreate, async (interaction) => {
 					const response = await fetch(`${API_URL}/guilds/${guildId}/setup`, {
 						method: "POST",
 						headers: {
-							"Content-Type": "application/json"
+							"Content-Type": "application/json",
 						},
 						body: JSON.stringify({
 							active_text_model: tempSession.config.models?.text || "none",
@@ -497,16 +661,17 @@ client.on(Events.InteractionCreate, async (interaction) => {
 
 					activeSetupSessions.delete(guildId);
 					await interaction.update({
-						content: "✅ **Ustawienia zostały pomyślnie zapisane na backendzie!**",
+						content:
+							"✅ **Ustawienia zostały pomyślnie zapisane na backendzie!**",
 						embeds: [],
-						components: []
+						components: [],
 					});
 				} catch (error) {
 					console.error("[SETUP ERROR]", error);
 					await interaction.update({
 						content: `❌ **Wystąpił błąd podczas zapisywania konfiguracji:** ${error.message}`,
 						embeds: [],
-						components: []
+						components: [],
 					});
 				}
 			}
@@ -517,7 +682,7 @@ client.on(Events.InteractionCreate, async (interaction) => {
 			await interaction.update({
 				content: "❌ **Konfiguracja została anulowana.**",
 				embeds: [],
-				components: []
+				components: [],
 			});
 		}
 
@@ -534,30 +699,35 @@ client.on(Events.InteractionCreate, async (interaction) => {
 					.setLabel("Zgłoś błąd analizy")
 					.setStyle(ButtonStyle.Danger)
 					.setEmoji("⚠️")
-					.setDisabled(true)
+					.setDisabled(true),
 			);
 
 			// 2 UPDATE BUTTONS
 			await interaction.update({
-				embeds: [interaction.message.embeds[0]], 
-				components: [disabledRow]
+				embeds: [interaction.message.embeds[0]],
+				components: [disabledRow],
 			});
 
 			// 3 CONFIRMATION
 			await interaction.followUp({
-				content: "✅ **Dziękujemy!** Twoje zgłoszenie błędu zostało zarejestrowane.",
-				flags: [MessageFlags.Ephemeral]
+				content:
+					"✅ **Dziękujemy!** Twoje zgłoszenie błędu zostało zarejestrowane.",
+				flags: [MessageFlags.Ephemeral],
 			});
 
-			console.log(`[RAPORT BŁĘDU] Użytkownik ${interaction.user.tag} (ID: ${interaction.user.id}) zgłosił błąd klasyfikacji.`);
+			console.log(
+				`[RAPORT BŁĘDU] Użytkownik ${interaction.user.tag} (ID: ${interaction.user.id}) zgłosił błąd klasyfikacji.`,
+			);
 
 			const originalEmbed = interaction.message.embeds[0];
 			if (originalEmbed) {
 				const logEmbed = EmbedBuilder.from(originalEmbed)
-					.setColor(0xFFAA00)
+					.setColor(0xffaa00)
 					.setTitle("⚠️ Zgłoszenie błędu analizy")
-					.setDescription(`Użytkownik **${interaction.user.tag}** (ID: \`${interaction.user.id}\`) zgłosił błąd analizy w poniższym raporcie.`);
-				
+					.setDescription(
+						`Użytkownik **${interaction.user.tag}** (ID: \`${interaction.user.id}\`) zgłosił błąd analizy w poniższym raporcie.`,
+					);
+
 				await sendLogToDiscord(interaction.guild, logEmbed);
 			}
 		}
@@ -576,30 +746,35 @@ client.on(Events.InteractionCreate, async (interaction) => {
 					.setLabel("Zgłoś błąd analizy")
 					.setStyle(ButtonStyle.Danger)
 					.setEmoji("⚠️")
-					.setDisabled(true)
+					.setDisabled(true),
 			);
 
 			// 2 DISABLE BUTTONS
 			await interaction.update({
-				embeds: [interaction.message.embeds[0]], 
-				components: [disabledRow]
+				embeds: [interaction.message.embeds[0]],
+				components: [disabledRow],
 			});
 
 			// 3 CONFIRMATION
 			await interaction.followUp({
-				content: "✅ **Dziękujemy!** Twoje potwierdzenie zostało pomyślnie zapisane.",
-				flags: [MessageFlags.Ephemeral]
+				content:
+					"✅ **Dziękujemy!** Twoje potwierdzenie zostało pomyślnie zapisane.",
+				flags: [MessageFlags.Ephemeral],
 			});
 
-			console.log(`[POTWIERDZENIE] Użytkownik ${interaction.user.tag} (ID: ${interaction.user.id}) potwierdził poprawną klasyfikację.`);
+			console.log(
+				`[POTWIERDZENIE] Użytkownik ${interaction.user.tag} (ID: ${interaction.user.id}) potwierdził poprawną klasyfikację.`,
+			);
 
 			const originalEmbed = interaction.message.embeds[0];
 			if (originalEmbed) {
 				const logEmbed = EmbedBuilder.from(originalEmbed)
-					.setColor(0x00AAFF)
+					.setColor(0x00aaff)
 					.setTitle("✅ Potwierdzona poprawność analizy")
-					.setDescription(`Użytkownik **${interaction.user.tag}** (ID: \`${interaction.user.id}\`) potwierdził poprawność raportu.`);
-				
+					.setDescription(
+						`Użytkownik **${interaction.user.tag}** (ID: \`${interaction.user.id}\`) potwierdził poprawność raportu.`,
+					);
+
 				await sendLogToDiscord(interaction.guild, logEmbed);
 			}
 		}
@@ -619,4 +794,4 @@ client.on(Events.MessageCreate, (message) => {
 	console.log(`Message from ${message.author.tag}: ${message.content}`);
 });
 
-client.login(process.env.DISCORD_TOKEN);
+client.login(process.env.DISCORD_TOKEN);