first commit

.vscode/launch.json

@@ -0,0 +1,12 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "TruthCheck Gradio",
+            "type": "python",
+            "request": "launch",
+            "program": "run.py",
+            "console": "integratedTerminal"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "python.defaultInterpreterPath": "./venv/bin/python",
+    "python.terminal.activateEnvironment": true,
+    "files.exclude": {
+        "**/__pycache__": true,
+        "**/*.pyc": true
+    }
+}

README.md

@@ -1,2 +1,2 @@
-# truth-check
-
+# TruthCheck-App
+An intelligent fact-checking tool would not only help users verify the accuracy of digital content instantly but also foster greater transparency and accountability in online communication..

app.py

@@ -0,0 +1,143 @@
+# app.py - Main Flask application
+
+from flask import Flask, render_template, request, jsonify
+import os
+import threading 
+import time 
+
+# Import all necessary components from your models and utils directories
+from models.claim_extractor import ClaimExtractor
+from models.keyword_extractor import KeywordExtractor
+from models.evidence_retriever import EvidenceRetriever
+from models.nli_classifier import NLIClassifier
+from utils.similarity import calculate_similarity 
+from utils.config import Config 
+
+# Initialize models globally or within a singleton pattern for efficiency
+claim_extractor = ClaimExtractor()
+keyword_extractor = KeywordExtractor()
+evidence_retriever = EvidenceRetriever()
+nli_classifier = NLIClassifier()
+
+class TruthCheckSystem:
+    def __init__(self): 
+        self.claim_extractor = claim_extractor
+        self.keyword_extractor = keyword_extractor
+        self.evidence_retriever = evidence_retriever
+        self.nli_classifier = nli_classifier
+    
+    def verify_claim(self, text):
+        """
+        Main function to verify a factual claim.
+        Processes the claim through extraction, evidence retrieval, and NLI.
+        """
+        try:
+            # Step 1: Extract claims from the input text
+            claims = self.claim_extractor.extract_claims(text)
+            if not claims:
+                return "No valid claims found", 0.0, "Please provide a clear factual statement."
+            
+            claim = claims[0]
+            
+            # Step 2: Extract keywords from the claim
+            keywords = self.keyword_extractor.extract_keywords(claim)
+            
+            # Step 3: Retrieve evidence from external sources (Wikipedia, Google News, Academic, Gov, Fact-Check)
+            evidence_items = self.evidence_retriever.get_evidence(keywords)
+            
+            if not evidence_items:
+                return "Low Confidence", 0.3, "Not enough reliable evidence found from external sources."
+            
+            # Step 4: Check semantic similarity between the claim and retrieved evidence
+            relevant_evidence = []
+            for item in evidence_items:
+                similarity = calculate_similarity(claim, item['content'])
+                if similarity > Config.SIMILARITY_THRESHOLD: 
+                    relevant_evidence.append(item)
+            
+            if not relevant_evidence:
+                return "Low Confidence", 0.4, "No semantically relevant evidence found after similarity check."
+            
+            # --- NEW: Sort relevant evidence by credibility score before NLI ---
+            # We want to prioritize the most credible relevant evidence for classification
+            relevant_evidence.sort(key=lambda x: x.get('credibility_score', 0.0), reverse=True)
+            primary_evidence = relevant_evidence[0] # The most credible relevant piece of evidence
+            # --- END NEW ---
+
+            # Step 5: Perform Natural Language Inference (NLI)
+            nli_result = self.nli_classifier.classify(claim, primary_evidence['content'])
+            
+            # Step 6: Format the result based on NLI classification and adjust confidence by credibility
+            label = "Low Confidence" 
+            nli_confidence = nli_result['confidence'] 
+            
+            # --- NEW: Factor in source credibility to the final confidence score ---
+            # Weight the NLI confidence (e.g., 70%) and the source credibility (e.g., 30%)
+            source_credibility_weight = primary_evidence.get('credibility_score', 0.5) # Default to 0.5 if somehow missing
+            final_confidence = (nli_confidence * 0.7) + (source_credibility_weight * 0.3)
+            final_confidence = min(max(final_confidence, 0.0), 1.0) # Ensure it stays within 0-1
+            # --- END NEW ---
+
+            if nli_result['label'] == 'ENTAILMENT':
+                label = "True"
+            elif nli_result['label'] == 'CONTRADICTION':
+                label = "False"
+            else:
+                label = "Low Confidence"
+                # If NLI is neutral, the credibility helps fine-tune, but still indicates low confidence
+                final_confidence = max(final_confidence, 0.3) # Ensure neutral isn't too high from credibility alone
+
+
+            evidence_snippet = primary_evidence['content']
+            if len(evidence_snippet) > 500:
+                evidence_snippet = evidence_snippet[:500] + "..."
+            
+            source = f"Source: {primary_evidence['source']} (Credibility: {source_credibility_weight:.2f})" # NEW: Show credibility
+            
+            return label, final_confidence, f"{evidence_snippet}\n\n{source}"
+            
+        except Exception as e:
+            print(f"An error occurred during claim verification: {e}")
+            return "Error", 0.0, f"An internal error occurred: {str(e)}. Please try again."
+
+# Initialize TruthCheck system globally once when the app starts
+truthcheck_system_instance = TruthCheckSystem()
+
+def create_app():
+    app = Flask(__name__, static_folder='static', template_folder='templates')
+    app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', Config.SECRET_KEY)
+    app.config['DEBUG'] = Config.DEBUG 
+
+    @app.route('/')
+    def index():
+        return render_template('index.html')
+    
+    @app.route('/api/verify', methods=['POST'])
+    def verify_claim_api():
+        try:
+            data = request.get_json()
+            claim_text = data.get('claim', '')
+            
+            if not claim_text:
+                return jsonify({'error': 'No claim provided'}), 400
+            
+            label, confidence, evidence = truthcheck_system_instance.verify_claim(claim_text)
+            
+            result = {
+                'label': label,
+                'confidence': round(confidence, 3), 
+                'evidence': evidence,
+                'claim': claim_text
+            }
+            
+            return jsonify(result) 
+            
+        except Exception as e:
+            print(f"API error: {e}")
+            return jsonify({'error': f'An error occurred on the server: {str(e)}'}), 500
+    
+    @app.route('/health')
+    def health_check():
+        return jsonify({'status': 'healthy', 'message': 'TruthCheck backend is running.'})
+    
+    return app

curl.exe

@@ -0,0 +1,3 @@
+curl.exe -X POST http://127.0.0.1:5000/api/verify `
+  -H "Content-Type: application/json" `
+  -d "{\"claim\": \"The sun is a star.\"}"

google_search.py

@@ -0,0 +1,26 @@
+# google_search.py
+
+class SearchResult:
+    def __init__(self, snippet, url, source_title=None):
+        self.snippet = snippet
+        self.url = url
+        self.source_title = source_title
+
+class SearchResponse:
+    def __init__(self, results):
+        self.results = results
+
+def search(queries, num_results=3):
+    """Mock search function returning dummy data for testing."""
+    responses = []
+    for query in queries:
+        dummy_results = [
+            SearchResult(
+                snippet=f"This is a mock snippet for query '{query}' - result {i+1}.",
+                url=f"https://example.com/{query.replace(' ', '_')}/{i}",
+                source_title="Mock News Source"
+            )
+            for i in range(num_results)
+        ]
+        responses.append(SearchResponse(results=dummy_results))
+    return responses

models/__init__.py

@@ -0,0 +1,4 @@
+"""
+TruthCheck Models Package
+Contains all the NLP and ML models for fact-checking
+"""

models/claim_extractor.py

@@ -0,0 +1,34 @@
+# models/claim_extractor.py
+import re
+import spacy
+
+class ClaimExtractor:
+    def __init__(self): # Corrected __init__
+        try:
+            self.nlp = spacy.load("en_core_web_sm")
+        except OSError:
+            print("Please install spaCy English model: python -m spacy download en_core_web_sm")
+            raise
+    
+    def extract_claims(self, text):
+        """Extract factual claims from text"""
+        if not text or len(text.strip()) < 10:
+            return []
+        
+        # Use spaCy for sentence segmentation
+        doc = self.nlp(text)
+        claims = []
+        
+        for sent in doc.sents:
+            sentence = sent.text.strip()
+            
+            # Filter out questions, commands, and short sentences
+            if (len(sentence.split()) > 5 and 
+                not sentence.endswith('?') and 
+                not sentence.startswith(('How', 'What', 'When', 'Where', 'Why', 'Who')) and
+                not re.match(r'^(Please|Let|Can you)', sentence, re.IGNORECASE)):
+                
+                claims.append(sentence)
+        
+        return claims if claims else [text.strip()]
+

models/evidence_retriever.py

@@ -0,0 +1,102 @@
+# models/evidence_retriever.py
+import wikipedia
+import requests
+import time
+
+# Import the google_search tool for real-time news simulation
+from google_search import search as google_search_tool
+
+class EvidenceRetriever:
+    def __init__(self):
+        self.wikipedia_timeout = 10
+        self.news_timeout = 10 # This timeout is less relevant now but kept for consistency
+        
+    def get_evidence(self, keywords):
+        """Retrieve evidence from multiple sources"""
+        evidence = []
+        
+        # Get evidence from Wikipedia
+        wiki_evidence = self._get_wikipedia_evidence(keywords)
+        evidence.extend(wiki_evidence)
+        
+        # Get evidence from a simulated "real-time" news search
+        # This replaces the unreliable Google News RSS feed approach
+        realtime_news_evidence = self._get_realtime_news_evidence(keywords)
+        evidence.extend(realtime_news_evidence)
+        
+        return evidence
+    
+    def _get_wikipedia_evidence(self, keywords):
+        """Retrieve evidence from Wikipedia"""
+        evidence = []
+        
+        try:
+            # Increased search results from 3 to 5
+            search_terms = ' '.join(keywords[:3])
+            search_results = wikipedia.search(search_terms, results=5) # Increased results
+            
+            for title in search_results:
+                try:
+                    # Increased summary sentences from 3 to 5
+                    summary = wikipedia.summary(title, sentences=5, auto_suggest=False) # Increased sentences
+                    
+                    evidence.append({
+                        'content': summary,
+                        'source': f'Wikipedia - {title}',
+                        'url': f'https://en.wikipedia.org/wiki/{title.replace(" ", "_")}'
+                    })
+                    
+                    # Allow more Wikipedia sources (e.g., up to 3 instead of 2)
+                    if len(evidence) >= 3: # Increased limit
+                        break
+                        
+                except (wikipedia.DisambiguationError, wikipedia.PageError):
+                    print(f"Wikipedia disambiguation/page error for '{title}'. Skipping.")
+                    continue
+                    
+        except Exception as e:
+            print(f"Wikipedia search error: {e}")
+        
+        return evidence
+    
+    def _get_realtime_news_evidence(self, keywords):
+        """
+        Simulates real-time news retrieval using the google_search tool.
+        This focuses on finding recent and breaking news snippets.
+        """
+        evidence = []
+        
+        try:
+            # Create a search query emphasizing recency and news context
+            # Adding terms like "breaking news" or "latest update" helps bias results
+            query_phrases = [
+                f"{' '.join(keywords)} breaking news",
+                f"{' '.join(keywords)} latest update",
+                f"{' '.join(keywords)} recent news article"
+            ]
+
+            # Perform multiple searches for broader coverage
+            all_search_results = []
+            for q_phrase in query_phrases:
+                # The google_search tool provides recent results by default for news queries
+                search_results_for_phrase = google_search_tool(queries=[q_phrase])
+                if search_results_for_phrase and search_results_for_phrase[0].results:
+                    all_search_results.extend(search_results_for_phrase[0].results)
+            
+            # Filter and add unique relevant snippets
+            added_urls = set()
+            for result in all_search_results:
+                if result.snippet and result.url and result.url not in added_urls:
+                    evidence.append({
+                        'content': result.snippet,
+                        'source': f'Real-time Web News - {result.source_title or "Unknown"}',
+                        'url': result.url
+                    })
+                    added_urls.add(result.url)
+                    if len(evidence) >= 5: # Limit total real-time news snippets
+                        break
+        except Exception as e:
+            print(f"Real-time news search error: {e}")
+            
+        return evidence
+

models/keyword_extractor.py

@@ -0,0 +1,40 @@
+# models/keyword_extractor.py
+import spacy
+from collections import Counter
+
+class KeywordExtractor:
+    def __init__(self): # Corrected __init__
+        try:
+            self.nlp = spacy.load("en_core_web_sm")
+        except OSError:
+            print("Please install spaCy English model: python -m spacy download en_core_web_sm")
+            raise
+    
+    def extract_keywords(self, text):
+        """Extract keywords and named entities from text"""
+        doc = self.nlp(text)
+        
+        keywords = []
+        
+        # Extract named entities
+        for ent in doc.ents:
+            if ent.label_ in ['PERSON', 'ORG', 'GPE', 'PRODUCT', 'EVENT', 'DATE']:
+                keywords.append(ent.text)
+        
+        # Extract noun phrases and important words
+        for chunk in doc.noun_chunks:
+            if len(chunk.text.split()) <= 3:  # Avoid very long phrases
+                keywords.append(chunk.text)
+        
+        # Extract individual important words
+        for token in doc:
+            if (token.pos_ in ['NOUN', 'PROPN'] and 
+                not token.is_stop and 
+                not token.is_punct and 
+                len(token.text) > 2):
+                keywords.append(token.text)
+        
+        # Remove duplicates and return most common
+        keyword_counts = Counter(keywords)
+        return [word for word, count in keyword_counts.most_common(10)]
+

models/nli_classifier.py

@@ -0,0 +1,93 @@
+# models/nli_classifier.py
+from transformers import pipeline
+import torch
+
+class NLIClassifier:
+    def __init__(self): # Corrected __init__
+        """Initialize the Natural Language Inference classifier"""
+        try:
+            # Use RoBERTa-large-MNLI for NLI
+            self.classifier = pipeline(
+                "zero-shot-classification",
+                model="facebook/bart-large-mnli",
+                device=0 if torch.cuda.is_available() else -1
+            )
+            
+            # Alternative: Direct NLI pipeline
+            self.nli_pipeline = pipeline(
+                "text-classification",
+                model="roberta-large-mnli",
+                device=0 if torch.cuda.is_available() else -1
+            )
+            
+        except Exception as e:
+            print(f"Error loading NLI model: {e}")
+            # Fallback to a smaller model or a dummy pipeline if the main one fails
+            # For a realistic app, consider a more robust fallback or error handling.
+            # For now, let's use a simpler, more generally available model if roberta-large-mnli fails.
+            # Note: DialoGPT is not an NLI model, it's a conversational model.
+            # A better fallback would be to indicate failure or use a simpler NLI model if available.
+            # For demonstration, we'll keep the direct NLI pipeline and let it fail if models aren't found.
+            # If this becomes an issue, we might need to adjust the requirements or provide more specific fallback.
+            print("Attempting to load a smaller NLI model if roberta-large-mnli fails...")
+            try:
+                self.nli_pipeline = pipeline(
+                    "text-classification",
+                    model="distilbert-base-uncased-mnli", # A smaller NLI model
+                    device=0 if torch.cuda.is_available() else -1
+                )
+            except Exception as fallback_e:
+                print(f"Error loading fallback NLI model: {fallback_e}")
+                # If even fallback fails, set pipeline to None and handle in classify method
+                self.nli_pipeline = None
+
+
+    def classify(self, claim, evidence):
+        """Classify relationship between claim and evidence"""
+        if not self.nli_pipeline:
+            print("NLI pipeline not initialized. Returning neutral with low confidence.")
+            return {
+                'label': 'NEUTRAL',
+                'confidence': 0.5
+            }
+
+        try:
+            # Format for NLI: premise (evidence) and hypothesis (claim)
+            premise = evidence
+            hypothesis = claim
+            
+            # Use the NLI pipeline
+            # For NLI models, the input typically concatenates premise and hypothesis
+            # with a special token, like " [SEP] ".
+            # The pipeline itself often handles this, but explicitly formatting can help.
+            result = self.nli_pipeline(f"{premise} [SEP] {hypothesis}")
+            
+            # Map labels to our format
+            label_mapping = {
+                'ENTAILMENT': 'ENTAILMENT',
+                'CONTRADICTION': 'CONTRADICTION',
+                'NEUTRAL': 'NEUTRAL',
+                'entailment': 'ENTAILMENT',
+                'contradiction': 'CONTRADICTION',
+                'neutral': 'NEUTRAL'
+            }
+            
+            if isinstance(result, list):
+                result = result[0] # The pipeline returns a list, take the first result
+            
+            mapped_label = label_mapping.get(result['label'], 'NEUTRAL')
+            confidence = result['score']
+            
+            return {
+                'label': mapped_label,
+                'confidence': confidence
+            }
+            
+        except Exception as e:
+            print(f"NLI classification error: {e}")
+            # Return neutral with low confidence as fallback
+            return {
+                'label': 'NEUTRAL',
+                'confidence': 0.5
+            }
+

requirements.txt

@@ -0,0 +1,11 @@
+Flask
+spacy
+wikipedia
+requests
+transformers
+torch
+sentence-transformers
+scikit-learn
+numpy
+# feedparser              # Removed
+# beautifulsoup4          # Removed

run.py

@@ -0,0 +1,17 @@
+# run.py - Entry point to start the application
+
+# Import the create_app function from your app.py
+from app import create_app
+
+# Create the Flask application instance
+app = create_app()
+
+if __name__ == "__main__":
+    print("🚀 Starting TruthCheck System...")
+    print("📊 Flask Backend: http://127.0.0.1:5000") # Updated to 127.0.0.1 for local access
+
+    # Run the Flask application
+    # debug=True enables reloader and debugger, useful during development
+    # host='0.0.0.0' makes the server accessible from other devices on the network
+    # port=5000 is the default Flask port
+    app.run(debug=True, host='0.0.0.0', port=5000)

static/css/style.css

@@ -0,0 +1,64 @@
+/* static/css/style.css - Global and Custom Styles for TruthCheck */
+
+/* Custom font import - Inter is a great modern choice for clean UIs */
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap');
+
+/* Define the custom font family for Tailwind's usage */
+@layer base {
+  body {
+    font-family: 'Inter', sans-serif;
+  }
+}
+
+/* Custom scrollbar for a cleaner, modern look */
+::-webkit-scrollbar {
+    width: 8px; /* Width of the scrollbar */
+}
+
+::-webkit-scrollbar-track {
+    background: #e0e0e0; /* Color of the tracking area */
+    border-radius: 10px; /* Rounded corners for the track */
+}
+
+::-webkit-scrollbar-thumb {
+    background: #a0a0a0; /* Color of the scroll thumb */
+    border-radius: 10px; /* Rounded corners for the thumb */
+    border: 2px solid #e0e0e0; /* Creates a small border around the thumb */
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #888; /* Color of the thumb on hover */
+}
+
+/* Blob animation for background elements */
+@keyframes blob {
+    0% {
+        transform: translate(0, 0) scale(1);
+    }
+    33% {
+        transform: translate(30px, -50px) scale(1.1);
+    }
+    66% {
+        transform: translate(-20px, 20px) scale(0.9);
+    }
+    100% {
+        transform: translate(0, 0) scale(1);
+    }
+}
+
+.animate-blob {
+    animation: blob 7s infinite cubic-bezier(0.68, -0.55, 0.27, 1.55);
+}
+
+/* Delay for blob animation */
+.animation-delay-2000 {
+    animation-delay: 2s;
+}
+.animation-delay-4000 {
+    animation-delay: 4s;
+}
+
+/* Styles for example tags */
+.example-tag {
+    @apply inline-block bg-blue-100 text-blue-700 rounded-full px-3 py-1 text-sm cursor-pointer transition-all duration-200 ease-in-out hover:bg-blue-200 hover:text-blue-800 hover:shadow-sm active:scale-95;
+}

static/js/main.js

@@ -0,0 +1,141 @@
+// static/js/main.js - Frontend logic for TruthCheck
+
+document.addEventListener('DOMContentLoaded', () => {
+    // Get references to DOM elements
+    const claimInput = document.getElementById('claimInput');
+    const verifyButton = document.getElementById('verifyButton');
+    const buttonText = document.getElementById('buttonText');
+    const loadingSpinner = document.getElementById('loadingSpinner');
+    const resultContainer = document.getElementById('resultContainer');
+    const resultContent = document.getElementById('resultContent');
+    const userIdDisplay = document.getElementById('userIdDisplay');
+    const exampleTags = document.querySelectorAll('.example-tag'); // Get all example tags
+
+    // Set a placeholder user ID (in a real app, this would come from authentication)
+    userIdDisplay.textContent = 'Guest (Not authenticated)'; // Or generate a random one: `crypto.randomUUID()`
+
+    // Add event listener to the Verify button
+    verifyButton.addEventListener('click', async () => {
+        const claimText = claimInput.value.trim(); // Get text and remove leading/trailing whitespace
+
+        // Basic input validation
+        if (!claimText) {
+            displayResult('Error', 0.0, 'Please enter a claim to verify.', 'truth-red', '❗'); // Using custom color
+            return;
+        }
+
+        // Show loading state
+        setLoadingState(true);
+
+        try {
+            // Make a POST request to your Flask API
+            const response = await fetch('/api/verify', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ claim: claimText }), // Send the claim as JSON
+            });
+
+            // Check if the response was successful
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.error || `HTTP error! status: ${response.status}`);
+            }
+
+            // Parse the JSON response
+            const data = await response.json();
+
+            // Determine color and emoji based on the label (using custom colors)
+            let resultColor = 'truth-blue'; // Default for neutral
+            let emoji = '❓';
+            if (data.label === 'True') {
+                resultColor = 'truth-green';
+                emoji = '✅';
+            } else if (data.label === 'False') {
+                resultColor = 'truth-red';
+                emoji = '❌';
+            } else if (data.label === 'Low Confidence') {
+                resultColor = 'truth-orange';
+                emoji = '⚠️';
+            } else if (data.label === 'Error') {
+                resultColor = 'truth-red';
+                emoji = '❗';
+            }
+
+            // Display the result
+            displayResult(data.label, data.confidence, data.evidence, resultColor, emoji);
+
+        } catch (error) {
+            // Handle any errors during the fetch operation
+            console.error('Fetch error:', error);
+            displayResult('Error', 0.0, `Could not verify claim. ${error.message}`, 'truth-red', '❗'); // Using custom color
+        } finally {
+            // Hide loading state regardless of success or failure
+            setLoadingState(false);
+        }
+    });
+
+    // Add event listeners for example tags
+    exampleTags.forEach(tag => {
+        tag.addEventListener('click', () => {
+            claimInput.value = tag.dataset.claim; // Set claim input to the tag's data-claim
+            verifyButton.click(); // Trigger the verify button click
+        });
+    });
+
+
+    /**
+     * Sets the loading state of the button and input.
+     * @param {boolean} isLoading - True to show loading, false to hide.
+     */
+    function setLoadingState(isLoading) {
+        if (isLoading) {
+            buttonText.textContent = 'Verifying...';
+            loadingSpinner.classList.remove('hidden');
+            verifyButton.disabled = true; // Disable button to prevent multiple clicks
+            claimInput.disabled = true; // Disable input during processing
+            resultContainer.classList.add('hidden'); // Hide previous results
+            verifyButton.classList.add('opacity-75', 'cursor-not-allowed'); // Dim button
+        } else {
+            buttonText.textContent = 'Verify Claim';
+            loadingSpinner.classList.add('hidden');
+            verifyButton.disabled = false; // Re-enable button
+            claimInput.disabled = false; // Re-enable input
+            verifyButton.classList.remove('opacity-75', 'cursor-not-allowed'); // Restore button style
+        }
+    }
+
+    /**
+     * Displays the verification result in the UI.
+     * @param {string} label - The verification label (True, False, Low Confidence, Error).
+     * @param {number} confidence - The confidence score.
+     * @param {string} evidence - The evidence snippet.
+     * @param {string} color - Tailwind color class (e.g., 'truth-green', 'truth-red', 'truth-orange').
+     * @param {string} emoji - Emoji to display with the label.
+     */
+    function displayResult(label, confidence, evidence, color, emoji) {
+        resultContainer.classList.remove('hidden'); // Show the result container
+
+        // Format confidence as percentage
+        const confidencePct = (confidence * 100).toFixed(1) + '%';
+
+        // Construct the HTML for the result content
+        resultContent.innerHTML = `
+            <div class="p-6 sm:p-8 rounded-lg border-4 border-${color}-500 bg-${color}-50 text-${color}-800 shadow-xl transition-all duration-300 ease-in-out transform hover:scale-[1.005]">
+                <h3 class="text-3xl sm:text-4xl font-extrabold mb-4 flex items-center justify-center">
+                    ${emoji} <span class="ml-3">${label}</span>
+                </h3>
+                <p class="text-xl sm:text-2xl font-semibold mb-3">
+                    <strong>Confidence:</strong> <span class="text-${color}-700">${confidencePct}</span>
+                </p>
+                <p class="text-lg sm:text-xl font-medium mb-3"><strong>Evidence:</strong></p>
+                <div class="bg-white p-4 sm:p-5 rounded-md shadow-inner border border-gray-200 text-gray-700 whitespace-pre-wrap overflow-auto max-h-64 text-base leading-relaxed">
+                    ${evidence}
+                </div>
+            </div>
+        `;
+        // Scroll to the result container for better UX on mobile
+        resultContainer.scrollIntoView({ behavior: 'smooth', block: 'start' });
+    }
+});

templates/index.html

@@ -0,0 +1,96 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>🔍 TruthCheck: AI-Powered Fact Verification</title>
+    <link rel="icon" href="https://placehold.co/32x32/1E3A8A/FFFFFF?text=TC" type="image/x-icon">
+
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script>
+        tailwind.config = {
+            theme: {
+                extend: {
+                    colors: {
+                        'truth-blue': '#1E3A8A', // A custom primary blue
+                        'truth-green': '#059669', // Stronger green for true
+                        'truth-red': '#DC2626', // Stronger red for false
+                        'truth-orange': '#EA580C', // Stronger orange for low confidence
+                    },
+                    boxShadow: {
+                        '3xl': '0 35px 60px -15px rgba(0, 0, 0, 0.3)',
+                    }
+                }
+            }
+        }
+    </script>
+    <link rel="stylesheet" href="/static/css/style.css">
+</head>
+<body class="min-h-screen flex flex-col items-center justify-center p-4 sm:p-6 lg:p-8 bg-gradient-to-br from-blue-50 to-indigo-100 font-inter text-gray-800 antialiased">
+
+    <div class="max-w-4xl w-full bg-white p-8 sm:p-10 rounded-3xl shadow-3xl space-y-10 border border-gray-100 relative overflow-hidden">
+        <div class="absolute top-0 left-0 w-40 h-40 bg-blue-200 rounded-full mix-blend-multiply filter blur-xl opacity-30 animate-blob"></div>
+        <div class="absolute top-0 right-0 w-40 h-40 bg-purple-200 rounded-full mix-blend-multiply filter blur-xl opacity-30 animate-blob animation-delay-2000"></div>
+        <div class="absolute bottom-0 left-1/2 w-40 h-40 bg-pink-200 rounded-full mix-blend-multiply filter blur-xl opacity-30 animate-blob animation-delay-4000"></div>
+
+
+        <div class="text-center z-10 relative">
+            <h1 class="text-6xl sm:text-7xl font-extrabold text-gray-900 mb-4 tracking-tight leading-tight drop-shadow-lg">
+                <span class="text-truth-blue">🔍 TruthCheck</span>
+            </h1>
+            <p class="text-2xl sm:text-3xl text-gray-700 font-semibold mb-3">
+                AI-Powered Fact Verification System
+            </p>
+            <p class="text-lg text-gray-600 max-w-2xl mx-auto">
+                Enter any factual claim below and get it verified using cutting-edge AI and real-time evidence from credible sources.
+            </p>
+        </div>
+
+        <div class="space-y-6 z-10 relative">
+            <label for="claimInput" class="block text-xl font-semibold text-gray-800">
+                Enter a claim to verify:
+            </label>
+            <textarea
+                id="claimInput"
+                rows="5"
+                class="mt-1 block w-full p-4 border-2 border-gray-300 rounded-xl shadow-inner-lg focus:outline-none focus:ring-4 focus:ring-truth-blue/30 focus:border-truth-blue text-lg placeholder-gray-500 bg-gray-50 transition-all duration-300 ease-in-out transform hover:scale-[1.005] hover:shadow-md resize-y"
+                placeholder="Example: 'NASA landed a rover on Mars in 2021'"
+            ></textarea>
+            <button
+                id="verifyButton"
+                class="w-full flex items-center justify-center py-4 px-8 border border-transparent rounded-xl shadow-xl text-xl font-bold text-white bg-gradient-to-r from-truth-blue to-indigo-700 hover:from-indigo-700 hover:to-truth-blue focus:outline-none focus:ring-4 focus:ring-offset-2 focus:ring-truth-blue/50 transition-all duration-300 ease-in-out transform hover:-translate-y-1 hover:scale-105 group"
+            >
+                <span id="buttonText" class="transition-all duration-300 group-hover:scale-105">Verify Claim</span>
+                <svg id="loadingSpinner" class="animate-spin -ml-1 mr-3 h-7 w-7 text-white hidden" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                    <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                    <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                </svg>
+            </button>
+        </div>
+
+        <div class="text-center text-gray-600 text-md z-10 relative">
+            <p class="font-medium mb-2">Try these examples:</p>
+            <div class="flex flex-wrap justify-center gap-2">
+                <span class="example-tag" data-claim="NASA landed a rover on Mars in 2021">NASA landed a rover on Mars in 2021</span>
+                <span class="example-tag" data-claim="India is a continent">India is a continent</span>
+                <span class="example-tag" data-claim="The Earth is flat">The Earth is flat</span>
+                <span class="example-tag" data-claim="Donald Trump won the 2024 US Presidential election">Donald Trump won the 2024 US Presidential election</span>
+                <span class="example-tag" data-claim="COVID-19 vaccines contain microchips">COVID-19 vaccines contain microchips</span>
+            </div>
+        </div>
+
+        <div id="resultContainer" class="hidden mt-8 p-8 bg-gradient-to-br from-gray-50 to-gray-100 rounded-2xl shadow-xl border border-gray-200 z-10 relative">
+            <h2 class="text-4xl font-bold text-gray-900 mb-6 text-center drop-shadow-sm">Verification Result</h2>
+            <div id="resultContent" class="space-y-6">
+                </div>
+        </div>
+
+        <div class="text-center text-sm text-gray-400 mt-8 z-10 relative">
+            <p>Current User ID: <span id="userIdDisplay" class="font-medium text-gray-500">Guest (Authentication not implemented)</span></p>
+            <p class="text-xs mt-2">© 2024 TruthCheck. All rights reserved.</p>
+        </div>
+    </div>
+
+    <script src="/static/js/main.js"></script>
+</body>
+</html>

utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+TruthCheck Utilities Package
+"""

utils/config.py

@@ -0,0 +1,24 @@
+# utils/config.py
+import os
+
+class Config:
+    """Configuration settings for TruthCheck"""
+    
+    # Model settings
+    SIMILARITY_THRESHOLD = 0.5
+    CONFIDENCE_THRESHOLD = 0.7 # This threshold is currently not explicitly used in app.py logic but can be for stricter classification
+    
+    # API settings
+    WIKIPEDIA_TIMEOUT = 10
+    # NEWS_TIMEOUT is less relevant now as we use google_search tool directly
+    MAX_EVIDENCE_SOURCES = 5 # Max number of evidence sources to retrieve (e.g., 2 wiki, 3 web search)
+    
+    # Flask settings
+    SECRET_KEY = os.environ.get('SECRET_KEY', 'truthcheck-secret-key-2024')
+    DEBUG = os.environ.get('DEBUG', 'True').lower() == 'true'
+    
+    # Model paths (for local models if needed)
+    SPACY_MODEL = "en_core_web_sm"
+    SBERT_MODEL = "all-MiniLM-L6-v2"
+    NLI_MODEL = "roberta-large-mnli" # Or "distilbert-base-uncased-mnli" as a fallback
+

utils/similarity.py

@@ -0,0 +1,43 @@
+# utils/similarity.py
+from sentence_transformers import SentenceTransformer
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+
+class SimilarityCalculator:
+    def __init__(self): # Corrected __init__
+        """Initialize sentence transformer model"""
+        try:
+            self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        except Exception as e:
+            print(f"Error loading similarity model: {e}")
+            self.model = None
+    
+    def calculate_similarity(self, text1, text2):
+        """Calculate semantic similarity between two texts"""
+        if not self.model:
+            print("Similarity model not loaded. Returning fallback similarity.")
+            return 0.5  # Fallback similarity
+        
+        try:
+            # Encode texts to embeddings
+            embeddings = self.model.encode([text1, text2])
+            
+            # Calculate cosine similarity
+            similarity = cosine_similarity(
+                embeddings[0].reshape(1, -1),
+                embeddings[1].reshape(1, -1)
+            )[0][0]
+            
+            return float(similarity)
+            
+        except Exception as e:
+            print(f"Similarity calculation error: {e}")
+            return 0.5
+
+# Global similarity calculator instance
+_similarity_calculator = SimilarityCalculator()
+
+def calculate_similarity(text1, text2):
+    """Global function to calculate similarity"""
+    return _similarity_calculator.calculate_similarity(text1, text2)
+