Create app.py

app.py

@@ -4,6 +4,7 @@ from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import numpy as np
 import logging
 from datetime import datetime
+import re
 
 # Set up logging
 logging.basicConfig(
@@ -16,49 +17,146 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-class FallacyFinder:
+class EnhancedFallacyFinder:
     def __init__(self):
-        # Fallacy labels mapping
+        # Enhanced fallacy labels with better descriptions
         self.fallacy_labels = {
-            'ad_hominem': 'Ad Hominem (Personal Attack)',
-            'strawman': 'Strawman (Misrepresenting Argument)', 
-            'whataboutism': 'Whataboutism (Deflecting with Counter-Accusations)',
-            'gaslighting': 'Gaslighting (Making Someone Question Reality)',
-            'false_dichotomy': 'False Dichotomy (Only Two Options When More Exist)',
-            'appeal_to_emotion': 'Appeal to Emotion (Using Emotions Instead of Logic)',
-            'darvo': 'DARVO (Deny, Attack, Reverse Victim/Offender)',
-            'moving_goalposts': 'Moving Goalposts (Changing Criteria When Challenged)',
-            'cherry_picking': 'Cherry Picking (Selecting Only Supporting Evidence)',
-            'appeal_to_authority': 'Appeal to Authority (Inappropriate Use of Authority)',
-            'slippery_slope': 'Slippery Slope (One Thing Leads to Extreme Consequences)',
-            'motte_and_bailey': 'Motte and Bailey (Defending Weak Position with Stronger One)',
-            'gish_gallop': 'Gish Gallop (Overwhelming with Many Weak Arguments)',
-            'kafkatrapping': 'Kafkatrapping (Denial Proves Guilt)',
-            'sealioning': 'Sealioning (Persistent Bad-Faith Requests for Evidence)',
-            'no_fallacy': 'No Fallacy (Clean, Logical Statement)'
+            'ad_hominem': 'Ad Hominem',
+            'strawman': 'Strawman', 
+            'whataboutism': 'Whataboutism',
+            'gaslighting': 'Gaslighting',
+            'false_dichotomy': 'False Dichotomy',
+            'appeal_to_emotion': 'Appeal to Emotion',
+            'darvo': 'DARVO',
+            'moving_goalposts': 'Moving Goalposts',
+            'cherry_picking': 'Cherry Picking',
+            'appeal_to_authority': 'Appeal to Authority',
+            'slippery_slope': 'Slippery Slope',
+            'motte_and_bailey': 'Motte and Bailey',
+            'gish_gallop': 'Gish Gallop',
+            'kafkatrapping': 'Kafkatrapping',
+            'sealioning': 'Sealioning',
+            'no_fallacy': 'Clean Communication'
         }
         
-        # Fallacy descriptions
+        # Simplified, actionable descriptions
         self.fallacy_descriptions = {
-            'ad_hominem': "Attacking the person making the argument rather than addressing the argument itself.",
-            'strawman': "Misrepresenting someone's argument to make it easier to attack.",
-            'whataboutism': "Deflecting criticism by pointing out similar issues elsewhere instead of addressing the original concern.",
-            'gaslighting': "Making someone question their own memory, perception, or sanity.",
-            'false_dichotomy': "Presenting only two options when more alternatives exist.",
-            'appeal_to_emotion': "Using emotional manipulation instead of logical reasoning to persuade.",
-            'darvo': "A manipulation tactic: Deny the abuse, Attack the victim, Reverse Victim and Offender roles.",
-            'moving_goalposts': "Changing the criteria for evidence or success when the original criteria are met.",
-            'cherry_picking': "Selecting only data or examples that support your position while ignoring contradictory evidence.",
-            'appeal_to_authority': "Citing an authority figure inappropriately to support an argument.",
-            'slippery_slope': "Arguing that one small step will lead to a chain of negative consequences.",
-            'motte_and_bailey': "Switching between a defensible position (motte) and a controversial one (bailey).",
-            'gish_gallop': "Overwhelming an opponent with many rapid-fire arguments, regardless of their quality.",
-            'kafkatrapping': "A logical trap where denial of guilt is taken as evidence of guilt.",
-            'sealioning': "Persistently requesting evidence or debate in a way that appears reasonable but is actually harassment.",
-            'no_fallacy': "The statement appears to be logically sound and free of common fallacies."
+            'ad_hominem': "Attacking the person instead of their argument",
+            'strawman': "Misrepresenting someone's position to attack it easier",
+            'whataboutism': "Deflecting by pointing to other issues",
+            'gaslighting': "Making someone question their own reality",
+            'false_dichotomy': "Presenting only two options when more exist",
+            'appeal_to_emotion': "Using emotions to manipulate instead of logic",
+            'darvo': "Deny, Attack, and Reverse victim/offender roles",
+            'moving_goalposts': "Changing requirements when original ones are met",
+            'cherry_picking': "Selecting only supporting evidence",
+            'appeal_to_authority': "Misusing authority to support weak arguments",
+            'slippery_slope': "Claiming one thing leads to extreme outcomes",
+            'motte_and_bailey': "Switching between strong and weak positions",
+            'gish_gallop': "Overwhelming with many rapid-fire weak arguments",
+            'kafkatrapping': "Where denial of guilt proves guilt",
+            'sealioning': "Persistent bad-faith requests for evidence",
+            'no_fallacy': "Logical, respectful communication"
         }
         
-        # Load your trained model from Hugging Face
+        # Rewrite suggestions - the most valuable feature
+        self.rewrite_suggestions = {
+            'ad_hominem': {
+                'problem': "Focuses on attacking the person",
+                'better': "Focus on the argument: 'I disagree with your point because...'"
+            },
+            'strawman': {
+                'problem': "Misrepresents the other person's view",
+                'better': "Address their actual position: 'I understand you're saying X, but I think Y because...'"
+            },
+            'whataboutism': {
+                'problem': "Deflects instead of addressing the issue",
+                'better': "Address the concern first: 'You're right about X. Here's how we can fix it...'"
+            },
+            'gaslighting': {
+                'problem': "Makes the other person question reality",
+                'better': "Acknowledge their experience: 'I remember it differently, let's figure out what happened...'"
+            },
+            'false_dichotomy': {
+                'problem': "Forces an either/or choice",
+                'better': "Present more options: 'There are several ways we could approach this...'"
+            },
+            'appeal_to_emotion': {
+                'problem': "Uses emotions to manipulate",
+                'better': "Use facts and logic: 'The evidence shows that...'"
+            },
+            'darvo': {
+                'problem': "Reverses victim and offender",
+                'better': "Take responsibility: 'I understand your concern. Let me address it...'"
+            },
+            'moving_goalposts': {
+                'problem': "Changes requirements unfairly",
+                'better': "Be consistent: 'Here's what I need to be convinced...'"
+            },
+            'cherry_picking': {
+                'problem': "Ignores contradictory evidence",
+                'better': "Consider all evidence: 'While some data shows X, other studies show Y...'"
+            },
+            'appeal_to_authority': {
+                'problem': "Relies on inappropriate authority",
+                'better': "Use relevant expertise: 'According to experts in this specific field...'"
+            },
+            'slippery_slope': {
+                'problem': "Assumes extreme consequences",
+                'better': "Focus on immediate effects: 'This specific change would result in...'"
+            },
+            'motte_and_bailey': {
+                'problem': "Switches between positions",
+                'better': "Be consistent: 'My position is X, and here's why...'"
+            },
+            'gish_gallop': {
+                'problem': "Overwhelms with too many points",
+                'better': "Focus on key issues: 'The main concern is X because...'"
+            },
+            'kafkatrapping': {
+                'problem': "Makes denial proof of guilt",
+                'better': "Allow for honest denial: 'Let's examine the evidence together...'"
+            },
+            'sealioning': {
+                'problem': "Persistently demands evidence in bad faith",
+                'better': "Ask genuinely: 'I'd appreciate learning more about your perspective...'"
+            },
+            'no_fallacy': {
+                'problem': "None detected",
+                'better': "Great communication! Clear, logical, and respectful."
+            }
+        }
+        
+        # Categorized examples for better exploration
+        self.example_categories = {
+            "Personal Attacks": [
+                "You're too stupid to understand this basic concept",
+                "What would someone with your background know about this?",
+                "You're clearly too emotional to think rationally about this"
+            ],
+            "Deflection & Avoidance": [
+                "What about when you made the same mistake last year?",
+                "But what about all the problems with your solution?",
+                "That never happened, you're imagining things"
+            ],
+            "False Choices": [
+                "Either you support this or you hate progress",
+                "You're either with us or against us on this issue",
+                "We either act now or everything will be ruined"
+            ],
+            "Manipulation": [
+                "Think of the innocent children who will suffer",
+                "If you really cared about people, you'd support this",
+                "How can you sleep at night knowing this?"
+            ],
+            "Healthy Communication": [
+                "I understand your concerns, but here's why I disagree",
+                "Based on the evidence I've seen, I think we should consider this",
+                "I appreciate your perspective and want to discuss this further"
+            ]
+        }
+        
+        # Load model
         self.model = None
         self.tokenizer = None
         self.use_model = False
@@ -68,161 +166,50 @@ class FallacyFinder:
             self.tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/fallacyfinder")
             self.model = AutoModelForSequenceClassification.from_pretrained(
                 "SamanthaStorm/fallacyfinder",
-                num_labels=16  # Specify 16 fallacy classes
+                num_labels=16
             )
             self.use_model = True
             logger.info("✅ Model loaded successfully!")
         except Exception as e:
             logger.error(f"❌ Error loading model: {e}")
-            logger.error("Model loading failed - cannot continue without trained model")
-            raise e  # Stop execution if model fails to load
-    
-    def predict_with_rules(self, text):
-        """Rule-based fallacy detection for when model isn't available"""
-        text_lower = text.lower().strip()
-        detected_patterns = []
-        
-        # Ad Hominem patterns
-        ad_hominem_patterns = [
-            'you\'re', 'you are', 'stupid', 'idiot', 'moron', 'dumb', 'ignorant',
-            'loser', 'pathetic', 'crazy', 'insane', 'nuts'
-        ]
-        matched_ad_hominem = [p for p in ad_hominem_patterns if p in text_lower]
-        if matched_ad_hominem and ('you' in text_lower):
-            detected_patterns.append(f"ad_hominem: {matched_ad_hominem}")
-            logger.info(f"RULE-BASED: Ad Hominem detected - patterns: {matched_ad_hominem}")
-            return 'ad_hominem', 0.85, detected_patterns
-        
-        # Strawman patterns
-        strawman_patterns = [
-            'so you\'re saying', 'so you think', 'so you believe', 'so you want',
-            'according to you', 'you\'re advocating', 'you want to destroy'
-        ]
-        matched_strawman = [p for p in strawman_patterns if p in text_lower]
-        if matched_strawman:
-            detected_patterns.append(f"strawman: {matched_strawman}")
-            logger.info(f"RULE-BASED: Strawman detected - patterns: {matched_strawman}")
-            return 'strawman', 0.82, detected_patterns
-        
-        # Whataboutism patterns
-        whataboutism_patterns = [
-            'what about', 'but what about', 'how about when', 'what about when you',
-            'but you', 'but when you'
-        ]
-        matched_whataboutism = [p for p in whataboutism_patterns if p in text_lower]
-        if matched_whataboutism:
-            detected_patterns.append(f"whataboutism: {matched_whataboutism}")
-            logger.info(f"RULE-BASED: Whataboutism detected - patterns: {matched_whataboutism}")
-            return 'whataboutism', 0.88, detected_patterns
-        
-        # Gaslighting patterns
-        gaslighting_patterns = [
-            'that never happened', 'you\'re imagining', 'you\'re being too sensitive',
-            'you\'re overreacting', 'that\'s not what i said', 'you\'re remembering wrong',
-            'you\'re being paranoid', 'you\'re being dramatic'
-        ]
-        matched_gaslighting = [p for p in gaslighting_patterns if p in text_lower]
-        if matched_gaslighting:
-            detected_patterns.append(f"gaslighting: {matched_gaslighting}")
-            logger.info(f"RULE-BASED: Gaslighting detected - patterns: {matched_gaslighting}")
-            return 'gaslighting', 0.80, detected_patterns
-        
-        # False Dichotomy patterns
-        false_dichotomy_patterns = [
-            'either you\'re', 'either we', 'you\'re either', 'it\'s either',
-            'with us or against us', 'love it or leave it'
-        ]
-        matched_false_dichotomy = [p for p in false_dichotomy_patterns if p in text_lower]
-        if matched_false_dichotomy:
-            detected_patterns.append(f"false_dichotomy: {matched_false_dichotomy}")
-            logger.info(f"RULE-BASED: False Dichotomy detected - patterns: {matched_false_dichotomy}")
-            return 'false_dichotomy', 0.78, detected_patterns
-        
-        # Appeal to Emotion patterns
-        emotion_patterns = [
-            'think of the children', 'innocent people will', 'if you have any heart',
-            'how can you sleep', 'break the hearts', 'suffer needlessly'
-        ]
-        matched_emotion = [p for p in emotion_patterns if p in text_lower]
-        if matched_emotion:
-            detected_patterns.append(f"appeal_to_emotion: {matched_emotion}")
-            logger.info(f"RULE-BASED: Appeal to Emotion detected - patterns: {matched_emotion}")
-            return 'appeal_to_emotion', 0.83, detected_patterns
-        
-        # DARVO patterns
-        darvo_patterns = [
-            'i never did that', 'you\'re the one who', 'i\'m the victim here',
-            'you\'re attacking me', 'i\'m innocent', 'you started this'
-        ]
-        matched_darvo = [p for p in darvo_patterns if p in text_lower]
-        if matched_darvo and len(matched_darvo) >= 2:
-            detected_patterns.append(f"darvo: {matched_darvo}")
-            logger.info(f"RULE-BASED: DARVO detected - patterns: {matched_darvo}")
-            return 'darvo', 0.75, detected_patterns
-        
-        # Moving Goalposts patterns
-        goalpost_patterns = [
-            'that doesn\'t count because', 'you need better sources', 'that\'s not enough evidence',
-            'those statistics don\'t count', 'that\'s different because'
-        ]
-        matched_goalpost = [p for p in goalpost_patterns if p in text_lower]
-        if matched_goalpost:
-            detected_patterns.append(f"moving_goalposts: {matched_goalpost}")
-            logger.info(f"RULE-BASED: Moving Goalposts detected - patterns: {matched_goalpost}")
-            return 'moving_goalposts', 0.77, detected_patterns
-        
-        # Appeal to Authority patterns
-        authority_patterns = [
-            'my doctor said', 'the expert said', 'the ceo thinks', 'einstein believed',
-            'my professor told me', 'the government says'
-        ]
-        matched_authority = [p for p in authority_patterns if p in text_lower]
-        if matched_authority:
-            detected_patterns.append(f"appeal_to_authority: {matched_authority}")
-            logger.info(f"RULE-BASED: Appeal to Authority detected - patterns: {matched_authority}")
-            return 'appeal_to_authority', 0.72, detected_patterns
-        
-        # Slippery Slope patterns
-        slope_patterns = [
-            'if we allow this', 'this will lead to', 'give them an inch',
-            'this is just the beginning', 'where will it end', 'slippery slope'
-        ]
-        matched_slope = [p for p in slope_patterns if p in text_lower]
-        if matched_slope:
-            detected_patterns.append(f"slippery_slope: {matched_slope}")
-            logger.info(f"RULE-BASED: Slippery Slope detected - patterns: {matched_slope}")
-            return 'slippery_slope', 0.74, detected_patterns
-        
-        # Check for healthy communication (No Fallacy)
-        healthy_patterns = [
-            'i understand your perspective', 'i disagree because', 'based on the evidence',
-            'i appreciate your input', 'let\'s examine', 'i think we need more information',
-            'i see the merit', 'thank you for sharing'
-        ]
-        matched_healthy = [p for p in healthy_patterns if p in text_lower]
-        if matched_healthy:
-            detected_patterns.append(f"no_fallacy: {matched_healthy}")
-            logger.info(f"RULE-BASED: Healthy communication detected - patterns: {matched_healthy}")
-            return 'no_fallacy', 0.90, detected_patterns
-        
-        # Default to no fallacy if nothing detected
-        logger.info("RULE-BASED: No specific patterns detected, defaulting to no_fallacy")
-        return 'no_fallacy', 0.60, ["no_specific_patterns"]
-    
+            raise e
+
+    def get_confidence_display(self, confidence):
+        """Simplified traffic light confidence system"""
+        if confidence >= 0.85:
+            return "🔴 Strong Detection", "high", f"{confidence * 100:.0f}%"
+        elif confidence >= 0.70:
+            return "🟡 Likely Fallacy", "medium", f"{confidence * 100:.0f}%"
+        elif confidence >= 0.55:
+            return "🟠 Possible Issue", "low", f"{confidence * 100:.0f}%"
+        else:
+            return "🟢 Looks Clean", "clean", f"{confidence * 100:.0f}%"
+
+    def get_text_guidance(self, text):
+        """Provide real-time guidance as user types"""
+        if len(text.strip()) == 0:
+            return "💡 Enter a message to analyze for logical fallacies"
+        elif len(text.strip()) < 10:
+            return "💡 Try a longer example for better analysis"
+        elif len(text) > 500:
+            return "⚠️ Very long text - consider analyzing in smaller parts"
+        elif len(text) > 200:
+            return "📝 Good length for comprehensive analysis"
+        else:
+            return "✅ Perfect length for analysis"
+
     def predict_fallacy(self, text):
-        """Main prediction function using trained model only"""
+        """Main prediction function"""
         if not text.strip():
-            return None, 0, "Please enter a message to analyze.", []
+            return None, 0, [], {}
         
         logger.info(f"ANALYZING: '{text[:100]}{'...' if len(text) > 100 else ''}'")
         
         if not self.use_model or self.model is None:
-            logger.error("Trained model not available - cannot analyze")
-            return None, 0, "Model not loaded", []
+            logger.error("Model not available")
+            return None, 0, [], {}
         
-        # Use trained model
         try:
-            logger.info("Using trained model for prediction")
             inputs = self.tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
             
             with torch.no_grad():
@@ -231,236 +218,309 @@ class FallacyFinder:
                 predicted_class_id = predictions.argmax().item()
                 confidence = predictions.max().item()
             
-            # Log all prediction scores
+            # Get top 3 predictions for transparency
             label_keys = list(self.fallacy_labels.keys())
-            prediction_scores = {}
-            for i, label in enumerate(label_keys):
-                score = predictions[0][i].item()
-                prediction_scores[label] = f"{score:.3f}"
+            top_predictions = []
+            values, indices = torch.topk(predictions[0], 3)
             
-            logger.info(f"MODEL PREDICTIONS: {prediction_scores}")
+            for i in range(3):
+                label = label_keys[indices[i].item()]
+                score = values[i].item()
+                top_predictions.append((label, score))
             
-            # Map to fallacy label
             predicted_label = label_keys[predicted_class_id]
-            logger.info(f"MODEL RESULT: {predicted_label} (confidence: {confidence:.3f})")
-            
-            patterns_detected = [f"model_prediction: top_3: {sorted(prediction_scores.items(), key=lambda x: float(x[1]), reverse=True)[:3]}"]
             
-            fallacy_name = self.fallacy_labels[predicted_label]
-            description = self.fallacy_descriptions[predicted_label]
-            
-            logger.info(f"FINAL RESULT: {predicted_label} ({fallacy_name}) - confidence: {confidence}")
+            logger.info(f"MODEL RESULT: {predicted_label} (confidence: {confidence:.3f})")
             
-            return predicted_label, confidence, fallacy_name, description, patterns_detected
+            return predicted_label, confidence, top_predictions, {}
             
         except Exception as e:
             logger.error(f"Model prediction failed: {e}")
-            return None, 0, "Prediction failed", []
-    
-    def analyze_message(self, message):
-        """Analyze a message and return formatted results"""
-        if not message.strip():
-            return "Please enter a message to analyze.", "", ""
-        
-        predicted_label, confidence, fallacy_name, description, patterns = self.predict_fallacy(message)
+            return None, 0, [], {}
+
+    def format_analysis_result(self, predicted_label, confidence, top_predictions):
+        """Format the main analysis result with better visual design"""
+        if predicted_label is None:
+            return "❌ Analysis failed. Please try again.", "", ""
         
-        # Format confidence as percentage
-        confidence_percent = f"{confidence * 100:.1f}%"
+        # Get confidence display
+        conf_display, conf_level, conf_percent = self.get_confidence_display(confidence)
         
-        # Determine confidence level and colors
-        if confidence >= 0.8:
-            confidence_level = "🔵 High Confidence"
-            confidence_color = "high"
-        elif confidence >= 0.6:
-            confidence_level = "🟣 Medium Confidence"
-            confidence_color = "medium"
-        else:
-            confidence_level = "🟢 Low Confidence"
-            confidence_color = "low"
+        # Get fallacy info
+        fallacy_name = self.fallacy_labels[predicted_label]
+        description = self.fallacy_descriptions[predicted_label]
+        suggestion = self.rewrite_suggestions[predicted_label]
         
-        # Format the main result with better structure
+        # Format main result
         if predicted_label == 'no_fallacy':
-            result = f"✅ **No Fallacy Detected**\n\n**Confidence:** {confidence_level} ({confidence_percent})"
+            icon = "✅"
+            main_result = f"{icon} **{fallacy_name}**"
+            result_color = "success"
         else:
-            result = f"⚠️ **{fallacy_name}**\n\n**Confidence:** {confidence_level} ({confidence_percent})"
-        
-        # Add top predictions in a clean list format
-        if patterns and patterns[0].startswith('model_prediction'):
-            # Extract top 3 predictions from debug info
-            try:
-                import ast
-                debug_str = patterns[0].replace('model_prediction: top_3: ', '')
-                top_predictions = ast.literal_eval(debug_str)
-                
-                result += f"\n\n**Top Predictions:**"
-                for i, (fallacy, score) in enumerate(top_predictions, 1):
-                    fallacy_display = self.fallacy_labels.get(fallacy, fallacy.replace('_', ' ').title())
-                    percentage = f"{float(score) * 100:.1f}%"
-                    result += f"\n{i}. {fallacy_display}: {percentage}"
-                    
-            except:
-                # Fallback if parsing fails
-                result += f"\n\n**Debug Info:** Model prediction analysis available in logs"
+            icon = "⚠️"
+            main_result = f"{icon} **{fallacy_name} Detected**"
+            result_color = "warning"
         
-        # Format the explanation
-        explanation = f"**What this means:**\n{description}"
-        
-        # Add examples or tips based on fallacy type
-        if predicted_label == 'ad_hominem':
-            explanation += "\n\n**Better approach:** Focus on the argument itself rather than the person making it."
-        elif predicted_label == 'strawman':
-            explanation += "\n\n**Better approach:** Address the actual argument being made, not a distorted version of it."
-        elif predicted_label == 'whataboutism':
-            explanation += "\n\n**Better approach:** Address the original concern directly before discussing other issues."
-        elif predicted_label == 'gaslighting':
-            explanation += "\n\n**Better approach:** Acknowledge the other person's experience and work toward understanding."
-        elif predicted_label == 'no_fallacy':
-            explanation = "**Great communication!** This message appears to use logical reasoning and respectful language."
-        
-        # Log the final user-facing result
-        logger.info(f"USER RESULT: {predicted_label} - {confidence_percent} confidence")
-        logger.info("="*50)
-        
-        return result, explanation, confidence_color
+        # Build result string
+        result = f"""
+{main_result}
 
-# Initialize the fallacy finder
-logger.info("Initializing Fallacy Finder...")
-finder = FallacyFinder()
-logger.info("Fallacy Finder initialized successfully")
+**Confidence:** {conf_display} ({conf_percent})
 
-def analyze_fallacy(message):
-    result, explanation, _ = finder.analyze_message(message)  # Ignore 3rd return value
-    return result, explanation
+**What this means:** {description}
+"""
+        
+        # Add top predictions for transparency
+        if len(top_predictions) >= 2:
+            result += f"\n**Other possibilities:**"
+            for i, (label, score) in enumerate(top_predictions[1:3], 2):
+                fallacy_display = self.fallacy_labels[label]
+                percentage = f"{score * 100:.0f}%"
+                result += f"\n{i}. {fallacy_display}: {percentage}"
+        
+        # Format suggestions
+        if predicted_label != 'no_fallacy':
+            suggestion_text = f"""
+**💡 How to improve:**
 
-# Create the Gradio interface
-with gr.Blocks(
-    theme=gr.themes.Soft(primary_hue="blue", secondary_hue="indigo"),
-    title="Fallacy Finder",
-    css="""
+**The problem:** {suggestion['problem']}
+
+**Better approach:** {suggestion['better']}
+"""
+        else:
+            suggestion_text = """
+**🎉 Excellent communication!**
+
+This message uses logical reasoning and respectful language. Keep it up!
+
+**What makes this good:**
+• Addresses the topic directly
+• Uses respectful language  
+• Focuses on facts and reasoning
+• Acknowledges other perspectives
+"""
+        
+        return result, suggestion_text, conf_level
+
+def create_enhanced_interface():
+    """Create the enhanced Gradio interface"""
+    
+    # Initialize the finder
+    logger.info("Initializing Enhanced Fallacy Finder...")
+    finder = EnhancedFallacyFinder()
+    logger.info("Enhanced Fallacy Finder initialized successfully")
+    
+    # Analysis function
+    def analyze_message(message):
+        """Main analysis function called by interface"""
+        if not message.strip():
+            return "Please enter a message to analyze.", "", "clean"
+        
+        predicted_label, confidence, top_predictions, _ = finder.predict_fallacy(message)
+        result, suggestion, conf_level = finder.format_analysis_result(predicted_label, confidence, top_predictions)
+        
+        logger.info(f"USER RESULT: {predicted_label} - {confidence*100:.0f}% confidence")
+        return result, suggestion, conf_level
+    
+    # Get guidance function
+    def get_guidance(text):
+        return finder.get_text_guidance(text)
+    
+    # Custom CSS for better visual design
+    custom_css = """
     .gradio-container {
-        max-width: 900px !important;
+        max-width: 1000px !important;
+        margin: auto;
     }
-    .high-confidence {
-        border-left: 4px solid #3b82f6;
+    .high {
+        background: linear-gradient(90deg, #fee2e2, #fef2f2);
+        border-left: 4px solid #dc2626;
+        padding: 1rem;
+        border-radius: 8px;
     }
-    .medium-confidence {
-        border-left: 4px solid #8b5cf6;
+    .medium {
+        background: linear-gradient(90deg, #fef3c7, #fffbeb);
+        border-left: 4px solid #d97706;
+        padding: 1rem;
+        border-radius: 8px;
     }
-    .low-confidence {
-        border-left: 4px solid #10b981;
+    .low {
+        background: linear-gradient(90deg, #ddd6fe, #f3f4f6);
+        border-left: 4px solid #7c3aed;
+        padding: 1rem;
+        border-radius: 8px;
+    }
+    .clean {
+        background: linear-gradient(90deg, #dcfce7, #f0fdf4);
+        border-left: 4px solid #16a34a;
+        padding: 1rem;
+        border-radius: 8px;
+    }
+    .examples-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+        gap: 1rem;
+        margin: 1rem 0;
+    }
+    .category-header {
+        font-weight: bold;
+        color: #374151;
+        margin-bottom: 0.5rem;
     }
     """
-) as demo:
-    
-    gr.Markdown(
-        """
-        # 🔍 Fallacy Finder
-        
-        Analyze messages for logical fallacies and argumentative patterns. Enter any statement, argument, or message to identify potential fallacies and get suggestions for better communication.
-        
-        **Detects 15+ types of fallacies** including ad hominem, strawman, whataboutism, gaslighting, and more.
-        """
-    )
     
-    with gr.Row():
-        with gr.Column(scale=2):
-            message_input = gr.Textbox(
-                label="Enter a message to analyze",
-                placeholder="e.g., 'You're just saying that because you're too young to understand politics'",
-                lines=4,
-                info="Paste any statement, argument, or message you want to check for logical fallacies"
-            )
+    # Create the interface
+    with gr.Blocks(
+        theme=gr.themes.Soft(primary_hue="blue", secondary_hue="indigo"),
+        title="Enhanced Fallacy Finder",
+        css=custom_css
+    ) as demo:
+        
+        # Header
+        gr.Markdown(
+            """
+            # 🔍 Fallacy Finder Pro
             
-            analyze_btn = gr.Button("🔍 Analyze for Fallacies", variant="primary", size="lg")
+            **Advanced AI-powered logical fallacy detection** - Analyze any message for argumentative fallacies and get specific suggestions for better communication.
             
-        with gr.Column(scale=1):
+            ✨ **Enhanced with**: Real-time guidance • Rewrite suggestions • Confidence levels • Categorized examples
+            """
+        )
+        
+        # Main interface
+        with gr.Row():
+            with gr.Column(scale=3):
+                # Input section
+                message_input = gr.Textbox(
+                    label="💬 Enter your message",
+                    placeholder="e.g., 'You're just saying that because you're too young to understand politics'",
+                    lines=4,
+                    info="Paste any statement, argument, or message to check for logical fallacies"
+                )
+                
+                # Real-time guidance
+                guidance_output = gr.Textbox(
+                    label="💡 Guidance",
+                    interactive=False,
+                    max_lines=1
+                )
+                
+                # Action buttons
+                with gr.Row():
+                    analyze_btn = gr.Button("🔍 Analyze Message", variant="primary", size="lg")
+                    clear_btn = gr.Button("🔄 Clear", variant="secondary")
+                
+            with gr.Column(scale=2):
+                # Quick stats or tips
+                gr.Markdown(
+                    """
+                    ### 🎯 What We Detect
+                    
+                    **Personal Attacks** • **Strawman Arguments** • **Whataboutism** • **Gaslighting** • **False Choices** • **Emotional Manipulation** • **And 10+ more...**
+                    
+                    ### 🚦 Confidence Levels
+                    🔴 **Strong Detection** (85%+)  
+                    🟡 **Likely Fallacy** (70%+)  
+                    🟠 **Possible Issue** (55%+)  
+                    🟢 **Looks Clean** (<55%)
+                    """
+                )
+        
+        # Results section
+        with gr.Row():
+            with gr.Column():
+                result_output = gr.Textbox(
+                    label="📊 Analysis Result",
+                    lines=6,
+                    interactive=False
+                )
+                
+                suggestion_output = gr.Textbox(
+                    label="💡 Suggestions & Improvements",
+                    lines=6,
+                    interactive=False
+                )
+        
+        # Enhanced examples section
+        gr.Markdown("## 📚 Try These Examples")
+        
+        # Create example buttons for each category
+        for category, examples in finder.example_categories.items():
+            with gr.Accordion(f"{category}", open=False):
+                for example in examples:
+                    example_btn = gr.Button(f"📝 {example[:60]}{'...' if len(example) > 60 else ''}", 
+                                          variant="secondary", size="sm")
+                    example_btn.click(
+                        lambda x=example: x,
+                        outputs=message_input
+                    )
+        
+        # Information section
+        with gr.Accordion("🎓 Learn More", open=False):
             gr.Markdown(
                 """
-                ### Quick Examples:
+                ### How This Works
+                
+                Our AI model analyzes text patterns to identify logical fallacies that can harm productive communication. It's trained on thousands of examples to recognize:
+                
+                - **Argumentative fallacies** that weaken reasoning
+                - **Manipulation tactics** that avoid real discussion  
+                - **Respectful communication** patterns to encourage
                 
-                **Ad Hominem:**  
-                *"You're too stupid to understand"*
+                ### Tips for Better Arguments
                 
-                **Strawman:**  
-                *"So you want to destroy the economy?"*
+                ✅ **Address the argument, not the person**  
+                ✅ **Represent opposing views accurately**  
+                ✅ **Use evidence and logical reasoning**  
+                ✅ **Stay focused on the main issue**  
+                ✅ **Acknowledge valid concerns**
                 
-                **Whataboutism:**  
-                *"What about when you did the same thing?"*
+                ### About Confidence Scores
                 
-                **No Fallacy:**  
-                *"I disagree because the evidence shows..."*
+                - **High confidence** = Clear fallacy pattern detected
+                - **Medium confidence** = Likely problematic, worth reviewing
+                - **Low confidence** = Possible issue, but context matters
+                - **Clean** = No concerning patterns found
+                
+                *Remember: Context always matters in human communication!*
                 """
             )
-    
-    with gr.Row():
-        with gr.Column():
-            result_output = gr.Textbox(
-                label="Analysis Result",
-                lines=6,
-                interactive=False
-            )
-            
-            explanation_output = gr.Textbox(
-                label="Explanation & Suggestions",
-                lines=6,
-                interactive=False
-            )
-    
-    # Examples section
-    gr.Markdown("## 📋 Try These Examples")
-    
-    example_messages = [
-        "You're clearly too young and inexperienced to have a valid opinion on this topic",
-        "So you're saying we should just let criminals run free and destroy society?", 
-        "What about when you lied to me last year? Why should I trust you now?",
-        "That never happened, you're just being overly emotional and dramatic about nothing",
-        "Either you support the troops or you hate America - there's no middle ground",
-        "I understand your concerns, but based on the research I've seen, I think we should consider other options"
-    ]
-    
-    examples = gr.Examples(
-        examples=[[msg] for msg in example_messages],
-        inputs=[message_input],
-        outputs=[result_output, explanation_output],
-        fn=analyze_fallacy,
-        cache_examples=False
-    )
-    
-    # Information section
-    gr.Markdown(
-        """
-        ### 🎯 How It Works
         
-        This tool uses an AI model trained to detect logical fallacies and argumentative patterns that can harm productive communication. It analyzes:
-        
-        - **Personal attacks** instead of addressing arguments
-        - **Misrepresentations** of opposing viewpoints  
-        - **Emotional manipulation** instead of logical reasoning
-        - **Deflection tactics** that avoid the main issue
-        - **False choices** that ignore other options
-        
-        ### 💡 Tips for Better Arguments
-        
-        ✅ **Focus on the argument, not the person**  
-        ✅ **Address the actual position being argued**  
-        ✅ **Use evidence and logical reasoning**  
-        ✅ **Acknowledge valid points from the other side**  
-        ✅ **Stay on topic and address concerns directly**
-        """
-    )
-    
-    # Connect the function
-    analyze_btn.click(
-        fn=analyze_fallacy,
-        inputs=[message_input],
-        outputs=[result_output, explanation_output]
-    )
+        # Connect functions
+        message_input.change(
+            fn=get_guidance,
+            inputs=[message_input],
+            outputs=[guidance_output]
+        )
+        
+        analyze_btn.click(
+            fn=analyze_message,
+            inputs=[message_input],
+            outputs=[result_output, suggestion_output]
+        )
+        
+        clear_btn.click(
+            fn=lambda: ("", "", "", ""),
+            outputs=[message_input, result_output, suggestion_output, guidance_output]
+        )
+        
+        # Footer
+        gr.Markdown(
+            """
+            ---
+            **Fallacy Finder Pro** • Built with ❤️ for better communication • [Learn about logical fallacies](https://en.wikipedia.org/wiki/List_of_fallacies)
+            """
+        )
+        
+        return demo
 
 # Launch the app
 if __name__ == "__main__":
-    logger.info("Starting Gradio interface...")
+    logger.info("Starting Enhanced Gradio interface...")
+    demo = create_enhanced_interface()
     demo.launch(
         share=True,
         server_name="0.0.0.0",
-        server_port=7860
+        server_port=7860,
+        show_error=True
     )