Automate Community Management 🚀

# Unified user identity across platforms
class UnifiedUser:
    def __init__(self, user_id: str):
        self.user_id = user_id
        self.identities = {}
        
    def add_platform_identity(self, platform: str, platform_user_id: str):
        """Link platform-specific IDs to unified user"""
        self.identities[platform] = platform_user_id
        
        # Store in Redis
        redis.hset(f"user:{self.user_id}", platform, platform_user_id)
        redis.hset(f"platform:{platform}:{platform_user_id}", "unified_id", self.user_id)
    
    def get_cross_platform_history(self) -> dict:
        """Get moderation history across all platforms"""
        history = {}
        for platform, platform_id in self.identities.items():
            history[platform] = redis.lrange(f"mod_history:{platform}:{platform_id}", 0, -1)
        return history

# Usage: Moderate based on cross-platform behavior
user = UnifiedUser("unified_user_123")
user.add_platform_identity("discord", "discord_456")
user.add_platform_identity("slack", "slack_789")

# When moderating, check ALL platforms
cross_platform_history = user.get_cross_platform_history()
if len(cross_platform_history['discord']) + len(cross_platform_history['slack']) > 5:
    # User has 5+ violations across platforms = stricter action
    action = "ban"
else:
    action = "warn"

// Timezone-aware moderation sensitivity
import { DateTime } from 'luxon';

interface UserTimezone {
  userId: string;
  timezone: string;
  localHour: number;
}

async function adjustModerationForTimezone(
  toxicityScore: number,
  userId: string
): Promise<number> {
  // Get user's timezone (inferred from past activity or profile)
  const userTz = await redis.get(`user:${userId}:timezone`) || 'UTC';
  const userLocalTime = DateTime.now().setZone(userTz);
  const localHour = userLocalTime.hour;

  // Late night (11pm-5am local) = higher tolerance
  // People are tired, less filtered
  if (localHour >= 23 || localHour <= 5) {
    toxicityScore *= 0.8; // 20% more lenient
  }

  // Work hours (9am-5pm local) = stricter
  // Professional context expected
  if (localHour >= 9 && localHour <= 17) {
    toxicityScore *= 1.2; // 20% stricter
  }

  return toxicityScore;
}

// Usage in moderation pipeline
let toxicityScore = 0.75;
toxicityScore = await adjustModerationForTimezone(toxicityScore, userId);

if (toxicityScore > 0.8) {
  // Take action
}

# Whitelist technical jargon to avoid false positives
TECH_JARGON_WHITELIST = [
    r'kill (the )?process',
    r'master[/-]slave',
    r'execute (the )?script',
    r'parent[/-]child',
    r'blacklist|whitelist',
    r'abort',
    r'terminate',
    r'force (push|quit)',
    r'nuke',
    r'blow away',
]

def is_technical_context(message: str) -> bool:
    """Check if message contains technical jargon"""
    import re
    for pattern in TECH_JARGON_WHITELIST:
        if re.search(pattern, message, re.IGNORECASE):
            return True
    return False

def adjust_for_technical_context(toxicity_score: float, message: str) -> float:
    """Lower toxicity score if technical jargon detected"""
    if is_technical_context(message):
        # Check if message also contains code blocks
        if '```' in message or '`' in message:
            return toxicity_score * 0.5  # 50% less sensitive
    return toxicity_score

# Usage
raw_score = 0.82  # "kill the process" flagged as toxic
adjusted_score = adjust_for_technical_context(raw_score, message_text)
print(f"Adjusted: {adjusted_score}")  # 0.41 - no longer flagged

// Detect ambassador burnout patterns
interface AmbassadorMetrics {
  userId: string;
  weeklyMessages: number[];
  weeklyHelpfulResponses: number[];
  weeklySentiment: number[];
}

async function detectBurnout(userId: string): Promise<boolean> {
  // Get last 8 weeks of activity
  const metrics = await getAmbassadorMetrics(userId, 8);

  // Burnout indicators:
  // 1. Declining message volume (>30% drop)
  const recentAvg = average(metrics.weeklyMessages.slice(-4));
  const earlierAvg = average(metrics.weeklyMessages.slice(0, 4));
  const volumeDecline = (earlierAvg - recentAvg) / earlierAvg;

  // 2. Declining helpfulness (>40% drop in helpful responses)
  const recentHelpful = average(metrics.weeklyHelpfulResponses.slice(-4));
  const earlierHelpful = average(metrics.weeklyHelpfulResponses.slice(0, 4));
  const helpfulnessDecline = (earlierHelpful - recentHelpful) / earlierHelpful;

  // 3. Declining sentiment (more negative)
  const recentSentiment = average(metrics.weeklySentiment.slice(-4));
  const earlierSentiment = average(metrics.weeklySentiment.slice(0, 4));
  const sentimentDecline = earlierSentiment - recentSentiment;

  // Burnout if 2+ indicators triggered
  const indicators = [
    volumeDecline > 0.3,
    helpfulnessDecline > 0.4,
    sentimentDecline > 0.2,
  ];

  const burnoutScore = indicators.filter(Boolean).length;

  if (burnoutScore >= 2) {
    // Alert community manager
    await sendBurnoutAlert(userId, {
      volumeDecline,
      helpfulnessDecline,
      sentimentDecline,
    });
    return true;
  }

  return false;
}

// Run weekly check on all ambassadors
setInterval(async () => {
  const ambassadors = await getAmbassadorList();
  for (const ambassador of ambassadors) {
    await detectBurnout(ambassador.userId);
  }
}, 7 * 24 * 60 * 60 * 1000); // Weekly

# Detect and amplify viral threads
import asyncio
from datetime import datetime, timedelta

class ViralThreadDetector:
    def __init__(self):
        self.engagement_threshold = {
            'replies_per_hour': 10,
            'reactions_per_hour': 30,
            'unique_participants': 5,
            'sentiment_score': 0.6  # Positive sentiment
        }
    
    async def analyze_thread(self, thread_id: str, platform: str) -> dict:
        """Analyze thread engagement metrics"""
        
        # Get thread messages from last 2 hours
        messages = await get_thread_messages(thread_id, hours=2)
        
        metrics = {
            'replies_per_hour': len(messages) / 2,
            'reactions_per_hour': sum(m['reaction_count'] for m in messages) / 2,
            'unique_participants': len(set(m['user_id'] for m in messages)),
            'sentiment_score': await calculate_sentiment(messages)
        }
        
        return metrics
    
    async def should_amplify(self, thread_id: str, platform: str) -> bool:
        """Check if thread meets viral criteria"""
        metrics = await self.analyze_thread(thread_id, platform)
        
        # Check all thresholds
        viral = all([
            metrics['replies_per_hour'] >= self.engagement_threshold['replies_per_hour'],
            metrics['reactions_per_hour'] >= self.engagement_threshold['reactions_per_hour'],
            metrics['unique_participants'] >= self.engagement_threshold['unique_participants'],
            metrics['sentiment_score'] >= self.engagement_threshold['sentiment_score']
        ])
        
        return viral
    
    async def amplify_thread(self, thread_id: str, platform: str):
        """Amplify viral thread across channels"""
        
        if platform == 'discord':
            # Pin the thread
            await pin_discord_message(thread_id)
            
            # Cross-post to announcements
            await cross_post_to_channel(thread_id, 'announcements')
            
        elif platform == 'slack':
            # Add to channel topic
            await update_slack_topic(thread_id)
            
            # Send to #highlights channel
            await cross_post_to_channel(thread_id, 'highlights')
        
        # Notify community manager
        await notify_manager(f"Viral thread detected: {thread_id}")
        
        # Log amplification
        redis.sadd('amplified_threads', thread_id)

# Run every 30 minutes
detector = ViralThreadDetector()

async def check_viral_threads():
    while True:
        # Get active threads from last 2 hours
        active_threads = await get_active_threads(hours=2)
        
        for thread in active_threads:
            # Skip if already amplified
            if redis.sismember('amplified_threads', thread['id']):
                continue
            
            if await detector.should_amplify(thread['id'], thread['platform']):
                await detector.amplify_thread(thread['id'], thread['platform'])
        
        await asyncio.sleep(30 * 60)  # 30 minutes

asyncio.create_task(check_viral_threads())