Automate Crisis Response 🚀

async function handleApprovalTimeout(approvalId: string) {
  const approval = await getApproval(approvalId);
  const elapsed = Date.now() - approval.created_at;
  
  // If 30 minutes passed and CEO hasn't approved
  if (elapsed > 30 * 60 * 1000 && !approval.ceo_approved) {
    // Escalate to COO
    await sendUrgentApprovalRequest({
      to: 'coo@company.com',
      subject: 'URGENT: Crisis Approval Escalation',
      body: `CEO hasn't responded to crisis approval in 30 mins.\n\nCrisis: ${approval.description}\n\nApprove now: ${approval.approve_link}`,
      priority: 'urgent'
    });
    
    // Also call COO's cell phone
    await makePhoneCall({
      to: process.env.COO_CELL_PHONE!,
      message: 'Urgent crisis approval needed. Check email immediately.'
    });
    
    // Log escalation
    await logEscalation(approvalId, 'CEO_timeout', 'escalated_to_COO');
  }
  
  // If 1 hour passed and still no approval, auto-publish with disclaimer
  if (elapsed > 60 * 60 * 1000 && !approval.any_approved) {
    await publishWithDisclaimer(approval.messages, {
      note: 'Published without full executive approval due to time-critical nature'
    });
    
    // Alert board
    await alertBoard(approvalId, 'auto_published_after_timeout');
  }
}

from ratelimit import limits, sleep_and_retry
import time

class SocialMediaPublisher:
    def __init__(self):
        self.twitter_calls = 0
        self.linkedin_calls = 0
        self.last_twitter_reset = time.time()
        self.last_linkedin_reset = time.time()
    
    @sleep_and_retry
    @limits(calls=300, period=10800)  # 300 calls per 3 hours
    def publish_to_twitter(self, message: str):
        """Rate-limited Twitter publishing"""
        # Actual Twitter API call
        twitter_client.tweet(message)
        self.twitter_calls += 1
        
        # Log rate limit usage
        print(f"Twitter: {self.twitter_calls}/300 calls used")
    
    @sleep_and_retry
    @limits(calls=100, period=86400)  # 100 calls per day
    def publish_to_linkedin(self, message: str):
        """Rate-limited LinkedIn publishing"""
        linkedin_client.create_share(message)
        self.linkedin_calls += 1
        
        print(f"LinkedIn: {self.linkedin_calls}/100 calls used")
    
    async def publish_with_retry(self, message: str, platform: str):
        """Retry with exponential backoff if rate limited"""
        max_retries = 3
        for attempt in range(max_retries):
            try:
                if platform == 'twitter':
                    self.publish_to_twitter(message)
                elif platform == 'linkedin':
                    self.publish_to_linkedin(message)
                return True
            except RateLimitException:
                if attempt < max_retries - 1:
                    wait_time = 2 ** attempt * 60  # 1min, 2min, 4min
                    print(f"Rate limited. Waiting {wait_time}s...")
                    await asyncio.sleep(wait_time)
                else:
                    # Queue for later
                    await self.queue_for_later(message, platform)
                    return False

import { TwitterApi } from 'twitter-api-v2';
import Anthropic from '@anthropic-ai/sdk';

class CrisisSentimentMonitor {
  private twitter: TwitterApi;
  private anthropic: Anthropic;
  private sentimentHistory: Array<{ timestamp: Date; score: number }> = [];

  async monitorHashtag(hashtag: string, crisisId: string) {
    // Start streaming mentions
    const stream = await this.twitter.v2.searchStream({
      'tweet.fields': ['created_at', 'text', 'public_metrics'],
      expansions: ['author_id'],
    });

    stream.on('data', async (tweet) => {
      if (tweet.data.text.includes(hashtag)) {
        // Analyze sentiment
        const sentiment = await this.analyzeSentiment(tweet.data.text);
        
        this.sentimentHistory.push({
          timestamp: new Date(),
          score: sentiment.score,
        });

        // Check if sentiment is deteriorating
        if (this.isGettingWorse()) {
          await this.alertLeadership({
            crisis_id: crisisId,
            message: 'Sentiment declining - consider revised messaging',
            current_score: sentiment.score,
            trend: 'negative',
            sample_tweets: await this.getMostNegativeTweets(5),
          });
        }
      }
    });
  }

  private async analyzeSentiment(text: string) {
    const response = await this.anthropic.messages.create({
      model: 'claude-3-5-sonnet-20241022',
      max_tokens: 256,
      messages: [
        {
          role: 'user',
          content: `Analyze sentiment of this tweet about our crisis response. Score from -1 (very negative) to 1 (very positive). Output JSON: {score: number, reasoning: string}\n\nTweet: ${text}`,
        },
      ],
    });

    const content = response.content[0];
    if (content.type !== 'text') throw new Error('Invalid response');
    return JSON.parse(content.text);
  }

  private isGettingWorse(): boolean {
    if (this.sentimentHistory.length < 10) return false;

    // Compare last 5 tweets to previous 5
    const recent = this.sentimentHistory.slice(-5);
    const previous = this.sentimentHistory.slice(-10, -5);

    const recentAvg = recent.reduce((sum, s) => sum + s.score, 0) / 5;
    const previousAvg = previous.reduce((sum, s) => sum + s.score, 0) / 5;

    // Alert if sentiment dropped by more than 0.2
    return recentAvg < previousAvg - 0.2;
  }

  private async getMostNegativeTweets(count: number) {
    // Return most negative tweets for context
    return this.sentimentHistory
      .sort((a, b) => a.score - b.score)
      .slice(0, count);
  }

  private async alertLeadership(alert: any) {
    // Send to Slack crisis channel
    await fetch(process.env.SLACK_WEBHOOK_URL!, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        text: `⚠️ Sentiment Alert: ${alert.message}`,
        attachments: [
          {
            color: 'danger',
            fields: [
              { title: 'Current Score', value: alert.current_score.toFixed(2), short: true },
              { title: 'Trend', value: alert.trend, short: true },
            ],
          },
        ],
      }),
    });
  }
}

from typing import List, Dict
import re

class ComplianceChecker:
    def __init__(self, industry: str):
        self.industry = industry
        self.violations = []
    
    async def check_compliance(self, message: str, severity: str) -> Dict:
        """Run all compliance checks based on industry"""
        self.violations = []
        
        if self.industry == 'public_company':
            await self.check_sec_compliance(message, severity)
        elif self.industry == 'healthcare':
            await self.check_hipaa_compliance(message)
        elif self.industry == 'finance':
            await self.check_finra_compliance(message)
        
        # Universal checks
        await self.check_for_promises(message)
        await self.check_for_speculation(message)
        
        return {
            'compliant': len(self.violations) == 0,
            'violations': self.violations,
            'requires_legal_review': len(self.violations) > 0 or severity == 'critical'
        }
    
    async def check_sec_compliance(self, message: str, severity: str):
        """SEC disclosure requirements for public companies"""
        # Material events must be disclosed via 8-K filing
        material_keywords = ['breach', 'lawsuit', 'investigation', 'fraud', 'bankruptcy']
        
        if any(keyword in message.lower() for keyword in material_keywords):
            self.violations.append({
                'type': 'SEC_8K_REQUIRED',
                'message': 'Material event requires 8-K filing before public disclosure',
                'severity': 'critical',
                'action': 'File 8-K with SEC before publishing'
            })
        
        # Forward-looking statements need safe harbor language
        future_keywords = ['will', 'expect', 'anticipate', 'plan', 'forecast']
        if any(keyword in message.lower() for keyword in future_keywords):
            if 'forward-looking' not in message.lower():
                self.violations.append({
                    'type': 'SAFE_HARBOR_MISSING',
                    'message': 'Forward-looking statements need safe harbor disclaimer',
                    'severity': 'medium',
                    'action': 'Add: "These are forward-looking statements subject to risks..."'
                })
    
    async def check_hipaa_compliance(self, message: str):
        """HIPAA compliance for healthcare"""
        # Check for PHI (Protected Health Information)
        phi_patterns = [
            r'\b\d{3}-\d{2}-\d{4}\b',  # SSN
            r'\b[A-Z][a-z]+ [A-Z][a-z]+\b',  # Names
            r'\b\d{1,5}\s\w+\s(Street|St|Avenue|Ave|Road|Rd)\b',  # Addresses
        ]
        
        for pattern in phi_patterns:
            if re.search(pattern, message):
                self.violations.append({
                    'type': 'PHI_DETECTED',
                    'message': 'Potential PHI found in message',
                    'severity': 'critical',
                    'action': 'Remove or redact PHI before publishing'
                })
    
    async def check_for_promises(self, message: str):
        """Don't make promises you can't keep"""
        promise_phrases = [
            'guarantee', 'promise', 'will never happen again',
            'completely resolved', 'fully secure'
        ]
        
        for phrase in promise_phrases:
            if phrase in message.lower():
                self.violations.append({
                    'type': 'OVERPROMISE',
                    'message': f'Phrase "{phrase}" makes absolute promise',
                    'severity': 'medium',
                    'action': 'Use "working to" or "committed to" instead'
                })
    
    async def check_for_speculation(self, message: str):
        """Avoid speculation about causes or responsibility"""
        speculation_phrases = [
            'we believe the cause was',
            'likely caused by',
            'probably due to'
        ]
        
        for phrase in speculation_phrases:
            if phrase in message.lower():
                self.violations.append({
                    'type': 'SPECULATION',
                    'message': 'Message contains speculation about cause',
                    'severity': 'high',
                    'action': 'Wait for investigation results before stating cause'
                })

# Usage
checker = ComplianceChecker(industry='public_company')
result = await checker.check_compliance(message, severity='high')

if not result['compliant']:
    # Block publication and route to legal
    await route_to_legal(result['violations'])
else:
    # Proceed with approval workflow
    await request_approvals(message)

import Anthropic from '@anthropic-ai/sdk';

interface TranslationRequest {
  text: string;
  target_languages: string[];
  requires_review: boolean;
}

class GlobalCrisisPublisher {
  private anthropic: Anthropic;
  private native_reviewers: Map<string, string[]>;

  constructor() {
    this.anthropic = new Anthropic({
      apiKey: process.env.ANTHROPIC_API_KEY!,
    });
    
    // Map of language -> reviewer emails
    this.native_reviewers = new Map([
      ['es', ['maria@company.com', 'carlos@company.com']],
      ['fr', ['pierre@company.com']],
      ['de', ['hans@company.com']],
      ['ja', ['yuki@company.com']],
      ['zh', ['wei@company.com']],
    ]);
  }

  async translateAndPublish(request: TranslationRequest) {
    const translations = new Map<string, string>();

    // Translate to all target languages
    for (const lang of request.target_languages) {
      const translated = await this.translateMessage(request.text, lang);
      translations.set(lang, translated);
    }

    if (request.requires_review) {
      // Send to native speakers for review
      const reviewIds = await this.requestNativeReview(translations);
      
      // Wait for reviews (with timeout)
      const approved = await this.waitForReviews(reviewIds, 3600000); // 1 hour
      
      if (!approved) {
        // Publish English only if reviews timeout
        await this.publishEnglishOnly(request.text);
        return { status: 'partial', published_languages: ['en'] };
      }
    }

    // Publish all translations
    await this.publishAllLanguages(translations);
    return { status: 'complete', published_languages: Array.from(translations.keys()) };
  }

  private async translateMessage(text: string, targetLang: string): Promise<string> {
    const langNames: Record<string, string> = {
      es: 'Spanish',
      fr: 'French',
      de: 'German',
      ja: 'Japanese',
      zh: 'Chinese',
    };

    const prompt = `Translate this crisis communication message to ${langNames[targetLang]}. Maintain the tone (urgent but professional) and ensure cultural appropriateness.\n\nOriginal message:\n${text}\n\nTranslated message:`;

    const response = await this.anthropic.messages.create({
      model: 'claude-3-5-sonnet-20241022',
      max_tokens: 1024,
      messages: [{ role: 'user', content: prompt }],
    });

    const content = response.content[0];
    if (content.type !== 'text') throw new Error('Invalid response');
    return content.text;
  }

  private async requestNativeReview(
    translations: Map<string, string>
  ): Promise<string[]> {
    const reviewIds: string[] = [];

    for (const [lang, text] of translations.entries()) {
      const reviewers = this.native_reviewers.get(lang) || [];
      
      for (const reviewer of reviewers) {
        const reviewId = `review_${Date.now()}_${lang}_${reviewer}`;
        
        await this.sendReviewRequest({
          reviewId,
          reviewer,
          language: lang,
          text,
          deadline: new Date(Date.now() + 3600000), // 1 hour
        });
        
        reviewIds.push(reviewId);
      }
    }

    return reviewIds;
  }

  private async sendReviewRequest(request: any) {
    // Send email to native speaker
    const emailBody = `URGENT: Crisis Message Translation Review

Language: ${request.language}
Deadline: ${request.deadline.toISOString()}

Translated message:
${request.text}

Approve: https://crisis.company.com/review/${request.reviewId}/approve
Request changes: https://crisis.company.com/review/${request.reviewId}/edit

This is time-sensitive. Please review within 1 hour.`;

    // Send via email API
    await sendEmail({
      to: request.reviewer,
      subject: `URGENT: ${request.language.toUpperCase()} Translation Review`,
      body: emailBody,
      priority: 'urgent',
    });
  }

  private async waitForReviews(
    reviewIds: string[],
    timeout: number
  ): Promise<boolean> {
    const startTime = Date.now();
    
    while (Date.now() - startTime < timeout) {
      const allApproved = await this.checkAllReviewsApproved(reviewIds);
      if (allApproved) return true;
      
      await new Promise((resolve) => setTimeout(resolve, 10000)); // Check every 10s
    }
    
    return false; // Timeout
  }

  private async checkAllReviewsApproved(reviewIds: string[]): Promise<boolean> {
    // Check database for review status
    // Implementation depends on your DB
    return false;
  }

  private async publishEnglishOnly(text: string) {
    // Fallback: publish English version only
    await this.publishToAllChannels({ en: text });
  }

  private async publishAllLanguages(translations: Map<string, string>) {
    // Publish to regional social media accounts
    const promises = [];
    
    for (const [lang, text] of translations.entries()) {
      promises.push(this.publishToRegionalChannels(lang, text));
    }
    
    await Promise.all(promises);
  }

  private async publishToRegionalChannels(lang: string, text: string) {
    // Publish to language-specific Twitter/LinkedIn accounts
    // e.g., @CompanyES for Spanish, @CompanyFR for French
  }

  private async publishToAllChannels(translations: Record<string, string>) {
    // Implementation
  }
}

// Usage
const publisher = new GlobalCrisisPublisher();
await publisher.translateAndPublish({
  text: 'We experienced a security incident...',
  target_languages: ['es', 'fr', 'de', 'ja'],
  requires_review: true,
});