Update code

Dockerfile

@@ -16,6 +16,7 @@ COPY search.py .
 COPY semantic_search.py .
 COPY hybrid_search.py .
 COPY gemini_client.py .
+COPY stylometry.py .
 COPY schema.sql .
 COPY static/ static/
 COPY templates/ templates/

dashboard.py

@@ -299,6 +299,12 @@ def ai_search_page():
     return render_template('ai_search.html')
 
 
+@app.route('/maintenance')
+def maintenance_page():
+    """Maintenance page - password protected."""
+    return render_template('maintenance.html')
+
+
 # ==========================================
 # API ENDPOINTS - OVERVIEW STATS
 # ==========================================
@@ -2040,6 +2046,87 @@ def api_hybrid_status():
         })
 
 
+# ==========================================
+# API ENDPOINTS - STYLOMETRY (Duplicate Detection)
+# ==========================================
+
+# Global stylometry state
+_stylometry_status = {'status': 'idle', 'progress': 0, 'message': '', 'results': None}
+
+@app.route('/api/stylometry/analyze', methods=['POST'])
+def api_stylometry_analyze():
+    """Start stylometry analysis to detect duplicate accounts."""
+    import threading
+
+    data = request.get_json() or {}
+    min_messages = data.get('min_messages', 300)
+    days = data.get('days', 365)
+    threshold = data.get('threshold', 0.85)
+
+    global _stylometry_status
+    _stylometry_status = {'status': 'running', 'progress': 0, 'message': 'מתחיל ניתוח...', 'results': None}
+
+    def run_analysis():
+        global _stylometry_status
+        try:
+            from stylometry import get_stylometry_analyzer
+
+            analyzer = get_stylometry_analyzer()
+            analyzer.similarity_threshold = threshold
+
+            def progress_callback(event, *args):
+                global _stylometry_status
+                if event == 'users_found':
+                    _stylometry_status['message'] = f'נמצאו {args[0]} משתמשים לניתוח'
+                    _stylometry_status['progress'] = 5
+                elif event == 'user_processed':
+                    current, total, name = args
+                    pct = 5 + int(70 * current / total)
+                    _stylometry_status['progress'] = pct
+                    _stylometry_status['message'] = f'מעבד {current}/{total}: {name}'
+                elif event == 'comparing':
+                    current = args[0]
+                    total = args[1] if len(args) > 1 else 1
+                    pct = 75 + int(25 * current / max(1, total))
+                    _stylometry_status['progress'] = min(99, pct)
+                    _stylometry_status['message'] = 'משווה דפוסי כתיבה...'
+
+            results = analyzer.analyze_all_users(
+                min_messages=min_messages,
+                days=days,
+                progress_callback=progress_callback
+            )
+
+            _stylometry_status = {
+                'status': 'completed',
+                'progress': 100,
+                'message': 'הניתוח הושלם',
+                'results': results
+            }
+
+        except Exception as e:
+            import traceback
+            _stylometry_status = {
+                'status': 'error',
+                'progress': 0,
+                'message': str(e),
+                'error': traceback.format_exc(),
+                'results': None
+            }
+
+    # Run in background thread
+    thread = threading.Thread(target=run_analysis)
+    thread.start()
+
+    return jsonify({'status': 'started'})
+
+
+@app.route('/api/stylometry/status')
+def api_stylometry_status():
+    """Get stylometry analysis status."""
+    return jsonify(_stylometry_status)
+
+
 def fallback_ai_search(query: str):
     """Fallback search when AI is not available."""
     conn = get_db()

stylometry.py

@@ -0,0 +1,487 @@
+"""
+Stylometry Analysis Module for Hebrew Text
+Detects potential duplicate accounts based on writing style patterns.
+"""
+
+import re
+import sqlite3
+import math
+from collections import Counter, defaultdict
+from datetime import datetime, timedelta
+from typing import Dict, List, Tuple, Optional
+import json
+
+# Hebrew character range
+HEBREW_PATTERN = re.compile(r'[\u0590-\u05FF]')
+ENGLISH_PATTERN = re.compile(r'[a-zA-Z]')
+EMOJI_PATTERN = re.compile(
+    "["
+    "\U0001F600-\U0001F64F"  # emoticons
+    "\U0001F300-\U0001F5FF"  # symbols & pictographs
+    "\U0001F680-\U0001F6FF"  # transport & map symbols
+    "\U0001F1E0-\U0001F1FF"  # flags
+    "\U00002702-\U000027B0"
+    "\U000024C2-\U0001F251"
+    "]+",
+    flags=re.UNICODE
+)
+
+# Common Hebrew slang and expressions
+HEBREW_SLANG = ['אחלה', 'סבבה', 'יאללה', 'וואלה', 'באסה', 'חבל', 'מגניב', 'אשכרה', 'חחחח', 'חחח', 'הההה', 'ממממ']
+HEBREW_ACRONYMS = ['בעזהש', 'אכא', 'לול', 'בטח', 'נלענד', 'תנצבה', 'זאת']
+
+
+class StyleFeatures:
+    """Features extracted from a user's messages."""
+
+    def __init__(self, user_id: int, user_name: str):
+        self.user_id = user_id
+        self.user_name = user_name
+        self.message_count = 0
+
+        # Length features
+        self.avg_message_length = 0.0
+        self.avg_word_length = 0.0
+        self.std_message_length = 0.0
+
+        # Character ratios
+        self.hebrew_ratio = 0.0
+        self.english_ratio = 0.0
+        self.digit_ratio = 0.0
+        self.emoji_ratio = 0.0
+
+        # Punctuation patterns
+        self.comma_rate = 0.0
+        self.period_rate = 0.0
+        self.question_rate = 0.0
+        self.exclamation_rate = 0.0
+        self.ellipsis_rate = 0.0  # ...
+
+        # Special patterns
+        self.caps_ratio = 0.0
+        self.repeated_chars_rate = 0.0  # כןןןןן
+        self.slang_rate = 0.0
+
+        # Time patterns (24 hours distribution)
+        self.hour_distribution = [0.0] * 24
+        self.weekend_ratio = 0.0
+
+        # Word patterns
+        self.unique_word_ratio = 0.0
+        self.short_message_ratio = 0.0  # < 5 words
+
+        # Top character bigrams (normalized)
+        self.char_bigrams: Dict[str, float] = {}
+
+        # Feature vector for similarity calculation
+        self.feature_vector: List[float] = []
+
+    def to_dict(self) -> dict:
+        return {
+            'user_id': self.user_id,
+            'user_name': self.user_name,
+            'message_count': self.message_count,
+            'avg_message_length': round(self.avg_message_length, 2),
+            'avg_word_length': round(self.avg_word_length, 2),
+            'hebrew_ratio': round(self.hebrew_ratio, 3),
+            'english_ratio': round(self.english_ratio, 3),
+            'emoji_ratio': round(self.emoji_ratio, 3),
+            'question_rate': round(self.question_rate, 3),
+            'exclamation_rate': round(self.exclamation_rate, 3),
+            'ellipsis_rate': round(self.ellipsis_rate, 3),
+            'repeated_chars_rate': round(self.repeated_chars_rate, 3),
+            'weekend_ratio': round(self.weekend_ratio, 3),
+            'unique_word_ratio': round(self.unique_word_ratio, 3),
+        }
+
+
+class StylometryAnalyzer:
+    """Analyzes writing styles to detect potential duplicate accounts."""
+
+    def __init__(self, db_path: str = 'telegram_data.db'):
+        self.db_path = db_path
+        self.user_features: Dict[int, StyleFeatures] = {}
+        self.similarity_threshold = 0.85  # Adjustable threshold
+
+    def get_active_users(self, min_messages: int = 300, days: int = 365) -> List[Tuple[int, str, int]]:
+        """Get users active in the last N days with at least min_messages."""
+        cutoff_date = datetime.now() - timedelta(days=days)
+        cutoff_str = cutoff_date.strftime('%Y-%m-%d')
+
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        query = """
+            SELECT u.id, u.name, COUNT(m.id) as msg_count
+            FROM users u
+            JOIN messages m ON u.id = m.sender_id
+            WHERE m.date >= ?
+            GROUP BY u.id
+            HAVING msg_count >= ?
+            ORDER BY msg_count DESC
+        """
+
+        cursor.execute(query, (cutoff_str, min_messages))
+        users = cursor.fetchall()
+        conn.close()
+
+        return users
+
+    def get_user_messages(self, user_id: int, days: int = 365) -> List[Tuple[str, str]]:
+        """Get messages for a user (text, date)."""
+        cutoff_date = datetime.now() - timedelta(days=days)
+        cutoff_str = cutoff_date.strftime('%Y-%m-%d')
+
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        query = """
+            SELECT text, date FROM messages
+            WHERE sender_id = ? AND date >= ? AND text IS NOT NULL AND text != ''
+            ORDER BY date
+        """
+
+        cursor.execute(query, (user_id, cutoff_str))
+        messages = cursor.fetchall()
+        conn.close()
+
+        return messages
+
+    def extract_features(self, user_id: int, user_name: str, messages: List[Tuple[str, str]]) -> StyleFeatures:
+        """Extract stylometric features from user messages."""
+        features = StyleFeatures(user_id, user_name)
+        features.message_count = len(messages)
+
+        if not messages:
+            return features
+
+        # Collect statistics
+        message_lengths = []
+        word_lengths = []
+        all_words = []
+        unique_words = set()
+        short_messages = 0
+
+        hebrew_chars = 0
+        english_chars = 0
+        digit_chars = 0
+        total_chars = 0
+        caps_chars = 0
+
+        commas = 0
+        periods = 0
+        questions = 0
+        exclamations = 0
+        ellipsis = 0
+
+        repeated_char_msgs = 0
+        slang_count = 0
+        emoji_count = 0
+
+        hour_counts = [0] * 24
+        weekend_msgs = 0
+
+        char_bigram_counter = Counter()
+
+        for text, date_str in messages:
+            if not text:
+                continue
+
+            # Message length
+            msg_len = len(text)
+            message_lengths.append(msg_len)
+            total_chars += msg_len
+
+            # Word analysis
+            words = text.split()
+            if len(words) < 5:
+                short_messages += 1
+            for word in words:
+                word_lengths.append(len(word))
+                all_words.append(word.lower())
+                unique_words.add(word.lower())
+
+            # Character analysis
+            hebrew_chars += len(HEBREW_PATTERN.findall(text))
+            english_chars += len(ENGLISH_PATTERN.findall(text))
+            digit_chars += sum(1 for c in text if c.isdigit())
+            caps_chars += sum(1 for c in text if c.isupper())
+
+            # Emoji analysis
+            emojis = EMOJI_PATTERN.findall(text)
+            emoji_count += len(emojis)
+
+            # Punctuation
+            commas += text.count(',')
+            periods += text.count('.')
+            questions += text.count('?')
+            exclamations += text.count('!')
+            ellipsis += text.count('...')
+
+            # Repeated characters pattern (like כןןןןן or אההההה)
+            if re.search(r'(.)\1{3,}', text):
+                repeated_char_msgs += 1
+
+            # Slang detection
+            text_lower = text.lower()
+            for slang in HEBREW_SLANG:
+                if slang in text:
+                    slang_count += 1
+                    break
+
+            # Time analysis
+            try:
+                if 'T' in date_str:
+                    dt = datetime.fromisoformat(date_str.replace('Z', '+00:00'))
+                else:
+                    dt = datetime.strptime(date_str[:19], '%Y-%m-%d %H:%M:%S')
+                hour_counts[dt.hour] += 1
+                if dt.weekday() >= 5:  # Saturday=5, Sunday=6
+                    weekend_msgs += 1
+            except:
+                pass
+
+            # Character bigrams
+            clean_text = re.sub(r'\s+', ' ', text.lower())
+            for i in range(len(clean_text) - 1):
+                bigram = clean_text[i:i+2]
+                if bigram.strip():
+                    char_bigram_counter[bigram] += 1
+
+        n_msgs = len(messages)
+
+        # Calculate averages
+        if message_lengths:
+            features.avg_message_length = sum(message_lengths) / len(message_lengths)
+            variance = sum((x - features.avg_message_length) ** 2 for x in message_lengths) / len(message_lengths)
+            features.std_message_length = math.sqrt(variance)
+
+        if word_lengths:
+            features.avg_word_length = sum(word_lengths) / len(word_lengths)
+
+        # Character ratios
+        if total_chars > 0:
+            features.hebrew_ratio = hebrew_chars / total_chars
+            features.english_ratio = english_chars / total_chars
+            features.digit_ratio = digit_chars / total_chars
+            features.emoji_ratio = emoji_count / total_chars
+            features.caps_ratio = caps_chars / max(1, english_chars)
+
+        # Punctuation rates (per message)
+        features.comma_rate = commas / n_msgs
+        features.period_rate = periods / n_msgs
+        features.question_rate = questions / n_msgs
+        features.exclamation_rate = exclamations / n_msgs
+        features.ellipsis_rate = ellipsis / n_msgs
+
+        # Special patterns
+        features.repeated_chars_rate = repeated_char_msgs / n_msgs
+        features.slang_rate = slang_count / n_msgs
+
+        # Time patterns
+        total_hour_msgs = sum(hour_counts)
+        if total_hour_msgs > 0:
+            features.hour_distribution = [h / total_hour_msgs for h in hour_counts]
+            features.weekend_ratio = weekend_msgs / n_msgs
+
+        # Word patterns
+        if all_words:
+            features.unique_word_ratio = len(unique_words) / len(all_words)
+        features.short_message_ratio = short_messages / n_msgs
+
+        # Top character bigrams (normalized)
+        total_bigrams = sum(char_bigram_counter.values())
+        if total_bigrams > 0:
+            top_bigrams = char_bigram_counter.most_common(50)
+            features.char_bigrams = {bg: count / total_bigrams for bg, count in top_bigrams}
+
+        # Build feature vector for similarity calculation
+        features.feature_vector = self._build_feature_vector(features)
+
+        return features
+
+    def _build_feature_vector(self, f: StyleFeatures) -> List[float]:
+        """Build normalized feature vector for similarity comparison."""
+        vector = [
+            f.avg_message_length / 100,  # Normalize to ~1
+            f.avg_word_length / 10,
+            f.hebrew_ratio,
+            f.english_ratio,
+            f.emoji_ratio * 10,  # Scale up small values
+            f.question_rate,
+            f.exclamation_rate,
+            f.ellipsis_rate * 5,
+            f.repeated_chars_rate * 10,
+            f.weekend_ratio,
+            f.unique_word_ratio,
+            f.short_message_ratio,
+            f.caps_ratio,
+            f.slang_rate,
+            f.comma_rate,
+            f.period_rate,
+        ]
+
+        # Add hour distribution (24 values)
+        vector.extend(f.hour_distribution)
+
+        return vector
+
+    def calculate_similarity(self, f1: StyleFeatures, f2: StyleFeatures) -> float:
+        """Calculate cosine similarity between two feature vectors."""
+        v1 = f1.feature_vector
+        v2 = f2.feature_vector
+
+        if not v1 or not v2 or len(v1) != len(v2):
+            return 0.0
+
+        # Cosine similarity
+        dot_product = sum(a * b for a, b in zip(v1, v2))
+        norm1 = math.sqrt(sum(a * a for a in v1))
+        norm2 = math.sqrt(sum(b * b for b in v2))
+
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+
+        cosine_sim = dot_product / (norm1 * norm2)
+
+        # Also compare character bigrams (Jaccard-like)
+        bigram_sim = self._compare_bigrams(f1.char_bigrams, f2.char_bigrams)
+
+        # Weighted combination
+        return 0.7 * cosine_sim + 0.3 * bigram_sim
+
+    def _compare_bigrams(self, bg1: Dict[str, float], bg2: Dict[str, float]) -> float:
+        """Compare character bigram distributions."""
+        if not bg1 or not bg2:
+            return 0.0
+
+        all_bigrams = set(bg1.keys()) | set(bg2.keys())
+        if not all_bigrams:
+            return 0.0
+
+        # Calculate similarity based on shared bigrams
+        intersection = 0.0
+        union = 0.0
+
+        for bg in all_bigrams:
+            v1 = bg1.get(bg, 0)
+            v2 = bg2.get(bg, 0)
+            intersection += min(v1, v2)
+            union += max(v1, v2)
+
+        if union == 0:
+            return 0.0
+
+        return intersection / union
+
+    def analyze_all_users(self, min_messages: int = 300, days: int = 365,
+                          progress_callback=None) -> Dict:
+        """Analyze all active users and find potential duplicates."""
+
+        # Get active users
+        users = self.get_active_users(min_messages, days)
+        total_users = len(users)
+
+        if progress_callback:
+            progress_callback('users_found', total_users)
+
+        # Extract features for each user
+        self.user_features = {}
+        for idx, (user_id, user_name, msg_count) in enumerate(users):
+            messages = self.get_user_messages(user_id, days)
+            features = self.extract_features(user_id, user_name or f"User_{user_id}", messages)
+            self.user_features[user_id] = features
+
+            if progress_callback:
+                progress_callback('user_processed', idx + 1, total_users, user_name)
+
+        # Find similar pairs
+        if progress_callback:
+            progress_callback('comparing', 0)
+
+        similar_pairs = []
+        user_ids = list(self.user_features.keys())
+        total_comparisons = len(user_ids) * (len(user_ids) - 1) // 2
+        comparison_count = 0
+
+        for i in range(len(user_ids)):
+            for j in range(i + 1, len(user_ids)):
+                uid1, uid2 = user_ids[i], user_ids[j]
+                f1, f2 = self.user_features[uid1], self.user_features[uid2]
+
+                similarity = self.calculate_similarity(f1, f2)
+
+                if similarity >= self.similarity_threshold:
+                    similar_pairs.append({
+                        'user1': f1.to_dict(),
+                        'user2': f2.to_dict(),
+                        'similarity': round(similarity * 100, 1),
+                        'details': self._get_similarity_details(f1, f2)
+                    })
+
+                comparison_count += 1
+                if progress_callback and comparison_count % 100 == 0:
+                    progress_callback('comparing', comparison_count, total_comparisons)
+
+        # Sort by similarity (highest first)
+        similar_pairs.sort(key=lambda x: x['similarity'], reverse=True)
+
+        return {
+            'total_users_analyzed': total_users,
+            'threshold': self.similarity_threshold * 100,
+            'potential_duplicates': len(similar_pairs),
+            'pairs': similar_pairs,
+            'all_users': [f.to_dict() for f in self.user_features.values()]
+        }
+
+    def _get_similarity_details(self, f1: StyleFeatures, f2: StyleFeatures) -> List[str]:
+        """Get human-readable similarity details."""
+        details = []
+
+        # Message length similarity
+        len_diff = abs(f1.avg_message_length - f2.avg_message_length)
+        if len_diff < 10:
+            details.append(f"אורך הודעה דומה ({f1.avg_message_length:.0f} vs {f2.avg_message_length:.0f})")
+
+        # Hebrew/English ratio
+        heb_diff = abs(f1.hebrew_ratio - f2.hebrew_ratio)
+        if heb_diff < 0.1:
+            details.append(f"יחס עברית/אנגלית דומה ({f1.hebrew_ratio:.0%} vs {f2.hebrew_ratio:.0%})")
+
+        # Emoji usage
+        emoji_diff = abs(f1.emoji_ratio - f2.emoji_ratio)
+        if emoji_diff < 0.01:
+            details.append("שימוש דומה באימוג'י")
+
+        # Question marks
+        q_diff = abs(f1.question_rate - f2.question_rate)
+        if q_diff < 0.1:
+            details.append("שימוש דומה בסימני שאלה")
+
+        # Weekend activity
+        weekend_diff = abs(f1.weekend_ratio - f2.weekend_ratio)
+        if weekend_diff < 0.1:
+            details.append("פעילות דומה בסופ\"ש")
+
+        # Repeated characters
+        if abs(f1.repeated_chars_rate - f2.repeated_chars_rate) < 0.05:
+            if f1.repeated_chars_rate > 0.1:
+                details.append("שניהם משתמשים בתווים חוזרים (כמו כןןןןן)")
+
+        # Time patterns
+        hour_sim = sum(min(h1, h2) for h1, h2 in zip(f1.hour_distribution, f2.hour_distribution))
+        if hour_sim > 0.7:
+            details.append("דפוס שעות פעילות דומה")
+
+        return details
+
+
+# Singleton instance
+_analyzer_instance: Optional[StylometryAnalyzer] = None
+
+def get_stylometry_analyzer() -> StylometryAnalyzer:
+    """Get or create the stylometry analyzer singleton."""
+    global _analyzer_instance
+    if _analyzer_instance is None:
+        _analyzer_instance = StylometryAnalyzer()
+    return _analyzer_instance

templates/maintenance.html

@@ -0,0 +1,750 @@
+<!DOCTYPE html>
+<html lang="he" dir="rtl">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>תחזוקה - Telegram Analytics</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+            background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+            min-height: 100vh;
+            color: #e4e4e4;
+        }
+
+        .header {
+            background: rgba(0, 0, 0, 0.3);
+            padding: 15px 30px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+        }
+
+        .header h1 {
+            font-size: 1.5rem;
+            color: #ff6b6b;
+        }
+
+        .nav-links {
+            display: flex;
+            gap: 20px;
+        }
+
+        .nav-links a {
+            color: #a0a0a0;
+            text-decoration: none;
+            padding: 8px 16px;
+            border-radius: 6px;
+            transition: all 0.3s ease;
+        }
+
+        .nav-links a:hover {
+            background: rgba(255, 255, 255, 0.1);
+            color: #fff;
+        }
+
+        .nav-links a.active {
+            background: rgba(255, 107, 107, 0.2);
+            color: #ff6b6b;
+        }
+
+        /* Password Modal */
+        .modal-overlay {
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: rgba(0, 0, 0, 0.8);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            z-index: 1000;
+        }
+
+        .modal-overlay.hidden {
+            display: none;
+        }
+
+        .modal {
+            background: #1e2a3a;
+            padding: 40px;
+            border-radius: 12px;
+            text-align: center;
+            border: 1px solid rgba(255, 107, 107, 0.3);
+            box-shadow: 0 10px 40px rgba(0, 0, 0, 0.5);
+        }
+
+        .modal h2 {
+            margin-bottom: 20px;
+            color: #ff6b6b;
+        }
+
+        .modal input {
+            padding: 12px 20px;
+            font-size: 1.2rem;
+            border: 2px solid #3a4a5a;
+            border-radius: 8px;
+            background: #0d1520;
+            color: #fff;
+            text-align: center;
+            letter-spacing: 4px;
+            width: 200px;
+        }
+
+        .modal input:focus {
+            outline: none;
+            border-color: #ff6b6b;
+        }
+
+        .modal button {
+            display: block;
+            margin: 20px auto 0;
+            padding: 12px 40px;
+            font-size: 1rem;
+            background: #ff6b6b;
+            color: #fff;
+            border: none;
+            border-radius: 8px;
+            cursor: pointer;
+            transition: background 0.3s ease;
+        }
+
+        .modal button:hover {
+            background: #ff5252;
+        }
+
+        .modal .error {
+            color: #ff6b6b;
+            margin-top: 15px;
+            font-size: 0.9rem;
+        }
+
+        /* Main Content */
+        .main-content {
+            padding: 30px;
+            max-width: 1400px;
+            margin: 0 auto;
+        }
+
+        .main-content.locked {
+            filter: blur(10px);
+            pointer-events: none;
+        }
+
+        .section {
+            background: rgba(255, 255, 255, 0.05);
+            border-radius: 12px;
+            padding: 25px;
+            margin-bottom: 25px;
+            border: 1px solid rgba(255, 255, 255, 0.1);
+        }
+
+        .section h2 {
+            color: #ff6b6b;
+            margin-bottom: 15px;
+            font-size: 1.3rem;
+        }
+
+        .section p {
+            color: #a0a0a0;
+            margin-bottom: 15px;
+            line-height: 1.6;
+        }
+
+        /* Analysis Controls */
+        .controls {
+            display: flex;
+            gap: 20px;
+            align-items: center;
+            flex-wrap: wrap;
+        }
+
+        .control-group {
+            display: flex;
+            flex-direction: column;
+            gap: 5px;
+        }
+
+        .control-group label {
+            font-size: 0.85rem;
+            color: #a0a0a0;
+        }
+
+        .control-group input, .control-group select {
+            padding: 10px 15px;
+            border: 1px solid #3a4a5a;
+            border-radius: 6px;
+            background: #0d1520;
+            color: #fff;
+            font-size: 1rem;
+        }
+
+        .btn-primary {
+            padding: 12px 30px;
+            background: linear-gradient(135deg, #ff6b6b, #ff5252);
+            color: #fff;
+            border: none;
+            border-radius: 8px;
+            font-size: 1rem;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            margin-top: 20px;
+        }
+
+        .btn-primary:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 5px 20px rgba(255, 107, 107, 0.3);
+        }
+
+        .btn-primary:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        /* Progress */
+        .progress-container {
+            margin-top: 20px;
+            display: none;
+        }
+
+        .progress-container.active {
+            display: block;
+        }
+
+        .progress-bar {
+            height: 8px;
+            background: #1a2535;
+            border-radius: 4px;
+            overflow: hidden;
+            margin-bottom: 10px;
+        }
+
+        .progress-fill {
+            height: 100%;
+            background: linear-gradient(90deg, #ff6b6b, #ff5252);
+            width: 0%;
+            transition: width 0.3s ease;
+        }
+
+        .progress-text {
+            color: #a0a0a0;
+            font-size: 0.9rem;
+        }
+
+        /* Results */
+        .results-container {
+            display: none;
+        }
+
+        .results-container.active {
+            display: block;
+        }
+
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-bottom: 25px;
+        }
+
+        .stat-card {
+            background: rgba(0, 0, 0, 0.3);
+            padding: 20px;
+            border-radius: 10px;
+            text-align: center;
+        }
+
+        .stat-card .value {
+            font-size: 2rem;
+            font-weight: bold;
+            color: #ff6b6b;
+        }
+
+        .stat-card .label {
+            color: #a0a0a0;
+            font-size: 0.9rem;
+            margin-top: 5px;
+        }
+
+        /* Pairs List */
+        .pairs-list {
+            display: flex;
+            flex-direction: column;
+            gap: 15px;
+        }
+
+        .pair-card {
+            background: rgba(0, 0, 0, 0.3);
+            border-radius: 10px;
+            padding: 20px;
+            border-right: 4px solid;
+        }
+
+        .pair-card.high {
+            border-color: #ff5252;
+        }
+
+        .pair-card.medium {
+            border-color: #ffa726;
+        }
+
+        .pair-card.low {
+            border-color: #66bb6a;
+        }
+
+        .pair-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 15px;
+        }
+
+        .pair-users {
+            display: flex;
+            gap: 20px;
+            align-items: center;
+        }
+
+        .user-info {
+            display: flex;
+            flex-direction: column;
+        }
+
+        .user-name {
+            font-weight: bold;
+            color: #fff;
+        }
+
+        .user-stats {
+            font-size: 0.85rem;
+            color: #a0a0a0;
+        }
+
+        .vs-badge {
+            background: #3a4a5a;
+            padding: 5px 12px;
+            border-radius: 15px;
+            font-size: 0.8rem;
+            color: #fff;
+        }
+
+        .similarity-badge {
+            font-size: 1.5rem;
+            font-weight: bold;
+        }
+
+        .pair-card.high .similarity-badge {
+            color: #ff5252;
+        }
+
+        .pair-card.medium .similarity-badge {
+            color: #ffa726;
+        }
+
+        .pair-card.low .similarity-badge {
+            color: #66bb6a;
+        }
+
+        .pair-details {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+        }
+
+        .detail-tag {
+            background: rgba(255, 107, 107, 0.1);
+            color: #ff6b6b;
+            padding: 5px 12px;
+            border-radius: 15px;
+            font-size: 0.85rem;
+        }
+
+        .no-duplicates {
+            text-align: center;
+            padding: 40px;
+            color: #66bb6a;
+        }
+
+        .no-duplicates svg {
+            width: 60px;
+            height: 60px;
+            margin-bottom: 15px;
+        }
+
+        /* Feature comparison table */
+        .comparison-toggle {
+            background: none;
+            border: 1px solid #3a4a5a;
+            color: #a0a0a0;
+            padding: 5px 15px;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 0.85rem;
+            margin-top: 10px;
+        }
+
+        .comparison-toggle:hover {
+            border-color: #ff6b6b;
+            color: #ff6b6b;
+        }
+
+        .comparison-table {
+            display: none;
+            margin-top: 15px;
+            width: 100%;
+            font-size: 0.85rem;
+        }
+
+        .comparison-table.active {
+            display: table;
+        }
+
+        .comparison-table th, .comparison-table td {
+            padding: 8px 12px;
+            text-align: right;
+            border-bottom: 1px solid #2a3a4a;
+        }
+
+        .comparison-table th {
+            color: #a0a0a0;
+            font-weight: normal;
+        }
+
+        .comparison-table td {
+            color: #fff;
+        }
+
+        /* Responsive */
+        @media (max-width: 768px) {
+            .header {
+                flex-direction: column;
+                gap: 15px;
+            }
+
+            .nav-links {
+                flex-wrap: wrap;
+                justify-content: center;
+            }
+
+            .controls {
+                flex-direction: column;
+                align-items: stretch;
+            }
+
+            .pair-users {
+                flex-direction: column;
+                text-align: center;
+            }
+        }
+    </style>
+</head>
+<body>
+    <!-- Password Modal -->
+    <div class="modal-overlay" id="password-modal">
+        <div class="modal">
+            <h2>אזור מוגן</h2>
+            <p style="color: #a0a0a0; margin-bottom: 20px;">הזן סיסמה כדי להיכנס לאזור התחזוקה</p>
+            <input type="password" id="password-input" placeholder="******" maxlength="10" autofocus>
+            <button onclick="checkPassword()">כניסה</button>
+            <p class="error hidden" id="password-error">סיסמה שגויה</p>
+        </div>
+    </div>
+
+    <header class="header">
+        <h1>תחזוקה</h1>
+        <nav class="nav-links">
+            <a href="/">סטטיסטיקות</a>
+            <a href="/chat">צ'אט</a>
+            <a href="/ai-search">AI Search</a>
+            <a href="/maintenance" class="active">תחזוקה</a>
+        </nav>
+    </header>
+
+    <main class="main-content locked" id="main-content">
+        <!-- Stylometry Analysis Section -->
+        <section class="section">
+            <h2>זיהוי משתמשים כפולים (Stylometry)</h2>
+            <p>
+                המערכת מנתחת את סגנון הכתיבה של כל משתמש כדי לזהות חשבונות שייתכן ושייכים לאותו אדם.
+                הניתוח כולל: אורך הודעות, שימוש באימוג'י, סימני פיסוק, יחס עברית/אנגלית, שעות פעילות ועוד.
+            </p>
+
+            <div class="controls">
+                <div class="control-group">
+                    <label>מינימום הודעות</label>
+                    <input type="number" id="min-messages" value="300" min="50" max="10000">
+                </div>
+                <div class="control-group">
+                    <label>תקופה (ימים)</label>
+                    <input type="number" id="days" value="365" min="30" max="730">
+                </div>
+                <div class="control-group">
+                    <label>סף דמיון (%)</label>
+                    <input type="number" id="threshold" value="85" min="50" max="99">
+                </div>
+            </div>
+
+            <button class="btn-primary" id="analyze-btn" onclick="startAnalysis()">
+                התחל ניתוח
+            </button>
+
+            <!-- Progress -->
+            <div class="progress-container" id="progress-container">
+                <div class="progress-bar">
+                    <div class="progress-fill" id="progress-fill"></div>
+                </div>
+                <p class="progress-text" id="progress-text">מתחיל ניתוח...</p>
+            </div>
+        </section>
+
+        <!-- Results Section -->
+        <section class="section results-container" id="results-container">
+            <h2>תוצאות הניתוח</h2>
+
+            <div class="stats-grid" id="stats-grid">
+                <!-- Filled by JS -->
+            </div>
+
+            <div id="pairs-container">
+                <!-- Filled by JS -->
+            </div>
+        </section>
+    </main>
+
+    <script>
+        const CORRECT_PASSWORD = '8716156';
+        let analysisResults = null;
+
+        // Check if already authenticated (session storage)
+        if (sessionStorage.getItem('maintenance_auth') === 'true') {
+            unlockContent();
+        }
+
+        // Enter key for password
+        document.getElementById('password-input').addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') checkPassword();
+        });
+
+        function checkPassword() {
+            const input = document.getElementById('password-input');
+            const error = document.getElementById('password-error');
+
+            if (input.value === CORRECT_PASSWORD) {
+                sessionStorage.setItem('maintenance_auth', 'true');
+                unlockContent();
+            } else {
+                error.classList.remove('hidden');
+                input.value = '';
+                input.focus();
+            }
+        }
+
+        function unlockContent() {
+            document.getElementById('password-modal').classList.add('hidden');
+            document.getElementById('main-content').classList.remove('locked');
+        }
+
+        async function startAnalysis() {
+            const minMessages = parseInt(document.getElementById('min-messages').value);
+            const days = parseInt(document.getElementById('days').value);
+            const threshold = parseInt(document.getElementById('threshold').value);
+
+            const btn = document.getElementById('analyze-btn');
+            const progress = document.getElementById('progress-container');
+            const progressFill = document.getElementById('progress-fill');
+            const progressText = document.getElementById('progress-text');
+
+            btn.disabled = true;
+            progress.classList.add('active');
+            progressFill.style.width = '0%';
+            progressText.textContent = 'מתחיל ניתוח...';
+
+            try {
+                // Start the analysis
+                const response = await fetch('/api/stylometry/analyze', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        min_messages: minMessages,
+                        days: days,
+                        threshold: threshold / 100
+                    })
+                });
+
+                if (!response.ok) {
+                    throw new Error('Analysis failed');
+                }
+
+                // Poll for progress
+                let completed = false;
+                while (!completed) {
+                    await new Promise(r => setTimeout(r, 500));
+
+                    const statusRes = await fetch('/api/stylometry/status');
+                    const status = await statusRes.json();
+
+                    if (status.status === 'completed') {
+                        completed = true;
+                        analysisResults = status.results;
+                        progressFill.style.width = '100%';
+                        progressText.textContent = 'הניתוח הושלם!';
+                    } else if (status.status === 'error') {
+                        throw new Error(status.error);
+                    } else if (status.status === 'running') {
+                        const pct = status.progress || 0;
+                        progressFill.style.width = pct + '%';
+                        progressText.textContent = status.message || 'מעבד...';
+                    }
+                }
+
+                // Show results
+                setTimeout(() => {
+                    progress.classList.remove('active');
+                    displayResults(analysisResults);
+                }, 500);
+
+            } catch (error) {
+                progressText.textContent = 'שגיאה: ' + error.message;
+                progressFill.style.width = '0%';
+            } finally {
+                btn.disabled = false;
+            }
+        }
+
+        function displayResults(data) {
+            const container = document.getElementById('results-container');
+            const statsGrid = document.getElementById('stats-grid');
+            const pairsContainer = document.getElementById('pairs-container');
+
+            container.classList.add('active');
+
+            // Stats
+            statsGrid.innerHTML = `
+                <div class="stat-card">
+                    <div class="value">${data.total_users_analyzed}</div>
+                    <div class="label">משתמשים נבדקו</div>
+                </div>
+                <div class="stat-card">
+                    <div class="value">${data.potential_duplicates}</div>
+                    <div class="label">חשודים ככפולים</div>
+                </div>
+                <div class="stat-card">
+                    <div class="value">${data.threshold}%</div>
+                    <div class="label">סף דמיון</div>
+                </div>
+            `;
+
+            // Pairs
+            if (data.pairs.length === 0) {
+                pairsContainer.innerHTML = `
+                    <div class="no-duplicates">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/>
+                            <polyline points="22 4 12 14.01 9 11.01"/>
+                        </svg>
+                        <h3>לא נמצאו משתמשים כפולים!</h3>
+                        <p>כל המשתמשים שנבדקו נראים ייחודיים</p>
+                    </div>
+                `;
+            } else {
+                let pairsHTML = '<div class="pairs-list">';
+
+                for (const pair of data.pairs) {
+                    const level = pair.similarity >= 95 ? 'high' : (pair.similarity >= 90 ? 'medium' : 'low');
+                    const pairId = `pair-${pair.user1.user_id}-${pair.user2.user_id}`;
+
+                    pairsHTML += `
+                        <div class="pair-card ${level}">
+                            <div class="pair-header">
+                                <div class="pair-users">
+                                    <div class="user-info">
+                                        <span class="user-name">${escapeHtml(pair.user1.user_name)}</span>
+                                        <span class="user-stats">${pair.user1.message_count} הודעות</span>
+                                    </div>
+                                    <span class="vs-badge">VS</span>
+                                    <div class="user-info">
+                                        <span class="user-name">${escapeHtml(pair.user2.user_name)}</span>
+                                        <span class="user-stats">${pair.user2.message_count} הודעות</span>
+                                    </div>
+                                </div>
+                                <div class="similarity-badge">${pair.similarity}%</div>
+                            </div>
+                            <div class="pair-details">
+                                ${pair.details.map(d => `<span class="detail-tag">${d}</span>`).join('')}
+                            </div>
+                            <button class="comparison-toggle" onclick="toggleComparison('${pairId}')">
+                                הצג השוואה מפורטת
+                            </button>
+                            <table class="comparison-table" id="${pairId}">
+                                <tr>
+                                    <th>מדד</th>
+                                    <th>${escapeHtml(pair.user1.user_name)}</th>
+                                    <th>${escapeHtml(pair.user2.user_name)}</th>
+                                </tr>
+                                <tr>
+                                    <td>אורך הודעה ממוצע</td>
+                                    <td>${pair.user1.avg_message_length}</td>
+                                    <td>${pair.user2.avg_message_length}</td>
+                                </tr>
+                                <tr>
+                                    <td>יחס עברית</td>
+                                    <td>${(pair.user1.hebrew_ratio * 100).toFixed(1)}%</td>
+                                    <td>${(pair.user2.hebrew_ratio * 100).toFixed(1)}%</td>
+                                </tr>
+                                <tr>
+                                    <td>יחס אנגלית</td>
+                                    <td>${(pair.user1.english_ratio * 100).toFixed(1)}%</td>
+                                    <td>${(pair.user2.english_ratio * 100).toFixed(1)}%</td>
+                                </tr>
+                                <tr>
+                                    <td>שימוש באימוג'י</td>
+                                    <td>${(pair.user1.emoji_ratio * 100).toFixed(2)}%</td>
+                                    <td>${(pair.user2.emoji_ratio * 100).toFixed(2)}%</td>
+                                </tr>
+                                <tr>
+                                    <td>סימני שאלה (לכל הודעה)</td>
+                                    <td>${pair.user1.question_rate.toFixed(2)}</td>
+                                    <td>${pair.user2.question_rate.toFixed(2)}</td>
+                                </tr>
+                                <tr>
+                                    <td>סימני קריאה (לכל הודעה)</td>
+                                    <td>${pair.user1.exclamation_rate.toFixed(2)}</td>
+                                    <td>${pair.user2.exclamation_rate.toFixed(2)}</td>
+                                </tr>
+                                <tr>
+                                    <td>פעילות בסופ"ש</td>
+                                    <td>${(pair.user1.weekend_ratio * 100).toFixed(1)}%</td>
+                                    <td>${(pair.user2.weekend_ratio * 100).toFixed(1)}%</td>
+                                </tr>
+                            </table>
+                        </div>
+                    `;
+                }
+
+                pairsHTML += '</div>';
+                pairsContainer.innerHTML = pairsHTML;
+            }
+        }
+
+        function toggleComparison(id) {
+            const table = document.getElementById(id);
+            table.classList.toggle('active');
+        }
+
+        function escapeHtml(text) {
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }
+    </script>
+</body>
+</html>